diff --git a/.changeset/ai-prompt-management.md b/.changeset/ai-prompt-management.md
new file mode 100644
index 00000000000..d3250bebda7
--- /dev/null
+++ b/.changeset/ai-prompt-management.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+Define and manage AI prompts with `prompts.define()`. Create typesafe prompt templates with variables, resolve them at runtime, and manage versions and overrides from the dashboard without redeploying.
diff --git a/.changeset/chilly-tips-explode.md b/.changeset/chilly-tips-explode.md
new file mode 100644
index 00000000000..7a5235904a4
--- /dev/null
+++ b/.changeset/chilly-tips-explode.md
@@ -0,0 +1,5 @@
+---
+"trigger.dev": patch
+---
+
+Add platform notifications support to the CLI. The `trigger dev` and `trigger login` commands now fetch and display platform notifications (info, warn, error, success) from the server. Includes discovery-based filtering to conditionally show notifications based on project file patterns, color markup rendering for styled terminal output, and a non-blocking display flow with a spinner fallback for slow fetches. Use `--skip-platform-notifications` flag with `trigger dev` to disable the notification check.
diff --git a/.changeset/fix-dev-build-dir-leak.md b/.changeset/fix-dev-build-dir-leak.md
new file mode 100644
index 00000000000..a1e6219c8bb
--- /dev/null
+++ b/.changeset/fix-dev-build-dir-leak.md
@@ -0,0 +1,5 @@
+---
+"trigger.dev": patch
+---
+
+Fix dev CLI leaking build directories on rebuild, causing disk space accumulation. Deprecated workers are now pruned (capped at 2 retained) when no active runs reference them. The watchdog process also cleans up `.trigger/tmp/` when the dev CLI is killed ungracefully (e.g. SIGKILL from pnpm).
diff --git a/.changeset/fix-list-deploys-nullable.md b/.changeset/fix-list-deploys-nullable.md
new file mode 100644
index 00000000000..d9d5e82116a
--- /dev/null
+++ b/.changeset/fix-list-deploys-nullable.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+Fix `list_deploys` MCP tool failing when deployments have null `runtime` or `runtimeVersion` fields.
diff --git a/.changeset/fix-local-build-load.md b/.changeset/fix-local-build-load.md
new file mode 100644
index 00000000000..13f91da9d6a
--- /dev/null
+++ b/.changeset/fix-local-build-load.md
@@ -0,0 +1,5 @@
+---
+"trigger.dev": patch
+---
+
+Fix `--load` flag being silently ignored on local/self-hosted builds.
diff --git a/.changeset/fluffy-crews-rhyme.md b/.changeset/fluffy-crews-rhyme.md
deleted file mode 100644
index ba2a2e8bf70..00000000000
--- a/.changeset/fluffy-crews-rhyme.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@trigger.dev/sdk": patch
----
-
-feat: Support for new batch trigger system
diff --git a/.changeset/llm-metadata-run-tags.md b/.changeset/llm-metadata-run-tags.md
new file mode 100644
index 00000000000..85f04c363b8
--- /dev/null
+++ b/.changeset/llm-metadata-run-tags.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+Propagate run tags to span attributes so they can be extracted server-side for LLM cost attribution metadata.
diff --git a/.changeset/mcp-get-span-details.md b/.changeset/mcp-get-span-details.md
new file mode 100644
index 00000000000..e69b7979b07
--- /dev/null
+++ b/.changeset/mcp-get-span-details.md
@@ -0,0 +1,11 @@
+---
+"@trigger.dev/core": patch
+"trigger.dev": patch
+---
+
+Add `get_span_details` MCP tool for inspecting individual spans within a run trace.
+
+- New `get_span_details` tool returns full span attributes, timing, events, and AI enrichment (model, tokens, cost, speed)
+- Span IDs now shown in `get_run_details` trace output for easy discovery
+- New API endpoint `GET /api/v1/runs/:runId/spans/:spanId`
+- New `retrieveSpan()` method on the API client
diff --git a/.changeset/mcp-query-tools.md b/.changeset/mcp-query-tools.md
new file mode 100644
index 00000000000..23e09c1afec
--- /dev/null
+++ b/.changeset/mcp-query-tools.md
@@ -0,0 +1,42 @@
+---
+"@trigger.dev/core": patch
+"trigger.dev": patch
+---
+
+MCP server improvements: new tools, bug fixes, and new flags.
+
+**New tools:**
+- `get_query_schema` — discover available TRQL tables and columns
+- `query` — execute TRQL queries against your data
+- `list_dashboards` — list built-in dashboards and their widgets
+- `run_dashboard_query` — execute a single dashboard widget query
+- `whoami` — show current profile, user, and API URL
+- `list_profiles` — list all configured CLI profiles
+- `switch_profile` — switch active profile for the MCP session
+- `start_dev_server` — start `trigger dev` in the background and stream output
+- `stop_dev_server` — stop the running dev server
+- `dev_server_status` — check dev server status and view recent logs
+
+**New API endpoints:**
+- `GET /api/v1/query/schema` — query table schema discovery
+- `GET /api/v1/query/dashboards` — list built-in dashboards
+
+**New features:**
+- `--readonly` flag hides write tools (`deploy`, `trigger_task`, `cancel_run`) so the AI cannot make changes
+- `read:query` JWT scope for query endpoint authorization
+- `get_run_details` trace output is now paginated with cursor support
+- MCP tool annotations (`readOnlyHint`, `destructiveHint`) for all tools
+
+**Bug fixes:**
+- Fixed `search_docs` tool failing due to renamed upstream Mintlify tool (`SearchTriggerDev` → `search_trigger_dev`)
+- Fixed `list_deploys` failing when deployments have null `runtime`/`runtimeVersion` fields (#3139)
+- Fixed `list_preview_branches` crashing due to incorrect response shape access
+- Fixed `metrics` table column documented as `value` instead of `metric_value` in query docs
+- Fixed dev CLI leaking build directories on rebuild — deprecated workers now clean up their build dirs when their last run completes
+
+**Context optimizations:**
+- `get_query_schema` now requires a table name and returns only one table's schema (was returning all tables)
+- `get_current_worker` no longer inlines payload schemas; use new `get_task_schema` tool instead
+- Query results formatted as text tables instead of JSON (~50% fewer tokens)
+- `cancel_run`, `list_deploys`, `list_preview_branches` formatted as text instead of raw JSON
+- Schema and dashboard API responses cached to avoid redundant fetches
diff --git a/.changeset/ninety-cows-lay.md b/.changeset/ninety-cows-lay.md
deleted file mode 100644
index 67e588ec949..00000000000
--- a/.changeset/ninety-cows-lay.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@trigger.dev/sdk": patch
----
-
-feat(sdk): Support debouncing runs when triggering with new debounce options
diff --git a/.changeset/packet-v2-packets-api.md b/.changeset/packet-v2-packets-api.md
new file mode 100644
index 00000000000..9ec5fa1b338
--- /dev/null
+++ b/.changeset/packet-v2-packets-api.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+Large run outputs can use the new API which allows switching object storage providers.
\ No newline at end of file
diff --git a/.changeset/private-networking-dequeue.md b/.changeset/private-networking-dequeue.md
new file mode 100644
index 00000000000..4a5bdba6a67
--- /dev/null
+++ b/.changeset/private-networking-dequeue.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+Add optional `hasPrivateLink` field to the dequeue message organization object for private networking support
diff --git a/.changeset/quick-plums-tan.md b/.changeset/quick-plums-tan.md
deleted file mode 100644
index bacd44fb903..00000000000
--- a/.changeset/quick-plums-tan.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@trigger.dev/sdk": patch
-"@trigger.dev/core": patch
----
-
-Added support for idempotency reset
diff --git a/.changeset/quiet-dogs-fly.md b/.changeset/quiet-dogs-fly.md
new file mode 100644
index 00000000000..e6017304760
--- /dev/null
+++ b/.changeset/quiet-dogs-fly.md
@@ -0,0 +1,7 @@
+---
+"@trigger.dev/sdk": patch
+"@trigger.dev/core": patch
+"trigger.dev": patch
+---
+
+Add support for setting TTL (time-to-live) defaults at the task level and globally in trigger.config.ts, with per-trigger overrides still taking precedence
diff --git a/.changeset/tame-oranges-change.md b/.changeset/tame-oranges-change.md
new file mode 100644
index 00000000000..9755a41a26a
--- /dev/null
+++ b/.changeset/tame-oranges-change.md
@@ -0,0 +1,8 @@
+---
+"@trigger.dev/redis-worker": patch
+"@trigger.dev/sdk": patch
+"trigger.dev": patch
+"@trigger.dev/core": patch
+---
+
+Adapted the CLI API client to propagate the trigger source via http headers.
diff --git a/.claude/rules/database-safety.md b/.claude/rules/database-safety.md
new file mode 100644
index 00000000000..14a6523595b
--- /dev/null
+++ b/.claude/rules/database-safety.md
@@ -0,0 +1,13 @@
+---
+paths:
+  - "internal-packages/database/**"
+---
+
+# Database Migration Safety
+
+- When adding indexes to **existing tables**, use `CREATE INDEX CONCURRENTLY IF NOT EXISTS` to avoid table locks. These must be in their own separate migration file (one index per file).
+- Indexes on **newly created tables** (same migration as `CREATE TABLE`) do not need CONCURRENTLY.
+- When indexing a **new column on an existing table**, split into two migrations: first `ADD COLUMN IF NOT EXISTS`, then `CREATE INDEX CONCURRENTLY IF NOT EXISTS` in a separate file.
+- After generating a migration with Prisma, remove extraneous lines for: `_BackgroundWorkerToBackgroundWorkerFile`, `_BackgroundWorkerToTaskQueue`, `_TaskRunToTaskRunTag`, `_WaitpointRunConnections`, `_completedWaitpoints`, `SecretStore_key_idx`, and unrelated TaskRun indexes.
+- Never drop columns or tables without explicit approval.
+- New code should target `RunEngineVersion.V2` only.
diff --git a/.claude/rules/docs-writing.md b/.claude/rules/docs-writing.md
new file mode 100644
index 00000000000..bbfb471368e
--- /dev/null
+++ b/.claude/rules/docs-writing.md
@@ -0,0 +1,14 @@
+---
+paths:
+  - "docs/**"
+---
+
+# Documentation Writing Rules
+
+- Use Mintlify MDX format. Frontmatter: `title`, `description`, `sidebarTitle` (optional).
+- After creating a new page, add it to `docs.json` navigation under the correct group.
+- Use Mintlify components: `<Note>`, `<Warning>`, `<Info>`, `<Tip>`, `<CodeGroup>`, `<Expandable>`, `<Steps>`/`<Step>`.
+- Code examples should be complete and runnable where possible.
+- Always import from `@trigger.dev/sdk`, never `@trigger.dev/sdk/v3`.
+- Keep paragraphs short. Use headers to break up content.
+- Link to related pages using relative paths (e.g., `[Tasks](/tasks/overview)`).
diff --git a/.claude/rules/legacy-v3-code.md b/.claude/rules/legacy-v3-code.md
new file mode 100644
index 00000000000..6fd8d9402c2
--- /dev/null
+++ b/.claude/rules/legacy-v3-code.md
@@ -0,0 +1,33 @@
+---
+paths:
+  - "apps/webapp/app/v3/**"
+---
+
+# Legacy V1 Engine Code in `app/v3/`
+
+The `v3/` directory name is misleading - most code here is actively used by the current V2 engine. Only the specific files below are legacy V1-only code.
+
+## V1-Only Files - Never Modify
+
+- `marqs/` directory (entire MarQS queue system: sharedQueueConsumer, devQueueConsumer, fairDequeuingStrategy, devPubSub)
+- `legacyRunEngineWorker.server.ts` (V1 background job worker)
+- `services/triggerTaskV1.server.ts` (deprecated V1 task triggering)
+- `services/cancelTaskRunV1.server.ts` (deprecated V1 cancellation)
+- `authenticatedSocketConnection.server.ts` (V1 dev WebSocket using DevQueueConsumer)
+- `sharedSocketConnection.ts` (V1 shared queue socket using SharedQueueConsumer)
+
+## V1/V2 Branching Pattern
+
+Some services act as routers that branch on `RunEngineVersion`:
+- `services/cancelTaskRun.server.ts` - calls V1 service or `engine.cancelRun()` for V2
+- `services/batchTriggerV3.server.ts` - uses marqs for V1 path, run-engine for V2
+
+When editing these shared services, only modify V2 code paths.
+
+## V2 Modern Stack
+
+- **Run lifecycle**: `@internal/run-engine` (internal-packages/run-engine)
+- **Background jobs**: `@trigger.dev/redis-worker` (not graphile-worker/zodworker)
+- **Queue operations**: RunQueue inside run-engine (not MarQS)
+- **V2 engine singleton**: `runEngine.server.ts`, `runEngineHandlers.server.ts`
+- **V2 workers**: `commonWorker.server.ts`, `alertsWorker.server.ts`, `batchTriggerWorker.server.ts`
diff --git a/.claude/rules/sdk-packages.md b/.claude/rules/sdk-packages.md
new file mode 100644
index 00000000000..549eb341809
--- /dev/null
+++ b/.claude/rules/sdk-packages.md
@@ -0,0 +1,12 @@
+---
+paths:
+  - "packages/**"
+---
+
+# Public Package Rules
+
+- Changes to `packages/` are **customer-facing**. Always add a changeset: `pnpm run changeset:add`
+- Default to **patch**. Get maintainer approval for minor. Never select major without explicit approval.
+- `@trigger.dev/core`: **Never import the root**. Always use subpath imports (e.g., `@trigger.dev/core/v3`).
+- Do NOT update `rules/` or `.claude/skills/trigger-dev-tasks/` unless explicitly asked. These are maintained in separate dedicated passes.
+- Test changes using `references/hello-world` reference project.
diff --git a/.claude/rules/server-apps.md b/.claude/rules/server-apps.md
new file mode 100644
index 00000000000..4d46789701c
--- /dev/null
+++ b/.claude/rules/server-apps.md
@@ -0,0 +1,23 @@
+---
+paths:
+  - "apps/**"
+---
+
+# Server App Changes
+
+When modifying server apps (webapp, supervisor, coordinator, etc.) with **no package changes**, add a `.server-changes/` file instead of a changeset:
+
+```bash
+cat > .server-changes/descriptive-name.md << 'EOF'
+---
+area: webapp
+type: fix
+---
+
+Brief description of what changed and why.
+EOF
+```
+
+- **area**: `webapp` | `supervisor` | `coordinator` | `kubernetes-provider` | `docker-provider`
+- **type**: `feature` | `fix` | `improvement` | `breaking`
+- If the PR also touches `packages/`, just the changeset is sufficient (no `.server-changes/` needed).
diff --git a/.claude/skills/span-timeline-events/SKILL.md b/.claude/skills/span-timeline-events/SKILL.md
new file mode 100644
index 00000000000..122f49912d7
--- /dev/null
+++ b/.claude/skills/span-timeline-events/SKILL.md
@@ -0,0 +1,78 @@
+---
+name: span-timeline-events
+description: Use when adding, modifying, or debugging OTel span timeline events in the trace view. Covers event structure, ClickHouse storage constraints, rendering in SpanTimeline component, admin visibility, and the step-by-step process for adding new events.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Span Timeline Events
+
+The trace view's right panel shows a timeline of events for the selected span. These are OTel span events rendered by `app/utils/timelineSpanEvents.ts` and the `SpanTimeline` component.
+
+## How They Work
+
+1. **Span events** in OTel are attached to a parent span. In ClickHouse, they're stored as separate rows with `kind: "SPAN_EVENT"` sharing the parent span's `span_id`. The `#mergeRecordsIntoSpanDetail` method reassembles them into the span's `events` array at query time.
+2. The timeline only renders events whose `name` starts with `trigger.dev/` - all others are silently filtered out.
+3. The **display name** comes from `properties.event` (not the span event name), mapped through `getFriendlyNameForEvent()`.
+4. Events are shown on the **span they belong to** - events on one span don't appear in another span's timeline.
+
+## ClickHouse Storage Constraint
+
+When events are written to ClickHouse, `spanEventsToTaskEventV1Input()` filters out events whose `start_time` is not greater than the parent span's `startTime`. Events at or before the span start are silently dropped. This means span events must have timestamps strictly after the span's own `startTimeUnixNano`.
+
+## Timeline Rendering (SpanTimeline component)
+
+The `SpanTimeline` component in `app/components/run/RunTimeline.tsx` renders:
+
+1. **Events** (thin 1px line with hollow dots) - all events from `createTimelineSpanEventsFromSpanEvents()`
+2. **"Started"** marker (thick cap) - at the span's `startTime`
+3. **Duration bar** (thick 7px line) - from "Started" to "Finished"
+4. **"Finished"** marker (thick cap) - at `startTime + duration`
+
+The thin line before "Started" only appears when there are events with timestamps between the span start and the first child span. For the Attempt span this works well (Dequeued -> Pod scheduled -> Launched -> etc. all happen before execution starts). Events all get `lineVariant: "light"` (thin) while the execution bar gets `variant: "normal"` (thick).
+
+## Trace View Sort Order
+
+Sibling spans (same parent) are sorted by `start_time ASC` from the ClickHouse query. The `createTreeFromFlatItems` function preserves this order. Event timestamps don't affect sort order - only the span's own `start_time`.
+
+## Event Structure
+
+```typescript
+// OTel span event format
+{
+  name: "trigger.dev/run",        // Must start with "trigger.dev/" to render
+  timeUnixNano: "1711200000000000000",
+  attributes: [
+    { key: "event", value: { stringValue: "dequeue" } },  // The actual event type
+    { key: "duration", value: { intValue: 150 } },         // Optional: duration in ms
+  ]
+}
+```
+
+## Admin-Only Events
+
+`getAdminOnlyForEvent()` controls visibility. Events default to **admin-only** (`true`).
+
+| Event | Admin-only | Friendly name |
+|-------|-----------|---------------|
+| `dequeue` | No | Dequeued |
+| `fork` | No | Launched |
+| `import` | No (if no fork event) | Importing task file |
+| `create_attempt` | Yes | Attempt created |
+| `lazy_payload` | Yes | Lazy attempt initialized |
+| `pod_scheduled` | Yes | Pod scheduled |
+| (default) | Yes | (raw event name) |
+
+## Adding New Timeline Events
+
+1. Add OTLP span event with `name: "trigger.dev/<scope>"` and `properties.event: "<type>"`
+2. Event timestamp must be strictly after the parent span's `startTimeUnixNano` (ClickHouse drops earlier events)
+3. Add friendly name in `getFriendlyNameForEvent()` in `app/utils/timelineSpanEvents.ts`
+4. Set admin visibility in `getAdminOnlyForEvent()`
+5. Optionally add help text in `getHelpTextForEvent()`
+
+## Key Files
+
+- `app/utils/timelineSpanEvents.ts` - filtering, naming, admin logic
+- `app/components/run/RunTimeline.tsx` - `SpanTimeline` component (thin line + thick bar rendering)
+- `app/presenters/v3/SpanPresenter.server.ts` - loads span data including events
+- `app/v3/eventRepository/clickhouseEventRepository.server.ts` - `spanEventsToTaskEventV1Input()` (storage filter), `#mergeRecordsIntoSpanDetail` (reassembly)
diff --git a/.claude/skills/trigger-dev-tasks/SKILL.md b/.claude/skills/trigger-dev-tasks/SKILL.md
new file mode 100644
index 00000000000..791c22c27ed
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/SKILL.md
@@ -0,0 +1,200 @@
+---
+name: trigger-dev-tasks
+description: Use this skill when writing, designing, or optimizing Trigger.dev background tasks and workflows. This includes creating reliable async tasks, implementing AI workflows, setting up scheduled jobs, structuring complex task hierarchies with subtasks, configuring build extensions for tools like ffmpeg or Puppeteer/Playwright, and handling task schemas with Zod validation.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Trigger.dev Task Expert
+
+You are an expert Trigger.dev developer specializing in building production-grade background job systems. Tasks deployed to Trigger.dev run in Node.js 21+ and use the `@trigger.dev/sdk` package.
+
+## Critical Rules
+
+1. **Always use `@trigger.dev/sdk`** - Never use `@trigger.dev/sdk/v3` or deprecated `client.defineJob` pattern
+2. **Never use `node-fetch`** - Use the built-in `fetch` function
+3. **Export all tasks** - Every task must be exported, including subtasks
+4. **Never wrap wait/trigger calls in Promise.all** - `triggerAndWait`, `batchTriggerAndWait`, and `wait.*` calls cannot be wrapped in `Promise.all` or `Promise.allSettled`
+
+## Basic Task Pattern
+
+```ts
+import { task } from "@trigger.dev/sdk";
+
+export const processData = task({
+  id: "process-data",
+  retry: {
+    maxAttempts: 10,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+  },
+  run: async (payload: { userId: string; data: any[] }) => {
+    console.log(`Processing ${payload.data.length} items`);
+    return { processed: payload.data.length };
+  },
+});
+```
+
+## Schema Task (with validation)
+
+```ts
+import { schemaTask } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const validatedTask = schemaTask({
+  id: "validated-task",
+  schema: z.object({
+    name: z.string(),
+    email: z.string().email(),
+  }),
+  run: async (payload) => {
+    // Payload is automatically validated and typed
+    return { message: `Hello ${payload.name}` };
+  },
+});
+```
+
+## Triggering Tasks
+
+### From Backend Code (type-only import to prevent dependency leakage)
+
+```ts
+import { tasks } from "@trigger.dev/sdk";
+import type { processData } from "./trigger/tasks";
+
+const handle = await tasks.trigger<typeof processData>("process-data", {
+  userId: "123",
+  data: [{ id: 1 }],
+});
+```
+
+### From Inside Tasks
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Trigger and wait - returns Result object, NOT direct output
+    const result = await childTask.triggerAndWait({ data: "value" });
+    if (result.ok) {
+      console.log("Output:", result.output);
+    } else {
+      console.error("Failed:", result.error);
+    }
+
+    // Or unwrap directly (throws on error)
+    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
+  },
+});
+```
+
+## Idempotency (Critical for Retries)
+
+Always use idempotency keys when triggering tasks from inside other tasks:
+
+```ts
+import { idempotencyKeys } from "@trigger.dev/sdk";
+
+export const paymentTask = task({
+  id: "process-payment",
+  run: async (payload: { orderId: string }) => {
+    // Scoped to current run - survives retries
+    const key = await idempotencyKeys.create(`payment-${payload.orderId}`);
+
+    await chargeCustomer.trigger(payload, {
+      idempotencyKey: key,
+      idempotencyKeyTTL: "24h",
+    });
+  },
+});
+```
+
+## Trigger Options
+
+```ts
+await myTask.trigger(payload, {
+  delay: "1h",           // Delay execution
+  ttl: "10m",            // Cancel if not started within TTL
+  idempotencyKey: key,
+  queue: "my-queue",
+  machine: "large-1x",   // micro, small-1x, small-2x, medium-1x, medium-2x, large-1x, large-2x
+  maxAttempts: 3,
+  tags: ["user_123"],    // Max 10 tags
+  debounce: {            // Consolidate rapid triggers
+    key: "unique-key",
+    delay: "5s",
+    mode: "trailing",    // "leading" (default) or "trailing"
+  },
+});
+```
+
+## Debouncing
+
+Consolidate multiple triggers into a single execution:
+
+```ts
+// Rapid triggers with same key = single execution
+await myTask.trigger({ userId: "123" }, {
+  debounce: {
+    key: "user-123-update",
+    delay: "5s",
+  },
+});
+
+// Trailing mode: use payload from LAST trigger
+await myTask.trigger({ data: "latest" }, {
+  debounce: {
+    key: "my-key",
+    delay: "10s",
+    mode: "trailing",
+  },
+});
+```
+
+Use cases: user activity updates, webhook deduplication, search indexing, notification batching.
+
+## Batch Triggering
+
+Up to 1,000 items per batch, 3MB per payload:
+
+```ts
+const results = await myTask.batchTriggerAndWait([
+  { payload: { userId: "1" } },
+  { payload: { userId: "2" } },
+]);
+
+for (const result of results) {
+  if (result.ok) console.log(result.output);
+}
+```
+
+## Machine Presets
+
+| Preset      | vCPU | Memory |
+|-------------|------|--------|
+| micro       | 0.25 | 0.25GB |
+| small-1x    | 0.5  | 0.5GB  |
+| small-2x    | 1    | 1GB    |
+| medium-1x   | 1    | 2GB    |
+| medium-2x   | 2    | 4GB    |
+| large-1x    | 4    | 8GB    |
+| large-2x    | 8    | 16GB   |
+
+## Design Principles
+
+1. **Break complex workflows into subtasks** that can be independently retried and made idempotent
+2. **Don't over-complicate** - Sometimes `Promise.allSettled` inside a single task is better than many subtasks (each task has dedicated process and is charged by millisecond)
+3. **Always configure retries** - Set appropriate `maxAttempts` based on the operation
+4. **Use idempotency keys** - Especially for payment/critical operations
+5. **Group related subtasks** - Keep subtasks only used by one parent in the same file, don't export them
+6. **Use logger** - Log at key execution points with `logger.info()`, `logger.error()`, etc.
+
+## Reference Documentation
+
+For detailed documentation on specific topics, read these files:
+
+- `basic-tasks.md` - Task basics, triggering, waits
+- `advanced-tasks.md` - Tags, queues, concurrency, metadata, error handling
+- `scheduled-tasks.md` - Cron schedules, declarative and imperative
+- `realtime.md` - Real-time subscriptions, streams, React hooks
+- `config.md` - trigger.config.ts, build extensions (Prisma, Playwright, FFmpeg, etc.)
diff --git a/.claude/skills/trigger-dev-tasks/advanced-tasks.md b/.claude/skills/trigger-dev-tasks/advanced-tasks.md
new file mode 100644
index 00000000000..32a00337f89
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/advanced-tasks.md
@@ -0,0 +1,485 @@
+# Trigger.dev Advanced Tasks (v4)
+
+**Advanced patterns and features for writing tasks**
+
+## Tags & Organization
+
+```ts
+import { task, tags } from "@trigger.dev/sdk";
+
+export const processUser = task({
+  id: "process-user",
+  run: async (payload: { userId: string; orgId: string }, { ctx }) => {
+    // Add tags during execution
+    await tags.add(`user_${payload.userId}`);
+    await tags.add(`org_${payload.orgId}`);
+
+    return { processed: true };
+  },
+});
+
+// Trigger with tags
+await processUser.trigger(
+  { userId: "123", orgId: "abc" },
+  { tags: ["priority", "user_123", "org_abc"] } // Max 10 tags per run
+);
+
+// Subscribe to tagged runs
+for await (const run of runs.subscribeToRunsWithTag("user_123")) {
+  console.log(`User task ${run.id}: ${run.status}`);
+}
+```
+
+**Tag Best Practices:**
+
+- Use prefixes: `user_123`, `org_abc`, `video:456`
+- Max 10 tags per run, 1-64 characters each
+- Tags don't propagate to child tasks automatically
+
+## Batch Triggering v2
+
+Enhanced batch triggering with larger payloads and streaming ingestion.
+
+### Limits
+
+- **Maximum batch size**: 1,000 items (increased from 500)
+- **Payload per item**: 3MB each (increased from 1MB combined)
+- Payloads > 512KB automatically offload to object storage
+
+### Rate Limiting (per environment)
+
+| Tier | Bucket Size | Refill Rate |
+|------|-------------|-------------|
+| Free | 1,200 runs | 100 runs/10 sec |
+| Hobby | 5,000 runs | 500 runs/5 sec |
+| Pro | 5,000 runs | 500 runs/5 sec |
+
+### Concurrent Batch Processing
+
+| Tier | Concurrent Batches |
+|------|-------------------|
+| Free | 1 |
+| Hobby | 10 |
+| Pro | 10 |
+
+### Usage
+
+```ts
+import { myTask } from "./trigger/myTask";
+
+// Basic batch trigger (up to 1,000 items)
+const runs = await myTask.batchTrigger([
+  { payload: { userId: "user-1" } },
+  { payload: { userId: "user-2" } },
+  { payload: { userId: "user-3" } },
+]);
+
+// Batch trigger with wait
+const results = await myTask.batchTriggerAndWait([
+  { payload: { userId: "user-1" } },
+  { payload: { userId: "user-2" } },
+]);
+
+for (const result of results) {
+  if (result.ok) {
+    console.log("Result:", result.output);
+  }
+}
+
+// With per-item options
+const batchHandle = await myTask.batchTrigger([
+  {
+    payload: { userId: "123" },
+    options: {
+      idempotencyKey: "user-123-batch",
+      tags: ["priority"],
+    },
+  },
+  {
+    payload: { userId: "456" },
+    options: {
+      idempotencyKey: "user-456-batch",
+    },
+  },
+]);
+```
+
+## Debouncing
+
+Consolidate multiple triggers into a single execution by debouncing task runs with a unique key and delay window.
+
+### Use Cases
+
+- **User activity updates**: Batch rapid user actions into a single run
+- **Webhook deduplication**: Handle webhook bursts without redundant processing
+- **Search indexing**: Combine document updates instead of processing individually
+- **Notification batching**: Group notifications to prevent user spam
+
+### Basic Usage
+
+```ts
+await myTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "user-123-update",  // Unique identifier for debounce group
+      delay: "5s",              // Wait duration ("5s", "1m", or milliseconds)
+    },
+  }
+);
+```
+
+### Execution Modes
+
+**Leading Mode** (default): Uses payload/options from the first trigger; subsequent triggers only reschedule execution time.
+
+```ts
+// First trigger sets the payload
+await myTask.trigger({ action: "first" }, {
+  debounce: { key: "my-key", delay: "10s" }
+});
+
+// Second trigger only reschedules - payload remains "first"
+await myTask.trigger({ action: "second" }, {
+  debounce: { key: "my-key", delay: "10s" }
+});
+// Task executes with { action: "first" }
+```
+
+**Trailing Mode**: Uses payload/options from the most recent trigger.
+
+```ts
+await myTask.trigger(
+  { data: "latest-value" },
+  {
+    debounce: {
+      key: "trailing-example",
+      delay: "10s",
+      mode: "trailing",
+    },
+  }
+);
+```
+
+In trailing mode, these options update with each trigger:
+- `payload` — task input data
+- `metadata` — run metadata
+- `tags` — run tags (replaces existing)
+- `maxAttempts` — retry attempts
+- `maxDuration` — maximum compute time
+- `machine` — machine preset
+
+### Important Notes
+
+- Idempotency keys take precedence over debounce settings
+- Compatible with `triggerAndWait()` — parent runs block correctly on debounced execution
+- Debounce key is scoped to the task
+
+## Concurrency & Queues
+
+```ts
+import { task, queue } from "@trigger.dev/sdk";
+
+// Shared queue for related tasks
+const emailQueue = queue({
+  name: "email-processing",
+  concurrencyLimit: 5, // Max 5 emails processing simultaneously
+});
+
+// Task-level concurrency
+export const oneAtATime = task({
+  id: "sequential-task",
+  queue: { concurrencyLimit: 1 }, // Process one at a time
+  run: async (payload) => {
+    // Critical section - only one instance runs
+  },
+});
+
+// Per-user concurrency
+export const processUserData = task({
+  id: "process-user-data",
+  run: async (payload: { userId: string }) => {
+    // Override queue with user-specific concurrency
+    await childTask.trigger(payload, {
+      queue: {
+        name: `user-${payload.userId}`,
+        concurrencyLimit: 2,
+      },
+    });
+  },
+});
+
+export const emailTask = task({
+  id: "send-email",
+  queue: emailQueue, // Use shared queue
+  run: async (payload: { to: string }) => {
+    // Send email logic
+  },
+});
+```
+
+## Error Handling & Retries
+
+```ts
+import { task, retry, AbortTaskRunError } from "@trigger.dev/sdk";
+
+export const resilientTask = task({
+  id: "resilient-task",
+  retry: {
+    maxAttempts: 10,
+    factor: 1.8, // Exponential backoff multiplier
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+    randomize: false,
+  },
+  catchError: async ({ error, ctx }) => {
+    // Custom error handling
+    if (error.code === "FATAL_ERROR") {
+      throw new AbortTaskRunError("Cannot retry this error");
+    }
+
+    // Log error details
+    console.error(`Task ${ctx.task.id} failed:`, error);
+
+    // Allow retry by returning nothing
+    return { retryAt: new Date(Date.now() + 60000) }; // Retry in 1 minute
+  },
+  run: async (payload) => {
+    // Retry specific operations
+    const result = await retry.onThrow(
+      async () => {
+        return await unstableApiCall(payload);
+      },
+      { maxAttempts: 3 }
+    );
+
+    // Conditional HTTP retries
+    const response = await retry.fetch("https://api.example.com", {
+      retry: {
+        maxAttempts: 5,
+        condition: (response, error) => {
+          return response?.status === 429 || response?.status >= 500;
+        },
+      },
+    });
+
+    return result;
+  },
+});
+```
+
+## Machines & Performance
+
+```ts
+export const heavyTask = task({
+  id: "heavy-computation",
+  machine: { preset: "large-2x" }, // 8 vCPU, 16 GB RAM
+  maxDuration: 1800, // 30 minutes timeout
+  run: async (payload, { ctx }) => {
+    // Resource-intensive computation
+    if (ctx.machine.preset === "large-2x") {
+      // Use all available cores
+      return await parallelProcessing(payload);
+    }
+
+    return await standardProcessing(payload);
+  },
+});
+
+// Override machine when triggering
+await heavyTask.trigger(payload, {
+  machine: { preset: "medium-1x" }, // Override for this run
+});
+```
+
+**Machine Presets:**
+
+- `micro`: 0.25 vCPU, 0.25 GB RAM
+- `small-1x`: 0.5 vCPU, 0.5 GB RAM (default)
+- `small-2x`: 1 vCPU, 1 GB RAM
+- `medium-1x`: 1 vCPU, 2 GB RAM
+- `medium-2x`: 2 vCPU, 4 GB RAM
+- `large-1x`: 4 vCPU, 8 GB RAM
+- `large-2x`: 8 vCPU, 16 GB RAM
+
+## Idempotency
+
+```ts
+import { task, idempotencyKeys } from "@trigger.dev/sdk";
+
+export const paymentTask = task({
+  id: "process-payment",
+  retry: {
+    maxAttempts: 3,
+  },
+  run: async (payload: { orderId: string; amount: number }) => {
+    // Automatically scoped to this task run, so if the task is retried, the idempotency key will be the same
+    const idempotencyKey = await idempotencyKeys.create(`payment-${payload.orderId}`);
+
+    // Ensure payment is processed only once
+    await chargeCustomer.trigger(payload, {
+      idempotencyKey,
+      idempotencyKeyTTL: "24h", // Key expires in 24 hours
+    });
+  },
+});
+
+// Payload-based idempotency
+import { createHash } from "node:crypto";
+
+function createPayloadHash(payload: any): string {
+  const hash = createHash("sha256");
+  hash.update(JSON.stringify(payload));
+  return hash.digest("hex");
+}
+
+export const deduplicatedTask = task({
+  id: "deduplicated-task",
+  run: async (payload) => {
+    const payloadHash = createPayloadHash(payload);
+    const idempotencyKey = await idempotencyKeys.create(payloadHash);
+
+    await processData.trigger(payload, { idempotencyKey });
+  },
+});
+```
+
+## Metadata & Progress Tracking
+
+```ts
+import { task, metadata } from "@trigger.dev/sdk";
+
+export const batchProcessor = task({
+  id: "batch-processor",
+  run: async (payload: { items: any[] }, { ctx }) => {
+    const totalItems = payload.items.length;
+
+    // Initialize progress metadata
+    metadata
+      .set("progress", 0)
+      .set("totalItems", totalItems)
+      .set("processedItems", 0)
+      .set("status", "starting");
+
+    const results = [];
+
+    for (let i = 0; i < payload.items.length; i++) {
+      const item = payload.items[i];
+
+      // Process item
+      const result = await processItem(item);
+      results.push(result);
+
+      // Update progress
+      const progress = ((i + 1) / totalItems) * 100;
+      metadata
+        .set("progress", progress)
+        .increment("processedItems", 1)
+        .append("logs", `Processed item ${i + 1}/${totalItems}`)
+        .set("currentItem", item.id);
+    }
+
+    // Final status
+    metadata.set("status", "completed");
+
+    return { results, totalProcessed: results.length };
+  },
+});
+
+// Update parent metadata from child task
+export const childTask = task({
+  id: "child-task",
+  run: async (payload, { ctx }) => {
+    // Update parent task metadata
+    metadata.parent.set("childStatus", "processing");
+    metadata.root.increment("childrenCompleted", 1);
+
+    return { processed: true };
+  },
+});
+```
+
+## Logging & Tracing
+
+```ts
+import { task, logger } from "@trigger.dev/sdk";
+
+export const tracedTask = task({
+  id: "traced-task",
+  run: async (payload, { ctx }) => {
+    logger.info("Task started", { userId: payload.userId });
+
+    // Custom trace with attributes
+    const user = await logger.trace(
+      "fetch-user",
+      async (span) => {
+        span.setAttribute("user.id", payload.userId);
+        span.setAttribute("operation", "database-fetch");
+
+        const userData = await database.findUser(payload.userId);
+        span.setAttribute("user.found", !!userData);
+
+        return userData;
+      },
+      { userId: payload.userId }
+    );
+
+    logger.debug("User fetched", { user: user.id });
+
+    try {
+      const result = await processUser(user);
+      logger.info("Processing completed", { result });
+      return result;
+    } catch (error) {
+      logger.error("Processing failed", {
+        error: error.message,
+        userId: payload.userId,
+      });
+      throw error;
+    }
+  },
+});
+```
+
+## Hidden Tasks
+
+```ts
+// Hidden task - not exported, only used internally
+const internalProcessor = task({
+  id: "internal-processor",
+  run: async (payload: { data: string }) => {
+    return { processed: payload.data.toUpperCase() };
+  },
+});
+
+// Public task that uses hidden task
+export const publicWorkflow = task({
+  id: "public-workflow",
+  run: async (payload: { input: string }) => {
+    // Use hidden task internally
+    const result = await internalProcessor.triggerAndWait({
+      data: payload.input,
+    });
+
+    if (result.ok) {
+      return { output: result.output.processed };
+    }
+
+    throw new Error("Internal processing failed");
+  },
+});
+```
+
+## Best Practices
+
+- **Concurrency**: Use queues to prevent overwhelming external services
+- **Retries**: Configure exponential backoff for transient failures
+- **Idempotency**: Always use for payment/critical operations
+- **Metadata**: Track progress for long-running tasks
+- **Machines**: Match machine size to computational requirements
+- **Tags**: Use consistent naming patterns for filtering
+- **Debouncing**: Use for user activity, webhooks, and notification batching
+- **Batch triggering**: Use for bulk operations up to 1,000 items
+- **Error Handling**: Distinguish between retryable and fatal errors
+
+Design tasks to be stateless, idempotent, and resilient to failures. Use metadata for state tracking and queues for resource management.
diff --git a/.claude/skills/trigger-dev-tasks/basic-tasks.md b/.claude/skills/trigger-dev-tasks/basic-tasks.md
new file mode 100644
index 00000000000..56bff340761
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/basic-tasks.md
@@ -0,0 +1,199 @@
+# Trigger.dev Basic Tasks (v4)
+
+**MUST use `@trigger.dev/sdk`, NEVER `client.defineJob`**
+
+## Basic Task
+
+```ts
+import { task } from "@trigger.dev/sdk";
+
+export const processData = task({
+  id: "process-data",
+  retry: {
+    maxAttempts: 10,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+    randomize: false,
+  },
+  run: async (payload: { userId: string; data: any[] }) => {
+    // Task logic - runs for long time, no timeouts
+    console.log(`Processing ${payload.data.length} items for user ${payload.userId}`);
+    return { processed: payload.data.length };
+  },
+});
+```
+
+## Schema Task (with validation)
+
+```ts
+import { schemaTask } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const validatedTask = schemaTask({
+  id: "validated-task",
+  schema: z.object({
+    name: z.string(),
+    age: z.number(),
+    email: z.string().email(),
+  }),
+  run: async (payload) => {
+    // Payload is automatically validated and typed
+    return { message: `Hello ${payload.name}, age ${payload.age}` };
+  },
+});
+```
+
+## Triggering Tasks
+
+### From Backend Code
+
+```ts
+import { tasks } from "@trigger.dev/sdk";
+import type { processData } from "./trigger/tasks";
+
+// Single trigger
+const handle = await tasks.trigger<typeof processData>("process-data", {
+  userId: "123",
+  data: [{ id: 1 }, { id: 2 }],
+});
+
+// Batch trigger (up to 1,000 items, 3MB per payload)
+const batchHandle = await tasks.batchTrigger<typeof processData>("process-data", [
+  { payload: { userId: "123", data: [{ id: 1 }] } },
+  { payload: { userId: "456", data: [{ id: 2 }] } },
+]);
+```
+
+### Debounced Triggering
+
+Consolidate multiple triggers into a single execution:
+
+```ts
+// Multiple rapid triggers with same key = single execution
+await myTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "user-123-update",  // Unique key for debounce group
+      delay: "5s",              // Wait before executing
+    },
+  }
+);
+
+// Trailing mode: use payload from LAST trigger
+await myTask.trigger(
+  { data: "latest-value" },
+  {
+    debounce: {
+      key: "trailing-example",
+      delay: "10s",
+      mode: "trailing",  // Default is "leading" (first payload)
+    },
+  }
+);
+```
+
+**Debounce modes:**
+- `leading` (default): Uses payload from first trigger, subsequent triggers only reschedule
+- `trailing`: Uses payload from most recent trigger
+
+### From Inside Tasks (with Result handling)
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Trigger and continue
+    const handle = await childTask.trigger({ data: "value" });
+
+    // Trigger and wait - returns Result object, NOT task output
+    const result = await childTask.triggerAndWait({ data: "value" });
+    if (result.ok) {
+      console.log("Task output:", result.output); // Actual task return value
+    } else {
+      console.error("Task failed:", result.error);
+    }
+
+    // Quick unwrap (throws on error)
+    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
+
+    // Batch trigger and wait
+    const results = await childTask.batchTriggerAndWait([
+      { payload: { data: "item1" } },
+      { payload: { data: "item2" } },
+    ]);
+
+    for (const run of results) {
+      if (run.ok) {
+        console.log("Success:", run.output);
+      } else {
+        console.log("Failed:", run.error);
+      }
+    }
+  },
+});
+
+export const childTask = task({
+  id: "child-task",
+  run: async (payload: { data: string }) => {
+    return { processed: payload.data };
+  },
+});
+```
+
+> Never wrap triggerAndWait or batchTriggerAndWait calls in a Promise.all or Promise.allSettled as this is not supported in Trigger.dev tasks.
+
+## Waits
+
+```ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const taskWithWaits = task({
+  id: "task-with-waits",
+  run: async (payload) => {
+    console.log("Starting task");
+
+    // Wait for specific duration
+    await wait.for({ seconds: 30 });
+    await wait.for({ minutes: 5 });
+    await wait.for({ hours: 1 });
+    await wait.for({ days: 1 });
+
+    // Wait until specific date
+    await wait.until({ date: new Date("2024-12-25") });
+
+    // Wait for token (from external system)
+    await wait.forToken({
+      token: "user-approval-token",
+      timeoutInSeconds: 3600, // 1 hour timeout
+    });
+
+    console.log("All waits completed");
+    return { status: "completed" };
+  },
+});
+```
+
+> Never wrap wait calls in a Promise.all or Promise.allSettled as this is not supported in Trigger.dev tasks.
+
+## Key Points
+
+- **Result vs Output**: `triggerAndWait()` returns a `Result` object with `ok`, `output`, `error` properties - NOT the direct task output
+- **Type safety**: Use `import type` for task references when triggering from backend
+- **Waits > 5 seconds**: Automatically checkpointed, don't count toward compute usage
+- **Debounce + idempotency**: Idempotency keys take precedence over debounce settings
+
+## NEVER Use (v2 deprecated)
+
+```ts
+// BREAKS APPLICATION
+client.defineJob({
+  id: "job-id",
+  run: async (payload, io) => {
+    /* ... */
+  },
+});
+```
+
+Use SDK (`@trigger.dev/sdk`), check `result.ok` before accessing `result.output`
diff --git a/.claude/skills/trigger-dev-tasks/config.md b/.claude/skills/trigger-dev-tasks/config.md
new file mode 100644
index 00000000000..f6a4db1c4b8
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/config.md
@@ -0,0 +1,346 @@
+# Trigger.dev Configuration
+
+**Complete guide to configuring `trigger.config.ts` with build extensions**
+
+## Basic Configuration
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "<project-ref>", // Required: Your project reference
+  dirs: ["./trigger"], // Task directories
+  runtime: "node", // "node", "node-22", or "bun"
+  logLevel: "info", // "debug", "info", "warn", "error"
+
+  // Default retry settings
+  retries: {
+    enabledInDev: false,
+    default: {
+      maxAttempts: 3,
+      minTimeoutInMs: 1000,
+      maxTimeoutInMs: 10000,
+      factor: 2,
+      randomize: true,
+    },
+  },
+
+  // Build configuration
+  build: {
+    autoDetectExternal: true,
+    keepNames: true,
+    minify: false,
+    extensions: [], // Build extensions go here
+  },
+
+  // Global lifecycle hooks
+  onStartAttempt: async ({ payload, ctx }) => {
+    console.log("Global task start");
+  },
+  onSuccess: async ({ payload, output, ctx }) => {
+    console.log("Global task success");
+  },
+  onFailure: async ({ payload, error, ctx }) => {
+    console.log("Global task failure");
+  },
+});
+```
+
+## Build Extensions
+
+### Database & ORM
+
+#### Prisma
+
+```ts
+import { prismaExtension } from "@trigger.dev/build/extensions/prisma";
+
+extensions: [
+  prismaExtension({
+    schema: "prisma/schema.prisma",
+    version: "5.19.0", // Optional: specify version
+    migrate: true, // Run migrations during build
+    directUrlEnvVarName: "DIRECT_DATABASE_URL",
+    typedSql: true, // Enable TypedSQL support
+  }),
+];
+```
+
+#### TypeScript Decorators (for TypeORM)
+
+```ts
+import { emitDecoratorMetadata } from "@trigger.dev/build/extensions/typescript";
+
+extensions: [
+  emitDecoratorMetadata(), // Enables decorator metadata
+];
+```
+
+### Scripting Languages
+
+#### Python
+
+```ts
+import { pythonExtension } from "@trigger.dev/build/extensions/python";
+
+extensions: [
+  pythonExtension({
+    scripts: ["./python/**/*.py"], // Copy Python files
+    requirementsFile: "./requirements.txt", // Install packages
+    devPythonBinaryPath: ".venv/bin/python", // Dev mode binary
+  }),
+];
+
+// Usage in tasks
+const result = await python.runInline(`print("Hello, world!")`);
+const output = await python.runScript("./python/script.py", ["arg1"]);
+```
+
+### Browser Automation
+
+#### Playwright
+
+```ts
+import { playwright } from "@trigger.dev/build/extensions/playwright";
+
+extensions: [
+  playwright({
+    browsers: ["chromium", "firefox", "webkit"], // Default: ["chromium"]
+    headless: true, // Default: true
+  }),
+];
+```
+
+#### Puppeteer
+
+```ts
+import { puppeteer } from "@trigger.dev/build/extensions/puppeteer";
+
+extensions: [puppeteer()];
+
+// Environment variable needed:
+// PUPPETEER_EXECUTABLE_PATH: "/usr/bin/google-chrome-stable"
+```
+
+#### Lightpanda
+
+```ts
+import { lightpanda } from "@trigger.dev/build/extensions/lightpanda";
+
+extensions: [
+  lightpanda({
+    version: "latest", // or "nightly"
+    disableTelemetry: false,
+  }),
+];
+```
+
+### Media Processing
+
+#### FFmpeg
+
+```ts
+import { ffmpeg } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  ffmpeg({ version: "7" }), // Static build, or omit for Debian version
+];
+
+// Automatically sets FFMPEG_PATH and FFPROBE_PATH
+// Add fluent-ffmpeg to external packages if using
+```
+
+#### Audio Waveform
+
+```ts
+import { audioWaveform } from "@trigger.dev/build/extensions/audioWaveform";
+
+extensions: [
+  audioWaveform(), // Installs Audio Waveform 1.1.0
+];
+```
+
+### System & Package Management
+
+#### System Packages (apt-get)
+
+```ts
+import { aptGet } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  aptGet({
+    packages: ["ffmpeg", "imagemagick", "curl=7.68.0-1"], // Can specify versions
+  }),
+];
+```
+
+#### Additional NPM Packages
+
+Only use this for installing CLI tools, NOT packages you import in your code.
+
+```ts
+import { additionalPackages } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  additionalPackages({
+    packages: ["wrangler"], // CLI tools and specific versions
+  }),
+];
+```
+
+#### Additional Files
+
+```ts
+import { additionalFiles } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  additionalFiles({
+    files: ["wrangler.toml", "./assets/**", "./fonts/**"], // Glob patterns supported
+  }),
+];
+```
+
+### Environment & Build Tools
+
+#### Environment Variable Sync
+
+```ts
+import { syncEnvVars } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  syncEnvVars(async (ctx) => {
+    // ctx contains: environment, projectRef, env
+    return [
+      { name: "SECRET_KEY", value: await getSecret(ctx.environment) },
+      { name: "API_URL", value: ctx.environment === "prod" ? "api.prod.com" : "api.dev.com" },
+    ];
+  }),
+];
+```
+
+#### ESBuild Plugins
+
+```ts
+import { esbuildPlugin } from "@trigger.dev/build/extensions";
+import { sentryEsbuildPlugin } from "@sentry/esbuild-plugin";
+
+extensions: [
+  esbuildPlugin(
+    sentryEsbuildPlugin({
+      org: process.env.SENTRY_ORG,
+      project: process.env.SENTRY_PROJECT,
+      authToken: process.env.SENTRY_AUTH_TOKEN,
+    }),
+    { placement: "last", target: "deploy" } // Optional config
+  ),
+];
+```
+
+## Custom Build Extensions
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+const customExtension = {
+  name: "my-custom-extension",
+
+  externalsForTarget: (target) => {
+    return ["some-native-module"]; // Add external dependencies
+  },
+
+  onBuildStart: async (context) => {
+    console.log(`Build starting for ${context.target}`);
+    // Register esbuild plugins, modify build context
+  },
+
+  onBuildComplete: async (context, manifest) => {
+    console.log("Build complete, adding layers");
+    // Add build layers, modify deployment
+    context.addLayer({
+      id: "my-layer",
+      files: [{ source: "./custom-file", destination: "/app/custom" }],
+      commands: ["chmod +x /app/custom"],
+    });
+  },
+};
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [customExtension],
+  },
+});
+```
+
+## Advanced Configuration
+
+### Telemetry
+
+```ts
+import { PrismaInstrumentation } from "@prisma/instrumentation";
+import { OpenAIInstrumentation } from "@langfuse/openai";
+
+export default defineConfig({
+  // ... other config
+  telemetry: {
+    instrumentations: [new PrismaInstrumentation(), new OpenAIInstrumentation()],
+    exporters: [customExporter], // Optional custom exporters
+  },
+});
+```
+
+### Machine & Performance
+
+```ts
+export default defineConfig({
+  // ... other config
+  defaultMachine: "large-1x", // Default machine for all tasks
+  maxDuration: 300, // Default max duration (seconds)
+  enableConsoleLogging: true, // Console logging in development
+});
+```
+
+## Common Extension Combinations
+
+### Full-Stack Web App
+
+```ts
+extensions: [
+  prismaExtension({ schema: "prisma/schema.prisma", migrate: true }),
+  additionalFiles({ files: ["./public/**", "./assets/**"] }),
+  syncEnvVars(async (ctx) => [...envVars]),
+];
+```
+
+### AI/ML Processing
+
+```ts
+extensions: [
+  pythonExtension({
+    scripts: ["./ai/**/*.py"],
+    requirementsFile: "./requirements.txt",
+  }),
+  ffmpeg({ version: "7" }),
+  additionalPackages({ packages: ["wrangler"] }),
+];
+```
+
+### Web Scraping
+
+```ts
+extensions: [
+  playwright({ browsers: ["chromium"] }),
+  puppeteer(),
+  additionalFiles({ files: ["./selectors.json", "./proxies.txt"] }),
+];
+```
+
+## Best Practices
+
+- **Use specific versions**: Pin extension versions for reproducible builds
+- **External packages**: Add modules with native addons to the `build.external` array
+- **Environment sync**: Use `syncEnvVars` for dynamic secrets
+- **File paths**: Use glob patterns for flexible file inclusion
+- **Debug builds**: Use `--log-level debug --dry-run` for troubleshooting
+
+Extensions only affect deployment, not local development. Use `external` array for packages that shouldn't be bundled.
diff --git a/.claude/skills/trigger-dev-tasks/realtime.md b/.claude/skills/trigger-dev-tasks/realtime.md
new file mode 100644
index 00000000000..c1c4c5821a9
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/realtime.md
@@ -0,0 +1,244 @@
+# Trigger.dev Realtime
+
+**Real-time monitoring and updates for runs**
+
+## Core Concepts
+
+Realtime allows you to:
+
+- Subscribe to run status changes, metadata updates, and streams
+- Build real-time dashboards and UI updates
+- Monitor task progress from frontend and backend
+
+## Authentication
+
+### Public Access Tokens
+
+```ts
+import { auth } from "@trigger.dev/sdk";
+
+// Read-only token for specific runs
+const publicToken = await auth.createPublicToken({
+  scopes: {
+    read: {
+      runs: ["run_123", "run_456"],
+      tasks: ["my-task-1", "my-task-2"],
+    },
+  },
+  expirationTime: "1h", // Default: 15 minutes
+});
+```
+
+### Trigger Tokens (Frontend only)
+
+```ts
+// Single-use token for triggering tasks
+const triggerToken = await auth.createTriggerPublicToken("my-task", {
+  expirationTime: "30m",
+});
+```
+
+## Backend Usage
+
+### Subscribe to Runs
+
+```ts
+import { runs, tasks } from "@trigger.dev/sdk";
+
+// Trigger and subscribe
+const handle = await tasks.trigger("my-task", { data: "value" });
+
+// Subscribe to specific run
+for await (const run of runs.subscribeToRun<typeof myTask>(handle.id)) {
+  console.log(`Status: ${run.status}, Progress: ${run.metadata?.progress}`);
+  if (run.status === "COMPLETED") break;
+}
+
+// Subscribe to runs with tag
+for await (const run of runs.subscribeToRunsWithTag("user-123")) {
+  console.log(`Tagged run ${run.id}: ${run.status}`);
+}
+
+// Subscribe to batch
+for await (const run of runs.subscribeToBatch(batchId)) {
+  console.log(`Batch run ${run.id}: ${run.status}`);
+}
+```
+
+### Realtime Streams v2
+
+```ts
+import { streams, InferStreamType } from "@trigger.dev/sdk";
+
+// 1. Define streams (shared location)
+export const aiStream = streams.define<string>({
+  id: "ai-output",
+});
+
+export type AIStreamPart = InferStreamType<typeof aiStream>;
+
+// 2. Pipe from task
+export const streamingTask = task({
+  id: "streaming-task",
+  run: async (payload) => {
+    const completion = await openai.chat.completions.create({
+      model: "gpt-4",
+      messages: [{ role: "user", content: payload.prompt }],
+      stream: true,
+    });
+
+    const { waitUntilComplete } = aiStream.pipe(completion);
+    await waitUntilComplete();
+  },
+});
+
+// 3. Read from backend
+const stream = await aiStream.read(runId, {
+  timeoutInSeconds: 300,
+  startIndex: 0, // Resume from specific chunk
+});
+
+for await (const chunk of stream) {
+  console.log("Chunk:", chunk); // Fully typed
+}
+```
+
+## React Frontend Usage
+
+### Installation
+
+```bash
+npm add @trigger.dev/react-hooks
+```
+
+### Triggering Tasks
+
+```tsx
+"use client";
+import { useTaskTrigger, useRealtimeTaskTrigger } from "@trigger.dev/react-hooks";
+import type { myTask } from "../trigger/tasks";
+
+function TriggerComponent({ accessToken }: { accessToken: string }) {
+  // Basic trigger
+  const { submit, handle, isLoading } = useTaskTrigger<typeof myTask>("my-task", {
+    accessToken,
+  });
+
+  // Trigger with realtime updates
+  const {
+    submit: realtimeSubmit,
+    run,
+    isLoading: isRealtimeLoading,
+  } = useRealtimeTaskTrigger<typeof myTask>("my-task", { accessToken });
+
+  return (
+    <div>
+      <button onClick={() => submit({ data: "value" })} disabled={isLoading}>
+        Trigger Task
+      </button>
+
+      <button onClick={() => realtimeSubmit({ data: "realtime" })} disabled={isRealtimeLoading}>
+        Trigger with Realtime
+      </button>
+
+      {run && <div>Status: {run.status}</div>}
+    </div>
+  );
+}
+```
+
+### Subscribing to Runs
+
+```tsx
+"use client";
+import { useRealtimeRun, useRealtimeRunsWithTag } from "@trigger.dev/react-hooks";
+import type { myTask } from "../trigger/tasks";
+
+function SubscribeComponent({ runId, accessToken }: { runId: string; accessToken: string }) {
+  // Subscribe to specific run
+  const { run, error } = useRealtimeRun<typeof myTask>(runId, {
+    accessToken,
+    onComplete: (run) => {
+      console.log("Task completed:", run.output);
+    },
+  });
+
+  // Subscribe to tagged runs
+  const { runs } = useRealtimeRunsWithTag("user-123", { accessToken });
+
+  if (error) return <div>Error: {error.message}</div>;
+  if (!run) return <div>Loading...</div>;
+
+  return (
+    <div>
+      <div>Status: {run.status}</div>
+      <div>Progress: {run.metadata?.progress || 0}%</div>
+      {run.output && <div>Result: {JSON.stringify(run.output)}</div>}
+
+      <h3>Tagged Runs:</h3>
+      {runs.map((r) => (
+        <div key={r.id}>
+          {r.id}: {r.status}
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+### Realtime Streams with React
+
+```tsx
+"use client";
+import { useRealtimeStream } from "@trigger.dev/react-hooks";
+import { aiStream } from "../trigger/streams";
+
+function StreamComponent({ runId, accessToken }: { runId: string; accessToken: string }) {
+  // Pass defined stream directly for type safety
+  const { parts, error } = useRealtimeStream(aiStream, runId, {
+    accessToken,
+    timeoutInSeconds: 300,
+    throttleInMs: 50, // Control re-render frequency
+  });
+
+  if (error) return <div>Error: {error.message}</div>;
+  if (!parts) return <div>Loading...</div>;
+
+  const text = parts.join(""); // parts is typed as AIStreamPart[]
+
+  return <div>Streamed Text: {text}</div>;
+}
+```
+
+### Wait Tokens
+
+```tsx
+"use client";
+import { useWaitToken } from "@trigger.dev/react-hooks";
+
+function WaitTokenComponent({ tokenId, accessToken }: { tokenId: string; accessToken: string }) {
+  const { complete } = useWaitToken(tokenId, { accessToken });
+
+  return <button onClick={() => complete({ approved: true })}>Approve Task</button>;
+}
+```
+
+## Run Object Properties
+
+Key properties available in run subscriptions:
+
+- `id`: Unique run identifier
+- `status`: `QUEUED`, `EXECUTING`, `COMPLETED`, `FAILED`, `CANCELED`, etc.
+- `payload`: Task input data (typed)
+- `output`: Task result (typed, when completed)
+- `metadata`: Real-time updatable data
+- `createdAt`, `updatedAt`: Timestamps
+- `costInCents`: Execution cost
+
+## Best Practices
+
+- **Use Realtime over SWR**: Recommended for most use cases due to rate limits
+- **Scope tokens properly**: Only grant necessary read/trigger permissions
+- **Handle errors**: Always check for errors in hooks and subscriptions
+- **Type safety**: Use task types for proper payload/output typing
+- **Cleanup subscriptions**: Backend subscriptions auto-complete, frontend hooks auto-cleanup
diff --git a/.claude/skills/trigger-dev-tasks/scheduled-tasks.md b/.claude/skills/trigger-dev-tasks/scheduled-tasks.md
new file mode 100644
index 00000000000..b314753497f
--- /dev/null
+++ b/.claude/skills/trigger-dev-tasks/scheduled-tasks.md
@@ -0,0 +1,113 @@
+# Scheduled Tasks (Cron)
+
+Recurring tasks using cron. For one-off future runs, use the **delay** option.
+
+## Define a Scheduled Task
+
+```ts
+import { schedules } from "@trigger.dev/sdk";
+
+export const task = schedules.task({
+  id: "first-scheduled-task",
+  run: async (payload) => {
+    payload.timestamp; // Date (scheduled time, UTC)
+    payload.lastTimestamp; // Date | undefined
+    payload.timezone; // IANA, e.g. "America/New_York" (default "UTC")
+    payload.scheduleId; // string
+    payload.externalId; // string | undefined
+    payload.upcoming; // Date[]
+
+    payload.timestamp.toLocaleString("en-US", { timeZone: payload.timezone });
+  },
+});
+```
+
+> Scheduled tasks need at least one schedule attached to run.
+
+## Attach Schedules
+
+**Declarative (sync on dev/deploy):**
+
+```ts
+schedules.task({
+  id: "every-2h",
+  cron: "0 */2 * * *", // UTC
+  run: async () => {},
+});
+
+schedules.task({
+  id: "tokyo-5am",
+  cron: { pattern: "0 5 * * *", timezone: "Asia/Tokyo", environments: ["PRODUCTION", "STAGING"] },
+  run: async () => {},
+});
+```
+
+**Imperative (SDK or dashboard):**
+
+```ts
+await schedules.create({
+  task: task.id,
+  cron: "0 0 * * *",
+  timezone: "America/New_York", // DST-aware
+  externalId: "user_123",
+  deduplicationKey: "user_123-daily", // updates if reused
+});
+```
+
+### Dynamic / Multi-tenant Example
+
+```ts
+// /trigger/reminder.ts
+export const reminderTask = schedules.task({
+  id: "todo-reminder",
+  run: async (p) => {
+    if (!p.externalId) throw new Error("externalId is required");
+    const user = await db.getUser(p.externalId);
+    await sendReminderEmail(user);
+  },
+});
+```
+
+```ts
+// app/reminders/route.ts
+export async function POST(req: Request) {
+  const data = await req.json();
+  return Response.json(
+    await schedules.create({
+      task: reminderTask.id,
+      cron: "0 8 * * *",
+      timezone: data.timezone,
+      externalId: data.userId,
+      deduplicationKey: `${data.userId}-reminder`,
+    })
+  );
+}
+```
+
+## Cron Syntax (no seconds)
+
+```
+* * * * *
+| | | | └ day of week (0–7 or 1L–7L; 0/7=Sun; L=last)
+| | | └── month (1–12)
+| | └──── day of month (1–31 or L)
+| └────── hour (0–23)
+└──────── minute (0–59)
+```
+
+## When Schedules Won't Trigger
+
+- **Dev:** only when the dev CLI is running.
+- **Staging/Production:** only for tasks in the **latest deployment**.
+
+## SDK Management
+
+```ts
+await schedules.retrieve(id);
+await schedules.list();
+await schedules.update(id, { cron: "0 0 1 * *", externalId: "ext", deduplicationKey: "key" });
+await schedules.deactivate(id);
+await schedules.activate(id);
+await schedules.del(id);
+await schedules.timezones(); // list of IANA timezones
+```
diff --git a/.cursor/rules/otel-metrics.mdc b/.cursor/rules/otel-metrics.mdc
new file mode 100644
index 00000000000..218f07c41e2
--- /dev/null
+++ b/.cursor/rules/otel-metrics.mdc
@@ -0,0 +1,66 @@
+---
+description: Guidelines for creating OpenTelemetry metrics to avoid cardinality issues
+globs:
+  - "**/*.ts"
+---
+
+# OpenTelemetry Metrics Guidelines
+
+When creating or editing OTEL metrics (counters, histograms, gauges), always ensure metric attributes have **low cardinality**.
+
+## What is Cardinality?
+
+Cardinality refers to the number of unique values an attribute can have. Each unique combination of attribute values creates a new time series, which consumes memory and storage in your metrics backend.
+
+## Rules
+
+### DO use low-cardinality attributes:
+- **Enums**: `environment_type` (PRODUCTION, STAGING, DEVELOPMENT, PREVIEW)
+- **Booleans**: `hasFailures`, `streaming`, `success`
+- **Bounded error codes**: A finite, controlled set of error types
+- **Shard IDs**: When sharding is bounded (e.g., 0-15)
+
+### DO NOT use high-cardinality attributes:
+- **UUIDs/IDs**: `envId`, `userId`, `runId`, `projectId`, `organizationId`
+- **Unbounded integers**: `itemCount`, `batchSize`, `retryCount`
+- **Timestamps**: `createdAt`, `startTime`
+- **Free-form strings**: `errorMessage`, `taskName`, `queueName`
+
+## Example
+
+```typescript
+// BAD - High cardinality
+this.counter.add(1, {
+  envId: options.environmentId,        // UUID - unbounded
+  itemCount: options.runCount,         // Integer - unbounded
+});
+
+// GOOD - Low cardinality
+this.counter.add(1, {
+  environment_type: options.environmentType,  // Enum - 4 values
+  streaming: true,                            // Boolean - 2 values
+});
+```
+
+## Prometheus Metric Naming
+
+When metrics are exported via OTLP to Prometheus, the exporter automatically adds unit suffixes to metric names:
+
+| OTel Metric Name | Unit | Prometheus Name |
+|------------------|------|-----------------|
+| `my_duration_ms` | `ms` | `my_duration_ms_milliseconds` |
+| `my_counter` | counter | `my_counter_total` |
+| `items_inserted` | counter | `items_inserted_inserts_total` |
+| `batch_size` | histogram | `batch_size_items_bucket` |
+
+Keep this in mind when writing Grafana dashboards or Prometheus queries—the metric names in Prometheus will differ from the names defined in code.
+
+## Reference
+
+See the schedule engine (`internal-packages/schedule-engine/src/engine/index.ts`) for a good example of low-cardinality metric attributes.
+
+High cardinality metrics can cause:
+- Memory bloat in metrics backends (Axiom, Prometheus, etc.)
+- Slow queries and dashboard timeouts
+- Increased costs (many backends charge per time series)
+- Potential data loss or crashes at scale
diff --git a/.cursor/rules/writing-tasks.mdc b/.cursor/rules/writing-tasks.mdc
index 5116d083e23..359ed5d4733 100644
--- a/.cursor/rules/writing-tasks.mdc
+++ b/.cursor/rules/writing-tasks.mdc
@@ -14,7 +14,7 @@ alwaysApply: false
 
 ## Essential requirements when generating task code
 
-1. You MUST use `@trigger.dev/sdk/v3`
+1. You MUST import from `@trigger.dev/sdk` (NEVER `@trigger.dev/sdk/v3`)
 2. You MUST NEVER use `client.defineJob`
 3. YOU MUST `export` every task, including subtasks
 4. If you are able to generate an example payload for a task, do so.
@@ -53,7 +53,7 @@ Instead, you MUST ALWAYS generate ONLY this pattern:
 ```ts
 // ✅ ALWAYS GENERATE THIS EXACT PATTERN
 
-import { task } from "@trigger.dev/sdk/v3";
+import { task } from "@trigger.dev/sdk";
 
 //1. You need to export each task, even if it's a subtask
 export const helloWorld = task({
@@ -71,7 +71,7 @@ export const helloWorld = task({
 A task is a function that can run for a long time with resilience to failure:
 
 ```ts
-import { task } from "@trigger.dev/sdk/v3";
+import { task } from "@trigger.dev/sdk";
 
 export const helloWorld = task({
   id: "hello-world",
@@ -271,7 +271,7 @@ Global lifecycle hooks can also be defined in `trigger.config.ts` to apply to al
 ## Correct Schedules task (cron) implementations
 
 ```ts
-import { schedules } from "@trigger.dev/sdk/v3";
+import { schedules } from "@trigger.dev/sdk";
 
 export const firstScheduledTask = schedules.task({
   id: "first-scheduled-task",
@@ -312,7 +312,7 @@ export const firstScheduledTask = schedules.task({
 ### Attach a Declarative schedule
 
 ```ts
-import { schedules } from "@trigger.dev/sdk/v3";
+import { schedules } from "@trigger.dev/sdk";
 
 // Sepcify a cron pattern (UTC)
 export const firstScheduledTask = schedules.task({
@@ -326,7 +326,7 @@ export const firstScheduledTask = schedules.task({
 ```
 
 ```ts
-import { schedules } from "@trigger.dev/sdk/v3";
+import { schedules } from "@trigger.dev/sdk";
 
 // Specify a specific timezone like this:
 export const secondScheduledTask = schedules.task({
@@ -375,7 +375,7 @@ const createdSchedule = await schedules.create({
 Schema tasks validate payloads against a schema before execution:
 
 ```ts
-import { schemaTask } from "@trigger.dev/sdk/v3";
+import { schemaTask } from "@trigger.dev/sdk";
 import { z } from "zod";
 
 const myTask = schemaTask({
@@ -400,7 +400,7 @@ When you trigger a task from your backend code, you need to set the `TRIGGER_SEC
 Triggers a single run of a task with specified payload and options without importing the task. Use type-only imports for full type checking.
 
 ```ts
-import { tasks } from "@trigger.dev/sdk/v3";
+import { tasks } from "@trigger.dev/sdk";
 import type { emailSequence } from "~/trigger/emails";
 
 export async function POST(request: Request) {
@@ -418,7 +418,7 @@ export async function POST(request: Request) {
 Triggers multiple runs of a single task with different payloads without importing the task.
 
 ```ts
-import { tasks } from "@trigger.dev/sdk/v3";
+import { tasks } from "@trigger.dev/sdk";
 import type { emailSequence } from "~/trigger/emails";
 
 export async function POST(request: Request) {
@@ -436,7 +436,7 @@ export async function POST(request: Request) {
 Triggers multiple runs of different tasks at once, useful when you need to execute multiple tasks simultaneously.
 
 ```ts
-import { batch } from "@trigger.dev/sdk/v3";
+import { batch } from "@trigger.dev/sdk";
 import type { myTask1, myTask2 } from "~/trigger/myTasks";
 
 export async function POST(request: Request) {
@@ -621,7 +621,7 @@ const handle = await myTask.trigger(
 Access metadata inside a run:
 
 ```ts
-import { task, metadata } from "@trigger.dev/sdk/v3";
+import { task, metadata } from "@trigger.dev/sdk";
 
 export const myTask = task({
   id: "my-task",
@@ -713,7 +713,7 @@ Trigger.dev Realtime enables subscribing to runs for real-time updates on run st
 Subscribe to a run after triggering a task:
 
 ```ts
-import { runs, tasks } from "@trigger.dev/sdk/v3";
+import { runs, tasks } from "@trigger.dev/sdk";
 
 async function myBackend() {
   const handle = await tasks.trigger("my-task", { some: "data" });
@@ -735,7 +735,7 @@ async function myBackend() {
 You can infer types of run's payload and output by passing the task type:
 
 ```ts
-import { runs } from "@trigger.dev/sdk/v3";
+import { runs } from "@trigger.dev/sdk";
 import type { myTask } from "./trigger/my-task";
 
 for await (const run of runs.subscribeToRun<typeof myTask>(handle.id)) {
@@ -752,7 +752,7 @@ for await (const run of runs.subscribeToRun<typeof myTask>(handle.id)) {
 Stream data in realtime from inside your tasks using the metadata system:
 
 ```ts
-import { task, metadata } from "@trigger.dev/sdk/v3";
+import { task, metadata } from "@trigger.dev/sdk";
 import OpenAI from "openai";
 
 export type STREAMS = {
@@ -947,7 +947,7 @@ For most use cases, Realtime hooks are preferred over SWR hooks with polling due
 For client-side usage, generate a public access token with appropriate scopes:
 
 ```ts
-import { auth } from "@trigger.dev/sdk/v3";
+import { auth } from "@trigger.dev/sdk";
 
 const publicToken = await auth.createPublicToken({
   scopes: {
@@ -967,7 +967,7 @@ Idempotency ensures that an operation produces the same result when called multi
 Provide an `idempotencyKey` when triggering a task to ensure it runs only once with that key:
 
 ```ts
-import { idempotencyKeys, task } from "@trigger.dev/sdk/v3";
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
 
 export const myTask = task({
   id: "my-task",
@@ -1058,7 +1058,7 @@ function hash(payload: any): string {
 
 ```ts
 // onFailure executes after all retries are exhausted; use for notifications, logging, or side effects on final failure:
-import { task, logger } from "@trigger.dev/sdk/v3";
+import { task, logger } from "@trigger.dev/sdk";
 
 export const loggingExample = task({
   id: "logging-example",
@@ -1078,7 +1078,7 @@ export const loggingExample = task({
 The `trigger.config.ts` file configures your Trigger.dev project, specifying task locations, retry settings, telemetry, and build options.
 
 ```ts
-import { defineConfig } from "@trigger.dev/sdk/v3";
+import { defineConfig } from "@trigger.dev/sdk";
 
 export default defineConfig({
   project: "<project ref>",
@@ -1226,7 +1226,7 @@ await myTask.trigger({ name: "Alice", age: 30 });
 
 Before generating any code, you MUST verify:
 
-1. Are you importing from `@trigger.dev/sdk/v3`? If not, STOP and FIX.
+1. Are you importing from `@trigger.dev/sdk` (NOT `@trigger.dev/sdk/v3`)? If not, STOP and FIX.
 2. Have you exported every task? If not, STOP and FIX.
 3. Have you generated any DEPRECATED code patterns? If yes, STOP and FIX.
 
diff --git a/.env.example b/.env.example
index 35c8c976ff6..69d5acdc560 100644
--- a/.env.example
+++ b/.env.example
@@ -77,9 +77,28 @@ POSTHOG_PROJECT_KEY=
 # DEPOT_TOKEN=<Depot org token>
 # DEV_OTEL_EXPORTER_OTLP_ENDPOINT="http://0.0.0.0:4318"
 # These are needed for the object store (for handling large payloads/outputs)
-# OBJECT_STORE_BASE_URL="https://{bucket}.{accountId}.r2.cloudflarestorage.com"
-# OBJECT_STORE_ACCESS_KEY_ID=
-# OBJECT_STORE_SECRET_ACCESS_KEY=
+#
+# Default provider
+# OBJECT_STORE_BASE_URL=http://localhost:9005
+# OBJECT_STORE_BUCKET=packets
+# OBJECT_STORE_ACCESS_KEY_ID=minioadmin
+# OBJECT_STORE_SECRET_ACCESS_KEY=minioadmin
+# OBJECT_STORE_REGION=us-east-1
+# OBJECT_STORE_SERVICE=s3
+#
+# OBJECT_STORE_DEFAULT_PROTOCOL=s3  # Only specify this if you're going to migrate object storage and set protocol values below
+# Named providers (protocol-prefixed data) - optional for multi-provider support
+# OBJECT_STORE_S3_BASE_URL=https://s3.amazonaws.com
+# OBJECT_STORE_S3_ACCESS_KEY_ID=
+# OBJECT_STORE_S3_SECRET_ACCESS_KEY=
+# OBJECT_STORE_S3_REGION=us-east-1
+# OBJECT_STORE_S3_SERVICE=s3
+#
+# OBJECT_STORE_R2_BASE_URL=https://{bucket}.{accountId}.r2.cloudflarestorage.com
+# OBJECT_STORE_R2_ACCESS_KEY_ID=
+# OBJECT_STORE_R2_SECRET_ACCESS_KEY=
+# OBJECT_STORE_R2_REGION=auto
+# OBJECT_STORE_R2_SERVICE=s3
 # CHECKPOINT_THRESHOLD_IN_MS=10000
 
 # These control the server-side internal telemetry
diff --git a/.github/ISSUE_TEMPLATE/vouch-request.yml b/.github/ISSUE_TEMPLATE/vouch-request.yml
new file mode 100644
index 00000000000..9ffe04a8984
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/vouch-request.yml
@@ -0,0 +1,28 @@
+name: Vouch Request
+description: Request to be vouched as a contributor
+labels: ["vouch-request"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Vouch Request
+
+        We use [vouch](https://github.com/mitchellh/vouch) to manage contributor trust. PRs from unvouched users are automatically closed.
+
+        To get vouched, fill out this form. A maintainer will review your request and vouch for you by commenting on this issue.
+  - type: textarea
+    id: context
+    attributes:
+      label: Why do you want to contribute?
+      description: Tell us a bit about yourself and what you'd like to work on.
+      placeholder: "I'd like to fix a bug I found in..."
+    validations:
+      required: true
+  - type: textarea
+    id: prior-work
+    attributes:
+      label: Prior contributions or relevant experience
+      description: Links to previous open source work, relevant projects, or anything that helps us understand your background.
+      placeholder: "https://github.com/..."
+    validations:
+      required: false
diff --git a/.github/VOUCHED.td b/.github/VOUCHED.td
new file mode 100644
index 00000000000..ce96548aa6f
--- /dev/null
+++ b/.github/VOUCHED.td
@@ -0,0 +1,20 @@
+# Vouched contributors for Trigger.dev
+# See: https://github.com/mitchellh/vouch
+#
+# Org members
+0ski
+D-K-P
+ericallam
+matt-aitken
+mpcgrid
+myftija
+nicktrn
+samejr
+isshaddad
+# Outside contributors
+gautamsi
+capaj
+chengzp
+bharathkumar39293
+bhekanik
+jrossi
\ No newline at end of file
diff --git a/.github/workflows/changesets-pr.yml b/.github/workflows/changesets-pr.yml
index ec21972361e..c7fc4e07136 100644
--- a/.github/workflows/changesets-pr.yml
+++ b/.github/workflows/changesets-pr.yml
@@ -7,6 +7,7 @@ on:
     paths:
       - "packages/**"
       - ".changeset/**"
+      - ".server-changes/**"
       - "package.json"
       - "pnpm-lock.yaml"
 
@@ -34,7 +35,7 @@ jobs:
       - name: Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       - name: Install dependencies
@@ -50,7 +51,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Update PR title with version
+      - name: Update PR title and enhance body
         if: steps.changesets.outputs.published != 'true'
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -61,6 +62,15 @@ jobs:
             # we arbitrarily reference the version of the cli package here; it is the same for all package releases
             VERSION=$(git show origin/changeset-release/main:packages/cli-v3/package.json | jq -r '.version')
             gh pr edit "$PR_NUMBER" --title "chore: release v$VERSION"
+
+            # Enhance the PR body with a clean, deduplicated summary
+            RAW_BODY=$(gh pr view "$PR_NUMBER" --json body --jq '.body')
+            ENHANCED_BODY=$(CHANGESET_PR_BODY="$RAW_BODY" node scripts/enhance-release-pr.mjs "$VERSION")
+            if [ -n "$ENHANCED_BODY" ]; then
+              gh api repos/triggerdotdev/trigger.dev/pulls/"$PR_NUMBER" \
+                -X PATCH \
+                -f body="$ENHANCED_BODY"
+            fi
           fi
 
   update-lockfile:
@@ -83,20 +93,31 @@ jobs:
       - name: Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
 
       - name: Install and update lockfile
         run: pnpm install --no-frozen-lockfile
 
-      - name: Commit and push lockfile
+      - name: Clean up consumed .server-changes/ files
         run: |
           set -e
-          if git diff --quiet pnpm-lock.yaml; then
-            echo "No lockfile changes"
-          else
-            git config user.name "github-actions[bot]"
-            git config user.email "github-actions[bot]@users.noreply.github.com"
-            git add pnpm-lock.yaml
-            git commit -m "chore: update lockfile for release"
+          shopt -s nullglob
+          files=(.server-changes/*.md)
+          for f in "${files[@]}"; do
+            if [ "$(basename "$f")" != "README.md" ]; then
+              git rm --ignore-unmatch "$f"
+            fi
+          done
+
+      - name: Commit and push lockfile + server-changes cleanup
+        run: |
+          set -e
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pnpm-lock.yaml
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: update lockfile and clean up .server-changes/ for release"
             git push origin changeset-release/main
+          else
+            echo "No changes to commit"
           fi
diff --git a/.github/workflows/claude-md-audit.yml b/.github/workflows/claude-md-audit.yml
new file mode 100644
index 00000000000..a80bbca0f52
--- /dev/null
+++ b/.github/workflows/claude-md-audit.yml
@@ -0,0 +1,69 @@
+name: 📝 CLAUDE.md Audit
+
+on:
+  pull_request:
+    types: [opened, ready_for_review, synchronize]
+    paths-ignore:
+      - "docs/**"
+      - ".changeset/**"
+      - ".server-changes/**"
+      - "**/*.md"
+      - "references/**"
+
+concurrency:
+  group: claude-md-audit-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  audit:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          use_sticky_comment: true
+
+          claude_args: |
+            --max-turns 15
+            --allowedTools "Read,Glob,Grep,Bash(git diff:*)"
+
+          prompt: |
+            You are reviewing a PR to check whether any CLAUDE.md files or .claude/rules/ files need updating.
+
+            ## Your task
+
+            1. Run `git diff origin/main...HEAD --name-only` to see which files changed in this PR.
+            2. For each changed directory, check if there's a CLAUDE.md in that directory or a parent directory.
+            3. Determine if any CLAUDE.md or .claude/rules/ file should be updated based on the changes. Consider:
+               - New files/directories that aren't covered by existing documentation
+               - Changed architecture or patterns that contradict current CLAUDE.md guidance
+               - New dependencies, services, or infrastructure that Claude should know about
+               - Renamed or moved files that are referenced in CLAUDE.md
+               - Changes to build commands, test patterns, or development workflows
+
+            ## Response format
+
+            If NO updates are needed, respond with exactly:
+            ✅ CLAUDE.md files look current for this PR.
+
+            If updates ARE needed, respond with a short list:
+            📝 **CLAUDE.md updates suggested:**
+            - `path/to/CLAUDE.md`: [what should be added/changed]
+            - `.claude/rules/file.md`: [what should be added/changed]
+
+            Keep suggestions specific and brief. Only flag things that would actually mislead Claude in future sessions.
+            Do NOT suggest updates for trivial changes (bug fixes, small refactors within existing patterns).
+            Do NOT suggest creating new CLAUDE.md files - only updates to existing ones.
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 00000000000..cadbe31773f
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,70 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: ⎔ Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.23.0
+
+      - name: ⎔ Setup node
+        uses: buildjet/setup-node@v4
+        with:
+          node-version: 20.20.0
+          cache: "pnpm"
+
+      - name: 📥 Download deps
+        run: pnpm install --frozen-lockfile
+
+      - name: 📀 Generate Prisma Client
+        run: pnpm run generate
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          claude_args: |
+            --model claude-opus-4-5-20251101
+            --allowedTools "Bash(pnpm:*),Bash(turbo:*),Bash(git:*),Bash(gh:*),Bash(npx:*),Bash(docker:*),Edit,MultiEdit,Read,Write,Glob,Grep,LS,Task"
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 97170c2225a..9518ca6157c 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -36,7 +36,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
 
       - name: 📥 Download deps
         run: pnpm install --frozen-lockfile --filter trigger.dev...
diff --git a/.github/workflows/helm-pr-prerelease.yml b/.github/workflows/helm-pr-prerelease.yml
new file mode 100644
index 00000000000..8df045945e6
--- /dev/null
+++ b/.github/workflows/helm-pr-prerelease.yml
@@ -0,0 +1,138 @@
+name: 🧭 Helm Chart PR Prerelease
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths:
+      - "hosting/k8s/helm/**"
+
+concurrency:
+  group: helm-prerelease-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+env:
+  REGISTRY: ghcr.io
+  CHART_NAME: trigger
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v4
+        with:
+          version: "3.18.3"
+
+      - name: Build dependencies
+        run: helm dependency build ./hosting/k8s/helm/
+
+      - name: Extract dependency charts
+        run: |
+          cd ./hosting/k8s/helm/
+          for file in ./charts/*.tgz; do echo "Extracting $file"; tar -xzf "$file" -C ./charts; done
+
+      - name: Lint Helm Chart
+        run: |
+          helm lint ./hosting/k8s/helm/
+
+      - name: Render templates
+        run: |
+          helm template test-release ./hosting/k8s/helm/ \
+            --values ./hosting/k8s/helm/values.yaml \
+            --output-dir ./helm-output
+
+      - name: Validate manifests
+        uses: docker://ghcr.io/yannh/kubeconform:v0.7.0
+        with:
+          entrypoint: "/kubeconform"
+          args: "-summary -output json ./helm-output"
+
+  prerelease:
+    needs: lint-and-test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v4
+        with:
+          version: "3.18.3"
+
+      - name: Build dependencies
+        run: helm dependency build ./hosting/k8s/helm/
+
+      - name: Extract dependency charts
+        run: |
+          cd ./hosting/k8s/helm/
+          for file in ./charts/*.tgz; do echo "Extracting $file"; tar -xzf "$file" -C ./charts; done
+
+      - name: Log in to Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate prerelease version
+        id: version
+        run: |
+          BASE_VERSION=$(grep '^version:' ./hosting/k8s/helm/Chart.yaml | awk '{print $2}')
+          PR_NUMBER=${{ github.event.pull_request.number }}
+          SHORT_SHA=$(echo "${{ github.event.pull_request.head.sha }}" | cut -c1-7)
+          PRERELEASE_VERSION="${BASE_VERSION}-pr${PR_NUMBER}.${SHORT_SHA}"
+          echo "version=$PRERELEASE_VERSION" >> $GITHUB_OUTPUT
+          echo "Prerelease version: $PRERELEASE_VERSION"
+
+      - name: Update Chart.yaml with prerelease version
+        run: |
+          sed -i "s/^version:.*/version: ${{ steps.version.outputs.version }}/" ./hosting/k8s/helm/Chart.yaml
+
+      - name: Package Helm Chart
+        run: |
+          helm package ./hosting/k8s/helm/ --destination /tmp/
+
+      - name: Push Helm Chart to GHCR
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          CHART_PACKAGE="/tmp/${{ env.CHART_NAME }}-${VERSION}.tgz"
+
+          # Push to GHCR OCI registry
+          helm push "$CHART_PACKAGE" "oci://${{ env.REGISTRY }}/${{ github.repository_owner }}/charts"
+
+      - name: Find existing comment
+        uses: peter-evans/find-comment@v3
+        id: find-comment
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-author: "github-actions[bot]"
+          body-includes: "Helm Chart Prerelease Published"
+
+      - name: Create or update PR comment
+        uses: peter-evans/create-or-update-comment@v4
+        with:
+          comment-id: ${{ steps.find-comment.outputs.comment-id }}
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            ### 🧭 Helm Chart Prerelease Published
+
+            **Version:** `${{ steps.version.outputs.version }}`
+
+            **Install:**
+            ```bash
+            helm upgrade --install trigger \
+              oci://ghcr.io/${{ github.repository_owner }}/charts/trigger \
+              --version "${{ steps.version.outputs.version }}"
+            ```
+
+            > ⚠️ This is a prerelease for testing. Do not use in production.
+          edit-mode: replace
diff --git a/.github/workflows/pr_checks.yml b/.github/workflows/pr_checks.yml
index b6be1eddfa1..dab18223e35 100644
--- a/.github/workflows/pr_checks.yml
+++ b/.github/workflows/pr_checks.yml
@@ -29,3 +29,7 @@ jobs:
     with:
       package: cli-v3
     secrets: inherit
+
+  sdk-compat:
+    uses: ./.github/workflows/sdk-compat.yml
+    secrets: inherit
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 684d36dec3a..79b113b0f2a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -86,7 +86,7 @@ jobs:
       - name: Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       # npm v11.5.1 or newer is required for OIDC support
@@ -111,7 +111,7 @@ jobs:
         uses: changesets/action@v1
         with:
           publish: pnpm run changeset:release
-          createGithubReleases: true
+          createGithubReleases: false
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -122,7 +122,19 @@ jobs:
           package_version=$(echo '${{ steps.changesets.outputs.publishedPackages }}' | jq -r '.[0].version')
           echo "package_version=${package_version}" >> "$GITHUB_OUTPUT"
 
-      # this triggers the publish workflow for the docker images
+      - name: Create unified GitHub release
+        if: steps.changesets.outputs.published == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RELEASE_PR_BODY: ${{ github.event.pull_request.body }}
+        run: |
+          VERSION="${{ steps.get_version.outputs.package_version }}"
+          node scripts/generate-github-release.mjs "$VERSION" > /tmp/release-body.md
+          gh release create "v${VERSION}" \
+            --title "trigger.dev v${VERSION}" \
+            --notes-file /tmp/release-body.md \
+            --target main
+
       - name: Create and push Docker tag
         if: steps.changesets.outputs.published == 'true'
         run: |
@@ -130,6 +142,73 @@ jobs:
           git tag "v.docker.${{ steps.get_version.outputs.package_version }}"
           git push origin "v.docker.${{ steps.get_version.outputs.package_version }}"
 
+  # Trigger Docker builds directly via workflow_call since tags pushed with
+  # GITHUB_TOKEN don't trigger other workflows (GitHub Actions limitation).
+  publish-docker:
+    name: 🐳 Publish Docker images
+    needs: release
+    if: needs.release.outputs.published == 'true'
+    uses: ./.github/workflows/publish.yml
+    secrets: inherit
+    with:
+      image_tag: v${{ needs.release.outputs.published_package_version }}
+
+  # After Docker images are published, update the GitHub release with the exact GHCR tag URL.
+  # The GHCR package version ID is only known after the image is pushed, so we query for it here.
+  update-release:
+    name: 🔗 Update release Docker link
+    needs: [release, publish-docker]
+    if: needs.release.outputs.published == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: read
+    steps:
+      - name: Update GitHub release with Docker image link
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          VERSION="${{ needs.release.outputs.published_package_version }}"
+          TAG="v${VERSION}"
+
+          # Query GHCR for the version ID matching this tag
+          VERSION_ID=$(gh api --paginate -H "Accept: application/vnd.github+json" \
+            /orgs/triggerdotdev/packages/container/trigger.dev/versions \
+            --jq ".[] | select(.metadata.container.tags[] == \"${TAG}\") | .id" \
+            | head -1)
+
+          if [ -z "$VERSION_ID" ]; then
+            echo "Warning: Could not find GHCR version ID for tag ${TAG}, skipping update"
+            exit 0
+          fi
+
+          DOCKER_URL="https://github.com/triggerdotdev/trigger.dev/pkgs/container/trigger.dev/${VERSION_ID}?tag=${TAG}"
+          GENERIC_URL="https://github.com/triggerdotdev/trigger.dev/pkgs/container/trigger.dev"
+
+          # Get current release body and replace the generic link with the tag-specific one.
+          # Use word boundary after GENERIC_URL (closing paren) to avoid matching URLs that
+          # already have a version ID appended (idempotent on re-runs).
+          gh release view "${TAG}" --repo triggerdotdev/trigger.dev --json body --jq '.body' > /tmp/release-body.md
+          sed -i "s|${GENERIC_URL})|${DOCKER_URL})|g" /tmp/release-body.md
+
+          gh release edit "${TAG}" --repo triggerdotdev/trigger.dev --notes-file /tmp/release-body.md
+
+  # Dispatch changelog entry creation to the marketing site repo.
+  # Runs after update-release so the GitHub release body already has the exact Docker image URL.
+  dispatch-changelog:
+    name: 📝 Dispatch changelog PR
+    needs: [release, update-release]
+    if: needs.release.outputs.published == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.CROSS_REPO_PAT }}
+          repository: triggerdotdev/trigger.dev-site-v3
+          event-type: new-release
+          client-payload: '{"version": "${{ needs.release.outputs.published_package_version }}"}'
+
   # The prerelease job needs to be on the same workflow file due to a limitation related to how npm verifies OIDC claims.
   prerelease:
     name: 🧪 Prerelease
@@ -154,7 +233,7 @@ jobs:
       - name: Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       # npm v11.5.1 or newer is required for OIDC support
diff --git a/.github/workflows/sdk-compat.yml b/.github/workflows/sdk-compat.yml
new file mode 100644
index 00000000000..eb347c0f771
--- /dev/null
+++ b/.github/workflows/sdk-compat.yml
@@ -0,0 +1,178 @@
+name: "🔌 SDK Compatibility Tests"
+
+permissions:
+  contents: read
+
+on:
+  workflow_call:
+
+jobs:
+  node-compat:
+    name: "Node.js ${{ matrix.node }} (${{ matrix.os }})"
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        node: ["20.20", "22.12"]
+
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: ⎔ Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.23.0
+
+      - name: ⎔ Setup node
+        uses: buildjet/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: "pnpm"
+
+      - name: 📥 Download deps
+        run: pnpm install --frozen-lockfile
+
+      - name: 📀 Generate Prisma Client
+        run: pnpm run generate
+
+      - name: 🔨 Build SDK dependencies
+        shell: bash
+        run: pnpm run build --filter '@trigger.dev/sdk^...'
+
+      - name: 🔨 Build SDK
+        shell: bash
+        run: pnpm run build --filter '@trigger.dev/sdk'
+
+      - name: 🧪 Run SDK Compatibility Tests
+        shell: bash
+        run: pnpm --filter @internal/sdk-compat-tests test
+
+  bun-compat:
+    name: "Bun Runtime"
+    runs-on: ubuntu-latest
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: ⎔ Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.23.0
+
+      - name: ⎔ Setup node
+        uses: buildjet/setup-node@v4
+        with:
+          node-version: 20.20.0
+          cache: "pnpm"
+
+      - name: 🥟 Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: 📥 Download deps
+        run: pnpm install --frozen-lockfile
+
+      - name: 📀 Generate Prisma Client
+        run: pnpm run generate
+
+      - name: 🔨 Build SDK dependencies
+        run: pnpm run build --filter @trigger.dev/sdk^...
+
+      - name: 🔨 Build SDK
+        run: pnpm run build --filter @trigger.dev/sdk
+
+      - name: 🧪 Run Bun Compatibility Test
+        working-directory: internal-packages/sdk-compat-tests/src/fixtures/bun
+        run: bun run test.ts
+
+  deno-compat:
+    name: "Deno Runtime"
+    runs-on: ubuntu-latest
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: ⎔ Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.23.0
+
+      - name: ⎔ Setup node
+        uses: buildjet/setup-node@v4
+        with:
+          node-version: 20.20.0
+          cache: "pnpm"
+
+      - name: 🦕 Setup Deno
+        uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+
+      - name: 📥 Download deps
+        run: pnpm install --frozen-lockfile
+
+      - name: 📀 Generate Prisma Client
+        run: pnpm run generate
+
+      - name: 🔨 Build SDK dependencies
+        run: pnpm run build --filter @trigger.dev/sdk^...
+
+      - name: 🔨 Build SDK
+        run: pnpm run build --filter @trigger.dev/sdk
+
+      - name: 🔗 Link node_modules for Deno fixture
+        working-directory: internal-packages/sdk-compat-tests/src/fixtures/deno
+        run: ln -s ../../../../../node_modules node_modules
+
+      - name: 🧪 Run Deno Compatibility Test
+        working-directory: internal-packages/sdk-compat-tests/src/fixtures/deno
+        run: deno run --allow-read --allow-env --allow-sys test.ts
+
+  cloudflare-compat:
+    name: "Cloudflare Workers"
+    runs-on: ubuntu-latest
+    steps:
+      - name: ⬇️ Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: ⎔ Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.23.0
+
+      - name: ⎔ Setup node
+        uses: buildjet/setup-node@v4
+        with:
+          node-version: 20.20.0
+          cache: "pnpm"
+
+      - name: 📥 Download deps
+        run: pnpm install --frozen-lockfile
+
+      - name: 📀 Generate Prisma Client
+        run: pnpm run generate
+
+      - name: 🔨 Build SDK dependencies
+        run: pnpm run build --filter @trigger.dev/sdk^...
+
+      - name: 🔨 Build SDK
+        run: pnpm run build --filter @trigger.dev/sdk
+
+      - name: 📥 Install Cloudflare fixture deps
+        working-directory: internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker
+        run: pnpm install
+
+      - name: 🧪 Run Cloudflare Workers Compatibility Test (dry-run)
+        working-directory: internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker
+        run: npx wrangler deploy --dry-run --outdir dist
diff --git a/.github/workflows/typecheck.yml b/.github/workflows/typecheck.yml
index 3eb98e51772..665d54b2563 100644
--- a/.github/workflows/typecheck.yml
+++ b/.github/workflows/typecheck.yml
@@ -24,7 +24,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       - name: 📥 Download deps
diff --git a/.github/workflows/unit-tests-internal.yml b/.github/workflows/unit-tests-internal.yml
index e903e0145a4..92b951e8aa0 100644
--- a/.github/workflows/unit-tests-internal.yml
+++ b/.github/workflows/unit-tests-internal.yml
@@ -58,7 +58,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       # ..to avoid rate limits when pulling images
@@ -72,6 +72,17 @@ jobs:
         if: ${{ !env.DOCKERHUB_USERNAME }}
         run: echo "DockerHub login skipped because secrets are not available."
 
+      - name: 🐳 Pre-pull testcontainer images
+        if: ${{ env.DOCKERHUB_USERNAME }}
+        run: |
+          echo "Pre-pulling Docker images with authenticated session..."
+          docker pull postgres:14
+          docker pull clickhouse/clickhouse-server:25.4-alpine
+          docker pull redis:7-alpine
+          docker pull testcontainers/ryuk:0.11.0
+          docker pull electricsql/electric:1.2.4
+          echo "Image pre-pull complete"
+
       - name: 📥 Download deps
         run: pnpm install --frozen-lockfile
 
@@ -116,7 +127,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           # no cache enabled, we're not installing deps
 
       - name: Download blob reports from GitHub Actions Artifacts
diff --git a/.github/workflows/unit-tests-packages.yml b/.github/workflows/unit-tests-packages.yml
index d3210377039..78474e03f27 100644
--- a/.github/workflows/unit-tests-packages.yml
+++ b/.github/workflows/unit-tests-packages.yml
@@ -58,7 +58,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       # ..to avoid rate limits when pulling images
@@ -72,6 +72,17 @@ jobs:
         if: ${{ !env.DOCKERHUB_USERNAME }}
         run: echo "DockerHub login skipped because secrets are not available."
 
+      - name: 🐳 Pre-pull testcontainer images
+        if: ${{ env.DOCKERHUB_USERNAME }}
+        run: |
+          echo "Pre-pulling Docker images with authenticated session..."
+          docker pull postgres:14
+          docker pull clickhouse/clickhouse-server:25.4-alpine
+          docker pull redis:7-alpine
+          docker pull testcontainers/ryuk:0.11.0
+          docker pull electricsql/electric:1.2.4
+          echo "Image pre-pull complete"
+
       - name: 📥 Download deps
         run: pnpm install --frozen-lockfile
 
@@ -116,7 +127,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           # no cache enabled, we're not installing deps
 
       - name: Download blob reports from GitHub Actions Artifacts
diff --git a/.github/workflows/unit-tests-webapp.yml b/.github/workflows/unit-tests-webapp.yml
index e587bb38910..523a1887db8 100644
--- a/.github/workflows/unit-tests-webapp.yml
+++ b/.github/workflows/unit-tests-webapp.yml
@@ -58,7 +58,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           cache: "pnpm"
 
       # ..to avoid rate limits when pulling images
@@ -72,6 +72,17 @@ jobs:
         if: ${{ !env.DOCKERHUB_USERNAME }}
         run: echo "DockerHub login skipped because secrets are not available."
 
+      - name: 🐳 Pre-pull testcontainer images
+        if: ${{ env.DOCKERHUB_USERNAME }}
+        run: |
+          echo "Pre-pulling Docker images with authenticated session..."
+          docker pull postgres:14
+          docker pull clickhouse/clickhouse-server:25.4-alpine
+          docker pull redis:7-alpine
+          docker pull testcontainers/ryuk:0.11.0
+          docker pull electricsql/electric:1.2.4
+          echo "Image pre-pull complete"
+
       - name: 📥 Download deps
         run: pnpm install --frozen-lockfile
 
@@ -124,7 +135,7 @@ jobs:
       - name: ⎔ Setup node
         uses: buildjet/setup-node@v4
         with:
-          node-version: 20.19.0
+          node-version: 20.20.0
           # no cache enabled, we're not installing deps
 
       - name: Download blob reports from GitHub Actions Artifacts
diff --git a/.github/workflows/vouch-check-pr.yml b/.github/workflows/vouch-check-pr.yml
new file mode 100644
index 00000000000..21597cf467a
--- /dev/null
+++ b/.github/workflows/vouch-check-pr.yml
@@ -0,0 +1,44 @@
+name: Vouch - Check PR
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: read
+
+jobs:
+  check-vouch:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: mitchellh/vouch/action/check-pr@c6d80ead49839655b61b422700b7a3bc9d0804a9 # v1.4.2
+        with:
+          pr-number: ${{ github.event.pull_request.number }}
+          auto-close: true
+          require-vouch: true
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+  require-draft:
+    needs: check-vouch
+    if: >
+      github.event.pull_request.draft == false &&
+      github.event.pull_request.author_association != 'MEMBER' &&
+      github.event.pull_request.author_association != 'OWNER' &&
+      github.event.pull_request.author_association != 'COLLABORATOR'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Close non-draft PR
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          STATE=$(gh pr view ${{ github.event.pull_request.number }} --repo ${{ github.repository }} --json state -q '.state')
+          if [ "$STATE" != "OPEN" ]; then
+            echo "PR is already closed, skipping."
+            exit 0
+          fi
+          gh pr close ${{ github.event.pull_request.number }} \
+            --repo ${{ github.repository }} \
+            --comment "Thanks for your contribution! We require all external PRs to be opened in **draft** status first so you can address CodeRabbit review comments and ensure CI passes before requesting a review. Please re-open this PR as a draft. See [CONTRIBUTING.md](https://github.com/${{ github.repository }}/blob/main/CONTRIBUTING.md#pr-workflow) for details."
diff --git a/.github/workflows/vouch-manage-by-issue.yml b/.github/workflows/vouch-manage-by-issue.yml
new file mode 100644
index 00000000000..51bce367b3e
--- /dev/null
+++ b/.github/workflows/vouch-manage-by-issue.yml
@@ -0,0 +1,24 @@
+name: Vouch - Manage by Issue
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: write
+  issues: write
+
+jobs:
+  manage:
+    runs-on: ubuntu-latest
+    if: >-
+      contains(github.event.comment.body, 'vouch') ||
+      contains(github.event.comment.body, 'denounce') ||
+      contains(github.event.comment.body, 'unvouch')
+    steps:
+      - uses: mitchellh/vouch/action/manage-by-issue@c6d80ead49839655b61b422700b7a3bc9d0804a9 # v1.4.2
+        with:
+          comment-id: ${{ github.event.comment.id }}
+          issue-id: ${{ github.event.issue.number }}
+        env:
+          GH_TOKEN: ${{ github.token }}
diff --git a/.gitignore b/.gitignore
index 8267c9fbabb..5f6adddba0a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,6 +15,9 @@ out/
 dist
 packages/**/dist
 
+# vendored bundles (generated during build)
+packages/**/src/**/vendor
+
 # Tailwind
 apps/**/styles/tailwind.css
 packages/**/styles/tailwind.css
@@ -61,6 +64,8 @@ apps/**/public/build
 /packages/core/src/package.json
 /packages/trigger-sdk/src/package.json
 /packages/python/src/package.json
-.claude
+**/.claude/settings.local.json
 .mcp.log
-.cursor/debug.log
\ No newline at end of file
+.mcp.json
+.cursor/debug.log
+ailogger-output.log
\ No newline at end of file
diff --git a/.nvmrc b/.nvmrc
index 3bf34c27619..7c663e0a0bd 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-v20.19.0
\ No newline at end of file
+v20.20.0
\ No newline at end of file
diff --git a/.server-changes/.gitkeep b/.server-changes/.gitkeep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/.server-changes/README.md b/.server-changes/README.md
new file mode 100644
index 00000000000..82716de981c
--- /dev/null
+++ b/.server-changes/README.md
@@ -0,0 +1,81 @@
+# Server Changes
+
+This directory tracks changes to server-only components (webapp, supervisor, coordinator, etc.) that are not captured by changesets. Changesets only track published npm packages — server changes would otherwise go undocumented.
+
+## When to add a file
+
+**Server-only PRs**: If your PR only changes `apps/webapp/`, `apps/supervisor/`, `apps/coordinator/`, or other server components (and does NOT change anything in `packages/`), add a `.server-changes/` file.
+
+**Mixed PRs** (both packages and server): Just add a changeset as usual. No `.server-changes/` file needed — the changeset covers it.
+
+**Package-only PRs**: Just add a changeset as usual.
+
+## File format
+
+Create a markdown file with a descriptive name:
+
+```
+.server-changes/fix-batch-queue-stalls.md
+```
+
+With this format:
+
+```markdown
+---
+area: webapp
+type: fix
+---
+
+Speed up batch queue processing by removing stalls and fixing retry race
+```
+
+### Fields
+
+- **area** (required): `webapp` | `supervisor` | `coordinator` | `kubernetes-provider` | `docker-provider`
+- **type** (required): `feature` | `fix` | `improvement` | `breaking`
+
+### Description
+
+The body text (below the frontmatter) is a one-line description of the change. Keep it concise — it will appear in release notes.
+
+## Lifecycle
+
+1. Engineer adds a `.server-changes/` file in their PR
+2. Files accumulate on `main` as PRs merge
+3. The changeset release PR includes these in its summary
+4. After the release merges, CI cleans up the consumed files
+
+## Examples
+
+**New feature:**
+
+```markdown
+---
+area: webapp
+type: feature
+---
+
+TRQL query language and the Query page
+```
+
+**Bug fix:**
+
+```markdown
+---
+area: webapp
+type: fix
+---
+
+Fix schedule limit counting for orgs with custom limits
+```
+
+**Improvement:**
+
+```markdown
+---
+area: webapp
+type: improvement
+---
+
+Use the replica for API auth queries to reduce primary load
+```
diff --git a/.server-changes/admin-feature-flags-dialog.md b/.server-changes/admin-feature-flags-dialog.md
new file mode 100644
index 00000000000..2517e21a3b8
--- /dev/null
+++ b/.server-changes/admin-feature-flags-dialog.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add admin UI for viewing and editing feature flags (org-level overrides and global defaults).
diff --git a/.server-changes/ai-prompt-management.md b/.server-changes/ai-prompt-management.md
new file mode 100644
index 00000000000..624ec391047
--- /dev/null
+++ b/.server-changes/ai-prompt-management.md
@@ -0,0 +1,30 @@
+---
+area: webapp
+type: feature
+---
+
+AI prompt management dashboard and enhanced span inspectors.
+
+**Prompt management:**
+- Prompts list page with version status, model, override indicators, and 24h usage sparklines
+- Prompt detail page with template viewer, variable preview, version history timeline, and override editor
+- Create, edit, and remove overrides to change prompt content or model without redeploying
+- Promote any code-deployed version to current
+- Generations tab with infinite scroll, live polling, and inline span inspector
+- Per-prompt metrics: total generations, avg tokens, avg cost, latency, with version-level breakdowns
+
+**AI span inspectors:**
+- Custom inspectors for `ai.generateText`, `ai.streamText`, `ai.generateObject`, `ai.streamObject` parent spans
+- `ai.toolCall` inspector showing tool name, call ID, and input arguments
+- `ai.embed` inspector showing model, provider, and input text
+- Prompt tab on AI spans linking to prompt version with template and input variables
+- Compact timestamp and duration header on all AI span inspectors
+
+**AI metrics dashboard:**
+- Operations, Providers, and Prompts filters on the AI Metrics dashboard
+- Cost by prompt widget
+- "AI" section in the sidebar with Prompts and AI Metrics links
+
+**Other improvements:**
+- Resizable panel sizes now persist across page refreshes
+- Fixed `<div>` inside `<p>` DOM nesting warnings in span titles and chat messages
diff --git a/.server-changes/allow-rollbacks-promote-api.md b/.server-changes/allow-rollbacks-promote-api.md
new file mode 100644
index 00000000000..fc03fa114ff
--- /dev/null
+++ b/.server-changes/allow-rollbacks-promote-api.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add allowRollbacks query param to the promote deployment API to enable version downgrades
diff --git a/.server-changes/batch-r2-upload-retry.md b/.server-changes/batch-r2-upload-retry.md
new file mode 100644
index 00000000000..a2c6415635b
--- /dev/null
+++ b/.server-changes/batch-r2-upload-retry.md
@@ -0,0 +1,9 @@
+---
+area: webapp
+type: fix
+---
+
+Fix transient R2/object store upload failures during batchTrigger() item streaming.
+
+- Added p-retry (3 attempts, 500ms–2s exponential backoff) around `uploadPacketToObjectStore` in `BatchPayloadProcessor.process()` so transient network errors self-heal server-side rather than aborting the entire batch stream.
+- Removed `x-should-retry: false` from the 500 response on the batch items route so the SDK's existing 5xx retry path can recover if server-side retries are exhausted. Item deduplication by index makes full-stream retries safe.
diff --git a/.server-changes/ck-index-master-queue-dedup.md b/.server-changes/ck-index-master-queue-dedup.md
new file mode 100644
index 00000000000..a2ff6495e61
--- /dev/null
+++ b/.server-changes/ck-index-master-queue-dedup.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Concurrency-keyed queues now use a single master queue entry per base queue instead of one entry per key. Prevents high-CK-count tenants from consuming the entire parentQueueLimit window and starving other tenants on the same shard.
diff --git a/.server-changes/compute-template-shadow-mode.md b/.server-changes/compute-template-shadow-mode.md
new file mode 100644
index 00000000000..e8ae0af9b66
--- /dev/null
+++ b/.server-changes/compute-template-shadow-mode.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Pre-warm compute templates on deploy for orgs with compute access. Required for projects using a compute region, background-only for others.
diff --git a/.server-changes/dev-cli-disconnect-md b/.server-changes/dev-cli-disconnect-md
new file mode 100644
index 00000000000..a0790d70765
--- /dev/null
+++ b/.server-changes/dev-cli-disconnect-md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Added `/engine/v1/dev/disconnect` endpoint to auto-cancel runs when the CLI disconnects. Maximum of 500 runs can be cancelled. Uses the bulk action system when there are more than 25 runs to cancel.
\ No newline at end of file
diff --git a/.server-changes/enqueue-fast-path.md b/.server-changes/enqueue-fast-path.md
new file mode 100644
index 00000000000..65ff0dbaca8
--- /dev/null
+++ b/.server-changes/enqueue-fast-path.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Reduce run start latency by skipping the intermediate queue when concurrency is available. This optimization is rolled out per-region and enabled automatically for development environments.
diff --git a/.server-changes/env-variables-search-by-environment.md b/.server-changes/env-variables-search-by-environment.md
new file mode 100644
index 00000000000..c3f9ed8bc2a
--- /dev/null
+++ b/.server-changes/env-variables-search-by-environment.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Extended the search filter on the environment variables page to match on environment type (production, staging, development, preview) and branch name, not just variable name and value.
diff --git a/.server-changes/fix-batch-waitpoint-lock-contention.md b/.server-changes/fix-batch-waitpoint-lock-contention.md
new file mode 100644
index 00000000000..6b545eb794b
--- /dev/null
+++ b/.server-changes/fix-batch-waitpoint-lock-contention.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Reduce lock contention when processing large `batchTriggerAndWait` batches. Previously, each batch item acquired a Redis lock on the parent run to insert a `TaskRunWaitpoint` row, causing `LockAcquisitionTimeoutError` with high concurrency (880 errors/24h in prod). Since `blockRunWithCreatedBatch` already transitions the parent to `EXECUTING_WITH_WAITPOINTS` before items are processed, the per-item lock is unnecessary. The new `blockRunWithWaitpointLockless` method performs only the idempotent CTE insert without acquiring the lock.
diff --git a/.server-changes/fix-clickhouse-query-client-secure-param.md b/.server-changes/fix-clickhouse-query-client-secure-param.md
new file mode 100644
index 00000000000..4daa021fe40
--- /dev/null
+++ b/.server-changes/fix-clickhouse-query-client-secure-param.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Strip `secure` query parameter from QUERY_CLICKHOUSE_URL before passing to ClickHouse client. This was already done for the main and logs ClickHouse clients but was missing for the query client, causing a startup crash with `Error: Unknown URL parameters: secure`.
diff --git a/.server-changes/fix-dev-env-scope-wrong-member.md b/.server-changes/fix-dev-env-scope-wrong-member.md
new file mode 100644
index 00000000000..2bd3c92825c
--- /dev/null
+++ b/.server-changes/fix-dev-env-scope-wrong-member.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Fix `OrganizationsPresenter.#getEnvironment` matching the wrong development environment on teams with multiple members. All dev environments share the slug `"dev"`, so the previous `find` by slug alone could return another member's environment. Now filters DEVELOPMENT environments by `orgMember.userId` to ensure the logged-in user's dev environment is selected.
diff --git a/.server-changes/llm-cost-tracking.md b/.server-changes/llm-cost-tracking.md
new file mode 100644
index 00000000000..7567aae7d1b
--- /dev/null
+++ b/.server-changes/llm-cost-tracking.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add automatic LLM cost calculation for spans with GenAI semantic conventions. When a span arrives with `gen_ai.response.model` and token usage data, costs are calculated from an in-memory pricing registry backed by Postgres and dual-written to both span attributes (`trigger.llm.*`) and a new `llm_metrics_v1` ClickHouse table that captures usage, cost, performance (TTFC, tokens/sec), and behavioral (finish reason, operation type) metrics.
diff --git a/.server-changes/mcp-get-span-details.md b/.server-changes/mcp-get-span-details.md
new file mode 100644
index 00000000000..336595d2203
--- /dev/null
+++ b/.server-changes/mcp-get-span-details.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add API endpoint `GET /api/v1/runs/:runId/spans/:spanId` that returns detailed span information including properties, events, AI enrichment (model, tokens, cost), and triggered child runs.
diff --git a/.server-changes/multi-provider-object-storage.md b/.server-changes/multi-provider-object-storage.md
new file mode 100644
index 00000000000..6749b5dcdbb
--- /dev/null
+++ b/.server-changes/multi-provider-object-storage.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Multi-provider object storage with protocol-based routing for zero-downtime migration
diff --git a/.server-changes/object-store-iam-auth.md b/.server-changes/object-store-iam-auth.md
new file mode 100644
index 00000000000..4a400eb29fe
--- /dev/null
+++ b/.server-changes/object-store-iam-auth.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add IAM role-based auth support for object stores (no access keys required).
diff --git a/.server-changes/platform-notifications.md b/.server-changes/platform-notifications.md
new file mode 100644
index 00000000000..54d52d77673
--- /dev/null
+++ b/.server-changes/platform-notifications.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add platform notifications to inform users about new features, changelogs, and platform events directly in the dashboard.
diff --git a/.server-changes/prisma-application-name.md b/.server-changes/prisma-application-name.md
new file mode 100644
index 00000000000..825058f3b34
--- /dev/null
+++ b/.server-changes/prisma-application-name.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Set `application_name` on Prisma connections from SERVICE_NAME so DB load can be attributed by service
diff --git a/.server-changes/private-networking.md b/.server-changes/private-networking.md
new file mode 100644
index 00000000000..b9e0006af0f
--- /dev/null
+++ b/.server-changes/private-networking.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Add private networking support via AWS PrivateLink. Includes BillingClient methods for managing private connections, org settings UI pages for connection management, and supervisor changes to apply `privatelink` pod labels for CiliumNetworkPolicy matching.
diff --git a/.vouch.yml b/.vouch.yml
new file mode 100644
index 00000000000..8a9668392d3
--- /dev/null
+++ b/.vouch.yml
@@ -0,0 +1,2 @@
+vouch:
+  - github: edosrecki
diff --git a/.vscode/launch.json b/.vscode/launch.json
index d135aa70a20..71a76904a2b 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -31,6 +31,15 @@
       "cwd": "${workspaceFolder}/apps/webapp",
       "sourceMaps": true
     },
+    {
+      "type": "node-terminal",
+      "request": "launch",
+      "name": "Debug opened test file",
+      "command": "pnpm run test -- ./${relativeFile}",
+      "envFile": "${workspaceFolder}/.env",
+      "cwd": "${workspaceFolder}",
+      "sourceMaps": true
+    },
     {
       "type": "chrome",
       "request": "launch",
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 12aefeb358f..fd9f3dcde0c 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -7,5 +7,5 @@
     "packages/cli-v3/e2e": true
   },
   "vitest.disableWorkspaceWarning": true,
-  "typescript.experimental.useTsgo": false
+  "chat.agent.maxRequests": 10000
 }
diff --git a/AGENTS.md b/AGENTS.md
index 846c6d827cd..99496f91bde 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -13,7 +13,7 @@ This repository is a pnpm monorepo managed with Turbo. It contains multiple apps
 See `ai/references/repo.md` for a more complete explanation of the workspaces.
 
 ## Development setup
-1. Install dependencies with `pnpm i` (pnpm `10.23.0` and Node.js `20.11.1` are required).
+1. Install dependencies with `pnpm i` (pnpm `10.23.0` and Node.js `20.20.0` are required).
 2. Copy `.env.example` to `.env` and generate a random 16 byte hex string for `ENCRYPTION_KEY` (`openssl rand -hex 16`). Update other secrets if needed.
 3. Start the local services with Docker:
    ```bash
diff --git a/CHANGESETS.md b/CHANGESETS.md
index 722fe64eb4c..2e225b9ad34 100644
--- a/CHANGESETS.md
+++ b/CHANGESETS.md
@@ -1,24 +1,49 @@
-# Changesets
+# Changesets and Server Changes
 
-Trigger.dev uses [changesets](https://github.com/changesets/changesets) to manage updated our packages and releasing them to npm.
+Trigger.dev uses [changesets](https://github.com/changesets/changesets) to manage package versions and releasing them to npm. For server-only changes, we use a lightweight `.server-changes/` convention.
 
-## Adding a changeset
+## Adding a changeset (package changes)
 
 To add a changeset, use `pnpm run changeset:add` and follow the instructions [here](https://github.com/changesets/changesets/blob/main/docs/adding-a-changeset.md). Please only ever select one of our public packages when adding a changeset.
 
-## Release instructions (local only)
+## Adding a server change (server-only changes)
 
-Based on the instructions [here](https://github.com/changesets/changesets/blob/main/docs/intro-to-using-changesets.md)
+If your PR only changes server components (`apps/webapp/`, `apps/supervisor/`, etc.) and does NOT change any published packages, add a `.server-changes/` file instead of a changeset:
 
-1. Run `pnpm run changeset:version`
-2. Run `pnpm run changeset:release`
+```sh
+cat > .server-changes/fix-batch-queue-stalls.md << 'EOF'
+---
+area: webapp
+type: fix
+---
+
+Speed up batch queue processing by removing stalls and fixing retry race
+EOF
+```
+
+- `area`: `webapp` | `supervisor` | `coordinator` | `kubernetes-provider` | `docker-provider`
+- `type`: `feature` | `fix` | `improvement` | `breaking`
+
+For **mixed PRs** (both packages and server): just add a changeset. No `.server-changes/` file needed.
+
+See `.server-changes/README.md` for full documentation.
+
+## When to add which
+
+| PR changes | What to add |
+|---|---|
+| Only packages (`packages/`) | Changeset (`pnpm run changeset:add`) |
+| Only server (`apps/`) | `.server-changes/` file |
+| Both packages and server | Just the changeset |
 
 ## Release instructions (CI)
 
 Please follow the best-practice of adding changesets in the same commit as the code making the change with `pnpm run changeset:add`, as it will allow our release.yml CI workflow to function properly:
 
-- Anytime new changesets are added in a commit in the `main` branch, the [release.yml](./.github/workflows/release.yml) workflow will run and will automatically create/update a PR with a fresh run of `pnpm run changeset:version`.
-- When the version PR is merged into `main`, the release.yml workflow will automatically run `pnpm run changeset:release` to build and release packages to npm.
+- Anytime new changesets are added in a commit in the `main` branch, the [changesets-pr.yml](./.github/workflows/changesets-pr.yml) workflow will run and will automatically create/update a PR with a fresh run of `pnpm run changeset:version`.
+- The release PR body is automatically enhanced with a clean, deduplicated summary that includes both package changes and `.server-changes/` entries.
+- Consumed `.server-changes/` files are removed on the `changeset-release/main` branch — the same way changesets deletes `.changeset/*.md` files. When the release PR merges, they're gone from main.
+- When the version PR is merged into `main`, the [release.yml](./.github/workflows/release.yml) workflow will automatically build, release packages to npm, and create a single unified GitHub release.
 
 ## Pre-release instructions
 
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000000..0a54cced672
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,247 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with this repository. Subdirectory CLAUDE.md files provide deeper context when you navigate into specific areas.
+
+## Build and Development Commands
+
+This is a pnpm 10.23.0 monorepo using Turborepo. Run commands from root with `pnpm run`.
+
+```bash
+pnpm run docker              # Start Docker services (PostgreSQL, Redis, Electric)
+pnpm run db:migrate           # Run database migrations
+pnpm run db:seed              # Seed the database (required for reference projects)
+
+# Build packages (required before running)
+pnpm run build --filter webapp && pnpm run build --filter trigger.dev && pnpm run build --filter @trigger.dev/sdk
+
+pnpm run dev --filter webapp  # Run webapp (http://localhost:3030)
+pnpm run dev --filter trigger.dev --filter "@trigger.dev/*"  # Watch CLI and packages
+```
+
+### Verifying Changes
+
+The verification command depends on where the change lives:
+
+- **Apps and internal packages** (`apps/*`, `internal-packages/*`): Use `typecheck`. **Never use `build`** for these — building proves almost nothing about correctness.
+- **Public packages** (`packages/*`): Use `build`.
+
+```bash
+# Apps and internal packages — use typecheck
+pnpm run typecheck --filter webapp                  # ~1-2 minutes
+pnpm run typecheck --filter @internal/run-engine
+
+# Public packages — use build
+pnpm run build --filter @trigger.dev/sdk
+pnpm run build --filter @trigger.dev/core
+```
+
+Only run typecheck/build after major changes (new files, significant refactors, schema changes). For small edits, trust the types and let CI catch issues.
+
+## Testing
+
+We use vitest exclusively. **Never mock anything** - use testcontainers instead.
+
+```bash
+pnpm run test --filter webapp                          # All tests for a package
+cd internal-packages/run-engine
+pnpm run test ./src/engine/tests/ttl.test.ts --run     # Single test file
+pnpm run build --filter @internal/run-engine           # May need to build deps first
+```
+
+Test files go next to source files (e.g., `MyService.ts` -> `MyService.test.ts`).
+
+### Testcontainers for Redis/PostgreSQL
+
+```typescript
+import { redisTest, postgresTest, containerTest } from "@internal/testcontainers";
+
+redisTest("should use redis", async ({ redisOptions }) => {
+  /* ... */
+});
+postgresTest("should use postgres", async ({ prisma }) => {
+  /* ... */
+});
+containerTest("should use both", async ({ prisma, redisOptions }) => {
+  /* ... */
+});
+```
+
+## Changesets and Server Changes
+
+When modifying any public package (`packages/*` or `integrations/*`), add a changeset:
+
+```bash
+pnpm run changeset:add
+```
+
+- Default to **patch** for bug fixes and minor changes
+- Confirm with maintainers before selecting **minor** (new features)
+- **Never** select major without explicit approval
+
+When modifying only server components (`apps/webapp/`, `apps/supervisor/`, etc.) with no package changes, add a `.server-changes/` file instead. See `.server-changes/README.md` for format and documentation.
+
+## Dependency Pinning
+
+Zod is pinned to a single version across the entire monorepo (currently `3.25.76`). When adding zod to a new or existing package, use the **exact same version** as the rest of the repo - never a different version or a range. Mismatched zod versions cause runtime type incompatibilities (e.g., schemas from one package can't be used as body validators in another).
+
+## Architecture Overview
+
+### Request Flow
+
+User API call -> Webapp routes -> Services -> RunEngine -> Redis Queue -> Supervisor -> Container execution -> Results back through RunEngine -> ClickHouse (analytics) + PostgreSQL (state)
+
+### Apps
+
+- **apps/webapp**: Remix 2.1.0 app - main API, dashboard, orchestration. Uses Express server.
+- **apps/supervisor**: Manages task execution containers (Docker/Kubernetes).
+
+### Public Packages
+
+- **packages/trigger-sdk** (`@trigger.dev/sdk`): Main SDK for writing tasks
+- **packages/cli-v3** (`trigger.dev`): CLI - also bundles code that goes into customer task images
+- **packages/core** (`@trigger.dev/core`): Shared types. **Import subpaths only** (never root).
+- **packages/build** (`@trigger.dev/build`): Build extensions and types
+- **packages/react-hooks**: React hooks for realtime and triggering
+- **packages/redis-worker** (`@trigger.dev/redis-worker`): Redis-based background job system
+
+### Internal Packages
+
+- **internal-packages/database**: Prisma 6.14.0 client and schema (PostgreSQL)
+- **internal-packages/clickhouse**: ClickHouse client, schema migrations, analytics queries
+- **internal-packages/run-engine**: "Run Engine 2.0" - core run lifecycle management
+- **internal-packages/redis**: Redis client creation utilities (ioredis)
+- **internal-packages/testcontainers**: Test helpers for Redis/PostgreSQL containers
+- **internal-packages/schedule-engine**: Durable cron scheduling
+- **internal-packages/zodworker**: Graphile-worker wrapper (DEPRECATED - use redis-worker)
+
+### Legacy V1 Engine Code
+
+The `apps/webapp/app/v3/` directory name is misleading - most code there is actively used by V2. Only specific files are V1-only legacy (MarQS queue, triggerTaskV1, cancelTaskRunV1, etc.). See `apps/webapp/CLAUDE.md` for the exact list. When you encounter V1/V2 branching in services, only modify V2 code paths. All new work uses Run Engine 2.0 (`@internal/run-engine`) and redis-worker.
+
+### Documentation
+
+Docs live in `docs/` as a Mintlify site (MDX format). See `docs/CLAUDE.md` for conventions.
+
+### Reference Projects
+
+The `references/` directory contains test workspaces for testing SDK and platform features. Use `references/hello-world` to manually test changes before submitting PRs.
+
+## Docker Image Guidelines
+
+When updating Docker image references:
+
+- **Always use multiplatform/index digests**, not architecture-specific digests
+- Architecture-specific digests cause CI failures on different build environments
+- Use the digest from the main Docker Hub page, not from a specific OS/ARCH variant
+
+## Writing Trigger.dev Tasks
+
+Always import from `@trigger.dev/sdk`. Never use `@trigger.dev/sdk/v3` or deprecated `client.defineJob`.
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+
+export const myTask = task({
+  id: "my-task",
+  run: async (payload: { message: string }) => {
+    // Task logic
+  },
+});
+```
+
+### SDK Documentation Rules
+
+The `rules/` directory contains versioned SDK documentation distributed via the SDK installer. Current version: `rules/manifest.json`. Do NOT update `rules/` or `.claude/skills/trigger-dev-tasks/` unless explicitly asked - these are maintained in separate dedicated passes.
+
+## Testing with hello-world Reference Project
+
+First-time setup:
+
+1. `pnpm run db:seed` to seed the database
+2. Build CLI: `pnpm run build --filter trigger.dev && pnpm i`
+3. Authorize: `cd references/hello-world && pnpm exec trigger login -a http://localhost:3030`
+
+Running: `cd references/hello-world && pnpm exec trigger dev`
+
+## Local Task Testing Workflow
+
+### Step 1: Start Webapp in Background
+
+```bash
+# Run from repo root with run_in_background: true
+pnpm run dev --filter webapp
+curl -s http://localhost:3030/healthcheck  # Verify running
+```
+
+### Step 2: Start Trigger Dev in Background
+
+```bash
+cd references/hello-world && pnpm exec trigger dev
+# Wait for "Local worker ready [node]"
+```
+
+### Step 3: Trigger and Monitor Tasks via MCP
+
+```
+mcp__trigger__get_current_worker(projectRef: "proj_rrkpdguyagvsoktglnod", environment: "dev")
+mcp__trigger__trigger_task(projectRef: "proj_rrkpdguyagvsoktglnod", environment: "dev", taskId: "hello-world", payload: {"message": "Hello"})
+mcp__trigger__list_runs(projectRef: "proj_rrkpdguyagvsoktglnod", environment: "dev", taskIdentifier: "hello-world", limit: 5)
+```
+
+Dashboard: http://localhost:3030/orgs/references-9dfd/projects/hello-world-97DT/env/dev/runs
+
+<!-- intent-skills:start -->
+
+# Skill mappings — when working in these areas, load the linked skill file into context.
+
+skills:
+
+- task: "Using agentcrumbs for debug tracing, adding crumbs, trails, markers, querying traces, or stripping debug code before merge"
+  load: "node_modules/agentcrumbs/skills/agentcrumbs/SKILL.md"
+- task: "Setting up agentcrumbs in the project, initializing namespace catalog, running crumbs init"
+load: "node_modules/agentcrumbs/skills/agentcrumbs/init/SKILL.md"
+<!-- intent-skills:end -->
+
+## agentcrumbs
+
+Add crumbs as you write code — not just when debugging. Mark lines with
+`// @crumbs` or wrap blocks in `// #region @crumbs`. They stay on the
+branch throughout development and are stripped by `agentcrumbs strip`
+before merge.
+
+### Namespaces
+
+| Namespace         | Description                                    | Path                                |
+| ----------------- | ---------------------------------------------- | ----------------------------------- |
+| `webapp`          | Main Remix app — API, dashboard, orchestration | `apps/webapp`                       |
+| `supervisor`      | Task execution container manager               | `apps/supervisor`                   |
+| `sdk`             | Main SDK for writing tasks                     | `packages/trigger-sdk`              |
+| `cli`             | CLI and task image bundling                    | `packages/cli-v3`                   |
+| `core`            | Shared types and subpath exports               | `packages/core`                     |
+| `build`           | Build extensions and types                     | `packages/build`                    |
+| `react-hooks`     | React hooks for realtime/triggering            | `packages/react-hooks`              |
+| `redis-worker`    | Redis-based background job system              | `packages/redis-worker`             |
+| `run-engine`      | Run Engine 2.0 — core run lifecycle            | `internal-packages/run-engine`      |
+| `database`        | Prisma client and schema                       | `internal-packages/database`        |
+| `clickhouse`      | ClickHouse client, migrations, analytics       | `internal-packages/clickhouse`      |
+| `schedule-engine` | Durable cron scheduling                        | `internal-packages/schedule-engine` |
+| `run-queue`       | Run queue management                           | `internal-packages/run-queue`       |
+
+Do not invent new namespaces — pick from this table or ask first.
+
+### For PR reviewers
+
+Do not flag `// @crumbs` markers, `#region @crumbs` blocks, or agentcrumbs
+imports in reviews. These are temporary debug instrumentation stripped
+before merge. Data logged in crumbs (IDs, names, values) never reaches
+production.
+
+### CLI
+
+```bash
+pnpm exec agentcrumbs collect    # start collector (multi-service)
+pnpm exec agentcrumbs tail --app trigger       # live tail
+pnpm exec agentcrumbs clear --app trigger      # remove crumbs before merge
+```
+
+The preferred way to query for crumbs is to use `pnpm exec agentcrumbs query --app trigger` with the `--limit` option and cursor pagination, and clear existing crumbs before reproducing a bug via `pnpm exec agentcrumbs clear --app trigger`.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5924f89da3d..88e24cba4f0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,10 +2,25 @@
 
 Thank you for taking the time to contribute to Trigger.dev. Your involvement is not just welcomed, but we encourage it! 🚀
 
-Please take some time to read this guide to understand contributing best practices for Trigger.dev.
+Please take some time to read this guide to understand contributing best practices for Trigger.dev. Note that we use [vouch](https://github.com/mitchellh/vouch) to manage contributor trust, so you'll need to be vouched before opening a PR.
 
 Thank you for helping us make Trigger.dev even better! 🤩
 
+> **Important:** We only accept PRs that address a single issue. Please do not submit PRs containing multiple unrelated fixes or features. If you have multiple contributions, open a separate PR for each one.
+
+## Getting vouched (required before opening a PR)
+
+We use [vouch](https://github.com/mitchellh/vouch) to manage contributor trust. **PRs from unvouched users are automatically closed.**
+
+Before you open your first pull request, you need to be vouched by a maintainer. Here's how:
+
+1. Open a [Vouch Request](https://github.com/triggerdotdev/trigger.dev/issues/new?template=vouch-request.yml) issue.
+2. Tell us what you'd like to work on and share any relevant background.
+3. A maintainer will review your request and vouch for you by commenting on the issue.
+4. Once vouched, your PRs will be accepted normally.
+
+If you're unsure whether you're already vouched, go ahead and open a PR — the check will tell you.
+
 ## Developing
 
 The development branch is `main`. This is the branch that all pull
@@ -14,7 +29,7 @@ branch are tagged into a release periodically.
 
 ### Prerequisites
 
-- [Node.js](https://nodejs.org/en) version 20.11.1
+- [Node.js](https://nodejs.org/en) version 20.20.0
 - [pnpm package manager](https://pnpm.io/installation) version 10.23.0
 - [Docker](https://www.docker.com/get-started/)
 - [protobuf](https://github.com/protocolbuffers/protobuf)
@@ -34,7 +49,7 @@ branch are tagged into a release periodically.
    ```
    cd trigger.dev
    ```
-3. Ensure you are on the correct version of Node.js (20.11.1). If you are using `nvm`, there is an `.nvmrc` file that will automatically select the correct version of Node.js when you navigate to the repository.
+3. Ensure you are on the correct version of Node.js (20.20.0). If you are using `nvm`, there is an `.nvmrc` file that will automatically select the correct version of Node.js when you navigate to the repository.
 
 4. Run `corepack enable` to use the correct version of pnpm (`10.23.0`) as specified in the root `package.json` file.
 
@@ -92,7 +107,7 @@ We use the `<root>/references/hello-world` subdirectory as a staging ground for
 
 First, make sure you are running the webapp according to the instructions above. Then:
 
-1. Visit http://localhost:3030 in your browser and create a new V3 project called "hello-world".
+1. Visit http://localhost:3030 in your browser and create a new project called "hello-world".
 
 2. In Postgres go to the "Projects" table and for the project you create change the `externalRef` to `proj_rrkpdguyagvsoktglnod`.
 
@@ -127,7 +142,7 @@ pnpm exec trigger deploy --profile local
 
 ### Running
 
-The following steps should be followed any time you start working on a new feature you want to test in v3:
+The following steps should be followed any time you start working on a new feature you want to test:
 
 1. Make sure the webapp is running on localhost:3030
 
@@ -227,9 +242,23 @@ See the [Job Catalog](./references/job-catalog/README.md) file for more.
 
 **If you get errors, be sure to fix them before committing.**
 
-- Be sure to [check the "Allow edits from maintainers" option](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) while creating you PR.
-- If your PR refers to or fixes an issue, be sure to add `refs #XXX` or `fixes #XXX` to the PR description. Replacing `XXX` with the respective issue number. See more about [Linking a pull request to an issue
-  ](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
+> **Note:** We may close PRs if we decide that the cost of integrating the change outweighs the benefits. To improve the chances of your PR getting accepted, follow the guidelines below.
+
+### PR workflow
+
+1. **Always open your PR in draft status first.** Do not mark it as "Ready for Review" until the steps below are complete.
+2. **Address all CodeRabbit code review comments.** Our CI runs an automated code review via CodeRabbit. Go through each comment and either fix the issue or resolve it with a comment explaining why no change is needed.
+3. **Wait for all CI checks to pass.** Do not mark the PR as "Ready for Review" until every check is green.
+4. **Then mark the PR as "Ready for Review"** so a maintainer can take a look.
+
+### Cost/benefit analysis for risky changes
+
+If your change touches core infrastructure, modifies widely-used code paths, or could introduce regressions, consider doing a brief cost/benefit analysis and including it in the PR description. Explain what the benefit is to users and why the risk is worth it. This goes a long way toward helping maintainers evaluate your contribution.
+
+### General guidelines
+
+- Be sure to [check the "Allow edits from maintainers" option](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) while creating your PR.
+- If your PR refers to or fixes an issue, be sure to add `refs #XXX` or `fixes #XXX` to the PR description. Replacing `XXX` with the respective issue number. See more about [Linking a pull request to an issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
 - Be sure to fill the PR Template accordingly.
 
 ## Adding changesets
@@ -252,6 +281,39 @@ You will be prompted to select which packages to include in the changeset. Only
 
 Most of the time the changes you'll make are likely to be categorized as patch releases. If you feel like there is the need for a minor or major release of the package based on the changes being made, add the changeset as such and it will be discussed during PR review.
 
+## Adding server changes
+
+Changesets only track published npm packages. If your PR only changes server components (`apps/webapp/`, `apps/supervisor/`, `apps/coordinator/`, etc.) with no package changes, add a `.server-changes/` file so the change appears in release notes.
+
+Create a markdown file with a descriptive name:
+
+```sh
+cat > .server-changes/fix-batch-queue-stalls.md << 'EOF'
+---
+area: webapp
+type: fix
+---
+
+Speed up batch queue processing by removing stalls and fixing retry race
+EOF
+```
+
+**Fields:**
+- `area` (required): `webapp` | `supervisor` | `coordinator` | `kubernetes-provider` | `docker-provider`
+- `type` (required): `feature` | `fix` | `improvement` | `breaking`
+
+The body text (below the frontmatter) is a one-line description of the change. Keep it concise — it will appear in release notes.
+
+**When to add which:**
+
+| PR changes | What to add |
+|---|---|
+| Only packages (`packages/`) | Changeset |
+| Only server (`apps/`) | `.server-changes/` file |
+| Both packages and server | Just the changeset |
+
+See `.server-changes/README.md` for more details.
+
 ## Troubleshooting
 
 ### EADDRINUSE: address already in use :::3030
diff --git a/README.md b/README.md
index 6838d45468a..0d7f1ca2930 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 ### Build and deploy fully‑managed AI agents and workflows
 
-[Website](https://trigger.dev) | [Docs](https://trigger.dev/docs) | [Issues](https://github.com/triggerdotdev/trigger.dev/issues) | [Feature requests](https://triggerdev.featurebase.app/) | [Public roadmap](https://triggerdev.featurebase.app/roadmap) | [Self-hosting](https://trigger.dev/docs/self-hosting/overview)
+[Website](https://trigger.dev) | [Docs](https://trigger.dev/docs) | [Issues](https://github.com/triggerdotdev/trigger.dev/issues) | [Example projects](https://github.com/triggerdotdev/examples) | [Feature requests](https://triggerdev.featurebase.app/) | [Public roadmap](https://triggerdev.featurebase.app/roadmap) | [Self-hosting](https://trigger.dev/docs/self-hosting/overview) 
 
 [![Open Source](https://img.shields.io/badge/Open%20Source-%E2%9D%A4-red.svg)](https://github.com/triggerdotdev/trigger.dev)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/triggerdotdev/trigger.dev/blob/main/LICENSE)
diff --git a/RELEASE.md b/RELEASE.md
index 1b9273cb142..8ba3ecb5007 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,5 +1,28 @@
 ## Guide on releasing a new version
 
+### Automated release (v4+)
+
+Releases are fully automated via CI:
+
+1. PRs merge to `main` with changesets (for package changes) and/or `.server-changes/` files (for server-only changes).
+2. The [changesets-pr.yml](./.github/workflows/changesets-pr.yml) workflow automatically creates/updates the `changeset-release/main` PR with version bumps and an enhanced summary of all changes. Consumed `.server-changes/` files are removed on the release branch (same approach changesets uses for `.changeset/` files — they're deleted on the branch, so merging the PR cleans them up).
+3. When ready to release, merge the changeset release PR into `main`.
+4. The [release.yml](./.github/workflows/release.yml) workflow automatically:
+   - Publishes all packages to npm
+   - Creates a single unified GitHub release (e.g., "trigger.dev v4.3.4")
+   - Tags and triggers Docker image builds
+   - After Docker images are pushed, updates the GitHub release with the exact GHCR tag link
+
+### What engineers need to do
+
+- **Package changes**: Add a changeset with `pnpm run changeset:add`
+- **Server-only changes**: Add a `.server-changes/` file (see `.server-changes/README.md`)
+- **Mixed PRs**: Just the changeset is enough
+
+See `CHANGESETS.md` for full details on changesets and server changes.
+
+### Legacy release (v3)
+
 1. Merge in the changeset PR into main, making sure to cancel both the release and publish github actions from that merge.
 2. Pull the changes locally into main
 3. Run `pnpm i` which will update the pnpm lock file with the new versions
diff --git a/ailogger-output.log b/ailogger-output.log
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/apps/coordinator/Containerfile b/apps/coordinator/Containerfile
index 4e7b89e0af1..9e973675ab9 100644
--- a/apps/coordinator/Containerfile
+++ b/apps/coordinator/Containerfile
@@ -35,7 +35,7 @@ COPY --from=pruner --chown=node:node /app/out/full/ .
 COPY --from=dev-deps --chown=node:node /app/ .
 COPY --chown=node:node turbo.json turbo.json
 
-RUN pnpm run -r --filter coordinator build:bundle
+RUN pnpm run -r --filter @trigger.dev/core bundle-vendor && pnpm run -r --filter coordinator build:bundle
 
 FROM alpine AS cri-tools
 
diff --git a/apps/docker-provider/Containerfile b/apps/docker-provider/Containerfile
index bea730bda80..42a7ac23092 100644
--- a/apps/docker-provider/Containerfile
+++ b/apps/docker-provider/Containerfile
@@ -31,7 +31,7 @@ COPY --from=pruner --chown=node:node /app/out/full/ .
 COPY --from=dev-deps --chown=node:node /app/ .
 COPY --chown=node:node turbo.json turbo.json
 
-RUN pnpm run -r --filter docker-provider build:bundle
+RUN pnpm run -r --filter @trigger.dev/core bundle-vendor && pnpm run -r --filter docker-provider build:bundle
 
 FROM base AS runner
 
diff --git a/apps/kubernetes-provider/Containerfile b/apps/kubernetes-provider/Containerfile
index fb96304c26b..b46b9943275 100644
--- a/apps/kubernetes-provider/Containerfile
+++ b/apps/kubernetes-provider/Containerfile
@@ -31,7 +31,7 @@ COPY --from=pruner --chown=node:node /app/out/full/ .
 COPY --from=dev-deps --chown=node:node /app/ .
 COPY --chown=node:node turbo.json turbo.json
 
-RUN pnpm run -r --filter kubernetes-provider build:bundle
+RUN pnpm run -r --filter @trigger.dev/core bundle-vendor && pnpm run -r --filter kubernetes-provider build:bundle
 
 FROM base AS runner
 
diff --git a/apps/supervisor/CLAUDE.md b/apps/supervisor/CLAUDE.md
new file mode 100644
index 00000000000..ded836c6069
--- /dev/null
+++ b/apps/supervisor/CLAUDE.md
@@ -0,0 +1,20 @@
+# Supervisor
+
+Node.js app that manages task execution containers. Receives work from the platform, starts Docker/Kubernetes containers, monitors execution, and reports results.
+
+## Key Directories
+
+- `src/services/` - Core service logic
+- `src/workloadManager/` - Container orchestration abstraction (Docker or Kubernetes)
+- `src/workloadServer/` - HTTP server for workload communication (heartbeats, snapshots)
+- `src/clients/` - Platform communication (webapp/coordinator)
+- `src/env.ts` - Environment configuration
+
+## Architecture
+
+- **WorkloadManager**: Abstracts Docker vs Kubernetes execution
+- **SupervisorSession**: Manages the dequeue loop with EWMA-based dynamic scaling
+- **ResourceMonitor**: Tracks CPU/memory during execution
+- **PodCleaner/FailedPodHandler**: Kubernetes-specific cleanup
+
+Communicates with the platform via Socket.io and HTTP. Receives task assignments through the dequeue protocol from the webapp.
diff --git a/apps/supervisor/package.json b/apps/supervisor/package.json
index e9609bf1541..7456d421850 100644
--- a/apps/supervisor/package.json
+++ b/apps/supervisor/package.json
@@ -14,9 +14,11 @@
   },
   "dependencies": {
     "@aws-sdk/client-ecr": "^3.839.0",
+    "@internal/compute": "workspace:*",
     "@kubernetes/client-node": "^1.0.0",
     "@trigger.dev/core": "workspace:*",
     "dockerode": "^4.0.6",
+    "p-limit": "^6.2.0",
     "prom-client": "^15.1.0",
     "socket.io": "4.7.4",
     "std-env": "^3.8.0",
diff --git a/apps/supervisor/src/env.ts b/apps/supervisor/src/env.ts
index 1605a216373..b69fb24d73f 100644
--- a/apps/supervisor/src/env.ts
+++ b/apps/supervisor/src/env.ts
@@ -3,117 +3,267 @@ import { env as stdEnv } from "std-env";
 import { z } from "zod";
 import { AdditionalEnvVars, BoolEnv } from "./envUtil.js";
 
-const Env = z.object({
-  // This will come from `spec.nodeName` in k8s
-  TRIGGER_WORKER_INSTANCE_NAME: z.string().default(randomUUID()),
-  TRIGGER_WORKER_HEARTBEAT_INTERVAL_SECONDS: z.coerce.number().default(30),
-
-  // Required settings
-  TRIGGER_API_URL: z.string().url(),
-  TRIGGER_WORKER_TOKEN: z.string(), // accepts file:// path to read from a file
-  MANAGED_WORKER_SECRET: z.string(),
-  OTEL_EXPORTER_OTLP_ENDPOINT: z.string().url(), // set on the runners
-
-  // Workload API settings (coordinator mode) - the workload API is what the run controller connects to
-  TRIGGER_WORKLOAD_API_ENABLED: BoolEnv.default(true),
-  TRIGGER_WORKLOAD_API_PROTOCOL: z
-    .string()
-    .transform((s) => z.enum(["http", "https"]).parse(s.toLowerCase()))
-    .default("http"),
-  TRIGGER_WORKLOAD_API_DOMAIN: z.string().optional(), // If unset, will use orchestrator-specific default
-  TRIGGER_WORKLOAD_API_HOST_INTERNAL: z.string().default("0.0.0.0"),
-  TRIGGER_WORKLOAD_API_PORT_INTERNAL: z.coerce.number().default(8020), // This is the port the workload API listens on
-  TRIGGER_WORKLOAD_API_PORT_EXTERNAL: z.coerce.number().default(8020), // This is the exposed port passed to the run controller
-
-  // Runner settings
-  RUNNER_HEARTBEAT_INTERVAL_SECONDS: z.coerce.number().optional(),
-  RUNNER_SNAPSHOT_POLL_INTERVAL_SECONDS: z.coerce.number().optional(),
-  RUNNER_ADDITIONAL_ENV_VARS: AdditionalEnvVars, // optional (csv)
-  RUNNER_PRETTY_LOGS: BoolEnv.default(false),
-
-  // Dequeue settings (provider mode)
-  TRIGGER_DEQUEUE_ENABLED: BoolEnv.default(true),
-  TRIGGER_DEQUEUE_INTERVAL_MS: z.coerce.number().int().default(250),
-  TRIGGER_DEQUEUE_IDLE_INTERVAL_MS: z.coerce.number().int().default(1000),
-  TRIGGER_DEQUEUE_MAX_RUN_COUNT: z.coerce.number().int().default(1),
-  TRIGGER_DEQUEUE_MIN_CONSUMER_COUNT: z.coerce.number().int().default(1),
-  TRIGGER_DEQUEUE_MAX_CONSUMER_COUNT: z.coerce.number().int().default(10),
-  TRIGGER_DEQUEUE_SCALING_STRATEGY: z.enum(["none", "smooth", "aggressive"]).default("none"),
-  TRIGGER_DEQUEUE_SCALING_UP_COOLDOWN_MS: z.coerce.number().int().default(5000), // 5 seconds
-  TRIGGER_DEQUEUE_SCALING_DOWN_COOLDOWN_MS: z.coerce.number().int().default(30000), // 30 seconds
-  TRIGGER_DEQUEUE_SCALING_TARGET_RATIO: z.coerce.number().default(1.0), // Target ratio of queue items to consumers (1.0 = 1 item per consumer)
-  TRIGGER_DEQUEUE_SCALING_EWMA_ALPHA: z.coerce.number().min(0).max(1).default(0.3), // Smooths queue length measurements (0=historical, 1=current)
-  TRIGGER_DEQUEUE_SCALING_BATCH_WINDOW_MS: z.coerce.number().int().positive().default(1000), // Batch window for metrics processing (ms)
-  TRIGGER_DEQUEUE_SCALING_DAMPING_FACTOR: z.coerce.number().min(0).max(1).default(0.7), // Smooths consumer count changes after EWMA (0=no scaling, 1=immediate)
-
-  // Optional services
-  TRIGGER_WARM_START_URL: z.string().optional(),
-  TRIGGER_CHECKPOINT_URL: z.string().optional(),
-  TRIGGER_METADATA_URL: z.string().optional(),
-
-  // Used by the resource monitor
-  RESOURCE_MONITOR_ENABLED: BoolEnv.default(false),
-  RESOURCE_MONITOR_OVERRIDE_CPU_TOTAL: z.coerce.number().optional(),
-  RESOURCE_MONITOR_OVERRIDE_MEMORY_TOTAL_GB: z.coerce.number().optional(),
-
-  // Docker settings
-  DOCKER_API_VERSION: z.string().optional(),
-  DOCKER_PLATFORM: z.string().optional(), // e.g. linux/amd64, linux/arm64
-  DOCKER_STRIP_IMAGE_DIGEST: BoolEnv.default(true),
-  DOCKER_REGISTRY_USERNAME: z.string().optional(),
-  DOCKER_REGISTRY_PASSWORD: z.string().optional(),
-  DOCKER_REGISTRY_URL: z.string().optional(), // e.g. https://index.docker.io/v1
-  DOCKER_ENFORCE_MACHINE_PRESETS: BoolEnv.default(true),
-  DOCKER_AUTOREMOVE_EXITED_CONTAINERS: BoolEnv.default(true),
-  /**
-   * Network mode to use for all runners. Supported standard values are: `bridge`, `host`, `none`, and `container:<name|id>`.
-   * Any other value is taken as a custom network's name to which all runners should connect to.
-   *
-   * Accepts a list of comma-separated values to attach to multiple networks. Additional networks are interpreted as network names and will be attached after container creation.
-   *
-   * **WARNING**: Specifying multiple networks will slightly increase startup times.
-   *
-   * @default "host"
-   */
-  DOCKER_RUNNER_NETWORKS: z.string().default("host"),
-
-  // Kubernetes settings
-  KUBERNETES_FORCE_ENABLED: BoolEnv.default(false),
-  KUBERNETES_NAMESPACE: z.string().default("default"),
-  KUBERNETES_WORKER_NODETYPE_LABEL: z.string().default("v4-worker"),
-  KUBERNETES_IMAGE_PULL_SECRETS: z.string().optional(), // csv
-  KUBERNETES_EPHEMERAL_STORAGE_SIZE_LIMIT: z.string().default("10Gi"),
-  KUBERNETES_EPHEMERAL_STORAGE_SIZE_REQUEST: z.string().default("2Gi"),
-  KUBERNETES_STRIP_IMAGE_DIGEST: BoolEnv.default(false),
-  KUBERNETES_CPU_REQUEST_MIN_CORES: z.coerce.number().min(0).default(0),
-  KUBERNETES_CPU_REQUEST_RATIO: z.coerce.number().min(0).max(1).default(0.75), // Ratio of CPU limit, so 0.75 = 75% of CPU limit
-  KUBERNETES_MEMORY_REQUEST_MIN_GB: z.coerce.number().min(0).default(0),
-  KUBERNETES_MEMORY_REQUEST_RATIO: z.coerce.number().min(0).max(1).default(1), // Ratio of memory limit, so 1 = 100% of memory limit
-  KUBERNETES_MEMORY_OVERHEAD_GB: z.coerce.number().min(0).optional(), // Optional memory overhead to add to the limit in GB
-  KUBERNETES_SCHEDULER_NAME: z.string().optional(), // Custom scheduler name for pods
-
-  // Placement tags settings
-  PLACEMENT_TAGS_ENABLED: BoolEnv.default(false),
-  PLACEMENT_TAGS_PREFIX: z.string().default("node.cluster.x-k8s.io"),
-
-  // Metrics
-  METRICS_ENABLED: BoolEnv.default(true),
-  METRICS_COLLECT_DEFAULTS: BoolEnv.default(true),
-  METRICS_HOST: z.string().default("127.0.0.1"),
-  METRICS_PORT: z.coerce.number().int().default(9090),
-
-  // Pod cleaner
-  POD_CLEANER_ENABLED: BoolEnv.default(true),
-  POD_CLEANER_INTERVAL_MS: z.coerce.number().int().default(10000),
-  POD_CLEANER_BATCH_SIZE: z.coerce.number().int().default(500),
-
-  // Failed pod handler
-  FAILED_POD_HANDLER_ENABLED: BoolEnv.default(true),
-  FAILED_POD_HANDLER_RECONNECT_INTERVAL_MS: z.coerce.number().int().default(1000),
-
-  // Debug
-  DEBUG: BoolEnv.default(false),
-  SEND_RUN_DEBUG_LOGS: BoolEnv.default(false),
-});
+const Env = z
+  .object({
+    // This will come from `spec.nodeName` in k8s
+    TRIGGER_WORKER_INSTANCE_NAME: z.string().default(randomUUID()),
+    TRIGGER_WORKER_HEARTBEAT_INTERVAL_SECONDS: z.coerce.number().default(30),
+
+    // Required settings
+    TRIGGER_API_URL: z.string().url(),
+    TRIGGER_WORKER_TOKEN: z.string(), // accepts file:// path to read from a file
+    MANAGED_WORKER_SECRET: z.string(),
+    OTEL_EXPORTER_OTLP_ENDPOINT: z.string().url(), // set on the runners
+
+    // Workload API settings (coordinator mode) - the workload API is what the run controller connects to
+    TRIGGER_WORKLOAD_API_ENABLED: BoolEnv.default(true),
+    TRIGGER_WORKLOAD_API_PROTOCOL: z
+      .string()
+      .transform((s) => z.enum(["http", "https"]).parse(s.toLowerCase()))
+      .default("http"),
+    TRIGGER_WORKLOAD_API_DOMAIN: z.string().optional(), // If unset, will use orchestrator-specific default
+    TRIGGER_WORKLOAD_API_HOST_INTERNAL: z.string().default("0.0.0.0"),
+    TRIGGER_WORKLOAD_API_PORT_INTERNAL: z.coerce.number().default(8020), // This is the port the workload API listens on
+    TRIGGER_WORKLOAD_API_PORT_EXTERNAL: z.coerce.number().default(8020), // This is the exposed port passed to the run controller
+
+    // Runner settings
+    RUNNER_HEARTBEAT_INTERVAL_SECONDS: z.coerce.number().optional(),
+    RUNNER_SNAPSHOT_POLL_INTERVAL_SECONDS: z.coerce.number().optional(),
+    RUNNER_ADDITIONAL_ENV_VARS: AdditionalEnvVars, // optional (csv)
+    RUNNER_PRETTY_LOGS: BoolEnv.default(false),
+
+    // Dequeue settings (provider mode)
+    TRIGGER_DEQUEUE_ENABLED: BoolEnv.default(true),
+    TRIGGER_DEQUEUE_INTERVAL_MS: z.coerce.number().int().default(250),
+    TRIGGER_DEQUEUE_IDLE_INTERVAL_MS: z.coerce.number().int().default(1000),
+    TRIGGER_DEQUEUE_MAX_RUN_COUNT: z.coerce.number().int().default(1),
+    TRIGGER_DEQUEUE_MIN_CONSUMER_COUNT: z.coerce.number().int().default(1),
+    TRIGGER_DEQUEUE_MAX_CONSUMER_COUNT: z.coerce.number().int().default(10),
+    TRIGGER_DEQUEUE_SCALING_STRATEGY: z.enum(["none", "smooth", "aggressive"]).default("none"),
+    TRIGGER_DEQUEUE_SCALING_UP_COOLDOWN_MS: z.coerce.number().int().default(5000), // 5 seconds
+    TRIGGER_DEQUEUE_SCALING_DOWN_COOLDOWN_MS: z.coerce.number().int().default(30000), // 30 seconds
+    TRIGGER_DEQUEUE_SCALING_TARGET_RATIO: z.coerce.number().default(1.0), // Target ratio of queue items to consumers (1.0 = 1 item per consumer)
+    TRIGGER_DEQUEUE_SCALING_EWMA_ALPHA: z.coerce.number().min(0).max(1).default(0.3), // Smooths queue length measurements (0=historical, 1=current)
+    TRIGGER_DEQUEUE_SCALING_BATCH_WINDOW_MS: z.coerce.number().int().positive().default(1000), // Batch window for metrics processing (ms)
+    TRIGGER_DEQUEUE_SCALING_DAMPING_FACTOR: z.coerce.number().min(0).max(1).default(0.7), // Smooths consumer count changes after EWMA (0=no scaling, 1=immediate)
+
+    // Optional services
+    TRIGGER_WARM_START_URL: z.string().optional(),
+    TRIGGER_CHECKPOINT_URL: z.string().optional(),
+    TRIGGER_METADATA_URL: z.string().optional(),
+
+    // Used by the resource monitor
+    RESOURCE_MONITOR_ENABLED: BoolEnv.default(false),
+    RESOURCE_MONITOR_OVERRIDE_CPU_TOTAL: z.coerce.number().optional(),
+    RESOURCE_MONITOR_OVERRIDE_MEMORY_TOTAL_GB: z.coerce.number().optional(),
+
+    // Docker settings
+    DOCKER_API_VERSION: z.string().optional(),
+    DOCKER_PLATFORM: z.string().optional(), // e.g. linux/amd64, linux/arm64
+    DOCKER_STRIP_IMAGE_DIGEST: BoolEnv.default(true),
+    DOCKER_REGISTRY_USERNAME: z.string().optional(),
+    DOCKER_REGISTRY_PASSWORD: z.string().optional(),
+    DOCKER_REGISTRY_URL: z.string().optional(), // e.g. https://index.docker.io/v1
+    DOCKER_ENFORCE_MACHINE_PRESETS: BoolEnv.default(true),
+    DOCKER_AUTOREMOVE_EXITED_CONTAINERS: BoolEnv.default(true),
+    /**
+     * Network mode to use for all runners. Supported standard values are: `bridge`, `host`, `none`, and `container:<name|id>`.
+     * Any other value is taken as a custom network's name to which all runners should connect to.
+     *
+     * Accepts a list of comma-separated values to attach to multiple networks. Additional networks are interpreted as network names and will be attached after container creation.
+     *
+     * **WARNING**: Specifying multiple networks will slightly increase startup times.
+     *
+     * @default "host"
+     */
+    DOCKER_RUNNER_NETWORKS: z.string().default("host"),
+
+    // Compute settings
+    COMPUTE_GATEWAY_URL: z.string().url().optional(),
+    COMPUTE_GATEWAY_AUTH_TOKEN: z.string().optional(),
+    COMPUTE_GATEWAY_TIMEOUT_MS: z.coerce.number().int().default(30_000),
+    COMPUTE_SNAPSHOTS_ENABLED: BoolEnv.default(false),
+    COMPUTE_TRACE_SPANS_ENABLED: BoolEnv.default(true),
+    COMPUTE_TRACE_OTLP_ENDPOINT: z.string().url().optional(), // Override for span export (derived from TRIGGER_API_URL if unset)
+    COMPUTE_SNAPSHOT_DELAY_MS: z.coerce.number().int().min(0).max(60_000).default(5_000),
+    COMPUTE_SNAPSHOT_DISPATCH_LIMIT: z.coerce.number().int().min(1).max(100).default(10),
+
+    // Kubernetes settings
+    KUBERNETES_FORCE_ENABLED: BoolEnv.default(false),
+    KUBERNETES_NAMESPACE: z.string().default("default"),
+    KUBERNETES_WORKER_NODETYPE_LABEL: z.string().default("v4-worker"),
+    KUBERNETES_IMAGE_PULL_SECRETS: z.string().optional(), // csv
+    KUBERNETES_EPHEMERAL_STORAGE_SIZE_LIMIT: z.string().default("10Gi"),
+    KUBERNETES_EPHEMERAL_STORAGE_SIZE_REQUEST: z.string().default("2Gi"),
+    KUBERNETES_STRIP_IMAGE_DIGEST: BoolEnv.default(false),
+    KUBERNETES_CPU_REQUEST_MIN_CORES: z.coerce.number().min(0).default(0),
+    KUBERNETES_CPU_REQUEST_RATIO: z.coerce.number().min(0).max(1).default(0.75), // Ratio of CPU limit, so 0.75 = 75% of CPU limit
+    KUBERNETES_MEMORY_REQUEST_MIN_GB: z.coerce.number().min(0).default(0),
+    KUBERNETES_MEMORY_REQUEST_RATIO: z.coerce.number().min(0).max(1).default(1), // Ratio of memory limit, so 1 = 100% of memory limit
+
+    // Per-preset overrides of the global KUBERNETES_CPU_REQUEST_RATIO
+    KUBERNETES_CPU_REQUEST_RATIO_MICRO: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_SMALL_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_SMALL_2X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_MEDIUM_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_MEDIUM_2X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_LARGE_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_CPU_REQUEST_RATIO_LARGE_2X: z.coerce.number().min(0).max(1).optional(),
+
+    // Per-preset overrides of the global KUBERNETES_MEMORY_REQUEST_RATIO
+    KUBERNETES_MEMORY_REQUEST_RATIO_MICRO: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_SMALL_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_SMALL_2X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_MEDIUM_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_MEDIUM_2X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_LARGE_1X: z.coerce.number().min(0).max(1).optional(),
+    KUBERNETES_MEMORY_REQUEST_RATIO_LARGE_2X: z.coerce.number().min(0).max(1).optional(),
+
+    KUBERNETES_MEMORY_OVERHEAD_GB: z.coerce.number().min(0).optional(), // Optional memory overhead to add to the limit in GB
+    KUBERNETES_SCHEDULER_NAME: z.string().optional(), // Custom scheduler name for pods
+    // Large machine affinity settings - large-* presets prefer a dedicated pool
+    KUBERNETES_LARGE_MACHINE_AFFINITY_ENABLED: BoolEnv.default(false),
+    KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_KEY: z
+      .string()
+      .trim()
+      .min(1)
+      .default("node.cluster.x-k8s.io/machinepool"),
+    KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_VALUE: z
+      .string()
+      .trim()
+      .min(1)
+      .default("large-machines"),
+    KUBERNETES_LARGE_MACHINE_AFFINITY_WEIGHT: z.coerce.number().int().min(1).max(100).default(100),
+
+    // Project affinity settings - pods from the same project prefer the same node
+    KUBERNETES_PROJECT_AFFINITY_ENABLED: BoolEnv.default(false),
+    KUBERNETES_PROJECT_AFFINITY_WEIGHT: z.coerce.number().int().min(1).max(100).default(50),
+    KUBERNETES_PROJECT_AFFINITY_TOPOLOGY_KEY: z
+      .string()
+      .trim()
+      .min(1)
+      .default("kubernetes.io/hostname"),
+
+    // Schedule affinity settings - runs from schedule trees prefer a dedicated pool
+    KUBERNETES_SCHEDULED_RUN_AFFINITY_ENABLED: BoolEnv.default(false),
+    KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_KEY: z
+      .string()
+      .trim()
+      .min(1)
+      .default("node.cluster.x-k8s.io/machinepool"),
+    KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_VALUE: z
+      .string()
+      .trim()
+      .min(1)
+      .default("scheduled-runs"),
+    KUBERNETES_SCHEDULED_RUN_AFFINITY_WEIGHT: z.coerce.number().int().min(1).max(100).default(80),
+    KUBERNETES_SCHEDULED_RUN_ANTI_AFFINITY_WEIGHT: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .default(20),
+
+    // Schedule toleration settings - scheduled runs tolerate taints on the dedicated pool
+    // Comma-separated list of tolerations in the format: key=value:effect
+    // For Exists operator (no value): key:effect
+    KUBERNETES_SCHEDULED_RUN_TOLERATIONS: z
+      .string()
+      .transform((val, ctx) => {
+        const tolerations = val
+          .split(",")
+          .map((entry) => entry.trim())
+          .filter((entry) => entry.length > 0)
+          .map((entry) => {
+            const colonIdx = entry.lastIndexOf(":");
+            if (colonIdx === -1) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Invalid toleration format (missing effect): "${entry}"`,
+              });
+              return z.NEVER;
+            }
+
+            const effect = entry.slice(colonIdx + 1);
+            const validEffects = ["NoSchedule", "NoExecute", "PreferNoSchedule"];
+            if (!validEffects.includes(effect)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Invalid toleration effect "${effect}" in "${entry}". Must be one of: ${validEffects.join(", ")}`,
+              });
+              return z.NEVER;
+            }
+
+            const keyValue = entry.slice(0, colonIdx);
+            const eqIdx = keyValue.indexOf("=");
+            const key = eqIdx === -1 ? keyValue : keyValue.slice(0, eqIdx);
+
+            if (!key) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Invalid toleration format (empty key): "${entry}"`,
+              });
+              return z.NEVER;
+            }
+
+            if (eqIdx === -1) {
+              return { key, operator: "Exists" as const, effect };
+            }
+
+            return {
+              key,
+              operator: "Equal" as const,
+              value: keyValue.slice(eqIdx + 1),
+              effect,
+            };
+          });
+
+        return tolerations;
+      })
+      .optional(),
+
+    // Placement tags settings
+    PLACEMENT_TAGS_ENABLED: BoolEnv.default(false),
+    PLACEMENT_TAGS_PREFIX: z.string().default("node.cluster.x-k8s.io"),
+
+    // Metrics
+    METRICS_ENABLED: BoolEnv.default(true),
+    METRICS_COLLECT_DEFAULTS: BoolEnv.default(true),
+    METRICS_HOST: z.string().default("127.0.0.1"),
+    METRICS_PORT: z.coerce.number().int().default(9090),
+
+    // Pod cleaner
+    POD_CLEANER_ENABLED: BoolEnv.default(true),
+    POD_CLEANER_INTERVAL_MS: z.coerce.number().int().default(10000),
+    POD_CLEANER_BATCH_SIZE: z.coerce.number().int().default(500),
+
+    // Failed pod handler
+    FAILED_POD_HANDLER_ENABLED: BoolEnv.default(true),
+    FAILED_POD_HANDLER_RECONNECT_INTERVAL_MS: z.coerce.number().int().default(1000),
+
+    // Debug
+    DEBUG: BoolEnv.default(false),
+    SEND_RUN_DEBUG_LOGS: BoolEnv.default(false),
+  })
+  .superRefine((data, ctx) => {
+    if (data.COMPUTE_SNAPSHOTS_ENABLED && !data.TRIGGER_METADATA_URL) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "TRIGGER_METADATA_URL is required when COMPUTE_SNAPSHOTS_ENABLED is true",
+        path: ["TRIGGER_METADATA_URL"],
+      });
+    }
+    if (data.COMPUTE_SNAPSHOTS_ENABLED && !data.TRIGGER_WORKLOAD_API_DOMAIN) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "TRIGGER_WORKLOAD_API_DOMAIN is required when COMPUTE_SNAPSHOTS_ENABLED is true",
+        path: ["TRIGGER_WORKLOAD_API_DOMAIN"],
+      });
+    }
+  })
+  .transform((data) => ({
+    ...data,
+    COMPUTE_TRACE_OTLP_ENDPOINT: data.COMPUTE_TRACE_OTLP_ENDPOINT ?? `${data.TRIGGER_API_URL}/otel`,
+  }));
 
 export const env = Env.parse(stdEnv);
diff --git a/apps/supervisor/src/index.ts b/apps/supervisor/src/index.ts
index 0e274b30390..6f5913c47ca 100644
--- a/apps/supervisor/src/index.ts
+++ b/apps/supervisor/src/index.ts
@@ -14,6 +14,7 @@ import {
 } from "./resourceMonitor.js";
 import { KubernetesWorkloadManager } from "./workloadManager/kubernetes.js";
 import { DockerWorkloadManager } from "./workloadManager/docker.js";
+import { ComputeWorkloadManager } from "./workloadManager/compute.js";
 import {
   HttpServer,
   CheckpointClient,
@@ -25,6 +26,8 @@ import { register } from "./metrics.js";
 import { PodCleaner } from "./services/podCleaner.js";
 import { FailedPodHandler } from "./services/failedPodHandler.js";
 import { getWorkerToken } from "./workerToken.js";
+import { OtlpTraceService } from "./services/otlpTraceService.js";
+import { extractTraceparent, getRestoreRunnerId } from "./util.js";
 
 if (env.METRICS_COLLECT_DEFAULTS) {
   collectDefaultMetrics({ register });
@@ -35,18 +38,25 @@ class ManagedSupervisor {
   private readonly metricsServer?: HttpServer;
   private readonly workloadServer: WorkloadServer;
   private readonly workloadManager: WorkloadManager;
+  private readonly computeManager?: ComputeWorkloadManager;
   private readonly logger = new SimpleStructuredLogger("managed-supervisor");
   private readonly resourceMonitor: ResourceMonitor;
   private readonly checkpointClient?: CheckpointClient;
 
   private readonly podCleaner?: PodCleaner;
   private readonly failedPodHandler?: FailedPodHandler;
+  private readonly tracing?: OtlpTraceService;
 
   private readonly isKubernetes = isKubernetesEnvironment(env.KUBERNETES_FORCE_ENABLED);
   private readonly warmStartUrl = env.TRIGGER_WARM_START_URL;
 
   constructor() {
-    const { TRIGGER_WORKER_TOKEN, MANAGED_WORKER_SECRET, ...envWithoutSecrets } = env;
+    const {
+      TRIGGER_WORKER_TOKEN,
+      MANAGED_WORKER_SECRET,
+      COMPUTE_GATEWAY_AUTH_TOKEN,
+      ...envWithoutSecrets
+    } = env;
 
     if (env.DEBUG) {
       this.logger.debug("Starting up", { envWithoutSecrets });
@@ -77,9 +87,46 @@ class ManagedSupervisor {
         : new DockerResourceMonitor(new Docker())
       : new NoopResourceMonitor();
 
-    this.workloadManager = this.isKubernetes
-      ? new KubernetesWorkloadManager(workloadManagerOptions)
-      : new DockerWorkloadManager(workloadManagerOptions);
+    if (env.COMPUTE_GATEWAY_URL) {
+      if (!env.TRIGGER_WORKLOAD_API_DOMAIN) {
+        throw new Error("TRIGGER_WORKLOAD_API_DOMAIN is not set, cannot create compute manager");
+      }
+
+      const callbackUrl = `${env.TRIGGER_WORKLOAD_API_PROTOCOL}://${env.TRIGGER_WORKLOAD_API_DOMAIN}:${env.TRIGGER_WORKLOAD_API_PORT_EXTERNAL}/api/v1/compute/snapshot-complete`;
+
+      if (env.COMPUTE_TRACE_SPANS_ENABLED) {
+        this.tracing = new OtlpTraceService({
+          endpointUrl: env.COMPUTE_TRACE_OTLP_ENDPOINT,
+        });
+      }
+
+      const computeManager = new ComputeWorkloadManager({
+        ...workloadManagerOptions,
+        gateway: {
+          url: env.COMPUTE_GATEWAY_URL,
+          authToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
+          timeoutMs: env.COMPUTE_GATEWAY_TIMEOUT_MS,
+        },
+        snapshots: {
+          enabled: env.COMPUTE_SNAPSHOTS_ENABLED,
+          delayMs: env.COMPUTE_SNAPSHOT_DELAY_MS,
+          dispatchLimit: env.COMPUTE_SNAPSHOT_DISPATCH_LIMIT,
+          callbackUrl,
+        },
+        tracing: this.tracing,
+        runner: {
+          instanceName: env.TRIGGER_WORKER_INSTANCE_NAME,
+          otelEndpoint: env.OTEL_EXPORTER_OTLP_ENDPOINT,
+          prettyLogs: env.RUNNER_PRETTY_LOGS,
+        },
+      });
+      this.computeManager = computeManager;
+      this.workloadManager = computeManager;
+    } else {
+      this.workloadManager = this.isKubernetes
+        ? new KubernetesWorkloadManager(workloadManagerOptions)
+        : new DockerWorkloadManager(workloadManagerOptions);
+    }
 
     if (this.isKubernetes) {
       if (env.POD_CLEANER_ENABLED) {
@@ -182,102 +229,161 @@ class ManagedSupervisor {
     }
 
     this.workerSession.on("runNotification", async ({ time, run }) => {
-      this.logger.log("runNotification", { time, run });
+      this.logger.verbose("runNotification", { time, run });
 
       this.workloadServer.notifyRun({ run });
     });
 
-    this.workerSession.on("runQueueMessage", async ({ time, message }) => {
-      this.logger.log(`Received message with timestamp ${time.toLocaleString()}`, message);
+    this.workerSession.on(
+      "runQueueMessage",
+      async ({ time, message, dequeueResponseMs, pollingIntervalMs }) => {
+        this.logger.verbose(`Received message with timestamp ${time.toLocaleString()}`, message);
 
-      if (message.completedWaitpoints.length > 0) {
-        this.logger.debug("Run has completed waitpoints", {
-          runId: message.run.id,
-          completedWaitpoints: message.completedWaitpoints.length,
-        });
-      }
-
-      if (!message.image) {
-        this.logger.error("Run has no image", { runId: message.run.id });
-        return;
-      }
-
-      const { checkpoint, ...rest } = message;
-
-      if (checkpoint) {
-        this.logger.log("Restoring run", { runId: message.run.id });
+        if (message.completedWaitpoints.length > 0) {
+          this.logger.debug("Run has completed waitpoints", {
+            runId: message.run.id,
+            completedWaitpoints: message.completedWaitpoints.length,
+          });
+        }
 
-        if (!this.checkpointClient) {
-          this.logger.error("No checkpoint client", { runId: message.run.id });
+        if (!message.image) {
+          this.logger.error("Run has no image", { runId: message.run.id });
           return;
         }
 
-        try {
-          const didRestore = await this.checkpointClient.restoreRun({
-            runFriendlyId: message.run.friendlyId,
-            snapshotFriendlyId: message.snapshot.friendlyId,
-            body: {
-              ...rest,
-              checkpoint,
-            },
-          });
-
-          if (didRestore) {
-            this.logger.log("Restore successful", { runId: message.run.id });
-          } else {
-            this.logger.error("Restore failed", { runId: message.run.id });
+        const { checkpoint, ...rest } = message;
+
+        // Register trace context early so snapshot spans work for all paths
+        // (cold create, restore, warm start). Re-registration on restore is safe
+        // since dequeue always provides fresh context.
+        if (this.computeManager?.traceSpansEnabled) {
+          const traceparent = extractTraceparent(message.run.traceContext);
+
+          if (traceparent) {
+            this.workloadServer.registerRunTraceContext(message.run.friendlyId, {
+              traceparent,
+              envId: message.environment.id,
+              orgId: message.organization.id,
+              projectId: message.project.id,
+            });
           }
-        } catch (error) {
-          this.logger.error("Failed to restore run", { error });
         }
 
-        return;
-      }
+        if (checkpoint) {
+          this.logger.debug("Restoring run", { runId: message.run.id });
+
+          if (this.computeManager) {
+            try {
+              const runnerId = getRestoreRunnerId(message.run.friendlyId, checkpoint.id);
+
+              const didRestore = await this.computeManager.restore({
+                snapshotId: checkpoint.location,
+                runnerId,
+                runFriendlyId: message.run.friendlyId,
+                snapshotFriendlyId: message.snapshot.friendlyId,
+                machine: message.run.machine,
+                traceContext: message.run.traceContext,
+                envId: message.environment.id,
+                orgId: message.organization.id,
+                projectId: message.project.id,
+                dequeuedAt: message.dequeuedAt,
+              });
+
+              if (didRestore) {
+                this.logger.debug("Compute restore successful", {
+                  runId: message.run.id,
+                  runnerId,
+                });
+              } else {
+                this.logger.error("Compute restore failed", { runId: message.run.id, runnerId });
+              }
+            } catch (error) {
+              this.logger.error("Failed to restore run (compute)", { error });
+            }
+
+            return;
+          }
+
+          if (!this.checkpointClient) {
+            this.logger.error("No checkpoint client", { runId: message.run.id });
+            return;
+          }
+
+          try {
+            const didRestore = await this.checkpointClient.restoreRun({
+              runFriendlyId: message.run.friendlyId,
+              snapshotFriendlyId: message.snapshot.friendlyId,
+              body: {
+                ...rest,
+                checkpoint,
+              },
+            });
+
+            if (didRestore) {
+              this.logger.debug("Restore successful", { runId: message.run.id });
+            } else {
+              this.logger.error("Restore failed", { runId: message.run.id });
+            }
+          } catch (error) {
+            this.logger.error("Failed to restore run", { error });
+          }
 
-      this.logger.log("Scheduling run", { runId: message.run.id });
+          return;
+        }
 
-      const didWarmStart = await this.tryWarmStart(message);
+        this.logger.debug("Scheduling run", { runId: message.run.id });
 
-      if (didWarmStart) {
-        this.logger.log("Warm start successful", { runId: message.run.id });
-        return;
-      }
+        const warmStartStart = performance.now();
+        const didWarmStart = await this.tryWarmStart(message);
+        const warmStartCheckMs = Math.round(performance.now() - warmStartStart);
 
-      try {
-        if (!message.deployment.friendlyId) {
-          // mostly a type guard, deployments always exists for deployed environments
-          // a proper fix would be to use a discriminated union schema to differentiate between dequeued runs in dev and in deployed environments.
-          throw new Error("Deployment is missing");
+        if (didWarmStart) {
+          this.logger.debug("Warm start successful", { runId: message.run.id });
+          return;
         }
 
-        await this.workloadManager.create({
-          dequeuedAt: message.dequeuedAt,
-          envId: message.environment.id,
-          envType: message.environment.type,
-          image: message.image,
-          machine: message.run.machine,
-          orgId: message.organization.id,
-          projectId: message.project.id,
-          deploymentFriendlyId: message.deployment.friendlyId,
-          deploymentVersion: message.backgroundWorker.version,
-          runId: message.run.id,
-          runFriendlyId: message.run.friendlyId,
-          version: message.version,
-          nextAttemptNumber: message.run.attemptNumber,
-          snapshotId: message.snapshot.id,
-          snapshotFriendlyId: message.snapshot.friendlyId,
-          placementTags: message.placementTags,
-        });
+        try {
+          if (!message.deployment.friendlyId) {
+            // mostly a type guard, deployments always exists for deployed environments
+            // a proper fix would be to use a discriminated union schema to differentiate between dequeued runs in dev and in deployed environments.
+            throw new Error("Deployment is missing");
+          }
 
-        // Disabled for now
-        // this.resourceMonitor.blockResources({
-        //   cpu: message.run.machine.cpu,
-        //   memory: message.run.machine.memory,
-        // });
-      } catch (error) {
-        this.logger.error("Failed to create workload", { error });
+          await this.workloadManager.create({
+            dequeuedAt: message.dequeuedAt,
+            dequeueResponseMs,
+            pollingIntervalMs,
+            warmStartCheckMs,
+            envId: message.environment.id,
+            envType: message.environment.type,
+            image: message.image,
+            machine: message.run.machine,
+            orgId: message.organization.id,
+            projectId: message.project.id,
+            deploymentFriendlyId: message.deployment.friendlyId,
+            deploymentVersion: message.backgroundWorker.version,
+            runId: message.run.id,
+            runFriendlyId: message.run.friendlyId,
+            version: message.version,
+            nextAttemptNumber: message.run.attemptNumber,
+            snapshotId: message.snapshot.id,
+            snapshotFriendlyId: message.snapshot.friendlyId,
+            placementTags: message.placementTags,
+            traceContext: message.run.traceContext,
+            annotations: message.run.annotations,
+            hasPrivateLink: message.organization.hasPrivateLink,
+          });
+
+          // Disabled for now
+          // this.resourceMonitor.blockResources({
+          //   cpu: message.run.machine.cpu,
+          //   memory: message.run.machine.memory,
+          // });
+        } catch (error) {
+          this.logger.error("Failed to create workload", { error });
+        }
       }
-    });
+    );
 
     if (env.METRICS_ENABLED) {
       this.metricsServer = new HttpServer({
@@ -296,6 +402,8 @@ class ManagedSupervisor {
       host: env.TRIGGER_WORKLOAD_API_HOST_INTERNAL,
       workerClient: this.workerSession.httpClient,
       checkpointClient: this.checkpointClient,
+      computeManager: this.computeManager,
+      tracing: this.tracing,
     });
 
     this.workloadServer.on("runConnected", this.onRunConnected.bind(this));
@@ -380,6 +488,7 @@ class ManagedSupervisor {
 
   async stop() {
     this.logger.log("Shutting down");
+    await this.workloadServer.stop();
     await this.workerSession.stop();
 
     // Optional services
diff --git a/apps/supervisor/src/services/computeSnapshotService.ts b/apps/supervisor/src/services/computeSnapshotService.ts
new file mode 100644
index 00000000000..7206f57fb73
--- /dev/null
+++ b/apps/supervisor/src/services/computeSnapshotService.ts
@@ -0,0 +1,240 @@
+import pLimit from "p-limit";
+import { SimpleStructuredLogger } from "@trigger.dev/core/v3/utils/structuredLogger";
+import { parseTraceparent } from "@trigger.dev/core/v3/isomorphic";
+import type { SupervisorHttpClient } from "@trigger.dev/core/v3/workers";
+import { type SnapshotCallbackPayload } from "@internal/compute";
+import type { ComputeWorkloadManager } from "../workloadManager/compute.js";
+import { TimerWheel } from "./timerWheel.js";
+import type { OtlpTraceService } from "./otlpTraceService.js";
+
+type DelayedSnapshot = {
+  runnerId: string;
+  runFriendlyId: string;
+  snapshotFriendlyId: string;
+};
+
+export type RunTraceContext = {
+  traceparent: string;
+  envId: string;
+  orgId: string;
+  projectId: string;
+};
+
+export type ComputeSnapshotServiceOptions = {
+  computeManager: ComputeWorkloadManager;
+  workerClient: SupervisorHttpClient;
+  tracing?: OtlpTraceService;
+};
+
+export class ComputeSnapshotService {
+  private readonly logger = new SimpleStructuredLogger("compute-snapshot-service");
+
+  private static readonly MAX_TRACE_CONTEXTS = 10_000;
+  private readonly runTraceContexts = new Map<string, RunTraceContext>();
+  private readonly timerWheel: TimerWheel<DelayedSnapshot>;
+  private readonly dispatchLimit: ReturnType<typeof pLimit>;
+
+  private readonly computeManager: ComputeWorkloadManager;
+  private readonly workerClient: SupervisorHttpClient;
+  private readonly tracing?: OtlpTraceService;
+
+  constructor(opts: ComputeSnapshotServiceOptions) {
+    this.computeManager = opts.computeManager;
+    this.workerClient = opts.workerClient;
+    this.tracing = opts.tracing;
+
+    this.dispatchLimit = pLimit(this.computeManager.snapshotDispatchLimit);
+    this.timerWheel = new TimerWheel<DelayedSnapshot>({
+      delayMs: this.computeManager.snapshotDelayMs,
+      onExpire: (item) => {
+        this.dispatchLimit(() => this.dispatch(item.data)).catch((error) => {
+          this.logger.error("Snapshot dispatch failed", {
+            runId: item.data.runFriendlyId,
+            runnerId: item.data.runnerId,
+            error,
+          });
+        });
+      },
+    });
+    this.timerWheel.start();
+  }
+
+  /** Schedule a delayed snapshot for a run. Replaces any pending snapshot for the same run. */
+  schedule(runFriendlyId: string, data: DelayedSnapshot) {
+    this.timerWheel.submit(runFriendlyId, data);
+    this.logger.debug("Snapshot scheduled", {
+      runFriendlyId,
+      snapshotFriendlyId: data.snapshotFriendlyId,
+      delayMs: this.computeManager.snapshotDelayMs,
+    });
+  }
+
+  /** Cancel a pending delayed snapshot. Returns true if one was cancelled. */
+  cancel(runFriendlyId: string): boolean {
+    const cancelled = this.timerWheel.cancel(runFriendlyId);
+    if (cancelled) {
+      this.logger.debug("Snapshot cancelled", { runFriendlyId });
+    }
+    return cancelled;
+  }
+
+  /** Handle the callback from the gateway after a snapshot completes or fails. */
+  async handleCallback(body: SnapshotCallbackPayload) {
+    this.logger.debug("Snapshot callback", {
+      snapshotId: body.snapshot_id,
+      instanceId: body.instance_id,
+      status: body.status,
+      error: body.error,
+      metadata: body.metadata,
+      durationMs: body.duration_ms,
+    });
+
+    const runId = body.metadata?.runId;
+    const snapshotFriendlyId = body.metadata?.snapshotFriendlyId;
+
+    if (!runId || !snapshotFriendlyId) {
+      this.logger.error("Snapshot callback missing metadata", { body });
+      return { ok: false as const, status: 400 };
+    }
+
+    this.#emitSnapshotSpan(runId, body.duration_ms, body.snapshot_id);
+
+    if (body.status === "completed") {
+      const result = await this.workerClient.submitSuspendCompletion({
+        runId,
+        snapshotId: snapshotFriendlyId,
+        body: {
+          success: true,
+          checkpoint: {
+            type: "COMPUTE",
+            location: body.snapshot_id,
+          },
+        },
+      });
+
+      if (result.success) {
+        this.logger.debug("Suspend completion submitted", {
+          runId,
+          instanceId: body.instance_id,
+          snapshotId: body.snapshot_id,
+        });
+      } else {
+        this.logger.error("Failed to submit suspend completion", {
+          runId,
+          snapshotFriendlyId,
+          error: result.error,
+        });
+      }
+    } else {
+      const result = await this.workerClient.submitSuspendCompletion({
+        runId,
+        snapshotId: snapshotFriendlyId,
+        body: {
+          success: false,
+          error: body.error ?? "Snapshot failed",
+        },
+      });
+
+      if (!result.success) {
+        this.logger.error("Failed to submit suspend failure", {
+          runId,
+          snapshotFriendlyId,
+          error: result.error,
+        });
+      }
+    }
+
+    return { ok: true as const, status: 200 };
+  }
+
+  registerTraceContext(runFriendlyId: string, ctx: RunTraceContext) {
+    // Evict oldest entries if we've hit the cap. This is best-effort: on a busy
+    // supervisor, entries for long-lived runs may be evicted before their snapshot
+    // callback arrives, causing those snapshot spans to be silently dropped.
+    // That's acceptable - trace spans are observability sugar, not correctness.
+    if (this.runTraceContexts.size >= ComputeSnapshotService.MAX_TRACE_CONTEXTS) {
+      const firstKey = this.runTraceContexts.keys().next().value;
+      if (firstKey) {
+        this.runTraceContexts.delete(firstKey);
+      }
+    }
+
+    this.runTraceContexts.set(runFriendlyId, ctx);
+  }
+
+  /** Stop the timer wheel, dropping pending snapshots. */
+  stop(): string[] {
+    // Intentionally drop pending snapshots rather than dispatching them. The supervisor
+    // is shutting down, so our callback URL will be dead by the time the gateway responds.
+    // Runners detect the supervisor is gone and reconnect to a new instance, which
+    // re-triggers the snapshot workflow. Snapshots are an optimization, not a correctness
+    // requirement - runs continue fine without them.
+    const remaining = this.timerWheel.stop();
+    const droppedRuns = remaining.map((item) => item.key);
+
+    if (droppedRuns.length > 0) {
+      this.logger.info("Stopped, dropped pending snapshots", { count: droppedRuns.length });
+      this.logger.debug("Dropped snapshot details", { runs: droppedRuns });
+    }
+
+    return droppedRuns;
+  }
+
+  /** Dispatch a snapshot request to the gateway. */
+  private async dispatch(snapshot: DelayedSnapshot): Promise<void> {
+    const result = await this.computeManager.snapshot({
+      runnerId: snapshot.runnerId,
+      metadata: {
+        runId: snapshot.runFriendlyId,
+        snapshotFriendlyId: snapshot.snapshotFriendlyId,
+      },
+    });
+
+    if (!result) {
+      this.logger.error("Failed to request snapshot", {
+        runId: snapshot.runFriendlyId,
+        runnerId: snapshot.runnerId,
+      });
+    }
+  }
+
+  #emitSnapshotSpan(runFriendlyId: string, durationMs?: number, snapshotId?: string) {
+    if (!this.tracing) return;
+
+    const ctx = this.runTraceContexts.get(runFriendlyId);
+    if (!ctx) return;
+
+    const parsed = parseTraceparent(ctx.traceparent);
+    if (!parsed) return;
+
+    const endEpochMs = Date.now();
+    const startEpochMs = durationMs ? endEpochMs - durationMs : endEpochMs;
+
+    const spanAttributes: Record<string, string | number | boolean> = {
+      "compute.type": "snapshot",
+    };
+
+    if (durationMs !== undefined) {
+      spanAttributes["compute.total_ms"] = durationMs;
+    }
+
+    if (snapshotId) {
+      spanAttributes["compute.snapshot_id"] = snapshotId;
+    }
+
+    this.tracing.emit({
+      traceId: parsed.traceId,
+      parentSpanId: parsed.spanId,
+      spanName: "compute.snapshot",
+      startTimeMs: startEpochMs,
+      endTimeMs: endEpochMs,
+      resourceAttributes: {
+        "ctx.environment.id": ctx.envId,
+        "ctx.organization.id": ctx.orgId,
+        "ctx.project.id": ctx.projectId,
+        "ctx.run.id": runFriendlyId,
+      },
+      spanAttributes,
+    });
+  }
+}
diff --git a/apps/supervisor/src/services/failedPodHandler.test.ts b/apps/supervisor/src/services/failedPodHandler.test.ts
index d05783288ed..4dbfda16f43 100644
--- a/apps/supervisor/src/services/failedPodHandler.test.ts
+++ b/apps/supervisor/src/services/failedPodHandler.test.ts
@@ -1,10 +1,11 @@
 import { describe, it, expect, beforeAll, afterEach } from "vitest";
 import { FailedPodHandler } from "./failedPodHandler.js";
-import { K8sApi, createK8sApi } from "../clients/kubernetes.js";
+import { type K8sApi, createK8sApi } from "../clients/kubernetes.js";
 import { Registry } from "prom-client";
 import { setTimeout } from "timers/promises";
 
-describe("FailedPodHandler Integration Tests", () => {
+// These tests require live K8s cluster credentials - skip by default
+describe.skipIf(!process.env.K8S_INTEGRATION_TESTS)("FailedPodHandler Integration Tests", () => {
   const k8s = createK8sApi();
   const namespace = "integration-test";
   const register = new Registry();
diff --git a/apps/supervisor/src/services/failedPodHandler.ts b/apps/supervisor/src/services/failedPodHandler.ts
index 07217243769..3d56c92b213 100644
--- a/apps/supervisor/src/services/failedPodHandler.ts
+++ b/apps/supervisor/src/services/failedPodHandler.ts
@@ -151,7 +151,7 @@ export class FailedPodHandler {
   }
 
   private async onPodCompleted(pod: V1Pod) {
-    this.logger.info("pod-completed", this.podSummary(pod));
+    this.logger.debug("pod-completed", this.podSummary(pod));
     this.informerEventsTotal.inc({ namespace: this.namespace, verb: "add" });
 
     if (!pod.metadata?.name) {
@@ -165,7 +165,7 @@ export class FailedPodHandler {
     }
 
     if (pod.metadata?.deletionTimestamp) {
-      this.logger.info("pod-completed: pod is being deleted", this.podSummary(pod));
+      this.logger.verbose("pod-completed: pod is being deleted", this.podSummary(pod));
       return;
     }
 
@@ -188,7 +188,7 @@ export class FailedPodHandler {
   }
 
   private async onPodSucceeded(pod: V1Pod) {
-    this.logger.info("pod-succeeded", this.podSummary(pod));
+    this.logger.debug("pod-succeeded", this.podSummary(pod));
     this.processedPodsTotal.inc({
       namespace: this.namespace,
       status: this.podStatus(pod),
@@ -196,7 +196,7 @@ export class FailedPodHandler {
   }
 
   private async onPodFailed(pod: V1Pod) {
-    this.logger.info("pod-failed", this.podSummary(pod));
+    this.logger.debug("pod-failed", this.podSummary(pod));
 
     try {
       await this.processFailedPod(pod);
@@ -208,7 +208,7 @@ export class FailedPodHandler {
   }
 
   private async processFailedPod(pod: V1Pod) {
-    this.logger.info("pod-failed: processing pod", this.podSummary(pod));
+    this.logger.verbose("pod-failed: processing pod", this.podSummary(pod));
 
     const mainContainer = pod.status?.containerStatuses?.find((c) => c.name === "run-controller");
 
@@ -231,7 +231,7 @@ export class FailedPodHandler {
   }
 
   private async deletePod(pod: V1Pod) {
-    this.logger.info("pod-failed: deleting pod", this.podSummary(pod));
+    this.logger.verbose("pod-failed: deleting pod", this.podSummary(pod));
     try {
       await this.k8s.core.deleteNamespacedPod({
         name: pod.metadata!.name!,
diff --git a/apps/supervisor/src/services/otlpTraceService.test.ts b/apps/supervisor/src/services/otlpTraceService.test.ts
new file mode 100644
index 00000000000..baf3bd90306
--- /dev/null
+++ b/apps/supervisor/src/services/otlpTraceService.test.ts
@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+import { buildPayload } from "./otlpTraceService.js";
+
+describe("buildPayload", () => {
+  it("builds valid OTLP JSON with timing attributes", () => {
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      parentSpanId: "1234567890abcdef",
+      spanName: "compute.provision",
+      startTimeMs: 1000,
+      endTimeMs: 1250,
+      resourceAttributes: {
+        "ctx.environment.id": "env_123",
+        "ctx.organization.id": "org_456",
+        "ctx.project.id": "proj_789",
+        "ctx.run.id": "run_abc",
+      },
+      spanAttributes: {
+        "compute.total_ms": 250,
+        "compute.gateway.schedule_ms": 1,
+        "compute.cache.image_cached": true,
+      },
+    });
+
+    expect(payload.resourceSpans).toHaveLength(1);
+
+    const resourceSpan = payload.resourceSpans[0]!;
+
+    // $trigger=true so the webapp accepts it
+    const triggerAttr = resourceSpan.resource.attributes.find((a) => a.key === "$trigger");
+    expect(triggerAttr).toEqual({ key: "$trigger", value: { boolValue: true } });
+
+    // Resource attributes
+    const envAttr = resourceSpan.resource.attributes.find(
+      (a) => a.key === "ctx.environment.id"
+    );
+    expect(envAttr).toEqual({
+      key: "ctx.environment.id",
+      value: { stringValue: "env_123" },
+    });
+
+    // Span basics
+    const span = resourceSpan.scopeSpans[0]!.spans[0]!;
+    expect(span.name).toBe("compute.provision");
+    expect(span.traceId).toBe("abcd1234abcd1234abcd1234abcd1234");
+    expect(span.parentSpanId).toBe("1234567890abcdef");
+
+    // Integer attribute
+    const totalMs = span.attributes.find((a) => a.key === "compute.total_ms");
+    expect(totalMs).toEqual({ key: "compute.total_ms", value: { intValue: 250 } });
+
+    // Boolean attribute
+    const cached = span.attributes.find((a) => a.key === "compute.cache.image_cached");
+    expect(cached).toEqual({ key: "compute.cache.image_cached", value: { boolValue: true } });
+  });
+
+  it("generates a valid 16-char hex span ID", () => {
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: 1000,
+      endTimeMs: 1001,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    expect(span.spanId).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  it("converts timestamps to nanoseconds", () => {
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: 1000,
+      endTimeMs: 1250,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    expect(span.startTimeUnixNano).toBe("1000000000");
+    expect(span.endTimeUnixNano).toBe("1250000000");
+  });
+
+  it("converts real epoch timestamps without precision loss", () => {
+    // Date.now() values exceed Number.MAX_SAFE_INTEGER when multiplied by 1e6
+    const startMs = 1711929600000; // 2024-04-01T00:00:00Z
+    const endMs = 1711929600250;
+
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: startMs,
+      endTimeMs: endMs,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    expect(span.startTimeUnixNano).toBe("1711929600000000000");
+    expect(span.endTimeUnixNano).toBe("1711929600250000000");
+  });
+
+  it("preserves sub-millisecond precision from performance.now() arithmetic", () => {
+    // provisionStartEpochMs = Date.now() - (performance.now() - startMs) produces fractional ms.
+    // Use small epoch + fraction to avoid IEEE 754 noise in the fractional part.
+    const startMs = 1000.322;
+    const endMs = 1045.789;
+
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: startMs,
+      endTimeMs: endMs,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    expect(span.startTimeUnixNano).toBe("1000322000");
+    expect(span.endTimeUnixNano).toBe("1045789000");
+  });
+
+  it("sub-ms precision affects ordering for real epoch values", () => {
+    // Two spans within the same millisecond should have different nanosecond timestamps
+    const spanA = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "a",
+      startTimeMs: 1711929600000.3,
+      endTimeMs: 1711929600001,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const spanB = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "b",
+      startTimeMs: 1711929600000.7,
+      endTimeMs: 1711929600001,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const startA = BigInt(spanA.resourceSpans[0]!.scopeSpans[0]!.spans[0]!.startTimeUnixNano);
+    const startB = BigInt(spanB.resourceSpans[0]!.scopeSpans[0]!.spans[0]!.startTimeUnixNano);
+    // A should sort before B (both in the same ms but different sub-ms positions)
+    expect(startA).toBeLessThan(startB);
+  });
+
+  it("omits parentSpanId when not provided", () => {
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: 1000,
+      endTimeMs: 1001,
+      resourceAttributes: {},
+      spanAttributes: {},
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    expect(span.parentSpanId).toBeUndefined();
+  });
+
+  it("handles double values for non-integer numbers", () => {
+    const payload = buildPayload({
+      traceId: "abcd1234abcd1234abcd1234abcd1234",
+      spanName: "test",
+      startTimeMs: 1000,
+      endTimeMs: 1001,
+      resourceAttributes: {},
+      spanAttributes: { "compute.cpu": 0.25 },
+    });
+
+    const span = payload.resourceSpans[0]!.scopeSpans[0]!.spans[0]!;
+    const cpu = span.attributes.find((a) => a.key === "compute.cpu");
+    expect(cpu).toEqual({ key: "compute.cpu", value: { doubleValue: 0.25 } });
+  });
+});
diff --git a/apps/supervisor/src/services/otlpTraceService.ts b/apps/supervisor/src/services/otlpTraceService.ts
new file mode 100644
index 00000000000..da3310711d0
--- /dev/null
+++ b/apps/supervisor/src/services/otlpTraceService.ts
@@ -0,0 +1,104 @@
+import { randomBytes } from "crypto";
+import { SimpleStructuredLogger } from "@trigger.dev/core/v3/utils/structuredLogger";
+
+export type OtlpTraceServiceOptions = {
+  endpointUrl: string;
+  timeoutMs?: number;
+};
+
+export type OtlpTraceSpan = {
+  traceId: string;
+  parentSpanId?: string;
+  spanName: string;
+  startTimeMs: number;
+  endTimeMs: number;
+  resourceAttributes: Record<string, string | number | boolean>;
+  spanAttributes: Record<string, string | number | boolean>;
+};
+
+export class OtlpTraceService {
+  private readonly logger = new SimpleStructuredLogger("otlp-trace");
+
+  constructor(private opts: OtlpTraceServiceOptions) {}
+
+  /** Fire-and-forget: build payload and send to the configured OTLP endpoint */
+  emit(span: OtlpTraceSpan): void {
+    const payload = buildPayload(span);
+
+    fetch(`${this.opts.endpointUrl}/v1/traces`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5_000),
+    }).catch((err) => {
+      this.logger.warn("failed to send compute trace span", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+    });
+  }
+}
+
+// ── Payload builder (internal) ───────────────────────────────────────────────
+
+/** @internal Exported for tests only */
+export function buildPayload(span: OtlpTraceSpan) {
+  const spanId = randomBytes(8).toString("hex");
+
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [
+            { key: "$trigger", value: { boolValue: true } },
+            ...toOtlpAttributes(span.resourceAttributes),
+          ],
+        },
+        scopeSpans: [
+          {
+            scope: { name: "supervisor.compute" },
+            spans: [
+              {
+                traceId: span.traceId,
+                spanId,
+                parentSpanId: span.parentSpanId,
+                name: span.spanName,
+                kind: 3, // SPAN_KIND_CLIENT
+                startTimeUnixNano: msToNano(span.startTimeMs),
+                endTimeUnixNano: msToNano(span.endTimeMs),
+                attributes: toOtlpAttributes(span.spanAttributes),
+                status: { code: 1 }, // STATUS_CODE_OK
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function toOtlpAttributes(
+  attrs: Record<string, string | number | boolean>
+): Array<{ key: string; value: Record<string, unknown> }> {
+  return Object.entries(attrs).map(([key, value]) => ({
+    key,
+    value: toOtlpValue(value),
+  }));
+}
+
+function toOtlpValue(value: string | number | boolean): Record<string, unknown> {
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Number.isInteger(value)) return { intValue: value };
+  return { doubleValue: value };
+}
+
+/**
+ * Convert epoch milliseconds to nanosecond string, preserving sub-ms precision.
+ * Fractional ms from performance.now() arithmetic carry meaningful microsecond
+ * data that affects span sort ordering when events happen within the same ms.
+ */
+function msToNano(ms: number): string {
+  const wholeMs = Math.trunc(ms);
+  const fracNs = Math.round((ms - wholeMs) * 1_000_000);
+  return String(BigInt(wholeMs) * 1_000_000n + BigInt(fracNs));
+}
diff --git a/apps/supervisor/src/services/podCleaner.test.ts b/apps/supervisor/src/services/podCleaner.test.ts
index 36bb5de6d1f..d6ed2bb737f 100644
--- a/apps/supervisor/src/services/podCleaner.test.ts
+++ b/apps/supervisor/src/services/podCleaner.test.ts
@@ -1,10 +1,11 @@
 import { PodCleaner } from "./podCleaner.js";
-import { K8sApi, createK8sApi } from "../clients/kubernetes.js";
+import { type K8sApi, createK8sApi } from "../clients/kubernetes.js";
 import { setTimeout } from "timers/promises";
 import { describe, it, expect, beforeAll, afterEach } from "vitest";
 import { Registry } from "prom-client";
 
-describe("PodCleaner Integration Tests", () => {
+// These tests require live K8s cluster credentials - skip by default
+describe.skipIf(!process.env.K8S_INTEGRATION_TESTS)("PodCleaner Integration Tests", () => {
   const k8s = createK8sApi();
   const namespace = "integration-test";
   const register = new Registry();
diff --git a/apps/supervisor/src/services/podCleaner.ts b/apps/supervisor/src/services/podCleaner.ts
index 56eaaeb88af..3ac5da293df 100644
--- a/apps/supervisor/src/services/podCleaner.ts
+++ b/apps/supervisor/src/services/podCleaner.ts
@@ -90,7 +90,7 @@ export class PodCleaner {
           status: "succeeded",
         });
 
-        this.logger.info("Deleted batch of pods", { continuationToken });
+        this.logger.debug("Deleted batch of pods", { continuationToken });
       } catch (err) {
         this.logger.error("Failed to delete batch of pods", {
           err: err instanceof Error ? err.message : String(err),
diff --git a/apps/supervisor/src/services/timerWheel.test.ts b/apps/supervisor/src/services/timerWheel.test.ts
new file mode 100644
index 00000000000..3f6bb9aa19b
--- /dev/null
+++ b/apps/supervisor/src/services/timerWheel.test.ts
@@ -0,0 +1,254 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { TimerWheel } from "./timerWheel.js";
+
+describe("TimerWheel", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("dispatches item after delay", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "snapshot-data");
+
+    // Not yet
+    vi.advanceTimersByTime(2900);
+    expect(dispatched).toEqual([]);
+
+    // After delay
+    vi.advanceTimersByTime(200);
+    expect(dispatched).toEqual(["run-1"]);
+
+    wheel.stop();
+  });
+
+  it("cancels item before it fires", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "data");
+
+    vi.advanceTimersByTime(1000);
+    expect(wheel.cancel("run-1")).toBe(true);
+
+    vi.advanceTimersByTime(5000);
+    expect(dispatched).toEqual([]);
+    expect(wheel.size).toBe(0);
+
+    wheel.stop();
+  });
+
+  it("cancel returns false for unknown key", () => {
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: () => {},
+    });
+    expect(wheel.cancel("nonexistent")).toBe(false);
+  });
+
+  it("deduplicates: resubmitting same key replaces the entry", () => {
+    const dispatched: { key: string; data: string }[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push({ key: item.key, data: item.data }),
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "old-data");
+
+    vi.advanceTimersByTime(1000);
+    wheel.submit("run-1", "new-data");
+
+    // Original would have fired at t=3000, but was replaced
+    // New one fires at t=1000+3000=4000
+    vi.advanceTimersByTime(2100);
+    expect(dispatched).toEqual([]);
+
+    vi.advanceTimersByTime(1000);
+    expect(dispatched).toEqual([{ key: "run-1", data: "new-data" }]);
+
+    wheel.stop();
+  });
+
+  it("handles many concurrent items", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+
+    for (let i = 0; i < 1000; i++) {
+      wheel.submit(`run-${i}`, `data-${i}`);
+    }
+    expect(wheel.size).toBe(1000);
+
+    vi.advanceTimersByTime(3100);
+    expect(dispatched.length).toBe(1000);
+    expect(wheel.size).toBe(0);
+
+    wheel.stop();
+  });
+
+  it("handles items submitted at different times", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+
+    wheel.submit("run-1", "data");
+    vi.advanceTimersByTime(1000);
+    wheel.submit("run-2", "data");
+    vi.advanceTimersByTime(1000);
+    wheel.submit("run-3", "data");
+
+    // t=2000: nothing yet
+    expect(dispatched).toEqual([]);
+
+    // t=3100: run-1 fires
+    vi.advanceTimersByTime(1100);
+    expect(dispatched).toEqual(["run-1"]);
+
+    // t=4100: run-2 fires
+    vi.advanceTimersByTime(1000);
+    expect(dispatched).toEqual(["run-1", "run-2"]);
+
+    // t=5100: run-3 fires
+    vi.advanceTimersByTime(1000);
+    expect(dispatched).toEqual(["run-1", "run-2", "run-3"]);
+
+    wheel.stop();
+  });
+
+  it("setDelay changes delay for new items only", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+
+    wheel.submit("run-1", "data"); // 3s delay
+
+    vi.advanceTimersByTime(500);
+    wheel.setDelay(1000);
+    wheel.submit("run-2", "data"); // 1s delay
+
+    // t=1500: run-2 should have fired (submitted at t=500 with 1s delay)
+    vi.advanceTimersByTime(1100);
+    expect(dispatched).toEqual(["run-2"]);
+
+    // t=3100: run-1 fires at its original 3s delay
+    vi.advanceTimersByTime(1500);
+    expect(dispatched).toEqual(["run-2", "run-1"]);
+
+    wheel.stop();
+  });
+
+  it("stop returns unprocessed items", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "data-1");
+    wheel.submit("run-2", "data-2");
+    wheel.submit("run-3", "data-3");
+
+    const remaining = wheel.stop();
+    expect(dispatched).toEqual([]);
+    expect(wheel.size).toBe(0);
+    expect(remaining.length).toBe(3);
+    expect(remaining.map((r) => r.key).sort()).toEqual(["run-1", "run-2", "run-3"]);
+    expect(remaining.find((r) => r.key === "run-1")?.data).toBe("data-1");
+  });
+
+  it("after stop, new submissions are silently dropped", () => {
+    const dispatched: string[] = [];
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+    wheel.stop();
+
+    wheel.submit("run-late", "data");
+    expect(dispatched).toEqual([]);
+    expect(wheel.size).toBe(0);
+  });
+
+  it("tracks size correctly through submit/cancel/dispatch", () => {
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: () => {},
+    });
+
+    wheel.start();
+
+    wheel.submit("a", "data");
+    wheel.submit("b", "data");
+    expect(wheel.size).toBe(2);
+
+    wheel.cancel("a");
+    expect(wheel.size).toBe(1);
+
+    vi.advanceTimersByTime(3100);
+    expect(wheel.size).toBe(0);
+
+    wheel.stop();
+  });
+
+  it("clamps delay to valid range", () => {
+    const dispatched: string[] = [];
+
+    // Very small delay (should be at least 1 tick = 100ms)
+    const wheel = new TimerWheel<string>({
+      delayMs: 0,
+      onExpire: (item) => dispatched.push(item.key),
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "data");
+
+    vi.advanceTimersByTime(200);
+    expect(dispatched).toEqual(["run-1"]);
+
+    wheel.stop();
+  });
+
+  it("multiple cancel calls are safe", () => {
+    const wheel = new TimerWheel<string>({
+      delayMs: 3000,
+      onExpire: () => {},
+    });
+
+    wheel.start();
+    wheel.submit("run-1", "data");
+
+    expect(wheel.cancel("run-1")).toBe(true);
+    expect(wheel.cancel("run-1")).toBe(false);
+
+    wheel.stop();
+  });
+});
diff --git a/apps/supervisor/src/services/timerWheel.ts b/apps/supervisor/src/services/timerWheel.ts
new file mode 100644
index 00000000000..9584423824d
--- /dev/null
+++ b/apps/supervisor/src/services/timerWheel.ts
@@ -0,0 +1,160 @@
+/**
+ * TimerWheel implements a hashed timer wheel for efficiently managing large numbers
+ * of delayed operations with O(1) submit, cancel, and per-item dispatch.
+ *
+ * Used by the supervisor to delay snapshot requests so that short-lived waitpoints
+ * (e.g. triggerAndWait that resolves in <3s) skip the snapshot entirely.
+ *
+ * The wheel is a ring buffer of slots. A single setInterval advances a cursor.
+ * When the cursor reaches a slot, all items in that slot are dispatched.
+ *
+ * Fixed capacity: 600 slots at 100ms tick = 60s max delay.
+ */
+
+const TICK_MS = 100;
+const NUM_SLOTS = 600; // 60s max delay at 100ms tick
+
+export type TimerWheelItem<T> = {
+  key: string;
+  data: T;
+};
+
+export type TimerWheelOptions<T> = {
+  /** Called when an item's delay expires. */
+  onExpire: (item: TimerWheelItem<T>) => void;
+  /** Delay in milliseconds before items fire. Clamped to [100, 60000]. */
+  delayMs: number;
+};
+
+type Entry<T> = {
+  key: string;
+  data: T;
+  slotIndex: number;
+};
+
+export class TimerWheel<T> {
+  private slots: Set<string>[];
+  private entries: Map<string, Entry<T>>;
+  private cursor: number;
+  private intervalId: ReturnType<typeof setInterval> | null;
+  private onExpire: (item: TimerWheelItem<T>) => void;
+  private delaySlots: number;
+
+  constructor(opts: TimerWheelOptions<T>) {
+    this.slots = Array.from({ length: NUM_SLOTS }, () => new Set());
+    this.entries = new Map();
+    this.cursor = 0;
+    this.intervalId = null;
+    this.onExpire = opts.onExpire;
+    this.delaySlots = Math.max(1, Math.min(NUM_SLOTS, Math.ceil(opts.delayMs / TICK_MS)));
+  }
+
+  /** Start the timer wheel. Must be called before submitting items. */
+  start(): void {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(() => this.tick(), TICK_MS);
+    // Don't hold the process open just for the timer wheel
+    if (this.intervalId && typeof this.intervalId === "object" && "unref" in this.intervalId) {
+      this.intervalId.unref();
+    }
+  }
+
+  /**
+   * Stop the timer wheel and return all unprocessed items.
+   * The wheel keeps running normally during graceful shutdown - call stop()
+   * only when you're ready to tear down. Caller decides what to do with leftovers.
+   */
+  stop(): TimerWheelItem<T>[] {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+
+    const remaining: TimerWheelItem<T>[] = [];
+    for (const [key, entry] of this.entries) {
+      remaining.push({ key, data: entry.data });
+    }
+
+    for (const slot of this.slots) {
+      slot.clear();
+    }
+    this.entries.clear();
+
+    return remaining;
+  }
+
+  /**
+   * Update the delay for future submissions. Already-queued items keep their original timing.
+   * Clamped to [TICK_MS, 60000ms].
+   */
+  setDelay(delayMs: number): void {
+    this.delaySlots = Math.max(1, Math.min(NUM_SLOTS, Math.ceil(delayMs / TICK_MS)));
+  }
+
+  /**
+   * Submit an item to be dispatched after the configured delay.
+   * If an item with the same key already exists, it is replaced (dedup).
+   * No-op if the wheel is stopped.
+   */
+  submit(key: string, data: T): void {
+    if (!this.intervalId) return;
+
+    // Dedup: remove existing entry for this key
+    this.cancel(key);
+
+    const slotIndex = (this.cursor + this.delaySlots) % NUM_SLOTS;
+    const entry: Entry<T> = { key, data, slotIndex };
+
+    this.entries.set(key, entry);
+    this.slot(slotIndex).add(key);
+  }
+
+  /**
+   * Cancel a pending item. Returns true if the item was found and removed.
+   */
+  cancel(key: string): boolean {
+    const entry = this.entries.get(key);
+    if (!entry) return false;
+
+    this.slot(entry.slotIndex).delete(key);
+    this.entries.delete(key);
+    return true;
+  }
+
+  /** Number of pending items in the wheel. */
+  get size(): number {
+    return this.entries.size;
+  }
+
+  /** Whether the wheel is running. */
+  get running(): boolean {
+    return this.intervalId !== null;
+  }
+
+  /** Get a slot by index. The array is fully initialized so this always returns a Set. */
+  private slot(index: number): Set<string> {
+    const s = this.slots[index];
+    if (!s) throw new Error(`TimerWheel: invalid slot index ${index}`);
+    return s;
+  }
+
+  /** Advance the cursor and dispatch all items in the current slot. */
+  private tick(): void {
+    this.cursor = (this.cursor + 1) % NUM_SLOTS;
+    const slot = this.slot(this.cursor);
+
+    if (slot.size === 0) return;
+
+    // Collect items to dispatch (copy keys since we mutate during iteration)
+    const keys = [...slot];
+    slot.clear();
+
+    for (const key of keys) {
+      const entry = this.entries.get(key);
+      if (!entry) continue;
+
+      this.entries.delete(key);
+      this.onExpire({ key, data: entry.data });
+    }
+  }
+}
diff --git a/apps/supervisor/src/util.ts b/apps/supervisor/src/util.ts
index 4fcda27b2aa..d14dd99bfe1 100644
--- a/apps/supervisor/src/util.ts
+++ b/apps/supervisor/src/util.ts
@@ -14,6 +14,18 @@ export function getDockerHostDomain() {
   return isMacOS || isWindows ? "host.docker.internal" : "localhost";
 }
 
+/** Extract the W3C traceparent string from an untyped trace context record */
+export function extractTraceparent(traceContext?: Record<string, unknown>): string | undefined {
+  if (
+    traceContext &&
+    "traceparent" in traceContext &&
+    typeof traceContext.traceparent === "string"
+  ) {
+    return traceContext.traceparent;
+  }
+  return undefined;
+}
+
 export function getRunnerId(runId: string, attemptNumber?: number) {
   const parts = ["runner", runId.replace("run_", "")];
 
@@ -23,3 +35,10 @@ export function getRunnerId(runId: string, attemptNumber?: number) {
 
   return parts.join("-");
 }
+
+/** Derive a unique runnerId for a restore cycle using the checkpoint suffix */
+export function getRestoreRunnerId(runFriendlyId: string, checkpointId: string) {
+  const runIdShort = runFriendlyId.replace("run_", "");
+  const checkpointSuffix = checkpointId.slice(-8);
+  return `runner-${runIdShort}-${checkpointSuffix}`;
+}
diff --git a/apps/supervisor/src/workloadManager/compute.ts b/apps/supervisor/src/workloadManager/compute.ts
new file mode 100644
index 00000000000..1c00f33aad3
--- /dev/null
+++ b/apps/supervisor/src/workloadManager/compute.ts
@@ -0,0 +1,374 @@
+import { SimpleStructuredLogger } from "@trigger.dev/core/v3/utils/structuredLogger";
+import { parseTraceparent } from "@trigger.dev/core/v3/isomorphic";
+import { flattenAttributes } from "@trigger.dev/core/v3/utils/flattenAttributes";
+import {
+  type WorkloadManager,
+  type WorkloadManagerCreateOptions,
+  type WorkloadManagerOptions,
+} from "./types.js";
+import { ComputeClient, stripImageDigest } from "@internal/compute";
+import { extractTraceparent, getRunnerId } from "../util.js";
+import type { OtlpTraceService } from "../services/otlpTraceService.js";
+import { tryCatch } from "@trigger.dev/core";
+
+type ComputeWorkloadManagerOptions = WorkloadManagerOptions & {
+  gateway: {
+    url: string;
+    authToken?: string;
+    timeoutMs: number;
+  };
+  snapshots: {
+    enabled: boolean;
+    delayMs: number;
+    dispatchLimit: number;
+    callbackUrl: string;
+  };
+  tracing?: OtlpTraceService;
+  runner: {
+    instanceName: string;
+    otelEndpoint: string;
+    prettyLogs: boolean;
+  };
+};
+
+export class ComputeWorkloadManager implements WorkloadManager {
+  private readonly logger = new SimpleStructuredLogger("compute-workload-manager");
+  private readonly compute: ComputeClient;
+
+  constructor(private opts: ComputeWorkloadManagerOptions) {
+    if (opts.workloadApiDomain) {
+      this.logger.warn("⚠️ Custom workload API domain", {
+        domain: opts.workloadApiDomain,
+      });
+    }
+
+    this.compute = new ComputeClient({
+      gatewayUrl: opts.gateway.url,
+      authToken: opts.gateway.authToken,
+      timeoutMs: opts.gateway.timeoutMs,
+    });
+  }
+
+  get snapshotsEnabled(): boolean {
+    return this.opts.snapshots.enabled;
+  }
+
+  get snapshotDelayMs(): number {
+    return this.opts.snapshots.delayMs;
+  }
+
+  get snapshotDispatchLimit(): number {
+    return this.opts.snapshots.dispatchLimit;
+  }
+
+  get traceSpansEnabled(): boolean {
+    return !!this.opts.tracing;
+  }
+
+  async create(opts: WorkloadManagerCreateOptions) {
+    const runnerId = getRunnerId(opts.runFriendlyId, opts.nextAttemptNumber);
+
+    const envVars: Record<string, string> = {
+      OTEL_EXPORTER_OTLP_ENDPOINT: this.opts.runner.otelEndpoint,
+      TRIGGER_DEQUEUED_AT_MS: String(opts.dequeuedAt.getTime()),
+      TRIGGER_POD_SCHEDULED_AT_MS: String(Date.now()),
+      TRIGGER_ENV_ID: opts.envId,
+      TRIGGER_DEPLOYMENT_ID: opts.deploymentFriendlyId,
+      TRIGGER_DEPLOYMENT_VERSION: opts.deploymentVersion,
+      TRIGGER_RUN_ID: opts.runFriendlyId,
+      TRIGGER_SNAPSHOT_ID: opts.snapshotFriendlyId,
+      TRIGGER_SUPERVISOR_API_PROTOCOL: this.opts.workloadApiProtocol,
+      TRIGGER_SUPERVISOR_API_PORT: String(this.opts.workloadApiPort),
+      TRIGGER_SUPERVISOR_API_DOMAIN: this.opts.workloadApiDomain ?? "",
+      TRIGGER_WORKER_INSTANCE_NAME: this.opts.runner.instanceName,
+      TRIGGER_RUNNER_ID: runnerId,
+      TRIGGER_MACHINE_CPU: String(opts.machine.cpu),
+      TRIGGER_MACHINE_MEMORY: String(opts.machine.memory),
+      PRETTY_LOGS: String(this.opts.runner.prettyLogs),
+    };
+
+    if (this.opts.warmStartUrl) {
+      envVars.TRIGGER_WARM_START_URL = this.opts.warmStartUrl;
+    }
+
+    if (this.snapshotsEnabled && this.opts.metadataUrl) {
+      envVars.TRIGGER_METADATA_URL = this.opts.metadataUrl;
+    }
+
+    if (this.opts.heartbeatIntervalSeconds) {
+      envVars.TRIGGER_HEARTBEAT_INTERVAL_SECONDS = String(this.opts.heartbeatIntervalSeconds);
+    }
+
+    if (this.opts.snapshotPollIntervalSeconds) {
+      envVars.TRIGGER_SNAPSHOT_POLL_INTERVAL_SECONDS = String(
+        this.opts.snapshotPollIntervalSeconds
+      );
+    }
+
+    if (this.opts.additionalEnvVars) {
+      Object.assign(envVars, this.opts.additionalEnvVars);
+    }
+
+    // Strip image digest - resolve by tag, not digest
+    const imageRef = stripImageDigest(opts.image);
+
+    // Wide event: single canonical log line emitted in finally
+    const event: Record<string, unknown> = {
+      // High-cardinality identifiers
+      runId: opts.runFriendlyId,
+      runnerId,
+      envId: opts.envId,
+      envType: opts.envType,
+      orgId: opts.orgId,
+      projectId: opts.projectId,
+      deploymentVersion: opts.deploymentVersion,
+      machine: opts.machine.name,
+      // Environment
+      instanceName: this.opts.runner.instanceName,
+      // Supervisor timing
+      dequeueResponseMs: opts.dequeueResponseMs,
+      pollingIntervalMs: opts.pollingIntervalMs,
+      warmStartCheckMs: opts.warmStartCheckMs,
+      // Request
+      image: imageRef,
+    };
+
+    const startMs = performance.now();
+
+    try {
+      const [error, data] = await tryCatch(
+        this.compute.instances.create({
+          name: runnerId,
+          image: imageRef,
+          env: envVars,
+          cpu: opts.machine.cpu,
+          memory_gb: opts.machine.memory,
+          metadata: {
+            runId: opts.runFriendlyId,
+            envId: opts.envId,
+            envType: opts.envType,
+            orgId: opts.orgId,
+            projectId: opts.projectId,
+            deploymentVersion: opts.deploymentVersion,
+            machine: opts.machine.name,
+          },
+        })
+      );
+
+      if (error) {
+        event.error = error instanceof Error ? error.message : String(error);
+        event.errorType =
+          error instanceof DOMException && error.name === "TimeoutError" ? "timeout" : "fetch";
+        // Intentional: errors are captured in the wide event, not thrown. This matches
+        // the Docker/K8s managers. The run will eventually time out if scheduling fails.
+        return;
+      }
+
+      event.instanceId = data.id;
+      event.ok = true;
+
+      // Parse timing data from compute response (optional - requires gateway timing flag)
+      if (data._timing) {
+        event.timing = data._timing;
+      }
+
+      this.#emitProvisionSpan(opts, startMs, data._timing);
+    } finally {
+      event.durationMs = Math.round(performance.now() - startMs);
+      event.ok ??= false;
+      this.logger.debug("create instance", event);
+    }
+  }
+
+  async snapshot(opts: { runnerId: string; metadata: Record<string, string> }): Promise<boolean> {
+    const [error] = await tryCatch(
+      this.compute.instances.snapshot(opts.runnerId, {
+        callback: {
+          url: this.opts.snapshots.callbackUrl,
+          metadata: opts.metadata,
+        },
+      })
+    );
+
+    if (error) {
+      this.logger.error("snapshot request failed", {
+        runnerId: opts.runnerId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+
+    this.logger.debug("snapshot request accepted", { runnerId: opts.runnerId });
+    return true;
+  }
+
+  async deleteInstance(runnerId: string): Promise<boolean> {
+    const [error] = await tryCatch(this.compute.instances.delete(runnerId));
+
+    if (error) {
+      this.logger.error("delete instance failed", {
+        runnerId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+
+    this.logger.debug("delete instance success", { runnerId });
+    return true;
+  }
+
+  #emitProvisionSpan(opts: WorkloadManagerCreateOptions, startMs: number, timing?: unknown) {
+    if (!this.traceSpansEnabled) return;
+
+    const parsed = parseTraceparent(extractTraceparent(opts.traceContext));
+    if (!parsed) return;
+
+    const endMs = performance.now();
+    const now = Date.now();
+    const provisionStartEpochMs = now - (endMs - startMs);
+    const endEpochMs = now;
+
+    // Span starts at dequeue time so events (dequeue) render in the thin-line section
+    // before "Started". The actual provision call time is in provisionStartEpochMs.
+    // Subtract 1ms so compute span always sorts before the attempt span (same dequeue time)
+    const startEpochMs = opts.dequeuedAt.getTime() - 1;
+
+    const spanAttributes: Record<string, string | number | boolean> = {
+      "compute.type": "create",
+      "compute.provision_start_ms": provisionStartEpochMs,
+      ...(timing
+        ? (flattenAttributes(timing, "compute") as Record<string, string | number | boolean>)
+        : {}),
+    };
+
+    if (opts.dequeueResponseMs !== undefined) {
+      spanAttributes["supervisor.dequeue_response_ms"] = opts.dequeueResponseMs;
+    }
+    if (opts.warmStartCheckMs !== undefined) {
+      spanAttributes["supervisor.warm_start_check_ms"] = opts.warmStartCheckMs;
+    }
+
+    // Use the platform API URL, not the runner OTLP endpoint (which may be a VM gateway IP)
+    this.opts.tracing?.emit({
+      traceId: parsed.traceId,
+      parentSpanId: parsed.spanId,
+      spanName: "compute.provision",
+      startTimeMs: startEpochMs,
+      endTimeMs: endEpochMs,
+      resourceAttributes: {
+        "ctx.environment.id": opts.envId,
+        "ctx.organization.id": opts.orgId,
+        "ctx.project.id": opts.projectId,
+        "ctx.run.id": opts.runFriendlyId,
+      },
+      spanAttributes,
+    });
+  }
+
+  async restore(opts: {
+    snapshotId: string;
+    runnerId: string;
+    runFriendlyId: string;
+    snapshotFriendlyId: string;
+    machine: { cpu: number; memory: number };
+    // Trace context for OTel span emission
+    traceContext?: Record<string, unknown>;
+    envId?: string;
+    orgId?: string;
+    projectId?: string;
+    dequeuedAt?: Date;
+  }): Promise<boolean> {
+    const metadata: Record<string, string> = {
+      TRIGGER_RUNNER_ID: opts.runnerId,
+      TRIGGER_RUN_ID: opts.runFriendlyId,
+      TRIGGER_SNAPSHOT_ID: opts.snapshotFriendlyId,
+      TRIGGER_SUPERVISOR_API_PROTOCOL: this.opts.workloadApiProtocol,
+      TRIGGER_SUPERVISOR_API_PORT: String(this.opts.workloadApiPort),
+      TRIGGER_SUPERVISOR_API_DOMAIN: this.opts.workloadApiDomain ?? "",
+      TRIGGER_WORKER_INSTANCE_NAME: this.opts.runner.instanceName,
+    };
+
+    this.logger.verbose("restore request body", {
+      snapshotId: opts.snapshotId,
+      runnerId: opts.runnerId,
+    });
+
+    const startMs = performance.now();
+
+    const [error] = await tryCatch(
+      this.compute.snapshots.restore(opts.snapshotId, {
+        name: opts.runnerId,
+        metadata,
+        cpu: opts.machine.cpu,
+        memory_gb: opts.machine.memory,
+      })
+    );
+
+    const durationMs = Math.round(performance.now() - startMs);
+
+    if (error) {
+      this.logger.error("restore request failed", {
+        snapshotId: opts.snapshotId,
+        runnerId: opts.runnerId,
+        error: error instanceof Error ? error.message : String(error),
+        durationMs,
+      });
+      return false;
+    }
+
+    this.logger.debug("restore request success", {
+      snapshotId: opts.snapshotId,
+      runnerId: opts.runnerId,
+      durationMs,
+    });
+
+    this.#emitRestoreSpan(opts, startMs);
+
+    return true;
+  }
+
+  #emitRestoreSpan(
+    opts: {
+      snapshotId: string;
+      runnerId: string;
+      runFriendlyId: string;
+      traceContext?: Record<string, unknown>;
+      envId?: string;
+      orgId?: string;
+      projectId?: string;
+      dequeuedAt?: Date;
+    },
+    startMs: number
+  ) {
+    if (!this.traceSpansEnabled) return;
+
+    const parsed = parseTraceparent(extractTraceparent(opts.traceContext));
+    if (!parsed || !opts.envId || !opts.orgId || !opts.projectId) return;
+
+    const endMs = performance.now();
+    const now = Date.now();
+    const restoreStartEpochMs = now - (endMs - startMs);
+    const endEpochMs = now;
+
+    // Subtract 1ms so restore span always sorts before the attempt span
+    const startEpochMs = (opts.dequeuedAt?.getTime() ?? restoreStartEpochMs) - 1;
+
+    this.opts.tracing?.emit({
+      traceId: parsed.traceId,
+      parentSpanId: parsed.spanId,
+      spanName: "compute.restore",
+      startTimeMs: startEpochMs,
+      endTimeMs: endEpochMs,
+      resourceAttributes: {
+        "ctx.environment.id": opts.envId,
+        "ctx.organization.id": opts.orgId,
+        "ctx.project.id": opts.projectId,
+        "ctx.run.id": opts.runFriendlyId,
+      },
+      spanAttributes: {
+        "compute.type": "restore",
+        "compute.snapshot_id": opts.snapshotId,
+      },
+    });
+  }
+}
diff --git a/apps/supervisor/src/workloadManager/docker.ts b/apps/supervisor/src/workloadManager/docker.ts
index d6651d325a2..66405df9ba5 100644
--- a/apps/supervisor/src/workloadManager/docker.ts
+++ b/apps/supervisor/src/workloadManager/docker.ts
@@ -62,7 +62,7 @@ export class DockerWorkloadManager implements WorkloadManager {
   }
 
   async create(opts: WorkloadManagerCreateOptions) {
-    this.logger.log("create()", { opts });
+    this.logger.verbose("create()", { opts });
 
     const runnerId = getRunnerId(opts.runFriendlyId, opts.nextAttemptNumber);
 
diff --git a/apps/supervisor/src/workloadManager/kubernetes.ts b/apps/supervisor/src/workloadManager/kubernetes.ts
index 96fbd7a2740..ec089267219 100644
--- a/apps/supervisor/src/workloadManager/kubernetes.ts
+++ b/apps/supervisor/src/workloadManager/kubernetes.ts
@@ -4,7 +4,12 @@ import {
   type WorkloadManagerCreateOptions,
   type WorkloadManagerOptions,
 } from "./types.js";
-import type { EnvironmentType, MachinePreset, PlacementTag } from "@trigger.dev/core/v3";
+import type {
+  EnvironmentType,
+  MachinePreset,
+  MachinePresetName,
+  PlacementTag,
+} from "@trigger.dev/core/v3";
 import { PlacementTagProcessor } from "@trigger.dev/core/v3/serverOnly";
 import { env } from "../env.js";
 import { type K8sApi, createK8sApi, type k8s } from "../clients/kubernetes.js";
@@ -14,6 +19,26 @@ type ResourceQuantities = {
   [K in "cpu" | "memory" | "ephemeral-storage"]?: string;
 };
 
+const cpuRequestRatioByMachinePreset: Record<MachinePresetName, number | undefined> = {
+  micro: env.KUBERNETES_CPU_REQUEST_RATIO_MICRO,
+  "small-1x": env.KUBERNETES_CPU_REQUEST_RATIO_SMALL_1X,
+  "small-2x": env.KUBERNETES_CPU_REQUEST_RATIO_SMALL_2X,
+  "medium-1x": env.KUBERNETES_CPU_REQUEST_RATIO_MEDIUM_1X,
+  "medium-2x": env.KUBERNETES_CPU_REQUEST_RATIO_MEDIUM_2X,
+  "large-1x": env.KUBERNETES_CPU_REQUEST_RATIO_LARGE_1X,
+  "large-2x": env.KUBERNETES_CPU_REQUEST_RATIO_LARGE_2X,
+};
+
+const memoryRequestRatioByMachinePreset: Record<MachinePresetName, number | undefined> = {
+  micro: env.KUBERNETES_MEMORY_REQUEST_RATIO_MICRO,
+  "small-1x": env.KUBERNETES_MEMORY_REQUEST_RATIO_SMALL_1X,
+  "small-2x": env.KUBERNETES_MEMORY_REQUEST_RATIO_SMALL_2X,
+  "medium-1x": env.KUBERNETES_MEMORY_REQUEST_RATIO_MEDIUM_1X,
+  "medium-2x": env.KUBERNETES_MEMORY_REQUEST_RATIO_MEDIUM_2X,
+  "large-1x": env.KUBERNETES_MEMORY_REQUEST_RATIO_LARGE_1X,
+  "large-2x": env.KUBERNETES_MEMORY_REQUEST_RATIO_LARGE_2X,
+};
+
 export class KubernetesWorkloadManager implements WorkloadManager {
   private readonly logger = new SimpleStructuredLogger("kubernetes-workload-provider");
   private k8s: K8sApi;
@@ -75,7 +100,7 @@ export class KubernetesWorkloadManager implements WorkloadManager {
   }
 
   async create(opts: WorkloadManagerCreateOptions) {
-    this.logger.log("[KubernetesWorkloadManager] Creating container", { opts });
+    this.logger.verbose("[KubernetesWorkloadManager] Creating container", { opts });
 
     const runnerId = getRunnerId(opts.runFriendlyId, opts.nextAttemptNumber);
 
@@ -95,6 +120,8 @@ export class KubernetesWorkloadManager implements WorkloadManager {
           },
           spec: {
             ...this.addPlacementTags(this.#defaultPodSpec, opts.placementTags),
+            affinity: this.#getAffinity(opts),
+            tolerations: this.#getScheduleTolerations(this.#isScheduledRun(opts)),
             terminationGracePeriodSeconds: 60 * 60,
             containers: [
               {
@@ -309,19 +336,38 @@ export class KubernetesWorkloadManager implements WorkloadManager {
     };
   }
 
+  #isScheduledRun(opts: WorkloadManagerCreateOptions): boolean {
+    return opts.annotations?.rootTriggerSource === "schedule";
+  }
+
   #getSharedLabels(opts: WorkloadManagerCreateOptions): Record<string, string> {
-    return {
+    const labels: Record<string, string> = {
       env: opts.envId,
       envtype: this.#envTypeToLabelValue(opts.envType),
       org: opts.orgId,
       project: opts.projectId,
       machine: opts.machine.name,
+      // We intentionally use a boolean label rather than exposing the full trigger source
+      // (e.g. sdk, api, cli, mcp, schedule) to keep label cardinality low in metrics.
+      // The schedule vs non-schedule distinction is all we need for the current metrics
+      // and pool-level scheduling decisions; finer-grained source breakdowns live in run annotations.
+      scheduled: String(this.#isScheduledRun(opts)),
     };
+
+    // Add privatelink label for CiliumNetworkPolicy matching
+    if (opts.hasPrivateLink) {
+      labels.privatelink = opts.orgId;
+    }
+
+    return labels;
   }
 
   #getResourceRequestsForMachine(preset: MachinePreset): ResourceQuantities {
-    const cpuRequest = preset.cpu * this.cpuRequestRatio;
-    const memoryRequest = preset.memory * this.memoryRequestRatio;
+    const cpuRatio = cpuRequestRatioByMachinePreset[preset.name] ?? this.cpuRequestRatio;
+    const memoryRatio = memoryRequestRatioByMachinePreset[preset.name] ?? this.memoryRequestRatio;
+
+    const cpuRequest = preset.cpu * cpuRatio;
+    const memoryRequest = preset.memory * memoryRatio;
 
     // Clamp between min and max
     const clampedCpu = this.clamp(cpuRequest, this.cpuRequestMinCores, preset.cpu);
@@ -356,4 +402,164 @@ export class KubernetesWorkloadManager implements WorkloadManager {
       },
     };
   }
+
+  #isLargeMachine(preset: MachinePreset): boolean {
+    return preset.name.startsWith("large-");
+  }
+
+  #getAffinity(opts: WorkloadManagerCreateOptions): k8s.V1Affinity | undefined {
+    const largeNodeAffinity = this.#getNodeAffinityRules(opts.machine);
+    const scheduleNodeAffinity = this.#getScheduleNodeAffinityRules(this.#isScheduledRun(opts));
+    const podAffinity = this.#getProjectPodAffinity(opts.projectId);
+
+    // Merge node affinity rules from multiple sources
+    const preferred = [
+      ...(largeNodeAffinity?.preferredDuringSchedulingIgnoredDuringExecution ?? []),
+      ...(scheduleNodeAffinity?.preferredDuringSchedulingIgnoredDuringExecution ?? []),
+    ];
+    // Only large machine affinity produces hard requirements (non-large runs must stay off the large pool).
+    // Schedule affinity is soft both ways.
+    const required = [
+      ...(largeNodeAffinity?.requiredDuringSchedulingIgnoredDuringExecution?.nodeSelectorTerms ?? []),
+    ];
+
+    const hasNodeAffinity = preferred.length > 0 || required.length > 0;
+
+    if (!hasNodeAffinity && !podAffinity) {
+      return undefined;
+    }
+
+    return {
+      ...(hasNodeAffinity && {
+        nodeAffinity: {
+          ...(preferred.length > 0 && { preferredDuringSchedulingIgnoredDuringExecution: preferred }),
+          ...(required.length > 0 && {
+            requiredDuringSchedulingIgnoredDuringExecution: { nodeSelectorTerms: required },
+          }),
+        },
+      }),
+      ...(podAffinity && { podAffinity }),
+    };
+  }
+
+  #getNodeAffinityRules(preset: MachinePreset): k8s.V1NodeAffinity | undefined {
+    if (!env.KUBERNETES_LARGE_MACHINE_AFFINITY_ENABLED) {
+      return undefined;
+    }
+
+    if (this.#isLargeMachine(preset)) {
+      // soft preference for the large-machine pool, falls back to standard if unavailable
+      return {
+        preferredDuringSchedulingIgnoredDuringExecution: [
+          {
+            weight: env.KUBERNETES_LARGE_MACHINE_AFFINITY_WEIGHT,
+            preference: {
+              matchExpressions: [
+                {
+                  key: env.KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_KEY,
+                  operator: "In",
+                  values: [env.KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_VALUE],
+                },
+              ],
+            },
+          },
+        ],
+      };
+    }
+
+    // not schedulable in the large-machine pool
+    return {
+      requiredDuringSchedulingIgnoredDuringExecution: {
+        nodeSelectorTerms: [
+          {
+            matchExpressions: [
+              {
+                key: env.KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_KEY,
+                operator: "NotIn",
+                values: [env.KUBERNETES_LARGE_MACHINE_AFFINITY_POOL_LABEL_VALUE],
+              },
+            ],
+          },
+        ],
+      },
+    };
+  }
+
+  #getScheduleNodeAffinityRules(isScheduledRun: boolean): k8s.V1NodeAffinity | undefined {
+    if (!env.KUBERNETES_SCHEDULED_RUN_AFFINITY_ENABLED || !env.KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_VALUE) {
+      return undefined;
+    }
+
+    if (isScheduledRun) {
+      // soft preference for the schedule pool
+      return {
+        preferredDuringSchedulingIgnoredDuringExecution: [
+          {
+            weight: env.KUBERNETES_SCHEDULED_RUN_AFFINITY_WEIGHT,
+            preference: {
+              matchExpressions: [
+                {
+                  key: env.KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_KEY,
+                  operator: "In",
+                  values: [env.KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_VALUE],
+                },
+              ],
+            },
+          },
+        ],
+      };
+    }
+
+    // soft anti-affinity: non-schedule runs prefer to avoid the schedule pool
+    return {
+      preferredDuringSchedulingIgnoredDuringExecution: [
+        {
+          weight: env.KUBERNETES_SCHEDULED_RUN_ANTI_AFFINITY_WEIGHT,
+          preference: {
+            matchExpressions: [
+              {
+                key: env.KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_KEY,
+                operator: "NotIn",
+                values: [env.KUBERNETES_SCHEDULED_RUN_AFFINITY_POOL_LABEL_VALUE],
+              },
+            ],
+          },
+        },
+      ],
+    };
+  }
+
+  #getScheduleTolerations(isScheduledRun: boolean): k8s.V1Toleration[] | undefined {
+    if (!isScheduledRun || !env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS?.length) {
+      return undefined;
+    }
+
+    return env.KUBERNETES_SCHEDULED_RUN_TOLERATIONS;
+  }
+
+  #getProjectPodAffinity(projectId: string): k8s.V1PodAffinity | undefined {
+    if (!env.KUBERNETES_PROJECT_AFFINITY_ENABLED) {
+      return undefined;
+    }
+
+    return {
+      preferredDuringSchedulingIgnoredDuringExecution: [
+        {
+          weight: env.KUBERNETES_PROJECT_AFFINITY_WEIGHT,
+          podAffinityTerm: {
+            labelSelector: {
+              matchExpressions: [
+                {
+                  key: "project",
+                  operator: "In",
+                  values: [projectId],
+                },
+              ],
+            },
+            topologyKey: env.KUBERNETES_PROJECT_AFFINITY_TOPOLOGY_KEY,
+          },
+        },
+      ],
+    };
+  }
 }
diff --git a/apps/supervisor/src/workloadManager/types.ts b/apps/supervisor/src/workloadManager/types.ts
index 90b61957795..86199afe469 100644
--- a/apps/supervisor/src/workloadManager/types.ts
+++ b/apps/supervisor/src/workloadManager/types.ts
@@ -1,4 +1,4 @@
-import type { EnvironmentType, MachinePreset, PlacementTag } from "@trigger.dev/core/v3";
+import type { EnvironmentType, MachinePreset, PlacementTag, RunAnnotations } from "@trigger.dev/core/v3";
 
 export interface WorkloadManagerOptions {
   workloadApiProtocol: "http" | "https";
@@ -24,6 +24,10 @@ export interface WorkloadManagerCreateOptions {
   nextAttemptNumber?: number;
   dequeuedAt: Date;
   placementTags?: PlacementTag[];
+  // Timing context (populated by supervisor handler, included in wide event)
+  dequeueResponseMs?: number;
+  pollingIntervalMs?: number;
+  warmStartCheckMs?: number;
   // identifiers
   envId: string;
   envType: EnvironmentType;
@@ -35,4 +39,9 @@ export interface WorkloadManagerCreateOptions {
   runFriendlyId: string;
   snapshotId: string;
   snapshotFriendlyId: string;
+  // Trace context for OTel span emission (W3C format: { traceparent: "00-...", tracestate?: "..." })
+  traceContext?: Record<string, unknown>;
+  annotations?: RunAnnotations;
+  // private networking
+  hasPrivateLink?: boolean;
 }
diff --git a/apps/supervisor/src/workloadServer/index.ts b/apps/supervisor/src/workloadServer/index.ts
index 35d53d36099..bd38cc8700f 100644
--- a/apps/supervisor/src/workloadServer/index.ts
+++ b/apps/supervisor/src/workloadServer/index.ts
@@ -24,6 +24,13 @@ import { HttpServer, type CheckpointClient } from "@trigger.dev/core/v3/serverOn
 import { type IncomingMessage } from "node:http";
 import { register } from "../metrics.js";
 import { env } from "../env.js";
+import { SnapshotCallbackPayloadSchema } from "@internal/compute";
+import {
+  ComputeSnapshotService,
+  type RunTraceContext,
+} from "../services/computeSnapshotService.js";
+import type { ComputeWorkloadManager } from "../workloadManager/compute.js";
+import type { OtlpTraceService } from "../services/otlpTraceService.js";
 
 // Use the official export when upgrading to socket.io@4.8.0
 interface DefaultEventsMap {
@@ -58,10 +65,13 @@ type WorkloadServerOptions = {
   host?: string;
   workerClient: SupervisorHttpClient;
   checkpointClient?: CheckpointClient;
+  computeManager?: ComputeWorkloadManager;
+  tracing?: OtlpTraceService;
 };
 
 export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
   private checkpointClient?: CheckpointClient;
+  private readonly snapshotService?: ComputeSnapshotService;
 
   private readonly logger = new SimpleStructuredLogger("workload-server");
 
@@ -94,6 +104,14 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
     this.workerClient = opts.workerClient;
     this.checkpointClient = opts.checkpointClient;
 
+    if (opts.computeManager?.snapshotsEnabled) {
+      this.snapshotService = new ComputeSnapshotService({
+        computeManager: opts.computeManager,
+        workerClient: opts.workerClient,
+        tracing: opts.tracing,
+      });
+    }
+
     this.httpServer = this.createHttpServer({ host, port });
     this.websocketServer = this.createWebsocketServer();
   }
@@ -229,13 +247,28 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
         {
           paramsSchema: WorkloadActionParams,
           handler: async ({ reply, params, req }) => {
-            this.logger.debug("Suspend request", { params, headers: req.headers });
+            const runnerId = this.runnerIdFromRequest(req);
+            const deploymentVersion = this.deploymentVersionFromRequest(req);
+            const projectRef = this.projectRefFromRequest(req);
 
-            if (!this.checkpointClient) {
+            this.logger.debug("Suspend request", {
+              params,
+              runnerId,
+              deploymentVersion,
+              projectRef,
+            });
+
+            if (!runnerId || !deploymentVersion || !projectRef) {
+              this.logger.error("Invalid headers for suspend request", {
+                ...params,
+                runnerId,
+                deploymentVersion,
+                projectRef,
+              });
               reply.json(
                 {
                   ok: false,
-                  error: "Checkpoints disabled",
+                  error: "Invalid headers",
                 } satisfies WorkloadSuspendRunResponseBody,
                 false,
                 400
@@ -243,19 +276,25 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
               return;
             }
 
-            const runnerId = this.runnerIdFromRequest(req);
-            const deploymentVersion = this.deploymentVersionFromRequest(req);
-            const projectRef = this.projectRefFromRequest(req);
+            if (this.snapshotService) {
+              // Compute mode: delay snapshot to avoid wasted work on short-lived waitpoints.
+              // If the run continues before the delay expires, the snapshot is cancelled.
+              reply.json({ ok: true } satisfies WorkloadSuspendRunResponseBody, false, 202);
 
-            if (!runnerId || !deploymentVersion || !projectRef) {
-              this.logger.error("Invalid headers for suspend request", {
-                ...params,
-                headers: req.headers,
+              this.snapshotService.schedule(params.runFriendlyId, {
+                runnerId,
+                runFriendlyId: params.runFriendlyId,
+                snapshotFriendlyId: params.snapshotFriendlyId,
               });
+
+              return;
+            }
+
+            if (!this.checkpointClient) {
               reply.json(
                 {
                   ok: false,
-                  error: "Invalid headers",
+                  error: "Checkpoints disabled",
                 } satisfies WorkloadSuspendRunResponseBody,
                 false,
                 400
@@ -298,6 +337,9 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
           handler: async ({ req, reply, params }) => {
             this.logger.debug("Run continuation request", { params });
 
+            // Cancel any pending delayed snapshot for this run
+            this.snapshotService?.cancel(params.runFriendlyId);
+
             const continuationResult = await this.workerClient.continueRunExecution(
               params.runFriendlyId,
               params.snapshotFriendlyId,
@@ -394,6 +436,20 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
       });
     }
 
+    // Compute snapshot callback endpoint
+    httpServer.route("/api/v1/compute/snapshot-complete", "POST", {
+      bodySchema: SnapshotCallbackPayloadSchema,
+      handler: async ({ reply, body }) => {
+        if (!this.snapshotService) {
+          reply.empty(404);
+          return;
+        }
+
+        const result = await this.snapshotService.handleCallback(body);
+        reply.empty(result.status);
+      },
+    });
+
     return httpServer;
   }
 
@@ -408,7 +464,7 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
     > = io.of("/workload");
 
     websocketServer.on("disconnect", (socket) => {
-      this.logger.log("[WS] disconnect", socket.id);
+      this.logger.verbose("[WS] disconnect", socket.id);
     });
     websocketServer.use(async (socket, next) => {
       const setSocketDataFromHeader = (
@@ -490,7 +546,7 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
         socket.data.runFriendlyId = undefined;
       };
 
-      socketLogger.log("wsServer socket connected", { ...getSocketMetadata() });
+      socketLogger.debug("wsServer socket connected", { ...getSocketMetadata() });
 
       // FIXME: where does this get set?
       if (socket.data.runFriendlyId) {
@@ -498,7 +554,11 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
       }
 
       socket.on("disconnecting", (reason, description) => {
-        socketLogger.log("Socket disconnecting", { ...getSocketMetadata(), reason, description });
+        socketLogger.verbose("Socket disconnecting", {
+          ...getSocketMetadata(),
+          reason,
+          description,
+        });
 
         if (socket.data.runFriendlyId) {
           runDisconnected(socket.data.runFriendlyId);
@@ -506,7 +566,7 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
       });
 
       socket.on("disconnect", (reason, description) => {
-        socketLogger.log("Socket disconnected", { ...getSocketMetadata(), reason, description });
+        socketLogger.debug("Socket disconnected", { ...getSocketMetadata(), reason, description });
       });
 
       socket.on("error", (error) => {
@@ -527,7 +587,7 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
           ...message,
         });
 
-        log.log("Handling run:start");
+        log.debug("Handling run:start");
 
         try {
           runConnected(message.run.friendlyId);
@@ -543,10 +603,13 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
           ...message,
         });
 
-        log.log("Handling run:stop");
+        log.debug("Handling run:stop");
 
         try {
           runDisconnected(message.run.friendlyId);
+          // Don't delete trace context here - run:stop fires after each snapshot/shutdown
+          // but the run may be restored on a new VM and snapshot again. Trace context is
+          // re-populated on dequeue, and entries are small (4 strings per run).
         } catch (error) {
           log.error("run:stop error", { error });
         }
@@ -588,11 +651,16 @@ export class WorkloadServer extends EventEmitter<WorkloadServerEvents> {
     }
   }
 
+  registerRunTraceContext(runFriendlyId: string, ctx: RunTraceContext) {
+    this.snapshotService?.registerTraceContext(runFriendlyId, ctx);
+  }
+
   async start() {
     await this.httpServer.start();
   }
 
   async stop() {
+    this.snapshotService?.stop();
     await this.httpServer.stop();
   }
 }
diff --git a/apps/webapp/CLAUDE.md b/apps/webapp/CLAUDE.md
new file mode 100644
index 00000000000..b0f5e09b829
--- /dev/null
+++ b/apps/webapp/CLAUDE.md
@@ -0,0 +1,120 @@
+# Webapp
+
+Remix 2.1.0 app serving as the main API, dashboard, and orchestration engine. Uses an Express server (`server.ts`).
+
+## Verifying Changes
+
+**Never run `pnpm run build --filter webapp` to verify changes.** Building proves almost nothing about correctness. The webapp is an app, not a public package — use typecheck from the repo root:
+
+```bash
+pnpm run typecheck --filter webapp   # ~1-2 minutes
+```
+
+Only run typecheck after major changes (new files, significant refactors, schema changes). For small edits, trust the types and let CI catch issues.
+
+Note: Public packages (`packages/*`) use `build` instead. See the root CLAUDE.md for details.
+
+## Testing Dashboard Changes with Chrome DevTools MCP
+
+Use the `chrome-devtools` MCP server to visually verify local dashboard changes. The webapp must be running (`pnpm run dev --filter webapp` from repo root).
+
+### Login
+
+```
+1. mcp__chrome-devtools__new_page(url: "http://localhost:3030")
+   → Redirects to /login
+2. mcp__chrome-devtools__click the "Continue with Email" link
+3. mcp__chrome-devtools__fill the email field with "local@trigger.dev"
+4. mcp__chrome-devtools__click "Send a magic link"
+   → Auto-logs in and redirects to the dashboard (no email verification needed locally)
+```
+
+### Navigating and Verifying
+
+- **take_snapshot**: Get an a11y tree of the page (text content, element UIDs for interaction). Prefer this over screenshots for understanding page structure.
+- **take_screenshot**: Capture what the page looks like visually. Use to verify styling, layout, and visual changes.
+- **navigate_page**: Go to specific URLs, e.g. `http://localhost:3030/orgs/references-bc08/projects/hello-world-SiWs/env/dev/runs`
+- **click / fill**: Interact with elements using UIDs from `take_snapshot`.
+- **evaluate_script**: Run JS in the browser console for debugging.
+- **list_console_messages**: Check for console errors after navigating.
+
+### Tips
+
+- Snapshots can be very large on complex pages (200K+ chars). Use `take_screenshot` first to orient, then `take_snapshot` only when you need element UIDs to interact.
+- The local seeded user email is `local@trigger.dev`.
+- Dashboard URL pattern: `http://localhost:3030/orgs/{orgSlug}/projects/{projectSlug}/env/{envSlug}/{section}`
+
+## Key File Locations
+
+- **Trigger API**: `app/routes/api.v1.tasks.$taskId.trigger.ts`
+- **Batch trigger**: `app/routes/api.v1.tasks.batch.ts`
+- **OTEL endpoints**: `app/routes/otel.v1.logs.ts`, `app/routes/otel.v1.traces.ts`
+- **Prisma setup**: `app/db.server.ts`
+- **Run engine config**: `app/v3/runEngine.server.ts`
+- **Services**: `app/v3/services/**/*.server.ts`
+- **Presenters**: `app/v3/presenters/**/*.server.ts`
+
+## Route Convention
+
+Routes use Remix flat-file convention with dot-separated segments:
+`api.v1.tasks.$taskId.trigger.ts` -> `/api/v1/tasks/:taskId/trigger`
+
+## Environment Variables
+
+Access via `env` export from `app/env.server.ts`. **Never use `process.env` directly.**
+
+For testable code, **never import env.server.ts** in test files. Pass configuration as options instead:
+- `realtimeClient.server.ts` (testable service, takes config as constructor arg)
+- `realtimeClientGlobal.server.ts` (creates singleton with env config)
+
+## Run Engine 2.0
+
+The webapp integrates `@internal/run-engine` via `app/v3/runEngine.server.ts`. This is the singleton engine instance. Services in `app/v3/services/` call engine methods for all run lifecycle operations (triggering, completing, cancelling, etc.).
+
+The `engineVersion.server.ts` file determines V1 vs V2 for a given environment. New code should always target V2.
+
+## Background Workers
+
+Background job workers use `@trigger.dev/redis-worker`:
+- `app/v3/commonWorker.server.ts`
+- `app/v3/alertsWorker.server.ts`
+- `app/v3/batchTriggerWorker.server.ts`
+
+Do NOT add new jobs using zodworker/graphile-worker (legacy).
+
+## Real-time
+
+- Socket.io: `app/v3/handleSocketIo.server.ts`, `app/v3/handleWebsockets.server.ts`
+- Electric SQL: Powers real-time data sync for the dashboard
+
+## Legacy V1 Code
+
+The `app/v3/` directory name is misleading - most code is actively used by V2. Only these specific files are V1-only legacy:
+- `app/v3/marqs/` (old MarQS queue system)
+- `app/v3/legacyRunEngineWorker.server.ts`
+- `app/v3/services/triggerTaskV1.server.ts`
+- `app/v3/services/cancelTaskRunV1.server.ts`
+- `app/v3/authenticatedSocketConnection.server.ts`
+- `app/v3/sharedSocketConnection.ts`
+
+Some services (e.g., `cancelTaskRun.server.ts`, `batchTriggerV3.server.ts`) branch on `RunEngineVersion` to support both V1 and V2. When editing these, only modify V2 code paths.
+
+## Performance: Trigger Hot Path
+
+The `triggerTask.server.ts` service is the **highest-throughput code path** in the system. Every API trigger call goes through it. Keep it fast:
+
+- **Do NOT add database queries** to `triggerTask.server.ts` or `batchTriggerV3.server.ts`. Task defaults (TTL, etc.) are resolved via `backgroundWorkerTask.findFirst()` in the queue concern (`queues.server.ts`) - one query per request, in mutually exclusive branches depending on locked/non-locked path. Piggyback on the existing query instead of adding new ones.
+- **Two-stage resolution pattern**: Task metadata is resolved in two stages by design:
+  1. **Trigger time** (`triggerTask.server.ts`): Only TTL is resolved from task defaults. Everything else uses whatever the caller provides.
+  2. **Dequeue time** (`dequeueSystem.ts`): Full `BackgroundWorkerTask` is loaded and retry config, machine config, maxDuration, etc. are resolved against task defaults.
+- If you need to add a new task-level default, **add it to the existing `select` clause** in the `backgroundWorkerTask.findFirst()` query — do NOT add a second query. If the default doesn't need to be known at trigger time, resolve it at dequeue time instead.
+- Batch triggers (`batchTriggerV3.server.ts`) follow the same pattern — keep batch paths equally fast.
+
+## Prisma Query Patterns
+
+- **Always use `findFirst` instead of `findUnique`.** Prisma's `findUnique` has an implicit DataLoader that batches concurrent calls into a single `IN` query. This batching cannot be disabled and has active bugs even in Prisma 6.x: uppercase UUIDs returning null (#25484, confirmed 6.4.1), composite key SQL correctness issues (#22202), and 5-10x worse performance than manual DataLoader (#6573, open since 2021). `findFirst` is never batched and avoids this entire class of issues.
+
+## React Patterns
+
+- Only use `useCallback`/`useMemo` for context provider values, expensive derived data that is a dependency elsewhere, or stable refs required by a dependency array. Don't wrap ordinary event handlers or trivial computations.
+- Use named constants for sentinel/placeholder values (e.g. `const UNSET_VALUE = "__unset__"`) instead of raw string literals scattered across comparisons.
diff --git a/apps/webapp/app/assets/icons/AIMetricsIcon.tsx b/apps/webapp/app/assets/icons/AIMetricsIcon.tsx
new file mode 100644
index 00000000000..038eea70b49
--- /dev/null
+++ b/apps/webapp/app/assets/icons/AIMetricsIcon.tsx
@@ -0,0 +1,16 @@
+export function AIMetricsIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        fillRule="evenodd"
+        clipRule="evenodd"
+        d="M5.5 2C5.8013 2 6.0688 2.1928 6.16408 2.47864L6.53204 3.58252C6.67139 4.00057 6.99943 4.32861 7.41748 4.46796L8.52136 4.83592C8.8072 4.9312 9 5.1987 9 5.5C9 5.8013 8.8072 6.0688 8.52136 6.16408L7.41748 6.53204C6.99943 6.67139 6.67139 6.99943 6.53204 7.41748L6.16408 8.52136C6.0688 8.8072 5.8013 9 5.5 9C5.1987 9 4.9312 8.8072 4.83592 8.52136L4.46796 7.41748C4.32861 6.99943 4.00057 6.67139 3.58252 6.53204L2.47864 6.16408C2.1928 6.0688 2 5.8013 2 5.5C2 5.1987 2.1928 4.9312 2.47864 4.83592L3.58252 4.46796C4.00057 4.32861 4.32861 4.00057 4.46796 3.58252L4.83592 2.47864C4.9312 2.1928 5.1987 2 5.5 2Z"
+        fill="currentColor"
+      />
+      <path
+        d="M18.6 2.40002C18.1226 2.40002 17.6648 2.58967 17.3272 2.92723C16.9896 3.2648 16.8 3.72263 16.8 4.20002V19.8C16.8 20.2774 16.9896 20.7353 17.3272 21.0728C17.6648 21.4104 18.1226 21.6 18.6 21.6H19.8C20.2774 21.6 20.7352 21.4104 21.0728 21.0728C21.4104 20.7353 21.6 20.2774 21.6 19.8V4.20002C21.6 3.72263 21.4104 3.2648 21.0728 2.92723C20.7352 2.58967 20.2774 2.40002 19.8 2.40002H18.6ZM11.4 7.20002C10.9226 7.20002 10.4648 7.38967 10.1272 7.72723C9.78964 8.0648 9.6 8.52263 9.6 9.00002V19.8C9.6 20.2774 9.78964 20.7353 10.1272 21.0728C10.4648 21.4104 10.9226 21.6 11.4 21.6H12.6C13.0774 21.6 13.5352 21.4104 13.8728 21.0728C14.2104 20.7353 14.4 20.2774 14.4 19.8V9.00002C14.4 8.52263 14.2104 8.0648 13.8728 7.72723C13.5352 7.38967 13.0774 7.20002 12.6 7.20002H11.4ZM4.2 12C3.72261 12 3.26477 12.1897 2.92721 12.5272C2.58964 12.8648 2.4 13.3226 2.4 13.8V19.8C2.4 20.2774 2.58964 20.7353 2.92721 21.0728C3.26477 21.4104 3.72261 21.6 4.2 21.6H5.4C5.87739 21.6 6.33523 21.4104 6.67279 21.0728C7.01036 20.7353 7.2 20.2774 7.2 19.8V13.8C7.2 13.3226 7.01036 12.8648 6.67279 12.5272C6.33523 12.1897 5.87739 12 5.4 12H4.2Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/AIPromptsIcon.tsx b/apps/webapp/app/assets/icons/AIPromptsIcon.tsx
new file mode 100644
index 00000000000..dd434df9931
--- /dev/null
+++ b/apps/webapp/app/assets/icons/AIPromptsIcon.tsx
@@ -0,0 +1,10 @@
+export function AIPromptsIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M12 3C14.5154 3 16.9845 3.20109 19.3916 3.58887C21.0075 3.8492 22.125 5.2653 22.125 6.85449V12.6455C22.125 14.2347 21.0075 15.6508 19.3916 15.9111C17.4843 16.2184 15.5379 16.4079 13.5605 16.4736C13.3313 16.4813 13.1196 16.5737 12.9668 16.7266L8.94043 20.7529C8.69912 20.9942 8.33578 21.0661 8.02051 20.9355C7.70544 20.8049 7.50001 20.4974 7.5 20.1562V16.2832C6.52707 16.189 5.56281 16.0649 4.6084 15.9111C2.99251 15.6508 1.875 14.2347 1.875 12.6455V6.85449C1.875 5.2653 2.99251 3.8492 4.6084 3.58887C7.01552 3.20109 9.48459 3 12 3ZM12 5.25C11.6127 5.25 11.2691 5.49785 11.1465 5.86523L10.6729 7.28418C10.4937 7.8215 10.0724 8.24359 9.53516 8.42285L8.11523 8.89648C7.74786 9.01906 7.5 9.3627 7.5 9.75C7.50001 10.1373 7.74786 10.4809 8.11523 10.6035L9.53516 11.0771C10.0722 11.2564 10.4937 11.6778 10.6729 12.2148L11.1465 13.6348C11.2691 14.0021 11.6127 14.25 12 14.25C12.3873 14.25 12.7309 14.0021 12.8535 13.6348L13.3271 12.2148C13.5063 11.6778 13.9278 11.2564 14.4648 11.0771L15.8848 10.6035C16.2521 10.4809 16.5 10.1373 16.5 9.75C16.5 9.3627 16.2521 9.01906 15.8848 8.89648L14.4648 8.42285C13.9276 8.24359 13.5063 7.8215 13.3271 7.28418L12.8535 5.86523C12.7309 5.49785 12.3873 5.25 12 5.25Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/AbacusIcon.tsx b/apps/webapp/app/assets/icons/AbacusIcon.tsx
new file mode 100644
index 00000000000..f0b7bfdf7be
--- /dev/null
+++ b/apps/webapp/app/assets/icons/AbacusIcon.tsx
@@ -0,0 +1,71 @@
+export function AbacusIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <g clipPath="url(#clip0_16909_120578)">
+        <path
+          d="M4 3V21"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M20 21V3"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M8 5L8 6"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M14 5L14 6"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M15 10L15 11"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M9 10L9 11"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M12 15L12 16"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M8 15L8 16"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+        <path
+          d="M3 21H21"
+          stroke="currentColor"
+          strokeWidth="2"
+          strokeLinecap="round"
+          strokeLinejoin="round"
+        />
+      </g>
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/AiProviderIcons.tsx b/apps/webapp/app/assets/icons/AiProviderIcons.tsx
new file mode 100644
index 00000000000..85a01b98d63
--- /dev/null
+++ b/apps/webapp/app/assets/icons/AiProviderIcons.tsx
@@ -0,0 +1,177 @@
+type IconProps = { className?: string };
+
+export function OpenAIIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M9.648 9.27004V7.36778C9.648 7.20757 9.70764 7.08738 9.84657 7.00738L13.6396 4.80477C14.1559 4.50443 14.7715 4.36434 15.4069 4.36434C17.7899 4.36434 19.2992 6.22658 19.2992 8.20884C19.2992 8.34898 19.2992 8.50919 19.2793 8.6694L15.3473 6.3466C15.1091 6.20651 14.8707 6.20651 14.6324 6.3466L9.648 9.27004ZM18.5048 16.6789V12.1334C18.5048 11.853 18.3855 11.6528 18.1473 11.5126L13.1629 8.58919L14.7913 7.64801C14.9303 7.56801 15.0495 7.56801 15.1884 7.64801L18.9814 9.85062C20.0737 10.4915 20.8084 11.853 20.8084 13.1745C20.8084 14.6962 19.9148 16.098 18.5048 16.6787V16.6789ZM8.47638 12.6742L6.848 11.7131C6.70907 11.6331 6.64943 11.5128 6.64943 11.3526V6.94746C6.64943 4.80498 8.2778 3.18295 10.4821 3.18295C11.3163 3.18295 12.0906 3.46334 12.7461 3.96392L8.834 6.24669C8.59578 6.38679 8.47658 6.58702 8.47658 6.86746V12.6743L8.47638 12.6742ZM11.9814 14.7165L9.648 13.395V10.5918L11.9814 9.27025L14.3146 10.5918V13.395L11.9814 14.7165ZM13.4807 20.8038C12.6466 20.8038 11.8723 20.5234 11.2168 20.0229L15.1288 17.7401C15.3671 17.6 15.4863 17.3997 15.4863 17.1193V11.3124L17.1346 12.2735C17.2735 12.3535 17.3331 12.4737 17.3331 12.634V17.0391C17.3331 19.1816 15.6848 20.8036 13.4807 20.8036V20.8038ZM8.77424 16.3385L4.9812 14.136C3.88892 13.4951 3.15426 12.1336 3.15426 10.8121C3.15426 9.27025 4.06775 7.88863 5.4776 7.30789V11.8733C5.4776 12.1537 5.59683 12.3539 5.83506 12.494L10.7997 15.3974L9.17134 16.3385C9.03241 16.4185 8.91317 16.4185 8.77424 16.3385ZM8.55592 19.6224C6.31192 19.6224 4.66364 17.9204 4.66364 15.8179C4.66364 15.6577 4.68355 15.4975 4.70329 15.3373L8.61535 17.62C8.85358 17.7602 9.09201 17.7602 9.33023 17.62L14.3146 14.7167V16.619C14.3146 16.7792 14.255 16.8994 14.1161 16.9794L10.3231 19.182C9.80672 19.4823 9.19109 19.6224 8.55571 19.6224H8.55592ZM13.4807 22.0052C15.8836 22.0052 17.8891 20.2832 18.3461 18.0004C20.5701 17.4197 21.9999 15.3172 21.9999 13.1747C21.9999 11.773 21.4043 10.4115 20.3319 9.43025C20.4312 9.00972 20.4908 8.58919 20.4908 8.16886C20.4908 5.30551 18.1872 3.16283 15.5261 3.16283C14.9901 3.16283 14.4737 3.24283 13.9574 3.42316C13.0636 2.54207 11.8324 1.98145 10.4821 1.98145C8.07927 1.98145 6.07369 3.70339 5.61678 5.98616C3.39269 6.5669 1.96289 8.6694 1.96289 10.8119C1.96289 12.2136 2.55857 13.5751 3.63095 14.5563C3.53166 14.9768 3.47207 15.3974 3.47207 15.8177C3.47207 18.6811 5.77567 20.8237 8.43668 20.8237C8.97277 20.8237 9.48911 20.7437 10.0055 20.5634C10.899 21.4445 12.1302 22.0052 13.4807 22.0052Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
+
+export function AnthropicIcon({ className }: IconProps) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 24 24"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path d="M17.3041 3.541h-3.6718l6.696 16.918H24Zm-10.6082 0L0 20.459h3.7442l1.3693-3.5527h7.0052l1.3693 3.5528h3.7442L10.5363 3.5409Zm-.3712 10.2232 2.2914-5.9456 2.2914 5.9456Z" />
+    </svg>
+  );
+}
+
+export function GeminiIcon({ className }: IconProps) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 24 24"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path d="M12 0C12 6.627 6.627 12 0 12c6.627 0 12 5.373 12 12 0-6.627 5.373-12 12-12-6.627 0-12-5.373-12-12Z" />
+    </svg>
+  );
+}
+
+export function LlamaIcon({ className }: IconProps) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 12 12"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M3.4485 2C4.406 2 5.2065 2.466 6.1635 3.688L6.3045 3.5015C6.3995 3.3785 6.496 3.2595 6.5945 3.1465L6.751 2.9715C7.294 2.394 7.896 2 8.6125 2C9.249 2 9.847 2.2785 10.358 2.758L10.467 2.8645C11.332 3.747 11.9255 5.2195 11.9935 6.8775L11.999 7.0735L12 7.1985C12 7.949 11.86 8.578 11.591 9.0485L11.521 9.1635L11.467 9.24C11.3165 9.45 11.135 9.619 10.924 9.7445L10.7915 9.8155L10.748 9.8355C10.6986 9.85749 10.6482 9.87718 10.597 9.8945C10.3825 9.96542 10.1579 10.0006 9.932 9.9985C9.67 9.9985 9.434 9.965 9.213 9.891C8.906 9.789 8.6315 9.611 8.35 9.333L8.2365 9.2155C7.86 8.8095 7.4695 8.2275 6.99 7.4225L6.275 6.2175L6.003 5.77L5.12 7.335L4.9485 7.631C3.7985 9.578 3.1135 10 2.178 10C1.573 10 1.0755 9.79 0.71 9.409L0.626 9.317C0.384 9.0305 0.2075 8.6615 0.1045 8.2225L0.071 8.0625C0.0323456 7.84982 0.00961585 7.63456 0.003 7.4185L0 7.234C0.001 6.8615 0.03 6.489 0.087 6.119L0.137 5.8325C0.286 5.0675 0.551 4.3535 0.905 3.754L1.0095 3.584C1.598 2.669 2.404 2.0575 3.317 2.004L3.4485 2ZM3.432 3.3075L3.3315 3.3125C2.9165 3.354 2.5285 3.649 2.2055 4.101L2.1365 4.2005L2.1315 4.2095C1.7965 4.718 1.539 5.3985 1.4035 6.132L1.4015 6.143C1.33323 6.5148 1.29859 6.89199 1.298 7.27L1.299 7.364C1.301 7.454 1.3075 7.544 1.319 7.634L1.3405 7.7795C1.3865 8.031 1.469 8.2335 1.5835 8.3835L1.642 8.452C1.7935 8.6135 1.991 8.698 2.227 8.698C2.777 8.698 3.125 8.36 4.075 6.8775L5.1625 5.1775L5.3895 4.827L5.32 4.728C4.555 3.65 4.042 3.3075 3.432 3.3075ZM8.53 3.0315L8.442 3.035C8.1245 3.059 7.8305 3.2145 7.532 3.5015L7.434 3.6005C7.2145 3.8315 6.9905 4.1325 6.7505 4.504L6.8835 4.703C6.9735 4.84 7.0645 4.983 7.1585 5.132L7.305 5.3695L8.003 6.537L8.3505 7.094C8.642 7.557 8.8655 7.894 9.0545 8.135L9.161 8.266C9.302 8.429 9.4255 8.536 9.5495 8.6025L9.6005 8.6275C9.714 8.6775 9.829 8.6965 9.9595 8.6965C10.0475 8.6975 10.1345 8.685 10.2185 8.66C10.3875 8.608 10.5235 8.5 10.625 8.3415L10.6725 8.26L10.711 8.179C10.808 7.9495 10.856 7.649 10.856 7.2865L10.853 7.062C10.813 5.6265 10.384 4.376 9.753 3.663L9.665 3.5685C9.33 3.227 8.943 3.0315 8.53 3.0315Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
+
+export function DeepseekIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <g clip-path="url(#clip0_20374_57805)">
+        <path
+          fill-rule="evenodd"
+          clip-rule="evenodd"
+          d="M23.7479 4.48176C23.4939 4.35776 23.384 4.59476 23.236 4.71576C23.185 4.75476 23.142 4.80576 23.099 4.85176C22.727 5.24876 22.293 5.50876 21.726 5.47776C20.897 5.43176 20.189 5.69176 19.563 6.32576C19.43 5.54376 18.988 5.07776 18.316 4.77776C17.964 4.62176 17.608 4.46676 17.361 4.12776C17.189 3.88676 17.142 3.61776 17.056 3.35376C17.001 3.19376 16.946 3.03076 16.763 3.00376C16.563 2.97276 16.4849 3.13976 16.4069 3.27976C16.094 3.85176 15.9729 4.48176 15.9849 5.11976C16.0119 6.55576 16.618 7.69976 17.823 8.51276C17.96 8.60576 17.995 8.69976 17.952 8.83576C17.87 9.11576 17.772 9.38776 17.686 9.66876C17.631 9.84776 17.549 9.88576 17.357 9.80876C16.7082 9.52995 16.1189 9.12939 15.6209 8.62876C14.7639 7.80076 13.9899 6.88676 13.0239 6.17076C12.8001 6.00537 12.5703 5.84827 12.3349 5.69976C11.3499 4.74276 12.4649 3.95676 12.7229 3.86376C12.9929 3.76576 12.8159 3.43176 11.9439 3.43576C11.0719 3.43976 10.2739 3.73076 9.25695 4.11976C9.10582 4.17767 8.95033 4.22348 8.79195 4.25676C7.84158 4.07769 6.8696 4.0433 5.90895 4.15476C4.02395 4.36476 2.51895 5.25676 1.41195 6.77776C0.0819496 8.60576 -0.23105 10.6838 0.15195 12.8498C0.55495 15.1338 1.72095 17.0248 3.51195 18.5028C5.36995 20.0358 7.50895 20.7868 9.94995 20.6428C11.4319 20.5578 13.0829 20.3588 14.9439 18.7828C15.4139 19.0168 15.906 19.1098 16.724 19.1798C17.354 19.2388 17.96 19.1498 18.429 19.0518C19.164 18.8958 19.1129 18.2148 18.8479 18.0908C16.693 17.0868 17.166 17.4958 16.735 17.1648C17.831 15.8688 19.481 14.5228 20.127 10.1618C20.177 9.81476 20.134 9.59676 20.127 9.31676C20.123 9.14676 20.162 9.07976 20.357 9.06076C20.898 9.00463 21.4228 8.84327 21.902 8.58576C23.298 7.82276 23.862 6.57076 23.995 5.06876C24.015 4.83876 23.9909 4.60276 23.7479 4.48176ZM11.5809 17.9998C9.49195 16.3578 8.47895 15.8168 8.06095 15.8398C7.66895 15.8638 7.73995 16.3108 7.82595 16.6028C7.91595 16.8908 8.03295 17.0888 8.19695 17.3418C8.31095 17.5088 8.38895 17.7578 8.08395 17.9448C7.41095 18.3608 6.24195 17.8048 6.18695 17.7778C4.82595 16.9758 3.68695 15.9178 2.88595 14.4708C2.11195 13.0778 1.66195 11.5838 1.58795 9.98876C1.56795 9.60276 1.68095 9.46676 2.06495 9.39676C2.56906 9.30029 3.08558 9.28711 3.59395 9.35776C5.72595 9.66976 7.53995 10.6228 9.06195 12.1318C9.92995 12.9918 10.5869 14.0188 11.2639 15.0228C11.9839 16.0888 12.7579 17.1048 13.7439 17.9368C14.0919 18.2288 14.3689 18.4508 14.6349 18.6138C13.8329 18.7038 12.4949 18.7238 11.5809 17.9998ZM12.5809 11.5598C12.5808 11.5101 12.5927 11.4611 12.6157 11.4171C12.6387 11.373 12.672 11.3353 12.7129 11.307C12.7538 11.2787 12.8009 11.2609 12.8502 11.2549C12.8995 11.2489 12.9495 11.2551 12.9959 11.2728C13.0551 11.294 13.1062 11.3331 13.142 11.3848C13.1779 11.4364 13.1967 11.4979 13.1959 11.5608C13.1961 11.6014 13.1881 11.6416 13.1726 11.6791C13.157 11.7166 13.1341 11.7506 13.1053 11.7792C13.0764 11.8078 13.0422 11.8303 13.0045 11.8455C12.9669 11.8607 12.9266 11.8683 12.8859 11.8678C12.8457 11.8679 12.8057 11.86 12.7685 11.8445C12.7313 11.829 12.6976 11.8063 12.6693 11.7776C12.641 11.7489 12.6186 11.7149 12.6037 11.6775C12.5887 11.6401 12.5803 11.6 12.5809 11.5598ZM15.6909 13.1558C15.4909 13.2368 15.2919 13.3068 15.1009 13.3158C14.8136 13.3258 14.5316 13.236 14.3029 13.0618C14.0289 12.8318 13.8329 12.7038 13.7509 12.3038C13.7227 12.1083 13.7281 11.9094 13.7669 11.7158C13.8369 11.3888 13.7589 11.1788 13.5279 10.9888C13.3409 10.8328 13.1019 10.7898 12.8399 10.7898C12.7502 10.7845 12.6631 10.7578 12.5859 10.7118C12.4759 10.6578 12.3859 10.5218 12.4719 10.3538C12.4999 10.2998 12.6319 10.1678 12.6639 10.1438C13.0199 9.94176 13.4309 10.0078 13.8099 10.1598C14.1619 10.3038 14.4279 10.5678 14.8109 10.9418C15.2019 11.3928 15.2729 11.5178 15.4959 11.8558C15.6719 12.1208 15.8319 12.3928 15.9409 12.7038C16.0079 12.8988 15.9219 13.0578 15.6909 13.1558Z"
+          fill="currentColor"
+        />
+      </g>
+      <defs>
+        <clipPath id="clip0_20374_57805">
+          <rect width="24" height="24" fill="currentColor" />
+        </clipPath>
+      </defs>
+    </svg>
+  );
+}
+
+export function XAIIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M17.7329 8.44672L18.0784 22.0139H20.8452L21.1911 3.50781L17.7329 8.44672Z"
+        fill="currentColor"
+      />
+      <path d="M21.1911 2H16.9692L10.3442 11.4621L12.4552 14.4768L21.1911 2Z" fill="currentColor" />
+      <path
+        d="M2.95508 22.0136H7.17691L9.28824 18.9989L7.17691 15.9839L2.95508 22.0136Z"
+        fill="currentColor"
+      />
+      <path
+        d="M2.95508 8.44629L12.4546 22.0134H16.6764L7.17691 8.44629H2.95508Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
+
+export function PerplexityIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M18.4875 2V8.06H20.75V16.6833H18.3042V22L12.44 16.8383V21.9592H11.5308V16.8325L5.66 22V16.6125H3.25V7.99H5.65333V2L11.5308 7.41167V2.15833H12.4392V7.56667L18.4875 2ZM12.44 9.53667V15.6358L17.395 19.9975V14.0333L12.44 9.53667ZM11.5242 9.47L6.56917 13.9683V19.9975L11.5242 15.6358V9.47083V9.47ZM18.3042 15.7867H19.8408V8.9575H13.2167L18.3042 13.5742V15.7867ZM10.8192 8.88667H4.15833V15.7158H5.65833V13.5692L10.8183 8.88583L10.8192 8.88667ZM6.5625 4.06333V7.98833H10.825L6.5625 4.06333ZM17.5783 4.06333L13.3158 7.98833H17.5783V4.06333Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
+
+export function CerebrasIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M11.6535 20.6834C10.4382 20.6834 9.28717 20.4401 8.23625 20.0036C6.66345 19.3453 5.31944 18.2433 4.36862 16.8551C3.4178 15.4669 2.86732 13.7997 2.86732 11.9964C2.86732 10.7943 3.11039 9.65655 3.56078 8.61182C4.22564 7.0519 5.3409 5.72809 6.7421 4.7907C8.1433 3.85331 9.83047 3.30948 11.6535 3.30948V2C10.2594 2 8.92972 2.27907 7.71437 2.78712C5.8985 3.54562 4.35432 4.81217 3.26767 6.40788C2.17386 8.00356 1.5376 9.92844 1.5376 11.9964C1.5376 13.3774 1.82356 14.6941 2.33114 15.8891C3.09609 17.6851 4.38291 19.2093 5.99144 20.2898C7.60713 21.3703 9.55167 22 11.6463 22V20.6834H11.6535Z"
+        fill="currentColor"
+      />
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M7.14949 17.3272C6.32735 16.6403 5.71253 15.8102 5.2979 14.9014C4.88323 13.9927 4.66877 13.0124 4.66877 12.0249C4.66877 11.2378 4.8046 10.4506 5.06911 9.69931C5.34079 8.94794 5.74113 8.23241 6.29159 7.58122C6.9779 6.7655 7.81433 6.15012 8.72225 5.73508C9.63021 5.32005 10.6239 5.11254 11.6105 5.11254C12.3969 5.11254 13.1904 5.24849 13.9411 5.51325C14.6989 5.78516 15.4138 6.18588 16.0643 6.7297L16.9151 5.72077C16.143 5.07676 15.2851 4.59018 14.3843 4.27533C13.4835 3.95332 12.547 3.7959 11.6105 3.7959C10.4309 3.7959 9.25846 4.04634 8.17178 4.54009C7.08514 5.03382 6.09141 5.77087 5.27643 6.73687C4.62587 7.50967 4.14689 8.36119 3.82518 9.25563C3.50347 10.1501 3.34619 11.0875 3.34619 12.0249C3.34619 13.1984 3.59641 14.3719 4.08969 15.4524C4.58298 16.5329 5.32649 17.5276 6.29876 18.3362L7.14949 17.3272Z"
+        fill="currentColor"
+      />
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M9.18714 16.4758C8.32211 16.0179 7.64298 15.3524 7.17829 14.5724C6.7136 13.7925 6.47052 12.8909 6.47052 11.9821C6.47052 11.1807 6.65641 10.3721 7.06388 9.62074C7.52144 8.75492 8.19345 8.08228 8.97983 7.6243C9.76624 7.1592 10.667 6.9159 11.5821 6.9159C12.3828 6.9159 13.1978 7.10194 13.9556 7.50269L14.5704 6.33631C13.6196 5.83541 12.5901 5.59212 11.5749 5.59927C10.424 5.59927 9.28725 5.90697 8.30069 6.48655C7.31412 7.06618 6.46339 7.92487 5.89146 9.00535C5.39101 9.95706 5.14795 10.9803 5.14795 11.9821C5.14795 13.127 5.45536 14.2576 6.04159 15.2379C6.62782 16.2254 7.48568 17.0626 8.57236 17.635L9.18714 16.4758Z"
+        fill="currentColor"
+      />
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M11.6608 15.2165C11.2104 15.2165 10.7815 15.1235 10.3955 14.9589C9.80924 14.7156 9.31596 14.3005 8.96564 13.7782C8.61536 13.2558 8.40804 12.6333 8.40804 11.9606C8.40804 11.5098 8.50095 11.0805 8.66537 10.6941C8.90845 10.1145 9.32309 9.61359 9.84496 9.26297C10.3669 8.91235 10.9888 8.70484 11.6608 8.70484V7.38818C11.0317 7.38818 10.4312 7.517 9.88072 7.74597C9.05858 8.09659 8.36511 8.66905 7.87183 9.39892C7.37142 10.136 7.08545 11.0233 7.08545 11.9678C7.08545 12.5975 7.21412 13.1986 7.4429 13.7496C7.79322 14.5725 8.37228 15.2666 9.10147 15.7603C9.83067 16.2469 10.71 16.5331 11.6608 16.5331V15.2165Z"
+        fill="currentColor"
+      />
+      <path
+        fill-rule="evenodd"
+        clip-rule="evenodd"
+        d="M12.7332 10.9234C12.5831 10.766 12.4187 10.6372 12.2542 10.5442C12.0898 10.4511 11.9183 10.401 11.7395 10.401C11.4965 10.401 11.2891 10.444 11.0961 10.5299C10.9102 10.6157 10.7458 10.7302 10.61 10.8805C10.4741 11.0236 10.374 11.1953 10.3026 11.3814C10.2311 11.5674 10.2025 11.7678 10.2025 11.9681C10.2025 12.1685 10.2382 12.3689 10.3026 12.5549C10.374 12.7409 10.4741 12.9127 10.61 13.0558C10.7458 13.1989 10.9031 13.3206 11.0961 13.4064C11.282 13.4923 11.4965 13.5352 11.7395 13.5352C11.9397 13.5352 12.1327 13.4923 12.3043 13.4136C12.4759 13.3277 12.626 13.2061 12.7475 13.0486L13.6197 13.986C13.491 14.1148 13.3409 14.2293 13.1693 14.3223C12.9978 14.4154 12.8262 14.4941 12.6546 14.5513C12.483 14.6086 12.3114 14.6515 12.1542 14.673C11.9969 14.7016 11.8539 14.7087 11.7395 14.7087C11.3463 14.7087 10.9746 14.6443 10.6314 14.5155C10.2811 14.3868 9.98084 14.2007 9.73064 13.9574C9.47326 13.7213 9.27311 13.4279 9.12298 13.0916C8.97285 12.7553 8.90137 12.376 8.90137 11.9681C8.90137 11.5531 8.97285 11.181 9.12298 10.8447C9.27311 10.5084 9.47326 10.2222 9.73064 9.97887C9.98801 9.74274 10.2883 9.55669 10.6314 9.42075C10.9817 9.29193 11.3535 9.22754 11.7395 9.22754C12.0755 9.22754 12.4115 9.29193 12.7475 9.42075C13.0835 9.54953 13.3838 9.7499 13.634 10.0218L12.7332 10.9234Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
+
+export function MistralIcon({ className }: IconProps) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+      <path d="M7.28516 3.74658H4.1416V6.8809H7.28516V3.74658Z" />
+      <path d="M19.8579 3.74658H16.7144V6.8809H19.8579V3.74658Z" />
+      <path d="M10.4277 6.88086H4.1416V10.0152H10.4277V6.88086Z" />
+      <path d="M19.8588 6.88086H13.5728V10.0152H19.8588V6.88086Z" />
+      <path d="M19.8564 10.0137H4.1416V13.148H19.8564V10.0137Z" />
+      <path d="M7.28516 13.1484H4.1416V16.2828H7.28516V13.1484Z" />
+      <path d="M13.5723 13.1484H10.4287V16.2828H13.5723V13.1484Z" />
+      <path d="M19.8579 13.1484H16.7144V16.2828H19.8579V13.1484Z" />
+      <path d="M10.4286 16.2812H1V19.4157H10.4286V16.2812Z" />
+      <path d="M23.0024 16.2812H13.5728V19.4157H23.0024V16.2812Z" />
+    </svg>
+  );
+}
+
+export function AzureIcon({ className }: IconProps) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 24 24"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path d="M13.05 4.24L6.56 18.05l2.77-.46 1.89-4.55 4.2 5.19.03-.01 2.99.53L13.05 4.24zm-4.1 7.51L2.49 20.21h5.23l1.23-3.04v-5.42z" />
+    </svg>
+  );
+}
+
diff --git a/apps/webapp/app/assets/icons/AnthropicLogoIcon.tsx b/apps/webapp/app/assets/icons/AnthropicLogoIcon.tsx
new file mode 100644
index 00000000000..3e647284cce
--- /dev/null
+++ b/apps/webapp/app/assets/icons/AnthropicLogoIcon.tsx
@@ -0,0 +1,12 @@
+export function AnthropicLogoIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 24 24"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path d="M17.3041 3.541h-3.6718l6.696 16.918H24Zm-10.6082 0L0 20.459h3.7442l1.3693-3.5527h7.0052l1.3693 3.5528h3.7442L10.5363 3.5409Zm-.3712 10.2232 2.2914-5.9456 2.2914 5.9456Z" />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/ArrowTopRightBottomLeftIcon.tsx b/apps/webapp/app/assets/icons/ArrowTopRightBottomLeftIcon.tsx
new file mode 100644
index 00000000000..c49aa8cb0c2
--- /dev/null
+++ b/apps/webapp/app/assets/icons/ArrowTopRightBottomLeftIcon.tsx
@@ -0,0 +1,22 @@
+export function ArrowTopRightBottomLeftIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M14.8258 10.5L20.125 5.20083V8.5625C20.125 9.08027 20.5447 9.5 21.0625 9.5C21.5803 9.5 22 9.08027 22 8.5625V2.9375C22 2.41973 21.5803 2 21.0625 2H15.4375C14.9197 2 14.5 2.41973 14.5 2.9375C14.5 3.45527 14.9197 3.875 15.4375 3.875H18.7992L13.5 9.17417C13.1339 9.54029 13.1339 10.1339 13.5 10.5C13.8661 10.8661 14.4597 10.8661 14.8258 10.5Z"
+        fill="currentColor"
+      />
+      <path
+        d="M2 21.0625V15.4375C2 14.9197 2.41973 14.5 2.9375 14.5C3.45527 14.5 3.875 14.9197 3.875 15.4375V18.7992L9.17417 13.5C9.54029 13.1339 10.1339 13.1339 10.5 13.5C10.8661 13.8661 10.8661 14.4597 10.5 14.8258L5.20083 20.125H8.5625C9.08027 20.125 9.5 20.5447 9.5 21.0625C9.5 21.5803 9.08027 22 8.5625 22H2.9375C2.69757 22 2.45765 21.9085 2.27459 21.7254C2.1847 21.6355 2.11689 21.5319 2.07114 21.4214C2.0253 21.3108 2 21.1896 2 21.0625Z"
+        fill="currentColor"
+      />
+      <path
+        d="M14.8258 10.5L20.125 5.20083V10C20.125 10.5178 20.5447 10.9375 21.0625 10.9375C21.5803 10.9375 22 10.5178 22 10V2.9375C22 2.41973 21.5803 2 21.0625 2H14C13.4822 2 13.0625 2.41973 13.0625 2.9375C13.0625 3.45527 13.4822 3.875 14 3.875H18.7992L13.5 9.17417C13.1339 9.54029 13.1339 10.1339 13.5 10.5C13.8661 10.8661 14.4597 10.8661 14.8258 10.5Z"
+        fill="currentColor"
+      />
+      <path
+        d="M2 21.0625V13.9375C2 13.4197 2.41973 13 2.9375 13C3.45527 13 3.875 13.4197 3.875 13.9375V18.7992L9.17417 13.5C9.54029 13.1339 10.1339 13.1339 10.5 13.5C10.8661 13.8661 10.8661 14.4597 10.5 14.8258L5.20083 20.125H10.0625C10.5803 20.125 11 20.5447 11 21.0625C11 21.5803 10.5803 22 10.0625 22H2.9375C2.69757 22 2.45765 21.9085 2.27459 21.7254C2.1847 21.6355 2.11689 21.5319 2.07114 21.4214C2.0253 21.3108 2 21.1896 2 21.0625Z"
+        fill="currentColor"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/ChevronExtraSmallDown.tsx b/apps/webapp/app/assets/icons/ChevronExtraSmallDown.tsx
new file mode 100644
index 00000000000..134cbe4dfda
--- /dev/null
+++ b/apps/webapp/app/assets/icons/ChevronExtraSmallDown.tsx
@@ -0,0 +1,13 @@
+export function ChevronExtraSmallDown({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 18 18" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M15 6L9.75926 12.1142C9.36016 12.5798 8.63984 12.5798 8.24074 12.1142L3 6"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeMiterlimit="1.00244"
+        strokeLinecap="round"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/ChevronExtraSmallUp.tsx b/apps/webapp/app/assets/icons/ChevronExtraSmallUp.tsx
new file mode 100644
index 00000000000..710eeccdf20
--- /dev/null
+++ b/apps/webapp/app/assets/icons/ChevronExtraSmallUp.tsx
@@ -0,0 +1,13 @@
+export function ChevronExtraSmallUp({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 18 18" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        d="M3 12L8.24074 5.8858C8.63984 5.42019 9.36016 5.42019 9.75926 5.8858L15 12"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeMiterlimit="1.00244"
+        strokeLinecap="round"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/LogsIcon.tsx b/apps/webapp/app/assets/icons/LogsIcon.tsx
new file mode 100644
index 00000000000..3178da237e7
--- /dev/null
+++ b/apps/webapp/app/assets/icons/LogsIcon.tsx
@@ -0,0 +1,66 @@
+export function LogsIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <circle cx="4" cy="10" r="1" fill="currentColor" />
+      <circle cx="4" cy="5" r="1" fill="currentColor" />
+      <circle cx="4" cy="14" r="1" fill="currentColor" />
+      <circle cx="4" cy="19" r="1" fill="currentColor" />
+      <path
+        d="M7 9.75L10 9.75"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M7 5L10 5"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M7 14.25H10"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M7 19H10"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M13 5H20"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M13 9.75H20"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M13 14.25H20"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M13 19H20"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/assets/icons/SlackMonoIcon.tsx b/apps/webapp/app/assets/icons/SlackMonoIcon.tsx
new file mode 100644
index 00000000000..666393a229d
--- /dev/null
+++ b/apps/webapp/app/assets/icons/SlackMonoIcon.tsx
@@ -0,0 +1,10 @@
+export function SlackMonoIcon({ className }: { className?: string }) {
+  return (
+    <svg className={className} viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+      <path d="M5.042 15.165a2.528 2.528 0 0 1-2.52 2.523A2.528 2.528 0 0 1 0 15.165a2.527 2.527 0 0 1 2.522-2.52h2.52v2.52zm1.271 0a2.527 2.527 0 0 1 2.521-2.52 2.527 2.527 0 0 1 2.521 2.52v6.313A2.528 2.528 0 0 1 8.834 24a2.528 2.528 0 0 1-2.521-2.522v-6.313z" />
+      <path d="M8.834 5.042a2.528 2.528 0 0 1-2.521-2.52A2.528 2.528 0 0 1 8.834 0a2.528 2.528 0 0 1 2.521 2.522v2.52H8.834zm0 1.271a2.528 2.528 0 0 1 2.521 2.521 2.528 2.528 0 0 1-2.521 2.521H2.522A2.528 2.528 0 0 1 0 8.834a2.528 2.528 0 0 1 2.522-2.521h6.312z" />
+      <path d="M18.956 8.834a2.528 2.528 0 0 1 2.522-2.521A2.528 2.528 0 0 1 24 8.834a2.528 2.528 0 0 1-2.522 2.521h-2.522V8.834zm-1.27 0a2.528 2.528 0 0 1-2.522 2.521 2.527 2.527 0 0 1-2.521-2.521V2.522A2.527 2.527 0 0 1 15.165 0a2.528 2.528 0 0 1 2.522 2.522v6.312z" />
+      <path d="M15.165 18.956a2.528 2.528 0 0 1 2.522 2.522A2.528 2.528 0 0 1 15.165 24a2.527 2.527 0 0 1-2.521-2.522v-2.522h2.521zm0-1.27a2.527 2.527 0 0 1-2.521-2.522 2.528 2.528 0 0 1 2.521-2.521h6.313A2.528 2.528 0 0 1 24 15.165a2.528 2.528 0 0 1-2.522 2.522h-6.313z" />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/components/AlphaBadge.tsx b/apps/webapp/app/components/AlphaBadge.tsx
new file mode 100644
index 00000000000..0a1c4a7fc9a
--- /dev/null
+++ b/apps/webapp/app/components/AlphaBadge.tsx
@@ -0,0 +1,61 @@
+import { cn } from "~/utils/cn";
+import { Badge } from "./primitives/Badge";
+import { SimpleTooltip } from "./primitives/Tooltip";
+
+export function AlphaBadge({
+  inline = false,
+  className,
+}: {
+  inline?: boolean;
+  className?: string;
+}) {
+  return (
+    <SimpleTooltip
+      button={
+        <Badge variant="extra-small" className={cn(inline ? "inline-grid" : "", className)}>
+          Alpha
+        </Badge>
+      }
+      content="This feature is in Alpha."
+      disableHoverableContent
+    />
+  );
+}
+
+export function AlphaTitle({ children }: { children: React.ReactNode }) {
+  return (
+    <>
+      <span>{children}</span>
+      <AlphaBadge />
+    </>
+  );
+}
+
+export function BetaBadge({
+  inline = false,
+  className,
+}: {
+  inline?: boolean;
+  className?: string;
+}) {
+  return (
+    <SimpleTooltip
+      button={
+        <Badge variant="extra-small" className={cn(inline ? "inline-grid" : "", className)}>
+          Beta
+        </Badge>
+      }
+      content="This feature is in Beta."
+      disableHoverableContent
+    />
+  );
+}
+
+export function BetaTitle({ children }: { children: React.ReactNode }) {
+  return (
+    <>
+      <span>{children}</span>
+      <BetaBadge />
+    </>
+  );
+}
diff --git a/apps/webapp/app/components/AskAI.tsx b/apps/webapp/app/components/AskAI.tsx
index 39cc4cdaaf3..814d4649c8f 100644
--- a/apps/webapp/app/components/AskAI.tsx
+++ b/apps/webapp/app/components/AskAI.tsx
@@ -5,6 +5,7 @@ import {
   HandThumbUpIcon,
   StopIcon,
 } from "@heroicons/react/20/solid";
+import { cn } from "~/utils/cn";
 import { type FeedbackComment, KapaProvider, type QA, useChat } from "@kapaai/react-sdk";
 import { useSearchParams } from "@remix-run/react";
 import DOMPurify from "dompurify";
@@ -37,7 +38,7 @@ function useKapaWebsiteId() {
   return routeMatch?.kapa.websiteId;
 }
 
-export function AskAI() {
+export function AskAI({ isCollapsed = false }: { isCollapsed?: boolean }) {
   const { isManagedCloud } = useFeatures();
   const websiteId = useKapaWebsiteId();
 
@@ -54,21 +55,23 @@ export function AskAI() {
           hideShortcutKey
           data-modal-override-open-class-ask-ai="true"
           disabled
+          className={isCollapsed ? "w-full justify-center" : ""}
         >
           <AISparkleIcon className="size-5" />
         </Button>
       }
     >
-      {() => <AskAIProvider websiteId={websiteId} />}
+      {() => <AskAIProvider websiteId={websiteId} isCollapsed={isCollapsed} />}
     </ClientOnly>
   );
 }
 
 type AskAIProviderProps = {
   websiteId: string;
+  isCollapsed?: boolean;
 };
 
-function AskAIProvider({ websiteId }: AskAIProviderProps) {
+function AskAIProvider({ websiteId, isCollapsed = false }: AskAIProviderProps) {
   const [isOpen, setIsOpen] = useState(false);
   const [initialQuery, setInitialQuery] = useState<string | undefined>();
   const [searchParams, setSearchParams] = useSearchParams();
@@ -112,28 +115,39 @@ function AskAIProvider({ websiteId }: AskAIProviderProps) {
       }}
       botProtectionMechanism="hcaptcha"
     >
-      <TooltipProvider disableHoverableContent>
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <div className="inline-flex">
-              <Button
-                variant="small-menu-item"
-                data-action="ask-ai"
-                shortcut={{ modifiers: ["mod"], key: "/", enabledOnInputElements: true }}
-                hideShortcutKey
-                data-modal-override-open-class-ask-ai="true"
-                onClick={() => openAskAI()}
-              >
-                <AISparkleIcon className="size-5" />
-              </Button>
-            </div>
-          </TooltipTrigger>
-          <TooltipContent side="top" className="flex items-center gap-1 py-1.5 pl-2.5 pr-2 text-xs">
-            Ask AI
-            <ShortcutKey shortcut={{ modifiers: ["mod"], key: "/" }} variant="medium/bright" />
-          </TooltipContent>
-        </Tooltip>
-      </TooltipProvider>
+      <motion.div layout="position" transition={{ duration: 0.2, ease: "easeInOut" }}>
+        <TooltipProvider disableHoverableContent>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <span className={cn("inline-flex h-8", isCollapsed && "w-full")}>
+                <Button
+                  variant="small-menu-item"
+                  data-action="ask-ai"
+                  shortcut={{ modifiers: ["mod"], key: "i", enabledOnInputElements: true }}
+                  hideShortcutKey
+                  data-modal-override-open-class-ask-ai="true"
+                  onClick={() => openAskAI()}
+                  fullWidth={isCollapsed}
+                  className={cn("h-full", isCollapsed && "justify-center")}
+                >
+                  <AISparkleIcon className="size-5" />
+                </Button>
+              </span>
+            </TooltipTrigger>
+            <TooltipContent
+              side="right"
+              sideOffset={8}
+              className="flex items-center gap-2 text-xs"
+            >
+              Ask AI
+              <span className="flex items-center">
+                <ShortcutKey shortcut={{ modifiers: ["mod"] }} variant="medium/bright" />
+                <ShortcutKey shortcut={{ key: "i" }} variant="medium/bright" />
+              </span>
+            </TooltipContent>
+          </Tooltip>
+        </TooltipProvider>
+      </motion.div>
       <AskAIDialog
         initialQuery={initialQuery}
         isOpen={isOpen}
diff --git a/apps/webapp/app/components/BackgroundWrapper.tsx b/apps/webapp/app/components/BackgroundWrapper.tsx
index ecff3af6dd4..aaf06d56aaf 100644
--- a/apps/webapp/app/components/BackgroundWrapper.tsx
+++ b/apps/webapp/app/components/BackgroundWrapper.tsx
@@ -5,10 +5,9 @@ import blurredDashboardBackgroundTable from "~/assets/images/blurred-dashboard-b
 
 export function BackgroundWrapper({ children }: { children: ReactNode }) {
   return (
-    <div className="relative h-full w-full overflow-hidden">
-      {/* Left menu top background - fixed width 260px, maintains aspect ratio */}
+    <div className="relative h-full w-full overflow-hidden bg-background-dimmed lg:bg-transparent">
       <div
-        className="absolute left-0 top-0 w-[260px] bg-contain bg-left-top bg-no-repeat"
+        className="absolute left-0 top-0 hidden w-[260px] bg-contain bg-left-top bg-no-repeat lg:block"
         style={{
           backgroundImage: `url(${blurredDashboardBackgroundMenuTop})`,
           aspectRatio: "auto",
@@ -17,9 +16,8 @@ export function BackgroundWrapper({ children }: { children: ReactNode }) {
         }}
       />
 
-      {/* Left menu bottom background - fixed width 260px, maintains aspect ratio */}
       <div
-        className="absolute bottom-0 left-0 w-[260px] bg-contain bg-left-bottom bg-no-repeat"
+        className="absolute bottom-0 left-0 hidden w-[260px] bg-contain bg-left-bottom bg-no-repeat lg:block"
         style={{
           backgroundImage: `url(${blurredDashboardBackgroundMenuBottom})`,
           aspectRatio: "auto",
@@ -28,9 +26,8 @@ export function BackgroundWrapper({ children }: { children: ReactNode }) {
         }}
       />
 
-      {/* Right table background - fixed width 2000px, positioned next to menu */}
       <div
-        className="absolute top-0 bg-left-top bg-no-repeat"
+        className="absolute top-0 hidden bg-left-top bg-no-repeat lg:block"
         style={{
           left: "260px",
           backgroundImage: `url(${blurredDashboardBackgroundTable})`,
@@ -41,7 +38,6 @@ export function BackgroundWrapper({ children }: { children: ReactNode }) {
         }}
       />
 
-      {/* Content layer */}
       <div className="relative z-10 h-full w-full">{children}</div>
     </div>
   );
diff --git a/apps/webapp/app/components/BlankStatePanels.tsx b/apps/webapp/app/components/BlankStatePanels.tsx
index d0e798f1685..fe39f6785c5 100644
--- a/apps/webapp/app/components/BlankStatePanels.tsx
+++ b/apps/webapp/app/components/BlankStatePanels.tsx
@@ -8,10 +8,10 @@ import {
   QuestionMarkCircleIcon,
   RectangleGroupIcon,
   RectangleStackIcon,
-  ServerStackIcon,
   Squares2X2Icon,
 } from "@heroicons/react/20/solid";
 import { useLocation } from "react-use";
+import { AIPromptsIcon } from "~/assets/icons/AIPromptsIcon";
 import { BranchEnvironmentIconSmall } from "~/assets/icons/EnvironmentIcons";
 import { WaitpointTokenIcon } from "~/assets/icons/WaitpointTokenIcon";
 import openBulkActionsPanel from "~/assets/images/open-bulk-actions-panel.png";
@@ -23,21 +23,28 @@ import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { type MinimumEnvironment } from "~/presenters/SelectBestEnvironmentPresenter.server";
 import { NewBranchPanel } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route";
+import { GitHubSettingsPanel } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
 import {
   docsPath,
   v3BillingPath,
   v3CreateBulkActionPath,
   v3EnvironmentPath,
-  v3EnvironmentVariablesPath,
   v3NewProjectAlertPath,
   v3NewSchedulePath,
 } from "~/utils/pathBuilder";
 import { AskAI } from "./AskAI";
+import { CodeBlock } from "./code/CodeBlock";
 import { InlineCode } from "./code/InlineCode";
 import { environmentFullTitle, EnvironmentIcon } from "./environments/EnvironmentLabel";
 import { Feedback } from "./Feedback";
 import { EnvironmentSelector } from "./navigation/EnvironmentSelector";
 import { Button, LinkButton } from "./primitives/Buttons";
+import {
+  ClientTabs,
+  ClientTabsContent,
+  ClientTabsList,
+  ClientTabsTrigger,
+} from "./primitives/ClientTabs";
 import { Header1 } from "./primitives/Headers";
 import { InfoPanel } from "./primitives/InfoPanel";
 import { Paragraph } from "./primitives/Paragraph";
@@ -52,13 +59,6 @@ import {
 } from "./SetupCommands";
 import { StepContentContainer } from "./StepContentContainer";
 import { V4Badge } from "./V4Badge";
-import {
-  ClientTabs,
-  ClientTabsContent,
-  ClientTabsList,
-  ClientTabsTrigger,
-} from "./primitives/ClientTabs";
-import { GitHubSettingsPanel } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
 
 export function HasNoTasksDev() {
   return (
@@ -599,9 +599,11 @@ function DeploymentOnboardingSteps() {
   return (
     <PackageManagerProvider>
       <div className="mb-2 flex items-center justify-between border-b">
-        <div className="mb-2 flex items-center gap-2">
-          <EnvironmentIcon environment={environment} className="-ml-1 size-8" />
-          <Header1>Deploy your tasks to {environmentFullTitle(environment)}</Header1>
+        <div className="mb-2 flex min-w-0 items-center gap-2">
+          <EnvironmentIcon environment={environment} className="-ml-1 size-8 shrink-0" />
+          <Header1 className="truncate">
+            Deploy your tasks to {environmentFullTitle(environment)}
+          </Header1>
         </div>
         <div className="flex items-center">
           <SimpleTooltip
@@ -653,7 +655,7 @@ function DeploymentOnboardingSteps() {
                 organizationSlug={organization.slug}
                 projectSlug={project.slug}
                 environmentSlug={environment.slug}
-                billingPath={v3BillingPath({ slug: organization.slug })}              
+                billingPath={v3BillingPath({ slug: organization.slug })}
               />
             </div>
           </StepContentContainer>
@@ -686,3 +688,50 @@ function DeploymentOnboardingSteps() {
     </PackageManagerProvider>
   );
 }
+
+export function PromptsNone() {
+  return (
+    <InfoPanel
+      title="Define your first prompt"
+      icon={AIPromptsIcon}
+      iconClassName="text-aiPrompts"
+      panelClassName="max-w-lg"
+      accessory={
+        <LinkButton
+          to={docsPath("prompt-management")}
+          variant="docs/small"
+          LeadingIcon={BookOpenIcon}
+        >
+          Prompts docs
+        </LinkButton>
+      }
+    >
+      <Paragraph spacing variant="small">
+        Managed prompts let you define AI prompts in code with typesafe variables, then edit and
+        version them from the dashboard without redeploying.
+      </Paragraph>
+      <Paragraph spacing variant="small">
+        Add a prompt to your project using <InlineCode variant="small">prompts.define()</InlineCode>
+        :
+      </Paragraph>
+      <CodeBlock
+        code={`import { prompts } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const myPrompt = prompts.define({
+  id: "my-prompt",
+  variables: z.object({
+    name: z.string(),
+  }),
+  content: \`Hello {{name}}!\`,
+});`}
+        showLineNumbers={false}
+        showOpenInModal={false}
+      />
+      <Paragraph variant="small" className="mt-2">
+        Deploy your project and your prompts will appear here with version history and a live
+        editor.
+      </Paragraph>
+    </InfoPanel>
+  );
+}
diff --git a/apps/webapp/app/components/BulkActionFilterSummary.tsx b/apps/webapp/app/components/BulkActionFilterSummary.tsx
index 073940d7d0a..a230e70b346 100644
--- a/apps/webapp/app/components/BulkActionFilterSummary.tsx
+++ b/apps/webapp/app/components/BulkActionFilterSummary.tsx
@@ -228,6 +228,18 @@ export function BulkActionFilterSummary({
                     />
                   );
                 }
+                case "errorId": {
+                  return (
+                    <AppliedFilter
+                      variant="minimal/medium"
+                      key={key}
+                      label={"Error ID"}
+                      icon={filterIcon(key)}
+                      value={value}
+                      removable={false}
+                    />
+                  );
+                }
                 default: {
                   assertNever(typedKey);
                 }
diff --git a/apps/webapp/app/components/ErrorDisplay.tsx b/apps/webapp/app/components/ErrorDisplay.tsx
index 1a8f4b2ad94..5787a2edbac 100644
--- a/apps/webapp/app/components/ErrorDisplay.tsx
+++ b/apps/webapp/app/components/ErrorDisplay.tsx
@@ -1,11 +1,10 @@
 import { HomeIcon } from "@heroicons/react/20/solid";
 import { isRouteErrorResponse, useRouteError } from "@remix-run/react";
-import { motion } from "framer-motion";
 import { friendlyErrorDisplay } from "~/utils/httpErrors";
 import { LinkButton } from "./primitives/Buttons";
 import { Header1 } from "./primitives/Headers";
 import { Paragraph } from "./primitives/Paragraph";
-import Spline from "@splinetool/react-spline";
+import { TriggerRotatingLogo } from "./TriggerRotatingLogo";
 import { type ReactNode } from "react";
 
 type ErrorDisplayOptions = {
@@ -57,14 +56,7 @@ export function ErrorDisplay({ title, message, button }: DisplayOptionsProps) {
           {button ? button.title : "Go to homepage"}
         </LinkButton>
       </div>
-      <motion.div
-        className="pointer-events-none absolute inset-0 overflow-hidden"
-        initial={{ opacity: 0 }}
-        animate={{ opacity: 1 }}
-        transition={{ delay: 0.5, duration: 2, ease: "easeOut" }}
-      >
-        <Spline scene="https://prod.spline.design/wRly8TZN-e0Twb8W/scene.splinecode" />
-      </motion.div>
+      <TriggerRotatingLogo />
     </div>
   );
 }
diff --git a/apps/webapp/app/components/GitHubLoginButton.tsx b/apps/webapp/app/components/GitHubLoginButton.tsx
index 87238db087e..76a494927cd 100644
--- a/apps/webapp/app/components/GitHubLoginButton.tsx
+++ b/apps/webapp/app/components/GitHubLoginButton.tsx
@@ -32,8 +32,6 @@ export function OctoKitty({ className }: { className?: string }) {
       baseProfile="tiny"
       id="Layer_1"
       xmlns="http://www.w3.org/2000/svg"
-      x="0px"
-      y="0px"
       viewBox="0 0 2350 2314.8"
       xmlSpace="preserve"
       fill="currentColor"
diff --git a/apps/webapp/app/components/GitMetadata.tsx b/apps/webapp/app/components/GitMetadata.tsx
index efe3fb0efb7..fb53ee6bfea 100644
--- a/apps/webapp/app/components/GitMetadata.tsx
+++ b/apps/webapp/app/components/GitMetadata.tsx
@@ -25,9 +25,10 @@ export function GitMetadataBranch({
         <LinkButton
           variant="minimal/small"
           LeadingIcon={<GitBranchIcon className="size-4" />}
+          leadingIconClassName="group-hover/table-row:text-text-bright"
           iconSpacing="gap-x-1"
           to={git.branchUrl}
-          className="pl-1"
+          className="pl-1 duration-0 [&_span]:duration-0 [&_span]:group-hover/table-row:text-text-bright"
         >
           {git.branchName}
         </LinkButton>
@@ -49,8 +50,9 @@ export function GitMetadataCommit({
           variant="minimal/small"
           to={git.commitUrl}
           LeadingIcon={<GitCommitIcon className="size-4" />}
+          leadingIconClassName="group-hover/table-row:text-text-bright"
           iconSpacing="gap-x-1"
-          className="pl-1"
+          className="pl-1 duration-0 [&_span]:duration-0 [&_span]:group-hover/table-row:text-text-bright"
         >
           {`${git.shortSha} / ${git.commitMessage}`}
         </LinkButton>
@@ -74,8 +76,9 @@ export function GitMetadataPullRequest({
           variant="minimal/small"
           to={git.pullRequestUrl}
           LeadingIcon={<GitPullRequestIcon className="size-4" />}
+          leadingIconClassName="group-hover/table-row:text-text-bright"
           iconSpacing="gap-x-1"
-          className="pl-1"
+          className="pl-1 duration-0 [&_span]:duration-0 [&_span]:group-hover/table-row:text-text-bright"
         >
           #{git.pullRequestNumber} {git.pullRequestTitle}
         </LinkButton>
diff --git a/apps/webapp/app/components/LogLevelTooltipInfo.tsx b/apps/webapp/app/components/LogLevelTooltipInfo.tsx
new file mode 100644
index 00000000000..2a8093af066
--- /dev/null
+++ b/apps/webapp/app/components/LogLevelTooltipInfo.tsx
@@ -0,0 +1,56 @@
+import { Header3 } from "./primitives/Headers";
+import { Paragraph } from "./primitives/Paragraph";
+import { LogLevel } from "./logs/LogLevel";
+
+export function LogLevelTooltipInfo() {
+  return (
+    <div className="flex max-w-xs flex-col gap-4 p-1 pb-2">
+      <div>
+        <Header3>Log Levels</Header3>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Structured logging helps you debug and monitor your tasks.
+        </Paragraph>
+      </div>
+      <div>
+        <div className="mb-1">
+          <LogLevel level="TRACE" />
+        </div>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Traces and spans representing the execution flow of your tasks.
+        </Paragraph>
+      </div>
+      <div>
+        <div className="mb-1">
+          <LogLevel level="INFO" />
+        </div>
+        <Paragraph variant="small" className="text-text-dimmed">
+          General informational messages about task execution.
+        </Paragraph>
+      </div>
+      <div>
+        <div className="mb-1">
+          <LogLevel level="WARN" />
+        </div>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Warning messages indicating potential issues that don't prevent execution.
+        </Paragraph>
+      </div>
+      <div>
+        <div className="mb-1">
+          <LogLevel level="ERROR" />
+        </div>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Error messages for failures and exceptions during task execution.
+        </Paragraph>
+      </div>
+      <div>
+        <div className="mb-1">
+          <LogLevel level="DEBUG" />
+        </div>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Detailed diagnostic information for development and debugging.
+        </Paragraph>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/LoginPageLayout.tsx b/apps/webapp/app/components/LoginPageLayout.tsx
index d9ac7ceb4d7..3e42cd6894f 100644
--- a/apps/webapp/app/components/LoginPageLayout.tsx
+++ b/apps/webapp/app/components/LoginPageLayout.tsx
@@ -46,10 +46,10 @@ export function LoginPageLayout({ children }: { children: React.ReactNode }) {
   }, []);
 
   return (
-    <main className="grid h-full grid-cols-1 md:grid-cols-2">
-      <div className="border-r border-grid-bright bg-background-bright">
-        <div className="flex h-full flex-col items-center justify-between p-6">
-          <div className="flex w-full items-center justify-between">
+    <main className="grid h-full grid-cols-1 lg:grid-cols-2">
+      <div className="bg-background-dimmed lg:border-r lg:border-grid-bright lg:bg-background-bright">
+        <div className="flex h-full flex-col items-center justify-center p-6 lg:justify-between">
+          <div className="hidden w-full items-center justify-between lg:flex">
             <a href="https://trigger.dev">
               <LogoType className="w-36" />
             </a>
@@ -63,12 +63,12 @@ export function LoginPageLayout({ children }: { children: React.ReactNode }) {
           </div>
           <div className="flex h-full max-w-sm items-center justify-center">{children}</div>
           <Paragraph variant="small" className="text-center">
-            Having login issues? <TextLink href="https://@trigger.dev/contact">Email us</TextLink>{" "}
+            Having login issues? <TextLink href="https://trigger.dev/contact">Email us</TextLink>{" "}
             or <TextLink href="https://trigger.dev/discord">ask us in Discord</TextLink>
           </Paragraph>
         </div>
       </div>
-      <div className="hidden grid-rows-[1fr_auto] pb-6 md:grid">
+      <div className="hidden grid-rows-[1fr_auto] pb-6 lg:grid">
         <div className="flex h-full flex-col items-center justify-center px-16">
           <Header3 className="relative text-center text-2xl font-normal leading-8 text-text-dimmed transition before:relative before:right-1 before:top-0 before:text-6xl before:text-charcoal-750 before:content-['❝'] lg-height:text-xl md-height:text-lg">
             {randomQuote?.quote}
diff --git a/apps/webapp/app/components/Shortcuts.tsx b/apps/webapp/app/components/Shortcuts.tsx
index b21c556595b..2decc82c914 100644
--- a/apps/webapp/app/components/Shortcuts.tsx
+++ b/apps/webapp/app/components/Shortcuts.tsx
@@ -1,18 +1,17 @@
 import { Keyboard } from "lucide-react";
+import { useState } from "react";
+import { useShortcutKeys } from "~/hooks/useShortcutKeys";
+import { Button } from "./primitives/Buttons";
 import { Header3 } from "./primitives/Headers";
 import { Paragraph } from "./primitives/Paragraph";
 import {
   Sheet,
   SheetContent,
-  SheetDescription,
   SheetHeader,
   SheetTitle,
-  SheetTrigger,
+  SheetTrigger
 } from "./primitives/SheetV3";
 import { ShortcutKey } from "./primitives/ShortcutKey";
-import { Button } from "./primitives/Buttons";
-import { useState } from "react";
-import { useShortcutKeys } from "~/hooks/useShortcutKeys";
 
 export function Shortcuts() {
   return (
@@ -26,8 +25,8 @@ export function Shortcuts() {
           fullWidth
           textAlignLeft
           shortcut={{ modifiers: ["shift"], key: "?", enabled: false }}
-          className="gap-x-0 pl-0.5"
-          iconSpacing="gap-x-0.5"
+          className="gap-x-0 pl-1.5"
+          iconSpacing="gap-x-1.5"
         >
           Shortcuts
         </Button>
@@ -77,11 +76,16 @@ function ShortcutContent() {
               <ShortcutKey shortcut={{ key: "enter" }} variant="medium/bright" />
             </Shortcut>
             <Shortcut name="Ask AI">
-              <ShortcutKey shortcut={{ modifiers: ["mod"], key: "/" }} variant="medium/bright" />
+              <ShortcutKey shortcut={{ modifiers: ["mod"] }} variant="medium/bright" />
+              <ShortcutKey shortcut={{ key: "i" }} variant="medium/bright" />
             </Shortcut>
             <Shortcut name="Filter">
               <ShortcutKey shortcut={{ key: "f" }} variant="medium/bright" />
             </Shortcut>
+            <Shortcut name="Toggle side menu">
+              <ShortcutKey shortcut={{ modifiers: ["mod"]}} variant="medium/bright" />
+              <ShortcutKey shortcut={{ key: "b" }} variant="medium/bright" />
+            </Shortcut>
             <Shortcut name="Select filter">
               <ShortcutKey shortcut={{ key: "1" }} variant="medium/bright" />
               <Paragraph variant="small" className="ml-1.5">
@@ -134,9 +138,9 @@ function ShortcutContent() {
               <ShortcutKey shortcut={{ key: "arrowleft" }} variant="medium/bright" />
               <ShortcutKey shortcut={{ key: "arrowright" }} variant="medium/bright" />
             </Shortcut>
-            <Shortcut name="Jump to adjacent">
-              <ShortcutKey shortcut={{ key: "[" }} variant="medium/bright" />
-              <ShortcutKey shortcut={{ key: "]" }} variant="medium/bright" />
+            <Shortcut name="Jump to next/previous run">
+              <ShortcutKey shortcut={{ key: "j" }} variant="medium/bright" />
+              <ShortcutKey shortcut={{ key: "k" }} variant="medium/bright" />
             </Shortcut>
             <Shortcut name="Expand all">
               <ShortcutKey shortcut={{ key: "e" }} variant="medium/bright" />
@@ -158,6 +162,43 @@ function ShortcutContent() {
               <ShortcutKey shortcut={{ key: "p" }} variant="medium/bright" />
             </Shortcut>
           </div>
+          <div className="space-y-3">
+            <Header3>Logs page</Header3>
+            <Shortcut name="Filter by task">
+              <ShortcutKey shortcut={{ key: "t" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Filter by run ID">
+              <ShortcutKey shortcut={{ key: "i" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Filter by level">
+              <ShortcutKey shortcut={{ key: "l" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Select log level">
+              <ShortcutKey shortcut={{ key: "1" }} variant="medium/bright" />
+              <Paragraph variant="small" className="ml-1.5">
+                to
+              </Paragraph>
+              <ShortcutKey shortcut={{ key: "4" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Close detail panel">
+              <ShortcutKey shortcut={{ key: "esc" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Details tab">
+              <ShortcutKey shortcut={{ key: "d" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="Run tab">
+              <ShortcutKey shortcut={{ key: "r" }} variant="medium/bright" />
+            </Shortcut>
+            <Shortcut name="View full run">
+              <ShortcutKey shortcut={{ key: "v" }} variant="medium/bright" />
+            </Shortcut>
+          </div>
+          <div className="space-y-3">
+            <Header3>Metrics page</Header3>
+            <Shortcut name="Toggle fullscreen chart">
+              <ShortcutKey shortcut={{ key: "v" }} variant="medium/bright" />
+            </Shortcut>
+          </div>
           <div className="space-y-3">
             <Header3>Schedules page</Header3>
             <Shortcut name="New schedule">
diff --git a/apps/webapp/app/components/TimezoneSetter.tsx b/apps/webapp/app/components/TimezoneSetter.tsx
new file mode 100644
index 00000000000..3481af6571d
--- /dev/null
+++ b/apps/webapp/app/components/TimezoneSetter.tsx
@@ -0,0 +1,30 @@
+import { useFetcher } from "@remix-run/react";
+import { useEffect, useRef } from "react";
+import { useTypedLoaderData } from "remix-typedjson";
+import type { loader } from "~/root";
+
+export function TimezoneSetter() {
+  const { timezone: storedTimezone } = useTypedLoaderData<typeof loader>();
+  const fetcher = useFetcher();
+  const hasSetTimezone = useRef(false);
+
+  useEffect(() => {
+    if (hasSetTimezone.current) return;
+
+    const browserTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+    if (browserTimezone && browserTimezone !== storedTimezone) {
+      hasSetTimezone.current = true;
+      fetcher.submit(
+        { timezone: browserTimezone },
+        {
+          method: "POST",
+          action: "/resources/timezone",
+          encType: "application/json",
+        }
+      );
+    }
+  }, [storedTimezone, fetcher]);
+
+  return null;
+}
diff --git a/apps/webapp/app/components/TriggerRotatingLogo.tsx b/apps/webapp/app/components/TriggerRotatingLogo.tsx
new file mode 100644
index 00000000000..878c203a3ca
--- /dev/null
+++ b/apps/webapp/app/components/TriggerRotatingLogo.tsx
@@ -0,0 +1,75 @@
+import { motion } from "framer-motion";
+import { useEffect, useState } from "react";
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      "spline-viewer": React.DetailedHTMLProps<
+        React.HTMLAttributes<HTMLElement> & {
+          url?: string;
+          "loading-anim-type"?: string;
+        },
+        HTMLElement
+      >;
+    }
+  }
+
+  interface Window {
+    __splineLoader?: Promise<void>;
+  }
+}
+
+export function TriggerRotatingLogo() {
+  const [isSplineReady, setIsSplineReady] = useState(false);
+
+  useEffect(() => {
+    // Already registered from a previous render
+    if (customElements.get("spline-viewer")) {
+      setIsSplineReady(true);
+      return;
+    }
+
+    // Another mount already started loading - share the same promise
+    if (window.__splineLoader) {
+      window.__splineLoader.then(() => setIsSplineReady(true)).catch(() => setIsSplineReady(false));
+      return;
+    }
+
+    // First mount: create script and shared loader promise
+    const script = document.createElement("script");
+    script.type = "module";
+    // Version pinned; SRI hash omitted as unpkg doesn't guarantee hash stability across deploys
+    script.src = "https://unpkg.com/@splinetool/viewer@1.12.29/build/spline-viewer.js";
+
+    window.__splineLoader = new Promise<void>((resolve, reject) => {
+      script.onload = () => resolve();
+      script.onerror = () => reject();
+    });
+
+    window.__splineLoader.then(() => setIsSplineReady(true)).catch(() => setIsSplineReady(false));
+
+    document.head.appendChild(script);
+
+    // Intentionally no cleanup: once the custom element is registered globally,
+    // removing the script would break re-mounts while providing no benefit
+  }, []);
+
+  if (!isSplineReady) {
+    return null;
+  }
+
+  return (
+    <motion.div
+      className="pointer-events-none absolute inset-0 overflow-hidden"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      transition={{ delay: 0.5, duration: 2, ease: "easeOut" }}
+    >
+      <spline-viewer
+        loading-anim-type="spinner-small-light"
+        url="https://prod.spline.design/wRly8TZN-e0Twb8W/scene.splinecode"
+        style={{ width: "100%", height: "100%" }}
+      />
+    </motion.div>
+  );
+}
diff --git a/apps/webapp/app/components/admin/FeatureFlagsDialog.tsx b/apps/webapp/app/components/admin/FeatureFlagsDialog.tsx
new file mode 100644
index 00000000000..df8669d36dd
--- /dev/null
+++ b/apps/webapp/app/components/admin/FeatureFlagsDialog.tsx
@@ -0,0 +1,290 @@
+import { useFetcher } from "@remix-run/react";
+import { useEffect, useState } from "react";
+import stableStringify from "json-stable-stringify";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogDescription,
+  DialogFooter,
+} from "~/components/primitives/Dialog";
+import { Button } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { LockClosedIcon } from "@heroicons/react/20/solid";
+import { CheckboxWithLabel } from "~/components/primitives/Checkbox";
+import { cn } from "~/utils/cn";
+import { FEATURE_FLAG, ORG_LOCKED_FLAGS, type FlagControlType } from "~/v3/featureFlags";
+import {
+  UNSET_VALUE,
+  BooleanControl,
+  EnumControl,
+  StringControl,
+  WorkerGroupControl,
+  type WorkerGroup,
+} from "./FlagControls";
+
+type LoaderData = {
+  org: { id: string; title: string; slug: string };
+  orgFlags: Record<string, unknown>;
+  globalFlags: Record<string, unknown>;
+  controlTypes: Record<string, FlagControlType>;
+  workerGroupName?: string;
+  workerGroups?: WorkerGroup[];
+  isManagedCloud?: boolean;
+};
+
+type ActionData = {
+  success?: boolean;
+  error?: string;
+};
+
+type FeatureFlagsDialogProps = {
+  orgId: string | null;
+  orgTitle: string;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+};
+
+export function FeatureFlagsDialog({
+  orgId,
+  orgTitle,
+  open,
+  onOpenChange,
+}: FeatureFlagsDialogProps) {
+  const loadFetcher = useFetcher<LoaderData>();
+  const saveFetcher = useFetcher<ActionData>();
+
+  const [overrides, setOverrides] = useState<Record<string, unknown>>({});
+  const [initialOverrides, setInitialOverrides] = useState<Record<string, unknown>>({});
+  const [saveError, setSaveError] = useState<string | null>(null);
+  const [unlocked, setUnlocked] = useState(false);
+
+  const isLocked = (key: string) => !unlocked && ORG_LOCKED_FLAGS.includes(key);
+
+  useEffect(() => {
+    if (open && orgId) {
+      setSaveError(null);
+      setOverrides({});
+      setInitialOverrides({});
+      loadFetcher.load(`/admin/api/v2/orgs/${orgId}/feature-flags`);
+    }
+  }, [open, orgId]);
+
+  useEffect(() => {
+    if (loadFetcher.data) {
+      const loaded = loadFetcher.data.orgFlags ?? {};
+      setOverrides({ ...loaded });
+      setInitialOverrides({ ...loaded });
+    }
+  }, [loadFetcher.data]);
+
+  useEffect(() => {
+    if (saveFetcher.data?.success) {
+      onOpenChange(false);
+    } else if (saveFetcher.data?.error) {
+      setSaveError(saveFetcher.data.error);
+    }
+  }, [saveFetcher.data]);
+
+  const isDirty = stableStringify(overrides) !== stableStringify(initialOverrides);
+
+  const setFlagValue = (key: string, value: unknown) => {
+    setOverrides((prev) => ({ ...prev, [key]: value }));
+  };
+
+  const unsetFlag = (key: string) => {
+    setOverrides((prev) => {
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  };
+
+  const handleSave = () => {
+    if (!orgId) return;
+    const body = Object.keys(overrides).length === 0 ? null : overrides;
+    saveFetcher.submit(JSON.stringify(body), {
+      method: "POST",
+      action: `/admin/api/v2/orgs/${orgId}/feature-flags`,
+      encType: "application/json",
+    });
+  };
+
+  const data = loadFetcher.data;
+  const isLoading = loadFetcher.state === "loading";
+  const isSaving = saveFetcher.state === "submitting";
+
+  const jsonPreview =
+    Object.keys(overrides).length === 0 ? "null" : JSON.stringify(overrides, null, 2);
+
+  const sortedFlagKeys = data ? Object.keys(data.controlTypes).sort() : [];
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>Feature flags - {orgTitle}</DialogHeader>
+        <DialogDescription>
+          Org-level overrides. Unset flags inherit from global defaults.
+        </DialogDescription>
+
+        {data && (
+          <div className={data.isManagedCloud ? "cursor-not-allowed" : undefined}>
+            <CheckboxWithLabel
+              variant="simple/small"
+              label={
+                data.isManagedCloud
+                  ? "Unlock read-only flags (only in unmanaged cloud)"
+                  : "Unlock read-only flags"
+              }
+              defaultChecked={unlocked}
+              onChange={setUnlocked}
+              disabled={data.isManagedCloud}
+              className={data.isManagedCloud ? "pointer-events-none" : undefined}
+            />
+          </div>
+        )}
+
+        <div className="max-h-[60vh] overflow-y-auto">
+          {isLoading ? (
+            <div className="py-8 text-center text-sm text-text-dimmed">Loading flags...</div>
+          ) : data ? (
+            <div className="flex flex-col gap-1.5">
+              {sortedFlagKeys.map((key) => {
+                const control = data.controlTypes[key];
+                const locked = isLocked(key);
+                const globalValue = data.globalFlags[key as keyof typeof data.globalFlags];
+                const isWorkerGroup = key === FEATURE_FLAG.defaultWorkerInstanceGroupId;
+                const globalDisplay =
+                  isWorkerGroup && data.workerGroupName && globalValue !== undefined
+                    ? `${data.workerGroupName} (${String(globalValue).slice(0, 8)}...)`
+                    : globalValue !== undefined
+                      ? String(globalValue)
+                      : "unset";
+
+                if (locked) {
+                  return (
+                    <div
+                      key={key}
+                      className="flex items-center justify-between rounded-md border border-transparent bg-charcoal-750 px-3 py-2.5"
+                      title="Global-level setting - not editable per org"
+                    >
+                      <div className="min-w-0 flex-1">
+                        <div className="truncate text-sm text-text-dimmed">{key}</div>
+                        <div className="text-xs text-charcoal-400">global: {globalDisplay}</div>
+                      </div>
+                      <LockClosedIcon className="size-4 text-charcoal-500" />
+                    </div>
+                  );
+                }
+
+                const isOverridden = key in overrides;
+
+                return (
+                  <div
+                    key={key}
+                    className={cn(
+                      "flex items-center justify-between rounded-md border px-3 py-2.5",
+                      isOverridden
+                        ? "border-indigo-500/20 bg-indigo-500/5"
+                        : "border-transparent bg-charcoal-750"
+                    )}
+                  >
+                    <div className="min-w-0 flex-1">
+                      <div
+                        className={cn(
+                          "truncate text-sm",
+                          isOverridden ? "text-text-bright" : "text-text-dimmed"
+                        )}
+                      >
+                        {key}
+                      </div>
+                      <div className="text-xs text-charcoal-400">global: {globalDisplay}</div>
+                    </div>
+
+                    <div className="flex items-center gap-2">
+                      <Button
+                        variant="minimal/small"
+                        onClick={() => unsetFlag(key)}
+                        className={cn(!isOverridden && "invisible")}
+                      >
+                        unset
+                      </Button>
+
+                      {isWorkerGroup && data.workerGroups ? (
+                        <WorkerGroupControl
+                          value={isOverridden ? (overrides[key] as string) : undefined}
+                          workerGroups={data.workerGroups as WorkerGroup[]}
+                          onChange={(val) => {
+                            if (val === UNSET_VALUE) {
+                              unsetFlag(key);
+                            } else {
+                              setFlagValue(key, val);
+                            }
+                          }}
+                          dimmed={!isOverridden}
+                        />
+                      ) : control.type === "boolean" ? (
+                        <BooleanControl
+                          value={isOverridden ? (overrides[key] as boolean) : undefined}
+                          onChange={(val) => setFlagValue(key, val)}
+                          dimmed={!isOverridden}
+                        />
+                      ) : control.type === "enum" ? (
+                        <EnumControl
+                          value={isOverridden ? (overrides[key] as string) : undefined}
+                          options={control.options}
+                          onChange={(val) => {
+                            if (val === UNSET_VALUE) {
+                              unsetFlag(key);
+                            } else {
+                              setFlagValue(key, val);
+                            }
+                          }}
+                          dimmed={!isOverridden}
+                        />
+                      ) : control.type === "string" ? (
+                        <StringControl
+                          value={isOverridden ? (overrides[key] as string) : ""}
+                          onChange={(val) => {
+                            if (val === "") {
+                              unsetFlag(key);
+                            } else {
+                              setFlagValue(key, val);
+                            }
+                          }}
+                          dimmed={!isOverridden}
+                        />
+                      ) : null}
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+          ) : null}
+        </div>
+
+        {data && (
+          <details className="mt-2">
+            <summary className="cursor-pointer text-xs text-text-dimmed hover:text-text-bright">
+              Preview JSON
+            </summary>
+            <pre className="mt-1 max-h-40 overflow-auto rounded bg-charcoal-800 p-2 text-xs text-text-dimmed">
+              {jsonPreview}
+            </pre>
+          </details>
+        )}
+
+        {saveError && <Callout variant="error">{saveError}</Callout>}
+
+        <DialogFooter>
+          <Button variant="tertiary/small" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button variant="primary/small" onClick={handleSave} disabled={!isDirty || isSaving}>
+            {isSaving ? "Saving..." : "Save changes"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/components/admin/FlagControls.tsx b/apps/webapp/app/components/admin/FlagControls.tsx
new file mode 100644
index 00000000000..b08f925dd90
--- /dev/null
+++ b/apps/webapp/app/components/admin/FlagControls.tsx
@@ -0,0 +1,120 @@
+import { Switch } from "~/components/primitives/Switch";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { Input } from "~/components/primitives/Input";
+import { cn } from "~/utils/cn";
+
+export const UNSET_VALUE = "__unset__";
+
+export function BooleanControl({
+  value,
+  onChange,
+  dimmed,
+}: {
+  value: boolean | undefined;
+  onChange: (val: boolean) => void;
+  dimmed: boolean;
+}) {
+  return (
+    <Switch
+      variant="small"
+      checked={value ?? false}
+      onCheckedChange={onChange}
+      className={cn(dimmed && "opacity-50")}
+    />
+  );
+}
+
+export function EnumControl({
+  value,
+  options,
+  onChange,
+  dimmed,
+}: {
+  value: string | undefined;
+  options: string[];
+  onChange: (val: string) => void;
+  dimmed: boolean;
+}) {
+  const items = [UNSET_VALUE, ...options];
+
+  return (
+    <Select
+      variant="tertiary/small"
+      value={value ?? UNSET_VALUE}
+      setValue={onChange}
+      items={items}
+      text={(val) => (val === UNSET_VALUE ? "unset" : val)}
+      className={cn(dimmed && "opacity-50")}
+    >
+      {(items) =>
+        items.map((item) => (
+          <SelectItem key={item} value={item}>
+            {item === UNSET_VALUE ? "unset" : item}
+          </SelectItem>
+        ))
+      }
+    </Select>
+  );
+}
+
+export type WorkerGroup = { id: string; name: string };
+
+export function WorkerGroupControl({
+  value,
+  workerGroups,
+  onChange,
+  dimmed,
+}: {
+  value: string | undefined;
+  workerGroups: WorkerGroup[];
+  onChange: (val: string) => void;
+  dimmed: boolean;
+}) {
+  const items = [UNSET_VALUE, ...workerGroups.map((wg) => wg.id)];
+
+  return (
+    <Select
+      variant="tertiary/small"
+      value={value ?? UNSET_VALUE}
+      setValue={onChange}
+      items={items}
+      text={(val) => {
+        if (val === UNSET_VALUE) return "unset";
+        const wg = workerGroups.find((w) => w.id === val);
+        return wg ? wg.name : val;
+      }}
+      className={cn(dimmed && "opacity-50")}
+    >
+      {(items) =>
+        items.map((item) => {
+          const wg = workerGroups.find((w) => w.id === item);
+          return (
+            <SelectItem key={item} value={item}>
+              {item === UNSET_VALUE ? "unset" : wg ? wg.name : item}
+            </SelectItem>
+          );
+        })
+      }
+    </Select>
+  );
+}
+
+export function StringControl({
+  value,
+  onChange,
+  dimmed,
+}: {
+  value: string;
+  onChange: (val: string) => void;
+  dimmed: boolean;
+}) {
+  return (
+    <Input
+      variant="small"
+      value={value}
+      onChange={(e) => onChange(e.target.value)}
+      placeholder="unset"
+      className={cn("w-40", dimmed && "opacity-50")}
+    />
+  );
+}
diff --git a/apps/webapp/app/components/code/AIQueryInput.tsx b/apps/webapp/app/components/code/AIQueryInput.tsx
new file mode 100644
index 00000000000..0775ec2c2a0
--- /dev/null
+++ b/apps/webapp/app/components/code/AIQueryInput.tsx
@@ -0,0 +1,415 @@
+import { CheckIcon, PencilSquareIcon, PlusIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { AnimatePresence, motion } from "framer-motion";
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+import { Button } from "~/components/primitives/Buttons";
+import { Spinner } from "~/components/primitives/Spinner";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import type { AITimeFilter } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types";
+import { cn } from "~/utils/cn";
+
+// Lazy load streamdown components to avoid SSR issues
+const StreamdownRenderer = lazy(() =>
+  import("streamdown").then((mod) => ({
+    default: ({ children, isAnimating }: { children: string; isAnimating: boolean }) => (
+      <mod.ShikiThemeContext.Provider value={["one-dark-pro", "one-dark-pro"]}>
+        <mod.Streamdown isAnimating={isAnimating}>{children}</mod.Streamdown>
+      </mod.ShikiThemeContext.Provider>
+    ),
+  }))
+);
+
+type StreamEventType =
+  | { type: "thinking"; content: string }
+  | { type: "tool_call"; tool: string; args: unknown }
+  | { type: "time_filter"; filter: AITimeFilter }
+  | { type: "result"; success: true; query: string; timeFilter?: AITimeFilter }
+  | { type: "result"; success: false; error: string };
+
+export type AIQueryMode = "new" | "edit";
+
+interface AIQueryInputProps {
+  onQueryGenerated: (query: string) => void;
+  /** Called when the AI sets a time filter - updates URL search params */
+  onTimeFilterChange?: (filter: AITimeFilter) => void;
+  /** Set this to a prompt to auto-populate and immediately submit */
+  autoSubmitPrompt?: string;
+  /** Change this to force re-submission even if prompt is the same */
+  autoSubmitKey?: number;
+  /** Get the current query in the editor (used for edit mode) */
+  getCurrentQuery?: () => string;
+}
+
+export function AIQueryInput({
+  onQueryGenerated,
+  onTimeFilterChange,
+  autoSubmitPrompt,
+  autoSubmitKey,
+  getCurrentQuery,
+}: AIQueryInputProps) {
+  const [prompt, setPrompt] = useState("");
+  const [mode, setMode] = useState<AIQueryMode>("new");
+  const [isLoading, setIsLoading] = useState(false);
+  const [thinking, setThinking] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [showThinking, setShowThinking] = useState(false);
+  const [lastResult, setLastResult] = useState<"success" | "error" | null>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const lastAutoSubmitRef = useRef<{ prompt: string; key?: number } | null>(null);
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const resourcePath = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/query/ai-generate`;
+
+  // Can only use edit mode if there's a current query
+  const canEdit = Boolean(getCurrentQuery?.()?.trim());
+
+  // If mode is edit but there's no current query, switch to new
+  useEffect(() => {
+    if (mode === "edit" && !canEdit) {
+      setMode("new");
+    }
+  }, [mode, canEdit]);
+
+  const submitQuery = useCallback(
+    async (queryPrompt: string, submitMode: AIQueryMode = mode) => {
+      if (!queryPrompt.trim() || isLoading) return;
+      const currentQuery = getCurrentQuery?.();
+      if (submitMode === "edit" && !currentQuery?.trim()) return;
+
+      setIsLoading(true);
+      setThinking("");
+      setError(null);
+      setShowThinking(true);
+      setLastResult(null);
+
+      // Abort any existing request
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      abortControllerRef.current = new AbortController();
+
+      try {
+        const formData = new FormData();
+        formData.append("prompt", queryPrompt);
+        formData.append("mode", submitMode);
+        if (submitMode === "edit" && currentQuery) {
+          formData.append("currentQuery", currentQuery);
+        }
+
+        const response = await fetch(resourcePath, {
+          method: "POST",
+          body: formData,
+          signal: abortControllerRef.current.signal,
+        });
+
+        if (!response.ok) {
+          const errorData = (await response.json()) as { error?: string };
+          setError(errorData.error || "Failed to generate query");
+          setIsLoading(false);
+          setLastResult("error");
+          return;
+        }
+
+        const reader = response.body?.getReader();
+        if (!reader) {
+          setError("No response stream");
+          setIsLoading(false);
+          setLastResult("error");
+          return;
+        }
+
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+
+          // Process complete events from buffer
+          const lines = buffer.split("\n\n");
+          buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const event = JSON.parse(line.slice(6)) as StreamEventType;
+                processStreamEvent(event);
+              } catch {
+                // Ignore parse errors
+              }
+            }
+          }
+        }
+
+        // Process any remaining data
+        if (buffer.startsWith("data: ")) {
+          try {
+            const event = JSON.parse(buffer.slice(6)) as StreamEventType;
+            processStreamEvent(event);
+          } catch {
+            // Ignore parse errors
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          // Request was aborted, ignore
+          return;
+        }
+        setError(err instanceof Error ? err.message : "An error occurred");
+        setLastResult("error");
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [isLoading, resourcePath, mode, getCurrentQuery]
+  );
+
+  const processStreamEvent = useCallback(
+    (event: StreamEventType) => {
+      switch (event.type) {
+        case "thinking":
+          setThinking((prev) => prev + event.content);
+          break;
+        case "tool_call":
+          // Tool calls are handled silently — no UI text needed
+          break;
+        case "time_filter":
+          // Apply time filter immediately when the AI sets it
+          onTimeFilterChange?.(event.filter);
+          break;
+        case "result":
+          if (event.success) {
+            // Apply time filter if included in result (backup in case time_filter event was missed)
+            if (event.timeFilter) {
+              onTimeFilterChange?.(event.timeFilter);
+            }
+            onQueryGenerated(event.query);
+            setPrompt("");
+            setLastResult("success");
+            // Keep thinking visible to show what happened
+          } else {
+            setError(event.error);
+            setLastResult("error");
+          }
+          break;
+      }
+    },
+    [onQueryGenerated, onTimeFilterChange]
+  );
+
+  const handleSubmit = useCallback(
+    (e?: React.FormEvent) => {
+      e?.preventDefault();
+      submitQuery(prompt);
+    },
+    [prompt, submitQuery]
+  );
+
+  // Auto-submit when autoSubmitPrompt or autoSubmitKey changes
+  useEffect(() => {
+    if (!autoSubmitPrompt || !autoSubmitPrompt.trim() || isLoading) {
+      return;
+    }
+
+    const last = lastAutoSubmitRef.current;
+    const isDifferent =
+      last === null || autoSubmitPrompt !== last.prompt || autoSubmitKey !== last.key;
+
+    if (isDifferent) {
+      lastAutoSubmitRef.current = { prompt: autoSubmitPrompt, key: autoSubmitKey };
+      setPrompt(autoSubmitPrompt);
+      submitQuery(autoSubmitPrompt);
+    }
+  }, [autoSubmitPrompt, autoSubmitKey, isLoading, submitQuery]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+
+  // Auto-hide error after delay
+  useEffect(() => {
+    if (error) {
+      const timer = setTimeout(() => setError(null), 15000);
+      return () => clearTimeout(timer);
+    }
+  }, [error]);
+
+  return (
+    <div className="flex flex-col">
+      {/* Gradient border wrapper like the schedules AI input */}
+      <div
+        className="overflow-hidden rounded-md p-px"
+        style={{ background: "linear-gradient(to bottom right, #E543FF, #286399)" }}
+      >
+        <div className="overflow-hidden rounded-md bg-background-bright">
+          <form onSubmit={handleSubmit}>
+            <textarea
+              ref={textareaRef}
+              name="prompt"
+              placeholder={
+                mode === "edit"
+                  ? "e.g. add a filter for failed runs, change the limit to 50"
+                  : "e.g. show me failed runs from the last 7 days"
+              }
+              value={prompt}
+              onChange={(e) => setPrompt(e.target.value)}
+              disabled={isLoading}
+              rows={8}
+              className="m-0 min-h-10 w-full resize-none border-0 bg-background-bright px-3 py-2.5 text-sm text-text-bright scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600 file:border-0 file:bg-transparent file:text-base file:font-medium placeholder:text-text-dimmed focus:border-0 focus:outline-none focus:ring-0 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0 disabled:cursor-not-allowed disabled:opacity-50"
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && !e.shiftKey && prompt.trim() && !isLoading) {
+                  e.preventDefault();
+                  handleSubmit();
+                }
+              }}
+            />
+            <div className="flex justify-end gap-2 px-2 pb-2">
+              {isLoading ? (
+                <Button
+                  type="button"
+                  variant="tertiary/small"
+                  disabled={true}
+                  LeadingIcon={Spinner}
+                  className="pl-2"
+                  iconSpacing="gap-1.5"
+                >
+                  {mode === "edit" ? "Editing…" : "Generating…"}
+                </Button>
+              ) : (
+                <>
+                  <Button
+                    type="button"
+                    variant="tertiary/small"
+                    disabled={!prompt.trim()}
+                    LeadingIcon={PlusIcon}
+                    iconSpacing="gap-1.5"
+                    onClick={() => {
+                      setMode("new");
+                      submitQuery(prompt, "new");
+                    }}
+                  >
+                    New query
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="tertiary/small"
+                    disabled={!prompt.trim() || !canEdit}
+                    LeadingIcon={PencilSquareIcon}
+                    className={cn(!canEdit && "opacity-50")}
+                    iconSpacing="gap-2"
+                    tooltip={!canEdit ? "Write a query first to enable editing" : undefined}
+                    onClick={() => {
+                      setMode("edit");
+                      submitQuery(prompt, "edit");
+                    }}
+                  >
+                    Edit query
+                  </Button>
+                </>
+              )}
+            </div>
+          </form>
+        </div>
+      </div>
+
+      {/* Error message */}
+      <AnimatePresence>
+        {error && (
+          <motion.div
+            initial={{ opacity: 0, height: 0 }}
+            animate={{ opacity: 1, height: "auto" }}
+            exit={{ opacity: 0, height: 0 }}
+            transition={{ duration: 0.2 }}
+            className="overflow-hidden"
+          >
+            <div className="rounded-md border border-error/30 bg-error/10 px-3 py-2 text-sm text-error">
+              {error}
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+
+      {/* Thinking panel - stays visible after completion */}
+      <AnimatePresence>
+        {showThinking && thinking && (
+          <motion.div
+            initial={{ opacity: 0, height: 0 }}
+            animate={{ opacity: 1, height: "auto" }}
+            exit={{ opacity: 0, height: 0 }}
+            transition={{ duration: 0.2 }}
+            className="overflow-hidden"
+          >
+            <div className="px-1">
+              <div className="rounded-b-lg border-x border-b border-grid-dimmed bg-charcoal-850 p-3 pb-1">
+                <div className="mb-1 flex items-center justify-between">
+                  <div className="flex items-center gap-1">
+                    {isLoading ? (
+                      <Spinner className="size-4" />
+                    ) : lastResult === "success" ? (
+                      <CheckIcon className="size-4 text-success" />
+                    ) : lastResult === "error" ? (
+                      <XMarkIcon className="size-4 text-error" />
+                    ) : null}
+                    <span className="text-xs font-medium text-text-dimmed">
+                      {isLoading
+                        ? "AI is thinking…"
+                        : lastResult === "success"
+                        ? "Query generated"
+                        : lastResult === "error"
+                        ? "Generation failed"
+                        : "AI response"}
+                    </span>
+                  </div>
+                  {isLoading ? (
+                    <Button
+                      variant="minimal/small"
+                      onClick={() => {
+                        if (abortControllerRef.current) {
+                          abortControllerRef.current.abort();
+                        }
+                        setIsLoading(false);
+                        setShowThinking(false);
+                        setThinking("");
+                      }}
+                      className="text-xs"
+                    >
+                      Cancel
+                    </Button>
+                  ) : (
+                    <Button
+                      variant="minimal/small"
+                      onClick={() => {
+                        setShowThinking(false);
+                        setThinking("");
+                      }}
+                      className="text-xs"
+                    >
+                      Dismiss
+                    </Button>
+                  )}
+                </div>
+                <div className="streamdown-container max-h-96 overflow-y-auto text-xs text-text-dimmed scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+                  <Suspense fallback={<p className="whitespace-pre-wrap">{thinking}</p>}>
+                    <StreamdownRenderer isAnimating={isLoading}>{thinking}</StreamdownRenderer>
+                  </Suspense>
+                </div>
+              </div>
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/code/ChartConfigPanel.tsx b/apps/webapp/app/components/code/ChartConfigPanel.tsx
new file mode 100644
index 00000000000..3032795c1bf
--- /dev/null
+++ b/apps/webapp/app/components/code/ChartConfigPanel.tsx
@@ -0,0 +1,624 @@
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+import { IconSortAscending, IconSortDescending } from "@tabler/icons-react";
+import { BarChart, CheckIcon, LineChart, Plus, XIcon } from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { cn } from "~/utils/cn";
+import { Paragraph } from "../primitives/Paragraph";
+import { Popover, PopoverContent, PopoverTrigger } from "../primitives/Popover";
+import { Select, SelectItem } from "../primitives/Select";
+import { Switch } from "../primitives/Switch";
+import SegmentedControl from "../primitives/SegmentedControl";
+import { Button } from "../primitives/Buttons";
+import {
+  type AggregationType,
+  type ChartConfiguration,
+  type SortDirection,
+} from "../metrics/QueryWidget";
+import { CHART_COLORS_BY_HUE, getSeriesColor } from "./chartColors";
+
+export const defaultChartConfig: ChartConfiguration = {
+  chartType: "bar",
+  xAxisColumn: null,
+  yAxisColumns: [],
+  groupByColumn: null,
+  stacked: false,
+  sortByColumn: null,
+  sortDirection: "asc",
+  aggregation: "sum",
+  seriesColors: {},
+};
+
+interface ChartConfigPanelProps {
+  columns: OutputColumnMetadata[];
+  config: ChartConfiguration;
+  onChange: (config: ChartConfiguration) => void;
+  className?: string;
+}
+
+// Type detection helpers
+function isNumericType(type: string): boolean {
+  return (
+    type.startsWith("Int") ||
+    type.startsWith("UInt") ||
+    type.startsWith("Float") ||
+    type.startsWith("Decimal") ||
+    type.startsWith("Nullable(Int") ||
+    type.startsWith("Nullable(UInt") ||
+    type.startsWith("Nullable(Float") ||
+    type.startsWith("Nullable(Decimal")
+  );
+}
+
+function isDateTimeType(type: string): boolean {
+  return (
+    type === "DateTime" ||
+    type === "DateTime64" ||
+    type === "Date" ||
+    type === "Date32" ||
+    type.startsWith("DateTime64(") ||
+    type.startsWith("Nullable(DateTime") ||
+    type.startsWith("Nullable(Date")
+  );
+}
+
+function isStringType(type: string): boolean {
+  return (
+    type === "String" ||
+    type === "LowCardinality(String)" ||
+    type === "Nullable(String)" ||
+    type.startsWith("Enum") ||
+    type.startsWith("FixedString")
+  );
+}
+
+export function ChartConfigPanel({ columns, config, onChange, className }: ChartConfigPanelProps) {
+  // Categorize columns by type
+  const { numericColumns, dateTimeColumns, categoricalColumns, allColumns } = useMemo(() => {
+    const numeric: OutputColumnMetadata[] = [];
+    const dateTime: OutputColumnMetadata[] = [];
+    const categorical: OutputColumnMetadata[] = [];
+
+    for (const col of columns) {
+      if (isNumericType(col.type)) {
+        numeric.push(col);
+      }
+      if (isDateTimeType(col.type)) {
+        dateTime.push(col);
+      }
+      if (isStringType(col.type) || isDateTimeType(col.type)) {
+        categorical.push(col);
+      }
+    }
+
+    return {
+      numericColumns: numeric,
+      dateTimeColumns: dateTime,
+      categoricalColumns: categorical,
+      allColumns: columns,
+    };
+  }, [columns]);
+
+  // Create a stable key from column names and types to detect actual changes
+  const columnsKey = useMemo(() => columns.map((c) => `${c.name}:${c.type}`).join(","), [columns]);
+
+  // Use refs to access current config/onChange without adding them as dependencies
+  const configRef = useRef(config);
+  const onChangeRef = useRef(onChange);
+  useEffect(() => {
+    configRef.current = config;
+    onChangeRef.current = onChange;
+  });
+
+  // Auto-select defaults when columns change
+  useEffect(() => {
+    if (columns.length === 0) return;
+
+    const currentConfig = configRef.current;
+    let needsUpdate = false;
+    const updates: Partial<ChartConfiguration> = {};
+
+    // Auto-select X-axis (prefer datetime, then first categorical)
+    if (!currentConfig.xAxisColumn) {
+      const defaultX = dateTimeColumns[0] ?? categoricalColumns[0] ?? columns[0];
+      if (defaultX) {
+        updates.xAxisColumn = defaultX.name;
+        needsUpdate = true;
+      }
+    }
+
+    // Auto-select Y-axis (first numeric column)
+    if (currentConfig.yAxisColumns.length === 0 && numericColumns.length > 0) {
+      updates.yAxisColumns = [numericColumns[0].name];
+      needsUpdate = true;
+    }
+
+    // Determine the effective x-axis column (either existing or newly selected)
+    const effectiveXAxis = updates.xAxisColumn ?? currentConfig.xAxisColumn;
+
+    // Auto-set sort to x-axis ASC if it's a datetime column and no sort is configured
+    if (
+      effectiveXAxis &&
+      !currentConfig.sortByColumn &&
+      dateTimeColumns.some((col) => col.name === effectiveXAxis)
+    ) {
+      updates.sortByColumn = effectiveXAxis;
+      updates.sortDirection = "asc";
+      needsUpdate = true;
+    }
+
+    if (needsUpdate) {
+      onChangeRef.current({ ...currentConfig, ...updates });
+    }
+    // Only re-run when the actual column structure changes, not on every config change.
+    // columnsKey (a string) is stable when columns match, so this won't re-fire
+    // unnecessarily when the same query is re-run with identical columns.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [columnsKey]);
+
+  const updateConfig = useCallback(
+    (updates: Partial<ChartConfiguration>) => {
+      onChange({ ...config, ...updates });
+    },
+    [config, onChange]
+  );
+
+  // X-axis options: prefer datetime and string columns at the top
+  const xAxisOptions = useMemo(() => {
+    const preferred = [
+      ...dateTimeColumns,
+      ...categoricalColumns.filter((c) => !isDateTimeType(c.type)),
+    ];
+    const preferredNames = new Set(preferred.map((c) => c.name));
+    const other = allColumns.filter((c) => !preferredNames.has(c.name));
+
+    const options: Array<{ value: string; label: string; type: string }> = [];
+
+    for (const col of preferred) {
+      options.push({ value: col.name, label: col.name, type: col.type });
+    }
+    for (const col of other) {
+      options.push({ value: col.name, label: col.name, type: col.type });
+    }
+
+    return options;
+  }, [allColumns, dateTimeColumns, categoricalColumns]);
+
+  // Y-axis options: numeric columns only
+  const yAxisOptions = useMemo(() => {
+    return numericColumns.map((col) => ({
+      value: col.name,
+      label: col.name,
+      type: col.type,
+    }));
+  }, [numericColumns]);
+
+  // Aggregation options
+  const aggregationOptions = [
+    { value: "sum", label: "Sum" },
+    { value: "avg", label: "Average" },
+    { value: "count", label: "Count" },
+    { value: "min", label: "Min" },
+    { value: "max", label: "Max" },
+  ];
+
+  // Group by options: categorical columns (excluding selected X axis)
+  const groupByOptions = useMemo(() => {
+    const options = categoricalColumns
+      .filter((col) => col.name !== config.xAxisColumn)
+      .map((col) => ({
+        value: col.name,
+        label: col.name,
+        type: col.type,
+      }));
+
+    return [{ value: "__none__", label: "None", type: "" }, ...options];
+  }, [categoricalColumns, config.xAxisColumn]);
+
+  // Sort by options: all columns
+  const sortByOptions = useMemo(() => {
+    const options = allColumns.map((col) => ({
+      value: col.name,
+      label: col.name,
+      type: col.type,
+    }));
+
+    return [{ value: "__none__", label: "None", type: "" }, ...options];
+  }, [allColumns]);
+
+  if (columns.length === 0) {
+    return (
+      <div className={cn("flex items-center justify-center p-4", className)}>
+        <Paragraph variant="small" className="text-text-dimmed">
+          Run a query to configure the chart
+        </Paragraph>
+      </div>
+    );
+  }
+
+  return (
+    <div className={cn("flex flex-col gap-3 p-2", className)}>
+      {/* Chart Type */}
+      <div className="flex flex-col gap-3">
+        <ConfigField label="Type">
+          <SegmentedControl
+            name="chartType"
+            value={config.chartType}
+            variant="secondary/small"
+            options={[
+              {
+                label: (
+                  <span className="flex items-center gap-1">
+                    <BarChart className="size-3" /> Bar
+                  </span>
+                ),
+                value: "bar",
+              },
+              {
+                label: (
+                  <span className="flex items-center gap-1">
+                    <LineChart className="size-3" /> Line
+                  </span>
+                ),
+                value: "line",
+              },
+            ]}
+            onChange={(value) => updateConfig({ chartType: value as "bar" | "line" })}
+          />
+        </ConfigField>
+      </div>
+
+      <div className="flex flex-col gap-3">
+        {/* X-Axis */}
+        <ConfigField label="X-Axis">
+          <Select
+            value={config.xAxisColumn ?? ""}
+            setValue={(value) => {
+              const updates: Partial<ChartConfiguration> = { xAxisColumn: value || null };
+              // Auto-set sort to x-axis ASC if selecting a datetime column
+              if (value) {
+                const selectedCol = columns.find((c) => c.name === value);
+                if (selectedCol && isDateTimeType(selectedCol.type)) {
+                  updates.sortByColumn = value;
+                  updates.sortDirection = "asc";
+                }
+              }
+              updateConfig(updates);
+            }}
+            variant="tertiary/small"
+            placeholder="Select column"
+            items={xAxisOptions}
+            dropdownIcon
+            className="min-w-[140px]"
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  <span className="flex items-center gap-2">
+                    <span>{item.label}</span>
+                    <TypeBadge type={item.type} />
+                  </span>
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </ConfigField>
+
+        {/* Y-Axis / Series */}
+        <ConfigField label={config.yAxisColumns.length > 1 ? "Series" : "Y-Axis"}>
+          {yAxisOptions.length === 0 ? (
+            <span className="text-xs text-text-dimmed">No numeric columns</span>
+          ) : (
+            <div className="flex flex-col gap-1.5">
+              {/* Always show at least one dropdown, even if yAxisColumns is empty */}
+              {(config.yAxisColumns.length === 0 ? [""] : config.yAxisColumns).map((col, index) => (
+                <div key={index} className="flex items-center gap-1">
+                  {col && !config.groupByColumn && (
+                    <SeriesColorPicker
+                      color={config.seriesColors?.[col] ?? getSeriesColor(index)}
+                      onColorChange={(color) => {
+                        updateConfig({
+                          seriesColors: { ...config.seriesColors, [col]: color },
+                        });
+                      }}
+                    />
+                  )}
+                  <Select
+                    value={col}
+                    setValue={(value) => {
+                      const newColumns = [...config.yAxisColumns];
+                      const updates: Partial<ChartConfiguration> = {};
+                      if (value) {
+                        // If this is a new slot (empty string), add it
+                        if (index >= config.yAxisColumns.length) {
+                          newColumns.push(value);
+                        } else {
+                          // If the column name changed, migrate the color
+                          const oldCol = newColumns[index];
+                          if (oldCol && oldCol !== value && config.seriesColors?.[oldCol]) {
+                            const newSeriesColors = { ...config.seriesColors };
+                            newSeriesColors[value] = newSeriesColors[oldCol];
+                            delete newSeriesColors[oldCol];
+                            updates.seriesColors = newSeriesColors;
+                          }
+                          newColumns[index] = value;
+                        }
+                      } else if (index < config.yAxisColumns.length) {
+                        newColumns.splice(index, 1);
+                      }
+                      updateConfig({ ...updates, yAxisColumns: newColumns });
+                    }}
+                    variant="tertiary/small"
+                    placeholder="Select column"
+                    items={yAxisOptions.filter(
+                      (opt) => opt.value === col || !config.yAxisColumns.includes(opt.value)
+                    )}
+                    dropdownIcon
+                    className="min-w-[140px] flex-1"
+                  >
+                    {(items) =>
+                      items.map((item) => (
+                        <SelectItem key={item.value} value={item.value}>
+                          <span className="flex items-center gap-2">
+                            <span>{item.label}</span>
+                            <TypeBadge type={item.type} />
+                          </span>
+                        </SelectItem>
+                      ))
+                    }
+                  </Select>
+
+                  {index > 0 && (
+                    <button
+                      type="button"
+                      onClick={() => {
+                        const removedCol = config.yAxisColumns[index];
+                        const newColumns = config.yAxisColumns.filter((_, i) => i !== index);
+                        const updates: Partial<ChartConfiguration> = { yAxisColumns: newColumns };
+                        // Clean up the color entry for the removed series
+                        if (removedCol && config.seriesColors?.[removedCol]) {
+                          const newSeriesColors = { ...config.seriesColors };
+                          delete newSeriesColors[removedCol];
+                          updates.seriesColors = newSeriesColors;
+                        }
+                        updateConfig(updates);
+                      }}
+                      className="rounded p-1 text-text-dimmed hover:bg-charcoal-700 hover:text-text-bright"
+                      title="Remove series"
+                    >
+                      <XIcon className="h-3.5 w-3.5" />
+                    </button>
+                  )}
+                </div>
+              ))}
+
+              {/* Add another series button - only show when we have at least one series and not grouped */}
+              {config.yAxisColumns.length > 0 &&
+                config.yAxisColumns.length < yAxisOptions.length &&
+                !config.groupByColumn && (
+                  <button
+                    type="button"
+                    onClick={() => {
+                      const availableColumns = yAxisOptions.filter(
+                        (opt) => !config.yAxisColumns.includes(opt.value)
+                      );
+                      if (availableColumns.length > 0) {
+                        updateConfig({
+                          yAxisColumns: [...config.yAxisColumns, availableColumns[0].value],
+                        });
+                      }
+                    }}
+                    className="flex items-center gap-1 self-start rounded px-1 py-0.5 text-xs text-text-dimmed hover:bg-charcoal-700 hover:text-text-bright"
+                  >
+                    <Plus className="h-3 w-3" />
+                    Add series
+                  </button>
+                )}
+
+              {config.groupByColumn && config.yAxisColumns.length === 1 && (
+                <span className="text-xxs text-text-dimmed">
+                  Remove group by to add multiple series
+                </span>
+              )}
+            </div>
+          )}
+        </ConfigField>
+
+        {/* Aggregation */}
+        <ConfigField label="Aggregation">
+          <Select
+            value={config.aggregation}
+            setValue={(value) => updateConfig({ aggregation: value as AggregationType })}
+            variant="tertiary/small"
+            items={aggregationOptions}
+            dropdownIcon
+            className="min-w-[100px]"
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  {item.label}
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </ConfigField>
+
+        {/* Group By - disabled when multiple series are selected */}
+        <ConfigField label="Group by">
+          {config.yAxisColumns.length > 1 ? (
+            <span className="text-xs text-text-dimmed">Not available with multiple series</span>
+          ) : (
+            <Select
+              value={config.groupByColumn ?? "__none__"}
+              setValue={(value) =>
+                updateConfig({ groupByColumn: value === "__none__" ? null : value })
+              }
+              variant="tertiary/small"
+              placeholder="None"
+              items={groupByOptions}
+              dropdownIcon
+              className="min-w-[140px]"
+              text={(t) => (t === "__none__" ? "None" : t)}
+            >
+              {(items) =>
+                items.map((item) => (
+                  <SelectItem key={item.value} value={item.value}>
+                    <span className="flex items-center gap-2">
+                      <span>{item.label}</span>
+                      {item.type && <TypeBadge type={item.type} />}
+                    </span>
+                  </SelectItem>
+                ))
+              }
+            </Select>
+          )}
+        </ConfigField>
+
+        {/* Stacked toggle (when grouped or multiple series) */}
+        {(config.groupByColumn || config.yAxisColumns.length > 1) && (
+          <ConfigField label={config.groupByColumn ? "Stack groups" : "Stack series"}>
+            <Switch
+              variant="medium"
+              checked={config.stacked}
+              onCheckedChange={(checked) => updateConfig({ stacked: checked })}
+            />
+          </ConfigField>
+        )}
+
+        {/* Order By */}
+        <ConfigField label="Order by">
+          <Select
+            value={config.sortByColumn ?? "__none__"}
+            setValue={(value) =>
+              updateConfig({ sortByColumn: value === "__none__" ? null : value })
+            }
+            variant="tertiary/small"
+            placeholder="None"
+            items={sortByOptions}
+            dropdownIcon
+            className="min-w-[140px]"
+            text={(t) => (t === "__none__" ? "None" : t)}
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  <span className="flex items-center gap-2">
+                    <span>{item.label}</span>
+                    {item.type && <TypeBadge type={item.type} />}
+                  </span>
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </ConfigField>
+
+        {/* Sort Direction (only when sorting) */}
+        {config.sortByColumn && (
+          <ConfigField label="Sort direction">
+            <SegmentedControl
+              name="sortDirection"
+              value={config.sortDirection}
+              variant="secondary/small"
+              options={[
+                {
+                  label: (
+                    <span className="flex items-center gap-1">
+                      <IconSortAscending className="size-3" /> Asc
+                    </span>
+                  ),
+                  value: "asc",
+                },
+                {
+                  label: (
+                    <span className="flex items-center gap-1">
+                      <IconSortDescending className="size-3" /> Desc
+                    </span>
+                  ),
+                  value: "desc",
+                },
+              ]}
+              onChange={(value) => updateConfig({ sortDirection: value as SortDirection })}
+            />
+          </ConfigField>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function ConfigField({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div className="flex flex-col gap-1">
+      {label && <span className="text-xs text-text-bright">{label}</span>}
+      {children}
+    </div>
+  );
+}
+
+function SeriesColorPicker({
+  color,
+  onColorChange,
+}: {
+  color: string;
+  onColorChange: (color: string) => void;
+}) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger asChild>
+        <button
+          type="button"
+          className="flex-shrink-0 rounded p-0.5 hover:bg-charcoal-700"
+          title="Change series color"
+        >
+          <span
+            className="block h-4 w-4 rounded-full border border-white/30"
+            style={{ backgroundColor: color }}
+          />
+        </button>
+      </PopoverTrigger>
+      <PopoverContent align="start" className="w-auto p-2">
+        <div className="grid grid-cols-6 gap-1.5">
+          {CHART_COLORS_BY_HUE.map((c) => (
+            <button
+              key={c}
+              type="button"
+              onClick={() => {
+                onColorChange(c);
+                setOpen(false);
+              }}
+              className="group/swatch flex h-6 w-6 items-center justify-center rounded-full border border-white/30"
+              style={{ backgroundColor: c }}
+              title={c}
+            >
+              {c === color && <CheckIcon className="h-3.5 w-3.5 text-white drop-shadow-md" />}
+            </button>
+          ))}
+        </div>
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function TypeBadge({ type }: { type: string }) {
+  // Simplify type for display
+  let displayType = type;
+  if (type.startsWith("Nullable(")) {
+    displayType = type.slice(9, -1) + "?";
+  }
+  if (type.startsWith("LowCardinality(")) {
+    displayType = type.slice(15, -1);
+  }
+
+  // Shorten long type names
+  if (displayType.length > 12) {
+    displayType = displayType.slice(0, 10) + "…";
+  }
+
+  return (
+    <span className="rounded bg-charcoal-750 px-1 py-0.5 font-mono text-xxs text-text-dimmed">
+      {displayType}
+    </span>
+  );
+}
diff --git a/apps/webapp/app/components/code/CodeBlock.tsx b/apps/webapp/app/components/code/CodeBlock.tsx
index ea1d55e5d71..cc28c8142d3 100644
--- a/apps/webapp/app/components/code/CodeBlock.tsx
+++ b/apps/webapp/app/components/code/CodeBlock.tsx
@@ -5,6 +5,7 @@ import { Highlight, Prism } from "prism-react-renderer";
 import { forwardRef, ReactNode, useCallback, useEffect, useState } from "react";
 import { TextWrapIcon } from "~/assets/icons/TextWrapIcon";
 import { cn } from "~/utils/cn";
+import { highlightSearchText } from "~/utils/logUtils";
 import { Button } from "../primitives/Buttons";
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from "../primitives/Dialog";
 import { Paragraph } from "../primitives/Paragraph";
@@ -20,6 +21,8 @@ async function setup() {
   await import("prismjs/components/prism-json");
   //@ts-ignore
   await import("prismjs/components/prism-typescript");
+  //@ts-ignore
+  await import("prismjs/components/prism-sql.js");
 }
 setup();
 
@@ -62,6 +65,12 @@ type CodeBlockProps = {
 
   /** Whether to show the open in modal button */
   showOpenInModal?: boolean;
+
+  /** Search term to highlight in the code */
+  searchTerm?: string;
+
+  /** Whether to wrap the code */
+  wrap?: boolean;
 };
 
 const dimAmount = 0.5;
@@ -200,6 +209,8 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
       showChrome = false,
       fileName,
       rowTitle,
+      searchTerm,
+      wrap = false,
       ...props
     }: CodeBlockProps,
     ref
@@ -208,7 +219,7 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
     const [copied, setCopied] = useState(false);
     const [modalCopied, setModalCopied] = useState(false);
     const [isModalOpen, setIsModalOpen] = useState(false);
-    const [isWrapped, setIsWrapped] = useState(false);
+    const [isWrapped, setIsWrapped] = useState(wrap);
 
     const onCopied = useCallback(
       (event: React.MouseEvent<HTMLButtonElement>) => {
@@ -236,7 +247,7 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
       [code]
     );
 
-    code = code.trim();
+    code = code?.trim() ?? "";
     const lineCount = code.split("\n").length;
     const maxLineWidth = lineCount.toString().length;
     let maxHeight: string | undefined = undefined;
@@ -254,7 +265,10 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
     return (
       <>
         <div
-          className={cn("relative overflow-hidden rounded-md border border-grid-bright", className)}
+          className={cn(
+            "relative flex flex-col overflow-hidden rounded-md border border-grid-bright",
+            className
+          )}
           style={{
             backgroundColor: theme.plain.backgroundColor,
           }}
@@ -338,14 +352,14 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
               className="px-2 py-3"
               preClassName="text-xs"
               isWrapped={isWrapped}
+              searchTerm={searchTerm}
             />
           ) : (
             <div
               dir="ltr"
               className={cn(
-                "px-2 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
-                !isWrapped && "overflow-x-auto",
-                isWrapped && "overflow-y-auto"
+                "min-h-0 flex-1 px-2 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+                "overflow-auto"
               )}
               style={{
                 maxHeight,
@@ -358,7 +372,7 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
                 )}
                 dir="ltr"
               >
-                {code}
+                {highlightSearchText(code, searchTerm)}
               </pre>
             </div>
           )}
@@ -400,7 +414,7 @@ export const CodeBlock = forwardRef<HTMLDivElement, CodeBlockProps>(
                 className="overflow-auto px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
               >
                 <pre className="relative mr-2 p-2 font-mono text-base leading-relaxed" dir="ltr">
-                  {code}
+                  {highlightSearchText(code, searchTerm)}
                 </pre>
               </div>
             )}
@@ -449,6 +463,7 @@ type HighlightCodeProps = {
   className?: string;
   preClassName?: string;
   isWrapped: boolean;
+  searchTerm?: string;
 };
 
 function HighlightCode({
@@ -461,6 +476,7 @@ function HighlightCode({
   className,
   preClassName,
   isWrapped,
+  searchTerm,
 }: HighlightCodeProps) {
   const [isLoaded, setIsLoaded] = useState(false);
 
@@ -470,13 +486,15 @@ function HighlightCode({
       import("prismjs/components/prism-json"),
       //@ts-ignore
       import("prismjs/components/prism-typescript"),
+      //@ts-ignore
+      import("prismjs/components/prism-sql.js"),
     ]).then(() => setIsLoaded(true));
   }, []);
 
   const containerClasses = cn(
-    "px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
-    !isWrapped && "overflow-x-auto",
-    isWrapped && "overflow-y-auto",
+    "min-h-0 flex-1 px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+    !isWrapped && "overflow-auto",
+    isWrapped && "overflow-auto",
     className
   );
 
@@ -552,6 +570,10 @@ function HighlightCode({
                     <div className="flex-1">
                       {line.map((token, key) => {
                         const tokenProps = getTokenProps({ token, key });
+
+                        // Highlight search term matches in token
+                        const content = highlightSearchText(token.content, searchTerm);
+
                         return (
                           <span
                             key={key}
@@ -560,7 +582,9 @@ function HighlightCode({
                               color: tokenProps?.style?.color as string,
                               ...tokenProps.style,
                             }}
-                          />
+                          >
+                            {content}
+                          </span>
                         );
                       })}
                     </div>
diff --git a/apps/webapp/app/components/code/QueryResultsChart.tsx b/apps/webapp/app/components/code/QueryResultsChart.tsx
new file mode 100644
index 00000000000..2c3f1c9f2bf
--- /dev/null
+++ b/apps/webapp/app/components/code/QueryResultsChart.tsx
@@ -0,0 +1,1261 @@
+import type { ColumnFormatType, OutputColumnMetadata } from "@internal/clickhouse";
+import { formatDurationMilliseconds } from "@trigger.dev/core/v3";
+import { BarChart3, LineChart } from "lucide-react";
+import { memo, useMemo } from "react";
+import { createValueFormatter } from "~/utils/columnFormat";
+import { formatCurrencyAccurate } from "~/utils/numberFormatter";
+import type { ChartConfig } from "~/components/primitives/charts/Chart";
+import { Chart } from "~/components/primitives/charts/ChartCompound";
+import { ChartBlankState } from "../primitives/charts/ChartBlankState";
+import { Callout } from "../primitives/Callout";
+import type { AggregationType, ChartConfiguration } from "../metrics/QueryWidget";
+import { aggregateValues } from "../primitives/charts/aggregation";
+import { getRunStatusHexColor } from "~/components/runs/v3/TaskRunStatus";
+import { getSeriesColor } from "./chartColors";
+
+const MAX_SERIES = 50;
+const MAX_SVG_ELEMENT_BUDGET = 6_000;
+const MIN_DATA_POINTS = 100;
+const MAX_DATA_POINTS = 500;
+
+interface QueryResultsChartProps {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+  config: ChartConfiguration;
+  /** The effective time range from the query filter (used to show the full x-axis period) */
+  timeRange?: { from: string; to: string };
+  fullLegend?: boolean;
+  /** Callback when "View all" legend button is clicked */
+  onViewAllLegendItems?: () => void;
+  /** When true, constrains legend to max 50% height with scrolling */
+  legendScrollable?: boolean;
+  isLoading?: boolean;
+}
+
+interface TransformedData {
+  data: Record<string, unknown>[];
+  series: string[];
+  /** Total number of series before any truncation (equals series.length when no truncation) */
+  totalSeriesCount: number;
+  /** Raw date values for determining formatting granularity */
+  dateValues: Date[];
+  /** Whether the x-axis is date-based (continuous time scale) */
+  isDateBased: boolean;
+  /** The data key to use for x-axis (column name or '__timestamp' for dates) */
+  xDataKey: string;
+  /** Min/max timestamps for domain when date-based */
+  timeDomain: [number, number] | null;
+  /** Pre-calculated tick values for the time axis */
+  timeTicks: number[] | null;
+}
+
+/**
+ * Time granularity levels for date formatting
+ */
+type TimeGranularity = "seconds" | "minutes" | "hours" | "days" | "weeks" | "months" | "years";
+
+/**
+ * Determines the appropriate time granularity based on the date range
+ */
+function detectTimeGranularity(dates: Date[]): TimeGranularity {
+  if (dates.length < 2) return "days";
+
+  const sorted = [...dates].sort((a, b) => a.getTime() - b.getTime());
+  const minDate = sorted[0];
+  const maxDate = sorted[sorted.length - 1];
+  const rangeMs = maxDate.getTime() - minDate.getTime();
+
+  const SECOND = 1000;
+  const MINUTE = 60 * SECOND;
+  const HOUR = 60 * MINUTE;
+  const DAY = 24 * HOUR;
+  const WEEK = 7 * DAY;
+  const MONTH = 30 * DAY;
+  const YEAR = 365 * DAY;
+
+  // Choose granularity based on range
+  if (rangeMs <= 5 * MINUTE) return "seconds"; // < 5 minutes → show seconds
+  if (rangeMs <= 2 * HOUR) return "minutes"; // < 2 hours → show minutes
+  if (rangeMs <= 2 * DAY) return "hours"; // < 2 days → show hours
+  if (rangeMs <= 2 * WEEK) return "days"; // < 2 weeks → show days
+  if (rangeMs <= 3 * MONTH) return "weeks"; // < 3 months → show weeks
+  if (rangeMs <= 2 * YEAR) return "months"; // < 2 years → show months
+  return "years"; // >= 2 years → show years
+}
+
+/**
+ * Formats a date for the X-axis based on the detected granularity
+ */
+function formatDateByGranularity(date: Date, granularity: TimeGranularity): string {
+  switch (granularity) {
+    case "seconds":
+      // "10:30:45"
+      return date.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+      });
+    case "minutes":
+      // "10:30"
+      return date.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+      });
+    case "hours":
+      // "Jan 15 10:00"
+      return `${date.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+      })} ${date.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+      })}`;
+    case "days":
+      // "Jan 15"
+      return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    case "weeks":
+      // "Jan 15"
+      return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    case "months":
+      // "Jan 2024"
+      return date.toLocaleDateString("en-US", { month: "short", year: "numeric" });
+    case "years":
+      // "2024"
+      return date.toLocaleDateString("en-US", { year: "numeric" });
+    default:
+      return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+  }
+}
+
+/**
+ * Snap a millisecond value up to the nearest "nice" interval
+ */
+function snapToNiceInterval(ms: number): number {
+  const SECOND = 1000;
+  const MINUTE = 60 * SECOND;
+  const HOUR = 60 * MINUTE;
+  const DAY = 24 * HOUR;
+
+  if (ms <= SECOND) return SECOND;
+  if (ms <= 5 * SECOND) return 5 * SECOND;
+  if (ms <= 10 * SECOND) return 10 * SECOND;
+  if (ms <= 15 * SECOND) return 15 * SECOND;
+  if (ms <= 30 * SECOND) return 30 * SECOND;
+  if (ms <= MINUTE) return MINUTE;
+  if (ms <= 5 * MINUTE) return 5 * MINUTE;
+  if (ms <= 10 * MINUTE) return 10 * MINUTE;
+  if (ms <= 15 * MINUTE) return 15 * MINUTE;
+  if (ms <= 30 * MINUTE) return 30 * MINUTE;
+  if (ms <= HOUR) return HOUR;
+  if (ms <= 2 * HOUR) return 2 * HOUR;
+  if (ms <= 4 * HOUR) return 4 * HOUR;
+  if (ms <= 6 * HOUR) return 6 * HOUR;
+  if (ms <= 12 * HOUR) return 12 * HOUR;
+  if (ms <= DAY) return DAY;
+
+  return ms;
+}
+
+/**
+ * Detect the most common interval between consecutive data points
+ * This helps us understand the natural granularity of the data
+ */
+function detectDataInterval(timestamps: number[]): number {
+  if (timestamps.length < 2) return 24 * 60 * 60 * 1000; // Default to 1 day
+
+  const sorted = [...timestamps].sort((a, b) => a - b);
+  const gaps: number[] = [];
+
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap > 0) {
+      gaps.push(gap);
+    }
+  }
+
+  if (gaps.length === 0) return 60 * 1000;
+
+  // Find the most common small gap (this is likely the data's natural interval)
+  // We use the minimum gap as a heuristic for the data interval
+  const minGap = Math.min(...gaps);
+
+  return snapToNiceInterval(minGap);
+}
+
+/**
+ * Fill in missing time slots with zero values
+ * This ensures the chart shows gaps as zeros rather than connecting distant points
+ */
+function fillTimeGaps(
+  data: Record<string, unknown>[],
+  xDataKey: string,
+  series: string[],
+  minTime: number,
+  maxTime: number,
+  interval: number,
+  granularity: TimeGranularity,
+  aggregation: AggregationType,
+  maxPoints = 1000
+): Record<string, unknown>[] {
+  const range = maxTime - minTime;
+  const estimatedPoints = Math.ceil(range / interval);
+
+  // If filling would create too many points, increase the interval to stay within limits
+  let effectiveInterval = interval;
+  if (estimatedPoints > maxPoints) {
+    effectiveInterval = snapToNiceInterval(Math.ceil(range / maxPoints));
+  }
+
+  // Create a map to collect values for each bucket (for aggregation)
+  const bucketData = new Map<
+    number,
+    { values: Record<string, number[]>; rawDate: Date; originalX: string }
+  >();
+
+  for (const point of data) {
+    const timestamp = point[xDataKey] as number;
+    // Bucket to the nearest interval
+    const bucketedTime = Math.floor(timestamp / effectiveInterval) * effectiveInterval;
+
+    if (!bucketData.has(bucketedTime)) {
+      bucketData.set(bucketedTime, {
+        values: Object.fromEntries(series.map((s) => [s, []])),
+        rawDate: new Date(bucketedTime),
+        originalX: new Date(bucketedTime).toISOString(),
+      });
+    }
+
+    const bucket = bucketData.get(bucketedTime)!;
+    for (const s of series) {
+      const val = point[s] as number;
+      if (typeof val === "number") {
+        bucket.values[s].push(val);
+      }
+    }
+  }
+
+  // Generate all time slots and fill with zeros where missing
+  const filledData: Record<string, unknown>[] = [];
+  const startTime = Math.floor(minTime / effectiveInterval) * effectiveInterval;
+
+  for (let t = startTime; t <= maxTime; t += effectiveInterval) {
+    const bucket = bucketData.get(t);
+    if (bucket) {
+      // Apply aggregation to collected values
+      const point: Record<string, unknown> = {
+        [xDataKey]: t,
+        __rawDate: bucket.rawDate,
+        __granularity: granularity,
+        __originalX: bucket.originalX,
+      };
+      for (const s of series) {
+        point[s] = aggregateValues(bucket.values[s], aggregation);
+      }
+      filledData.push(point);
+    } else {
+      // Create a null-filled data point so gaps appear in line/bar charts
+      // and legend aggregations (avg/min/max) skip these slots
+      const gapPoint: Record<string, unknown> = {
+        [xDataKey]: t,
+        __rawDate: new Date(t),
+        __granularity: granularity,
+        __originalX: new Date(t).toISOString(),
+      };
+      for (const s of series) {
+        gapPoint[s] = null;
+      }
+      filledData.push(gapPoint);
+    }
+  }
+
+  return filledData;
+}
+
+/**
+ * "Nice" intervals for time axes - these create human-friendly tick marks
+ */
+const NICE_TIME_INTERVALS = [
+  { value: 1000, label: "1s" }, // 1 second
+  { value: 5 * 1000, label: "5s" }, // 5 seconds
+  { value: 10 * 1000, label: "10s" }, // 10 seconds
+  { value: 30 * 1000, label: "30s" }, // 30 seconds
+  { value: 60 * 1000, label: "1m" }, // 1 minute
+  { value: 5 * 60 * 1000, label: "5m" }, // 5 minutes
+  { value: 10 * 60 * 1000, label: "10m" }, // 10 minutes
+  { value: 15 * 60 * 1000, label: "15m" }, // 15 minutes
+  { value: 30 * 60 * 1000, label: "30m" }, // 30 minutes
+  { value: 60 * 60 * 1000, label: "1h" }, // 1 hour
+  { value: 2 * 60 * 60 * 1000, label: "2h" }, // 2 hours
+  { value: 3 * 60 * 60 * 1000, label: "3h" }, // 3 hours
+  { value: 4 * 60 * 60 * 1000, label: "4h" }, // 4 hours
+  { value: 6 * 60 * 60 * 1000, label: "6h" }, // 6 hours
+  { value: 12 * 60 * 60 * 1000, label: "12h" }, // 12 hours
+  { value: 24 * 60 * 60 * 1000, label: "1d" }, // 1 day
+  { value: 2 * 24 * 60 * 60 * 1000, label: "2d" }, // 2 days
+  { value: 7 * 24 * 60 * 60 * 1000, label: "1w" }, // 1 week
+  { value: 14 * 24 * 60 * 60 * 1000, label: "2w" }, // 2 weeks
+  { value: 30 * 24 * 60 * 60 * 1000, label: "1mo" }, // ~1 month
+  { value: 90 * 24 * 60 * 60 * 1000, label: "3mo" }, // ~3 months
+  { value: 180 * 24 * 60 * 60 * 1000, label: "6mo" }, // ~6 months
+  { value: 365 * 24 * 60 * 60 * 1000, label: "1y" }, // 1 year
+];
+
+/**
+ * Generate evenly-spaced tick values for a time axis using "nice" intervals
+ * that align to natural time boundaries (midnight, noon, hour marks, etc.)
+ */
+function generateTimeTicks(minTime: number, maxTime: number, maxTicks = 8): number[] {
+  const range = maxTime - minTime;
+
+  if (range <= 0) {
+    return [minTime];
+  }
+
+  // Find the best "nice" interval that gives us a reasonable number of ticks
+  // Target: between 4 and maxTicks ticks
+  let chosenInterval = NICE_TIME_INTERVALS[NICE_TIME_INTERVALS.length - 1].value;
+
+  for (const { value: interval } of NICE_TIME_INTERVALS) {
+    const tickCount = Math.ceil(range / interval);
+    if (tickCount <= maxTicks && tickCount >= 2) {
+      chosenInterval = interval;
+      break;
+    }
+  }
+
+  // Align the start tick to a nice boundary
+  // For intervals >= 1 day, align to midnight
+  // For intervals >= 1 hour, align to hour boundary
+  // For intervals >= 1 minute, align to minute boundary
+  const DAY = 24 * 60 * 60 * 1000;
+  const HOUR = 60 * 60 * 1000;
+  const MINUTE = 60 * 1000;
+
+  let alignTo: number;
+  if (chosenInterval >= DAY) {
+    // Align to midnight UTC (or we could use local midnight)
+    alignTo = DAY;
+  } else if (chosenInterval >= HOUR) {
+    alignTo = chosenInterval; // Align to the interval itself for hours
+  } else if (chosenInterval >= MINUTE) {
+    alignTo = chosenInterval;
+  } else {
+    alignTo = chosenInterval;
+  }
+
+  // Round down to the alignment boundary, then find first tick at or before minTime
+  const startTick = Math.floor(minTime / alignTo) * alignTo;
+
+  // Generate ticks
+  const ticks: number[] = [];
+  for (let t = startTick; t <= maxTime + chosenInterval; t += chosenInterval) {
+    if (t >= minTime - chosenInterval * 0.1 && t <= maxTime + chosenInterval * 0.1) {
+      ticks.push(t);
+    }
+  }
+
+  // Ensure we have at least 2 ticks
+  if (ticks.length < 2) {
+    return [minTime, maxTime];
+  }
+
+  return ticks;
+}
+
+/**
+ * Formats a date for tooltips and legend headers.
+ * Always includes time when the data point has a non-midnight time,
+ * so hovering a specific bar at e.g. 14:00 shows the full timestamp
+ * even when the axis labels only show the day.
+ * Seconds are shown whenever the granularity is "seconds" or the
+ * specific data point has non-zero seconds.
+ */
+function formatDateForTooltip(date: Date, granularity: TimeGranularity): string {
+  const hasTime = date.getHours() !== 0 || date.getMinutes() !== 0 || date.getSeconds() !== 0;
+  const hasSeconds = date.getSeconds() !== 0;
+
+  if (
+    granularity === "seconds" ||
+    (hasTime && granularity !== "months" && granularity !== "years")
+  ) {
+    return date.toLocaleString("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: granularity === "seconds" || hasSeconds ? "2-digit" : undefined,
+      hour12: false,
+    });
+  }
+
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+}
+
+/**
+ * Try to parse a value as a Date
+ */
+function tryParseDate(value: unknown): Date | null {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === "number") {
+    // First, try treating the number as milliseconds
+    const dateAsMs = new Date(value);
+    if (
+      !isNaN(dateAsMs.getTime()) &&
+      dateAsMs.getFullYear() >= 1970 &&
+      dateAsMs.getFullYear() <= 2100
+    ) {
+      return dateAsMs;
+    }
+    // If that fails, try treating the number as seconds (Unix timestamp)
+    const dateAsSec = new Date(value * 1000);
+    if (
+      !isNaN(dateAsSec.getTime()) &&
+      dateAsSec.getFullYear() >= 1970 &&
+      dateAsSec.getFullYear() <= 2100
+    ) {
+      return dateAsSec;
+    }
+  }
+  return null;
+}
+
+/**
+ * Transform raw query results into chart-ready data
+ *
+ * When grouped:
+ * - Pivots data so each unique group value becomes a separate series
+ * - Each row in output has xAxis value + one key per group value
+ *
+ * When not grouped:
+ * - Uses Y-axis columns directly as series
+ *
+ * For date-based x-axes:
+ * - Uses numeric timestamps so the chart renders with a continuous time scale
+ * - This ensures gaps in data are visually apparent
+ */
+function transformDataForChart(
+  rows: Record<string, unknown>[],
+  config: ChartConfiguration,
+  timeRange?: { from: string; to: string }
+): TransformedData {
+  const { xAxisColumn, yAxisColumns, groupByColumn, aggregation } = config;
+
+  if (!xAxisColumn || yAxisColumns.length === 0) {
+    return {
+      data: [],
+      series: [],
+      totalSeriesCount: 0,
+      dateValues: [],
+      isDateBased: false,
+      xDataKey: xAxisColumn || "",
+      timeDomain: null,
+      timeTicks: null,
+    };
+  }
+
+  // Collect date values for granularity detection
+  const dateValues: Date[] = [];
+  for (const row of rows) {
+    const date = tryParseDate(row[xAxisColumn]);
+    if (date) {
+      dateValues.push(date);
+    }
+  }
+
+  // Determine if X-axis is date-based (most values should be parseable as dates)
+  // When there are no results but a timeRange is provided, treat as date-based
+  const isDateBased =
+    rows.length === 0 && timeRange ? true : dateValues.length >= rows.length * 0.8; // At least 80% are dates
+
+  // Detect granularity from the full time range when available, otherwise from data
+  const granularity = isDateBased
+    ? timeRange
+      ? detectTimeGranularity([new Date(timeRange.from), new Date(timeRange.to)])
+      : detectTimeGranularity(dateValues)
+    : "days";
+
+  // For date-based axes, use a special key for the timestamp
+  const xDataKey = isDateBased ? "__timestamp" : xAxisColumn;
+
+  // Calculate time domain and ticks for date-based axes
+  // When a timeRange is provided (from the query filter), use it so the chart
+  // shows the full requested period rather than just the range of returned data.
+  let timeDomain: [number, number] | null = null;
+  let timeTicks: number[] | null = null;
+  // Raw min/max used for gap filling (without padding)
+  let rawMinTime = 0;
+  let rawMaxTime = 0;
+  if (isDateBased && (dateValues.length > 0 || timeRange)) {
+    const dataTimestamps = dateValues.map((d) => d.getTime());
+    rawMinTime = timeRange ? new Date(timeRange.from).getTime() : Math.min(...dataTimestamps);
+    rawMaxTime = timeRange ? new Date(timeRange.to).getTime() : Math.max(...dataTimestamps);
+    // Add a small padding (2% on each side) so points aren't at the very edge
+    const padding = (rawMaxTime - rawMinTime) * 0.02;
+    timeDomain = [rawMinTime - padding, rawMaxTime + padding];
+    // Generate evenly-spaced ticks across the entire range using nice intervals
+    timeTicks = generateTimeTicks(rawMinTime, rawMaxTime);
+  }
+
+  // Helper to format X value for categorical axes (non-date)
+  const formatX = (value: unknown): string => {
+    if (value === null || value === undefined) return "N/A";
+    return String(value);
+  };
+
+  // No grouping: use Y columns directly as series
+  // Group rows by X value first, then aggregate
+  if (!groupByColumn) {
+    // Group rows by X-axis value to handle duplicates
+    const groupedByX = new Map<
+      string | number,
+      { yValues: Record<string, number[]>; rawDate: Date | null; originalX: unknown }
+    >();
+
+    for (const row of rows) {
+      const rawDate = tryParseDate(row[xAxisColumn]);
+
+      // Skip rows with invalid dates for date-based axes
+      if (isDateBased && !rawDate) continue;
+
+      const xKey = isDateBased && rawDate ? rawDate.getTime() : formatX(row[xAxisColumn]);
+
+      if (!groupedByX.has(xKey)) {
+        groupedByX.set(xKey, {
+          yValues: Object.fromEntries(yAxisColumns.map((col) => [col, []])),
+          rawDate,
+          originalX: row[xAxisColumn],
+        });
+      }
+
+      const existing = groupedByX.get(xKey)!;
+      for (const yCol of yAxisColumns) {
+        existing.yValues[yCol].push(toNumber(row[yCol]));
+      }
+    }
+
+    // Convert to array format with aggregation applied
+    let data = Array.from(groupedByX.entries()).map(([xKey, { yValues, rawDate, originalX }]) => {
+      const point: Record<string, unknown> = {
+        [xDataKey]: xKey,
+        __rawDate: rawDate,
+        __granularity: granularity,
+        __originalX: originalX,
+      };
+      for (const yCol of yAxisColumns) {
+        point[yCol] = aggregateValues(yValues[yCol], aggregation);
+      }
+      return point;
+    });
+
+    // Fill in gaps with zeros for date-based data
+    const seriesForBudget = Math.min(yAxisColumns.length, MAX_SERIES);
+    const effectiveMaxPoints = Math.max(
+      MIN_DATA_POINTS,
+      Math.min(MAX_DATA_POINTS, Math.floor(MAX_SVG_ELEMENT_BUDGET / seriesForBudget))
+    );
+
+    if (isDateBased && timeDomain) {
+      const timestamps = dateValues.map((d) => d.getTime());
+      const dataInterval = detectDataInterval(timestamps);
+      const rangeMs = rawMaxTime - rawMinTime;
+      const minRangeInterval = timeRange ? snapToNiceInterval(rangeMs / effectiveMaxPoints) : 0;
+      const maxRangeInterval =
+        timeRange && rangeMs > 0 ? snapToNiceInterval(rangeMs / 8) : Infinity;
+      const effectiveInterval = Math.min(
+        Math.max(dataInterval, minRangeInterval),
+        maxRangeInterval
+      );
+      data = fillTimeGaps(
+        data,
+        xDataKey,
+        yAxisColumns,
+        rawMinTime,
+        rawMaxTime,
+        effectiveInterval,
+        granularity,
+        aggregation,
+        effectiveMaxPoints
+      );
+    } else if (data.length > effectiveMaxPoints) {
+      data = data.slice(0, effectiveMaxPoints);
+    }
+
+    return {
+      data,
+      series: yAxisColumns,
+      totalSeriesCount: yAxisColumns.length,
+      dateValues,
+      isDateBased,
+      xDataKey,
+      timeDomain,
+      timeTicks,
+    };
+  }
+
+  // With grouping: pivot data so each group value becomes a series
+  const yCol = yAxisColumns[0]; // Use first Y column when grouping
+
+  // First pass: collect all values grouped by (xKey, groupValue) and accumulate
+  // per-group totals so we can pick the top-N groups before building heavy data
+  // objects with thousands of keys.
+  const groupTotals = new Map<string, number>();
+  const groupedByX = new Map<
+    string | number,
+    { values: Record<string, number[]>; rawDate: Date | null; originalX: unknown }
+  >();
+
+  for (const row of rows) {
+    const rawDate = tryParseDate(row[xAxisColumn]);
+
+    if (isDateBased && !rawDate) continue;
+
+    const xKey = isDateBased && rawDate ? rawDate.getTime() : formatX(row[xAxisColumn]);
+    const groupValue = String(row[groupByColumn] ?? "Unknown");
+    const yValue = toNumber(row[yCol]);
+
+    groupTotals.set(groupValue, (groupTotals.get(groupValue) ?? 0) + Math.abs(yValue));
+
+    if (!groupedByX.has(xKey)) {
+      groupedByX.set(xKey, { values: {}, rawDate, originalX: row[xAxisColumn] });
+    }
+
+    const existing = groupedByX.get(xKey)!;
+    if (!existing.values[groupValue]) {
+      existing.values[groupValue] = [];
+    }
+    existing.values[groupValue].push(yValue);
+  }
+
+  // Keep only the top MAX_SERIES groups by absolute total to avoid O(n) processing
+  // downstream (data objects, gap filling, legend totals, SVG rendering).
+  const totalSeriesCount = groupTotals.size;
+  let series: string[];
+  if (groupTotals.size <= MAX_SERIES) {
+    series = Array.from(groupTotals.keys()).sort();
+  } else {
+    series = Array.from(groupTotals.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, MAX_SERIES)
+      .map(([key]) => key)
+      .sort();
+  }
+  // Convert to array format with aggregation applied (only for kept series)
+  let data = Array.from(groupedByX.entries()).map(([xKey, { values, rawDate, originalX }]) => {
+    const point: Record<string, unknown> = {
+      [xDataKey]: xKey,
+      __rawDate: rawDate,
+      __granularity: granularity,
+      __originalX: originalX,
+    };
+    for (const group of series) {
+      point[group] = values[group] ? aggregateValues(values[group], aggregation) : 0;
+    }
+    return point;
+  });
+
+  // Dynamic data-point budget based on the (already capped) series count
+  const effectiveMaxPoints = Math.max(
+    MIN_DATA_POINTS,
+    Math.min(MAX_DATA_POINTS, Math.floor(MAX_SVG_ELEMENT_BUDGET / series.length))
+  );
+
+  if (isDateBased && timeDomain) {
+    const timestamps = dateValues.map((d) => d.getTime());
+    const dataInterval = detectDataInterval(timestamps);
+    const rangeMs = rawMaxTime - rawMinTime;
+    const minRangeInterval = timeRange ? snapToNiceInterval(rangeMs / effectiveMaxPoints) : 0;
+    const maxRangeInterval = timeRange && rangeMs > 0 ? snapToNiceInterval(rangeMs / 8) : Infinity;
+    const effectiveInterval = Math.min(Math.max(dataInterval, minRangeInterval), maxRangeInterval);
+    data = fillTimeGaps(
+      data,
+      xDataKey,
+      series,
+      rawMinTime,
+      rawMaxTime,
+      effectiveInterval,
+      granularity,
+      aggregation,
+      effectiveMaxPoints
+    );
+  } else if (data.length > effectiveMaxPoints) {
+    data = data.slice(0, effectiveMaxPoints);
+  }
+
+  return {
+    data,
+    series,
+    totalSeriesCount,
+    dateValues,
+    isDateBased,
+    xDataKey,
+    timeDomain,
+    timeTicks,
+  };
+}
+
+function toNumber(value: unknown): number {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? 0 : parsed;
+  }
+  return 0;
+}
+
+/**
+ * Sort data array by a specified column
+ */
+function sortData(
+  data: Record<string, unknown>[],
+  sortByColumn: string | null,
+  sortDirection: "asc" | "desc",
+  xAxisColumn?: string | null
+): Record<string, unknown>[] {
+  if (!sortByColumn) return data;
+
+  return [...data].sort((a, b) => {
+    const aVal = a[sortByColumn];
+    const bVal = b[sortByColumn];
+
+    // Handle null/undefined
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return sortDirection === "asc" ? -1 : 1;
+    if (bVal == null) return sortDirection === "asc" ? 1 : -1;
+
+    // Only use date comparison when sorting by the X-axis column
+    if (sortByColumn === xAxisColumn) {
+      const aDate = a.__rawDate as Date | null;
+      const bDate = b.__rawDate as Date | null;
+      if (aDate && bDate) {
+        const diff = aDate.getTime() - bDate.getTime();
+        return sortDirection === "asc" ? diff : -diff;
+      }
+    }
+
+    // Compare as numbers if possible
+    const aNum = typeof aVal === "number" ? aVal : parseFloat(String(aVal));
+    const bNum = typeof bVal === "number" ? bVal : parseFloat(String(bVal));
+    if (!isNaN(aNum) && !isNaN(bNum)) {
+      return sortDirection === "asc" ? aNum - bNum : bNum - aNum;
+    }
+
+    // Fall back to string comparison
+    const aStr = String(aVal);
+    const bStr = String(bVal);
+    const cmp = aStr.localeCompare(bStr);
+    return sortDirection === "asc" ? cmp : -cmp;
+  });
+}
+
+export const QueryResultsChart = memo(function QueryResultsChart({
+  rows,
+  columns,
+  config,
+  timeRange,
+  fullLegend = false,
+  onViewAllLegendItems,
+  isLoading = false,
+  legendScrollable = false,
+}: QueryResultsChartProps) {
+  const {
+    xAxisColumn,
+    yAxisColumns,
+    chartType,
+    groupByColumn,
+    stacked,
+    sortByColumn,
+    sortDirection,
+  } = config;
+
+  // Transform data for charting
+  const {
+    data: unsortedData,
+    series,
+    totalSeriesCount,
+    dateValues,
+    isDateBased,
+    xDataKey,
+    timeDomain,
+    timeTicks,
+  } = useMemo(() => transformDataForChart(rows, config, timeRange), [rows, config, timeRange]);
+
+  // Apply sorting (for date-based, sort by timestamp to ensure correct order)
+  const data = useMemo(() => {
+    if (isDateBased) {
+      // Always sort by timestamp for date-based axes
+      return sortData(unsortedData, xDataKey, "asc", xDataKey);
+    }
+    return sortData(unsortedData, sortByColumn, sortDirection, xDataKey);
+  }, [unsortedData, sortByColumn, sortDirection, isDateBased, xDataKey]);
+
+  // Sort series by descending total sum so largest appears at bottom of
+  // stacked charts and first in the legend
+  const sortedSeries = useMemo(() => {
+    if (series.length <= 1) return series;
+    const totals = new Map<string, number>();
+    for (const s of series) {
+      let total = 0;
+      for (const point of data) {
+        const val = point[s];
+        if (typeof val === "number" && isFinite(val)) {
+          total += Math.abs(val);
+        }
+      }
+      totals.set(s, total);
+    }
+    return [...series].sort((a, b) => (totals.get(b) ?? 0) - (totals.get(a) ?? 0));
+  }, [series, data]);
+
+  // Limit SVG-rendered series to MAX_SERIES (top N by total value)
+  const visibleSeries = useMemo(
+    () => (sortedSeries.length > MAX_SERIES ? sortedSeries.slice(0, MAX_SERIES) : sortedSeries),
+    [sortedSeries]
+  );
+
+  const seriesLimitCallout =
+    totalSeriesCount > series.length ? (
+      <div className="mt-1 px-2">
+        <Callout variant="warning">
+          {`Limited to the top ${
+            series.length
+          } of ${totalSeriesCount.toLocaleString()} series for performance reasons.`}
+        </Callout>
+      </div>
+    ) : null;
+
+  // Detect time granularity — use the full time range when available so tick
+  // labels are appropriate for the period (e.g. "Jan 5" for a 7-day range
+  // instead of just "16:00:00" when data is sparse)
+  const timeGranularity = useMemo(() => {
+    if (timeRange) {
+      return detectTimeGranularity([new Date(timeRange.from), new Date(timeRange.to)]);
+    }
+    return dateValues.length > 0 ? detectTimeGranularity(dateValues) : null;
+  }, [dateValues, timeRange]);
+
+  // X-axis tick formatter for date-based axes (pure – no deduplication).
+  // Label deduplication is handled inside dateAxisTick below so that the
+  // mutable "lastLabel" state is correctly reset on each Recharts render pass.
+  const xAxisTickFormatter = useMemo(() => {
+    if (!isDateBased || !timeGranularity) return undefined;
+    return (value: number) => {
+      const date = new Date(value);
+      return formatDateByGranularity(date, timeGranularity);
+    };
+  }, [isDateBased, timeGranularity]);
+
+  // Resolve the Y-axis column format for formatting
+  const yAxisFormat = useMemo(() => {
+    if (yAxisColumns.length === 0) return undefined;
+    const col = columns.find((c) => c.name === yAxisColumns[0]);
+    return (col?.format ?? col?.customRenderType) as ColumnFormatType | undefined;
+  }, [yAxisColumns, columns]);
+
+  // Create dynamic Y-axis formatter based on data range and format
+  const yAxisFormatter = useMemo(
+    () => createYAxisFormatter(data, series, yAxisFormat),
+    [data, series, yAxisFormat]
+  );
+
+  // Create value formatter for tooltips and legend based on column format
+  const tooltipValueFormatter = useMemo(
+    () => createValueFormatter(yAxisFormat),
+    [yAxisFormat]
+  );
+
+  // Check if the group-by column has a runStatus customRenderType
+  const groupByIsRunStatus = useMemo(() => {
+    if (!groupByColumn) return false;
+    const col = columns.find((c) => c.name === groupByColumn);
+    return col?.customRenderType === "runStatus";
+  }, [groupByColumn, columns]);
+
+  // Build chart config for colors/labels
+  const chartConfig = useMemo(() => {
+    const cfg: ChartConfig = {};
+    sortedSeries.forEach((s, i) => {
+      const statusColor = groupByIsRunStatus ? getRunStatusHexColor(s) : undefined;
+      const originalIndex = config.yAxisColumns.indexOf(s);
+      const colorIndex = originalIndex >= 0 ? originalIndex : i;
+      cfg[s] = {
+        label: s,
+        color: statusColor ?? config.seriesColors?.[s] ?? getSeriesColor(colorIndex),
+      };
+    });
+    return cfg;
+  }, [sortedSeries, groupByIsRunStatus, config.seriesColors, config.yAxisColumns]);
+
+  // Custom tooltip label formatter for better date display
+  const tooltipLabelFormatter = useMemo(() => {
+    return (label: string, payload: Array<{ payload?: Record<string, unknown> }>) => {
+      // Try to get the raw date from the payload for better formatting
+      const rawDate = payload[0]?.payload?.__rawDate as Date | null | undefined;
+      const granularity = payload[0]?.payload?.__granularity as TimeGranularity | undefined;
+
+      if (rawDate && granularity) {
+        return formatDateForTooltip(rawDate, granularity);
+      }
+      return label;
+    };
+  }, []);
+
+  // Label formatter for the legend (formats x-axis values)
+  const legendLabelFormatter = useMemo(() => {
+    if (!isDateBased || !timeGranularity) return undefined;
+    return (value: string) => {
+      // For date-based axes, the value is a timestamp
+      const timestamp = Number(value);
+      if (!isNaN(timestamp)) {
+        const date = new Date(timestamp);
+        return formatDateForTooltip(date, timeGranularity);
+      }
+      return value;
+    };
+  }, [isDateBased, timeGranularity]);
+
+  // Y-axis domain calculation - must be before early returns to maintain consistent hook order
+  const yAxisDomain = useMemo(() => {
+    let min = 0;
+    for (const point of data) {
+      for (const s of series) {
+        const val = point[s];
+        if (typeof val === "number" && isFinite(val)) {
+          min = Math.min(min, val);
+        }
+      }
+    }
+    return [min, "auto"] as [number, string];
+  }, [data, series]);
+
+  // Angle all date-based labels for consistent appearance and to avoid overlap
+  const xAxisAngle = isDateBased ? -45 : 0;
+  const xAxisHeight = xAxisAngle !== 0 ? 65 : undefined;
+
+  // Check if the data would produce duplicate labels at the current granularity.
+  // Only use the custom tick renderer (with interval:0) when duplicates exist,
+  // otherwise let Recharts handle label spacing to avoid collisions.
+  const hasDuplicateLabels = useMemo(() => {
+    if (!isDateBased || !timeGranularity || data.length === 0) return false;
+    const labels = new Set<string>();
+    for (const point of data) {
+      const ts = point.__timestamp ?? point[xDataKey];
+      if (typeof ts === "number") {
+        labels.add(formatDateByGranularity(new Date(ts), timeGranularity));
+      }
+    }
+    return labels.size < data.length;
+  }, [isDateBased, timeGranularity, data, xDataKey]);
+
+  // Custom tick renderer for date-based axes: renders a tick mark alongside
+  // each label, and for unlabelled points (de-duplicated) just a subtle tick mark.
+  // De-duplication lives here (not in xAxisTickFormatter) so that the mutable
+  // lastLabel is reset when Recharts starts a new render pass (index === 0).
+  const dateAxisTick = useMemo(() => {
+    if (!isDateBased || !xAxisTickFormatter) return undefined;
+    let lastLabel = "";
+    return (props: Record<string, unknown>) => {
+      const { x, y, payload, index } = props as {
+        x: number;
+        y: number;
+        payload: { value: number };
+        index: number;
+      };
+
+      // Reset dedup state at the start of each Recharts render pass
+      if (index === 0) lastLabel = "";
+
+      const formatted = xAxisTickFormatter(payload.value);
+      const label = formatted === lastLabel ? "" : formatted;
+      lastLabel = formatted;
+      // y is the tick text position, offset from the axis by tickMargin + internal padding
+      const axisY = (y as number) - 12;
+      if (label) {
+        return (
+          <g>
+            <line
+              x1={x as number}
+              y1={axisY}
+              x2={x as number}
+              y2={axisY - 3}
+              stroke="#878C99"
+              strokeWidth={1}
+            />
+            <text
+              x={x}
+              y={axisY}
+              dy={10}
+              fill="#878C99"
+              fontSize={11}
+              textAnchor={xAxisAngle !== 0 ? "end" : "middle"}
+              style={{ fontVariantNumeric: "tabular-nums" }}
+              transform={
+                xAxisAngle !== 0 ? `rotate(${xAxisAngle}, ${x}, ${axisY + 10})` : undefined
+              }
+            >
+              {label}
+            </text>
+          </g>
+        );
+      }
+      // Small tick mark sitting on the axis baseline, pointing upward
+      return (
+        <line
+          x1={x as number}
+          y1={axisY}
+          x2={x as number}
+          y2={axisY - 3}
+          stroke="#272A2E"
+          strokeWidth={1}
+        />
+      );
+    };
+  }, [isDateBased, xAxisTickFormatter, xAxisAngle]);
+
+  // Validation — all hooks must be above this point
+  const chartIcon = chartType === "bar" ? BarChart3 : LineChart;
+
+  if (!xAxisColumn) {
+    return (
+      <ChartBlankState icon={chartIcon} message="Select an X-axis column to display the chart" />
+    );
+  }
+
+  if (yAxisColumns.length === 0) {
+    return (
+      <ChartBlankState icon={chartIcon} message="Select a Y-axis column to display the chart" />
+    );
+  }
+
+  if (rows.length === 0) {
+    return <ChartBlankState icon={chartIcon} message="No data to display" />;
+  }
+
+  if (data.length === 0) {
+    return <ChartBlankState icon={chartIcon} message="Unable to transform data for chart" />;
+  }
+
+  // Base x-axis props shared by all chart types
+  const baseXAxisProps = {
+    ...(dateAxisTick
+      ? {
+          tick: dateAxisTick,
+          tickLine: false,
+          tickFormatter: undefined,
+          // Only force every tick to render when there are duplicates to de-duplicate;
+          // otherwise let Recharts auto-space to avoid label collisions
+          ...(hasDuplicateLabels ? { interval: 0 } : {}),
+        }
+      : { tickFormatter: xAxisTickFormatter }),
+    angle: xAxisAngle,
+    textAnchor: xAxisAngle !== 0 ? ("end" as const) : ("middle" as const),
+    height: xAxisHeight,
+  };
+
+  // Line charts use continuous time scale for date-based data
+  // This properly represents time gaps between data points
+  const xAxisPropsForLine = isDateBased
+    ? {
+        type: "number" as const,
+        domain: timeDomain ?? (["auto", "auto"] as [string, string]),
+        scale: "time" as const,
+        // Explicitly specify tick positions so labels appear across the entire range
+        ticks: timeTicks ?? undefined,
+        ...baseXAxisProps,
+      }
+    : baseXAxisProps;
+
+  // Bar charts always use categorical axis positioning
+  // This ensures bars are evenly distributed regardless of data point count
+  // (prevents massive bars when there are only a few data points)
+  const xAxisPropsForBar = baseXAxisProps;
+
+  const yAxisProps = {
+    tickFormatter: yAxisFormatter,
+    domain: yAxisDomain,
+  };
+
+  const showLegend = sortedSeries.length > 0;
+
+  if (chartType === "bar") {
+    return (
+      <Chart.Root
+        config={chartConfig}
+        data={data}
+        dataKey={xDataKey}
+        series={sortedSeries}
+        visibleSeries={visibleSeries}
+        labelFormatter={legendLabelFormatter}
+        showLegend={showLegend}
+        maxLegendItems={fullLegend ? Infinity : 5}
+        legendAggregation={config.aggregation}
+        legendValueFormatter={tooltipValueFormatter}
+        minHeight="300px"
+        fillContainer
+        onViewAllLegendItems={onViewAllLegendItems}
+        legendScrollable={legendScrollable}
+        state={isLoading ? "loading" : "loaded"}
+        beforeLegend={seriesLimitCallout}
+      >
+        <Chart.Bar
+          xAxisProps={xAxisPropsForBar}
+          yAxisProps={yAxisProps}
+          stackId={stacked ? "stack" : undefined}
+          tooltipLabelFormatter={tooltipLabelFormatter}
+          tooltipValueFormatter={tooltipValueFormatter}
+        />
+      </Chart.Root>
+    );
+  }
+
+  // Line or stacked area chart
+  return (
+    <Chart.Root
+      config={chartConfig}
+      data={data}
+      dataKey={xDataKey}
+      series={sortedSeries}
+      visibleSeries={visibleSeries}
+      labelFormatter={legendLabelFormatter}
+      showLegend={showLegend}
+      maxLegendItems={fullLegend ? Infinity : 5}
+      legendAggregation={config.aggregation}
+      legendValueFormatter={tooltipValueFormatter}
+      minHeight="300px"
+      fillContainer
+      onViewAllLegendItems={onViewAllLegendItems}
+      legendScrollable={legendScrollable}
+      state={isLoading ? "loading" : "loaded"}
+      beforeLegend={seriesLimitCallout}
+    >
+      <Chart.Line
+        xAxisProps={xAxisPropsForLine}
+        yAxisProps={yAxisProps}
+        stacked={stacked && visibleSeries.length > 1}
+        tooltipLabelFormatter={tooltipLabelFormatter}
+        tooltipValueFormatter={tooltipValueFormatter}
+        lineType="linear"
+      />
+    </Chart.Root>
+  );
+});
+
+/**
+ * Creates a Y-axis value formatter based on the data range and optional format hint
+ */
+function createYAxisFormatter(
+  data: Record<string, unknown>[],
+  series: string[],
+  format?: ColumnFormatType
+) {
+  // Find min and max values across all series
+  let minVal = Infinity;
+  let maxVal = -Infinity;
+
+  for (const point of data) {
+    for (const s of series) {
+      const val = point[s];
+      if (typeof val === "number" && isFinite(val)) {
+        minVal = Math.min(minVal, val);
+        maxVal = Math.max(maxVal, val);
+      }
+    }
+  }
+
+  const range = maxVal - minVal;
+
+  // Format-aware formatters
+  if (format === "bytes" || format === "decimalBytes") {
+    const divisor = format === "bytes" ? 1024 : 1000;
+    const units =
+      format === "bytes"
+        ? ["B", "KiB", "MiB", "GiB", "TiB"]
+        : ["B", "KB", "MB", "GB", "TB"];
+    return (value: number): string => {
+      if (value === 0) return "0 B";
+      // Use consistent unit for all ticks based on max value
+      const i = Math.min(
+        Math.max(0, Math.floor(Math.log(Math.abs(maxVal || 1)) / Math.log(divisor))),
+        units.length - 1
+      );
+      const scaled = value / Math.pow(divisor, i);
+      return `${scaled.toFixed(scaled < 10 ? 1 : 0)} ${units[i]}`;
+    };
+  }
+
+  if (format === "percent") {
+    return (value: number): string => `${value.toFixed(range < 1 ? 2 : 1)}%`;
+  }
+
+  if (format === "duration") {
+    return (value: number): string => formatDurationMilliseconds(value, { style: "short" });
+  }
+
+  if (format === "durationSeconds") {
+    return (value: number): string =>
+      formatDurationMilliseconds(value * 1000, { style: "short" });
+  }
+
+  if (format === "durationNs") {
+    return (value: number): string =>
+      formatDurationMilliseconds(value / 1_000_000, { style: "short" });
+  }
+
+  if (format === "costInDollars" || format === "cost") {
+    return (value: number): string => {
+      const dollars = format === "cost" ? value / 100 : value;
+      if (dollars === 0) return "$0";
+      if (Math.abs(dollars) >= 1000) return `$${(dollars / 1000).toFixed(1)}K`;
+      if (Math.abs(dollars) >= 1) return `$${dollars.toFixed(2)}`;
+      if (Math.abs(dollars) >= 0.01) return `$${dollars.toFixed(4)}`;
+      if (Math.abs(dollars) >= 0.0001) return `$${dollars.toFixed(6)}`;
+      return formatCurrencyAccurate(dollars);
+    };
+  }
+
+  // Default formatter
+  return (value: number): string => {
+    // Use abbreviations for large numbers
+    if (Math.abs(value) >= 1_000_000) {
+      return `${(value / 1_000_000).toFixed(1)}M`;
+    }
+    if (Math.abs(value) >= 1_000) {
+      return `${(value / 1_000).toFixed(1)}K`;
+    }
+
+    // Determine decimal places based on range
+    if (range === 0 || !isFinite(range)) {
+      return Number.isInteger(value) ? value.toString() : value.toFixed(2);
+    }
+
+    // For small ranges, show more precision
+    if (range < 0.01) {
+      return value.toFixed(4);
+    }
+    if (range < 0.1) {
+      return value.toFixed(3);
+    }
+    if (range < 10) {
+      return value.toFixed(2);
+    }
+    if (range < 100) {
+      return value.toFixed(1);
+    }
+
+    // For large ranges, no decimals
+    return Math.round(value).toString();
+  };
+}
diff --git a/apps/webapp/app/components/code/TSQLEditor.tsx b/apps/webapp/app/components/code/TSQLEditor.tsx
new file mode 100644
index 00000000000..1fa56a2cea8
--- /dev/null
+++ b/apps/webapp/app/components/code/TSQLEditor.tsx
@@ -0,0 +1,387 @@
+import { sql, StandardSQL } from "@codemirror/lang-sql";
+import { autocompletion, startCompletion } from "@codemirror/autocomplete";
+import { linter, lintGutter } from "@codemirror/lint";
+import { EditorView, keymap } from "@codemirror/view";
+import type { ViewUpdate } from "@codemirror/view";
+import { CheckIcon, ClipboardIcon, SparklesIcon, TrashIcon } from "@heroicons/react/20/solid";
+import {
+  type ReactCodeMirrorProps,
+  type UseCodeMirror,
+  useCodeMirror,
+} from "@uiw/react-codemirror";
+import { useCallback, useEffect, useRef, useState, useMemo } from "react";
+import { cn } from "~/utils/cn";
+import { Button } from "../primitives/Buttons";
+import { getEditorSetup } from "./codeMirrorSetup";
+import { darkTheme } from "./codeMirrorTheme";
+import { createTSQLCompletion } from "./tsql/tsqlCompletion";
+import { createTSQLLinter } from "./tsql/tsqlLinter";
+import type { TableSchema } from "@internal/tsql";
+import { format as formatSQL } from "sql-formatter";
+
+export interface TSQLEditorProps extends Omit<ReactCodeMirrorProps, "onBlur"> {
+  /** Initial value for the editor */
+  defaultValue?: string;
+  /** Whether the editor is read-only */
+  readOnly?: boolean;
+  /** Called when the editor content changes */
+  onChange?: (value: string) => void;
+  /** Called when the editor state updates */
+  onUpdate?: (update: ViewUpdate) => void;
+  /** Called when the editor loses focus */
+  onBlur?: (code: string) => void;
+  /** Schema for table/column autocompletion */
+  schema?: TableSchema[];
+  /** Show copy button */
+  showCopyButton?: boolean;
+  /** Show clear button */
+  showClearButton?: boolean;
+  /** Show format button */
+  showFormatButton?: boolean;
+  /** Enable linting (syntax checking) */
+  linterEnabled?: boolean;
+  /** Placeholder text when empty */
+  placeholder?: string;
+  /** Additional actions to show in the toolbar */
+  additionalActions?: React.ReactNode;
+  /** Minimum height of the editor */
+  minHeight?: string;
+}
+
+type TSQLEditorDefaultProps = Partial<TSQLEditorProps>;
+
+const defaultProps: TSQLEditorDefaultProps = {
+  readOnly: false,
+  basicSetup: false,
+  linterEnabled: true,
+  showCopyButton: true,
+  showClearButton: false,
+  showFormatButton: true,
+  schema: [],
+};
+
+// Toggle comment on current line or selected lines with -- comment symbol
+const toggleLineComment = (view: EditorView): boolean => {
+  const { from, to } = view.state.selection.main;
+  const startLine = view.state.doc.lineAt(from);
+  // When `to` is exactly at the start of a line and there's an actual selection,
+  // the caret sits before that line — so exclude it by stepping back one position.
+  const adjustedTo = to > from && view.state.doc.lineAt(to).from === to ? to - 1 : to;
+  const endLine = view.state.doc.lineAt(adjustedTo);
+
+  // Collect all lines in the selection
+  const lines: { from: number; to: number; text: string }[] = [];
+  for (let i = startLine.number; i <= endLine.number; i++) {
+    const line = view.state.doc.line(i);
+    lines.push({ from: line.from, to: line.to, text: line.text });
+  }
+
+  // Determine action: if all non-empty lines are commented, uncomment; otherwise comment
+  const allCommented = lines.every((line) => {
+    const trimmed = line.text.trimStart();
+    return trimmed.length === 0 || trimmed.startsWith("--");
+  });
+
+  const changes = lines
+    .map((line) => {
+      const trimmed = line.text.trimStart();
+      if (trimmed.length === 0) return null; // skip empty lines
+      const indent = line.text.length - trimmed.length;
+
+      if (allCommented) {
+        // Remove comment: strip "-- " or just "--"
+        const afterComment = trimmed.slice(2);
+        const newText = line.text.slice(0, indent) + afterComment.replace(/^\s/, "");
+        return { from: line.from, to: line.to, insert: newText };
+      } else {
+        // Add comment: prepend "-- " to the line content
+        const newText = line.text.slice(0, indent) + "-- " + trimmed;
+        return { from: line.from, to: line.to, insert: newText };
+      }
+    })
+    .filter((c): c is { from: number; to: number; insert: string } => c !== null);
+
+  if (changes.length > 0) {
+    view.dispatch({ changes });
+  }
+
+  return true;
+};
+
+export function TSQLEditor(opts: TSQLEditorProps) {
+  const {
+    defaultValue = "",
+    readOnly = false,
+    onChange,
+    onUpdate,
+    onBlur,
+    basicSetup = false,
+    autoFocus,
+    showCopyButton = true,
+    showClearButton = false,
+    showFormatButton = true,
+    linterEnabled = true,
+    schema = [],
+    placeholder = "",
+    additionalActions,
+    minHeight = undefined,
+  } = {
+    ...defaultProps,
+    ...opts,
+  };
+
+  // Create extensions - memoize to avoid recreating on every render
+  const extensions = useMemo(() => {
+    const exts = getEditorSetup();
+
+    // Add SQL language support with StandardSQL dialect
+    // This provides syntax highlighting
+    exts.push(
+      sql({
+        dialect: StandardSQL,
+        upperCaseKeywords: true,
+      })
+    );
+
+    // Add custom TSQL completion
+    if (schema && schema.length > 0) {
+      exts.push(
+        autocompletion({
+          override: [createTSQLCompletion(schema)],
+          activateOnTyping: true,
+          maxRenderedOptions: 50,
+        })
+      );
+
+      // Trigger autocomplete when ' is typed in value context
+      // CodeMirror's activateOnTyping only triggers on alphanumeric characters,
+      // so we manually trigger for quotes after comparison operators
+      exts.push(
+        EditorView.domEventHandlers({
+          keyup: (event, view) => {
+            // Trigger on quote key (both ' and shift+' on some keyboards)
+            if (event.key === "'" || event.key === '"' || event.code === "Quote") {
+              setTimeout(() => {
+                startCompletion(view);
+              }, 50);
+            }
+            return false;
+          },
+        })
+      );
+    }
+
+    // Add TSQL linter
+    if (linterEnabled) {
+      exts.push(lintGutter());
+      exts.push(
+        linter(createTSQLLinter({ schema }), {
+          delay: 300, // Debounce linting for better performance
+        })
+      );
+    }
+
+    // Add keyboard shortcut for toggling comments
+    exts.push(
+      keymap.of([
+        { key: "Cmd-/", run: toggleLineComment },
+        { key: "Ctrl-/", run: toggleLineComment },
+      ])
+    );
+
+    return exts;
+  }, [schema, linterEnabled]);
+
+  const editor = useRef<HTMLDivElement>(null);
+
+  const settings: Omit<UseCodeMirror, "onBlur"> = {
+    ...opts,
+    container: editor.current,
+    extensions,
+    editable: !readOnly,
+    contentEditable: !readOnly,
+    value: defaultValue,
+    autoFocus,
+    theme: darkTheme(),
+    indentWithTab: false,
+    basicSetup,
+    onChange,
+    onUpdate,
+    placeholder,
+  };
+
+  const { setContainer, view } = useCodeMirror(settings);
+  const [copied, setCopied] = useState(false);
+
+  useEffect(() => {
+    if (editor.current) {
+      setContainer(editor.current);
+    }
+  }, [setContainer]);
+
+  // Update editor when defaultValue changes
+  useEffect(() => {
+    if (view !== undefined) {
+      if (view.state.doc.toString() === defaultValue) return;
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: defaultValue },
+      });
+    }
+  }, [defaultValue, view]);
+
+  const clear = () => {
+    if (view === undefined) return;
+    view.dispatch({
+      changes: { from: 0, to: view.state.doc.length, insert: undefined },
+    });
+    onChange?.("");
+  };
+
+  const copy = useCallback(() => {
+    if (view === undefined) return;
+    navigator.clipboard.writeText(view.state.doc.toString());
+    setCopied(true);
+    setTimeout(() => {
+      setCopied(false);
+    }, 1500);
+  }, [view]);
+
+  const format = useCallback(() => {
+    if (view === undefined) return;
+    const currentContent = view.state.doc.toString();
+    if (!currentContent.trim()) return;
+
+    try {
+      const formatted = autoFormatSQL(currentContent);
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: formatted },
+      });
+      onChange?.(formatted);
+    } catch {
+      // If formatting fails (e.g., invalid SQL), silently ignore
+    }
+  }, [view, onChange]);
+
+  const showButtons = showClearButton || showCopyButton || showFormatButton || additionalActions;
+
+  return (
+    <div
+      className={cn("relative flex h-full flex-col", opts.className)}
+      style={minHeight ? { minHeight } : undefined}
+    >
+      <div
+        className={cn(
+          "min-h-0 flex-1 overflow-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        )}
+        ref={editor}
+        onClick={() => {
+          view?.focus();
+        }}
+        onBlur={() => {
+          if (!onBlur) return;
+          if (!view) return;
+          onBlur(view.state.doc.toString());
+        }}
+      />
+      {showButtons && (
+        <div className="absolute right-0 top-0 z-10 flex items-center justify-end bg-charcoal-900/80 p-1.5">
+          {additionalActions && additionalActions}
+          {showFormatButton && (
+            <Button
+              type="button"
+              variant="minimal/small"
+              className="flex-none"
+              onClick={(event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                format();
+              }}
+              shortcut={{ key: "f", modifiers: ["shift", "alt"], enabledOnInputElements: true }}
+            >
+              Format
+            </Button>
+          )}
+          {showClearButton && (
+            <Button
+              type="button"
+              variant="minimal/small"
+              TrailingIcon={TrashIcon}
+              onClick={(event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                clear();
+              }}
+            >
+              Clear
+            </Button>
+          )}
+          {showCopyButton && (
+            <Button
+              type="button"
+              variant="minimal/small"
+              TrailingIcon={copied ? CheckIcon : ClipboardIcon}
+              trailingIconClassName={
+                copied ? "text-green-500 group-hover:text-green-500" : undefined
+              }
+              onClick={(event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                copy();
+              }}
+            >
+              Copy
+            </Button>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+// SQL keywords that legitimately appear before parentheses with a space
+const SQL_KEYWORDS_BEFORE_PAREN = new Set([
+  "IN",
+  "NOT",
+  "EXISTS",
+  "OVER",
+  "USING",
+  "VALUES",
+  "BETWEEN",
+  "LIKE",
+  "AND",
+  "OR",
+  "ON",
+  "SET",
+  "INTO",
+  "TABLE",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "AS",
+  "FROM",
+  "WHERE",
+  "HAVING",
+  "JOIN",
+  "SELECT",
+]);
+
+export function autoFormatSQL(sql: string) {
+  let formatted = formatSQL(sql, {
+    language: "sql",
+    keywordCase: "upper",
+    indentStyle: "standard",
+    linesBetweenQueries: 2,
+  });
+
+  // sql-formatter adds a space before ( for unknown/custom functions (e.g. timeBucket ())
+  // Remove that space for anything that isn't a SQL keyword
+  formatted = formatted.replace(/(\b\w+)\s+\(/g, (match, name) => {
+    if (SQL_KEYWORDS_BEFORE_PAREN.has(name.toUpperCase())) {
+      return match;
+    }
+    return `${name}(`;
+  });
+
+  return formatted;
+}
diff --git a/apps/webapp/app/components/code/TSQLResultsTable.tsx b/apps/webapp/app/components/code/TSQLResultsTable.tsx
new file mode 100644
index 00000000000..73ca07180bf
--- /dev/null
+++ b/apps/webapp/app/components/code/TSQLResultsTable.tsx
@@ -0,0 +1,1298 @@
+import { ChevronDownIcon, ChevronUpDownIcon, ChevronUpIcon } from "@heroicons/react/20/solid";
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+import { IconFilter2, IconFilter2X, IconTable } from "@tabler/icons-react";
+import { rankItem } from "@tanstack/match-sorter-utils";
+import {
+  flexRender,
+  getCoreRowModel,
+  getFilteredRowModel,
+  getSortedRowModel,
+  useReactTable,
+  type CellContext,
+  type Column,
+  type ColumnDef,
+  type ColumnFiltersState,
+  type ColumnResizeMode,
+  type FilterFn,
+  type SortDirection,
+  type SortingState,
+} from "@tanstack/react-table";
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { formatDurationMilliseconds, MachinePresetName } from "@trigger.dev/core/v3";
+import { AlertCircle, ClipboardCheckIcon, ClipboardIcon } from "lucide-react";
+import { forwardRef, memo, useEffect, useMemo, useRef, useState } from "react";
+import { EnvironmentLabel, EnvironmentSlug } from "~/components/environments/EnvironmentLabel";
+import { MachineLabelCombo } from "~/components/MachineLabelCombo";
+import { DateTimeAccurate } from "~/components/primitives/DateTime";
+import {
+  descriptionForTaskRunStatus,
+  isRunFriendlyStatus,
+  isTaskRunStatus,
+  runStatusFromFriendlyTitle,
+  TaskRunStatusCombo,
+} from "~/components/runs/v3/TaskRunStatus";
+import { useCopy } from "~/hooks/useCopy";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { cn } from "~/utils/cn";
+import { formatBytes, formatDecimalBytes, formatQuantity } from "~/utils/columnFormat";
+import { formatCurrencyAccurate, formatNumber } from "~/utils/numberFormatter";
+import { v3ProjectPath, v3RunPathFromFriendlyId } from "~/utils/pathBuilder";
+import { ChartBlankState } from "../primitives/charts/ChartBlankState";
+import { Paragraph } from "../primitives/Paragraph";
+
+import { TextLink } from "../primitives/TextLink";
+import { InfoIconTooltip, SimpleTooltip } from "../primitives/Tooltip";
+import { QueueName } from "../runs/v3/QueueName";
+
+const MAX_STRING_DISPLAY_LENGTH = 64;
+const ROW_HEIGHT = 33; // Estimated row height in pixels
+
+// Column width calculation constants
+const MIN_COLUMN_WIDTH = 60;
+const MAX_COLUMN_WIDTH = 400;
+const CHAR_WIDTH_PX = 7.5; // Approximate width of a monospace character at text-xs (12px)
+const CELL_PADDING_PX = 40; // px-2 (8px) on each side + buffer for copy button
+const HEADER_ICONS_WIDTH_PX = 80; // Sort icon (16px) + filter icon (12px) + info icon (16px) + gaps (12px) + header padding (24px)
+const SAMPLE_SIZE = 100; // Number of rows to sample for width calculation
+
+// Type for row data
+type RowData = Record<string, unknown>;
+
+/**
+ * Get the formatted display string for a value based on its column type
+ * This mirrors the formatting logic in CellValue component
+ */
+function getFormattedValue(value: unknown, column: OutputColumnMetadata): string {
+  if (value === null) return "NULL";
+  if (value === undefined) return "";
+
+  // Handle format hints (from prettyFormat() or auto-populated from customRenderType)
+  const formatType = column.format ?? column.customRenderType;
+  if (formatType) {
+    switch (formatType) {
+      case "duration":
+        if (typeof value === "number") {
+          return formatDurationMilliseconds(value, { style: "short" });
+        }
+        break;
+      case "durationSeconds":
+        if (typeof value === "number") {
+          return formatDurationMilliseconds(value * 1000, { style: "short" });
+        }
+        break;
+      case "durationNs":
+        if (typeof value === "number") {
+          return formatDurationMilliseconds(value / 1_000_000, { style: "short" });
+        }
+        break;
+      case "cost":
+        if (typeof value === "number") {
+          return formatCurrencyAccurate(value / 100);
+        }
+        break;
+      case "costInDollars":
+        if (typeof value === "number") {
+          return formatCurrencyAccurate(value);
+        }
+        break;
+      case "runStatus":
+        // Include friendly status names for searching
+        if (typeof value === "string") {
+          return value;
+        }
+        break;
+      case "bytes":
+        if (typeof value === "number") {
+          return formatBytes(value);
+        }
+        break;
+      case "decimalBytes":
+        if (typeof value === "number") {
+          return formatDecimalBytes(value);
+        }
+        break;
+      case "percent":
+        if (typeof value === "number") {
+          return `${value.toFixed(2)}%`;
+        }
+        break;
+      case "quantity":
+        if (typeof value === "number") {
+          return formatQuantity(value);
+        }
+        break;
+    }
+  }
+
+  // Handle DateTime types - format for display
+  if (isDateTimeType(column.type)) {
+    if (typeof value === "string") {
+      try {
+        const date = new Date(value);
+        // Format as a searchable string: "15 Jan 2026 12:34:56"
+        return date.toLocaleString("en-GB", {
+          day: "numeric",
+          month: "short",
+          year: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          timeZone: "UTC",
+        });
+      } catch {
+        return String(value);
+      }
+    }
+  }
+
+  // Handle numeric types - format with separators
+  if (isNumericType(column.type) && typeof value === "number") {
+    return formatNumber(value);
+  }
+
+  // Handle booleans
+  if (isBooleanType(column.type)) {
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+      return value === 1 ? "true" : "false";
+    }
+  }
+
+  // Handle objects/arrays
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+
+const fuzzyFilter: FilterFn<RowData> = (row, columnId, value, addMeta) => {
+  // Get the cell value
+  const cellValue = row.getValue(columnId);
+  const searchValue = String(value).toLowerCase();
+
+  // Handle empty search
+  if (!searchValue) return true;
+
+  // Get the column metadata from the cell
+  const cell = row.getAllCells().find((c) => c.column.id === columnId);
+  const meta = cell?.column.columnDef.meta as ColumnMeta | undefined;
+
+  // Build searchable strings - raw value
+  const rawValue =
+    cellValue === null
+      ? "NULL"
+      : cellValue === undefined
+      ? ""
+      : typeof cellValue === "object"
+      ? JSON.stringify(cellValue)
+      : String(cellValue);
+
+  // Build searchable strings - formatted value (if we have column metadata)
+  const formattedValue = meta?.outputColumn
+    ? getFormattedValue(cellValue, meta.outputColumn)
+    : rawValue;
+
+  // Combine both values for searching (separated by space to allow matching either)
+  const combinedSearchText = `${rawValue} ${formattedValue}`.toLowerCase();
+
+  // Rank against the combined text
+  const itemRank = rankItem(combinedSearchText, searchValue);
+
+  // Store the ranking info
+  addMeta({ itemRank });
+
+  // Return if the item should be filtered in/out
+  return itemRank.passed;
+};
+
+/**
+ * Debounced input component for filter inputs
+ */
+const DebouncedInput = forwardRef<
+  HTMLInputElement,
+  {
+    value: string;
+    onChange: (value: string) => void;
+    debounce?: number;
+  } & Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange">
+>(function DebouncedInput({ value: initialValue, onChange, debounce = 300, ...props }, ref) {
+  const [value, setValue] = useState(initialValue);
+
+  useEffect(() => {
+    setValue(initialValue);
+  }, [initialValue]);
+
+  useEffect(() => {
+    const timeout = setTimeout(() => {
+      onChange(value);
+    }, debounce);
+
+    return () => clearTimeout(timeout);
+  }, [value, debounce, onChange]);
+
+  return <input ref={ref} {...props} value={value} onChange={(e) => setValue(e.target.value)} />;
+});
+
+// Extended column meta to store OutputColumnMetadata
+interface ColumnMeta {
+  outputColumn: OutputColumnMetadata;
+  alignment: "left" | "right";
+}
+
+/**
+ * Get the approximate display length (in characters) of a value based on its type and formatting
+ */
+function getDisplayLength(value: unknown, column: OutputColumnMetadata): number {
+  if (value === null) return 4; // "NULL"
+  if (value === undefined) return 9; // "UNDEFINED"
+
+  // Handle format hint types - estimate their rendered width
+  const fmt = column.format;
+  if (fmt === "bytes" || fmt === "decimalBytes") {
+    // e.g., "1.50 GiB" or "256.00 MB"
+    return 12;
+  }
+  if (fmt === "percent") {
+    // e.g., "45.23%"
+    return 8;
+  }
+  if (fmt === "quantity") {
+    // e.g., "1.50M"
+    return 8;
+  }
+
+  // Handle custom render types - estimate their rendered width
+  if (column.customRenderType) {
+    switch (column.customRenderType) {
+      case "runId":
+        // Run IDs are typically like "run_abc123xyz"
+        return typeof value === "string" ? Math.min(value.length, MAX_STRING_DISPLAY_LENGTH) : 15;
+      case "runStatus":
+        // Status badges have icon + text, approximate width
+        return 12;
+      case "duration":
+        if (typeof value === "number") {
+          // Format and measure: "1h 23m 45s" style
+          const formatted = formatDurationMilliseconds(value, { style: "short" });
+          return formatted.length;
+        }
+        return 10;
+      case "durationSeconds":
+        if (typeof value === "number") {
+          const formatted = formatDurationMilliseconds(value * 1000, { style: "short" });
+          return formatted.length;
+        }
+        return 10;
+      case "durationNs":
+        if (typeof value === "number") {
+          const formatted = formatDurationMilliseconds(value / 1_000_000, { style: "short" });
+          return formatted.length;
+        }
+        return 10;
+      case "cost":
+      case "costInDollars":
+        // Currency format: "$1,234.56"
+        if (typeof value === "number") {
+          const amount = column.customRenderType === "cost" ? value / 100 : value;
+          return formatCurrencyAccurate(amount).length;
+        }
+        return 12;
+      case "machine":
+        // Machine preset names like "small-1x"
+        return typeof value === "string" ? value.length : 10;
+      case "environmentType":
+        // Environment labels: "PRODUCTION", "STAGING", etc.
+        return 12;
+      case "project":
+      case "environment":
+        return typeof value === "string" ? Math.min(value.length, 20) : 12;
+      case "queue":
+        return typeof value === "string" ? Math.min(value.length, 25) : 15;
+      case "deploymentId":
+        return typeof value === "string" ? Math.min(value.length, 25) : 20;
+    }
+  }
+
+  // Handle by ClickHouse type
+  if (isDateTimeType(column.type)) {
+    // DateTime format: "Jan 15, 2026, 12:34:56 PM"
+    return 24;
+  }
+
+  if (column.type === "JSON" || column.type.startsWith("Array")) {
+    if (typeof value === "object") {
+      const jsonStr = JSON.stringify(value);
+      return Math.min(jsonStr.length, MAX_STRING_DISPLAY_LENGTH);
+    }
+  }
+
+  if (isBooleanType(column.type)) {
+    return 5; // "true" or "false"
+  }
+
+  if (isNumericType(column.type)) {
+    if (typeof value === "number") {
+      return formatNumber(value).length;
+    }
+  }
+
+  // Default: string length capped at max display length
+  const strValue = String(value);
+  return Math.min(strValue.length, MAX_STRING_DISPLAY_LENGTH);
+}
+
+/**
+ * Calculate the optimal width for a column based on its content
+ */
+function calculateColumnWidth(
+  columnName: string,
+  rows: RowData[],
+  column: OutputColumnMetadata
+): number {
+  // Calculate minimum width needed for the header (text + icons)
+  const headerWidth = Math.ceil(columnName.length * CHAR_WIDTH_PX + HEADER_ICONS_WIDTH_PX);
+
+  // Sample rows to find max content length
+  let maxContentLength = 0;
+  const sampleRows = rows.slice(0, SAMPLE_SIZE);
+  for (const row of sampleRows) {
+    const value = row[columnName];
+    const displayLength = getDisplayLength(value, column);
+    if (displayLength > maxContentLength) {
+      maxContentLength = displayLength;
+    }
+  }
+
+  // Calculate pixel width for content: characters * char width + padding
+  const contentWidth = Math.ceil(maxContentLength * CHAR_WIDTH_PX + CELL_PADDING_PX);
+
+  // Use the larger of header width or content width
+  const calculatedWidth = Math.max(headerWidth, contentWidth);
+
+  // Apply min/max bounds
+  return Math.min(MAX_COLUMN_WIDTH, Math.max(MIN_COLUMN_WIDTH, calculatedWidth));
+}
+
+/**
+ * Truncate a string for display, adding ellipsis if it exceeds max length
+ */
+function truncateString(value: string, maxLength: number = MAX_STRING_DISPLAY_LENGTH): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return value.slice(0, maxLength) + "…";
+}
+
+/**
+ * Convert any value to a string suitable for copying
+ * Objects and arrays are JSON stringified, primitives use String()
+ */
+function valueToString(value: unknown): string {
+  if (value === null) return "NULL";
+  if (value === undefined) return "UNDEFINED";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+/**
+ * Check if a ClickHouse type is a DateTime type
+ */
+function isDateTimeType(type: string): boolean {
+  return (
+    type === "DateTime" ||
+    type === "DateTime64" ||
+    type === "Date" ||
+    type === "Date32" ||
+    type.startsWith("Nullable(DateTime") ||
+    type.startsWith("Nullable(Date")
+  );
+}
+
+/**
+ * Check if a ClickHouse type is a numeric type
+ */
+function isNumericType(type: string): boolean {
+  return (
+    type.startsWith("Int") ||
+    type.startsWith("UInt") ||
+    type.startsWith("Float") ||
+    type.startsWith("Nullable(Int") ||
+    type.startsWith("Nullable(UInt") ||
+    type.startsWith("Nullable(Float")
+  );
+}
+
+/**
+ * Check if a ClickHouse type is a boolean type
+ */
+function isBooleanType(type: string): boolean {
+  return type === "Bool" || type === "Nullable(Bool)";
+}
+
+/**
+ * Check if a column should be right-aligned (numeric columns, duration, cost)
+ */
+function isRightAlignedColumn(column: OutputColumnMetadata): boolean {
+  if (
+    column.customRenderType === "duration" ||
+    column.customRenderType === "durationSeconds" ||
+    column.customRenderType === "cost" ||
+    column.customRenderType === "costInDollars"
+  ) {
+    return true;
+  }
+  const fmt = column.format;
+  if (fmt === "bytes" || fmt === "decimalBytes" || fmt === "percent" || fmt === "quantity") {
+    return true;
+  }
+  return isNumericType(column.type);
+}
+
+/**
+ * Wrapper component that tracks hover state and passes it to CellValue
+ * This optimizes rendering by only enabling tooltips when the cell is hovered
+ */
+function CellValueWrapper({
+  value,
+  column,
+  prettyFormatting,
+  row,
+}: {
+  value: unknown;
+  column: OutputColumnMetadata;
+  prettyFormatting: boolean;
+  row?: Record<string, unknown>;
+}) {
+  const [hovered, setHovered] = useState(false);
+
+  return (
+    <span
+      className="flex flex-1 items-center"
+      onMouseEnter={() => setHovered(true)}
+      onMouseLeave={() => setHovered(false)}
+    >
+      <CellValue
+        value={value}
+        column={column}
+        prettyFormatting={prettyFormatting}
+        hovered={hovered}
+        row={row}
+      />
+    </span>
+  );
+}
+
+/**
+ * Render a cell value based on its type and optional customRenderType
+ */
+function CellValue({
+  value,
+  column,
+  prettyFormatting = true,
+  hovered = false,
+  row,
+}: {
+  value: unknown;
+  column: OutputColumnMetadata;
+  prettyFormatting?: boolean;
+  hovered?: boolean;
+  row?: Record<string, unknown>;
+}) {
+  // Plain text mode - render everything as monospace text with truncation
+  if (!prettyFormatting) {
+    if (column.type === "JSON") {
+      return <JSONCellValue value={value} />;
+    }
+
+    const plainValue = value === null ? "NULL" : String(value);
+    const isTruncated = plainValue.length > MAX_STRING_DISPLAY_LENGTH;
+
+    if (isTruncated) {
+      return (
+        <SimpleTooltip
+          content={
+            <pre className="max-w-sm whitespace-pre-wrap break-all font-mono text-xs">
+              {plainValue}
+            </pre>
+          }
+          button={<pre className="font-mono text-xs">{truncateString(plainValue)}</pre>}
+          disableHoverableContent
+        />
+      );
+    }
+
+    return <pre className="font-mono text-xs">{plainValue}</pre>;
+  }
+
+  if (value === null) {
+    return <pre className="text-text-dimmed">NULL</pre>;
+  }
+
+  if (value === undefined) {
+    return <pre className="text-text-dimmed">UNDEFINED</pre>;
+  }
+
+  // Check format hint for new format types (from prettyFormat())
+  if (column.format && !column.customRenderType) {
+    switch (column.format) {
+      case "bytes":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{formatBytes(value)}</span>;
+        }
+        break;
+      case "decimalBytes":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{formatDecimalBytes(value)}</span>;
+        }
+        break;
+      case "percent":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{value.toFixed(2)}%</span>;
+        }
+        break;
+      case "quantity":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{formatQuantity(value)}</span>;
+        }
+        break;
+    }
+  }
+
+  // First check customRenderType for special rendering
+  if (column.customRenderType) {
+    switch (column.customRenderType) {
+      case "runId": {
+        if (typeof value === "string") {
+          const spanId = row?.["span_id"];
+          const runPath = v3RunPathFromFriendlyId(value);
+          const href = typeof spanId === "string" && spanId
+            ? `${runPath}?span=${spanId}`
+            : runPath;
+          const tooltip = typeof spanId === "string" && spanId
+            ? "Jump to span"
+            : "Jump to run";
+          return (
+            <SimpleTooltip
+              content={tooltip}
+              disableHoverableContent
+              hidden={!hovered}
+              button={<TextLink to={href}>{value}</TextLink>}
+            />
+          );
+        }
+        break;
+      }
+      case "runStatus": {
+        const status = isTaskRunStatus(value)
+          ? value
+          : isRunFriendlyStatus(value)
+          ? runStatusFromFriendlyTitle(value)
+          : undefined;
+        if (status) {
+          return (
+            <SimpleTooltip
+              content={descriptionForTaskRunStatus(status)}
+              disableHoverableContent
+              hidden={!hovered}
+              button={<TaskRunStatusCombo status={status} />}
+            />
+          );
+        }
+        break;
+      }
+      case "duration":
+        if (typeof value === "number") {
+          return (
+            <span className="tabular-nums">
+              {formatDurationMilliseconds(value, { style: "short" })}
+            </span>
+          );
+        }
+        return <span>{String(value)}</span>;
+      case "durationSeconds":
+        if (typeof value === "number") {
+          return (
+            <span className="tabular-nums">
+              {formatDurationMilliseconds(value * 1000, { style: "short" })}
+            </span>
+          );
+        }
+        return <span>{String(value)}</span>;
+      case "durationNs":
+        if (typeof value === "number") {
+          return (
+            <span className="tabular-nums">
+              {formatDurationMilliseconds(value / 1_000_000, { style: "short" })}
+            </span>
+          );
+        }
+        return <span>{String(value)}</span>;
+      case "cost":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{formatCurrencyAccurate(value / 100)}</span>;
+        }
+        return <span>{String(value)}</span>;
+      case "costInDollars":
+        if (typeof value === "number") {
+          return <span className="tabular-nums">{formatCurrencyAccurate(value)}</span>;
+        }
+        return <span>{String(value)}</span>;
+      case "machine": {
+        const preset = MachinePresetName.safeParse(value);
+        if (preset.success) {
+          return <MachineLabelCombo preset={preset.data} />;
+        }
+        return <span>{String(value)}</span>;
+      }
+      case "environmentType": {
+        if (
+          typeof value === "string" &&
+          ["PRODUCTION", "STAGING", "DEVELOPMENT", "PREVIEW"].includes(value)
+        ) {
+          return (
+            <EnvironmentLabel
+              environment={{ type: value as "PRODUCTION" | "STAGING" | "DEVELOPMENT" | "PREVIEW" }}
+            />
+          );
+        }
+        return <span>{String(value)}</span>;
+      }
+      case "project": {
+        if (typeof value === "string") {
+          return <ProjectCellValue value={value} />;
+        }
+        return <span>{String(value)}</span>;
+      }
+      case "environment": {
+        if (typeof value === "string") {
+          return <EnvironmentCellValue value={value} />;
+        }
+        return <span>{String(value)}</span>;
+      }
+      case "queue": {
+        if (typeof value === "string") {
+          const type = value.startsWith("task/") ? "task" : "custom";
+          return <QueueName type={type} name={value.replace("task/", "")} />;
+        }
+        return <span>{String(value)}</span>;
+      }
+      case "deploymentId": {
+        if (typeof value === "string" && value.startsWith("deployment_")) {
+          return (
+            <SimpleTooltip
+              content="Jump to deployment"
+              disableHoverableContent
+              hidden={!hovered}
+              button={<TextLink to={`/deployments/${value}`}>{value}</TextLink>}
+            />
+          );
+        }
+        return <span>{String(value)}</span>;
+      }
+    }
+  }
+
+  // Fall back to rendering based on ClickHouse type
+  const { type } = column;
+
+  if (isDateTimeType(type)) {
+    if (typeof value === "string") {
+      return <DateTimeAccurate date={value} showTooltip={hovered} timeZone="UTC" />;
+    }
+    return <span>{String(value)}</span>;
+  }
+
+  if (type === "JSON") {
+    return <JSONCellValue value={value} />;
+  }
+
+  if (type.startsWith("Array")) {
+    const arrayString = JSON.stringify(value);
+    const isTruncated = arrayString.length > MAX_STRING_DISPLAY_LENGTH;
+
+    if (isTruncated) {
+      return (
+        <SimpleTooltip
+          content={
+            <pre className="max-w-sm whitespace-pre-wrap break-all font-mono text-xs">
+              {arrayString}
+            </pre>
+          }
+          button={
+            <span className="font-mono text-xs text-text-dimmed">
+              {truncateString(arrayString)}
+            </span>
+          }
+          disableHoverableContent
+        />
+      );
+    }
+    return <span className="font-mono text-xs text-text-dimmed">{arrayString}</span>;
+  }
+
+  if (isBooleanType(type)) {
+    if (typeof value === "boolean") {
+      return <span className="text-text-dimmed">{value ? "true" : "false"}</span>;
+    }
+    if (typeof value === "number") {
+      return <span className="text-text-dimmed">{value === 1 ? "true" : "false"}</span>;
+    }
+    return <span>{String(value)}</span>;
+  }
+
+  if (isNumericType(type)) {
+    if (typeof value === "number") {
+      return <span className="tabular-nums">{formatNumber(value)}</span>;
+    }
+    return <span>{String(value)}</span>;
+  }
+
+  const stringValue = String(value);
+  const isTruncated = stringValue.length > MAX_STRING_DISPLAY_LENGTH;
+
+  if (isTruncated) {
+    return (
+      <SimpleTooltip
+        content={
+          <pre className="max-w-sm whitespace-pre-wrap break-all font-mono text-xs">
+            {stringValue}
+          </pre>
+        }
+        button={<span>{truncateString(stringValue)}</span>}
+        disableHoverableContent
+      />
+    );
+  }
+
+  return <span>{stringValue}</span>;
+}
+
+function ProjectCellValue({ value }: { value: string }) {
+  const organization = useOrganization();
+  const project = organization.projects.find((p) => p.externalRef === value);
+
+  if (!project) {
+    return <span>{value}</span>;
+  }
+
+  return <TextLink to={v3ProjectPath(organization, project)}>{project.name}</TextLink>;
+}
+
+function EnvironmentCellValue({ value }: { value: string }) {
+  const project = useProject();
+  const environment = project.environments.find((e) => e.slug === value);
+
+  if (!environment) {
+    return <span>{value}</span>;
+  }
+
+  return <EnvironmentSlug environment={environment} />;
+}
+
+function JSONCellValue({ value }: { value: unknown }) {
+  // If the value is already a string (e.g., from a textColumn optimization),
+  // use it directly without double-stringifying
+  const jsonString = typeof value === "string" ? value : JSON.stringify(value);
+  const isTruncated = jsonString.length > MAX_STRING_DISPLAY_LENGTH;
+
+  if (isTruncated) {
+    return (
+      <SimpleTooltip
+        content={
+          <pre className="max-w-sm whitespace-pre-wrap break-all font-mono text-xs">
+            {jsonString}
+          </pre>
+        }
+        button={
+          <span className="font-mono text-xs text-text-dimmed">{truncateString(jsonString)}</span>
+        }
+        disableHoverableContent
+      />
+    );
+  }
+
+  return <span className="font-mono text-xs text-text-dimmed">{jsonString}</span>;
+}
+
+/**
+ * Copyable cell component for virtualized rows
+ */
+function CopyableCell({
+  value,
+  alignment,
+  children,
+}: {
+  value: string;
+  alignment: "left" | "right";
+  children: React.ReactNode;
+}) {
+  const [isHovered, setIsHovered] = useState(false);
+  const { copy, copied } = useCopy(value);
+
+  return (
+    <div
+      className={cn(
+        "relative flex h-full w-full items-center overflow-hidden px-2",
+        "bg-background-bright group-hover/row:bg-charcoal-750",
+        "font-mono text-xs text-text-dimmed group-hover/row:text-text-bright",
+        "[&_a:focus-visible]:underline [&_a:focus-visible]:underline-offset-[3px] [&_a:focus-visible]:outline-none",
+        alignment === "right" && "justify-end"
+      )}
+      onMouseEnter={() => setIsHovered(true)}
+      onMouseLeave={() => setIsHovered(false)}
+    >
+      <span className="flex items-center truncate">{children}</span>
+      {isHovered && (
+        <span
+          onClick={(e) => {
+            e.stopPropagation();
+            e.preventDefault();
+            copy();
+          }}
+          className="absolute right-1 top-1/2 z-10 flex -translate-y-1/2 cursor-pointer"
+        >
+          <SimpleTooltip
+            button={
+              <span
+                className={cn(
+                  "flex size-6 items-center justify-center rounded border border-charcoal-650 bg-charcoal-750",
+                  copied
+                    ? "text-green-500"
+                    : "text-text-dimmed hover:border-charcoal-600 hover:bg-charcoal-700 hover:text-text-bright"
+                )}
+              >
+                {copied ? (
+                  <ClipboardCheckIcon className="size-3.5" />
+                ) : (
+                  <ClipboardIcon className="size-3.5" />
+                )}
+              </span>
+            }
+            content={copied ? "Copied!" : "Copy"}
+            disableHoverableContent
+          />
+        </span>
+      )}
+    </div>
+  );
+}
+
+/**
+ * Header cell component with tooltip support and filter toggle
+ */
+function HeaderCellContent({
+  alignment,
+  tooltip,
+  children,
+  onFilterClick,
+  showFilters,
+  hasActiveFilter,
+  sortDirection,
+  onSortClick,
+  canSort,
+}: {
+  alignment: "left" | "right";
+  tooltip?: React.ReactNode;
+  children: React.ReactNode;
+  onFilterClick?: () => void;
+  showFilters?: boolean;
+  hasActiveFilter?: boolean;
+  sortDirection?: SortDirection | false;
+  onSortClick?: (event: React.MouseEvent) => void;
+  canSort?: boolean;
+}) {
+  const [isCellHovered, setIsCellHovered] = useState(false);
+  const [isFilterHovered, setIsFilterHovered] = useState(false);
+
+  const sortHighlighted = isCellHovered && !isFilterHovered;
+
+  return (
+    <div
+      className={cn(
+        "flex w-full items-center gap-1 overflow-hidden bg-background-bright py-2 pl-2 pr-3",
+        "font-mono text-xs font-medium text-text-bright",
+        alignment === "right" && "justify-end",
+        canSort && "cursor-pointer select-none"
+      )}
+      onMouseEnter={() => setIsCellHovered(true)}
+      onMouseLeave={() => setIsCellHovered(false)}
+      onClick={onSortClick}
+    >
+      {tooltip ? (
+        <div
+          className={cn("flex min-w-0 flex-1 items-center gap-1 truncate", {
+            "justify-end": alignment === "right",
+          })}
+        >
+          <span className="truncate text-left">{children}</span>
+          <span className="flex flex-shrink-0">
+            <InfoIconTooltip
+              content={tooltip}
+              contentClassName="normal-case tracking-normal"
+              enabled={isCellHovered}
+              disableHoverableContent
+            />
+          </span>
+        </div>
+      ) : (
+        <span className="min-w-0 flex-1 truncate text-left">{children}</span>
+      )}
+      {/* Sort indicator */}
+      {canSort && (
+        <span
+          className={cn(
+            "flex-shrink-0 transition-colors",
+            sortHighlighted ? "text-text-bright" : "text-text-dimmed"
+          )}
+        >
+          {sortDirection === "asc" ? (
+            <ChevronUpIcon className="size-4" />
+          ) : sortDirection === "desc" ? (
+            <ChevronDownIcon className="size-4" />
+          ) : (
+            <ChevronUpDownIcon className="size-4" />
+          )}
+        </span>
+      )}
+      {onFilterClick && (
+        <button
+          onClick={(e) => {
+            e.stopPropagation();
+            onFilterClick();
+          }}
+          onMouseEnter={() => setIsFilterHovered(true)}
+          onMouseLeave={() => setIsFilterHovered(false)}
+          className="flex-shrink-0 rounded text-text-dimmed transition-colors focus-custom hover:text-text-bright"
+          title="Toggle column filters"
+        >
+          {showFilters ? <IconFilter2X className="size-4" /> : <IconFilter2 className="size-4" />}
+        </button>
+      )}
+    </div>
+  );
+}
+
+/**
+ * Filter input cell for the filter row
+ */
+function FilterCell({
+  column,
+  width,
+  shouldFocus,
+  onFocused,
+}: {
+  column: Column<RowData, unknown>;
+  width: number;
+  shouldFocus?: boolean;
+  onFocused?: () => void;
+}) {
+  const columnFilterValue = column.getFilterValue() as string;
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    if (shouldFocus && inputRef.current) {
+      inputRef.current.focus();
+      onFocused?.();
+    }
+  }, [shouldFocus, onFocused]);
+
+  return (
+    <div className="flex items-center bg-background-bright px-1.5 pb-2" style={{ width }}>
+      <DebouncedInput
+        ref={inputRef}
+        value={columnFilterValue ?? ""}
+        onChange={(value) => column.setFilterValue(value)}
+        placeholder="Filter..."
+        className={cn(
+          "w-full rounded border border-charcoal-700 bg-charcoal-800 px-2 py-1",
+          "text-xs text-text-bright placeholder:text-text-dimmed",
+          "focus:border-indigo-500/50 focus:outline-none focus:ring-1 focus:ring-indigo-500/50"
+        )}
+      />
+    </div>
+  );
+}
+
+export const TSQLResultsTable = memo(function TSQLResultsTable({
+  rows,
+  columns,
+  prettyFormatting = true,
+  sorting: defaultSorting = [],
+  showHeaderOnEmpty = false,
+  hiddenColumns,
+}: {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+  prettyFormatting?: boolean;
+  sorting?: SortingState;
+  /** When true, show column headers + "No results" on empty data. When false, show a blank state icon. */
+  showHeaderOnEmpty?: boolean;
+  /** Column names to hide from display but keep in row data (useful for linking) */
+  hiddenColumns?: string[];
+}) {
+  const tableContainerRef = useRef<HTMLDivElement>(null);
+
+  // State for column filters and filter row visibility
+  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
+  const [showFilters, setShowFilters] = useState(false);
+  // Track which column's filter should be focused
+  const [focusFilterColumn, setFocusFilterColumn] = useState<string | null>(null);
+  // State for column sorting
+  const [sorting, setSorting] = useState<SortingState>(defaultSorting);
+
+  // Create TanStack Table column definitions from OutputColumnMetadata
+  // Calculate column widths based on content
+  const visibleColumns = useMemo(
+    () => hiddenColumns?.length ? columns.filter((col) => !hiddenColumns.includes(col.name)) : columns,
+    [columns, hiddenColumns]
+  );
+  const columnDefs = useMemo<ColumnDef<RowData, unknown>[]>(
+    () =>
+      visibleColumns.map((col) => ({
+        id: col.name,
+        accessorKey: col.name,
+        header: () => col.name,
+        cell: (info: CellContext<RowData, unknown>) => (
+          <CellValueWrapper
+            value={info.getValue()}
+            column={col}
+            prettyFormatting={prettyFormatting}
+            row={info.row.original}
+          />
+        ),
+        meta: {
+          outputColumn: col,
+          alignment: isRightAlignedColumn(col) ? "right" : "left",
+        } as ColumnMeta,
+        size: calculateColumnWidth(col.name, rows, col),
+        filterFn: fuzzyFilter,
+      })),
+    [visibleColumns, rows, prettyFormatting]
+  );
+
+  // Initialize TanStack Table
+  // Column resize mode: 'onChange' for real-time feedback, 'onEnd' for performance
+  const columnResizeMode: ColumnResizeMode = "onChange";
+
+  const table = useReactTable({
+    data: rows,
+    columns: columnDefs,
+    columnResizeMode,
+    state: {
+      columnFilters,
+      sorting,
+    },
+    onColumnFiltersChange: setColumnFilters,
+    onSortingChange: setSorting,
+    getCoreRowModel: getCoreRowModel(),
+    getFilteredRowModel: getFilteredRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+  });
+
+  const { rows: tableRows } = table.getRowModel();
+
+  // Set up the virtualizer
+  const rowVirtualizer = useVirtualizer({
+    count: tableRows.length,
+    estimateSize: () => ROW_HEIGHT,
+    getScrollElement: () => tableContainerRef.current,
+    overscan: 20,
+  });
+
+  if (!columns.length) return null;
+
+  // Empty state
+  if (rows.length === 0) {
+    if (!showHeaderOnEmpty) {
+      return <ChartBlankState icon={IconTable} message="No data to display" />;
+    }
+
+    return (
+      <div
+        className="h-full min-h-0 w-full overflow-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        style={{ position: "relative" }}
+      >
+        <table style={{ display: "grid" }}>
+          <thead
+            className="border-t border-grid-bright bg-background-bright after:absolute after:bottom-0 after:left-0 after:right-0 after:h-px after:bg-grid-bright"
+            style={{
+              display: "grid",
+              position: "sticky",
+              top: 0,
+              zIndex: 1,
+            }}
+          >
+            {table.getHeaderGroups().map((headerGroup) => (
+              <tr key={headerGroup.id} style={{ display: "flex", width: "100%" }}>
+                {headerGroup.headers.map((header) => {
+                  const meta = header.column.columnDef.meta as ColumnMeta | undefined;
+                  return (
+                    <th
+                      key={header.id}
+                      className="group/header relative"
+                      style={{
+                        display: "flex",
+                        width: header.getSize(),
+                      }}
+                    >
+                      <HeaderCellContent alignment={meta?.alignment ?? "left"}>
+                        {flexRender(header.column.columnDef.header, header.getContext())}
+                      </HeaderCellContent>
+                    </th>
+                  );
+                })}
+              </tr>
+            ))}
+          </thead>
+          <tbody style={{ display: "grid" }}>
+            <tr style={{ display: "flex", width: "100%" }}>
+              <td className="w-full px-3 py-6" colSpan={columns.length}>
+                <div className="flex items-center justify-center gap-1.5">
+                  <AlertCircle className="size-5 text-text-dimmed/50" />
+                  <Paragraph variant="small" className="text-text-dimmed">
+                    This query returned no results
+                  </Paragraph>
+                </div>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      ref={tableContainerRef}
+      className="h-full min-h-0 w-full overflow-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+      style={{ position: "relative" }}
+    >
+      <table style={{ display: "grid" }}>
+        <thead
+          className="border-t border-grid-bright bg-background-bright after:absolute after:bottom-0 after:left-0 after:right-0 after:h-px after:bg-grid-bright"
+          style={{
+            display: "grid",
+            position: "sticky",
+            top: 0,
+            zIndex: 1,
+          }}
+        >
+          {/* Main header row */}
+          {table.getHeaderGroups().map((headerGroup) => (
+            <tr key={headerGroup.id} style={{ display: "flex", width: "100%" }}>
+              {headerGroup.headers.map((header) => {
+                const meta = header.column.columnDef.meta as ColumnMeta | undefined;
+                return (
+                  <th
+                    key={header.id}
+                    className="group/header relative"
+                    style={{
+                      display: "flex",
+                      width: header.getSize(),
+                    }}
+                  >
+                    <HeaderCellContent
+                      alignment={meta?.alignment ?? "left"}
+                      tooltip={meta?.outputColumn.description}
+                      onFilterClick={() => {
+                        if (!showFilters) {
+                          setFocusFilterColumn(header.id);
+                        } else {
+                          setColumnFilters([]);
+                        }
+                        setShowFilters(!showFilters);
+                      }}
+                      showFilters={showFilters}
+                      hasActiveFilter={!!header.column.getFilterValue()}
+                      sortDirection={header.column.getIsSorted()}
+                      onSortClick={header.column.getToggleSortingHandler()}
+                      canSort={header.column.getCanSort()}
+                    >
+                      {flexRender(header.column.columnDef.header, header.getContext())}
+                    </HeaderCellContent>
+                    {/* Column resizer */}
+                    <div
+                      onDoubleClick={() => header.column.resetSize()}
+                      onMouseDown={header.getResizeHandler()}
+                      onTouchStart={header.getResizeHandler()}
+                      className={cn(
+                        "absolute right-0 top-0 h-full w-0.5 cursor-col-resize touch-none select-none",
+                        "opacity-0 group-hover/header:opacity-100",
+                        "bg-charcoal-600 hover:bg-indigo-500",
+                        header.column.getIsResizing() && "bg-indigo-500 opacity-100"
+                      )}
+                    />
+                  </th>
+                );
+              })}
+            </tr>
+          ))}
+          {/* Filter row - shown when filters are toggled */}
+          {showFilters && (
+            <tr style={{ display: "flex", width: "100%" }}>
+              {table.getHeaderGroups()[0]?.headers.map((header) => (
+                <FilterCell
+                  key={`filter-${header.id}`}
+                  column={header.column}
+                  width={header.getSize()}
+                  shouldFocus={focusFilterColumn === header.id}
+                  onFocused={() => setFocusFilterColumn(null)}
+                />
+              ))}
+            </tr>
+          )}
+        </thead>
+        <tbody
+          style={{
+            display: "grid",
+            height: `${rowVirtualizer.getTotalSize()}px`,
+            position: "relative",
+          }}
+          className="divide-y divide-charcoal-700 bg-background-bright after:absolute after:bottom-0 after:left-0 after:right-0 after:z-[1] after:h-px after:bg-grid-bright"
+        >
+          {rowVirtualizer.getVirtualItems().map((virtualRow) => {
+            const row = tableRows[virtualRow.index];
+            return (
+              <tr
+                key={row.id}
+                data-index={virtualRow.index}
+                className="group/row hover:bg-charcoal-750"
+                style={{
+                  display: "flex",
+                  position: "absolute",
+                  transform: `translateY(${virtualRow.start}px)`,
+                  width: "100%",
+                  height: `${virtualRow.size}px`,
+                }}
+              >
+                {row.getVisibleCells().map((cell) => {
+                  const meta = cell.column.columnDef.meta as ColumnMeta | undefined;
+                  return (
+                    <td
+                      key={cell.id}
+                      style={{
+                        display: "flex",
+                        width: cell.column.getSize(),
+                      }}
+                    >
+                      <CopyableCell
+                        alignment={meta?.alignment ?? "left"}
+                        value={valueToString(cell.getValue())}
+                      >
+                        {flexRender(cell.column.columnDef.cell, cell.getContext())}
+                      </CopyableCell>
+                    </td>
+                  );
+                })}
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+    </div>
+  );
+});
diff --git a/apps/webapp/app/components/code/TextEditor.tsx b/apps/webapp/app/components/code/TextEditor.tsx
new file mode 100644
index 00000000000..db16b996462
--- /dev/null
+++ b/apps/webapp/app/components/code/TextEditor.tsx
@@ -0,0 +1,125 @@
+import type { ViewUpdate } from "@codemirror/view";
+import { EditorView, lineNumbers } from "@codemirror/view";
+import { CheckIcon, ClipboardIcon } from "@heroicons/react/20/solid";
+import type { ReactCodeMirrorProps, UseCodeMirror } from "@uiw/react-codemirror";
+import { useCodeMirror } from "@uiw/react-codemirror";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { cn } from "~/utils/cn";
+import { Button } from "../primitives/Buttons";
+import { getEditorSetup } from "./codeMirrorSetup";
+import { darkTheme } from "./codeMirrorTheme";
+
+export interface TextEditorProps extends Omit<ReactCodeMirrorProps, "onBlur"> {
+  defaultValue?: string;
+  readOnly?: boolean;
+  onChange?: (value: string) => void;
+  onUpdate?: (update: ViewUpdate) => void;
+  showCopyButton?: boolean;
+  additionalActions?: React.ReactNode;
+}
+
+export function TextEditor(opts: TextEditorProps) {
+  const {
+    defaultValue = "",
+    readOnly = false,
+    onChange,
+    onUpdate,
+    autoFocus,
+    showCopyButton = true,
+    additionalActions,
+  } = opts;
+
+  // Don't use default line numbers from setup — add our own with proper sizing
+  const extensions = getEditorSetup(false);
+  extensions.push(EditorView.lineWrapping);
+  extensions.push(
+    lineNumbers({
+      formatNumber: (n) => String(n),
+    })
+  );
+  extensions.push(
+    EditorView.theme({
+      ".cm-lineNumbers": {
+        minWidth: "40px",
+      },
+    })
+  );
+
+  const editor = useRef<HTMLDivElement>(null);
+  const settings: Omit<UseCodeMirror, "onBlur"> = {
+    ...opts,
+    container: editor.current,
+    extensions,
+    editable: !readOnly,
+    contentEditable: !readOnly,
+    value: defaultValue,
+    autoFocus,
+    theme: darkTheme(),
+    indentWithTab: false,
+    basicSetup: false,
+    onChange,
+    onUpdate,
+  };
+  const { setContainer, view } = useCodeMirror(settings);
+  const [copied, setCopied] = useState(false);
+
+  useEffect(() => {
+    if (editor.current) {
+      setContainer(editor.current);
+    }
+  }, [setContainer]);
+
+  useEffect(() => {
+    if (view !== undefined) {
+      if (view.state.doc.toString() === defaultValue) return;
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: defaultValue },
+      });
+    }
+  }, [defaultValue, view]);
+
+  const copy = useCallback(() => {
+    if (view === undefined) return;
+    navigator.clipboard.writeText(view.state.doc.toString());
+    setCopied(true);
+    setTimeout(() => setCopied(false), 1500);
+  }, [view]);
+
+  const showToolbar = showCopyButton || additionalActions;
+
+  return (
+    <div
+      className={cn(
+        "grid",
+        showToolbar ? "grid-rows-[2.5rem_1fr]" : "grid-rows-[1fr]",
+        opts.className
+      )}
+    >
+      {showToolbar && (
+        <div className="mx-3 flex items-center justify-between gap-2 border-b border-grid-dimmed">
+          <div className="flex items-center">{additionalActions}</div>
+          <div className="flex items-center gap-2">
+            {showCopyButton && (
+              <Button
+                type="button"
+                variant="minimal/small"
+                TrailingIcon={copied ? CheckIcon : ClipboardIcon}
+                trailingIconClassName={
+                  copied ? "text-green-500 group-hover:text-green-500" : undefined
+                }
+                onClick={(event) => {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  copy();
+                }}
+              >
+                Copy
+              </Button>
+            )}
+          </div>
+        </div>
+      )}
+      <div className="min-h-0 min-w-0 overflow-auto" ref={editor} />
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/code/chartColors.ts b/apps/webapp/app/components/code/chartColors.ts
new file mode 100644
index 00000000000..26bcc487a2e
--- /dev/null
+++ b/apps/webapp/app/components/code/chartColors.ts
@@ -0,0 +1,183 @@
+/**
+ * Chart color palette defined in HSL (Hue, Saturation, Lightness).
+ *
+ * HSL is a human-friendly color model:
+ *   h: 0–360  (hue — position on the color wheel: 0=red, 120=green, 240=blue)
+ *   s: 0–100  (saturation — 0 is gray, 100 is full color)
+ *   l: 0–100  (lightness — 0 is black, 50 is pure color, 100 is white)
+ */
+
+interface HSLColor {
+  h: number;
+  s: number;
+  l: number;
+}
+
+interface ChartColorDef {
+  name: string;
+  hsl: HSLColor;
+}
+
+// ---------------------------------------------------------------------------
+// Palette — 30 distinct colors for chart series, defined in HSL
+// ---------------------------------------------------------------------------
+const CHART_COLOR_DEFS: ChartColorDef[] = [
+  // Primary colors (high contrast, spread across hue wheel)
+  { name: "Purple", hsl: { h: 252, s: 98, l: 66 } },
+  { name: "Green", hsl: { h: 142, s: 71, l: 45 } },
+  { name: "Amber", hsl: { h: 38, s: 92, l: 50 } },
+  { name: "Red", hsl: { h: 0, s: 84, l: 60 } },
+  { name: "Cyan", hsl: { h: 189, s: 95, l: 43 } },
+  { name: "Pink", hsl: { h: 330, s: 81, l: 60 } },
+  { name: "Violet", hsl: { h: 258, s: 90, l: 66 } },
+  { name: "Teal", hsl: { h: 173, s: 80, l: 40 } },
+  { name: "Orange", hsl: { h: 25, s: 95, l: 53 } },
+  { name: "Indigo", hsl: { h: 239, s: 84, l: 67 } },
+  // Extended palette
+  { name: "Lime", hsl: { h: 84, s: 81, l: 44 } },
+  { name: "Sky", hsl: { h: 199, s: 89, l: 48 } },
+  { name: "Rose", hsl: { h: 350, s: 89, l: 60 } },
+  { name: "Fuchsia", hsl: { h: 271, s: 91, l: 65 } },
+  { name: "Yellow", hsl: { h: 45, s: 93, l: 47 } },
+  { name: "Emerald", hsl: { h: 160, s: 84, l: 39 } },
+  { name: "Blue", hsl: { h: 217, s: 91, l: 60 } },
+  { name: "Magenta", hsl: { h: 292, s: 84, l: 61 } },
+  { name: "Stone", hsl: { h: 25, s: 5, l: 45 } },
+  { name: "Gold", hsl: { h: 48, s: 96, l: 53 } },
+  // Additional distinct colors (lighter variants)
+  { name: "Turquoise", hsl: { h: 173, s: 66, l: 50 } },
+  { name: "Light Orange", hsl: { h: 27, s: 96, l: 61 } },
+  { name: "Yellow-Green", hsl: { h: 83, s: 78, l: 55 } },
+  { name: "Light Blue", hsl: { h: 198, s: 93, l: 60 } },
+  { name: "Light Purple", hsl: { h: 270, s: 95, l: 75 } },
+  { name: "Light Green", hsl: { h: 142, s: 69, l: 58 } },
+  { name: "Light Amber", hsl: { h: 43, s: 96, l: 56 } },
+  { name: "Light Pink", hsl: { h: 329, s: 86, l: 70 } },
+  { name: "Light Cyan", hsl: { h: 187, s: 92, l: 69 } },
+  { name: "Light Indigo", hsl: { h: 235, s: 89, l: 74 } },
+];
+
+// ---------------------------------------------------------------------------
+// HSL ↔ Hex conversion
+// ---------------------------------------------------------------------------
+
+/** Convert an HSL color (h: 0–360, s: 0–100, l: 0–100) to a hex string */
+function hslToHex({ h, s, l }: HSLColor): string {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+
+  const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+  const hPrime = h / 60;
+  const x = c * (1 - Math.abs((hPrime % 2) - 1));
+  const m = lNorm - c / 2;
+
+  let r1: number, g1: number, b1: number;
+
+  if (hPrime < 1) {
+    r1 = c;
+    g1 = x;
+    b1 = 0;
+  } else if (hPrime < 2) {
+    r1 = x;
+    g1 = c;
+    b1 = 0;
+  } else if (hPrime < 3) {
+    r1 = 0;
+    g1 = c;
+    b1 = x;
+  } else if (hPrime < 4) {
+    r1 = 0;
+    g1 = x;
+    b1 = c;
+  } else if (hPrime < 5) {
+    r1 = x;
+    g1 = 0;
+    b1 = c;
+  } else {
+    r1 = c;
+    g1 = 0;
+    b1 = x;
+  }
+
+  const toHex = (v: number) =>
+    Math.round((v + m) * 255)
+      .toString(16)
+      .padStart(2, "0");
+
+  return `#${toHex(r1)}${toHex(g1)}${toHex(b1)}`;
+}
+
+/** Convert a hex string to HSL (h: 0–360, s: 0–100, l: 0–100) */
+function hexToHsl(hex: string): HSLColor {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  const l = (max + min) / 2;
+
+  if (delta === 0) {
+    return { h: 0, s: 0, l: Math.round(l * 100) };
+  }
+
+  const s = delta / (1 - Math.abs(2 * l - 1));
+
+  let h: number;
+  if (max === r) {
+    h = 60 * (((g - b) / delta + 6) % 6);
+  } else if (max === g) {
+    h = 60 * ((b - r) / delta + 2);
+  } else {
+    h = 60 * ((r - g) / delta + 4);
+  }
+
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Derived hex palette (for consumers that need plain hex strings)
+// ---------------------------------------------------------------------------
+
+/** Color palette for chart series — 30 distinct hex colors derived from HSL definitions */
+const CHART_COLORS: string[] = CHART_COLOR_DEFS.map((def) => hslToHex(def.hsl));
+
+/** Get the hex color for a series by its index (wraps around) */
+export function getSeriesColor(index: number): string {
+  return CHART_COLORS[index % CHART_COLORS.length];
+}
+
+// ---------------------------------------------------------------------------
+// Hue-sorted palette (rainbow order for color pickers)
+// ---------------------------------------------------------------------------
+
+const SATURATION_THRESHOLD = 10;
+
+/**
+ * Chart colors sorted by perceived hue — the natural rainbow order
+ * that humans expect: red -> orange -> yellow -> green -> cyan -> blue -> purple -> pink.
+ *
+ * Very desaturated colors (like grays) are placed at the end since they don't
+ * have a strong hue.
+ */
+export const CHART_COLORS_BY_HUE: string[] = [...CHART_COLOR_DEFS]
+  .sort((a, b) => {
+    const aIsGray = a.hsl.s < SATURATION_THRESHOLD;
+    const bIsGray = b.hsl.s < SATURATION_THRESHOLD;
+
+    // Push desaturated colors to the end
+    if (aIsGray && !bIsGray) return 1;
+    if (!aIsGray && bIsGray) return -1;
+    if (aIsGray && bIsGray) return a.hsl.l - b.hsl.l;
+
+    // Sort by hue, then by saturation (more vivid first), then by lightness
+    if (a.hsl.h !== b.hsl.h) return a.hsl.h - b.hsl.h;
+    if (a.hsl.s !== b.hsl.s) return b.hsl.s - a.hsl.s;
+    return a.hsl.l - b.hsl.l;
+  })
+  .map((def) => hslToHex(def.hsl));
diff --git a/apps/webapp/app/components/code/codeMirrorSetup.ts b/apps/webapp/app/components/code/codeMirrorSetup.ts
index 811a6ebc298..52a8e12a4d8 100644
--- a/apps/webapp/app/components/code/codeMirrorSetup.ts
+++ b/apps/webapp/app/components/code/codeMirrorSetup.ts
@@ -1,5 +1,5 @@
 import { closeBrackets } from "@codemirror/autocomplete";
-import { indentWithTab } from "@codemirror/commands";
+import { indentWithTab, history, historyKeymap, undo, redo } from "@codemirror/commands";
 import { bracketMatching } from "@codemirror/language";
 import { lintKeymap } from "@codemirror/lint";
 import { highlightSelectionMatches } from "@codemirror/search";
@@ -18,6 +18,7 @@ export function getEditorSetup(showLineNumbers = true, showHighlights = true): A
   const options = [
     drawSelection(),
     dropCursor(),
+    history(),
     bracketMatching(),
     closeBrackets(),
     Prec.highest(
@@ -31,7 +32,15 @@ export function getEditorSetup(showLineNumbers = true, showHighlights = true): A
         },
       ])
     ),
-    keymap.of([indentWithTab, ...lintKeymap]),
+    // Explicit undo/redo keybindings with high precedence
+    Prec.high(
+      keymap.of([
+        { key: "Mod-z", run: undo },
+        { key: "Mod-Shift-z", run: redo },
+        { key: "Mod-y", run: redo },
+      ])
+    ),
+    keymap.of([indentWithTab, ...historyKeymap, ...lintKeymap]),
   ];
 
   if (showLineNumbers) {
diff --git a/apps/webapp/app/components/code/codeMirrorTheme.ts b/apps/webapp/app/components/code/codeMirrorTheme.ts
index ed14ea0ac3c..2faed6eaa54 100644
--- a/apps/webapp/app/components/code/codeMirrorTheme.ts
+++ b/apps/webapp/app/components/code/codeMirrorTheme.ts
@@ -67,9 +67,10 @@ export function darkTheme(): Extension {
       },
 
       ".cm-cursor, .cm-dropCursor": { borderLeftColor: cursor },
-      "&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": {
-        backgroundColor: selection,
-      },
+      "&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection":
+        {
+          backgroundColor: selection,
+        },
 
       ".cm-panels": { backgroundColor: darkBackground, color: ivory },
       ".cm-panels.cm-panels-top": { borderBottom: "2px solid black" },
@@ -87,8 +88,8 @@ export function darkTheme(): Extension {
       ".cm-selectionMatch": { backgroundColor: "#aafe661a" },
 
       "&.cm-focused .cm-matchingBracket, &.cm-focused .cm-nonmatchingBracket": {
-        backgroundColor: "#bad0f847",
-        outline: "1px solid #515a6b",
+        backgroundColor: "rgba(18, 19, 23, 0.9)",
+        outline: "1px solid rgba(81, 90, 107, 0.5)",
       },
 
       ".cm-gutters": {
@@ -166,14 +167,20 @@ export function darkTheme(): Extension {
         backgroundColor: scrollbarBg,
       },
     },
-    { dark: true }
+    { dark: true },
   );
 
   /// The highlighting style for code in the JSON Hero theme.
   const jsonHeroHighlightStyle = HighlightStyle.define([
     { tag: tags.keyword, color: violet },
     {
-      tag: [tags.name, tags.deleted, tags.character, tags.propertyName, tags.macroName],
+      tag: [
+        tags.name,
+        tags.deleted,
+        tags.character,
+        tags.propertyName,
+        tags.macroName,
+      ],
       color: lilac,
     },
     { tag: [tags.function(tags.variableName), tags.labelName], color: malibu },
diff --git a/apps/webapp/app/components/code/tsql/index.ts b/apps/webapp/app/components/code/tsql/index.ts
new file mode 100644
index 00000000000..bda244e30fa
--- /dev/null
+++ b/apps/webapp/app/components/code/tsql/index.ts
@@ -0,0 +1,6 @@
+// TSQL CodeMirror support
+// Provides syntax highlighting, autocompletion, and linting for TSQL queries
+
+export { createTSQLCompletion } from "./tsqlCompletion";
+export { createTSQLLinter, isValidTSQLQuery, getTSQLError, type TSQLLinterConfig } from "./tsqlLinter";
+
diff --git a/apps/webapp/app/components/code/tsql/tsqlCompletion.ts b/apps/webapp/app/components/code/tsql/tsqlCompletion.ts
new file mode 100644
index 00000000000..b53c551a4d3
--- /dev/null
+++ b/apps/webapp/app/components/code/tsql/tsqlCompletion.ts
@@ -0,0 +1,490 @@
+import type { CompletionContext, CompletionResult, Completion } from "@codemirror/autocomplete";
+import {
+  type TableSchema,
+  type ColumnSchema,
+  TSQL_CLICKHOUSE_FUNCTIONS,
+  TSQL_AGGREGATIONS,
+} from "@internal/tsql";
+
+/**
+ * SQL keywords for autocomplete
+ */
+const SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "LIKE",
+  "ILIKE",
+  "BETWEEN",
+  "IS",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "AS",
+  "ORDER",
+  "BY",
+  "ASC",
+  "DESC",
+  "LIMIT",
+  "OFFSET",
+  "GROUP",
+  "HAVING",
+  "DISTINCT",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "FULL",
+  "CROSS",
+  "ON",
+  "UNION",
+  "INTERSECT",
+  "EXCEPT",
+  "ALL",
+  "WITH",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "OVER",
+  "PARTITION",
+  "ROWS",
+  "RANGE",
+  "UNBOUNDED",
+  "PRECEDING",
+  "FOLLOWING",
+  "CURRENT",
+  "ROW",
+  "NULLS",
+  "FIRST",
+  "LAST",
+];
+
+/**
+ * Create keyword completions from the SQL keywords list
+ */
+function createKeywordCompletions(): Completion[] {
+  return SQL_KEYWORDS.map((keyword) => ({
+    label: keyword,
+    type: "keyword",
+    boost: -1, // Keywords should have lower priority than schema items
+  }));
+}
+
+/**
+ * Create function completions from TSQL function definitions
+ */
+function createFunctionCompletions(): Completion[] {
+  const functions: Completion[] = [];
+
+  // Add regular functions
+  for (const [name, meta] of Object.entries(TSQL_CLICKHOUSE_FUNCTIONS)) {
+    // Skip internal functions starting with _
+    if (name.startsWith("_")) continue;
+
+    const argsHint =
+      meta.maxArgs === 0
+        ? "()"
+        : meta.minArgs === meta.maxArgs
+        ? `(${meta.minArgs} args)`
+        : `(${meta.minArgs}${meta.maxArgs ? `-${meta.maxArgs}` : "+"} args)`;
+
+    functions.push({
+      label: name,
+      type: "function",
+      detail: argsHint,
+      apply: `${name}()`,
+    });
+  }
+
+  // Add aggregate functions with slightly higher boost
+  for (const [name, meta] of Object.entries(TSQL_AGGREGATIONS)) {
+    if (name.startsWith("_")) continue;
+
+    const argsHint =
+      meta.maxArgs === 0
+        ? "()"
+        : meta.minArgs === meta.maxArgs
+        ? `(${meta.minArgs} args)`
+        : `(${meta.minArgs}${meta.maxArgs ? `-${meta.maxArgs}` : "+"} args)`;
+
+    functions.push({
+      label: name,
+      type: "function",
+      detail: `aggregate ${argsHint}`,
+      apply: `${name}()`,
+      boost: 0.5,
+    });
+  }
+
+  // Add special TSQL functions not in the ClickHouse function registry
+  functions.push({
+    label: "timeBucket",
+    type: "function",
+    detail: "auto time bucket (0 args)",
+    apply: "timeBucket()",
+    boost: 1.5,
+    info: "Automatically bucket by time using the table's time column. Interval is chosen based on the query's time range.",
+  });
+
+  return functions;
+}
+
+/**
+ * Create table completions from schema
+ */
+function createTableCompletions(schema: TableSchema[]): Completion[] {
+  return schema.map((table) => ({
+    label: table.name,
+    type: "class", // Using "class" type for tables gives them a nice icon
+    detail: table.description || "table",
+    boost: 1, // Tables should have higher priority
+  }));
+}
+
+/**
+ * Create column completions for a specific table
+ */
+function createColumnCompletions(table: TableSchema, prefix?: string): Completion[] {
+  const columns: Completion[] = [];
+
+  for (const [name, column] of Object.entries(table.columns)) {
+    columns.push({
+      label: prefix ? `${prefix}.${name}` : name,
+      type: "property", // Using "property" type for columns
+      detail: `${column.type}${column.description ? ` - ${column.description}` : ""}`,
+      boost: 2, // Columns should have highest priority
+    });
+  }
+
+  return columns;
+}
+
+/**
+ * Extract table names/aliases from the current query context
+ * This is a simplified parser that looks for FROM and JOIN clauses
+ */
+function extractTablesFromQuery(doc: string, schema: TableSchema[]): Map<string, TableSchema> {
+  const tableMap = new Map<string, TableSchema>();
+  const tableNames = schema.map((t) => t.name);
+
+  // Simple regex to find table references in FROM and JOIN clauses
+  // Handles: FROM table_name, FROM table_name AS alias, FROM table_name alias
+  const tablePattern = /(?:FROM|JOIN)\s+(\w+)(?:\s+(?:AS\s+)?(\w+))?/gi;
+
+  let match;
+  while ((match = tablePattern.exec(doc)) !== null) {
+    const tableName = match[1];
+    const alias = match[2] || tableName;
+
+    // Find the table schema if it exists
+    const tableSchema = schema.find((t) => t.name.toLowerCase() === tableName.toLowerCase());
+
+    if (tableSchema) {
+      tableMap.set(alias.toLowerCase(), tableSchema);
+    }
+  }
+
+  return tableMap;
+}
+
+/**
+ * Determine what context we're in based on cursor position
+ */
+type CompletionContextType =
+  | "table" // After FROM or JOIN
+  | "column" // After SELECT, WHERE, ORDER BY, GROUP BY, etc.
+  | "alias" // After table_name.
+  | "value" // After comparison operator (=, !=, IN, etc.)
+  | "general"; // Anywhere else
+
+/**
+ * Result of context detection
+ */
+interface ContextResult {
+  type: CompletionContextType;
+  tablePrefix?: string;
+  /** Column being compared (for value context) */
+  columnName?: string;
+  /** Table alias for the column (for value context) */
+  columnTableAlias?: string;
+}
+
+/**
+ * Extract column name from text before a comparison operator
+ * Handles: "column =", "table.column =", "column IN", "column = 'partial", etc.
+ */
+function extractColumnBeforeOperator(
+  textBefore: string
+): { columnName: string; tableAlias?: string } | null {
+  // Match patterns like: column =, column !=, column IN, table.column =, etc.
+  // We need to capture the column (and optional table prefix) before the operator
+  // Also match when user is typing a partial string value like: column = 'val
+  const patterns = [
+    // column = or column != or column <> (with optional whitespace and optional partial string value)
+    /(\w+)\.(\w+)\s*(?:=|!=|<>)\s*(?:'[^']*)?$/i,
+    /(\w+)\s*(?:=|!=|<>)\s*(?:'[^']*)?$/i,
+    // column IN ( or column NOT IN ( (with optional partial string value)
+    /(\w+)\.(\w+)\s+(?:NOT\s+)?IN\s*\(\s*(?:'[^']*)?$/i,
+    /(\w+)\s+(?:NOT\s+)?IN\s*\(\s*(?:'[^']*)?$/i,
+    // After a comma in IN clause (with optional partial string value)
+    /(\w+)\.(\w+)\s+(?:NOT\s+)?IN\s*\([^)]*,\s*(?:'[^']*)?$/i,
+    /(\w+)\s+(?:NOT\s+)?IN\s*\([^)]*,\s*(?:'[^']*)?$/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = textBefore.match(pattern);
+    if (match) {
+      if (match.length === 3) {
+        // table.column pattern
+        return { tableAlias: match[1], columnName: match[2] };
+      } else {
+        // just column pattern
+        return { columnName: match[1] };
+      }
+    }
+  }
+
+  return null;
+}
+
+function determineContext(doc: string, pos: number): ContextResult {
+  // Get text before cursor
+  const textBefore = doc.slice(0, pos);
+
+  // Check if we're in a value context (after comparison operator)
+  // This should be checked before other contexts
+  const columnInfo = extractColumnBeforeOperator(textBefore);
+  if (columnInfo) {
+    return {
+      type: "value",
+      columnName: columnInfo.columnName,
+      columnTableAlias: columnInfo.tableAlias,
+    };
+  }
+
+  // Check if we're completing after a dot (table.column)
+  const dotMatch = textBefore.match(/(\w+)\.\s*$/);
+  if (dotMatch) {
+    return { type: "alias", tablePrefix: dotMatch[1] };
+  }
+
+  // Find the LAST significant keyword before cursor
+  // We match all keywords and take the last one
+  const keywordPattern = /\b(SELECT|FROM|JOIN|WHERE|AND|OR|ORDER\s+BY|GROUP\s+BY|HAVING|ON)\b/gi;
+  let lastMatch: RegExpExecArray | null = null;
+  let match: RegExpExecArray | null;
+
+  while ((match = keywordPattern.exec(textBefore)) !== null) {
+    lastMatch = match;
+  }
+
+  if (lastMatch) {
+    const keyword = lastMatch[1].toUpperCase().replace(/\s+/g, " ");
+
+    if (keyword === "FROM" || keyword === "JOIN") {
+      return { type: "table" };
+    }
+
+    if (
+      keyword === "SELECT" ||
+      keyword === "WHERE" ||
+      keyword === "AND" ||
+      keyword === "OR" ||
+      keyword === "ORDER BY" ||
+      keyword === "GROUP BY" ||
+      keyword === "HAVING" ||
+      keyword === "ON"
+    ) {
+      return { type: "column" };
+    }
+  }
+
+  return { type: "general" };
+}
+
+/**
+ * Find a column schema by name in the tables map
+ */
+function findColumnSchema(
+  columnName: string,
+  tableAlias: string | undefined,
+  tables: Map<string, TableSchema>
+): ColumnSchema | null {
+  if (tableAlias) {
+    // Look in specific table
+    const tableSchema = tables.get(tableAlias.toLowerCase());
+    if (tableSchema) {
+      return tableSchema.columns[columnName] || null;
+    }
+  } else {
+    // Look in all tables
+    for (const tableSchema of tables.values()) {
+      const col = tableSchema.columns[columnName];
+      if (col) {
+        return col;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Create completions for enum values from allowedValues
+ */
+function createEnumValueCompletions(columnSchema: ColumnSchema): Completion[] {
+  if (!columnSchema.allowedValues || columnSchema.allowedValues.length === 0) {
+    return [];
+  }
+
+  return columnSchema.allowedValues.map((value) => ({
+    label: `'${value}'`,
+    type: "enum",
+    detail: columnSchema.description || "allowed value",
+    boost: 3, // Highest priority for enum values in value context
+  }));
+}
+
+/**
+ * Create a TSQL-aware autocompletion source
+ *
+ * @param schema - Array of table schemas to use for completions
+ * @returns A CodeMirror completion source function
+ */
+export function createTSQLCompletion(
+  schema: TableSchema[]
+): (context: CompletionContext) => CompletionResult | null {
+  // Pre-compute static completions
+  const keywordCompletions = createKeywordCompletions();
+  const functionCompletions = createFunctionCompletions();
+  const tableCompletions = createTableCompletions(schema);
+
+  return (context: CompletionContext): CompletionResult | null => {
+    // Get the word being typed - include single quotes for value completion
+    const word = context.matchBefore(/[\w.']+/);
+
+    // Don't show completions if no word is being typed and not explicitly triggered
+    if (!word && !context.explicit) {
+      return null;
+    }
+
+    const from = word ? word.from : context.pos;
+    const doc = context.state.doc.toString();
+    const queryContext = determineContext(doc, context.pos);
+
+    let options: Completion[] = [];
+    // Track if we need to extend replacement range (e.g., to consume auto-paired closing quote)
+    let to: number | undefined = undefined;
+
+    switch (queryContext.type) {
+      case "table":
+        // After FROM or JOIN, show only tables
+        options = tableCompletions;
+        break;
+
+      case "alias":
+        // After table., show columns for that table
+        if (queryContext.tablePrefix) {
+          const tables = extractTablesFromQuery(doc, schema);
+          const tableSchema = tables.get(queryContext.tablePrefix.toLowerCase());
+
+          if (tableSchema) {
+            options = createColumnCompletions(tableSchema);
+          }
+        }
+        break;
+
+      case "value":
+        // After comparison operator, show enum values if available
+        if (queryContext.columnName) {
+          const tables = extractTablesFromQuery(doc, schema);
+          const columnSchema = findColumnSchema(
+            queryContext.columnName,
+            queryContext.columnTableAlias,
+            tables
+          );
+
+          if (columnSchema) {
+            options = createEnumValueCompletions(columnSchema);
+            // Check if there's a closing quote right after cursor (from auto-pairing)
+            // If so, extend replacement range to include it to avoid 'Completed''
+            const charAfterCursor = context.state.doc.sliceString(context.pos, context.pos + 1);
+            if (charAfterCursor === "'") {
+              to = context.pos + 1;
+            }
+          }
+        }
+        break;
+
+      case "column":
+        // After SELECT, WHERE, etc., show columns, functions, and some keywords
+        {
+          const tables = extractTablesFromQuery(doc, schema);
+
+          // Add columns from all tables in the query
+          tables.forEach((tableSchema, alias) => {
+            // If multiple tables, prefix with alias
+            const prefix = tables.size > 1 ? alias : undefined;
+            options.push(...createColumnCompletions(tableSchema, prefix));
+          });
+
+          // Also add functions and relevant keywords
+          options.push(...functionCompletions);
+          options.push(
+            ...keywordCompletions.filter((k) =>
+              [
+                "AND",
+                "OR",
+                "NOT",
+                "IN",
+                "LIKE",
+                "ILIKE",
+                "BETWEEN",
+                "IS",
+                "NULL",
+                "AS",
+                "CASE",
+                "WHEN",
+                "THEN",
+                "ELSE",
+                "END",
+              ].includes(k.label as string)
+            )
+          );
+        }
+        break;
+
+      case "general":
+      default:
+        // Show everything
+        options = [...tableCompletions, ...functionCompletions, ...keywordCompletions];
+
+        // Also add columns from tables in query
+        {
+          const tables = extractTablesFromQuery(doc, schema);
+          tables.forEach((tableSchema, alias) => {
+            const prefix = tables.size > 1 ? alias : undefined;
+            options.push(...createColumnCompletions(tableSchema, prefix));
+          });
+        }
+        break;
+    }
+
+    const result: CompletionResult = {
+      from,
+      options,
+      validFor: /^[\w.']*$/,
+    };
+    // Only set 'to' if we need to extend the replacement range
+    if (to !== undefined) {
+      result.to = to;
+    }
+    return result;
+  };
+}
diff --git a/apps/webapp/app/components/code/tsql/tsqlLinter.test.ts b/apps/webapp/app/components/code/tsql/tsqlLinter.test.ts
new file mode 100644
index 00000000000..8acc81d66f0
--- /dev/null
+++ b/apps/webapp/app/components/code/tsql/tsqlLinter.test.ts
@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { isValidTSQLQuery, getTSQLError } from "./tsqlLinter";
+
+describe("tsqlLinter", () => {
+  describe("isValidTSQLQuery", () => {
+    it("should return true for empty queries", () => {
+      expect(isValidTSQLQuery("")).toBe(true);
+      expect(isValidTSQLQuery("   ")).toBe(true);
+    });
+
+    it("should return true for valid SELECT queries", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users")).toBe(true);
+      expect(isValidTSQLQuery("SELECT id, name FROM users WHERE status = 'active'")).toBe(true);
+      expect(isValidTSQLQuery("SELECT count(*) FROM users GROUP BY status")).toBe(true);
+    });
+
+    it("should return true for queries with ORDER BY", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users ORDER BY created_at DESC")).toBe(true);
+    });
+
+    it("should return true for queries with LIMIT", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10")).toBe(true);
+      expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10 OFFSET 20")).toBe(true);
+    });
+
+    it("should return true for queries with JOINs", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users JOIN orders ON users.id = orders.user_id")).toBe(
+        true
+      );
+      expect(
+        isValidTSQLQuery(
+          "SELECT * FROM users LEFT JOIN orders ON users.id = orders.user_id"
+        )
+      ).toBe(true);
+    });
+
+    it("should return false for invalid syntax", () => {
+      expect(isValidTSQLQuery("SELEC * FROM users")).toBe(false);
+      expect(isValidTSQLQuery("SELECT * FORM users")).toBe(false);
+      expect(isValidTSQLQuery("SELECT FROM users")).toBe(false);
+    });
+
+    it("should return false for incomplete queries", () => {
+      expect(isValidTSQLQuery("SELECT * FROM")).toBe(false);
+      expect(isValidTSQLQuery("SELECT")).toBe(false);
+    });
+  });
+
+  describe("getTSQLError", () => {
+    it("should return null for empty queries", () => {
+      expect(getTSQLError("")).toBeNull();
+      expect(getTSQLError("   ")).toBeNull();
+    });
+
+    it("should return null for valid queries", () => {
+      expect(getTSQLError("SELECT * FROM users")).toBeNull();
+      expect(getTSQLError("SELECT id, name FROM users WHERE id = 1")).toBeNull();
+    });
+
+    it("should return error message for invalid queries", () => {
+      const error = getTSQLError("SELEC * FROM users");
+      expect(error).not.toBeNull();
+      expect(typeof error).toBe("string");
+    });
+
+    it("should include position information in error", () => {
+      const error = getTSQLError("SELECT * FORM users");
+      expect(error).not.toBeNull();
+      // Error message should contain line/column info
+      expect(error).toContain("line");
+    });
+
+    it("should handle missing FROM clause", () => {
+      const error = getTSQLError("SELECT * WHERE id = 1");
+      expect(error).not.toBeNull();
+    });
+  });
+});
+
diff --git a/apps/webapp/app/components/code/tsql/tsqlLinter.ts b/apps/webapp/app/components/code/tsql/tsqlLinter.ts
new file mode 100644
index 00000000000..72794e3e9ab
--- /dev/null
+++ b/apps/webapp/app/components/code/tsql/tsqlLinter.ts
@@ -0,0 +1,213 @@
+import type { EditorView } from "@codemirror/view";
+import type { Diagnostic } from "@codemirror/lint";
+import type { TableSchema } from "@internal/tsql";
+import { parseTSQLSelect, SyntaxError, QueryError, validateQuery } from "@internal/tsql";
+
+/**
+ * Configuration for the TSQL linter
+ */
+export interface TSQLLinterConfig {
+  /** Optional schema for validating table/column names */
+  schema?: TableSchema[];
+  /** Delay in milliseconds before running the linter (debouncing) */
+  delay?: number;
+}
+
+/**
+ * Extract line and column from a TSQL error message
+ * Error format: "Syntax error at line X:Y: message"
+ */
+function parseErrorPosition(message: string): { line: number; column: number } | null {
+  const match = message.match(/at line (\d+):(\d+)/);
+  if (match) {
+    return {
+      line: parseInt(match[1], 10),
+      column: parseInt(match[2], 10),
+    };
+  }
+  return null;
+}
+
+/**
+ * Convert line/column to a document position
+ */
+function positionToOffset(
+  doc: string,
+  line: number,
+  column: number
+): number {
+  const lines = doc.split("\n");
+
+  // line is 1-indexed
+  let offset = 0;
+  for (let i = 0; i < line - 1 && i < lines.length; i++) {
+    offset += lines[i].length + 1; // +1 for newline
+  }
+
+  return offset + column;
+}
+
+/**
+ * Find the end of a word/token at the given position
+ */
+function findTokenEnd(doc: string, start: number): number {
+  let end = start;
+
+  // Scan forward until we hit whitespace or end of string
+  while (end < doc.length && /\S/.test(doc[end])) {
+    end++;
+  }
+
+  // If we didn't move, include at least one character
+  if (end === start) {
+    end = Math.min(start + 1, doc.length);
+  }
+
+  return end;
+}
+
+/**
+ * Create a TSQL linter function for CodeMirror
+ *
+ * This linter uses the TSQL ANTLR parser to detect syntax errors
+ * and optionally validates against a schema.
+ *
+ * @param config - Linter configuration
+ * @returns A linter function for use with CodeMirror's linter extension
+ */
+export function createTSQLLinter(
+  config: TSQLLinterConfig = {}
+): (view: EditorView) => Diagnostic[] {
+  const { schema = [] } = config;
+
+  return (view: EditorView): Diagnostic[] => {
+    const content = view.state.doc.toString().trim();
+
+    // Return no errors for empty content
+    if (!content) {
+      return [];
+    }
+
+    const diagnostics: Diagnostic[] = [];
+
+    try {
+      // Try to parse the query
+      const ast = parseTSQLSelect(content);
+
+      // If parsing succeeds and we have a schema, run schema validation
+      if (schema.length > 0) {
+        const validationResult = validateQuery(ast, schema);
+
+        for (const issue of validationResult.issues) {
+          // Map validation severity to CodeMirror diagnostic severity
+          const severity: "error" | "warning" | "info" =
+            issue.severity === "error"
+              ? "error"
+              : issue.severity === "warning"
+                ? "warning"
+                : "info";
+
+          diagnostics.push({
+            from: 0,
+            to: content.length,
+            severity,
+            message: issue.message,
+            source: "tsql",
+          });
+        }
+      }
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        const position = parseErrorPosition(error.message);
+
+        let from: number;
+        let to: number;
+
+        if (position) {
+          from = positionToOffset(content, position.line, position.column);
+          to = findTokenEnd(content, from);
+        } else {
+          // If we can't parse the position, highlight the whole query
+          from = 0;
+          to = content.length;
+        }
+
+        // Clean up the error message
+        let message = error.message;
+        // Remove the "Syntax error at line X:Y: " prefix if present
+        message = message.replace(/^Syntax error at line \d+:\d+:\s*/, "");
+
+        diagnostics.push({
+          from,
+          to,
+          severity: "error",
+          message: message,
+          source: "tsql",
+        });
+      } else if (error instanceof QueryError) {
+        // Schema validation errors don't have position info,
+        // so highlight the whole query
+        diagnostics.push({
+          from: 0,
+          to: content.length,
+          severity: "warning",
+          message: error.message,
+          source: "tsql",
+        });
+      } else if (error instanceof Error) {
+        // Unknown error
+        diagnostics.push({
+          from: 0,
+          to: content.length,
+          severity: "error",
+          message: error.message,
+          source: "tsql",
+        });
+      }
+    }
+
+    return diagnostics;
+  };
+}
+
+/**
+ * Check if a TSQL query is valid
+ *
+ * @param query - The query to validate
+ * @returns true if the query is valid, false otherwise
+ */
+export function isValidTSQLQuery(query: string): boolean {
+  if (!query.trim()) {
+    return true; // Empty queries are considered valid
+  }
+
+  try {
+    parseTSQLSelect(query);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get error message for a TSQL query, if any
+ *
+ * @param query - The query to validate
+ * @returns Error message if invalid, null if valid
+ */
+export function getTSQLError(query: string): string | null {
+  if (!query.trim()) {
+    return null;
+  }
+
+  try {
+    parseTSQLSelect(query);
+    return null;
+  } catch (error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return "Unknown error";
+  }
+}
+
diff --git a/apps/webapp/app/components/environments/EnvironmentLabel.tsx b/apps/webapp/app/components/environments/EnvironmentLabel.tsx
index 33860b9c254..57d70406ccf 100644
--- a/apps/webapp/app/components/environments/EnvironmentLabel.tsx
+++ b/apps/webapp/app/components/environments/EnvironmentLabel.tsx
@@ -51,10 +51,14 @@ export function EnvironmentCombo({
   environment,
   className,
   iconClassName,
+  tooltipSideOffset,
+  tooltipSide,
 }: {
   environment: Environment;
   className?: string;
   iconClassName?: string;
+  tooltipSideOffset?: number;
+  tooltipSide?: "top" | "right" | "bottom" | "left";
 }) {
   return (
     <span className={cn("flex items-center gap-1.5 text-sm text-text-bright", className)}>
@@ -62,7 +66,11 @@ export function EnvironmentCombo({
         environment={environment}
         className={cn("size-4.5 shrink-0", iconClassName)}
       />
-      <EnvironmentLabel environment={environment} />
+      <EnvironmentLabel
+        environment={environment}
+        tooltipSideOffset={tooltipSideOffset}
+        tooltipSide={tooltipSide}
+      />
     </span>
   );
 }
@@ -70,9 +78,15 @@ export function EnvironmentCombo({
 export function EnvironmentLabel({
   environment,
   className,
+  tooltipSideOffset = 34,
+  tooltipSide = "right",
+  disableTooltip = false,
 }: {
   environment: Environment;
   className?: string;
+  tooltipSideOffset?: number;
+  tooltipSide?: "top" | "right" | "bottom" | "left";
+  disableTooltip?: boolean;
 }) {
   const spanRef = useRef<HTMLSpanElement>(null);
   const [isTruncated, setIsTruncated] = useState(false);
@@ -105,7 +119,7 @@ export function EnvironmentLabel({
     </span>
   );
 
-  if (isTruncated) {
+  if (isTruncated && !disableTooltip) {
     return (
       <SimpleTooltip
         asChild
@@ -115,9 +129,10 @@ export function EnvironmentLabel({
             {text}
           </span>
         }
-        side="right"
+        side={tooltipSide}
         variant="dark"
-        sideOffset={34}
+        sideOffset={tooltipSideOffset}
+        disableHoverableContent
       />
     );
   }
@@ -125,6 +140,10 @@ export function EnvironmentLabel({
   return content;
 }
 
+export function EnvironmentSlug({ environment }: { environment: Environment & { slug: string } }) {
+  return <span className={environmentTextClassName(environment)}>{environment.slug}</span>;
+}
+
 export function environmentTitle(environment: Environment, username?: string) {
   if (environment.branchName) {
     return environment.branchName;
diff --git a/apps/webapp/app/components/environments/RegenerateApiKeyModal.tsx b/apps/webapp/app/components/environments/RegenerateApiKeyModal.tsx
index 130c1c4acc3..439fd892f91 100644
--- a/apps/webapp/app/components/environments/RegenerateApiKeyModal.tsx
+++ b/apps/webapp/app/components/environments/RegenerateApiKeyModal.tsx
@@ -10,11 +10,14 @@ import { FormButtons } from "../primitives/FormButtons";
 import { Input } from "../primitives/Input";
 import { InputGroup } from "../primitives/InputGroup";
 import { Paragraph } from "../primitives/Paragraph";
+import { CheckboxWithLabel } from "../primitives/Checkbox";
 import { Spinner } from "../primitives/Spinner";
 
 type ModalProps = {
   id: string;
   title: string;
+  hasVercelIntegration: boolean;
+  isDevelopment: boolean;
 };
 
 type ModalContentProps = ModalProps & {
@@ -22,7 +25,12 @@ type ModalContentProps = ModalProps & {
   closeModal: () => void;
 };
 
-export function RegenerateApiKeyModal({ id, title }: ModalProps) {
+export function RegenerateApiKeyModal({
+  id,
+  title,
+  hasVercelIntegration,
+  isDevelopment,
+}: ModalProps) {
   const randomWord = generateTwoRandomWords();
   const [open, setOpen] = useState(false);
   return (
@@ -37,6 +45,8 @@ export function RegenerateApiKeyModal({ id, title }: ModalProps) {
         <RegenerateApiKeyModalContent
           id={id}
           title={title}
+          hasVercelIntegration={hasVercelIntegration}
+          isDevelopment={isDevelopment}
           randomWord={randomWord}
           closeModal={() => setOpen(false)}
         />
@@ -45,7 +55,14 @@ export function RegenerateApiKeyModal({ id, title }: ModalProps) {
   );
 }
 
-const RegenerateApiKeyModalContent = ({ id, randomWord, title, closeModal }: ModalContentProps) => {
+const RegenerateApiKeyModalContent = ({
+  id,
+  randomWord,
+  title,
+  hasVercelIntegration,
+  isDevelopment,
+  closeModal,
+}: ModalContentProps) => {
   const [confirmationText, setConfirmationText] = useState("");
   const fetcher = useFetcher();
   const isSubmitting = fetcher.state === "submitting";
@@ -83,6 +100,15 @@ const RegenerateApiKeyModalContent = ({ id, randomWord, title, closeModal }: Mod
               onChange={(e) => setConfirmationText(e.target.value)}
             />
           </InputGroup>
+          {hasVercelIntegration && !isDevelopment && (
+            <CheckboxWithLabel
+              name="syncToVercel"
+              variant="simple/small"
+              label="Also update TRIGGER_SECRET_KEY in Vercel"
+              defaultChecked={true}
+              value="on"
+            />
+          )}
           <FormButtons
             confirmButton={
               <Button
@@ -94,7 +120,11 @@ const RegenerateApiKeyModalContent = ({ id, randomWord, title, closeModal }: Mod
                 Regenerate
               </Button>
             }
-            cancelButton={<Button variant={"tertiary/medium"}>Cancel</Button>}
+            cancelButton={
+              <Button variant={"tertiary/medium"} type="button" onClick={closeModal}>
+                Cancel
+              </Button>
+            }
           />
         </Fieldset>
       </fetcher.Form>
diff --git a/apps/webapp/app/components/errors/ConfigureErrorAlerts.tsx b/apps/webapp/app/components/errors/ConfigureErrorAlerts.tsx
new file mode 100644
index 00000000000..dc586c89438
--- /dev/null
+++ b/apps/webapp/app/components/errors/ConfigureErrorAlerts.tsx
@@ -0,0 +1,365 @@
+import { conform, list, requestIntent, useFieldList, useForm } from "@conform-to/react";
+import { parse } from "@conform-to/zod";
+import {
+  EnvelopeIcon,
+  GlobeAltIcon,
+  HashtagIcon,
+  LockClosedIcon,
+  XMarkIcon,
+} from "@heroicons/react/20/solid";
+import { useFetcher, useNavigate } from "@remix-run/react";
+import { SlackIcon } from "@trigger.dev/companyicons";
+import { Fragment, useEffect, useRef, useState } from "react";
+import { z } from "zod";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Callout, variantClasses } from "~/components/primitives/Callout";
+import { useToast } from "~/components/primitives/Toast";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormError } from "~/components/primitives/FormError";
+import { Header2, Header3 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import { InlineCode } from "~/components/code/InlineCode";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { UnorderedList } from "~/components/primitives/UnorderedList";
+import type { ErrorAlertChannelData } from "~/presenters/v3/ErrorAlertChannelPresenter.server";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { cn } from "~/utils/cn";
+import { organizationSlackIntegrationPath } from "~/utils/pathBuilder";
+import { ExitIcon } from "~/assets/icons/ExitIcon";
+import { TextLink } from "~/components/primitives/TextLink";
+import { BellAlertIcon } from "@heroicons/react/24/solid";
+
+export const ErrorAlertsFormSchema = z.object({
+  emails: z.preprocess((i) => {
+    if (typeof i === "string") return i === "" ? [] : [i];
+    if (Array.isArray(i)) return i.filter((v) => typeof v === "string" && v !== "");
+    return [];
+  }, z.string().email().array()),
+  slackChannel: z.string().optional(),
+  slackIntegrationId: z.string().optional(),
+  webhooks: z.preprocess((i) => {
+    if (typeof i === "string") return i === "" ? [] : [i];
+    if (Array.isArray(i)) return i.filter((v) => typeof v === "string" && v !== "");
+    return [];
+  }, z.string().url().array()),
+});
+
+type ConfigureErrorAlertsProps = ErrorAlertChannelData & {
+  connectToSlackHref?: string;
+  formAction: string;
+};
+
+export function ConfigureErrorAlerts({
+  emails: existingEmails,
+  webhooks: existingWebhooks,
+  slackChannel: existingSlackChannel,
+  slack,
+  emailAlertsEnabled,
+  connectToSlackHref,
+  formAction,
+}: ConfigureErrorAlertsProps) {
+  const organization = useOrganization();
+  const fetcher = useFetcher<{ ok?: boolean }>();
+  const navigate = useNavigate();
+  const toast = useToast();
+  const location = useOptimisticLocation();
+  const isSubmitting = fetcher.state !== "idle";
+
+  const [selectedSlackChannelValue, setSelectedSlackChannelValue] = useState<string | undefined>(
+    existingSlackChannel
+      ? `${existingSlackChannel.channelId}/${existingSlackChannel.channelName}`
+      : undefined
+  );
+
+  const selectedSlackChannel =
+    slack.status === "READY"
+      ? slack.channels?.find((s) => selectedSlackChannelValue === `${s.id}/${s.name}`)
+      : undefined;
+
+  const closeHref = (() => {
+    const params = new URLSearchParams(location.search);
+    params.delete("alerts");
+    const qs = params.toString();
+    return qs ? `?${qs}` : location.pathname;
+  })();
+
+  const hasHandledSuccess = useRef(false);
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data?.ok && !hasHandledSuccess.current) {
+      hasHandledSuccess.current = true;
+      toast.success("Alert settings saved");
+      navigate(closeHref, { replace: true });
+    }
+  }, [fetcher.state, fetcher.data, closeHref, navigate, toast]);
+
+  const emailFieldValues = useRef<string[]>(
+    existingEmails.length > 0 ? [...existingEmails.map((e) => e.email), ""] : [""]
+  );
+
+  const webhookFieldValues = useRef<string[]>(
+    existingWebhooks.length > 0 ? [...existingWebhooks.map((w) => w.url), ""] : [""]
+  );
+
+  const [form, { emails, webhooks, slackChannel, slackIntegrationId }] = useForm({
+    id: "configure-error-alerts",
+    onValidate({ formData }) {
+      return parse(formData, { schema: ErrorAlertsFormSchema });
+    },
+    shouldRevalidate: "onSubmit",
+    defaultValue: {
+      emails: emailFieldValues.current,
+      webhooks: webhookFieldValues.current,
+    },
+  });
+
+  const emailFields = useFieldList(form.ref, emails);
+  const webhookFields = useFieldList(form.ref, webhooks);
+
+  return (
+    <div className="grid h-full grid-rows-[auto_1fr_auto] overflow-hidden">
+      <div className="flex items-center justify-between border-b border-grid-bright px-3 py-2">
+        <Header2 className="flex items-center gap-2">
+          <BellAlertIcon className="size-5 text-alerts" /> Configure alerts
+        </Header2>
+        <LinkButton
+          to={closeHref}
+          variant="minimal/small"
+          TrailingIcon={ExitIcon}
+          shortcut={{ key: "esc" }}
+          shortcutPosition="before-trailing-icon"
+          className="pl-1"
+        />
+      </div>
+
+      <fetcher.Form
+        method="post"
+        action={formAction}
+        {...form.props}
+        className="contents"
+      >
+        <div className="flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <Fieldset className="flex flex-col gap-4 p-4">
+            <div className="flex flex-col">
+              <Header3>Receive alerts when</Header3>
+              <UnorderedList variant="small/dimmed" className="mt-1">
+                <li>An error is seen for the first time</li>
+                <li>A resolved error re-occurs</li>
+                <li>An ignored error re-occurs based on settings you configured</li>
+              </UnorderedList>
+            </div>
+
+            {/* Email section */}
+            <div>
+              <Header3 className="mb-1">Email</Header3>
+              {emailAlertsEnabled ? (
+                <InputGroup>
+                  {emailFields.map((emailField, index) => (
+                    <Fragment key={emailField.key}>
+                      <Input
+                        {...conform.input(emailField, { type: "email" })}
+                        placeholder={index === 0 ? "Enter an email address" : "Add another email"}
+                        icon={EnvelopeIcon}
+                        onChange={(e) => {
+                          emailFieldValues.current[index] = e.target.value;
+                          if (
+                            emailFields.length === emailFieldValues.current.length &&
+                            emailFieldValues.current.every((v) => v !== "")
+                          ) {
+                            requestIntent(form.ref.current ?? undefined, list.append(emails.name));
+                          }
+                        }}
+                      />
+                      <FormError id={emailField.errorId}>{emailField.error}</FormError>
+                    </Fragment>
+                  ))}
+                </InputGroup>
+              ) : (
+                <Callout variant="warning">
+                  Email integration is not available. Please contact your organization
+                  administrator.
+                </Callout>
+              )}
+            </div>
+
+            {/* Slack section */}
+            <div>
+              <Header3 className="mb-1">Slack</Header3>
+
+              <InputGroup fullWidth>
+                {slack.status === "READY" ? (
+                  <>
+                    <Select
+                      name={slackChannel.name}
+                      placeholder={<span className="text-text-dimmed">Select a Slack channel</span>}
+                      heading="Filter channels…"
+                      defaultValue={selectedSlackChannelValue}
+                      dropdownIcon
+                      variant="tertiary/medium"
+                      items={slack.channels}
+                      setValue={(value) => {
+                        typeof value === "string" && setSelectedSlackChannelValue(value);
+                      }}
+                      filter={(channel, search) =>
+                        channel.name?.toLowerCase().includes(search.toLowerCase()) ?? false
+                      }
+                      text={(value) => {
+                        const channel = slack.channels.find((s) => value === `${s.id}/${s.name}`);
+                        if (!channel) return;
+                        return (
+                          <span className="text-text-bright">
+                            <SlackChannelTitle {...channel} />
+                          </span>
+                        );
+                      }}
+                    >
+                      {(matches) => (
+                        <>
+                          {matches?.map((channel) => (
+                            <SelectItem
+                              key={channel.id}
+                              value={`${channel.id}/${channel.name}`}
+                              className="text-text-bright"
+                            >
+                              <SlackChannelTitle {...channel} />
+                            </SelectItem>
+                          ))}
+                        </>
+                      )}
+                    </Select>
+                    {selectedSlackChannel && selectedSlackChannel.is_private && (
+                      <Callout
+                        variant="warning"
+                        className={cn("text-sm", variantClasses.warning.textColor)}
+                      >
+                        To receive alerts in the{" "}
+                        <InlineCode variant="extra-small">{selectedSlackChannel.name}</InlineCode>{" "}
+                        channel, you need to invite the @Trigger.dev Slack Bot. Go to the channel in
+                        Slack and type:{" "}
+                        <InlineCode variant="extra-small">/invite @Trigger.dev</InlineCode>.
+                      </Callout>
+                    )}
+                    <Hint>
+                      <TextLink to={organizationSlackIntegrationPath(organization)}>
+                        Manage Slack connection
+                      </TextLink>
+                    </Hint>
+                    <input
+                      type="hidden"
+                      name={slackIntegrationId.name}
+                      value={slack.integrationId}
+                    />
+                  </>
+                ) : slack.status === "NOT_CONFIGURED" ? (
+                  connectToSlackHref ? (
+                    <LinkButton variant="tertiary/medium" to={connectToSlackHref} fullWidth>
+                      <span className="flex items-center gap-2 text-text-bright">
+                        <SlackIcon className="size-5" /> Connect to Slack
+                      </span>
+                    </LinkButton>
+                  ) : (
+                    <Callout variant="info">
+                      Slack is not connected. Connect Slack from the{" "}
+                      <span className="font-medium text-text-bright">Alerts</span> page to enable
+                      Slack notifications.
+                    </Callout>
+                  )
+                ) : slack.status === "TOKEN_REVOKED" || slack.status === "TOKEN_EXPIRED" ? (
+                  connectToSlackHref ? (
+                    <div className="flex flex-col gap-4">
+                      <Callout variant="info">
+                        The Slack integration in your workspace has been revoked or has expired.
+                        Please re-connect your Slack workspace.
+                      </Callout>
+                      <LinkButton
+                        variant="tertiary/large"
+                        to={`${connectToSlackHref}?reinstall=true`}
+                        fullWidth
+                      >
+                        <span className="flex items-center gap-2 text-text-bright">
+                          <SlackIcon className="size-5" /> Connect to Slack
+                        </span>
+                      </LinkButton>
+                    </div>
+                  ) : (
+                    <Callout variant="info">
+                      The Slack integration in your workspace has been revoked or expired. Please
+                      re-connect from the{" "}
+                      <span className="font-medium text-text-bright">Alerts</span> page.
+                    </Callout>
+                  )
+                ) : slack.status === "FAILED_FETCHING_CHANNELS" ? (
+                  <Callout variant="warning">
+                    Failed loading channels from Slack. Please try again later.
+                  </Callout>
+                ) : (
+                  <Callout variant="warning">
+                    Slack integration is not available. Please contact your organization
+                    administrator.
+                  </Callout>
+                )}
+              </InputGroup>
+            </div>
+
+            {/* Webhook section */}
+            <div>
+              <Header3 className="mb-1">Webhook</Header3>
+              <InputGroup>
+                {webhookFields.map((webhookField, index) => (
+                  <Fragment key={webhookField.key}>
+                    <Input
+                      {...conform.input(webhookField, { type: "url" })}
+                      placeholder={
+                        index === 0 ? "https://example.com/webhook" : "Add another webhook URL"
+                      }
+                      icon={GlobeAltIcon}
+                      onChange={(e) => {
+                        webhookFieldValues.current[index] = e.target.value;
+                        if (
+                          webhookFields.length === webhookFieldValues.current.length &&
+                          webhookFieldValues.current.every((v) => v !== "")
+                        ) {
+                          requestIntent(form.ref.current ?? undefined, list.append(webhooks.name));
+                        }
+                      }}
+                    />
+                    <FormError id={webhookField.errorId}>{webhookField.error}</FormError>
+                  </Fragment>
+                ))}
+                <Hint>We'll issue POST requests to these URLs with a JSON payload.</Hint>
+              </InputGroup>
+            </div>
+
+            <FormError>{form.error}</FormError>
+          </Fieldset>
+        </div>
+
+        <div className="flex items-center justify-between border-t border-grid-bright px-3 py-3">
+          <LinkButton variant="secondary/medium" to={closeHref}>
+            Cancel
+          </LinkButton>
+          <Button
+            variant="primary/medium"
+            type="submit"
+            disabled={isSubmitting}
+            isLoading={isSubmitting}
+          >
+            {isSubmitting ? "Saving…" : "Save"}
+          </Button>
+        </div>
+      </fetcher.Form>
+    </div>
+  );
+}
+
+function SlackChannelTitle({ name, is_private }: { name?: string; is_private?: boolean }) {
+  return (
+    <div className="flex items-center gap-1.5">
+      {is_private ? <LockClosedIcon className="size-4" /> : <HashtagIcon className="size-4" />}
+      <span>{name}</span>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/errors/ErrorStatusBadge.tsx b/apps/webapp/app/components/errors/ErrorStatusBadge.tsx
new file mode 100644
index 00000000000..571a209ddf1
--- /dev/null
+++ b/apps/webapp/app/components/errors/ErrorStatusBadge.tsx
@@ -0,0 +1,34 @@
+import { type ErrorGroupStatus } from "@trigger.dev/database";
+import { cn } from "~/utils/cn";
+
+const styles: Record<ErrorGroupStatus, string> = {
+  UNRESOLVED: "bg-error/10 text-error",
+  RESOLVED: "bg-success/10 text-success",
+  IGNORED: "bg-blue-500/10 text-blue-400",
+};
+
+const labels: Record<ErrorGroupStatus, string> = {
+  UNRESOLVED: "Unresolved",
+  RESOLVED: "Resolved",
+  IGNORED: "Ignored",
+};
+
+export function ErrorStatusBadge({
+  status,
+  className,
+}: {
+  status: ErrorGroupStatus;
+  className?: string;
+}) {
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center rounded px-2 py-0.5 text-xs font-medium",
+        styles[status],
+        className
+      )}
+    >
+      {labels[status]}
+    </span>
+  );
+}
diff --git a/apps/webapp/app/components/errors/ErrorStatusMenu.tsx b/apps/webapp/app/components/errors/ErrorStatusMenu.tsx
new file mode 100644
index 00000000000..a981c8eee52
--- /dev/null
+++ b/apps/webapp/app/components/errors/ErrorStatusMenu.tsx
@@ -0,0 +1,250 @@
+import { CheckIcon } from "@heroicons/react/20/solid";
+import {
+  IconAlarmSnooze as IconAlarmSnoozeBase,
+  IconArrowBackUp as IconArrowBackUpBase,
+  IconBugOff as IconBugOffBase,
+} from "@tabler/icons-react";
+import { useEffect, useRef, useState } from "react";
+import { type ErrorGroupStatus } from "@trigger.dev/database";
+import { useFetcher } from "@remix-run/react";
+import { Button } from "~/components/primitives/Buttons";
+import { useToast } from "~/components/primitives/Toast";
+import { FormError } from "~/components/primitives/FormError";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { PopoverMenuItem } from "~/components/primitives/Popover";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "~/components/primitives/Dialog";
+
+const AlarmSnoozeIcon = ({ className }: { className?: string }) => (
+  <IconAlarmSnoozeBase className={className} size={18} />
+);
+const ArrowBackUpIcon = ({ className }: { className?: string }) => (
+  <IconArrowBackUpBase className={className} size={18} />
+);
+const BugOffIcon = ({ className }: { className?: string }) => (
+  <IconBugOffBase className={className} size={18} />
+);
+
+export function statusActionToastMessage(data: Record<string, string>): string {
+  switch (data.action) {
+    case "resolve":
+      return "Error marked as resolved";
+    case "unresolve":
+      return "Error marked as unresolved";
+    case "ignore": {
+      const duration = data.duration ? Number(data.duration) : undefined;
+      if (!duration) return "Error ignored indefinitely";
+      const hours = duration / (60 * 60 * 1000);
+      if (hours < 24) return `Error ignored for ${hours} ${hours === 1 ? "hour" : "hours"}`;
+      const days = hours / 24;
+      return `Error ignored for ${days} ${days === 1 ? "day" : "days"}`;
+    }
+    default:
+      return "Error status updated";
+  }
+}
+
+export function ErrorStatusMenuItems({
+  status,
+  taskIdentifier,
+  onAction,
+  onCustomIgnore,
+}: {
+  status: ErrorGroupStatus;
+  taskIdentifier: string;
+  onAction: (data: Record<string, string>) => void;
+  onCustomIgnore: () => void;
+}) {
+  return (
+    <>
+      {status === "UNRESOLVED" && (
+        <>
+          <PopoverMenuItem
+            icon={CheckIcon}
+            leadingIconClassName="text-success"
+            title="Resolved"
+            onClick={() => onAction({ taskIdentifier, action: "resolve" })}
+          />
+          <PopoverMenuItem
+            icon={AlarmSnoozeIcon}
+            leadingIconClassName="text-blue-500"
+            title="Ignored for 1 hour"
+            onClick={() =>
+              onAction({
+                taskIdentifier,
+                action: "ignore",
+                duration: String(60 * 60 * 1000),
+              })
+            }
+          />
+          <PopoverMenuItem
+            icon={AlarmSnoozeIcon}
+            leadingIconClassName="text-blue-500"
+            title="Ignored for 24 hours"
+            onClick={() =>
+              onAction({
+                taskIdentifier,
+                action: "ignore",
+                duration: String(24 * 60 * 60 * 1000),
+              })
+            }
+          />
+          <PopoverMenuItem
+            icon={BugOffIcon}
+            leadingIconClassName="text-blue-500"
+            title="Ignored forever"
+            onClick={() => onAction({ taskIdentifier, action: "ignore" })}
+          />
+          <PopoverMenuItem
+            icon={AlarmSnoozeIcon}
+            leadingIconClassName="text-blue-500"
+            title="Ignored with custom condition…"
+            onClick={onCustomIgnore}
+          />
+        </>
+      )}
+
+      {status === "IGNORED" && (
+        <>
+          <PopoverMenuItem
+            icon={CheckIcon}
+            leadingIconClassName="text-success"
+            title="Resolved"
+            onClick={() => onAction({ taskIdentifier, action: "resolve" })}
+          />
+          <PopoverMenuItem
+            icon={ArrowBackUpIcon}
+            leadingIconClassName="text-error"
+            title="Unresolved"
+            onClick={() => onAction({ taskIdentifier, action: "unresolve" })}
+          />
+        </>
+      )}
+
+      {status === "RESOLVED" && (
+        <PopoverMenuItem
+          icon={ArrowBackUpIcon}
+          leadingIconClassName="text-error"
+          title="Unresolved"
+          onClick={() => onAction({ taskIdentifier, action: "unresolve" })}
+        />
+      )}
+    </>
+  );
+}
+
+export function CustomIgnoreDialog({
+  open,
+  onOpenChange,
+  taskIdentifier,
+  formAction,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  taskIdentifier: string;
+  formAction?: string;
+}) {
+  const fetcher = useFetcher<{ ok?: boolean }>();
+  const isSubmitting = fetcher.state !== "idle";
+  const [conditionError, setConditionError] = useState<string | null>(null);
+  const toast = useToast();
+  const hasHandledSuccess = useRef(false);
+
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data?.ok && !hasHandledSuccess.current) {
+      hasHandledSuccess.current = true;
+      toast.success("Error ignored with custom condition");
+      onOpenChange(false);
+    }
+  }, [fetcher.state, fetcher.data, onOpenChange, toast]);
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-1.5">
+            <IconAlarmSnoozeBase className="-ml-1.5 size-6 text-blue-500" />
+            Custom ignore condition
+          </DialogTitle>
+        </DialogHeader>
+        <fetcher.Form
+          method="post"
+          action={formAction}
+          onSubmit={(e) => {
+            e.preventDefault();
+            const formData = new FormData(e.currentTarget);
+            const rate = formData.get("occurrenceRate")?.toString().trim();
+            const total = formData.get("totalOccurrences")?.toString().trim();
+
+            if (!rate && !total) {
+              setConditionError("At least one unignore condition is required");
+              return;
+            }
+
+            setConditionError(null);
+            hasHandledSuccess.current = false;
+            fetcher.submit(e.currentTarget, { method: "post", action: formAction });
+          }}
+        >
+          <input type="hidden" name="action" value="ignore" />
+          <input type="hidden" name="taskIdentifier" value={taskIdentifier} />
+
+          <div className="flex flex-col gap-4 py-4">
+            <InputGroup fullWidth>
+              <Label htmlFor="occurrenceRate" variant="small">
+                Unignore when occurrence rate exceeds (per minute)
+              </Label>
+              <Input
+                id="occurrenceRate"
+                name="occurrenceRate"
+                type="number"
+                min={1}
+                placeholder="e.g. 10"
+                onChange={() => conditionError && setConditionError(null)}
+              />
+            </InputGroup>
+
+            <InputGroup fullWidth>
+              <Label htmlFor="totalOccurrences" variant="small">
+                Unignore when total occurrences exceed
+              </Label>
+              <Input
+                id="totalOccurrences"
+                name="totalOccurrences"
+                type="number"
+                min={1}
+                placeholder="e.g. 100"
+                onChange={() => conditionError && setConditionError(null)}
+              />
+            </InputGroup>
+
+            {conditionError && <FormError>{conditionError}</FormError>}
+
+            <InputGroup fullWidth>
+              <Label htmlFor="reason" variant="small" required={false}>
+                Reason
+              </Label>
+              <Input id="reason" name="reason" type="text" placeholder="e.g. Known flaky test" />
+            </InputGroup>
+          </div>
+
+          <DialogFooter>
+            <Button variant="tertiary/medium" type="button" onClick={() => onOpenChange(false)}>
+              Cancel
+            </Button>
+            <Button variant="primary/medium" type="submit" disabled={isSubmitting}>
+              {isSubmitting ? "Ignoring…" : "Ignore error"}
+            </Button>
+          </DialogFooter>
+        </fetcher.Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/components/integrations/VercelBuildSettings.tsx b/apps/webapp/app/components/integrations/VercelBuildSettings.tsx
new file mode 100644
index 00000000000..3a2da69d7ee
--- /dev/null
+++ b/apps/webapp/app/components/integrations/VercelBuildSettings.tsx
@@ -0,0 +1,207 @@
+import { Switch } from "~/components/primitives/Switch";
+import { Label } from "~/components/primitives/Label";
+import { Hint } from "~/components/primitives/Hint";
+import { TextLink } from "~/components/primitives/TextLink";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import {
+  EnvironmentIcon,
+  environmentFullTitle,
+  environmentTextClassName,
+} from "~/components/environments/EnvironmentLabel";
+import { envSlugToType, type EnvSlug } from "~/v3/vercel/vercelProjectIntegrationSchema";
+
+type BuildSettingsFieldsProps = {
+  availableEnvSlugs: EnvSlug[];
+  pullEnvVarsBeforeBuild: EnvSlug[];
+  onPullEnvVarsChange: (slugs: EnvSlug[]) => void;
+  discoverEnvVars: EnvSlug[];
+  onDiscoverEnvVarsChange: (slugs: EnvSlug[]) => void;
+  atomicBuilds: EnvSlug[];
+  onAtomicBuildsChange: (slugs: EnvSlug[]) => void;
+  envVarsConfigLink?: string;
+  /** Slugs that should be forced off and disabled, with tooltip reason. */
+  disabledEnvSlugs?: Partial<Record<EnvSlug, string>>;
+};
+
+export function BuildSettingsFields({
+  availableEnvSlugs,
+  pullEnvVarsBeforeBuild,
+  onPullEnvVarsChange,
+  discoverEnvVars,
+  onDiscoverEnvVarsChange,
+  atomicBuilds,
+  onAtomicBuildsChange,
+  envVarsConfigLink,
+  disabledEnvSlugs,
+}: BuildSettingsFieldsProps) {
+  const isSlugDisabled = (slug: EnvSlug) => !!disabledEnvSlugs?.[slug];
+  const enabledSlugs = availableEnvSlugs.filter((s) => !isSlugDisabled(s));
+
+  return (
+    <>
+      {/* Pull env vars before build */}
+      <div>
+        <div className="mb-2">
+          <div className="flex items-center justify-between">
+            <Label>Pull env vars before build</Label>
+            {availableEnvSlugs.length > 1 && (
+              <Switch
+                variant="small"
+                checked={
+                  enabledSlugs.length > 0 &&
+                  enabledSlugs.every((s) => pullEnvVarsBeforeBuild.includes(s))
+                }
+                onCheckedChange={(checked) => {
+                  onPullEnvVarsChange(checked ? [...enabledSlugs] : []);
+                }}
+              />
+            )}
+          </div>
+          <Hint className="pr-6">
+            Select which environments should pull environment variables from Vercel before each
+            build.{" "}
+            {envVarsConfigLink && (
+              <>
+                <TextLink to={envVarsConfigLink}>Configure which variables to pull</TextLink>.
+              </>
+            )}
+          </Hint>
+        </div>
+        <div className="flex flex-col gap-2 rounded border bg-charcoal-800 p-3">
+          {availableEnvSlugs.map((slug) => {
+            const envType = envSlugToType(slug);
+            const disabled = isSlugDisabled(slug);
+            const disabledReason = disabledEnvSlugs?.[slug];
+            const row = (
+              <div
+                key={slug}
+                className={`flex items-center justify-between ${disabled ? "opacity-50" : ""}`}
+              >
+                <div className="flex items-center gap-1.5">
+                  <EnvironmentIcon environment={{ type: envType }} className="size-4" />
+                  <span className={`text-sm ${environmentTextClassName({ type: envType })}`}>
+                    {environmentFullTitle({ type: envType })}
+                  </span>
+                </div>
+                <Switch
+                  variant="small"
+                  checked={disabled ? false : pullEnvVarsBeforeBuild.includes(slug)}
+                  disabled={disabled}
+                  onCheckedChange={(checked) => {
+                    onPullEnvVarsChange(
+                      checked
+                        ? [...pullEnvVarsBeforeBuild, slug]
+                        : pullEnvVarsBeforeBuild.filter((s) => s !== slug)
+                    );
+                  }}
+                />
+              </div>
+            );
+            if (disabled && disabledReason) {
+              return (
+                <SimpleTooltip key={slug} button={row} content={disabledReason} side="left" />
+              );
+            }
+            return row;
+          })}
+        </div>
+      </div>
+
+      {/* Discover new env vars */}
+      <div>
+        <div className="mb-2">
+          <div className="flex items-center justify-between">
+            <Label>Discover new env vars</Label>
+            {availableEnvSlugs.length > 1 && (
+              <Switch
+                variant="small"
+                checked={
+                  enabledSlugs.length > 0 &&
+                  enabledSlugs.every(
+                    (s) => discoverEnvVars.includes(s) || !pullEnvVarsBeforeBuild.includes(s)
+                  ) &&
+                  enabledSlugs.some((s) => discoverEnvVars.includes(s))
+                }
+                disabled={!enabledSlugs.some((s) => pullEnvVarsBeforeBuild.includes(s))}
+                onCheckedChange={(checked) => {
+                  onDiscoverEnvVarsChange(
+                    checked
+                      ? enabledSlugs.filter((s) => pullEnvVarsBeforeBuild.includes(s))
+                      : []
+                  );
+                }}
+              />
+            )}
+          </div>
+          <Hint className="pr-6">
+            Select which environments should automatically discover and create new environment
+            variables from Vercel during builds.
+          </Hint>
+        </div>
+        <div className="flex flex-col gap-2 rounded border bg-charcoal-800 p-3">
+          {availableEnvSlugs.map((slug) => {
+            const envType = envSlugToType(slug);
+            const disabled = isSlugDisabled(slug);
+            const disabledReason = disabledEnvSlugs?.[slug];
+            const isPullDisabled = !pullEnvVarsBeforeBuild.includes(slug);
+            const row = (
+              <div
+                key={slug}
+                className={`flex items-center justify-between ${disabled || isPullDisabled ? "opacity-50" : ""}`}
+              >
+                <div className="flex items-center gap-1.5">
+                  <EnvironmentIcon environment={{ type: envType }} className="size-4" />
+                  <span className={`text-sm ${environmentTextClassName({ type: envType })}`}>
+                    {environmentFullTitle({ type: envType })}
+                  </span>
+                </div>
+                <Switch
+                  variant="small"
+                  checked={disabled ? false : discoverEnvVars.includes(slug)}
+                  disabled={disabled || isPullDisabled}
+                  onCheckedChange={(checked) => {
+                    onDiscoverEnvVarsChange(
+                      checked
+                        ? [...discoverEnvVars, slug]
+                        : discoverEnvVars.filter((s) => s !== slug)
+                    );
+                  }}
+                />
+              </div>
+            );
+            if (disabled && disabledReason) {
+              return (
+                <SimpleTooltip key={slug} button={row} content={disabledReason} side="left" />
+              );
+            }
+            return row;
+          })}
+        </div>
+      </div>
+
+      {/* Atomic deployments */}
+      <div>
+        <div className="flex items-center justify-between">
+          <Label>Atomic deployments</Label>
+          <Switch
+            variant="small"
+            checked={atomicBuilds.includes("prod")}
+            onCheckedChange={(checked) => {
+              onAtomicBuildsChange(checked ? ["prod"] : []);
+            }}
+          />
+        </div>
+        <Hint className="pr-6">
+          When enabled, production deployments wait for Vercel deployment to complete before
+          promoting the Trigger.dev deployment. This will disable the "Auto-assign Custom
+          Production Domains" option in your Vercel project settings to perform staged
+          deployments.{" "}
+          <TextLink href="https://trigger.dev/docs/vercel-integration#atomic-deployments" target="_blank">
+            Learn more
+          </TextLink>
+          .
+        </Hint>
+      </div>
+    </>
+  );
+}
diff --git a/apps/webapp/app/components/integrations/VercelLink.tsx b/apps/webapp/app/components/integrations/VercelLink.tsx
new file mode 100644
index 00000000000..4a74e599f3d
--- /dev/null
+++ b/apps/webapp/app/components/integrations/VercelLink.tsx
@@ -0,0 +1,22 @@
+import { VercelLogo } from "./VercelLogo";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+
+export function VercelLink({ vercelDeploymentUrl }: { vercelDeploymentUrl: string }) {
+  return (
+    <SimpleTooltip
+      button={
+        <LinkButton
+          variant="minimal/small"
+          LeadingIcon={<VercelLogo className="size-3.5" />}
+          iconSpacing="gap-x-1"
+          to={vercelDeploymentUrl}
+          className="pl-1"
+        >
+          Vercel
+        </LinkButton>
+      }
+      content="View on Vercel"
+    />
+  );
+}
diff --git a/apps/webapp/app/components/integrations/VercelLogo.tsx b/apps/webapp/app/components/integrations/VercelLogo.tsx
new file mode 100644
index 00000000000..7ddf039abfd
--- /dev/null
+++ b/apps/webapp/app/components/integrations/VercelLogo.tsx
@@ -0,0 +1,12 @@
+export function VercelLogo({ className }: { className?: string }) {
+  return (
+    <svg
+      viewBox="0 0 76 65"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      className={className}
+    >
+      <path d="M37.5274 0L75.0548 65H0L37.5274 0Z" fill="currentColor" />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/components/integrations/VercelOnboardingModal.tsx b/apps/webapp/app/components/integrations/VercelOnboardingModal.tsx
new file mode 100644
index 00000000000..7ff99d7d448
--- /dev/null
+++ b/apps/webapp/app/components/integrations/VercelOnboardingModal.tsx
@@ -0,0 +1,1186 @@
+import {
+  CheckCircleIcon,
+  ExclamationTriangleIcon,
+  ChevronDownIcon,
+  ChevronUpIcon,
+} from "@heroicons/react/20/solid";
+import {
+  useFetcher,
+  useNavigation,
+  useSearchParams,
+} from "@remix-run/react";
+import { useTypedFetcher } from "remix-typedjson";
+import { Dialog, DialogContent, DialogHeader } from "~/components/primitives/Dialog";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
+import { Header3 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import { Label } from "~/components/primitives/Label";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
+import { Switch } from "~/components/primitives/Switch";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+  TooltipProvider,
+} from "~/components/primitives/Tooltip";
+import { VercelLogo } from "~/components/integrations/VercelLogo";
+import { BuildSettingsFields } from "~/components/integrations/VercelBuildSettings";
+import { OctoKitty } from "~/components/GitHubLoginButton";
+import {
+  ConnectGitHubRepoModal,
+} from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
+import {
+  type SyncEnvVarsMapping,
+  type EnvSlug,
+  ALL_ENV_SLUGS,
+  shouldSyncEnvVarForAnyEnvironment,
+  getAvailableEnvSlugs,
+  getAvailableEnvSlugsForBuildSettings,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+import { type VercelCustomEnvironment } from "~/models/vercelIntegration.server";
+import { type VercelOnboardingData } from "~/presenters/v3/VercelSettingsPresenter.server";
+import { vercelAppInstallPath, v3ProjectSettingsIntegrationsPath, githubAppInstallPath, vercelResourcePath } from "~/utils/pathBuilder";
+import type { loader } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel";
+import { useEffect, useState, useCallback, useRef } from "react";
+import { usePostHogTracking } from "~/hooks/usePostHog";
+import { TextLink } from "../primitives/TextLink";
+
+function safeRedirectUrl(url: string): string | null {
+  try {
+    const parsed = new URL(url, window.location.origin);
+    if (parsed.origin === window.location.origin) {
+      return parsed.toString();
+    }
+    if (parsed.protocol === "https:" && /^([a-z0-9-]+\.)*vercel\.com$/i.test(parsed.hostname)) {
+      return parsed.toString();
+    }
+  } catch {
+    // Invalid URL
+  }
+  return null;
+}
+
+function formatVercelTargets(targets: string[]): string {
+  const targetLabels: Record<string, string> = {
+    production: "Production",
+    preview: "Preview",
+    development: "Development",
+    staging: "Staging",
+  };
+
+  return targets
+    .map((t) => targetLabels[t.toLowerCase()] || t)
+    .join(", ");
+}
+
+type OnboardingState =
+  | "idle"
+  | "installing"
+  | "loading-projects"
+  | "project-selection"
+  | "loading-env-mapping"
+  | "env-mapping"
+  | "loading-env-vars"
+  | "env-var-sync"
+  | "build-settings"
+  | "github-connection"
+  | "completed";
+
+export function VercelOnboardingModal({
+  isOpen,
+  onClose,
+  onboardingData,
+  organizationSlug,
+  projectSlug,
+  environmentSlug,
+  hasStagingEnvironment,
+  hasPreviewEnvironment,
+  hasOrgIntegration,
+  nextUrl,
+  onDataReload,
+  vercelManageAccessUrl,
+}: {
+  isOpen: boolean;
+  onClose: () => void;
+  onboardingData: VercelOnboardingData | null;
+  organizationSlug: string;
+  projectSlug: string;
+  environmentSlug: string;
+  hasStagingEnvironment: boolean;
+  hasPreviewEnvironment: boolean;
+  hasOrgIntegration: boolean;
+  nextUrl?: string;
+  onDataReload?: (vercelStagingEnvironment?: string) => void;
+  vercelManageAccessUrl?: string;
+}) {
+  const { capture, startSessionRecording } = usePostHogTracking();
+  const navigation = useNavigation();
+  const fetcher = useTypedFetcher<typeof loader>();
+  const envMappingFetcher = useFetcher();
+  const completeOnboardingFetcher = useFetcher();
+  const { Form: CompleteOnboardingForm } = completeOnboardingFetcher;
+  const [searchParams] = useSearchParams();
+  const origin = searchParams.get("origin");
+  const fromMarketplaceContext = origin === "marketplace";
+
+  const availableProjects = onboardingData?.availableProjects || [];
+  const hasProjectSelected = onboardingData?.hasProjectSelected ?? false;
+  const customEnvironments = onboardingData?.customEnvironments || [];
+  const envVars = onboardingData?.environmentVariables || [];
+  const existingVars = onboardingData?.existingVariables || {};
+  const hasCustomEnvs = customEnvironments.length > 0 && hasStagingEnvironment;
+
+  const computeInitialState = useCallback((): OnboardingState => {
+    if (!hasOrgIntegration || onboardingData?.authInvalid) {
+      return "idle";
+    }
+    const projectSelected = onboardingData?.hasProjectSelected ?? false;
+    if (!projectSelected) {
+      if (!onboardingData?.availableProjects || onboardingData.availableProjects.length === 0) {
+        return "loading-projects";
+      }
+      return "project-selection";
+    }
+    // If onboarding was already completed but GitHub is not connected,
+    // go directly to the github-connection step (e.g., returning from GitHub App installation)
+    if (onboardingData?.isOnboardingComplete && !onboardingData?.isGitHubConnected) {
+      return "github-connection";
+    }
+    // For marketplace origin, skip env-mapping step and go directly to env-var-sync
+    if (!fromMarketplaceContext) {
+      const customEnvs = (onboardingData?.customEnvironments?.length ?? 0) > 0 && hasStagingEnvironment;
+      if (customEnvs) {
+        return "env-mapping";
+      }
+    }
+    if (!onboardingData?.environmentVariables || onboardingData.environmentVariables.length === 0) {
+      return "loading-env-vars";
+    }
+    return "env-var-sync";
+  }, [hasOrgIntegration, onboardingData, hasStagingEnvironment, fromMarketplaceContext]);
+
+  const [state, setState] = useState<OnboardingState>(() => {
+    if (!isOpen) return "idle";
+    return computeInitialState();
+  });
+
+  const prevIsOpenRef = useRef(isOpen);
+  const hasSyncedStagingRef = useRef(false);
+  const hasSyncedPreviewRef = useRef(false);
+  useEffect(() => {
+    if (isOpen && !prevIsOpenRef.current) {
+      setState(computeInitialState());
+      hasSyncedStagingRef.current = false;
+      hasSyncedPreviewRef.current = false;
+    } else if (isOpen && state === "idle") {
+      setState(computeInitialState());
+    }
+    prevIsOpenRef.current = isOpen;
+  }, [isOpen, state, computeInitialState]);
+
+  const trackOnboarding = useCallback(
+    (eventName: string, extraProperties?: Record<string, unknown>) => {
+      capture(eventName, {
+        origin: fromMarketplaceContext ? "marketplace" : "dashboard",
+        step: state,
+        organization_slug: organizationSlug,
+        project_slug: projectSlug,
+        ...extraProperties,
+      });
+    },
+    [capture, fromMarketplaceContext, state, organizationSlug, projectSlug]
+  );
+
+  const hasTrackedStartRef = useRef(false);
+  const hasTrackedCompletionRef = useRef(false);
+  useEffect(() => {
+    if (isOpen && state === "project-selection" && !hasTrackedStartRef.current) {
+      hasTrackedStartRef.current = true;
+      startSessionRecording();
+      trackOnboarding("vercel onboarding started");
+    }
+    if (!isOpen) {
+      hasTrackedStartRef.current = false;
+      hasTrackedCompletionRef.current = false;
+    }
+  }, [isOpen, state, trackOnboarding, startSessionRecording]);
+
+  const [selectedVercelProject, setSelectedVercelProject] = useState<{
+    id: string;
+    name: string;
+  } | null>(null);
+  const [vercelStagingEnvironment, setVercelStagingEnvironment] = useState<{
+    environmentId: string;
+    displayName: string;
+  } | null>(null);
+  const availableEnvSlugsForOnboarding = getAvailableEnvSlugs(hasStagingEnvironment, hasPreviewEnvironment);
+  const availableEnvSlugsForOnboardingBuildSettings = getAvailableEnvSlugsForBuildSettings(hasStagingEnvironment, hasPreviewEnvironment);
+  const [pullEnvVarsBeforeBuild, setPullEnvVarsBeforeBuild] = useState<EnvSlug[]>(
+    () => availableEnvSlugsForOnboardingBuildSettings
+  );
+  const [atomicBuilds, setAtomicBuilds] = useState<EnvSlug[]>(
+    () => ["prod"]
+  );
+  const [discoverEnvVars, setDiscoverEnvVars] = useState<EnvSlug[]>(
+    () => availableEnvSlugsForOnboardingBuildSettings
+  );
+
+  // Sync pullEnvVarsBeforeBuild and discoverEnvVars when hasStagingEnvironment becomes true
+  // AND a custom Vercel environment is mapped (once)
+  useEffect(() => {
+    if (hasStagingEnvironment && vercelStagingEnvironment && !hasSyncedStagingRef.current) {
+      hasSyncedStagingRef.current = true;
+      setPullEnvVarsBeforeBuild((prev) => {
+        if (!prev.includes("stg")) {
+          return [...prev, "stg"];
+        }
+        return prev;
+      });
+      setDiscoverEnvVars((prev) => {
+        if (!prev.includes("stg")) {
+          return [...prev, "stg"];
+        }
+        return prev;
+      });
+    }
+  }, [hasStagingEnvironment, vercelStagingEnvironment]);
+
+  // Strip "stg" from build settings when the staging environment mapping is cleared
+  useEffect(() => {
+    if (!vercelStagingEnvironment) {
+      setPullEnvVarsBeforeBuild((prev) => prev.filter((s) => s !== "stg"));
+      setDiscoverEnvVars((prev) => prev.filter((s) => s !== "stg"));
+    }
+  }, [vercelStagingEnvironment]);
+
+  // Sync pullEnvVarsBeforeBuild and discoverEnvVars when hasPreviewEnvironment becomes true (once)
+  useEffect(() => {
+    if (hasPreviewEnvironment && !hasSyncedPreviewRef.current) {
+      hasSyncedPreviewRef.current = true;
+      setPullEnvVarsBeforeBuild((prev) => {
+        if (!prev.includes("preview")) {
+          return [...prev, "preview"];
+        }
+        return prev;
+      });
+      setDiscoverEnvVars((prev) => {
+        if (!prev.includes("preview")) {
+          return [...prev, "preview"];
+        }
+        return prev;
+      });
+    }
+  }, [hasPreviewEnvironment]);
+  const [syncEnvVarsMapping, setSyncEnvVarsMapping] = useState<SyncEnvVarsMapping>({});
+  const [expandedEnvVars, setExpandedEnvVars] = useState(false);
+  const [expandedSecretEnvVars, setExpandedSecretEnvVars] = useState(false);
+  const [projectSelectionError, setProjectSelectionError] = useState<string | null>(null);
+  const [isRedirecting, setIsRedirecting] = useState(false);
+
+  const gitHubAppInstallations = onboardingData?.gitHubAppInstallations ?? [];
+  const isGitHubConnectedForOnboarding = onboardingData?.isGitHubConnected ?? false;
+  const isOnboardingComplete = onboardingData?.isOnboardingComplete ?? false;
+
+  const hasTriggeredMarketplaceRedirectRef = useRef(false);
+
+  // Auto-redirect for marketplace flow when returning from GitHub with everything complete
+  useEffect(() => {
+    if (hasTriggeredMarketplaceRedirectRef.current) {
+      return;
+    }
+
+    if (
+      isOpen &&
+      fromMarketplaceContext &&
+      nextUrl &&
+      isOnboardingComplete &&
+      isGitHubConnectedForOnboarding
+    ) {
+      hasTriggeredMarketplaceRedirectRef.current = true;
+      const validUrl = safeRedirectUrl(nextUrl);
+      if (validUrl) {
+        setTimeout(() => {
+          window.location.href = validUrl;
+        }, 100);
+      }
+    }
+  }, [isOpen, fromMarketplaceContext, nextUrl, isOnboardingComplete, isGitHubConnectedForOnboarding]);
+
+  useEffect(() => {
+    if (!isOpen) {
+      hasTriggeredMarketplaceRedirectRef.current = false;
+      setIsRedirecting(false);
+    }
+  }, [isOpen]);
+
+  const loadingStateRef = useRef<OnboardingState | null>(null);
+
+  useEffect(() => {
+    if (!isOpen || state === "idle") {
+      loadingStateRef.current = null;
+      return;
+    }
+
+    if (onboardingData?.authInvalid) {
+      onClose();
+      return;
+    }
+
+    if (loadingStateRef.current === state) {
+      return;
+    }
+
+    switch (state) {
+
+      case "loading-projects":
+        loadingStateRef.current = state;
+        if (onDataReload) {
+          onDataReload();
+        }
+        break;
+
+      case "loading-env-mapping":
+        loadingStateRef.current = state;
+        if (onDataReload) {
+          onDataReload();
+        }
+        break;
+
+      case "loading-env-vars":
+        loadingStateRef.current = state;
+        if (onDataReload) {
+          onDataReload(vercelStagingEnvironment?.environmentId || undefined);
+        }
+        break;
+
+      case "installing":
+      case "project-selection":
+      case "env-mapping":
+      case "env-var-sync":
+      case "completed":
+      case "build-settings":
+      case "github-connection":
+        loadingStateRef.current = null;
+        break;
+    }
+  }, [isOpen, state, onboardingData?.authInvalid, vercelStagingEnvironment, onDataReload, onClose]);
+
+  useEffect(() => {
+    if (!onboardingData?.authInvalid && state === "loading-projects" && onboardingData?.availableProjects !== undefined) {
+      setState("project-selection");
+    }
+  }, [state, onboardingData?.availableProjects, onboardingData?.authInvalid]);
+
+  useEffect(() => {
+    if (!onboardingData?.authInvalid && state === "loading-env-vars" && onboardingData?.environmentVariables) {
+      setState("env-var-sync");
+    }
+  }, [state, onboardingData?.environmentVariables, onboardingData?.authInvalid]);
+
+  useEffect(() => {
+    if (state === "project-selection" && fetcher.data && "success" in fetcher.data && fetcher.data.success && fetcher.state === "idle") {
+      trackOnboarding("vercel onboarding project selected", {
+        vercel_project_name: selectedVercelProject?.name,
+      });
+      setState("loading-env-mapping");
+      if (onDataReload) {
+        onDataReload();
+      }
+    } else if (fetcher.data && "error" in fetcher.data && typeof fetcher.data.error === "string") {
+      setProjectSelectionError(fetcher.data.error);
+    }
+  }, [state, fetcher.data, fetcher.state, onDataReload, trackOnboarding, selectedVercelProject?.name]);
+
+  // For marketplace origin, skip env-mapping step
+  useEffect(() => {
+    if (state === "loading-env-mapping" && onboardingData) {
+      const hasCustomEnvs = (onboardingData.customEnvironments?.length ?? 0) > 0 && hasStagingEnvironment;
+      if (hasCustomEnvs && !fromMarketplaceContext) {
+        setState("env-mapping");
+      } else {
+        setState("loading-env-vars");
+      }
+    }
+  }, [state, onboardingData, hasStagingEnvironment, fromMarketplaceContext]);
+
+  const secretEnvVars = envVars.filter((v) => v.isSecret);
+  const syncableEnvVars = envVars.filter((v) => !v.isSecret);
+  const enabledEnvVars = syncableEnvVars.filter(
+    (v) => shouldSyncEnvVarForAnyEnvironment(syncEnvVarsMapping, v.key)
+  );
+
+  const overlappingEnvVarsCount = enabledEnvVars.filter((v) => existingVars[v.key]).length;
+
+  const isSubmitting =
+    navigation.state === "submitting" || navigation.state === "loading";
+
+  const actionUrl = vercelResourcePath(organizationSlug, projectSlug, environmentSlug);
+
+  const handleToggleEnvVar = useCallback((key: string, enabled: boolean) => {
+    setSyncEnvVarsMapping((prev) => {
+      const newMapping = { ...prev };
+
+      if (enabled) {
+        for (const envSlug of ALL_ENV_SLUGS) {
+          if (newMapping[envSlug]) {
+            const { [key]: _, ...rest } = newMapping[envSlug];
+            if (Object.keys(rest).length === 0) {
+              delete newMapping[envSlug];
+            } else {
+              newMapping[envSlug] = rest;
+            }
+          }
+        }
+      } else {
+        for (const envSlug of ALL_ENV_SLUGS) {
+          newMapping[envSlug] = {
+            ...(newMapping[envSlug] || {}),
+            [key]: false,
+          };
+        }
+      }
+
+      return newMapping;
+    });
+  }, []);
+
+  const handleToggleAllEnvVars = useCallback(
+    (enabled: boolean, syncableVars: Array<{ key: string }>) => {
+      if (enabled) {
+        setSyncEnvVarsMapping({});
+      } else {
+        const newMapping: SyncEnvVarsMapping = {};
+        for (const envSlug of ALL_ENV_SLUGS) {
+          newMapping[envSlug] = {};
+          for (const v of syncableVars) {
+            newMapping[envSlug][v.key] = false;
+          }
+        }
+        setSyncEnvVarsMapping(newMapping);
+      }
+    },
+    []
+  );
+
+  const handleProjectSelection = useCallback(async () => {
+    if (!selectedVercelProject) {
+      setProjectSelectionError("Please select a Vercel project");
+      return;
+    }
+
+    setProjectSelectionError(null);
+
+    const formData = new FormData();
+    formData.append("action", "select-vercel-project");
+    formData.append("vercelProjectId", selectedVercelProject.id);
+    formData.append("vercelProjectName", selectedVercelProject.name);
+
+    fetcher.submit(formData, {
+      method: "post",
+      action: actionUrl,
+    });
+  }, [selectedVercelProject, fetcher, actionUrl]);
+
+  const handleSkipOnboarding = useCallback(() => {
+    onClose();
+
+    if (fromMarketplaceContext) {
+      return window.close();
+    }
+
+    const formData = new FormData();
+    formData.append("action", "skip-onboarding");
+    fetcher.submit(formData, {
+      method: "post",
+      action: actionUrl,
+    });
+  }, [actionUrl, fetcher, onClose, fromMarketplaceContext]);
+
+  const handleSkipEnvMapping = useCallback(() => {
+    trackOnboarding("vercel onboarding env mapping completed", {
+      skipped: true,
+      staging_environment: null,
+    });
+    setVercelStagingEnvironment(null);
+    setState("loading-env-vars");
+  }, [trackOnboarding]);
+
+  const handleUpdateEnvMapping = useCallback(() => {
+    trackOnboarding("vercel onboarding env mapping completed", {
+      skipped: false,
+      staging_environment: vercelStagingEnvironment?.displayName ?? null,
+    });
+
+    if (!vercelStagingEnvironment) {
+      setState("loading-env-vars");
+      return;
+    }
+
+    const formData = new FormData();
+    formData.append("action", "update-env-mapping");
+    formData.append("vercelStagingEnvironment", JSON.stringify(vercelStagingEnvironment));
+
+    envMappingFetcher.submit(formData, {
+      method: "post",
+      action: actionUrl,
+    });
+
+  }, [vercelStagingEnvironment, envMappingFetcher, actionUrl, trackOnboarding]);
+
+  const handleBuildSettingsNext = useCallback(() => {
+    trackOnboarding("vercel onboarding build settings completed");
+
+    if (nextUrl && fromMarketplaceContext && isGitHubConnectedForOnboarding) {
+      setIsRedirecting(true);
+    }
+
+    const formData = new FormData();
+    formData.append("action", "complete-onboarding");
+    formData.append("vercelStagingEnvironment", vercelStagingEnvironment ? JSON.stringify(vercelStagingEnvironment) : "");
+    formData.append("pullEnvVarsBeforeBuild", JSON.stringify(pullEnvVarsBeforeBuild));
+    formData.append("atomicBuilds", JSON.stringify(atomicBuilds));
+    formData.append("discoverEnvVars", JSON.stringify(discoverEnvVars));
+    formData.append("syncEnvVarsMapping", JSON.stringify(syncEnvVarsMapping));
+    if (fromMarketplaceContext) {
+      formData.append("origin", "marketplace");
+    }
+    if (nextUrl && fromMarketplaceContext && isGitHubConnectedForOnboarding) {
+      formData.append("next", nextUrl);
+    }
+
+    if (!isGitHubConnectedForOnboarding) {
+      formData.append("skipRedirect", "true");
+    }
+
+    completeOnboardingFetcher.submit(formData, {
+      method: "post",
+      action: actionUrl,
+    });
+
+    if (!isGitHubConnectedForOnboarding) {
+      setState("github-connection");
+      capture("vercel onboarding github step viewed", {
+        origin: fromMarketplaceContext ? "marketplace" : "dashboard",
+        step: "github-connection",
+        organization_slug: organizationSlug,
+        project_slug: projectSlug,
+        github_app_installed: gitHubAppInstallations.length > 0,
+      });
+    }
+  }, [vercelStagingEnvironment, pullEnvVarsBeforeBuild, atomicBuilds, discoverEnvVars, syncEnvVarsMapping, nextUrl, fromMarketplaceContext, isGitHubConnectedForOnboarding, completeOnboardingFetcher, actionUrl, trackOnboarding, capture, organizationSlug, projectSlug, gitHubAppInstallations.length]);
+
+  const handleFinishOnboarding = useCallback((e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    const form = e.currentTarget;
+    const formData = new FormData(form);
+    completeOnboardingFetcher.submit(formData, {
+      method: "post",
+      action: actionUrl,
+    });
+  }, [completeOnboardingFetcher, actionUrl]);
+
+  useEffect(() => {
+    if (completeOnboardingFetcher.data && typeof completeOnboardingFetcher.data === "object" && "success" in completeOnboardingFetcher.data && completeOnboardingFetcher.data.success && completeOnboardingFetcher.state === "idle") {
+      if (state === "github-connection") {
+        return;
+      }
+      if ("redirectTo" in completeOnboardingFetcher.data && typeof completeOnboardingFetcher.data.redirectTo === "string") {
+        const validRedirect = safeRedirectUrl(completeOnboardingFetcher.data.redirectTo);
+        if (validRedirect) {
+          window.location.href = validRedirect;
+        }
+        return;
+      }
+      setState("completed");
+    }
+  }, [completeOnboardingFetcher.data, completeOnboardingFetcher.state, state]);
+
+  useEffect(() => {
+    if (state === "completed" && !hasTrackedCompletionRef.current) {
+      hasTrackedCompletionRef.current = true;
+      trackOnboarding("vercel onboarding completed", {
+        github_connected: isGitHubConnectedForOnboarding,
+      });
+      onClose();
+    }
+  }, [state, onClose, trackOnboarding, isGitHubConnectedForOnboarding]);
+
+  useEffect(() => {
+    if (state === "installing") {
+      const installUrl = vercelAppInstallPath(organizationSlug, projectSlug);
+      window.location.href = installUrl;
+    }
+  }, [state, organizationSlug, projectSlug]);
+
+  useEffect(() => {
+    if (envMappingFetcher.data && typeof envMappingFetcher.data === "object" && "success" in envMappingFetcher.data && envMappingFetcher.data.success && envMappingFetcher.state === "idle") {
+      setState("loading-env-vars");
+    }
+  }, [envMappingFetcher.data, envMappingFetcher.state]);
+
+  useEffect(() => {
+    if (state === "env-mapping" && customEnvironments.length > 0 && !vercelStagingEnvironment) {
+      let selectedEnv: VercelCustomEnvironment;
+
+      if (customEnvironments.length === 1) {
+        selectedEnv = customEnvironments[0];
+      } else {
+        const stagingEnv = customEnvironments.find(
+          (env) => env.slug.toLowerCase() === "staging"
+        );
+        selectedEnv = stagingEnv ?? customEnvironments[0];
+      }
+
+      setVercelStagingEnvironment({ environmentId: selectedEnv.id, displayName: selectedEnv.slug });
+    }
+  }, [state, customEnvironments, vercelStagingEnvironment]);
+
+  useEffect(() => {
+    if (state === "project-selection" && availableProjects.length > 0 && !selectedVercelProject) {
+      setSelectedVercelProject(availableProjects[0]);
+    }
+  }, [state, availableProjects, selectedVercelProject]);
+
+  if (!isOpen || onboardingData?.authInvalid) {
+    return null;
+  }
+
+  const isLoadingState =
+    state === "loading-projects" ||
+    state === "loading-env-mapping" ||
+    state === "loading-env-vars" ||
+    state === "installing" ||
+    (state === "idle" && !onboardingData);
+
+  if (isLoadingState) {
+    return (
+      <Dialog open={isOpen} onOpenChange={(open) => {
+        if (!open && !fromMarketplaceContext) {
+          if (state as string !== "completed") {
+            trackOnboarding("vercel onboarding abandoned");
+          }
+          onClose();
+        }
+      }}>
+        <DialogContent className="max-w-lg" onInteractOutside={(e) => e.preventDefault()}>
+          <DialogHeader>
+            <div className="flex items-center gap-2">
+              <VercelLogo className="size-5" />
+              <span>Set up Vercel Integration</span>
+            </div>
+          </DialogHeader>
+          <div className="flex items-center justify-center py-8">
+            <SpinnerWhite className="size-6" />
+          </div>
+        </DialogContent>
+      </Dialog>
+    );
+  }
+
+  const showProjectSelection = state === "project-selection";
+  const showEnvMapping = state === "env-mapping";
+  const showEnvVarSync = state === "env-var-sync";
+  const showBuildSettings = state === "build-settings";
+  const showGitHubConnection = state === "github-connection";
+
+  const disabledEnvSlugsForBuildSettings =
+    hasStagingEnvironment && !vercelStagingEnvironment
+      ? ({ stg: "Map a custom Vercel environment to Staging to enable this" } as Partial<Record<EnvSlug, string>>)
+      : undefined;
+
+  return (
+    <Dialog open={isOpen} onOpenChange={(open) => {
+      if (!open && !fromMarketplaceContext) {
+        if (state !== "completed") {
+          trackOnboarding("vercel onboarding abandoned");
+        }
+        onClose();
+      }
+    }}>
+      <DialogContent className="max-w-lg" onInteractOutside={(e) => e.preventDefault()}>
+        <DialogHeader>
+          <div className="flex items-center gap-2">
+            <VercelLogo className="size-5" />
+            <span>Set up Vercel Integration</span>
+          </div>
+        </DialogHeader>
+
+        <div className="mt-4">
+          {showProjectSelection && (
+            <div className="flex flex-col gap-4">
+              <Header3>Select Vercel Project</Header3>
+              <Paragraph className="text-sm">
+                Choose which Vercel project to connect with this Trigger.dev project.
+                Your API keys will be automatically synced to Vercel.
+              </Paragraph>
+
+              {availableProjects.length === 0 ? (
+                <Callout variant="warning">
+                  No Vercel projects found. Please create a project in Vercel first.
+                </Callout>
+              ) : (
+                <Select
+                  disabled={availableProjects.length === 1}
+                  value={selectedVercelProject?.id || ""}
+                  setValue={(value) => {
+                    if (!Array.isArray(value)) {
+                      const project = availableProjects.find((p) => p.id === value);
+                      setSelectedVercelProject(project || null);
+                      setProjectSelectionError(null);
+                    }
+                  }}
+                  items={availableProjects}
+                  filter={availableProjects.length > 5 ? { keys: ["name"] } : undefined}
+                  variant="tertiary/medium"
+                  placeholder="Select a Vercel project"
+                  dropdownIcon
+                  text={selectedVercelProject?.name || "Select a project"}
+                >
+                  {availableProjects.map((project) => (
+                    <SelectItem key={project.id} value={project.id}>
+                      {project.name}
+                    </SelectItem>
+                  ))}
+                </Select>
+              )}
+
+              {projectSelectionError && (
+                <FormError>{projectSelectionError}</FormError>
+              )}
+
+              <Hint>
+                Once connected, your <code className="text-xs rounded bg-charcoal-700 px-1 py-0.5 text-text-bright">TRIGGER_SECRET_KEY</code> will be
+                automatically synced to Vercel for each environment.
+              </Hint>
+
+              <FormButtons
+                confirmButton={
+                  <div className="flex items-center gap-2">
+                    {vercelManageAccessUrl && !origin && (
+                      <LinkButton
+                        to={vercelManageAccessUrl}
+                        variant="tertiary/medium"
+                        target="_self"
+                      >
+                        Manage access
+                      </LinkButton>
+                    )}
+                    <Button
+                      variant="primary/medium"
+                      onClick={handleProjectSelection}
+                      disabled={!selectedVercelProject || fetcher.state !== "idle"}
+                      LeadingIcon={fetcher.state !== "idle" ? SpinnerWhite : undefined}
+                    >
+                      {fetcher.state !== "idle" ? "Connecting..." : "Connect Project"}
+                    </Button>
+                  </div>
+                }
+                cancelButton={
+                  <Button
+                    variant="tertiary/medium"
+                    onClick={handleSkipOnboarding}
+                  >
+                    Cancel
+                  </Button>
+                }
+              />
+            </div>
+          )}
+
+          {showEnvMapping && (
+            <div className="flex flex-col gap-4">
+              <Header3>Map Vercel Environment to Staging</Header3>
+              <Paragraph className="text-sm">
+                Select which custom Vercel environment should map to Trigger.dev's Staging
+                environment. Production and Preview environments are mapped automatically.
+                If you skip this step, the{" "}
+                <code className="rounded bg-charcoal-700 px-1 py-0.5 text-text-bright">TRIGGER_SECRET_KEY</code>{" "}
+                will not be installed for the staging environment in Vercel. You can configure this later in
+                project settings.
+              </Paragraph>
+
+              <Select
+                value={vercelStagingEnvironment?.environmentId || ""}
+                setValue={(value) => {
+                  if (!Array.isArray(value)) {
+                    const env = customEnvironments.find((e) => e.id === value);
+                    setVercelStagingEnvironment(
+                      env ? { environmentId: env.id, displayName: env.slug } : null
+                    );
+                  }
+                }}
+                items={customEnvironments}
+                variant="tertiary/medium"
+                placeholder="Select environment"
+                dropdownIcon
+                text={vercelStagingEnvironment?.displayName || "Select environment"}
+              >
+                {customEnvironments.map((env) => (
+                  <SelectItem key={env.id} value={env.id}>
+                    {env.slug}
+                  </SelectItem>
+                ))}
+              </Select>
+
+              <Paragraph className="text-xs text-text-dimmed">
+                Make sure the staging branch in your Vercel project's Git settings matches the staging branch
+                configured in your GitHub integration.
+              </Paragraph>
+
+              <div className="flex items-center justify-between gap-2">
+                <Button
+                  variant="tertiary/medium"
+                  onClick={handleSkipOnboarding}
+                >
+                  Cancel
+                </Button>
+                <div className="flex items-center gap-2">
+                  {!fromMarketplaceContext && (
+                    <Button
+                      variant="tertiary/medium"
+                      onClick={handleSkipEnvMapping}
+                    >
+                      Skip
+                    </Button>
+                  )}
+                  <Button
+                    variant="primary/medium"
+                    onClick={handleUpdateEnvMapping}
+                    disabled={envMappingFetcher.state !== "idle"}
+                    LeadingIcon={envMappingFetcher.state !== "idle" ? SpinnerWhite : undefined}
+                  >
+                    Next
+                  </Button>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {showEnvVarSync && (
+            <div className="flex flex-col gap-4">
+              <div className="flex flex-col gap-1">
+                <Header3>Pull Environment Variables</Header3>
+                <Paragraph className="text-sm">
+                Choose which environment variables to import from Vercel. This runs as a one time pull to prefill your project with the variables it needs. You’ll be able to pull again later, or enable automatic syncing before each build if you prefer.
+                If you are using Supabase or Neon branching, <TextLink href="https://trigger.dev/docs/vercel-integration#supabase-and-neon-database-branching" target="_blank" rel="noopener noreferrer">read the docs</TextLink> for the recommended setup.
+                </Paragraph>
+              </div>
+              <div className="flex items-center justify-between rounded border bg-charcoal-800 p-3">
+                <div>
+                  <Label>Pull all environment variables now</Label>
+                  <Hint>Select all variables to pull from Vercel.</Hint>
+                </div>
+                <Switch
+                  variant="small"
+                  checked={enabledEnvVars.length === syncableEnvVars.length}
+                  onCheckedChange={(checked) => handleToggleAllEnvVars(checked, syncableEnvVars)}
+                />
+              </div>
+
+              {syncableEnvVars.length > 0 && (
+                <div className="rounded border">
+                  <button
+                    type="button"
+                    className="flex w-full items-center justify-between p-3 text-left"
+                    onClick={() => setExpandedEnvVars(!expandedEnvVars)}
+                  >
+                    <span className="text-sm text-text-dimmed">
+                      {enabledEnvVars.length} of {syncableEnvVars.length} variables will be pulled
+                    </span>
+                    {expandedEnvVars ? (
+                      <ChevronUpIcon className="size-4" />
+                    ) : (
+                      <ChevronDownIcon className="size-4" />
+                    )}
+                  </button>
+
+                  {expandedEnvVars && (
+                    <div className="max-h-64 overflow-y-auto border-t">
+                      {syncableEnvVars.map((envVar) => (
+                        <div
+                          key={envVar.id}
+                          className="flex items-center justify-between gap-2 border-b px-3 py-2 last:border-b-0"
+                        >
+                          <div className="flex min-w-0 flex-1 flex-col gap-0.5">
+                            {existingVars[envVar.key] ? (
+                              <TooltipProvider>
+                                <Tooltip>
+                                  <TooltipTrigger asChild>
+                                    <div className="min-w-0 max-w-full cursor-default text-left truncate font-mono text-xs underline decoration-yellow-500 decoration-dotted underline-offset-2">
+                                      {envVar.key}
+                                    </div>
+                                  </TooltipTrigger>
+                                  <TooltipContent className="flex items-center gap-1 text-xs">
+                                    {`This variable is going to be replaced in: ${existingVars[
+                                      envVar.key
+                                    ].environments.join(", ")}`}
+                                  </TooltipContent>
+                                </Tooltip>
+                              </TooltipProvider>
+                            ) : (
+                              <span className="truncate font-mono text-xs">{envVar.key}</span>
+                            )}
+                            {envVar.target && envVar.target.length > 0 && (
+                              <span className="text-xs text-text-dimmed">
+                                {formatVercelTargets(envVar.target)}
+                                {envVar.isShared && " · Shared"}
+                              </span>
+                            )}
+                          </div>
+                          <Switch
+                            variant="small"
+                            checked={shouldSyncEnvVarForAnyEnvironment(syncEnvVarsMapping, envVar.key)}
+                            onCheckedChange={(checked) =>
+                              handleToggleEnvVar(envVar.key, checked)
+                            }
+                          />
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )}
+
+              {secretEnvVars.length > 0 && (
+                <div className="rounded border">
+                  <button
+                    type="button"
+                    className="flex w-full items-center justify-between p-3 text-left"
+                    onClick={() => setExpandedSecretEnvVars(!expandedSecretEnvVars)}
+                  >
+                    <span className="text-sm text-text-dimmed">
+                      {secretEnvVars.length} secret {secretEnvVars.length === 1 ? "variable" : "variables"} (cannot be pulled)
+                    </span>
+                    {expandedSecretEnvVars ? (
+                      <ChevronUpIcon className="size-4" />
+                    ) : (
+                      <ChevronDownIcon className="size-4" />
+                    )}
+                  </button>
+
+                  {expandedSecretEnvVars && (
+                    <div className="max-h-64 overflow-y-auto border-t">
+                      {secretEnvVars.map((envVar) => (
+                        <div
+                          key={envVar.id}
+                          className="flex items-center justify-between gap-2 border-b px-3 py-2 last:border-b-0"
+                        >
+                          <div className="flex min-w-0 flex-1 flex-col gap-0.5">
+                            <span className="truncate font-mono text-xs">{envVar.key}</span>
+                            {envVar.target && envVar.target.length > 0 && (
+                              <span className="text-xs text-text-dimmed">
+                                {formatVercelTargets(envVar.target)}
+                                {envVar.isShared && " · Shared"}
+                              </span>
+                            )}
+                          </div>
+                          <span className="shrink-0 text-xs text-amber-400">Secret</span>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )}
+
+              {overlappingEnvVarsCount > 0 && enabledEnvVars.length > 0 && (
+                <div className="flex items-center gap-2">
+                  <ExclamationTriangleIcon className="h-4 w-4 text-amber-500" />
+                  <span className="text-xs text-text-dimmed">
+                    {overlappingEnvVarsCount} env vars are going to be updated (marked with{" "}
+                    <span className="underline decoration-yellow-500 decoration-dotted underline-offset-2">
+                      underline
+                    </span>
+                    )
+                  </span>
+                </div>
+              )}
+
+              <FormButtons
+                confirmButton={
+                  <Button
+                    variant="primary/medium"
+                    onClick={() => {
+                      trackOnboarding("vercel onboarding env vars configured", {
+                        env_vars_enabled: enabledEnvVars.length,
+                        env_vars_total: syncableEnvVars.length,
+                      });
+                      if (fromMarketplaceContext) {
+                        handleBuildSettingsNext();
+                      } else {
+                        setState("build-settings");
+                      }
+                    }}
+                    disabled={fromMarketplaceContext && (completeOnboardingFetcher.state !== "idle" || isRedirecting)}
+                    LeadingIcon={fromMarketplaceContext && (completeOnboardingFetcher.state !== "idle" || isRedirecting) ? SpinnerWhite : undefined}
+                  >
+                    {fromMarketplaceContext ? (isGitHubConnectedForOnboarding ? "Finish" : "Next") : "Next"}
+                  </Button>
+                }
+                cancelButton={
+                  hasCustomEnvs && !fromMarketplaceContext ? (
+                    <Button
+                      variant="tertiary/medium"
+                      onClick={() => setState("env-mapping")}
+                    >
+                      Back
+                    </Button>
+                  ) : (
+                    <Button
+                      variant="tertiary/medium"
+                      onClick={handleSkipOnboarding}
+                      disabled={fetcher.state !== "idle"}
+                    >
+                      Cancel
+                    </Button>
+                  )
+                }
+              />
+            </div>
+          )}
+
+          {showBuildSettings && (
+            <div className="flex flex-col gap-4">
+              <Header3>Build Settings</Header3>
+              <Paragraph className="text-sm">
+                Configure how environment variables are pulled during builds and atomic deployments.
+              </Paragraph>
+
+              <BuildSettingsFields
+                availableEnvSlugs={availableEnvSlugsForOnboardingBuildSettings}
+                pullEnvVarsBeforeBuild={pullEnvVarsBeforeBuild}
+                onPullEnvVarsChange={setPullEnvVarsBeforeBuild}
+                discoverEnvVars={discoverEnvVars}
+                onDiscoverEnvVarsChange={setDiscoverEnvVars}
+                atomicBuilds={atomicBuilds}
+                onAtomicBuildsChange={setAtomicBuilds}
+                disabledEnvSlugs={disabledEnvSlugsForBuildSettings}
+              />
+
+              <FormButtons
+                confirmButton={
+                  <Button
+                    variant="primary/medium"
+                    onClick={handleBuildSettingsNext}
+                    disabled={completeOnboardingFetcher.state !== "idle" || isRedirecting}
+                    LeadingIcon={completeOnboardingFetcher.state !== "idle" || isRedirecting ? SpinnerWhite : undefined}
+                  >
+                    {isGitHubConnectedForOnboarding ? "Finish" : "Next"}
+                  </Button>
+                }
+                cancelButton={
+                  <Button
+                    variant="tertiary/medium"
+                    onClick={() => setState("env-var-sync")}
+                  >
+                    Back
+                  </Button>
+                }
+              />
+            </div>
+          )}
+
+          {showGitHubConnection && (
+            <div className="flex flex-col gap-4">
+              <Header3>Connect GitHub Repository</Header3>
+              <Paragraph className="text-sm">
+                To fully integrate with Vercel, Trigger.dev needs access to your source code.
+                This allows automatic deployments and build synchronization.
+              </Paragraph>
+
+              <Callout variant="info">
+                <p className="text-xs">
+                  Connecting your GitHub repository enables Trigger.dev to read your source code
+                  and automatically create deployments when you push changes to Vercel.
+                </p>
+              </Callout>
+
+              {(() => {
+                const baseSettingsPath = v3ProjectSettingsIntegrationsPath(
+                  { slug: organizationSlug },
+                  { slug: projectSlug },
+                  { slug: environmentSlug }
+                );
+                const redirectParams = new URLSearchParams();
+                redirectParams.set("vercelOnboarding", "true");
+                if (fromMarketplaceContext) {
+                  redirectParams.set("origin", "marketplace");
+                }
+                if (nextUrl) {
+                  redirectParams.set("next", nextUrl);
+                }
+                const redirectUrlWithContext = `${baseSettingsPath}?${redirectParams.toString()}`;
+
+                return gitHubAppInstallations.length === 0 ? (
+                  <div className="flex flex-col gap-3">
+                    <LinkButton
+                      to={githubAppInstallPath(
+                        organizationSlug,
+                        `${redirectUrlWithContext}&openGithubRepoModal=1`
+                      )}
+                      variant="secondary/medium"
+                      LeadingIcon={OctoKitty}
+                      onClick={() => trackOnboarding("vercel onboarding github app install clicked")}
+                    >
+                      Install GitHub app
+                    </LinkButton>
+                  </div>
+                ) : (
+                  <div className="flex flex-col gap-3">
+                    <div className="flex items-center gap-3">
+                      <ConnectGitHubRepoModal
+                        gitHubAppInstallations={gitHubAppInstallations}
+                        organizationSlug={organizationSlug}
+                        projectSlug={projectSlug}
+                        environmentSlug={environmentSlug}
+                        redirectUrl={redirectUrlWithContext}
+                        preventDismiss={fromMarketplaceContext}
+                      />
+                      <span className="flex items-center gap-1 text-xs text-text-dimmed">
+                        <CheckCircleIcon className="size-4 text-success" /> GitHub app is installed
+                      </span>
+                    </div>
+                  </div>
+                );
+              })()}
+
+              <FormButtons
+                confirmButton={
+                  isGitHubConnectedForOnboarding && fromMarketplaceContext && nextUrl ? (
+                    <Button
+                      variant="primary/medium"
+                      onClick={() => {
+                        trackOnboarding("vercel onboarding github completed");
+                        setState("completed");
+                        const validUrl = safeRedirectUrl(nextUrl);
+                        if (validUrl) {
+                          window.location.href = validUrl;
+                        }
+                      }}
+                    >
+                      Complete
+                    </Button>
+                  ) : !fromMarketplaceContext ? (
+                    <Button
+                      variant="tertiary/medium"
+                      onClick={() => {
+                        trackOnboarding("vercel onboarding github skipped");
+                        setState("completed");
+                      }}
+                    >
+                      Skip for now
+                    </Button>
+                  ) : undefined
+                }
+              />
+            </div>
+          )}
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/components/layout/AppLayout.tsx b/apps/webapp/app/components/layout/AppLayout.tsx
index 0793c52cac7..3da2bfbb5a5 100644
--- a/apps/webapp/app/components/layout/AppLayout.tsx
+++ b/apps/webapp/app/components/layout/AppLayout.tsx
@@ -20,8 +20,18 @@ export function MainBody({ children }: { children: React.ReactNode }) {
 }
 
 /** This container should be placed around the content on a page */
-export function PageContainer({ children }: { children: React.ReactNode }) {
-  return <div className="grid grid-rows-[auto_1fr] overflow-hidden">{children}</div>;
+export function PageContainer({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <div className={cn("grid h-full grid-rows-[auto_1fr] overflow-hidden", className)}>
+      {children}
+    </div>
+  );
 }
 
 export function PageBody({
@@ -50,13 +60,26 @@ export function PageBody({
 export function MainCenteredContainer({
   children,
   className,
+  variant = "default",
 }: {
   children: React.ReactNode;
   className?: string;
+  variant?: "default" | "onboarding";
 }) {
   return (
-    <div className="h-full w-full overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
-      <div className={cn("mx-auto mt-6 max-w-xs overflow-y-auto p-1 md:mt-[22vh]", className)}>
+    <div
+      className={cn(
+        "h-full w-full overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+        variant === "onboarding" && "flex flex-col p-4 lg:p-0"
+      )}
+    >
+      <div
+        className={cn(
+          "mx-auto max-w-xs p-1",
+          variant === "onboarding" ? "m-auto lg:mx-auto lg:mb-0 lg:mt-[22vh]" : "mt-6 md:mt-[22vh]",
+          className
+        )}
+      >
         {children}
       </div>
     </div>
diff --git a/apps/webapp/app/components/logs/LogDetailView.tsx b/apps/webapp/app/components/logs/LogDetailView.tsx
new file mode 100644
index 00000000000..a44d833054f
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogDetailView.tsx
@@ -0,0 +1,258 @@
+import { XMarkIcon } from "@heroicons/react/20/solid";
+import type { TaskRunStatus } from "@trigger.dev/database";
+import { useEffect, useState } from "react";
+import { useTypedFetcher } from "remix-typedjson";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { CopyableText } from "~/components/primitives/CopyableText";
+import { DateTimeAccurate } from "~/components/primitives/DateTime";
+import { Header2 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import * as Property from "~/components/primitives/PropertyTable";
+import { Spinner } from "~/components/primitives/Spinner";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { PacketDisplay } from "~/components/runs/v3/PacketDisplay";
+import {
+  TaskRunStatusCombo,
+  descriptionForTaskRunStatus,
+} from "~/components/runs/v3/TaskRunStatus";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import type { LogEntry } from "~/presenters/v3/LogsListPresenter.server";
+import type { loader as logDetailLoader } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.$logId";
+import { cn } from "~/utils/cn";
+import { getLevelColor } from "~/utils/logUtils";
+import { v3RunSpanPath } from "~/utils/pathBuilder";
+import { LogLevel } from "./LogLevel";
+import { ExitIcon } from "~/assets/icons/ExitIcon";
+type LogDetailViewProps = {
+  logId: string;
+  // If we have the log entry from the list, we can display it immediately
+  initialLog?: LogEntry;
+  onClose: () => void;
+  searchTerm?: string;
+};
+
+type LogAttributes = Record<string, unknown> & {
+  error?: {
+    message?: string;
+  };
+};
+
+function getDisplayMessage(log: {
+  message: string;
+  level: string;
+  attributes?: LogAttributes;
+}): string {
+  let message = log.message ?? "";
+  if (log.level === "ERROR") {
+    const maybeErrorMessage = log.attributes?.error?.message;
+    if (typeof maybeErrorMessage === "string" && maybeErrorMessage.length > 0) {
+      message = maybeErrorMessage;
+    }
+  }
+  return message;
+}
+
+function formatStringJSON(str: string): string {
+  return str
+    .replace(/\\n/g, "\n") // Converts literal "\n" to newline
+    .replace(/\\t/g, "\t"); // Converts literal "\t" to tab
+}
+
+export function LogDetailView({ logId, initialLog, onClose, searchTerm }: LogDetailViewProps) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const fetcher = useTypedFetcher<typeof logDetailLoader>();
+  const [error, setError] = useState<string | null>(null);
+
+  // Fetch full log details when logId changes
+  useEffect(() => {
+    if (!logId) return;
+
+    setError(null);
+    fetcher.load(
+      `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${
+        environment.slug
+      }/logs/${encodeURIComponent(logId)}`
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [organization.slug, project.slug, environment.slug, logId]);
+
+  // Handle fetch errors
+  useEffect(() => {
+    if (fetcher.data && typeof fetcher.data === "object" && "error" in fetcher.data) {
+      setError(fetcher.data.error as string);
+    } else if (fetcher.state === "idle" && fetcher.data === null && !initialLog) {
+      setError("Failed to load log details");
+    } else {
+      setError(null);
+    }
+  }, [fetcher.data, initialLog, fetcher.state]);
+
+  const isLoading = fetcher.state === "loading";
+  const log = fetcher.data ?? initialLog;
+  const runStatus = fetcher.data?.runStatus;
+
+  const runPath = v3RunSpanPath(
+    organization,
+    project,
+    environment,
+    { friendlyId: log?.runId ?? "" },
+    { spanId: log?.spanId ?? "" }
+  );
+
+  if (isLoading && !log) {
+    return (
+      <div className="flex h-full items-center justify-center">
+        <Spinner />
+      </div>
+    );
+  }
+
+  if (!log) {
+    return (
+      <div className="flex h-full flex-col">
+        <div className="flex items-center justify-between border-b border-grid-dimmed py-2 pl-3 pr-2">
+          <Header2>Log Details</Header2>
+          <Button
+            onClick={onClose}
+            variant="minimal/small"
+            TrailingIcon={ExitIcon}
+            shortcut={{ key: "esc" }}
+            shortcutPosition="before-trailing-icon"
+            className="pl-1"
+          />
+        </div>
+        <div className="flex flex-1 items-center justify-center">
+          <Paragraph className="text-text-dimmed">{error ?? "Log not found"}</Paragraph>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="grid h-full grid-rows-[auto_1fr] overflow-hidden">
+      {/* Header */}
+      <div className="flex items-center justify-between overflow-hidden border-b border-grid-dimmed py-2 pl-3 pr-2">
+        <Header2 className="truncate">{getDisplayMessage(log)}</Header2>
+        <Button
+          onClick={onClose}
+          variant="minimal/small"
+          TrailingIcon={ExitIcon}
+          shortcut={{ key: "esc" }}
+          shortcutPosition="before-trailing-icon"
+          className="pl-1"
+        />
+      </div>
+      <div className="overflow-y-auto px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <DetailsTab log={log} runPath={runPath} runStatus={runStatus} searchTerm={searchTerm} />
+      </div>
+    </div>
+  );
+}
+
+function DetailsTab({
+  log,
+  runPath,
+  runStatus,
+  searchTerm,
+}: {
+  log: LogEntry & {
+    attributes?: LogAttributes;
+  };
+  runPath: string;
+  runStatus?: TaskRunStatus;
+  searchTerm?: string;
+}) {
+  let beautifiedAttributes: string | null = null;
+
+  if (log.attributes) {
+    beautifiedAttributes = JSON.stringify(log.attributes, null, 2);
+    beautifiedAttributes = formatStringJSON(beautifiedAttributes);
+  }
+
+  const showAttributes = beautifiedAttributes && beautifiedAttributes !== "{}";
+
+  const message = getDisplayMessage(log);
+
+  return (
+    <>
+      <Property.Table>
+        <Property.Item>
+          <Property.Label>Run ID</Property.Label>
+          <Property.Value>
+            <CopyableText value={log.runId} copyValue={log.runId} asChild />
+            <LinkButton
+              to={runPath}
+              variant="secondary/small"
+              shortcut={{ key: "v" }}
+              className="mt-2"
+            >
+              View full run
+            </LinkButton>
+          </Property.Value>
+        </Property.Item>
+
+        {runStatus && (
+          <Property.Item>
+            <Property.Label>Status</Property.Label>
+            <Property.Value>
+              <SimpleTooltip
+                button={<TaskRunStatusCombo status={runStatus} />}
+                content={descriptionForTaskRunStatus(runStatus)}
+                disableHoverableContent
+                className="mt-1"
+              />
+            </Property.Value>
+          </Property.Item>
+        )}
+
+        <Property.Item>
+          <Property.Label>Task</Property.Label>
+          <Property.Value>
+            <CopyableText value={log.taskIdentifier} copyValue={log.taskIdentifier} asChild />
+          </Property.Value>
+        </Property.Item>
+
+        <Property.Item>
+          <Property.Label>Level</Property.Label>
+          <Property.Value>
+            <LogLevel level={log.level} />
+          </Property.Value>
+        </Property.Item>
+
+        <Property.Item>
+          <Property.Label>Timestamp</Property.Label>
+          <Property.Value>
+            <DateTimeAccurate date={log.triggeredTimestamp} />
+          </Property.Value>
+        </Property.Item>
+      </Property.Table>
+
+      {/* Message */}
+      <div className="mb-6 mt-3">
+        <PacketDisplay
+          data={message}
+          dataType="application/json"
+          title="Message"
+          searchTerm={searchTerm}
+          wrap={true}
+        />
+      </div>
+
+      {/* Attributes - only available in full log detail */}
+      {showAttributes && beautifiedAttributes && (
+        <div className="mb-6">
+          <PacketDisplay
+            data={beautifiedAttributes}
+            dataType="application/json"
+            title="Attributes"
+            searchTerm={searchTerm}
+          />
+        </div>
+      )}
+    </>
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogLevel.tsx b/apps/webapp/app/components/logs/LogLevel.tsx
new file mode 100644
index 00000000000..3c2c38301ff
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogLevel.tsx
@@ -0,0 +1,16 @@
+import { cn } from "~/utils/cn";
+import { getLevelColor } from "~/utils/logUtils";
+import type { LogEntry } from "~/presenters/v3/LogsListPresenter.server";
+
+export function LogLevel({ level }: { level: LogEntry["level"] }) {
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center rounded border px-1 py-0.5 text-xxs font-medium uppercase tracking-wider",
+        getLevelColor(level)
+      )}
+    >
+      {level}
+    </span>
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogsLevelFilter.tsx b/apps/webapp/app/components/logs/LogsLevelFilter.tsx
new file mode 100644
index 00000000000..947bef88fcc
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogsLevelFilter.tsx
@@ -0,0 +1,138 @@
+import * as Ariakit from "@ariakit/react";
+import { IconListTree } from "@tabler/icons-react";
+import { type ReactNode } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+  shortcutFromIndex,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary } from "~/components/runs/v3/SharedFilters";
+import type { LogLevel } from "~/presenters/v3/LogsListPresenter.server";
+import { cn } from "~/utils/cn";
+
+const allLogLevels: { level: LogLevel; label: string; color: string }[] = [
+  { level: "TRACE", label: "Trace", color: "text-purple-400" },
+  { level: "INFO", label: "Info", color: "text-blue-400" },
+  { level: "WARN", label: "Warning", color: "text-warning" },
+  { level: "ERROR", label: "Error", color: "text-error" },
+  { level: "DEBUG", label: "Debug", color: "text-charcoal-400" },
+];
+
+// In the future we might add other levels or change which are available
+function getAvailableLevels(): typeof allLogLevels {
+  return allLogLevels;
+}
+
+function getLevelBadgeColor(level: LogLevel): string {
+  switch (level) {
+    case "ERROR":
+      return "text-error bg-error/10 border-error/20";
+    case "WARN":
+      return "text-warning bg-warning/10 border-warning/20";
+    case "TRACE":
+      return "text-purple-400 bg-purple-500/10 border-purple-500/20";
+    case "DEBUG":
+      return "text-charcoal-400 bg-charcoal-700 border-charcoal-600";
+    case "INFO":
+      return "text-blue-400 bg-blue-500/10 border-blue-500/20";
+    default:
+      return "text-text-dimmed bg-charcoal-750 border-charcoal-700";
+  }
+}
+
+const shortcut = { key: "l" };
+
+export function LogsLevelFilter() {
+  const { values } = useSearchParams();
+  const selectedLevels = values("levels");
+  const hasLevels = selectedLevels.length > 0 && selectedLevels.some((v) => v !== "");
+
+  if (hasLevels) {
+    return <AppliedLevelFilter/>;
+  }
+
+  return (
+    <LevelDropdown
+      trigger={
+        <SelectTrigger
+          icon={<IconListTree className="size-4" />}
+          variant="secondary/small"
+          shortcut={shortcut}
+          tooltipTitle="Filter by level"
+        >
+          Level
+        </SelectTrigger>
+      }
+    />
+  );
+}
+
+function LevelDropdown({
+  trigger,
+}: {
+  trigger: ReactNode;
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    replace({ levels: values, cursor: undefined, direction: undefined });
+  };
+
+  const availableLevels = getAvailableLevels();
+
+  return (
+    <SelectProvider value={values("levels")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover className="min-w-0 max-w-[min(240px,var(--popover-available-width))]">
+        <SelectList>
+          {availableLevels.map((item, index) => (
+            <SelectItem
+              key={item.level}
+              value={item.level}
+              shortcut={shortcutFromIndex(index, { shortcutsEnabled: true })}
+            >
+              <span
+                className={cn(
+                  "inline-flex items-center rounded border px-1.5 py-0.5 text-xs font-medium uppercase",
+                  getLevelBadgeColor(item.level)
+                )}
+              >
+                {item.level}
+              </span>
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function AppliedLevelFilter() {
+  const { values, del } = useSearchParams();
+  const levels = values("levels");
+
+  if (levels.length === 0 || levels.every((v) => v === "")) {
+    return null;
+  }
+
+  return (
+    <LevelDropdown
+      trigger={
+        <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+          <AppliedFilter
+            label="Level"
+            icon={<IconListTree className="size-4" />}
+            value={appliedSummary(levels)}
+            onRemove={() => del(["levels", "cursor", "direction"])}
+            variant="secondary/small"
+          />
+        </Ariakit.Select>
+      }
+    />
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogsRunIdFilter.tsx b/apps/webapp/app/components/logs/LogsRunIdFilter.tsx
new file mode 100644
index 00000000000..857e623d7c9
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogsRunIdFilter.tsx
@@ -0,0 +1,161 @@
+import * as Ariakit from "@ariakit/react";
+import { FingerPrintIcon } from "@heroicons/react/20/solid";
+import { useCallback, useState } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import { Button } from "~/components/primitives/Buttons";
+import { FormError } from "~/components/primitives/FormError";
+import { Input } from "~/components/primitives/Input";
+import { Label } from "~/components/primitives/Label";
+import {
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+
+const shortcut = { key: "i" };
+
+export function LogsRunIdFilter() {
+  const { value } = useSearchParams();
+  const runIdValue = value("runId");
+
+  if (runIdValue) {
+    return <AppliedRunIdFilter />;
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <RunIdDropdown
+          trigger={
+            <SelectTrigger
+              icon={<FingerPrintIcon className="size-4" />}
+              variant="secondary/small"
+              shortcut={shortcut}
+              tooltipTitle="Filter by run ID"
+            >
+              Run ID
+            </SelectTrigger>
+          }
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function RunIdDropdown({
+  trigger,
+  clearSearchValue,
+  onClose,
+}: {
+  trigger: React.ReactNode;
+  clearSearchValue: () => void;
+  onClose?: () => void;
+}) {
+  const [open, setOpen] = useState<boolean | undefined>();
+  const { value, replace } = useSearchParams();
+  const runIdValue = value("runId");
+
+  const [runId, setRunId] = useState(runIdValue);
+
+  const apply = useCallback(() => {
+    clearSearchValue();
+    replace({
+      cursor: undefined,
+      direction: undefined,
+      runId: runId === "" ? undefined : runId?.toString(),
+    });
+
+    setOpen(false);
+  }, [runId, replace, clearSearchValue]);
+
+  let error: string | undefined = undefined;
+  if (runId) {
+    if (!runId.startsWith("run_")) {
+      error = "Run IDs start with 'run_'";
+    } else if (runId.length !== 25 && runId.length !== 29) {
+      error = "Run IDs are 25 or 29 characters long";
+    }
+  }
+
+  return (
+    <SelectProvider virtualFocus={true} open={open} setOpen={setOpen}>
+      {trigger}
+      <SelectPopover
+        hideOnEnter={false}
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+        className="max-w-[min(32ch,var(--popover-available-width))]"
+      >
+        <div className="flex flex-col gap-4 p-3">
+          <div className="flex flex-col gap-1">
+            <Label>Run ID</Label>
+            <Input
+              placeholder="run_"
+              value={runId ?? ""}
+              onChange={(e) => setRunId(e.target.value)}
+              variant="small"
+              className="w-[27ch] font-mono"
+              spellCheck={false}
+            />
+            {error ? <FormError>{error}</FormError> : null}
+          </div>
+          <div className="flex justify-between gap-1 border-t border-grid-dimmed pt-3">
+            <Button variant="tertiary/small" onClick={() => setOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              disabled={error !== undefined || !runId}
+              variant="secondary/small"
+              shortcut={{
+                modifiers: ["mod"],
+                key: "Enter",
+                enabledOnInputElements: true,
+              }}
+              onClick={() => apply()}
+            >
+              Apply
+            </Button>
+          </div>
+        </div>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function AppliedRunIdFilter() {
+  const { value, del } = useSearchParams();
+
+  const runId = value("runId");
+  if (!runId) {
+    return null;
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <RunIdDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Run ID"
+                icon={<FingerPrintIcon className="size-4" />}
+                value={runId}
+                onRemove={() => del(["runId", "cursor", "direction"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogsTable.tsx b/apps/webapp/app/components/logs/LogsTable.tsx
new file mode 100644
index 00000000000..ed8e6793e5f
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogsTable.tsx
@@ -0,0 +1,243 @@
+import { ArrowPathIcon, ArrowTopRightOnSquareIcon } from "@heroicons/react/20/solid";
+import { Link } from "@remix-run/react";
+import { useEffect, useRef, useState } from "react";
+import { cn } from "~/utils/cn";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import type { LogEntry } from "~/presenters/v3/LogsListPresenter.server";
+import { highlightSearchText } from "~/utils/logUtils";
+import { v3RunSpanPath } from "~/utils/pathBuilder";
+import { DateTimeAccurate } from "../primitives/DateTime";
+import { Paragraph } from "../primitives/Paragraph";
+import { Spinner } from "../primitives/Spinner";
+import { LogLevel } from "./LogLevel";
+import { TruncatedCopyableValue } from "../primitives/TruncatedCopyableValue";
+import { LogLevelTooltipInfo } from "~/components/LogLevelTooltipInfo";
+import {
+  Table,
+  TableBlankRow,
+  TableBody,
+  TableCell,
+  TableCellMenu,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+  type TableVariant,
+} from "../primitives/Table";
+import { RunsIcon } from "~/assets/icons/RunsIcon";
+
+type LogsTableProps = {
+  logs: LogEntry[];
+  searchTerm?: string;
+  isLoading?: boolean;
+  isLoadingMore?: boolean;
+  hasMore?: boolean;
+  onLoadMore?: () => void;
+  onCheckForMore?: () => void;
+  variant?: TableVariant;
+  selectedLogId?: string;
+  onLogSelect?: (logId: string) => void;
+};
+
+// Inner shadow for level highlighting (better scroll performance than border-l)
+function getLevelBoxShadow(level: LogEntry["level"]): string {
+  switch (level) {
+    case "ERROR":
+      return "inset 2px 0 0 0 rgb(239, 68, 68)";
+    case "WARN":
+      return "inset 2px 0 0 0 rgb(234, 179, 8)";
+    case "INFO":
+      return "inset 2px 0 0 0 rgb(59, 130, 246)";
+    case "TRACE":
+      return "inset 2px 0 0 0 rgb(168, 85, 247)";
+    case "DEBUG":
+    default:
+      return "none";
+  }
+}
+
+export function LogsTable({
+  logs,
+  searchTerm,
+  isLoading = false,
+  isLoadingMore = false,
+  hasMore = false,
+  onLoadMore,
+  onCheckForMore,
+  selectedLogId,
+  onLogSelect,
+}: LogsTableProps) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const loadMoreRef = useRef<HTMLDivElement>(null);
+  const [showLoadMoreSpinner, setShowLoadMoreSpinner] = useState(false);
+
+  // Show load more spinner only after 0.2 seconds of loading time
+  useEffect(() => {
+    if (!isLoadingMore) {
+      setShowLoadMoreSpinner(false);
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      setShowLoadMoreSpinner(true);
+    }, 200);
+
+    return () => clearTimeout(timer);
+  }, [isLoadingMore]);
+
+  // Intersection observer for infinite scroll
+  useEffect(() => {
+    if (!hasMore || isLoadingMore || !onLoadMore) return;
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting) {
+          onLoadMore();
+        }
+      },
+      { threshold: 0.1 }
+    );
+
+    const currentRef = loadMoreRef.current;
+    if (currentRef) {
+      observer.observe(currentRef);
+    }
+
+    return () => {
+      if (currentRef) {
+        observer.unobserve(currentRef);
+      }
+    };
+  }, [hasMore, isLoadingMore, onLoadMore]);
+
+  return (
+    <div className="relative h-full overflow-auto border-t scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+      <Table variant="compact/mono" containerClassName="overflow-visible" showTopBorder={false}>
+        <TableHeader className="sticky top-0 z-10">
+          <TableRow>
+            <TableHeaderCell className="min-w-48 whitespace-nowrap">Time</TableHeaderCell>
+            <TableHeaderCell className="min-w-24 whitespace-nowrap">Run</TableHeaderCell>
+            <TableHeaderCell className="min-w-32 whitespace-nowrap">Task</TableHeaderCell>
+            <TableHeaderCell
+              className="min-w-24 whitespace-nowrap"
+              tooltip={<LogLevelTooltipInfo />}
+              disableTooltipHoverableContent
+            >
+              Level
+            </TableHeaderCell>
+            <TableHeaderCell className="w-full min-w-0">Message</TableHeaderCell>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {logs.length === 0 ? (
+            <BlankState isLoading={isLoading} onRefresh={() => window.location.reload()} />
+          ) : (
+            logs.map((log) => {
+              const isSelected = selectedLogId === log.id;
+              const runPath = v3RunSpanPath(
+                organization,
+                project,
+                environment,
+                { friendlyId: log.runId },
+                { spanId: log.spanId }
+              );
+
+              const handleRowClick = () => onLogSelect?.(log.id);
+
+              return (
+                <TableRow
+                  key={log.id}
+                  className={cn(
+                    "cursor-pointer transition-colors",
+                    isSelected ? "bg-charcoal-750" : "hover:bg-charcoal-850"
+                  )}
+                  isSelected={isSelected}
+                >
+                  <TableCell
+                    className="whitespace-nowrap tabular-nums"
+                    onClick={handleRowClick}
+                    hasAction
+                    style={{
+                      boxShadow: getLevelBoxShadow(log.level),
+                    }}
+                  >
+                    <DateTimeAccurate date={log.triggeredTimestamp} hour12={false} />
+                  </TableCell>
+                  <TableCell className="min-w-24 cursor-pointer" onClick={handleRowClick}>
+                    <span className="font-mono text-xs">{log.runId}</span>
+                  </TableCell>
+                  <TableCell className="min-w-32" onClick={handleRowClick} hasAction>
+                    <span className="font-mono text-xs">{log.taskIdentifier}</span>
+                  </TableCell>
+                  <TableCell onClick={handleRowClick} hasAction>
+                    <LogLevel level={log.level} />
+                  </TableCell>
+                  <TableCell className="max-w-0 truncate" onClick={handleRowClick} hasAction>
+                    <span className="block truncate font-mono text-xs" title={log.message}>
+                      {highlightSearchText(log.message, searchTerm)}
+                    </span>
+                  </TableCell>
+                  <TableCellMenu
+                    className="pl-32"
+                    hiddenButtons={
+                      <LinkButton
+                        to={runPath}
+                        variant="minimal/small"
+                        TrailingIcon={RunsIcon}
+                        trailingIconClassName="text-text-bright"
+                        className="h-[1.375rem] pl-1.5 pr-2"
+                      >
+                        <span className="text-[0.6875rem] text-text-bright">View run</span>
+                      </LinkButton>
+                    }
+                  />
+                </TableRow>
+              );
+            })
+          )}
+        </TableBody>
+      </Table>
+      {/* Infinite scroll trigger */}
+      {hasMore && logs.length > 0 && (
+        <div ref={loadMoreRef} className="flex items-center justify-center py-12">
+          <div className={cn("flex items-center gap-2", !showLoadMoreSpinner && "invisible")}>
+            <Spinner /> <span className="text-text-dimmed">Loading more…</span>
+          </div>
+        </div>
+      )}
+      {/* Show all logs message with check for more button */}
+      {!hasMore && logs.length > 0 && (
+        <div className="flex items-center justify-center py-12">
+          <div className="flex flex-col items-center gap-3">
+            <span className="text-text-dimmed">Showing all {logs.length} logs</span>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function BlankState({ isLoading, onRefresh }: { isLoading?: boolean; onRefresh?: () => void }) {
+  if (isLoading) return <TableBlankRow colSpan={6}></TableBlankRow>;
+
+  const handleRefresh = onRefresh ?? (() => window.location.reload());
+
+  return (
+    <TableBlankRow colSpan={6}>
+      <div className="flex flex-col items-center justify-center gap-6">
+        <Paragraph className="w-auto" variant="base/bright">
+          No logs match your filters. Try refreshing or modifying your filters.
+        </Paragraph>
+        <div className="flex items-center gap-2">
+          <Button LeadingIcon={ArrowPathIcon} variant="tertiary/medium" onClick={handleRefresh}>
+            Refresh
+          </Button>
+        </div>
+      </div>
+    </TableBlankRow>
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogsTaskFilter.tsx b/apps/webapp/app/components/logs/LogsTaskFilter.tsx
new file mode 100644
index 00000000000..fa64eff7bd3
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogsTaskFilter.tsx
@@ -0,0 +1,144 @@
+import type { TaskTriggerSource } from "@trigger.dev/database";
+import type { ReactNode } from "react";
+import { useMemo } from "react";
+import * as Ariakit from "@ariakit/react";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { TaskTriggerSourceIcon } from "~/components/runs/v3/TaskTriggerSource";
+import { TaskIcon } from "~/assets/icons/TaskIcon";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+
+const shortcut = { key: "t" };
+
+type TaskOption = {
+  slug: string;
+  triggerSource: TaskTriggerSource;
+};
+
+interface LogsTaskFilterProps {
+  possibleTasks: TaskOption[];
+}
+
+export function LogsTaskFilter({ possibleTasks }: LogsTaskFilterProps) {
+  const { values, replace, del } = useSearchParams();
+  const selectedTasks = values("tasks");
+
+  if (selectedTasks.length === 0 || selectedTasks.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <TasksDropdown
+            trigger={
+              <SelectTrigger
+                icon={<TaskIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by task"
+              >
+                <span className="ml-0.5">Tasks</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+            possibleTasks={possibleTasks}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <TasksDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Task"
+                icon={<TaskIcon className="size-4" />}
+                value={appliedSummary(
+                  selectedTasks.map((v) => {
+                    const task = possibleTasks.find((task) => task.slug === v);
+                    return task ? task.slug : v;
+                  })
+                )}
+                onRemove={() => del(["tasks", "cursor", "direction"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+          possibleTasks={possibleTasks}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function TasksDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+  possibleTasks,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+  possibleTasks: TaskOption[];
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({ tasks: values, cursor: undefined, direction: undefined });
+  };
+
+  const filtered = useMemo(() => {
+    return possibleTasks.filter((item) => {
+      return item.slug.toLowerCase().includes(searchValue.toLowerCase());
+    });
+  }, [searchValue, possibleTasks]);
+
+  return (
+    <SelectProvider value={values("tasks")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+
+          return true;
+        }}
+      >
+        <ComboBox placeholder={"Filter by task..."} value={searchValue} />
+        <SelectList>
+          {filtered.map((item, index) => (
+            <SelectItem
+              key={`${item.triggerSource}-${item.slug}`}
+              value={item.slug}
+              icon={
+                <TaskTriggerSourceIcon source={item.triggerSource} className="size-4 flex-none" />
+              }
+            >
+              {item.slug}
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/logs/LogsVersionFilter.tsx b/apps/webapp/app/components/logs/LogsVersionFilter.tsx
new file mode 100644
index 00000000000..4cc10545060
--- /dev/null
+++ b/apps/webapp/app/components/logs/LogsVersionFilter.tsx
@@ -0,0 +1,58 @@
+import * as Ariakit from "@ariakit/react";
+import { SelectTrigger } from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+import { filterIcon, VersionsDropdown } from "~/components/runs/v3/RunFilters";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+
+const shortcut = { key: "v" };
+
+export function LogsVersionFilter() {
+  const { values, del } = useSearchParams();
+  const selectedVersions = values("versions");
+
+  if (selectedVersions.length === 0 || selectedVersions.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <VersionsDropdown
+            trigger={
+              <SelectTrigger
+                icon={filterIcon("versions")}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by version"
+              >
+                <span className="ml-0.5">Versions</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <VersionsDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Versions"
+                icon={filterIcon("versions")}
+                value={appliedSummary(selectedVersions)}
+                onRemove={() => del(["versions", "cursor", "direction"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/ModelsFilter.tsx b/apps/webapp/app/components/metrics/ModelsFilter.tsx
new file mode 100644
index 00000000000..e641f826ae3
--- /dev/null
+++ b/apps/webapp/app/components/metrics/ModelsFilter.tsx
@@ -0,0 +1,159 @@
+import { CubeIcon } from "@heroicons/react/20/solid";
+import * as Ariakit from "@ariakit/react";
+import { type ReactNode, useMemo } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+import { tablerIcons } from "~/utils/tablerIcons";
+import tablerSpritePath from "~/components/primitives/tabler-sprite.svg";
+import { AnthropicLogoIcon } from "~/assets/icons/AnthropicLogoIcon";
+
+const shortcut = { key: "l" };
+
+export type ModelOption = {
+  model: string;
+  system: string;
+};
+
+interface ModelsFilterProps {
+  possibleModels: ModelOption[];
+}
+
+function modelIcon(system: string, model: string): ReactNode {
+  // For gateway/openrouter, derive provider from model prefix
+  let provider = system.split(".")[0];
+  if (provider === "gateway" || provider === "openrouter") {
+    if (model.includes("/")) {
+      provider = model.split("/")[0].replace(/-/g, "");
+    }
+  }
+
+  // Special case: Anthropic uses a custom SVG icon
+  if (provider === "anthropic") {
+    return <AnthropicLogoIcon className="size-4 shrink-0" />;
+  }
+
+  const iconName = `tabler-brand-${provider}`;
+  if (tablerIcons.has(iconName)) {
+    return (
+      <svg className="size-4 shrink-0 stroke-[1.5]">
+        <use xlinkHref={`${tablerSpritePath}#${iconName}`} />
+      </svg>
+    );
+  }
+
+  return <CubeIcon className="size-4 shrink-0" />;
+}
+
+export function ModelsFilter({ possibleModels }: ModelsFilterProps) {
+  const { values, replace, del } = useSearchParams();
+  const selectedModels = values("models");
+
+  if (selectedModels.length === 0 || selectedModels.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <ModelsDropdown
+            trigger={
+              <SelectTrigger
+                icon={<CubeIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by model"
+              >
+                <span className="ml-0.5">Models</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+            possibleModels={possibleModels}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <ModelsDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Model"
+                icon={<CubeIcon className="size-4" />}
+                value={appliedSummary(selectedModels)}
+                onRemove={() => del(["models"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+          possibleModels={possibleModels}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function ModelsDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+  possibleModels,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+  possibleModels: ModelOption[];
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({ models: values });
+  };
+
+  const filtered = useMemo(() => {
+    return possibleModels.filter((m) => {
+      return m.model?.toLowerCase().includes(searchValue.toLowerCase());
+    });
+  }, [searchValue, possibleModels]);
+
+  return (
+    <SelectProvider value={values("models")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+      >
+        <ComboBox placeholder="Filter by model..." value={searchValue} />
+        <SelectList>
+          {filtered.map((m) => (
+            <SelectItem key={m.model} value={m.model} icon={modelIcon(m.system, m.model)}>
+              {m.model}
+            </SelectItem>
+          ))}
+          {filtered.length === 0 && <SelectItem disabled>No models found</SelectItem>}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/OperationsFilter.tsx b/apps/webapp/app/components/metrics/OperationsFilter.tsx
new file mode 100644
index 00000000000..679332fc3c4
--- /dev/null
+++ b/apps/webapp/app/components/metrics/OperationsFilter.tsx
@@ -0,0 +1,137 @@
+import { CommandLineIcon } from "@heroicons/react/20/solid";
+import * as Ariakit from "@ariakit/react";
+import { type ReactNode, useMemo } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+
+const shortcut = { key: "n" };
+
+interface OperationsFilterProps {
+  possibleOperations: string[];
+}
+
+/** Pretty-print an operation ID like "ai.generateText.doGenerate" → "generateText" */
+function formatOperation(op: string): string {
+  const parts = op.split(".");
+  // ai.generateText.doGenerate → generateText
+  // ai.streamText.doStream → streamText
+  if (parts.length >= 2 && parts[0] === "ai") {
+    return parts[1];
+  }
+  return op;
+}
+
+export function OperationsFilter({ possibleOperations }: OperationsFilterProps) {
+  const { values, replace, del } = useSearchParams();
+  const selectedOperations = values("operations");
+
+  if (selectedOperations.length === 0 || selectedOperations.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <OperationsDropdown
+            trigger={
+              <SelectTrigger
+                icon={<CommandLineIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by operation"
+              >
+                <span className="ml-0.5">Operations</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+            possibleOperations={possibleOperations}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <OperationsDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Operation"
+                icon={<CommandLineIcon className="size-4" />}
+                value={appliedSummary(selectedOperations.map(formatOperation))}
+                onRemove={() => del(["operations"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+          possibleOperations={possibleOperations}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function OperationsDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+  possibleOperations,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+  possibleOperations: string[];
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({ operations: values });
+  };
+
+  const filtered = useMemo(() => {
+    const q = searchValue.toLowerCase();
+    return possibleOperations.filter(
+      (op) => op.toLowerCase().includes(q) || formatOperation(op).toLowerCase().includes(q)
+    );
+  }, [searchValue, possibleOperations]);
+
+  return (
+    <SelectProvider value={values("operations")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+      >
+        <ComboBox placeholder="Filter by operation..." value={searchValue} />
+        <SelectList>
+          {filtered.map((op) => (
+            <SelectItem key={op} value={op} icon={<CommandLineIcon className="size-4" />}>
+              {formatOperation(op)}
+            </SelectItem>
+          ))}
+          {filtered.length === 0 && <SelectItem disabled>No operations found</SelectItem>}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/PromptsFilter.tsx b/apps/webapp/app/components/metrics/PromptsFilter.tsx
new file mode 100644
index 00000000000..a4ad8a00045
--- /dev/null
+++ b/apps/webapp/app/components/metrics/PromptsFilter.tsx
@@ -0,0 +1,125 @@
+import { DocumentTextIcon } from "@heroicons/react/20/solid";
+import * as Ariakit from "@ariakit/react";
+import { type ReactNode, useMemo } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+
+const shortcut = { key: "p" };
+
+interface PromptsFilterProps {
+  possiblePrompts: string[];
+}
+
+export function PromptsFilter({ possiblePrompts }: PromptsFilterProps) {
+  const { values, replace, del } = useSearchParams();
+  const selectedPrompts = values("prompts");
+
+  if (selectedPrompts.length === 0 || selectedPrompts.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <PromptsDropdown
+            trigger={
+              <SelectTrigger
+                icon={<DocumentTextIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by prompt"
+              >
+                <span className="ml-0.5">Prompts</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+            possiblePrompts={possiblePrompts}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <PromptsDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Prompt"
+                icon={<DocumentTextIcon className="size-4" />}
+                value={appliedSummary(selectedPrompts)}
+                onRemove={() => del(["prompts"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+          possiblePrompts={possiblePrompts}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function PromptsDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+  possiblePrompts,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+  possiblePrompts: string[];
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({ prompts: values });
+  };
+
+  const filtered = useMemo(() => {
+    return possiblePrompts.filter((p) => {
+      return p.toLowerCase().includes(searchValue.toLowerCase());
+    });
+  }, [searchValue, possiblePrompts]);
+
+  return (
+    <SelectProvider value={values("prompts")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+      >
+        <ComboBox placeholder="Filter by prompt..." value={searchValue} />
+        <SelectList>
+          {filtered.map((slug) => (
+            <SelectItem key={slug} value={slug} icon={<DocumentTextIcon className="size-4" />}>
+              {slug}
+            </SelectItem>
+          ))}
+          {filtered.length === 0 && <SelectItem disabled>No prompts found</SelectItem>}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/ProvidersFilter.tsx b/apps/webapp/app/components/metrics/ProvidersFilter.tsx
new file mode 100644
index 00000000000..fe018eefb98
--- /dev/null
+++ b/apps/webapp/app/components/metrics/ProvidersFilter.tsx
@@ -0,0 +1,123 @@
+import { ServerIcon } from "@heroicons/react/20/solid";
+import * as Ariakit from "@ariakit/react";
+import { type ReactNode, useMemo } from "react";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+
+const shortcut = { key: "r" };
+
+interface ProvidersFilterProps {
+  possibleProviders: string[];
+}
+
+export function ProvidersFilter({ possibleProviders }: ProvidersFilterProps) {
+  const { values, replace, del } = useSearchParams();
+  const selectedProviders = values("providers");
+
+  if (selectedProviders.length === 0 || selectedProviders.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <ProvidersDropdown
+            trigger={
+              <SelectTrigger
+                icon={<ServerIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by provider"
+              >
+                <span className="ml-0.5">Providers</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+            possibleProviders={possibleProviders}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <ProvidersDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Provider"
+                icon={<ServerIcon className="size-4" />}
+                value={appliedSummary(selectedProviders)}
+                onRemove={() => del(["providers"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+          possibleProviders={possibleProviders}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function ProvidersDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+  possibleProviders,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+  possibleProviders: string[];
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({ providers: values });
+  };
+
+  const filtered = useMemo(() => {
+    return possibleProviders.filter((p) => p.toLowerCase().includes(searchValue.toLowerCase()));
+  }, [searchValue, possibleProviders]);
+
+  return (
+    <SelectProvider value={values("providers")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+      >
+        <ComboBox placeholder="Filter by provider..." value={searchValue} />
+        <SelectList>
+          {filtered.map((provider) => (
+            <SelectItem key={provider} value={provider} icon={<ServerIcon className="size-4" />}>
+              {provider}
+            </SelectItem>
+          ))}
+          {filtered.length === 0 && <SelectItem disabled>No providers found</SelectItem>}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/QueryWidget.tsx b/apps/webapp/app/components/metrics/QueryWidget.tsx
new file mode 100644
index 00000000000..cde5465721b
--- /dev/null
+++ b/apps/webapp/app/components/metrics/QueryWidget.tsx
@@ -0,0 +1,528 @@
+import { DocumentDuplicateIcon, PencilSquareIcon, TrashIcon } from "@heroicons/react/20/solid";
+import { ClipboardIcon } from "@heroicons/react/24/outline";
+import { ChartBarIcon } from "@heroicons/react/24/solid";
+import { type OutputColumnMetadata } from "@internal/tsql";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { IconBraces, IconChartHistogram, IconFileTypeCsv } from "@tabler/icons-react";
+import { assertNever } from "assert-never";
+import { Maximize2 } from "lucide-react";
+import { useCallback, useRef, useState, type ReactNode } from "react";
+import { z } from "zod";
+import { Card } from "~/components/primitives/charts/Card";
+import { ShortcutKey } from "~/components/primitives/ShortcutKey";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { useShortcutKeys } from "~/hooks/useShortcutKeys";
+import { cn } from "~/utils/cn";
+import { rowsToCSV, rowsToJSON } from "~/utils/dataExport";
+import { QueryResultsChart } from "../code/QueryResultsChart";
+import { TSQLResultsTable } from "../code/TSQLResultsTable";
+import { Button } from "../primitives/Buttons";
+import { Callout } from "../primitives/Callout";
+import { BigNumberCard } from "../primitives/charts/BigNumberCard";
+import { Dialog, DialogContent, DialogFooter, DialogHeader } from "../primitives/Dialog";
+import { Input } from "../primitives/Input";
+import { InputGroup } from "../primitives/InputGroup";
+import { Label } from "../primitives/Label";
+import { LoadingBarDivider } from "../primitives/LoadingBarDivider";
+import {
+  Popover,
+  PopoverContent,
+  PopoverMenuItem,
+  PopoverVerticalEllipseTrigger,
+} from "../primitives/Popover";
+
+const ChartType = z.union([z.literal("bar"), z.literal("line")]);
+export type ChartType = z.infer<typeof ChartType>;
+
+const SortDirection = z.union([z.literal("asc"), z.literal("desc")]);
+export type SortDirection = z.infer<typeof SortDirection>;
+
+const AggregationType = z.union([
+  z.literal("sum"),
+  z.literal("avg"),
+  z.literal("count"),
+  z.literal("min"),
+  z.literal("max"),
+]);
+export type AggregationType = z.infer<typeof AggregationType>;
+
+const chartConfigOptions = {
+  chartType: ChartType,
+  xAxisColumn: z.string().nullable(),
+  yAxisColumns: z.string().array(),
+  groupByColumn: z.string().nullable(),
+  stacked: z.boolean(),
+  sortByColumn: z.string().nullable(),
+  sortDirection: SortDirection,
+  aggregation: AggregationType,
+  seriesColors: z.record(z.string()).optional(),
+};
+
+const ChartConfiguration = z.object({ ...chartConfigOptions });
+export type ChartConfiguration = z.infer<typeof ChartConfiguration>;
+
+const BigNumberAggregationType = z.union([
+  z.literal("sum"),
+  z.literal("avg"),
+  z.literal("count"),
+  z.literal("min"),
+  z.literal("max"),
+  z.literal("first"),
+  z.literal("last"),
+]);
+export type BigNumberAggregationType = z.infer<typeof BigNumberAggregationType>;
+
+const BigNumberSortDirection = z.union([z.literal("asc"), z.literal("desc")]);
+
+const bigNumberConfigOptions = {
+  column: z.string(),
+  aggregation: BigNumberAggregationType,
+  sortDirection: BigNumberSortDirection.optional(),
+  abbreviate: z.boolean().default(false),
+  prefix: z.string().optional(),
+  suffix: z.string().optional(),
+};
+
+const BigNumberConfiguration = z.object({ ...bigNumberConfigOptions });
+export type BigNumberConfiguration = z.infer<typeof BigNumberConfiguration>;
+
+export const QueryWidgetConfig = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("table"),
+    prettyFormatting: z.boolean().default(true),
+    sorting: z
+      .array(
+        z.object({
+          desc: z.boolean(),
+          id: z.string(),
+        })
+      )
+      .default([]),
+  }),
+  z.object({
+    type: z.literal("chart"),
+    ...chartConfigOptions,
+  }),
+  z.object({
+    type: z.literal("bignumber"),
+    ...bigNumberConfigOptions,
+  }),
+  z.object({
+    type: z.literal("title"),
+  }),
+]);
+
+export type QueryWidgetConfig = z.infer<typeof QueryWidgetConfig>;
+
+/** Result data containing rows and column metadata */
+export type QueryWidgetData = {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+};
+
+/** Widget configuration with optional result data (used for edit callbacks) */
+export type WidgetData = {
+  title: string;
+  query: string;
+  display: QueryWidgetConfig;
+  /** The current result data from the widget */
+  resultData?: QueryWidgetData;
+};
+
+export type QueryWidgetProps = {
+  title: ReactNode;
+  /** String title for rename dialog (optional - if not provided, rename won't be available) */
+  titleString?: string;
+  /** The TSQL query string (used for "Copy query" in the menu) */
+  query?: string;
+  isLoading?: boolean;
+  error?: string;
+  data: QueryWidgetData;
+  config: QueryWidgetConfig;
+  /** The effective time range for the query (used to show full x-axis on time-based charts) */
+  timeRange?: { from: string; to: string };
+  accessory?: ReactNode;
+  isResizing?: boolean;
+  isDraggable?: boolean;
+  /** Additional className applied to the Card wrapper */
+  className?: string;
+  /** Callback when edit is clicked. Receives the current data. */
+  onEdit?: (data: QueryWidgetData) => void;
+  /** Callback when rename is clicked. Receives the new title. */
+  onRename?: (newTitle: string) => void;
+  /** Callback when delete is clicked. */
+  onDelete?: () => void;
+  /** Callback when duplicate is clicked. Receives the current data. */
+  onDuplicate?: (data: QueryWidgetData) => void;
+  /** When true, show table column headers even when there are no rows */
+  showTableHeaderOnEmpty?: boolean;
+  /** Column names to hide from table display but keep in row data (useful for linking) */
+  hiddenColumns?: string[];
+};
+
+export function QueryWidget({
+  title,
+  titleString,
+  query,
+  accessory,
+  isLoading,
+  error,
+  isResizing,
+  isDraggable,
+  className,
+  onEdit,
+  onRename,
+  onDelete,
+  onDuplicate,
+  ...props
+}: QueryWidgetProps) {
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const [isRenameDialogOpen, setIsRenameDialogOpen] = useState(false);
+  const [renameValue, setRenameValue] = useState(titleString ?? "");
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const hasEditActions = onEdit || onRename || onDelete || onDuplicate;
+  const hasData = props.data.rows.length > 0;
+
+  // "v" to toggle fullscreen on hovered widget
+  useShortcutKeys({
+    shortcut: { key: "v" },
+    action: useCallback(() => {
+      const isHovered = containerRef.current?.matches(":hover");
+      if (!isFullscreen && !isHovered) return;
+      setIsFullscreen((prev) => !prev);
+    }, [isFullscreen]),
+  });
+
+  const copyToClipboard = useCallback((text: string) => {
+    navigator.clipboard.writeText(text);
+  }, []);
+
+  const copyQuery = useCallback(() => {
+    if (query) {
+      copyToClipboard(query);
+    }
+  }, [query, copyToClipboard]);
+
+  const copyJSON = useCallback(() => {
+    copyToClipboard(rowsToJSON(props.data.rows));
+  }, [props.data.rows, copyToClipboard]);
+
+  const copyCSV = useCallback(() => {
+    copyToClipboard(rowsToCSV(props.data.rows, props.data.columns));
+  }, [props.data, copyToClipboard]);
+
+  return (
+    <div ref={containerRef} className="group h-full">
+      <Card className={cn("h-full overflow-hidden px-0 pb-0", className)}>
+        <Card.Header draggable={isDraggable}>
+          <div className="flex items-center gap-1.5">{title}</div>
+          <Card.Accessory>
+            <SimpleTooltip
+              button={
+                <span className="opacity-0 transition-opacity group-hover:opacity-100">
+                  <Button
+                    variant="minimal/small"
+                    LeadingIcon={Maximize2}
+                    leadingIconClassName="text-text-dimmed group-hover/button:text-text-bright"
+                    onClick={() => setIsFullscreen(true)}
+                    className="!px-1"
+                  />
+                </span>
+              }
+              content={
+                <span className="flex items-center gap-1">
+                  Maximize
+                  <ShortcutKey shortcut={{ key: "v" }} variant="small/bright" />
+                </span>
+              }
+              asChild
+            />
+            <Popover open={isMenuOpen} onOpenChange={setIsMenuOpen}>
+              <PopoverVerticalEllipseTrigger
+                isOpen={isMenuOpen}
+                className={cn(
+                  "transition-opacity",
+                  isMenuOpen ? "opacity-100" : "opacity-0 group-hover:opacity-100"
+                )}
+              />
+              <PopoverContent align="end" className="p-0">
+                <div className="flex flex-col gap-1 p-1">
+                  {hasEditActions && (
+                    <>
+                      {onEdit && (
+                        <PopoverMenuItem
+                          icon={IconChartHistogram}
+                          title="Edit chart"
+                          onClick={() => {
+                            onEdit(props.data);
+                            setIsMenuOpen(false);
+                          }}
+                          leadingIconClassName="-ml-0.5 -mr-1"
+                        />
+                      )}
+                      {onRename && (
+                        <PopoverMenuItem
+                          icon={PencilSquareIcon}
+                          title="Rename"
+                          onClick={() => {
+                            setRenameValue(titleString ?? "");
+                            setIsRenameDialogOpen(true);
+                            setIsMenuOpen(false);
+                          }}
+                        />
+                      )}
+                      {onDuplicate && (
+                        <PopoverMenuItem
+                          icon={DocumentDuplicateIcon}
+                          title="Duplicate chart"
+                          onClick={() => {
+                            onDuplicate(props.data);
+                            setIsMenuOpen(false);
+                          }}
+                          className="pr-4"
+                        />
+                      )}
+                    </>
+                  )}
+                  {query && (
+                    <PopoverMenuItem
+                      icon={ClipboardIcon}
+                      title="Copy query"
+                      onClick={() => {
+                        copyQuery();
+                        setIsMenuOpen(false);
+                      }}
+                    />
+                  )}
+                  <PopoverMenuItem
+                    icon={IconBraces}
+                    title="Copy JSON"
+                    disabled={!hasData}
+                    onClick={() => {
+                      copyJSON();
+                      setIsMenuOpen(false);
+                    }}
+                    leadingIconClassName="-ml-0.5 -mr-1"
+                  />
+                  <PopoverMenuItem
+                    icon={IconFileTypeCsv}
+                    title="Copy CSV"
+                    disabled={!hasData}
+                    onClick={() => {
+                      copyCSV();
+                      setIsMenuOpen(false);
+                    }}
+                    leadingIconClassName="-ml-0.5 -mr-1"
+                  />
+                  {onDelete && (
+                    <PopoverMenuItem
+                      icon={TrashIcon}
+                      title="Delete chart"
+                      leadingIconClassName="text-error"
+                      className="text-error hover:!bg-error/10"
+                      onClick={() => {
+                        onDelete();
+                        setIsMenuOpen(false);
+                      }}
+                    />
+                  )}
+                </div>
+              </PopoverContent>
+            </Popover>
+            {accessory}
+          </Card.Accessory>
+        </Card.Header>
+        <LoadingBarDivider isLoading={isLoading ?? false} className="bg-transparent" />
+        <Card.Content className="min-h-0 flex-1 overflow-hidden p-0">
+          {isResizing ? (
+            <div className="flex h-full flex-1 items-center justify-center p-3">
+              <div className="flex flex-col items-center gap-1 text-text-dimmed">
+                <ChartBarIcon className="size-10 text-text-dimmed" />{" "}
+                <span className="text-base font-medium">Resizing...</span>
+              </div>
+            </div>
+          ) : error ? (
+            <div className="p-3">
+              <Callout variant="error">{error}</Callout>
+            </div>
+          ) : (
+            <QueryWidgetBody
+              {...props}
+              title={title}
+              isFullscreen={isFullscreen}
+              setIsFullscreen={setIsFullscreen}
+              isLoading={isLoading ?? false}
+            />
+          )}
+        </Card.Content>
+      </Card>
+
+      {/* Rename Dialog */}
+      {onRename && (
+        <Dialog open={isRenameDialogOpen} onOpenChange={setIsRenameDialogOpen}>
+          <DialogContent className="sm:max-w-md">
+            <DialogHeader>Rename chart</DialogHeader>
+            <form
+              className="space-y-4 pt-3"
+              onSubmit={(e) => {
+                e.preventDefault();
+                if (renameValue.trim()) {
+                  onRename(renameValue.trim());
+                  setIsRenameDialogOpen(false);
+                }
+              }}
+            >
+              <InputGroup>
+                <Label>Title</Label>
+                <Input
+                  value={renameValue}
+                  onChange={(e) => setRenameValue(e.target.value)}
+                  placeholder="Chart title"
+                  autoFocus
+                />
+              </InputGroup>
+              <DialogFooter>
+                <DialogClose asChild>
+                  <Button variant="tertiary/medium">Cancel</Button>
+                </DialogClose>
+                <Button type="submit" variant="primary/medium" disabled={!renameValue.trim()}>
+                  Save
+                </Button>
+              </DialogFooter>
+            </form>
+          </DialogContent>
+        </Dialog>
+      )}
+    </div>
+  );
+}
+
+type QueryWidgetBodyProps = {
+  title: ReactNode;
+  data: QueryWidgetData;
+  config: QueryWidgetConfig;
+  timeRange?: { from: string; to: string };
+  isFullscreen: boolean;
+  setIsFullscreen: (open: boolean) => void;
+  isLoading: boolean;
+  showTableHeaderOnEmpty?: boolean;
+  hiddenColumns?: string[];
+};
+
+function QueryWidgetBody({
+  title,
+  data,
+  config,
+  timeRange,
+  isFullscreen,
+  setIsFullscreen,
+  isLoading,
+  showTableHeaderOnEmpty,
+  hiddenColumns,
+}: QueryWidgetBodyProps) {
+  const type = config.type;
+
+  // Only show the loading state if we have no data yet (initial load).
+  // During a reload with existing data, keep showing the current data
+  // while the loading bar in the header indicates a refresh is in progress.
+  const hasData = data.rows.length > 0;
+  const showLoading = isLoading && !hasData;
+
+  switch (type) {
+    case "table": {
+      return (
+        <>
+          <TSQLResultsTable
+            rows={data.rows}
+            columns={data.columns}
+            prettyFormatting={config.prettyFormatting}
+            sorting={config.sorting}
+            showHeaderOnEmpty={showTableHeaderOnEmpty}
+            hiddenColumns={hiddenColumns}
+          />
+          <Dialog open={isFullscreen} onOpenChange={setIsFullscreen}>
+            <DialogContent
+              fullscreen
+              className="flex flex-col gap-0 bg-background-bright px-0 pb-0"
+            >
+              <DialogHeader className="px-4">{title}</DialogHeader>
+              <div className="min-h-0 w-full flex-1 pt-2.5">
+                <TSQLResultsTable
+                  rows={data.rows}
+                  columns={data.columns}
+                  prettyFormatting={config.prettyFormatting}
+                  sorting={config.sorting}
+                  showHeaderOnEmpty={showTableHeaderOnEmpty}
+                />
+              </div>
+            </DialogContent>
+          </Dialog>
+        </>
+      );
+    }
+    case "chart": {
+      return (
+        <>
+          <QueryResultsChart
+            rows={data.rows}
+            columns={data.columns}
+            config={config}
+            timeRange={timeRange}
+            onViewAllLegendItems={() => setIsFullscreen(true)}
+            isLoading={showLoading}
+          />
+          <Dialog open={isFullscreen} onOpenChange={setIsFullscreen}>
+            <DialogContent fullscreen className="flex flex-col bg-background-bright">
+              <DialogHeader>{title}</DialogHeader>
+              <div className="min-h-0 w-full flex-1 overflow-hidden pt-4">
+                <QueryResultsChart
+                  rows={data.rows}
+                  columns={data.columns}
+                  config={config}
+                  timeRange={timeRange}
+                  fullLegend
+                  legendScrollable
+                  isLoading={showLoading}
+                />
+              </div>
+            </DialogContent>
+          </Dialog>
+        </>
+      );
+    }
+    case "bignumber": {
+      return (
+        <>
+          <BigNumberCard
+            rows={data.rows}
+            columns={data.columns}
+            config={config}
+            isLoading={showLoading}
+          />
+          <Dialog open={isFullscreen} onOpenChange={setIsFullscreen}>
+            <DialogContent fullscreen className="flex flex-col bg-background-bright">
+              <DialogHeader>{title}</DialogHeader>
+              <div className="flex min-h-0 w-full flex-1 items-center justify-center pt-4">
+                <BigNumberCard
+                  rows={data.rows}
+                  columns={data.columns}
+                  config={config}
+                  isLoading={showLoading}
+                />
+              </div>
+            </DialogContent>
+          </Dialog>
+        </>
+      );
+    }
+    case "title": {
+      // Title widgets are rendered by TitleWidget, not QueryWidget
+      return null;
+    }
+    default: {
+      assertNever(type);
+    }
+  }
+}
diff --git a/apps/webapp/app/components/metrics/QueuesFilter.tsx b/apps/webapp/app/components/metrics/QueuesFilter.tsx
new file mode 100644
index 00000000000..87d7a612547
--- /dev/null
+++ b/apps/webapp/app/components/metrics/QueuesFilter.tsx
@@ -0,0 +1,212 @@
+import * as Ariakit from "@ariakit/react";
+import { RectangleStackIcon } from "@heroicons/react/20/solid";
+import { useFetcher } from "@remix-run/react";
+import { matchSorter } from "match-sorter";
+import { type ReactNode, useMemo } from "react";
+import { TaskIcon } from "~/assets/icons/TaskIcon";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { Spinner } from "~/components/primitives/Spinner";
+import { useDebounceEffect } from "~/hooks/useDebounce";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { type loader as queuesLoader } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues";
+import { appliedSummary, FilterMenuProvider } from "~/components/runs/v3/SharedFilters";
+
+const shortcut = { key: "q" };
+
+export function QueuesFilter() {
+  const { values, replace, del } = useSearchParams();
+  const selectedQueues = values("queues");
+
+  if (selectedQueues.length === 0 || selectedQueues.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <QueuesDropdown
+            trigger={
+              <SelectTrigger
+                icon={<RectangleStackIcon className="size-4" />}
+                variant="secondary/small"
+                shortcut={shortcut}
+                tooltipTitle="Filter by queue"
+              >
+                <span className="ml-1">Queues</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <QueuesDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Queues"
+                icon={<RectangleStackIcon className="size-4" />}
+                value={appliedSummary(selectedQueues.map((v) => v.replace("task/", "")))}
+                onRemove={() => del(["queues"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function QueuesDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+}) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({
+      queues: values.length > 0 ? values : undefined,
+    });
+  };
+
+  const queueValues = values("queues").filter((v) => v !== "");
+  const selected = queueValues.length > 0 ? queueValues : undefined;
+
+  const fetcher = useFetcher<typeof queuesLoader>();
+
+  useDebounceEffect(
+    searchValue,
+    (s) => {
+      const searchParams = new URLSearchParams();
+      searchParams.set("per_page", "25");
+      if (searchValue) {
+        searchParams.set("query", s);
+      }
+      fetcher.load(
+        `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${
+          environment.slug
+        }/queues?${searchParams.toString()}`
+      );
+    },
+    250
+  );
+
+  const filtered = useMemo(() => {
+    // Use a Map to deduplicate by value
+    const itemsMap = new Map<string, { name: string; type: "custom" | "task"; value: string }>();
+
+    // Add selected items first (for items not yet loaded from fetcher)
+    for (const queueName of selected ?? []) {
+      const queueItem = fetcher.data?.queues.find((q) => q.name === queueName);
+      if (!queueItem) {
+        if (queueName.startsWith("task/")) {
+          itemsMap.set(queueName, {
+            name: queueName.replace("task/", ""),
+            type: "task",
+            value: queueName,
+          });
+        } else {
+          itemsMap.set(queueName, {
+            name: queueName,
+            type: "custom",
+            value: queueName,
+          });
+        }
+      }
+    }
+
+    // Add items from fetcher data
+    if (fetcher.data !== undefined) {
+      for (const q of fetcher.data.queues) {
+        const value = q.type === "task" ? `task/${q.name}` : q.name;
+        itemsMap.set(value, {
+          name: q.name,
+          type: q.type,
+          value,
+        });
+      }
+    }
+
+    const items = Array.from(itemsMap.values());
+    return matchSorter(items, searchValue, {
+      keys: ["name"],
+    });
+  }, [searchValue, fetcher.data, selected]);
+
+  return (
+    <SelectProvider value={selected ?? []} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+
+          return true;
+        }}
+      >
+        <ComboBox
+          value={searchValue}
+          render={(props) => (
+            <div className="flex items-center justify-stretch">
+              <input {...props} placeholder={"Filter by queues..."} />
+              {fetcher.state === "loading" && <Spinner color="muted" />}
+            </div>
+          )}
+        />
+        <SelectList>
+          {filtered.length > 0
+            ? filtered.map((queue) => (
+                <SelectItem
+                  key={queue.value}
+                  value={queue.value}
+                  icon={
+                    queue.type === "task" ? (
+                      <TaskIcon className="size-4 shrink-0 text-blue-500" />
+                    ) : (
+                      <RectangleStackIcon className="size-4 shrink-0 text-purple-500" />
+                    )
+                  }
+                >
+                  {queue.name}
+                </SelectItem>
+              ))
+            : null}
+          {filtered.length === 0 && fetcher.state !== "loading" && (
+            <SelectItem disabled>No queues found</SelectItem>
+          )}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/SaveToDashboardDialog.tsx b/apps/webapp/app/components/metrics/SaveToDashboardDialog.tsx
new file mode 100644
index 00000000000..828ff2b9113
--- /dev/null
+++ b/apps/webapp/app/components/metrics/SaveToDashboardDialog.tsx
@@ -0,0 +1,181 @@
+import { DialogClose } from "@radix-ui/react-dialog";
+import { useFetcher, useNavigate } from "@remix-run/react";
+import { IconCheck } from "@tabler/icons-react";
+import { useEffect, useState } from "react";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import {
+  useCustomDashboards,
+  useOrganization,
+  useWidgetLimitPerDashboard,
+} from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { cn } from "~/utils/cn";
+import { v3CustomDashboardPath } from "~/utils/pathBuilder";
+import { Button } from "../primitives/Buttons";
+import { Dialog, DialogContent, DialogHeader } from "../primitives/Dialog";
+import { FormButtons } from "../primitives/FormButtons";
+import { Paragraph } from "../primitives/Paragraph";
+import type { QueryWidgetConfig } from "./QueryWidget";
+
+export type SaveToDashboardDialogProps = {
+  title: string;
+  query: string;
+  config: QueryWidgetConfig;
+  isOpen: boolean;
+  onOpenChange: (open: boolean) => void;
+};
+
+export function SaveToDashboardDialog({
+  title,
+  query,
+  config,
+  isOpen,
+  onOpenChange,
+}: SaveToDashboardDialogProps) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const customDashboards = useCustomDashboards();
+  const widgetLimit = useWidgetLimitPerDashboard();
+  const fetcher = useFetcher<{ success: boolean }>();
+  const navigate = useNavigate();
+
+  // Find the first dashboard that isn't at the widget limit
+  const firstAvailableDashboard = customDashboards.find((d) => d.widgetCount < widgetLimit);
+
+  const [selectedDashboardId, setSelectedDashboardId] = useState<string | null>(
+    firstAvailableDashboard?.friendlyId ?? customDashboards[0]?.friendlyId ?? null
+  );
+
+  // Build the form action URL
+  const formAction = selectedDashboardId
+    ? `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/dashboards/${selectedDashboardId}/widgets`
+    : "";
+
+  const isLoading = fetcher.state === "submitting";
+
+  // Check if selected dashboard is at widget limit
+  const selectedDashboard = customDashboards.find((d) => d.friendlyId === selectedDashboardId);
+  const isSelectedAtLimit = selectedDashboard
+    ? selectedDashboard.widgetCount >= widgetLimit
+    : false;
+
+  // Navigate to the dashboard when the fetcher completes successfully
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data?.success && selectedDashboardId) {
+      onOpenChange(false);
+      navigate(
+        v3CustomDashboardPath(
+          { slug: organization.slug },
+          { slug: project.slug },
+          { slug: environment.slug },
+          { friendlyId: selectedDashboardId }
+        )
+      );
+    }
+  }, [fetcher.state, fetcher.data, selectedDashboardId, onOpenChange, navigate, organization.slug, project.slug, environment.slug]);
+
+  // Update selection if dashboards change
+  useEffect(() => {
+    if (customDashboards.length > 0 && !selectedDashboardId) {
+      const available = customDashboards.find((d) => d.widgetCount < widgetLimit);
+      setSelectedDashboardId(available?.friendlyId ?? customDashboards[0].friendlyId);
+    }
+  }, [customDashboards, selectedDashboardId, widgetLimit]);
+
+  if (customDashboards.length === 0) {
+    return (
+      <Dialog open={isOpen} onOpenChange={onOpenChange}>
+        <DialogContent className="sm:max-w-sm">
+          <DialogHeader>Add to dashboard</DialogHeader>
+          <div className="!mt-1 space-y-4">
+            <Paragraph variant="small" className="text-text-dimmed">
+              You don't have any custom dashboards yet. Create one first from the sidebar menu.
+            </Paragraph>
+            <FormButtons
+              className="justify-end"
+              cancelButton={
+                <DialogClose asChild>
+                  <Button variant="secondary/medium">Close</Button>
+                </DialogClose>
+              }
+            />
+          </div>
+        </DialogContent>
+      </Dialog>
+    );
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-sm">
+        <DialogHeader>Add to dashboard</DialogHeader>
+        <fetcher.Form method="post" action={formAction} className="space-y-4">
+          <input type="hidden" name="action" value="add" />
+          <input type="hidden" name="title" value={title} />
+          <input type="hidden" name="query" value={query} />
+          <input type="hidden" name="config" value={JSON.stringify(config)} />
+
+          <div className="!mt-1 space-y-2">
+            <Paragraph variant="small" className="text-text-dimmed">
+              Select a dashboard to add this chart to:
+            </Paragraph>
+            <div className="max-h-64 space-y-1 overflow-y-auto">
+              {customDashboards.map((dashboard) => {
+                const isAtLimit = dashboard.widgetCount >= widgetLimit;
+                return (
+                  <button
+                    key={dashboard.friendlyId}
+                    type="button"
+                    onClick={() => !isAtLimit && setSelectedDashboardId(dashboard.friendlyId)}
+                    disabled={isAtLimit}
+                    className={cn(
+                      "flex w-full items-center gap-2 rounded-md px-3 py-2 text-left text-sm transition",
+                      isAtLimit
+                        ? "cursor-not-allowed opacity-50"
+                        : selectedDashboardId === dashboard.friendlyId
+                        ? "bg-charcoal-700 text-text-bright"
+                        : "text-text-dimmed hover:bg-charcoal-750 hover:text-text-bright"
+                    )}
+                  >
+                    {selectedDashboardId === dashboard.friendlyId ? (
+                      <IconCheck className="size-4 shrink-0 text-green-500" />
+                    ) : (
+                      <span className="size-4 shrink-0" />
+                    )}
+                    <span className="flex-1 truncate">{dashboard.title}</span>
+                    <span
+                      className={cn(
+                        "shrink-0 text-xs",
+                        isAtLimit ? "text-error" : "text-text-dimmed"
+                      )}
+                    >
+                      {dashboard.widgetCount}/{widgetLimit}
+                    </span>
+                  </button>
+                );
+              })}
+            </div>
+          </div>
+
+          <FormButtons
+            confirmButton={
+              <Button
+                type="submit"
+                variant="primary/medium"
+                disabled={isLoading || !selectedDashboardId || isSelectedAtLimit}
+              >
+                {isLoading ? "Saving..." : "Save"}
+              </Button>
+            }
+            cancelButton={
+              <DialogClose asChild>
+                <Button variant="secondary/medium">Cancel</Button>
+              </DialogClose>
+            }
+          />
+        </fetcher.Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/components/metrics/ScopeFilter.tsx b/apps/webapp/app/components/metrics/ScopeFilter.tsx
new file mode 100644
index 00000000000..1bf6b685676
--- /dev/null
+++ b/apps/webapp/app/components/metrics/ScopeFilter.tsx
@@ -0,0 +1,64 @@
+import * as Ariakit from "@ariakit/react";
+import { EnvironmentLabel } from "~/components/environments/EnvironmentLabel";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import { SelectItem, SelectPopover, SelectProvider } from "~/components/primitives/Select";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import type { QueryScope } from "~/services/queryService.server";
+import { CubeTransparentIcon, GlobeAltIcon } from "@heroicons/react/20/solid";
+import { IconListLetters } from "@tabler/icons-react";
+
+const scopeOptions = [
+  { value: "environment", label: "Environment" },
+  { value: "project", label: "Project" },
+  { value: "organization", label: "Organization" },
+] as const;
+
+export function ScopeFilter() {
+  const { value, replace } = useSearchParams();
+  const scope = (value("scope") as QueryScope) ?? "environment";
+
+  const handleChange = (newScope: string) => {
+    replace({ scope: newScope === "environment" ? undefined : newScope });
+  };
+
+  return (
+    <SelectProvider value={scope} setValue={handleChange}>
+      <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+        <AppliedFilter
+          label="Scope"
+          icon={<CubeTransparentIcon className="size-4" />}
+          value={<ScopeItem scope={scope} />}
+          removable={false}
+          variant="secondary/small"
+        />
+      </Ariakit.Select>
+      <SelectPopover className="min-w-0 max-w-[min(240px,var(--popover-available-width))]">
+        {scopeOptions.map((option) => (
+          <SelectItem key={option.value} value={option.value}>
+            <ScopeItem scope={option.value} />
+          </SelectItem>
+        ))}
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function ScopeItem({ scope }: { scope: QueryScope }) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  switch (scope) {
+    case "organization":
+      return `Org: ${organization.title}`;
+    case "project":
+      return `Project: ${project.name}`;
+    case "environment":
+      return <EnvironmentLabel environment={environment} />;
+    default:
+      return scope;
+  }
+}
diff --git a/apps/webapp/app/components/metrics/TitleWidget.tsx b/apps/webapp/app/components/metrics/TitleWidget.tsx
new file mode 100644
index 00000000000..0a5a7590e4d
--- /dev/null
+++ b/apps/webapp/app/components/metrics/TitleWidget.tsx
@@ -0,0 +1,125 @@
+import { useState } from "react";
+import { PencilIcon, TrashIcon } from "@heroicons/react/20/solid";
+import { cn } from "~/utils/cn";
+import { Button } from "../primitives/Buttons";
+import {
+  Popover,
+  PopoverContent,
+  PopoverMenuItem,
+  PopoverVerticalEllipseTrigger,
+} from "../primitives/Popover";
+import { Dialog, DialogContent, DialogFooter, DialogHeader } from "../primitives/Dialog";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { Input } from "../primitives/Input";
+import { InputGroup } from "../primitives/InputGroup";
+import { Label } from "../primitives/Label";
+
+export type TitleWidgetProps = {
+  title: string;
+  isDraggable?: boolean;
+  isResizing?: boolean;
+  /** Callback when rename is clicked. Receives the new title. */
+  onRename?: (newTitle: string) => void;
+  /** Callback when delete is clicked. */
+  onDelete?: () => void;
+};
+
+export function TitleWidget({
+  title,
+  isDraggable,
+  isResizing,
+  onRename,
+  onDelete,
+}: TitleWidgetProps) {
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const [isRenameDialogOpen, setIsRenameDialogOpen] = useState(false);
+  const [renameValue, setRenameValue] = useState(title);
+
+  const hasMenu = onRename || onDelete;
+
+  return (
+    <div className="h-full">
+      <div
+        className={cn(
+          "group flex h-full items-center gap-2 rounded-lg border border-grid-bright bg-background-bright px-4",
+          isDraggable && "drag-handle cursor-grab active:cursor-grabbing"
+        )}
+      >
+        <span className="min-w-0 flex-1 truncate text-lg font-medium text-text-bright">
+          {title}
+        </span>
+        {hasMenu && (
+          <div className="flex-shrink-0 opacity-0 transition-opacity group-hover:opacity-100">
+            <Popover open={isMenuOpen} onOpenChange={setIsMenuOpen}>
+              <PopoverVerticalEllipseTrigger isOpen={isMenuOpen} />
+              <PopoverContent align="end" className="p-0">
+                <div className="flex flex-col gap-1 p-1">
+                  {onRename && (
+                    <PopoverMenuItem
+                      icon={PencilIcon}
+                      title="Rename"
+                      onClick={() => {
+                        setRenameValue(title);
+                        setIsRenameDialogOpen(true);
+                        setIsMenuOpen(false);
+                      }}
+                    />
+                  )}
+                  {onDelete && (
+                    <PopoverMenuItem
+                      icon={TrashIcon}
+                      title="Delete"
+                      leadingIconClassName="text-error"
+                      className="text-error hover:!bg-error/10"
+                      onClick={() => {
+                        onDelete();
+                        setIsMenuOpen(false);
+                      }}
+                    />
+                  )}
+                </div>
+              </PopoverContent>
+            </Popover>
+          </div>
+        )}
+      </div>
+
+      {/* Rename Dialog */}
+      {onRename && (
+        <Dialog open={isRenameDialogOpen} onOpenChange={setIsRenameDialogOpen}>
+          <DialogContent className="sm:max-w-md">
+            <DialogHeader>Rename title</DialogHeader>
+            <form
+              className="space-y-4 pt-3"
+              onSubmit={(e) => {
+                e.preventDefault();
+                if (renameValue.trim()) {
+                  onRename(renameValue.trim());
+                  setIsRenameDialogOpen(false);
+                }
+              }}
+            >
+              <InputGroup>
+                <Label>Title</Label>
+                <Input
+                  value={renameValue}
+                  onChange={(e) => setRenameValue(e.target.value)}
+                  placeholder="Section title"
+                  autoFocus
+                />
+              </InputGroup>
+              <DialogFooter>
+                <DialogClose asChild>
+                  <Button variant="tertiary/medium">Cancel</Button>
+                </DialogClose>
+                <Button type="submit" variant="primary/medium" disabled={!renameValue.trim()}>
+                  Save
+                </Button>
+              </DialogFooter>
+            </form>
+          </DialogContent>
+        </Dialog>
+      )}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/navigation/AccountSideMenu.tsx b/apps/webapp/app/components/navigation/AccountSideMenu.tsx
index 30bf2c19258..5c74658f51d 100644
--- a/apps/webapp/app/components/navigation/AccountSideMenu.tsx
+++ b/apps/webapp/app/components/navigation/AccountSideMenu.tsx
@@ -8,10 +8,11 @@ import {
   personalAccessTokensPath,
   rootPath,
 } from "~/utils/pathBuilder";
+import { AskAI } from "../AskAI";
 import { LinkButton } from "../primitives/Buttons";
+import { HelpAndFeedback } from "./HelpAndFeedbackPopover";
 import { SideMenuHeader } from "./SideMenuHeader";
 import { SideMenuItem } from "./SideMenuItem";
-import { HelpAndFeedback } from "./HelpAndFeedbackPopover";
 
 export function AccountSideMenu({ user }: { user: User }) {
   return (
@@ -55,8 +56,9 @@ export function AccountSideMenu({ user }: { user: User }) {
           data-action="security"
         />
       </div>
-      <div className="flex flex-col gap-1 border-t border-grid-bright p-1">
+      <div className="flex w-full items-center justify-between border-t border-grid-bright p-1">
         <HelpAndFeedback />
+        <AskAI />
       </div>
     </div>
   );
diff --git a/apps/webapp/app/components/navigation/DashboardDialogs.tsx b/apps/webapp/app/components/navigation/DashboardDialogs.tsx
new file mode 100644
index 00000000000..f0cdd0406e0
--- /dev/null
+++ b/apps/webapp/app/components/navigation/DashboardDialogs.tsx
@@ -0,0 +1,310 @@
+import { DialogClose } from "@radix-ui/react-dialog";
+import { Form, useNavigation } from "@remix-run/react";
+import { motion } from "framer-motion";
+import { ArrowUpCircleIcon } from "@heroicons/react/24/outline";
+import { PlusIcon } from "@heroicons/react/20/solid";
+import { useEffect, useState } from "react";
+import { type MatchedOrganization, useDashboardLimits } from "~/hooks/useOrganizations";
+import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
+import { Feedback } from "~/components/Feedback";
+import { Button, LinkButton } from "../primitives/Buttons";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTrigger,
+} from "../primitives/Dialog";
+import { FormButtons } from "../primitives/FormButtons";
+import { Input } from "../primitives/Input";
+import { InputGroup } from "../primitives/InputGroup";
+import { Label } from "../primitives/Label";
+import { Paragraph } from "../primitives/Paragraph";
+import { TextLink } from "../primitives/TextLink";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../primitives/Tooltip";
+import { v3BillingPath } from "~/utils/pathBuilder";
+import { type SideMenuEnvironment, type SideMenuProject } from "./SideMenu";
+
+function useCreateDashboard({
+  organization,
+  project,
+  environment,
+}: {
+  organization: { slug: string };
+  project: { slug: string };
+  environment: { slug: string };
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+  const navigation = useNavigation();
+  const limits = useDashboardLimits();
+  const plan = useCurrentPlan();
+
+  const isAtLimit = limits.used >= limits.limit;
+  const planLimits = (plan?.v3Subscription?.plan?.limits as any)?.metricDashboards;
+  const canExceed = typeof planLimits === "object" && planLimits.canExceed === true;
+  const canUpgrade = plan?.v3Subscription?.plan && !canExceed;
+  const isFreePlan = plan?.v3Subscription?.isPaying === false;
+
+  const formAction = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/dashboards/create`;
+
+  useEffect(() => {
+    if (navigation.formAction === formAction && navigation.state === "loading") {
+      setIsOpen(false);
+    }
+  }, [navigation.formAction, navigation.state, formAction]);
+
+  return {
+    isOpen,
+    setIsOpen,
+    isAtLimit,
+    canUpgrade: !!canUpgrade,
+    isFreePlan,
+    formAction,
+    limits,
+    organization,
+  };
+}
+
+export function CreateDashboardButton({
+  organization,
+  project,
+  environment,
+  isCollapsed,
+}: {
+  organization: MatchedOrganization;
+  project: SideMenuProject;
+  environment: SideMenuEnvironment;
+  isCollapsed: boolean;
+}) {
+  const dashboard = useCreateDashboard({ organization, project, environment });
+
+  if (isCollapsed) return null;
+
+  return (
+    <Dialog open={dashboard.isOpen} onOpenChange={dashboard.setIsOpen}>
+      <TooltipProvider disableHoverableContent>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <DialogTrigger asChild>
+              <button
+                type="button"
+                className="flex h-full w-full items-center justify-center rounded text-text-dimmed transition focus-custom hover:bg-charcoal-600 hover:text-text-bright"
+              >
+                <PlusIcon className="size-4" />
+              </button>
+            </DialogTrigger>
+          </TooltipTrigger>
+          <TooltipContent side="right" className="text-xs">
+            Create dashboard
+          </TooltipContent>
+        </Tooltip>
+      </TooltipProvider>
+      {dashboard.isAtLimit ? (
+        <CreateDashboardUpgradeDialog
+          limits={dashboard.limits}
+          canUpgrade={dashboard.canUpgrade}
+          isFreePlan={dashboard.isFreePlan}
+          organization={dashboard.organization}
+        />
+      ) : (
+        <CreateDashboardDialog formAction={dashboard.formAction} limits={dashboard.limits} />
+      )}
+    </Dialog>
+  );
+}
+
+export function CreateDashboardPageButton({
+  organization,
+  project,
+  environment,
+}: {
+  organization: { slug: string };
+  project: { slug: string };
+  environment: { slug: string };
+}) {
+  const dashboard = useCreateDashboard({ organization, project, environment });
+
+  return (
+    <Dialog open={dashboard.isOpen} onOpenChange={dashboard.setIsOpen}>
+      <DialogTrigger asChild>
+        <Button variant="primary/small" LeadingIcon={PlusIcon}>
+          Create custom dashboard
+        </Button>
+      </DialogTrigger>
+      {dashboard.isAtLimit ? (
+        <CreateDashboardUpgradeDialog
+          limits={dashboard.limits}
+          canUpgrade={dashboard.canUpgrade}
+          isFreePlan={dashboard.isFreePlan}
+          organization={dashboard.organization}
+        />
+      ) : (
+        <CreateDashboardDialog formAction={dashboard.formAction} limits={dashboard.limits} />
+      )}
+    </Dialog>
+  );
+}
+
+const PROGRESS_RING_R = 27.5;
+const PROGRESS_RING_CIRCUMFERENCE = 2 * Math.PI * PROGRESS_RING_R;
+const PROGRESS_COLOR_SUCCESS = "#28BF5C"; // mint-500 / success
+const PROGRESS_COLOR_ERROR = "#E11D48"; // rose-600 / error
+
+function CreateDashboardUpgradeDialog({
+  limits,
+  canUpgrade,
+  isFreePlan,
+  organization,
+}: {
+  limits: { used: number; limit: number };
+  canUpgrade: boolean;
+  isFreePlan: boolean;
+  organization: { slug: string };
+}) {
+
+  if (isFreePlan) {
+    return (
+      <DialogContent>
+        <DialogHeader>Upgrade to unlock dashboards</DialogHeader>
+        <div className="flex items-center gap-4 pt-3">
+          <ArrowUpCircleIcon className="ml-1 size-14 shrink-0 text-indigo-500" />
+          <DialogDescription className="pt-0">
+            Custom metric dashboards are available on paid plans. Upgrade to create dashboards and
+            track your task metrics.
+          </DialogDescription>
+        </div>
+        <DialogFooter className="flex justify-between">
+          <DialogClose asChild>
+            <Button variant="secondary/medium">Cancel</Button>
+          </DialogClose>
+          <LinkButton variant="primary/medium" to={v3BillingPath(organization)}>
+            Upgrade plan
+          </LinkButton>
+        </DialogFooter>
+      </DialogContent>
+    );
+  }
+
+  const percentage = Math.min(limits.used / limits.limit, 1);
+  const filled = percentage * PROGRESS_RING_CIRCUMFERENCE;
+
+  return (
+    <DialogContent>
+      <DialogHeader>Dashboard limit reached</DialogHeader>
+      <div className="flex items-center gap-4 pt-3">
+        <div className="relative ml-1 mt-2 shrink-0" style={{ width: 60, height: 60 }}>
+          <svg className="h-full w-full -rotate-90 overflow-visible">
+            <circle
+              className="fill-none stroke-grid-bright"
+              strokeWidth="5"
+              r={PROGRESS_RING_R}
+              cx="30"
+              cy="30"
+            />
+            <motion.circle
+              className="fill-none"
+              strokeWidth="5"
+              r={PROGRESS_RING_R}
+              cx="30"
+              cy="30"
+              strokeLinecap="round"
+              initial={{
+                strokeDasharray: `0 ${PROGRESS_RING_CIRCUMFERENCE}`,
+                stroke: PROGRESS_COLOR_SUCCESS,
+              }}
+              animate={{
+                strokeDasharray: `${filled} ${PROGRESS_RING_CIRCUMFERENCE}`,
+                stroke: PROGRESS_COLOR_ERROR,
+              }}
+              transition={{ duration: 1.2, ease: "easeInOut" }}
+            />
+          </svg>
+          <span className="absolute inset-0 flex items-center justify-center text-lg text-text-dimmed">
+            {limits.limit}
+          </span>
+        </div>
+        <DialogDescription className="pt-0">
+          {canUpgrade ? (
+            <>
+              {limits.limit === 1
+                ? "Your plan includes 1 custom dashboard and it's already in use."
+                : `You've used all ${limits.limit} of your custom dashboards.`}{" "}
+              Upgrade your plan to create more.
+            </>
+          ) : (
+            <>
+              {limits.limit === 1
+                ? "Your plan includes 1 custom dashboard and it's already in use."
+                : `You've used all ${limits.limit} of your custom dashboards.`}{" "}
+              To create more, request a limit increase or visit the{" "}
+              <TextLink to={v3BillingPath(organization)}>billing page</TextLink> for pricing
+              details.
+            </>
+          )}
+        </DialogDescription>
+      </div>
+      <DialogFooter className="flex justify-between">
+        <DialogClose asChild>
+          <Button variant="secondary/medium">Cancel</Button>
+        </DialogClose>
+        {canUpgrade ? (
+          <LinkButton variant="primary/medium" to={v3BillingPath(organization)}>
+            Upgrade plan
+          </LinkButton>
+        ) : (
+          <Feedback
+            button={<Button variant="primary/medium">Request more…</Button>}
+            defaultValue="help"
+          />
+        )}
+      </DialogFooter>
+    </DialogContent>
+  );
+}
+
+function CreateDashboardDialog({
+  formAction,
+  limits,
+}: {
+  formAction: string;
+  limits: { used: number; limit: number };
+}) {
+  const navigation = useNavigation();
+  const [title, setTitle] = useState("");
+
+  const isLoading = navigation.formAction === formAction;
+
+  return (
+    <DialogContent className="sm:max-w-sm">
+      <DialogHeader>Create dashboard</DialogHeader>
+      <Form method="post" action={formAction} className="space-y-4 pt-3">
+        <InputGroup>
+          <Label>Title</Label>
+          <Input
+            name="title"
+            value={title}
+            onChange={(e) => setTitle(e.target.value)}
+            placeholder="My Dashboard"
+            required
+          />
+        </InputGroup>
+        <Paragraph variant="extra-small" className="text-text-dimmed">
+          {limits.used}/{limits.limit} dashboards used
+        </Paragraph>
+        <FormButtons
+          confirmButton={
+            <Button type="submit" variant="primary/medium" disabled={isLoading || !title.trim()}>
+              {isLoading ? "Creating..." : "Create"}
+            </Button>
+          }
+          cancelButton={
+            <DialogClose asChild>
+              <Button variant="secondary/medium">Cancel</Button>
+            </DialogClose>
+          }
+        />
+      </Form>
+    </DialogContent>
+  );
+}
diff --git a/apps/webapp/app/components/navigation/DashboardList.tsx b/apps/webapp/app/components/navigation/DashboardList.tsx
new file mode 100644
index 00000000000..132dc026896
--- /dev/null
+++ b/apps/webapp/app/components/navigation/DashboardList.tsx
@@ -0,0 +1,123 @@
+import { IconChartHistogram } from "@tabler/icons-react";
+import { GripVerticalIcon, LineChartIcon } from "lucide-react";
+import ReactGridLayout from "react-grid-layout";
+import { type MatchedOrganization, useCustomDashboards } from "~/hooks/useOrganizations";
+import { type UserWithDashboardPreferences } from "~/models/user.server";
+import { v3CustomDashboardPath } from "~/utils/pathBuilder";
+import { type SideMenuEnvironment, type SideMenuProject } from "./SideMenu";
+import { SideMenuItem } from "./SideMenuItem";
+import { TreeConnectorBranch, TreeConnectorEnd } from "./TreeConnectors";
+import { useReorderableList } from "./useReorderableList";
+
+type SideMenuUser = Pick<UserWithDashboardPreferences, "dashboardPreferences"> & {
+  isImpersonating: boolean;
+};
+
+export function DashboardList({
+  organization,
+  project,
+  environment,
+  isCollapsed,
+  user,
+}: {
+  organization: MatchedOrganization;
+  project: SideMenuProject;
+  environment: SideMenuEnvironment;
+  isCollapsed: boolean;
+  user: SideMenuUser;
+}) {
+  const customDashboards = useCustomDashboards();
+  const initialOrder =
+    user.dashboardPreferences.sideMenu?.organizations?.[organization.id]?.orderedItems?.[
+      "customDashboards"
+    ];
+
+  const {
+    orderedItems: orderedDashboards,
+    layout,
+    containerRef,
+    gridWidth,
+    canReorder,
+    handleDrag,
+    handleDragStop,
+    getIsLast,
+  } = useReorderableList({
+    organizationId: organization.id,
+    listId: "customDashboards",
+    items: customDashboards,
+    itemKey: (d) => d.friendlyId,
+    initialOrder,
+    isImpersonating: user.isImpersonating,
+  });
+
+  return (
+    <div ref={containerRef}>
+      {canReorder ? (
+        <ReactGridLayout
+          layout={layout}
+          width={gridWidth}
+          gridConfig={{
+            cols: 1,
+            rowHeight: 32,
+            margin: [0, 0] as const,
+            containerPadding: [0, 0] as const,
+          }}
+          resizeConfig={{ enabled: false }}
+          dragConfig={{ enabled: !isCollapsed, handle: ".sidebar-drag-handle" }}
+          onDrag={handleDrag}
+          onDragStop={handleDragStop}
+          className="sidebar-reorder-grid"
+          autoSize
+        >
+          {orderedDashboards.map((dashboard, index) => {
+            const isLast = getIsLast(dashboard.friendlyId, index);
+            return (
+              <div key={dashboard.friendlyId}>
+                <SideMenuItem
+                  name={dashboard.title}
+                  icon={
+                    isCollapsed
+                      ? IconChartHistogram
+                      : isLast
+                      ? TreeConnectorEnd
+                      : TreeConnectorBranch
+                  }
+                  activeIconColor={isCollapsed ? "text-customDashboards" : undefined}
+                  inactiveIconColor={isCollapsed ? "text-customDashboards" : undefined}
+                  to={v3CustomDashboardPath(organization, project, environment, dashboard)}
+                  isCollapsed={isCollapsed}
+                  action={
+                    <div className="sidebar-drag-handle flex h-full w-full cursor-grab items-center justify-center rounded text-text-dimmed opacity-0 transition group-hover/menuitem:opacity-100 hover:text-text-bright active:cursor-grabbing">
+                      <GripVerticalIcon className="size-3.5" />
+                    </div>
+                  }
+                />
+              </div>
+            );
+          })}
+        </ReactGridLayout>
+      ) : (
+        orderedDashboards.map((dashboard, index) => {
+          const isLast = index === orderedDashboards.length - 1;
+          return (
+            <SideMenuItem
+              key={dashboard.friendlyId}
+              name={dashboard.title}
+              icon={
+                isCollapsed
+                  ? LineChartIcon
+                  : isLast
+                  ? TreeConnectorEnd
+                  : TreeConnectorBranch
+              }
+              activeIconColor={isCollapsed ? "text-customDashboards" : "text-charcoal-700"}
+              inactiveIconColor={isCollapsed ? "text-customDashboards" : "text-charcoal-700"}
+              to={v3CustomDashboardPath(organization, project, environment, dashboard)}
+              isCollapsed={isCollapsed}
+            />
+          );
+        })
+      )}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/navigation/EnvironmentSelector.tsx b/apps/webapp/app/components/navigation/EnvironmentSelector.tsx
index def3996f859..ba3cce82320 100644
--- a/apps/webapp/app/components/navigation/EnvironmentSelector.tsx
+++ b/apps/webapp/app/components/navigation/EnvironmentSelector.tsx
@@ -1,4 +1,5 @@
 import { ChevronRightIcon, Cog8ToothIcon } from "@heroicons/react/20/solid";
+import { DropdownIcon } from "~/assets/icons/DropdownIcon";
 import { useNavigation } from "@remix-run/react";
 import { useEffect, useRef, useState } from "react";
 import { BranchEnvironmentIconSmall } from "~/assets/icons/EnvironmentIcons";
@@ -9,19 +10,19 @@ import { useOrganization, type MatchedOrganization } from "~/hooks/useOrganizati
 import { useProject } from "~/hooks/useProject";
 import { cn } from "~/utils/cn";
 import { branchesPath, docsPath, v3BillingPath } from "~/utils/pathBuilder";
-import { EnvironmentCombo } from "../environments/EnvironmentLabel";
+import { EnvironmentCombo, EnvironmentIcon, EnvironmentLabel, environmentFullTitle } from "../environments/EnvironmentLabel";
 import { ButtonContent } from "../primitives/Buttons";
 import { Header2 } from "../primitives/Headers";
 import { Paragraph } from "../primitives/Paragraph";
 import {
   Popover,
-  PopoverArrowTrigger,
   PopoverContent,
   PopoverMenuItem,
   PopoverSectionHeader,
   PopoverTrigger,
 } from "../primitives/Popover";
 import { TextLink } from "../primitives/TextLink";
+import { SimpleTooltip } from "../primitives/Tooltip";
 import { V4Badge } from "../V4Badge";
 import { type SideMenuEnvironment, type SideMenuProject } from "./SideMenu";
 import { Badge } from "../primitives/Badge";
@@ -31,11 +32,13 @@ export function EnvironmentSelector({
   project,
   environment,
   className,
+  isCollapsed = false,
 }: {
   organization: MatchedOrganization;
   project: SideMenuProject;
   environment: SideMenuEnvironment;
   className?: string;
+  isCollapsed?: boolean;
 }) {
   const { isManagedCloud } = useFeatures();
   const [isMenuOpen, setIsMenuOpen] = useState(false);
@@ -50,16 +53,48 @@ export function EnvironmentSelector({
 
   return (
     <Popover onOpenChange={(open) => setIsMenuOpen(open)} open={isMenuOpen}>
-      <PopoverArrowTrigger
-        isOpen={isMenuOpen}
-        overflowHidden
-        fullWidth
-        className={cn("h-7 overflow-hidden py-1 pl-1.5", className)}
-      >
-        <EnvironmentCombo environment={environment} className="w-full text-2sm" />
-      </PopoverArrowTrigger>
+      <SimpleTooltip
+        button={
+          <PopoverTrigger
+            className={cn(
+              "group flex h-8 items-center rounded pl-[0.4375rem] transition-colors hover:bg-charcoal-750",
+              isCollapsed ? "justify-center pr-0.5" : "justify-between pr-1",
+              className
+            )}
+          >
+            <span className="flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden">
+              <EnvironmentIcon environment={environment} className="size-5 shrink-0" />
+              <span
+                className={cn(
+                  "flex min-w-0 items-center overflow-hidden transition-all duration-200",
+                  isCollapsed ? "max-w-0 opacity-0" : "max-w-[200px] opacity-100"
+                )}
+              >
+                <EnvironmentLabel environment={environment} className="text-2sm" disableTooltip />
+              </span>
+            </span>
+            <span
+              className={cn(
+                "overflow-hidden transition-all duration-200",
+                isCollapsed ? "max-w-0 opacity-0" : "max-w-[16px] opacity-100"
+              )}
+            >
+              <DropdownIcon className="size-4 min-w-4 text-text-dimmed transition group-hover:text-text-bright" />
+            </span>
+          </PopoverTrigger>
+        }
+        content={environmentFullTitle(environment)}
+        side="right"
+        sideOffset={8}
+        hidden={!isCollapsed}
+        buttonClassName="!h-8"
+        asChild
+        disableHoverableContent
+      />
       <PopoverContent
         className="min-w-[14rem] overflow-y-auto p-0 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        side={isCollapsed ? "right" : "bottom"}
+        sideOffset={isCollapsed ? 8 : 4}
         align="start"
         style={{ maxHeight: `calc(var(--radix-popover-content-available-height) - 10vh)` }}
       >
diff --git a/apps/webapp/app/components/navigation/HelpAndFeedbackPopover.tsx b/apps/webapp/app/components/navigation/HelpAndFeedbackPopover.tsx
index 93f2843de50..39a3d386783 100644
--- a/apps/webapp/app/components/navigation/HelpAndFeedbackPopover.tsx
+++ b/apps/webapp/app/components/navigation/HelpAndFeedbackPopover.tsx
@@ -8,9 +8,13 @@ import {
   SignalIcon,
   StarIcon,
 } from "@heroicons/react/20/solid";
+import { cn } from "~/utils/cn";
 import { DiscordIcon, SlackIcon } from "@trigger.dev/companyicons";
 import { Fragment, useState } from "react";
+import { useRecentChangelogs } from "~/routes/resources.platform-changelogs";
+import { motion } from "framer-motion";
 import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
+import { useShortcutKeys } from "~/hooks/useShortcutKeys";
 import { Feedback } from "../Feedback";
 import { Shortcuts } from "../Shortcuts";
 import { StepContentContainer } from "../StepContentContainer";
@@ -19,30 +23,86 @@ import { ClipboardField } from "../primitives/ClipboardField";
 import { Dialog, DialogContent, DialogHeader, DialogTrigger } from "../primitives/Dialog";
 import { Icon } from "../primitives/Icon";
 import { Paragraph } from "../primitives/Paragraph";
-import { Popover, PopoverContent, PopoverSideMenuTrigger } from "../primitives/Popover";
+import { Popover, PopoverContent, PopoverTrigger } from "../primitives/Popover";
+import { SimpleTooltip } from "../primitives/Tooltip";
+import { ShortcutKey } from "../primitives/ShortcutKey";
 import { StepNumber } from "../primitives/StepNumber";
 import { SideMenuItem } from "./SideMenuItem";
 import { Badge } from "../primitives/Badge";
 
-export function HelpAndFeedback({ disableShortcut = false }: { disableShortcut?: boolean }) {
+export function HelpAndFeedback({
+  disableShortcut = false,
+  isCollapsed = false,
+}: {
+  disableShortcut?: boolean;
+  isCollapsed?: boolean;
+}) {
   const [isHelpMenuOpen, setHelpMenuOpen] = useState(false);
   const currentPlan = useCurrentPlan();
+  const { changelogs } = useRecentChangelogs();
+
+  useShortcutKeys({
+    shortcut: disableShortcut ? undefined : { key: "h", enabledOnInputElements: false },
+    action: (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setHelpMenuOpen(true);
+    },
+  });
 
   return (
-    <Popover onOpenChange={(open) => setHelpMenuOpen(open)}>
-      <PopoverSideMenuTrigger
-        isOpen={isHelpMenuOpen}
-        shortcut={{ key: "h", enabledOnInputElements: false }}
-        className="grow pr-2"
-        disabled={disableShortcut}
-      >
-        <div className="flex items-center gap-1.5">
-          <QuestionMarkCircleIcon className="size-4 text-success" />
-          Help & Feedback
-        </div>
-      </PopoverSideMenuTrigger>
+    <motion.div
+      layout="position"
+      transition={{ duration: 0.2, ease: "easeInOut" }}
+      className={isCollapsed ? undefined : "flex-1"}
+    >
+      <Popover open={isHelpMenuOpen} onOpenChange={setHelpMenuOpen}>
+      <SimpleTooltip
+        button={
+          <PopoverTrigger
+            className={cn(
+              "group flex h-8 items-center gap-1.5 rounded pl-[0.4375rem] pr-2 transition-colors hover:bg-charcoal-750 focus-custom",
+              isCollapsed ? "w-full" : "w-full justify-between"
+            )}
+          >
+            <span className="flex items-center gap-1.5 overflow-hidden">
+              <QuestionMarkCircleIcon className="size-5 min-w-5 shrink-0 text-success" />
+              <span
+                className={cn(
+                  "overflow-hidden whitespace-nowrap text-2sm text-text-bright transition-all duration-150",
+                  isCollapsed ? "max-w-0 opacity-0" : "max-w-[150px] opacity-100"
+                )}
+              >
+                Help & Feedback
+              </span>
+            </span>
+            <ShortcutKey
+              className={cn(
+                "size-4 flex-none transition-all duration-150",
+                isCollapsed ? "hidden" : ""
+              )}
+              shortcut={{ key: "h" }}
+              variant="medium/bright"
+            />
+          </PopoverTrigger>
+        }
+        content={
+          <span className="flex items-center gap-1">
+            Help & Feedback
+            <ShortcutKey shortcut={{ key: "h" }} variant="medium/bright" />
+          </span>
+        }
+        side="right"
+        sideOffset={8}
+        hidden={!isCollapsed}
+        buttonClassName="!h-8 w-full"
+        asChild
+        disableHoverableContent
+      />
       <PopoverContent
         className="min-w-[14rem] divide-y divide-grid-bright overflow-y-auto p-0 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        side={isCollapsed ? "right" : "top"}
+        sideOffset={isCollapsed ? 8 : 4}
         align="start"
       >
         <Fragment>
@@ -82,102 +142,14 @@ export function HelpAndFeedback({ disableShortcut = false }: { disableShortcut?:
               data-action="suggest-a-feature"
               target="_blank"
             />
-            <SideMenuItem
-              name="Changelog"
-              icon={StarIcon}
-              trailingIcon={ArrowUpRightIcon}
-              trailingIconClassName="text-text-dimmed"
-              inactiveIconColor="text-sun-500"
-              activeIconColor="text-sun-500"
-              to="https://trigger.dev/changelog"
-              data-action="changelog"
-              target="_blank"
-            />
             <Shortcuts />
-          </div>
-          <div className="flex flex-col gap-1 p-1">
-            <Paragraph className="pb-1 pl-1.5 pt-1.5 text-xs">Need help?</Paragraph>
-            {currentPlan?.v3Subscription?.plan?.limits.support === "slack" && (
-              <div>
-                <Dialog>
-                  <DialogTrigger asChild>
-                    <Button
-                      variant="small-menu-item"
-                      LeadingIcon={SlackIcon}
-                      data-action="join-our-slack"
-                      fullWidth
-                      textAlignLeft
-                    >
-                      <div className="flex w-full items-center justify-between">
-                        <span className="text-text-bright">Join our Slack…</span>
-                        <Badge variant="extra-small" className="uppercase">
-                          Pro
-                        </Badge>
-                      </div>
-                    </Button>
-                  </DialogTrigger>
-                  <DialogContent>
-                    <DialogHeader>Join our Slack</DialogHeader>
-                    <div className="mt-2 flex flex-col gap-4">
-                      <div className="flex items-center gap-4">
-                        <Icon icon={SlackIcon} className="h-10 w-10 min-w-[2.5rem]" />
-                        <Paragraph variant="base/bright">
-                          As a subscriber, you have access to a dedicated Slack channel for 1-to-1
-                          support with the Trigger.dev team.
-                        </Paragraph>
-                      </div>
-                      <hr className="border-charcoal-800" />
-                      <div>
-                        <StepNumber stepNumber="1" title="Email us" />
-                        <StepContentContainer>
-                          <Paragraph>
-                            Send us an email to this address from your Trigger.dev account email
-                            address:
-                            <ClipboardField
-                              variant="secondary/medium"
-                              value="priority-support@trigger.dev"
-                              className="my-2"
-                            />
-                          </Paragraph>
-                        </StepContentContainer>
-                        <StepNumber stepNumber="2" title="Look out for an invite from Slack" />
-                        <StepContentContainer>
-                          <Paragraph>
-                            As soon as we can, we'll setup a Slack Connect channel and say hello!
-                          </Paragraph>
-                        </StepContentContainer>
-                      </div>
-                    </div>
-                  </DialogContent>
-                </Dialog>
-              </div>
-            )}
-            <SideMenuItem
-              name="Ask in our Discord"
-              icon={DiscordIcon}
-              trailingIcon={ArrowUpRightIcon}
-              trailingIconClassName="text-text-dimmed"
-              to="https://trigger.dev/discord"
-              data-action="join our discord"
-              target="_blank"
-            />
-            <SideMenuItem
-              name="Book a 15 min call"
-              icon={CalendarDaysIcon}
-              trailingIcon={ArrowUpRightIcon}
-              trailingIconClassName="text-text-dimmed"
-              inactiveIconColor="text-rose-500"
-              activeIconColor="text-rose-500"
-              to="https://cal.com/team/triggerdotdev/founders-call"
-              data-action="book-a-call"
-              target="_blank"
-            />
             <Feedback
               button={
                 <Button
                   variant="small-menu-item"
+                  className="pl-2"
                   LeadingIcon={EnvelopeIcon}
-                  leadingIconClassName="text-blue-500"
+                  leadingIconClassName="text-blue-500 pr-1"
                   data-action="contact-us"
                   fullWidth
                   textAlignLeft
@@ -187,8 +159,44 @@ export function HelpAndFeedback({ disableShortcut = false }: { disableShortcut?:
               }
             />
           </div>
+          <div className="flex flex-col gap-1 p-1">
+            <Paragraph className="pb-1 pl-1.5 pt-1.5 text-xs">What's new</Paragraph>
+            {changelogs.map((entry) => (
+              <SideMenuItem
+                key={entry.id}
+                name={entry.title}
+                icon={GrayDotIcon}
+                trailingIcon={ArrowUpRightIcon}
+                trailingIconClassName="text-text-dimmed"
+                inactiveIconColor="text-text-dimmed"
+                activeIconColor="text-text-dimmed"
+                to={entry.actionUrl ?? "https://trigger.dev/changelog"}
+                target="_blank"
+              />
+            ))}
+            <SideMenuItem
+              name="Full changelog"
+              icon={StarIcon}
+              trailingIcon={ArrowUpRightIcon}
+              trailingIconClassName="text-text-dimmed"
+              inactiveIconColor="text-text-dimmed"
+              activeIconColor="text-text-dimmed"
+              to="https://trigger.dev/changelog"
+              data-action="full-changelog"
+              target="_blank"
+            />
+          </div>
         </Fragment>
       </PopoverContent>
-    </Popover>
+      </Popover>
+    </motion.div>
+  );
+}
+
+function GrayDotIcon({ className }: { className?: string }) {
+  return (
+    <span className={cn("flex items-center justify-center", className)}>
+      <span className="block h-1.5 w-1.5 rounded-full bg-text-dimmed" />
+    </span>
   );
 }
diff --git a/apps/webapp/app/components/navigation/NotificationPanel.tsx b/apps/webapp/app/components/navigation/NotificationPanel.tsx
new file mode 100644
index 00000000000..fdfbb2f8742
--- /dev/null
+++ b/apps/webapp/app/components/navigation/NotificationPanel.tsx
@@ -0,0 +1,312 @@
+import { BellAlertIcon, ChevronRightIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { useFetcher } from "@remix-run/react";
+import { motion } from "framer-motion";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import ReactMarkdown from "react-markdown";
+import { Header3 } from "~/components/primitives/Headers";
+import { Popover, PopoverContent, PopoverTrigger } from "~/components/primitives/Popover";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { usePlatformNotifications } from "~/routes/resources.platform-notifications";
+import { cn } from "~/utils/cn";
+
+type Notification = {
+  id: string;
+  friendlyId: string;
+  scope: string;
+  priority: number;
+  payload: {
+    version: string;
+    data: {
+      title: string;
+      description: string;
+      image?: string;
+      actionLabel?: string;
+      actionUrl?: string;
+      dismissOnAction?: boolean;
+    };
+  };
+  isRead: boolean;
+};
+
+export function NotificationPanel({
+  isCollapsed,
+  hasIncident,
+  organizationId,
+  projectId,
+}: {
+  isCollapsed: boolean;
+  hasIncident: boolean;
+  organizationId: string;
+  projectId: string;
+}) {
+  const { notifications } = usePlatformNotifications(organizationId, projectId) as {
+    notifications: Notification[];
+  };
+  const [dismissedIds, setDismissedIds] = useState<Set<string>>(new Set());
+  const dismissFetcher = useFetcher();
+  const seenIdsRef = useRef<Set<string>>(new Set());
+  const seenFetcher = useFetcher();
+  const clickedIdsRef = useRef<Set<string>>(new Set());
+  const clickFetcher = useFetcher();
+
+  const visibleNotifications = notifications.filter((n) => !dismissedIds.has(n.id));
+  const notification = visibleNotifications[0] ?? null;
+
+  const handleDismiss = useCallback((id: string) => {
+    setDismissedIds((prev) => new Set(prev).add(id));
+
+    dismissFetcher.submit(
+      {},
+      {
+        method: "POST",
+        action: `/resources/platform-notifications/${id}/dismiss`,
+      }
+    );
+  }, []);
+
+  const fireClickBeacon = useCallback((id: string) => {
+    if (clickedIdsRef.current.has(id)) return;
+    clickedIdsRef.current.add(id);
+
+    clickFetcher.submit(
+      {},
+      {
+        method: "POST",
+        action: `/resources/platform-notifications/${id}/clicked`,
+      }
+    );
+  }, []);
+
+  // Fire seen beacon
+  const fireSeenBeacon = useCallback((n: Notification) => {
+    if (seenIdsRef.current.has(n.id)) return;
+    seenIdsRef.current.add(n.id);
+
+    seenFetcher.submit(
+      {},
+      {
+        method: "POST",
+        action: `/resources/platform-notifications/${n.id}/seen`,
+      }
+    );
+  }, []);
+
+  // Beacon current notification on mount
+  useEffect(() => {
+    if (notification && !hasIncident) {
+      fireSeenBeacon(notification);
+    }
+  }, [notification?.id, hasIncident]);
+
+  if (!notification) {
+    return null;
+  }
+
+  const card = (
+    <NotificationCard
+      notification={notification}
+      onDismiss={handleDismiss}
+      onLinkClick={() => fireClickBeacon(notification.id)}
+    />
+  );
+
+  return (
+    <Popover>
+      <div className="p-1">
+        {/* Expanded sidebar: show card directly */}
+        <motion.div
+          initial={false}
+          animate={{
+            height: isCollapsed ? 0 : "auto",
+            opacity: isCollapsed ? 0 : 1,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
+        >
+          {card}
+        </motion.div>
+
+        {/* Collapsed sidebar: show bell icon that opens popover */}
+        <motion.div
+          initial={false}
+          animate={{
+            height: isCollapsed ? "auto" : 0,
+            opacity: isCollapsed ? 1 : 0,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
+        >
+          <SimpleTooltip
+            button={
+              <PopoverTrigger className="flex !h-8 w-full items-center justify-center rounded border border-charcoal-650 bg-charcoal-750/50 transition-colors hover:border-charcoal-600 hover:bg-charcoal-700/50">
+                <div className="relative">
+                  <BellAlertIcon className="size-5 text-text-dimmed" />
+                  <span
+                    className="absolute -right-1.5 -top-1.5 flex h-4 min-w-4 items-center justify-center rounded-full px-1 text-[10px] font-medium text-white"
+                    style={{ backgroundColor: "#6366f1" }}
+                  >
+                    {visibleNotifications.length}
+                  </span>
+                </div>
+              </PopoverTrigger>
+            }
+            content="Notifications"
+            side="right"
+            sideOffset={8}
+            disableHoverableContent
+            asChild
+          />
+        </motion.div>
+      </div>
+      <PopoverContent side="right" sideOffset={8} align="start" className="w-56 !min-w-0 p-0">
+        {card}
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function NotificationCard({
+  notification,
+  onDismiss,
+  onLinkClick,
+}: {
+  notification: Notification;
+  onDismiss: (id: string) => void;
+  onLinkClick: () => void;
+}) {
+  const { title, description, image, actionUrl, dismissOnAction } = notification.payload.data;
+  const [isExpanded, setIsExpanded] = useState(false);
+  const [isOverflowing, setIsOverflowing] = useState(false);
+  const descriptionRef = useRef<HTMLDivElement>(null);
+
+  useLayoutEffect(() => {
+    const el = descriptionRef.current;
+    if (el) {
+      setIsOverflowing(el.scrollHeight > el.clientHeight);
+    }
+  }, [description]);
+
+  const handleDismiss = (e: React.MouseEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    onDismiss(notification.id);
+  };
+
+  const handleToggleExpand = (e: React.MouseEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsExpanded((v) => !v);
+  };
+
+  const handleCardClick = () => {
+    onLinkClick();
+    if (dismissOnAction) {
+      onDismiss(notification.id);
+    }
+  };
+
+  const Wrapper = actionUrl ? "a" : "div";
+  const wrapperProps = actionUrl
+    ? {
+        href: actionUrl,
+        target: "_blank" as const,
+        rel: "noopener noreferrer" as const,
+        onClick: handleCardClick,
+      }
+    : {};
+
+  return (
+    <Wrapper
+      {...wrapperProps}
+      className="group/card group relative block overflow-hidden rounded border transition-colors border-grid-bright bg-charcoal-750/50 no-underline"
+    >
+      {/* Header: title + dismiss */}
+      <div className="relative flex items-start gap-1 px-2 pt-1.5">
+        <Header3 className="flex-1 !text-xs">
+          {title}
+        </Header3>
+        <button
+          type="button"
+          onClick={handleDismiss}
+          className="shrink-0 rounded p-0.5 text-text-dimmed transition-colors hover:bg-charcoal-700 hover:text-text-bright"
+        >
+          <XMarkIcon className="size-3.5" />
+        </button>
+      </div>
+
+      {/* Body: description + chevron */}
+      <div className="relative px-2 pb-2">
+        <div className="flex gap-1">
+          <div className="min-w-0 flex-1">
+            <div
+              ref={descriptionRef}
+              className={cn(!isExpanded && "line-clamp-3")}
+            >
+              <ReactMarkdown components={getMarkdownComponents(onLinkClick)}>{description}</ReactMarkdown>
+            </div>
+            {(isOverflowing || isExpanded) && (
+              <button
+                type="button"
+                onClick={handleToggleExpand}
+                className="mt-0.5 text-xs text-indigo-400 hover:text-indigo-300"
+              >
+                {isExpanded ? "Show less" : "Show more"}
+              </button>
+            )}
+          </div>
+          {actionUrl && (
+            <div className="mt-1 flex shrink-0 items-center pb-1 text-text-dimmed group-hover/card:text-text-bright transition-colors">
+              <ChevronRightIcon className="size-4" />
+            </div>
+          )}
+        </div>
+
+        {image && (
+          <img src={sanitizeImageUrl(image)} alt="" className="mt-1.5 rounded" />
+        )}
+      </div>
+    </Wrapper>
+  );
+}
+
+/** Sanitize image URL to prevent XSS via javascript: or data: URIs. */
+function sanitizeImageUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:" || parsed.protocol === "http:") {
+      return parsed.href;
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+function getMarkdownComponents(onLinkClick: () => void) {
+  return {
+    p: ({ children }: { children?: React.ReactNode }) => (
+      <p className="my-0.5 text-xs leading-relaxed text-text-dimmed">{children}</p>
+    ),
+    a: ({ href, children }: { href?: string; children?: React.ReactNode }) => (
+      <a
+        href={href}
+        target="_blank"
+        rel="noopener noreferrer"
+        className="text-indigo-400 underline hover:text-indigo-300 transition-colors"
+        onClick={(e) => {
+          e.stopPropagation();
+          onLinkClick();
+        }}
+      >
+        {children}
+      </a>
+    ),
+    strong: ({ children }: { children?: React.ReactNode }) => (
+      <strong className="font-semibold text-text-bright">{children}</strong>
+    ),
+    em: ({ children }: { children?: React.ReactNode }) => <em>{children}</em>,
+    code: ({ children }: { children?: React.ReactNode }) => (
+      <code className="rounded bg-charcoal-700 px-1 py-0.5 text-[11px]">{children}</code>
+    ),
+  };
+}
diff --git a/apps/webapp/app/components/navigation/OrganizationSettingsSideMenu.tsx b/apps/webapp/app/components/navigation/OrganizationSettingsSideMenu.tsx
index 7303142f3de..e274ad20f43 100644
--- a/apps/webapp/app/components/navigation/OrganizationSettingsSideMenu.tsx
+++ b/apps/webapp/app/components/navigation/OrganizationSettingsSideMenu.tsx
@@ -3,18 +3,25 @@ import {
   ChartBarIcon,
   Cog8ToothIcon,
   CreditCardIcon,
+  LockClosedIcon,
   UserGroupIcon,
 } from "@heroicons/react/20/solid";
 import { ArrowLeftIcon } from "@heroicons/react/24/solid";
+import { SlackIcon } from "@trigger.dev/companyicons";
+import { VercelLogo } from "~/components/integrations/VercelLogo";
+import { useFeatureFlags } from "~/hooks/useFeatureFlags";
 import { useFeatures } from "~/hooks/useFeatures";
 import { type MatchedOrganization } from "~/hooks/useOrganizations";
 import { cn } from "~/utils/cn";
 import {
   organizationSettingsPath,
+  organizationSlackIntegrationPath,
   organizationTeamPath,
+  organizationVercelIntegrationPath,
   rootPath,
   v3BillingAlertsPath,
   v3BillingPath,
+  v3PrivateConnectionsPath,
   v3UsagePath,
 } from "~/utils/pathBuilder";
 import { LinkButton } from "../primitives/Buttons";
@@ -25,6 +32,7 @@ import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
 import { Paragraph } from "../primitives/Paragraph";
 import { Badge } from "../primitives/Badge";
 import { useHasAdminAccess } from "~/hooks/useUser";
+import { AskAI } from "../AskAI";
 
 export type BuildInfo = {
   appVersion: string | undefined;
@@ -42,6 +50,7 @@ export function OrganizationSettingsSideMenu({
   buildInfo: BuildInfo;
 }) {
   const { isManagedCloud } = useFeatures();
+  const featureFlags = useFeatureFlags();
   const currentPlan = useCurrentPlan();
   const isAdmin = useHasAdminAccess();
   const showBuildInfo = isAdmin || !isManagedCloud;
@@ -74,6 +83,7 @@ export function OrganizationSettingsSideMenu({
                 name="Usage"
                 icon={ChartBarIcon}
                 activeIconColor="text-indigo-500"
+                inactiveIconColor="text-indigo-500"
                 to={v3UsagePath(organization)}
                 data-action="usage"
               />
@@ -81,6 +91,7 @@ export function OrganizationSettingsSideMenu({
                 name="Billing"
                 icon={CreditCardIcon}
                 activeIconColor="text-emerald-500"
+                inactiveIconColor="text-emerald-500"
                 to={v3BillingPath(organization)}
                 data-action="billing"
                 badge={
@@ -93,15 +104,27 @@ export function OrganizationSettingsSideMenu({
                 name="Billing alerts"
                 icon={BellAlertIcon}
                 activeIconColor="text-rose-500"
+                inactiveIconColor="text-rose-500"
                 to={v3BillingAlertsPath(organization)}
                 data-action="billing-alerts"
               />
             </>
           )}
+          {featureFlags.hasPrivateConnections && (
+            <SideMenuItem
+              name="Private Connections"
+              icon={LockClosedIcon}
+              activeIconColor="text-purple-500"
+              inactiveIconColor="text-purple-500"
+              to={v3PrivateConnectionsPath(organization)}
+              data-action="private-connections"
+            />
+          )}
           <SideMenuItem
             name="Team"
             icon={UserGroupIcon}
             activeIconColor="text-amber-500"
+            inactiveIconColor="text-amber-500"
             to={organizationTeamPath(organization)}
             data-action="team"
           />
@@ -109,10 +132,33 @@ export function OrganizationSettingsSideMenu({
             name="Settings"
             icon={Cog8ToothIcon}
             activeIconColor="text-orgSettings"
+            inactiveIconColor="text-orgSettings"
             to={organizationSettingsPath(organization)}
             data-action="settings"
           />
         </div>
+        <div className="flex flex-col">
+          <div className="mb-1">
+            <SideMenuHeader title="Integrations" />
+          </div>
+          <SideMenuItem
+            name="Vercel"
+            icon={VercelLogo}
+            activeIconColor="text-white"
+            inactiveIconColor="text-white"
+            iconClassName="size-4 ml-0.5"
+            to={organizationVercelIntegrationPath(organization)}
+            data-action="integrations"
+          />
+          <SideMenuItem
+            name="Slack"
+            icon={SlackIcon}
+            activeIconColor="text-white"
+            inactiveIconColor="text-white"
+            to={organizationSlackIntegrationPath(organization)}
+            data-action="integrations"
+          />
+        </div>
         <div className="flex flex-col gap-1">
           <SideMenuHeader title="App version" />
           <Paragraph variant="extra-small" className="px-2 text-text-dimmed">
@@ -131,7 +177,14 @@ export function OrganizationSettingsSideMenu({
           <div className="flex flex-col gap-1">
             <SideMenuHeader title="Git ref" />
             <Paragraph variant="extra-small" className="px-2 text-text-dimmed">
-              {buildInfo.gitRefName}
+              <a
+                href={`https://github.com/triggerdotdev/trigger.dev/tree/${buildInfo.gitRefName}`}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="transition hover:text-text-bright"
+              >
+                {buildInfo.gitRefName}
+              </a>
             </Paragraph>
           </div>
         )}
@@ -139,13 +192,21 @@ export function OrganizationSettingsSideMenu({
           <div className="flex flex-col gap-1">
             <SideMenuHeader title="Git sha" />
             <Paragraph variant="extra-small" className="px-2 text-text-dimmed">
-              {buildInfo.gitSha.slice(0, 9)}
+              <a
+                href={`https://github.com/triggerdotdev/trigger.dev/commit/${buildInfo.gitSha}`}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="transition hover:text-text-bright"
+              >
+                {buildInfo.gitSha.slice(0, 9)}
+              </a>
             </Paragraph>
           </div>
         )}
       </div>
-      <div className="flex flex-col gap-1 border-t border-grid-bright p-1">
+      <div className="flex w-full items-center justify-between border-t border-grid-bright p-1">
         <HelpAndFeedback />
+        <AskAI />
       </div>
     </div>
   );
diff --git a/apps/webapp/app/components/navigation/SideMenu.tsx b/apps/webapp/app/components/navigation/SideMenu.tsx
index bda24a32ea9..0693a2418b1 100644
--- a/apps/webapp/app/components/navigation/SideMenu.tsx
+++ b/apps/webapp/app/components/navigation/SideMenu.tsx
@@ -1,6 +1,8 @@
 import {
+  AdjustmentsHorizontalIcon,
   ArrowPathRoundedSquareIcon,
   ArrowRightOnRectangleIcon,
+  ArrowTopRightOnSquareIcon,
   BeakerIcon,
   BellAlertIcon,
   ChartBarIcon,
@@ -8,6 +10,8 @@ import {
   ClockIcon,
   Cog8ToothIcon,
   CogIcon,
+  CubeIcon,
+  ExclamationTriangleIcon,
   FolderIcon,
   FolderOpenIcon,
   GlobeAmericasIcon,
@@ -15,53 +19,72 @@ import {
   KeyIcon,
   PencilSquareIcon,
   PlusIcon,
+  PuzzlePieceIcon,
   RectangleStackIcon,
   ServerStackIcon,
   Squares2X2Icon,
+  TableCellsIcon,
   UsersIcon,
 } from "@heroicons/react/20/solid";
-import { Link, useNavigation } from "@remix-run/react";
-import { useEffect, useRef, useState, type ReactNode } from "react";
+import { Link, useFetcher, useNavigation } from "@remix-run/react";
+import { IconBugFilled } from "@tabler/icons-react";
+import { LayoutGroup, motion } from "framer-motion";
+import { type ReactNode, useCallback, useEffect, useRef, useState } from "react";
 import simplur from "simplur";
-import { BranchEnvironmentIconSmall } from "~/assets/icons/EnvironmentIcons";
+import { AIMetricsIcon } from "~/assets/icons/AIMetricsIcon";
+import { AIPromptsIcon } from "~/assets/icons/AIPromptsIcon";
 import { ConcurrencyIcon } from "~/assets/icons/ConcurrencyIcon";
+import { DropdownIcon } from "~/assets/icons/DropdownIcon";
+import { BranchEnvironmentIconSmall } from "~/assets/icons/EnvironmentIcons";
 import { ListCheckedIcon } from "~/assets/icons/ListCheckedIcon";
+import { LogsIcon } from "~/assets/icons/LogsIcon";
 import { RunsIconExtraSmall } from "~/assets/icons/RunsIcon";
 import { TaskIconSmall } from "~/assets/icons/TaskIcon";
 import { WaitpointTokenIcon } from "~/assets/icons/WaitpointTokenIcon";
 import { Avatar } from "~/components/primitives/Avatar";
 import { type MatchedEnvironment } from "~/hooks/useEnvironment";
+import { useFeatureFlags } from "~/hooks/useFeatureFlags";
 import { useFeatures } from "~/hooks/useFeatures";
 import { type MatchedOrganization } from "~/hooks/useOrganizations";
 import { type MatchedProject } from "~/hooks/useProject";
+import { useShortcutKeys } from "~/hooks/useShortcutKeys";
 import { useHasAdminAccess } from "~/hooks/useUser";
-import { type User } from "~/models/user.server";
+import { type UserWithDashboardPreferences } from "~/models/user.server";
 import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
 import { type FeedbackType } from "~/routes/resources.feedback";
-import { IncidentStatusPanel } from "~/routes/resources.incidents";
+import { IncidentStatusPanel, useIncidentStatus } from "~/routes/resources.incidents";
+import { NotificationPanel } from "./NotificationPanel";
 import { cn } from "~/utils/cn";
 import {
   accountPath,
   adminPath,
   branchesPath,
   concurrencyPath,
+  limitsPath,
   logoutPath,
   newOrganizationPath,
   newProjectPath,
   organizationPath,
   organizationSettingsPath,
   organizationTeamPath,
+  queryPath,
   regionsPath,
   v3ApiKeysPath,
   v3BatchesPath,
   v3BillingPath,
+  v3BuiltInDashboardPath,
   v3BulkActionsPath,
   v3DeploymentsPath,
   v3EnvironmentPath,
   v3EnvironmentVariablesPath,
+  v3ErrorsPath,
+  v3LogsPath,
+  v3PromptsPath,
+  v3ModelsPath,
   v3ProjectAlertsPath,
   v3ProjectPath,
-  v3ProjectSettingsPath,
+  v3ProjectSettingsGeneralPath,
+  v3ProjectSettingsIntegrationsPath,
   v3QueuesPath,
   v3RunsPath,
   v3SchedulesPath,
@@ -69,6 +92,7 @@ import {
   v3UsagePath,
   v3WaitpointTokensPath,
 } from "~/utils/pathBuilder";
+import { AlphaBadge } from "../AlphaBadge";
 import { AskAI } from "../AskAI";
 import { FreePlanUsage } from "../billing/FreePlanUsage";
 import { ConnectionIcon, DevPresencePanel, useDevPresence } from "../DevPresence";
@@ -76,28 +100,44 @@ import { ImpersonationBanner } from "../ImpersonationBanner";
 import { Button, ButtonContent, LinkButton } from "../primitives/Buttons";
 import { Dialog, DialogTrigger } from "../primitives/Dialog";
 import { Paragraph } from "../primitives/Paragraph";
-import {
-  Popover,
-  PopoverArrowTrigger,
-  PopoverContent,
-  PopoverMenuItem,
-  PopoverTrigger,
-} from "../primitives/Popover";
+import { Popover, PopoverContent, PopoverMenuItem, PopoverTrigger } from "../primitives/Popover";
+import { ShortcutKey } from "../primitives/ShortcutKey";
 import { TextLink } from "../primitives/TextLink";
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../primitives/Tooltip";
+import {
+  SimpleTooltip,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "../primitives/Tooltip";
 import { ShortcutsAutoOpen } from "../Shortcuts";
 import { UserProfilePhoto } from "../UserProfilePhoto";
-import { V4Badge } from "../V4Badge";
+import { CreateDashboardButton } from "./DashboardDialogs";
+import { DashboardList } from "./DashboardList";
 import { EnvironmentSelector } from "./EnvironmentSelector";
 import { HelpAndFeedback } from "./HelpAndFeedbackPopover";
 import { SideMenuHeader } from "./SideMenuHeader";
 import { SideMenuItem } from "./SideMenuItem";
 import { SideMenuSection } from "./SideMenuSection";
+import { type SideMenuSectionId } from "./sideMenuTypes";
 
-type SideMenuUser = Pick<User, "email" | "admin"> & { isImpersonating: boolean };
+/** Get the collapsed state for a specific side menu section from user preferences */
+function getSectionCollapsed(
+  sideMenu: { collapsedSections?: Record<string, boolean> } | undefined,
+  sectionId: SideMenuSectionId
+): boolean {
+  return sideMenu?.collapsedSections?.[sectionId] ?? false;
+}
+
+type SideMenuUser = Pick<
+  UserWithDashboardPreferences,
+  "email" | "admin" | "dashboardPreferences"
+> & {
+  isImpersonating: boolean;
+};
 export type SideMenuProject = Pick<
   MatchedProject,
-  "id" | "name" | "slug" | "version" | "environments" | "engine"
+  "id" | "name" | "slug" | "version" | "environments" | "engine" | "createdAt"
 >;
 export type SideMenuEnvironment = MatchedEnvironment;
 
@@ -120,11 +160,113 @@ export function SideMenu({
 }: SideMenuProps) {
   const borderRef = useRef<HTMLDivElement>(null);
   const [showHeaderDivider, setShowHeaderDivider] = useState(false);
+  const [isCollapsed, setIsCollapsed] = useState(
+    user.dashboardPreferences.sideMenu?.isCollapsed ?? false
+  );
+  const preferencesFetcher = useFetcher();
+  const pendingPreferencesRef = useRef<{
+    isCollapsed?: boolean;
+    sectionId?: SideMenuSectionId;
+    sectionCollapsed?: boolean;
+  }>({});
+  const debounceTimeoutRef = useRef<NodeJS.Timeout | null>(null);
   const currentPlan = useCurrentPlan();
   const { isConnected } = useDevPresence();
   const isFreeUser = currentPlan?.v3Subscription?.isPaying === false;
   const isAdmin = useHasAdminAccess();
   const { isManagedCloud } = useFeatures();
+  const featureFlags = useFeatureFlags();
+  const incidentStatus = useIncidentStatus();
+  const isV3Project = project.engine === "V1";
+
+  const persistSideMenuPreferences = useCallback(
+    (data: {
+      isCollapsed?: boolean;
+      sectionId?: SideMenuSectionId;
+      sectionCollapsed?: boolean;
+    }) => {
+      if (user.isImpersonating) return;
+
+      // Merge with any pending changes
+      pendingPreferencesRef.current = {
+        ...pendingPreferencesRef.current,
+        ...data,
+      };
+
+      // Clear existing timeout
+      if (debounceTimeoutRef.current) {
+        clearTimeout(debounceTimeoutRef.current);
+      }
+
+      // Debounce the actual submission by 500ms
+      debounceTimeoutRef.current = setTimeout(() => {
+        const pending = pendingPreferencesRef.current;
+        const formData = new FormData();
+        if (pending.isCollapsed !== undefined) {
+          formData.append("isCollapsed", String(pending.isCollapsed));
+        }
+        if (pending.sectionId !== undefined && pending.sectionCollapsed !== undefined) {
+          formData.append("sectionId", pending.sectionId);
+          formData.append("sectionCollapsed", String(pending.sectionCollapsed));
+        }
+        preferencesFetcher.submit(formData, {
+          method: "POST",
+          action: "/resources/preferences/sidemenu",
+        });
+        pendingPreferencesRef.current = {};
+      }, 500);
+    },
+    [user.isImpersonating, preferencesFetcher]
+  );
+
+  // Flush pending preferences on unmount to avoid losing the last toggle
+  useEffect(() => {
+    return () => {
+      if (debounceTimeoutRef.current) {
+        clearTimeout(debounceTimeoutRef.current);
+      }
+      if (user.isImpersonating) return;
+      const pending = pendingPreferencesRef.current;
+      const hasPendingChanges =
+        pending.isCollapsed !== undefined ||
+        (pending.sectionId !== undefined && pending.sectionCollapsed !== undefined);
+
+      if (hasPendingChanges) {
+        const formData = new FormData();
+        if (pending.isCollapsed !== undefined) {
+          formData.append("isCollapsed", String(pending.isCollapsed));
+        }
+        if (pending.sectionId !== undefined && pending.sectionCollapsed !== undefined) {
+          formData.append("sectionId", pending.sectionId);
+          formData.append("sectionCollapsed", String(pending.sectionCollapsed));
+        }
+        preferencesFetcher.submit(formData, {
+          method: "POST",
+          action: "/resources/preferences/sidemenu",
+        });
+        pendingPreferencesRef.current = {};
+      }
+    };
+  }, [preferencesFetcher, user.isImpersonating]);
+
+  const handleToggleCollapsed = () => {
+    const newIsCollapsed = !isCollapsed;
+    setIsCollapsed(newIsCollapsed);
+    persistSideMenuPreferences({ isCollapsed: newIsCollapsed });
+  };
+
+  /** Generic handler for any collapsible section - just pass the section ID */
+  const handleSectionToggle = useCallback(
+    (sectionId: SideMenuSectionId) => (collapsed: boolean) => {
+      persistSideMenuPreferences({ sectionId, sectionCollapsed: collapsed });
+    },
+    [persistSideMenuPreferences]
+  );
+
+  useShortcutKeys({
+    shortcut: { modifiers: ["mod"], key: "b", enabledOnInputElements: true },
+    action: handleToggleCollapsed,
+  });
 
   useEffect(() => {
     const handleScroll = () => {
@@ -143,234 +285,556 @@ export function SideMenu({
   return (
     <div
       className={cn(
-        "grid h-full grid-rows-[2.5rem_1fr_auto] overflow-hidden border-r border-grid-bright bg-background-bright transition"
+        "relative h-full border-r border-grid-bright bg-background-bright transition-all duration-200",
+        isCollapsed ? "w-[2.75rem]" : "w-56"
       )}
     >
-      <div
-        className={cn(
-          "flex items-center overflow-hidden border-b px-1 py-1 transition duration-300",
-          showHeaderDivider ? "border-grid-bright" : "border-transparent"
-        )}
-      >
-        <div className="min-w-0 flex-1">
-          <ProjectSelector
-            organizations={organizations}
-            organization={organization}
-            project={project}
-            user={user}
-          />
+      <CollapseToggle isCollapsed={isCollapsed} onToggle={handleToggleCollapsed} />
+      <div className="absolute inset-0 grid grid-cols-[100%] grid-rows-[2.5rem_1fr_auto] overflow-hidden">
+        <div
+          className={cn(
+            "flex min-w-0 items-center overflow-hidden border-b px-1 py-1 transition duration-300",
+            showHeaderDivider || isCollapsed ? "border-grid-bright" : "border-transparent"
+          )}
+        >
+          <div className={cn("min-w-0", !isCollapsed && "flex-1")}>
+            <ProjectSelector
+              organizations={organizations}
+              organization={organization}
+              project={project}
+              user={user}
+              isCollapsed={isCollapsed}
+            />
+          </div>
+          {isAdmin && !user.isImpersonating ? (
+            <CollapsibleElement isCollapsed={isCollapsed}>
+              <TooltipProvider disableHoverableContent={true}>
+                <Tooltip>
+                  <TooltipTrigger>
+                    <LinkButton
+                      variant="minimal/medium"
+                      to={adminPath()}
+                      TrailingIcon={UsersIcon}
+                    />
+                  </TooltipTrigger>
+                  <TooltipContent side="bottom" className={"text-xs"}>
+                    Admin dashboard
+                  </TooltipContent>
+                </Tooltip>
+              </TooltipProvider>
+            </CollapsibleElement>
+          ) : isAdmin && user.isImpersonating ? (
+            <CollapsibleElement isCollapsed={isCollapsed}>
+              <ImpersonationBanner />
+            </CollapsibleElement>
+          ) : null}
         </div>
-        {isAdmin && !user.isImpersonating ? (
-          <TooltipProvider disableHoverableContent={true}>
-            <Tooltip>
-              <TooltipTrigger>
-                <LinkButton variant="minimal/medium" to={adminPath()} TrailingIcon={UsersIcon} />
-              </TooltipTrigger>
-              <TooltipContent side="bottom" className={"text-xs"}>
-                Admin dashboard
-              </TooltipContent>
-            </Tooltip>
-          </TooltipProvider>
-        ) : isAdmin && user.isImpersonating ? (
-          <ImpersonationBanner />
-        ) : null}
-      </div>
-      <div
-        className="overflow-hidden overflow-y-auto pt-2 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
-        ref={borderRef}
-      >
-        <div className="mb-6 flex flex-col gap-4 px-1">
-          <div className="space-y-1">
-            <SideMenuHeader title={"Environment"} />
-            <div className="flex items-center">
-              <EnvironmentSelector
-                organization={organization}
-                project={project}
-                environment={environment}
+        <div
+          className={cn(
+            "min-h-0 overflow-y-auto pt-2",
+            isCollapsed
+              ? "scrollbar-none"
+              : "scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+          )}
+          ref={borderRef}
+        >
+          <div className="mb-6 flex w-full flex-col gap-4 overflow-hidden px-1">
+            <div className="w-full space-y-1">
+              <SideMenuHeader
+                title={"Environment"}
+                isCollapsed={isCollapsed}
+                collapsedTitle="Env"
               />
-              {environment.type === "DEVELOPMENT" && project.engine === "V2" && (
-                <Dialog>
-                  <TooltipProvider disableHoverableContent={true}>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <div className="inline-flex">
-                          <DialogTrigger asChild>
-                            <Button
-                              variant="minimal/small"
-                              className="aspect-square h-7 p-1"
-                              LeadingIcon={<ConnectionIcon isConnected={isConnected} />}
-                            />
-                          </DialogTrigger>
-                        </div>
-                      </TooltipTrigger>
-                      <TooltipContent side="right" className={"text-xs"}>
-                        {isConnected === undefined
-                          ? "Checking connection..."
-                          : isConnected
-                          ? "Your dev server is connected"
-                          : "Your dev server is not connected"}
-                      </TooltipContent>
-                    </Tooltip>
-                  </TooltipProvider>
-                  <DevPresencePanel isConnected={isConnected} />
-                </Dialog>
-              )}
+              <div className="flex items-center">
+                <EnvironmentSelector
+                  organization={organization}
+                  project={project}
+                  environment={environment}
+                  className="w-full"
+                  isCollapsed={isCollapsed}
+                />
+                {environment.type === "DEVELOPMENT" && project.engine === "V2" && (
+                  <CollapsibleElement isCollapsed={isCollapsed}>
+                    <Dialog>
+                      <TooltipProvider disableHoverableContent={true}>
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <div className="inline-flex">
+                              <DialogTrigger asChild>
+                                <Button
+                                  variant="minimal/small"
+                                  className="aspect-square h-7 p-1"
+                                  LeadingIcon={<ConnectionIcon isConnected={isConnected} />}
+                                />
+                              </DialogTrigger>
+                            </div>
+                          </TooltipTrigger>
+                          <TooltipContent side="right" className={"text-xs"}>
+                            {isConnected === undefined
+                              ? "Checking connection..."
+                              : isConnected
+                              ? "Your dev server is connected"
+                              : "Your dev server is not connected"}
+                          </TooltipContent>
+                        </Tooltip>
+                      </TooltipProvider>
+                      <DevPresencePanel isConnected={isConnected} />
+                    </Dialog>
+                  </CollapsibleElement>
+                )}
+              </div>
             </div>
-          </div>
 
-          <div>
-            <SideMenuItem
-              name="Tasks"
-              icon={TaskIconSmall}
-              activeIconColor="text-tasks"
-              to={v3EnvironmentPath(organization, project, environment)}
-              data-action="tasks"
-            />
-            <SideMenuItem
-              name="Runs"
-              icon={RunsIconExtraSmall}
-              activeIconColor="text-runs"
-              to={v3RunsPath(organization, project, environment)}
-            />
-            <SideMenuItem
-              name="Batches"
-              icon={Squares2X2Icon}
-              activeIconColor="text-batches"
-              to={v3BatchesPath(organization, project, environment)}
-              data-action="batches"
-            />
-            <SideMenuItem
-              name="Schedules"
-              icon={ClockIcon}
-              activeIconColor="text-schedules"
-              to={v3SchedulesPath(organization, project, environment)}
-              data-action="schedules"
-            />
-            <SideMenuItem
-              name="Queues"
-              icon={RectangleStackIcon}
-              activeIconColor="text-queues"
-              to={v3QueuesPath(organization, project, environment)}
-              data-action="queues"
-            />
-            <SideMenuItem
-              name="Deployments"
-              icon={ServerStackIcon}
-              activeIconColor="text-deployments"
-              to={v3DeploymentsPath(organization, project, environment)}
-              data-action="deployments"
-            />
-            <SideMenuItem
-              name="Test"
-              icon={BeakerIcon}
-              activeIconColor="text-tests"
-              to={v3TestPath(organization, project, environment)}
-              data-action="test"
-            />
-          </div>
+            <div className="w-full">
+              <SideMenuItem
+                name="Tasks"
+                icon={TaskIconSmall}
+                activeIconColor="text-tasks"
+                inactiveIconColor="text-tasks"
+                to={v3EnvironmentPath(organization, project, environment)}
+                data-action="tasks"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Runs"
+                icon={RunsIconExtraSmall}
+                activeIconColor="text-runs"
+                inactiveIconColor="text-runs"
+                to={v3RunsPath(organization, project, environment)}
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Batches"
+                icon={Squares2X2Icon}
+                activeIconColor="text-batches"
+                inactiveIconColor="text-batches"
+                to={v3BatchesPath(organization, project, environment)}
+                data-action="batches"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Schedules"
+                icon={ClockIcon}
+                activeIconColor="text-schedules"
+                inactiveIconColor="text-schedules"
+                to={v3SchedulesPath(organization, project, environment)}
+                data-action="schedules"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Queues"
+                icon={RectangleStackIcon}
+                activeIconColor="text-queues"
+                inactiveIconColor="text-queues"
+                to={v3QueuesPath(organization, project, environment)}
+                data-action="queues"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Waitpoint tokens"
+                icon={WaitpointTokenIcon}
+                activeIconColor="text-sky-500"
+                inactiveIconColor="text-sky-500"
+                to={v3WaitpointTokensPath(organization, project, environment)}
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Deployments"
+                icon={ServerStackIcon}
+                activeIconColor="text-deployments"
+                inactiveIconColor="text-deployments"
+                to={v3DeploymentsPath(organization, project, environment)}
+                data-action="deployments"
+                isCollapsed={isCollapsed}
+              />
 
-          <SideMenuSection title="Waitpoints">
-            <SideMenuItem
-              name="Tokens"
-              icon={WaitpointTokenIcon}
-              activeIconColor="text-sky-500"
-              to={v3WaitpointTokensPath(organization, project, environment)}
-              badge={<V4Badge />}
-            />
-          </SideMenuSection>
-
-          <SideMenuSection title="Manage">
-            <SideMenuItem
-              name="Bulk actions"
-              icon={ListCheckedIcon}
-              activeIconColor="text-bulkActions"
-              to={v3BulkActionsPath(organization, project, environment)}
-              data-action="bulk actions"
-            />
-            <SideMenuItem
-              name="API keys"
-              icon={KeyIcon}
-              activeIconColor="text-apiKeys"
-              to={v3ApiKeysPath(organization, project, environment)}
-              data-action="api keys"
-            />
-            <SideMenuItem
-              name="Environment variables"
-              icon={IdentificationIcon}
-              activeIconColor="text-environmentVariables"
-              to={v3EnvironmentVariablesPath(organization, project, environment)}
-              data-action="environment variables"
-            />
-            <SideMenuItem
-              name="Alerts"
-              icon={BellAlertIcon}
-              activeIconColor="text-alerts"
-              to={v3ProjectAlertsPath(organization, project, environment)}
-              data-action="alerts"
-            />
-            <SideMenuItem
-              name="Preview branches"
-              icon={BranchEnvironmentIconSmall}
-              activeIconColor="text-preview"
-              to={branchesPath(organization, project, environment)}
-              data-action="preview-branches"
-              badge={<V4Badge />}
-            />
-            {isManagedCloud && (
               <SideMenuItem
-                name="Concurrency"
-                icon={ConcurrencyIcon}
-                activeIconColor="text-amber-500"
-                to={concurrencyPath(organization, project, environment)}
-                data-action="concurrency"
+                name="Test"
+                icon={BeakerIcon}
+                activeIconColor="text-tests"
+                inactiveIconColor="text-tests"
+                to={v3TestPath(organization, project, environment)}
+                data-action="test"
+                isCollapsed={isCollapsed}
               />
+            </div>
+
+            {(user.admin || user.isImpersonating || featureFlags.hasAiAccess) && (
+              <SideMenuSection
+                title="AI"
+                isSideMenuCollapsed={isCollapsed}
+                itemSpacingClassName="space-y-0"
+                initialCollapsed={getSectionCollapsed(user.dashboardPreferences.sideMenu, "ai")}
+                onCollapseToggle={handleSectionToggle("ai")}
+              >
+                <SideMenuItem
+                  name="Prompts"
+                  icon={AIPromptsIcon}
+                  trailingIconClassName="size-6"
+                  activeIconColor="text-aiPrompts"
+                  inactiveIconColor="text-aiPrompts"
+                  to={v3PromptsPath(organization, project, environment)}
+                  data-action="prompts"
+                  isCollapsed={isCollapsed}
+                />
+                {(user.admin || user.isImpersonating || featureFlags.hasAiAccess) && (
+                  <SideMenuItem
+                    name="Models"
+                    icon={CubeIcon}
+                    activeIconColor="text-purple-500"
+                    inactiveIconColor="text-purple-500"
+                    to={v3ModelsPath(organization, project, environment)}
+                    data-action="models"
+                    isCollapsed={isCollapsed}
+                  />
+                )}
+                <SideMenuItem
+                  name="AI Metrics"
+                  icon={AIMetricsIcon}
+                  trailingIconClassName="size-5"
+                  activeIconColor="text-aiMetrics"
+                  inactiveIconColor="text-aiMetrics"
+                  to={v3BuiltInDashboardPath(organization, project, environment, "llm")}
+                  data-action="ai-metrics"
+                  isCollapsed={isCollapsed}
+                />
+              </SideMenuSection>
             )}
-            <SideMenuItem
-              name="Regions"
-              icon={GlobeAmericasIcon}
-              activeIconColor="text-green-500"
-              to={regionsPath(organization, project, environment)}
-              data-action="regions"
-              badge={<V4Badge />}
-            />
-            <SideMenuItem
-              name="Project settings"
-              icon={Cog8ToothIcon}
-              activeIconColor="text-projectSettings"
-              to={v3ProjectSettingsPath(organization, project, environment)}
-              data-action="project-settings"
-            />
-          </SideMenuSection>
-        </div>
-      </div>
-      <div>
-        <IncidentStatusPanel />
-        <div className="flex flex-col gap-1 border-t border-grid-bright p-1">
-          <div className="flex w-full items-center justify-between">
-            <HelpAndAI />
+
+            {(user.admin || user.isImpersonating || featureFlags.hasQueryAccess) && (
+              <SideMenuSection
+                title="Observability"
+                isSideMenuCollapsed={isCollapsed}
+                itemSpacingClassName="space-y-0"
+                initialCollapsed={getSectionCollapsed(
+                  user.dashboardPreferences.sideMenu,
+                  "metrics"
+                )}
+                onCollapseToggle={handleSectionToggle("metrics")}
+              >
+                {(user.admin || user.isImpersonating || featureFlags.hasLogsPageAccess) && (
+                  <SideMenuItem
+                    name="Logs"
+                    icon={LogsIcon}
+                    activeIconColor="text-logs"
+                    inactiveIconColor="text-logs"
+                    to={v3LogsPath(organization, project, environment)}
+                    data-action="logs"
+                    badge={<AlphaBadge />}
+                    isCollapsed={isCollapsed}
+                  />
+                )}
+                {(user.admin || user.isImpersonating) && (
+                  <SideMenuItem
+                    name="Errors"
+                    icon={IconBugFilled}
+                    activeIconColor="text-errors"
+                    inactiveIconColor="text-errors"
+                    to={v3ErrorsPath(organization, project, environment)}
+                    data-action="errors"
+                    isCollapsed={isCollapsed}
+                  />
+                )}
+                <SideMenuItem
+                  name="Query"
+                  icon={TableCellsIcon}
+                  activeIconColor="text-query"
+                  inactiveIconColor="text-query"
+                  to={queryPath(organization, project, environment)}
+                  data-action="query"
+                  isCollapsed={isCollapsed}
+                />
+                <SideMenuItem
+                  name="Dashboards"
+                  icon={ChartBarIcon}
+                  activeIconColor="text-metrics"
+                  inactiveIconColor="text-metrics"
+                  to={v3BuiltInDashboardPath(organization, project, environment, "overview")}
+                  data-action="metrics-overview"
+                  isCollapsed={isCollapsed}
+                  action={
+                    <CreateDashboardButton
+                      organization={organization}
+                      project={project}
+                      environment={environment}
+                      isCollapsed={isCollapsed}
+                    />
+                  }
+                />
+                <DashboardList
+                  organization={organization}
+                  project={project}
+                  environment={environment}
+                  isCollapsed={isCollapsed}
+                  user={user}
+                />
+              </SideMenuSection>
+            )}
+
+            <SideMenuSection
+              title="Manage"
+              isSideMenuCollapsed={isCollapsed}
+              itemSpacingClassName="space-y-0"
+              initialCollapsed={getSectionCollapsed(user.dashboardPreferences.sideMenu, "manage")}
+              onCollapseToggle={handleSectionToggle("manage")}
+            >
+              <SideMenuItem
+                name="Bulk actions"
+                icon={ListCheckedIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3BulkActionsPath(organization, project, environment)}
+                data-action="bulk actions"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="API keys"
+                icon={KeyIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3ApiKeysPath(organization, project, environment)}
+                data-action="api keys"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Environment variables"
+                icon={IdentificationIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3EnvironmentVariablesPath(organization, project, environment)}
+                data-action="environment variables"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Alerts"
+                icon={BellAlertIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3ProjectAlertsPath(organization, project, environment)}
+                data-action="alerts"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Preview branches"
+                icon={BranchEnvironmentIconSmall}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={branchesPath(organization, project, environment)}
+                data-action="preview-branches"
+                isCollapsed={isCollapsed}
+              />
+              {isManagedCloud && (
+                <SideMenuItem
+                  name="Concurrency"
+                  icon={ConcurrencyIcon}
+                  activeIconColor="text-text-bright"
+                  inactiveIconColor="text-text-dimmed"
+                  to={concurrencyPath(organization, project, environment)}
+                  data-action="concurrency"
+                  isCollapsed={isCollapsed}
+                />
+              )}
+              <SideMenuItem
+                name="Regions"
+                icon={GlobeAmericasIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={regionsPath(organization, project, environment)}
+                data-action="regions"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Limits"
+                icon={AdjustmentsHorizontalIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={limitsPath(organization, project, environment)}
+                data-action="limits"
+                isCollapsed={isCollapsed}
+              />
+            </SideMenuSection>
+
+            <SideMenuSection
+              title="Project settings"
+              isSideMenuCollapsed={isCollapsed}
+              itemSpacingClassName="space-y-0"
+              initialCollapsed={getSectionCollapsed(
+                user.dashboardPreferences.sideMenu,
+                "project-settings"
+              )}
+              onCollapseToggle={handleSectionToggle("project-settings")}
+            >
+              <SideMenuItem
+                name="General"
+                icon={Cog8ToothIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3ProjectSettingsGeneralPath(organization, project, environment)}
+                data-action="project-settings-general"
+                isCollapsed={isCollapsed}
+              />
+              <SideMenuItem
+                name="Integrations"
+                icon={PuzzlePieceIcon}
+                activeIconColor="text-text-bright"
+                inactiveIconColor="text-text-dimmed"
+                to={v3ProjectSettingsIntegrationsPath(organization, project, environment)}
+                data-action="project-settings-integrations"
+                isCollapsed={isCollapsed}
+              />
+            </SideMenuSection>
           </div>
-          {isFreeUser && (
-            <FreePlanUsage
-              to={v3BillingPath(organization)}
-              percentage={currentPlan.v3Usage.usagePercentage}
-            />
-          )}
+        </div>
+        <div>
+          <IncidentStatusPanel
+            isCollapsed={isCollapsed}
+            title={incidentStatus.title}
+            hasIncident={incidentStatus.hasIncident}
+            isManagedCloud={incidentStatus.isManagedCloud}
+          />
+          <V3DeprecationPanel
+            isCollapsed={isCollapsed}
+            isV3={isV3Project}
+            projectCreatedAt={project.createdAt}
+            hasIncident={incidentStatus.hasIncident}
+            isManagedCloud={incidentStatus.isManagedCloud}
+          />
+          <NotificationPanel
+            isCollapsed={isCollapsed}
+            hasIncident={incidentStatus.hasIncident}
+            organizationId={organization.id}
+            projectId={project.id}
+          />
+          <motion.div
+            layout
+            transition={{ duration: 0.2, ease: "easeInOut" }}
+            className={cn(
+              "flex flex-col gap-1 border-t border-grid-bright p-1",
+              isCollapsed && "items-center"
+            )}
+          >
+            <HelpAndAI isCollapsed={isCollapsed} />
+            {isFreeUser && (
+              <CollapsibleHeight isCollapsed={isCollapsed}>
+                <FreePlanUsage
+                  to={v3BillingPath(organization)}
+                  percentage={currentPlan.v3Usage.usagePercentage}
+                />
+              </CollapsibleHeight>
+            )}
+          </motion.div>
         </div>
       </div>
     </div>
   );
 }
 
+function V3DeprecationPanel({
+  isCollapsed,
+  isV3,
+  projectCreatedAt,
+  hasIncident,
+  isManagedCloud,
+}: {
+  isCollapsed: boolean;
+  isV3: boolean;
+  projectCreatedAt: Date;
+  hasIncident: boolean;
+  isManagedCloud: boolean;
+}) {
+  // Only show for projects created before v4 was released
+  const V4_RELEASE_DATE = new Date("2025-09-01");
+  const isLikelyV3 = isV3 && new Date(projectCreatedAt) < V4_RELEASE_DATE;
+
+  if (!isManagedCloud || !isLikelyV3 || hasIncident) {
+    return null;
+  }
+
+  return (
+    <Popover>
+      <div className="p-1">
+        <motion.div
+          initial={false}
+          animate={{
+            height: isCollapsed ? 0 : "auto",
+            opacity: isCollapsed ? 0 : 1,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
+        >
+          <V3DeprecationContent />
+        </motion.div>
+
+        <motion.div
+          initial={false}
+          animate={{
+            height: isCollapsed ? "auto" : 0,
+            opacity: isCollapsed ? 1 : 0,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
+        >
+          <SimpleTooltip
+            button={
+              <PopoverTrigger className="flex !h-8 w-full items-center justify-center rounded border border-amber-500/30 bg-amber-500/15 transition-colors hover:border-amber-500/50 hover:bg-amber-500/25">
+                <ExclamationTriangleIcon className="size-5 text-amber-400" />
+              </PopoverTrigger>
+            }
+            content="V3 deprecation warning"
+            side="right"
+            sideOffset={8}
+            disableHoverableContent
+            asChild
+          />
+        </motion.div>
+      </div>
+      <PopoverContent side="right" sideOffset={8} align="start" className="w-52 !min-w-0 p-0">
+        <V3DeprecationContent />
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function V3DeprecationContent() {
+  return (
+    <div className="flex flex-col gap-2 rounded border border-amber-500/30 bg-amber-500/10 p-2 pt-1.5">
+      <div className="flex items-center gap-1 border-b border-amber-500/30 pb-1">
+        <ExclamationTriangleIcon className="size-4 text-amber-400" />
+        <Paragraph variant="small/bright" className="text-amber-300">
+          V3 deprecation warning
+        </Paragraph>
+      </div>
+      <Paragraph variant="extra-small/bright" className="text-amber-300">
+        This is a v3 project. V3 deploys will stop working on 1 April 2026. Full shutdown is 1 July
+        2026 where all v3 runs will stop executing. Migrate to v4 to avoid downtime.
+      </Paragraph>
+      <LinkButton
+        variant="secondary/small"
+        to="https://trigger.dev/docs/migrating-from-v3"
+        target="_blank"
+        fullWidth
+        TrailingIcon={ArrowTopRightOnSquareIcon}
+        trailingIconClassName="text-amber-300"
+        className="border-amber-500/30 bg-amber-500/15 hover:!border-amber-500/50 hover:!bg-amber-500/25"
+      >
+        <span className="text-amber-300">View migration guide</span>
+      </LinkButton>
+    </div>
+  );
+}
+
 function ProjectSelector({
   project,
   organization,
   organizations,
   user,
+  isCollapsed = false,
 }: {
   project: SideMenuProject;
   organization: MatchedOrganization;
   organizations: MatchedOrganization[];
   user: SideMenuUser;
+  isCollapsed?: boolean;
 }) {
   const currentPlan = useCurrentPlan();
   const [isOrgMenuOpen, setOrgMenuOpen] = useState(false);
@@ -390,21 +854,50 @@ function ProjectSelector({
 
   return (
     <Popover onOpenChange={(open) => setOrgMenuOpen(open)} open={isOrgMenuOpen}>
-      <PopoverArrowTrigger
-        isOpen={isOrgMenuOpen}
-        overflowHidden
-        className="h-8 w-full justify-between py-1 pl-1.5"
-      >
-        <span className="flex items-center gap-1.5 overflow-hidden">
-          <Avatar avatar={organization.avatar} size={1.25} orgName={organization.title} />
-          <SelectorDivider />
-          <span className="truncate text-2sm font-normal text-text-bright">
-            {project.name ?? "Select a project"}
-          </span>
-        </span>
-      </PopoverArrowTrigger>
+      <SimpleTooltip
+        button={
+          <PopoverTrigger
+            className={cn(
+              "group flex h-8 items-center rounded pl-[0.4375rem] transition-colors hover:bg-charcoal-750",
+              isCollapsed ? "justify-center pr-0.5" : "w-full justify-between pr-1"
+            )}
+          >
+            <span className="flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden">
+              <Avatar avatar={organization.avatar} size={1.25} orgName={organization.title} />
+              <span
+                className={cn(
+                  "flex min-w-0 items-center gap-1.5 overflow-hidden transition-all duration-200",
+                  isCollapsed ? "max-w-0 opacity-0" : "max-w-[200px] opacity-100"
+                )}
+              >
+                <SelectorDivider />
+                <span className="truncate text-2sm font-normal text-text-bright">
+                  {project.name ?? "Select a project"}
+                </span>
+              </span>
+            </span>
+            <span
+              className={cn(
+                "overflow-hidden transition-all duration-200",
+                isCollapsed ? "max-w-0 opacity-0" : "max-w-[16px] opacity-100"
+              )}
+            >
+              <DropdownIcon className="size-4 min-w-4 text-text-dimmed transition group-hover:text-text-bright" />
+            </span>
+          </PopoverTrigger>
+        }
+        content={`${organization.title} / ${project.name ?? "Select a project"}`}
+        side="right"
+        sideOffset={8}
+        hidden={!isCollapsed}
+        buttonClassName="!h-8"
+        asChild
+        disableHoverableContent
+      />
       <PopoverContent
         className="min-w-[16rem] overflow-y-auto p-0 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        side={isCollapsed ? "right" : "bottom"}
+        sideOffset={isCollapsed ? 8 : 4}
         align="start"
         style={{ maxHeight: `calc(var(--radix-popover-content-available-height) - 10vh)` }}
       >
@@ -510,6 +1003,7 @@ function ProjectSelector({
             title="Logout"
             icon={ArrowRightOnRectangleIcon}
             leadingIconClassName="text-text-dimmed"
+            danger
           />
         </div>
       </PopoverContent>
@@ -623,12 +1117,191 @@ function SelectorDivider() {
   );
 }
 
-function HelpAndAI() {
+/** Helper component that fades out but preserves width (collapses to 0 width) */
+function CollapsibleElement({
+  isCollapsed,
+  children,
+  className,
+}: {
+  isCollapsed: boolean;
+  children: ReactNode;
+  className?: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "overflow-hidden transition-all duration-200",
+        isCollapsed ? "max-w-0 opacity-0" : "max-w-[100px] opacity-100",
+        className
+      )}
+    >
+      {children}
+    </div>
+  );
+}
+
+/** Helper component that fades out and collapses height completely */
+function CollapsibleHeight({
+  isCollapsed,
+  children,
+  className,
+}: {
+  isCollapsed: boolean;
+  children: ReactNode;
+  className?: string;
+}) {
   return (
-    <>
-      <ShortcutsAutoOpen />
-      <HelpAndFeedback />
-      <AskAI />
-    </>
+    <div
+      className={cn(
+        "grid transition-all duration-200 ease-in-out",
+        isCollapsed ? "grid-rows-[0fr] opacity-0" : "grid-rows-[1fr] opacity-100",
+        className
+      )}
+    >
+      <div className="overflow-hidden">{children}</div>
+    </div>
+  );
+}
+
+function HelpAndAI({ isCollapsed }: { isCollapsed: boolean }) {
+  return (
+    <LayoutGroup>
+      <div
+        className={cn(
+          "flex w-full",
+          isCollapsed ? "flex-col-reverse gap-1" : "items-center justify-between"
+        )}
+      >
+        <ShortcutsAutoOpen />
+        <HelpAndFeedback isCollapsed={isCollapsed} />
+        <AskAI isCollapsed={isCollapsed} />
+      </div>
+    </LayoutGroup>
+  );
+}
+
+function AnimatedChevron({
+  isHovering,
+  isCollapsed,
+}: {
+  isHovering: boolean;
+  isCollapsed: boolean;
+}) {
+  // When hovering and expanded: left chevron (pointing left to collapse)
+  // When hovering and collapsed: right chevron (pointing right to expand)
+  // When not hovering: straight vertical line
+
+  const getRotation = () => {
+    if (!isHovering) return { top: 0, bottom: 0 };
+    if (isCollapsed) {
+      // Right chevron
+      return { top: -17, bottom: 17 };
+    } else {
+      // Left chevron
+      return { top: 17, bottom: -17 };
+    }
+  };
+
+  const { top, bottom } = getRotation();
+
+  // Calculate horizontal offset to keep chevron centered when rotated
+  // Left chevron: translate left (-1.5px)
+  // Right chevron: translate right (+1.5px)
+  const getTranslateX = () => {
+    if (!isHovering) return 0;
+    return isCollapsed ? 1.5 : -1.5;
+  };
+
+  return (
+    <motion.svg
+      width="4"
+      height="30"
+      viewBox="0 0 4 30"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      className="pointer-events-none relative z-10 overflow-visible text-charcoal-600 transition-colors group-hover:text-text-bright"
+      initial={false}
+      animate={{
+        x: getTranslateX(),
+      }}
+      transition={{ duration: 0.4, ease: "easeOut" }}
+    >
+      {/* Top segment */}
+      <motion.line
+        x1="2"
+        y1="1.5"
+        x2="2"
+        y2="15"
+        stroke="currentColor"
+        strokeWidth="3"
+        strokeLinecap="round"
+        initial={false}
+        animate={{
+          rotate: top,
+        }}
+        transition={{ duration: 0.2, ease: "easeOut" }}
+        style={{ transformOrigin: "2px 15px" }}
+      />
+      {/* Bottom segment */}
+      <motion.line
+        x1="2"
+        y1="15"
+        x2="2"
+        y2="28.5"
+        stroke="currentColor"
+        strokeWidth="3"
+        strokeLinecap="round"
+        initial={false}
+        animate={{
+          rotate: bottom,
+        }}
+        transition={{ duration: 0.2, ease: "easeOut" }}
+        style={{ transformOrigin: "2px 15px" }}
+      />
+    </motion.svg>
+  );
+}
+
+function CollapseToggle({ isCollapsed, onToggle }: { isCollapsed: boolean; onToggle: () => void }) {
+  const [isHovering, setIsHovering] = useState(false);
+
+  return (
+    <div className="absolute -right-3 top-1/2 z-10 -translate-y-1/2">
+      {/* Vertical line to mask the side menu border */}
+      <div
+        className={cn(
+          "pointer-events-none absolute left-1/2 top-1/2 h-10 w-px -translate-y-1/2 transition-colors duration-200",
+          isHovering ? "bg-charcoal-750" : "bg-background-bright"
+        )}
+      />
+      <TooltipProvider disableHoverableContent>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="button"
+              aria-label={isCollapsed ? "Expand side menu" : "Collapse side menu"}
+              onClick={onToggle}
+              onMouseEnter={() => setIsHovering(true)}
+              onMouseLeave={() => setIsHovering(false)}
+              className={cn(
+                "group flex h-12 w-6 items-center justify-center rounded-md text-text-dimmed transition-all duration-200 focus-custom",
+                isHovering
+                  ? "border border-grid-bright bg-background-bright shadow-md hover:bg-charcoal-750 hover:text-text-bright"
+                  : "border border-transparent bg-transparent"
+              )}
+            >
+              <AnimatedChevron isHovering={isHovering} isCollapsed={isCollapsed} />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="right" className="flex items-center gap-2 text-xs">
+            {isCollapsed ? "Expand" : "Collapse"}
+            <span className="flex items-center">
+              <ShortcutKey shortcut={{ modifiers: ["mod"] }} variant="medium/bright" />
+              <ShortcutKey shortcut={{ key: "b" }} variant="medium/bright" />
+            </span>
+          </TooltipContent>
+        </Tooltip>
+      </TooltipProvider>
+    </div>
   );
 }
diff --git a/apps/webapp/app/components/navigation/SideMenuHeader.tsx b/apps/webapp/app/components/navigation/SideMenuHeader.tsx
index 83741a6c7a4..8d975cba436 100644
--- a/apps/webapp/app/components/navigation/SideMenuHeader.tsx
+++ b/apps/webapp/app/components/navigation/SideMenuHeader.tsx
@@ -1,9 +1,21 @@
 import { useNavigation } from "@remix-run/react";
 import { useEffect, useState } from "react";
+import { motion } from "framer-motion";
 import { Popover, PopoverContent, PopoverCustomTrigger } from "../primitives/Popover";
 import { EllipsisHorizontalIcon } from "@heroicons/react/20/solid";
 
-export function SideMenuHeader({ title, children }: { title: string; children?: React.ReactNode }) {
+export function SideMenuHeader({
+  title,
+  children,
+  isCollapsed = false,
+  collapsedTitle,
+}: {
+  title: string;
+  children?: React.ReactNode;
+  isCollapsed?: boolean;
+  /** When provided, this text stays visible when collapsed and the rest fades out */
+  collapsedTitle?: string;
+}) {
   const [isHeaderMenuOpen, setHeaderMenuOpen] = useState(false);
   const navigation = useNavigation();
 
@@ -11,9 +23,34 @@ export function SideMenuHeader({ title, children }: { title: string; children?:
     setHeaderMenuOpen(false);
   }, [navigation.location?.pathname]);
 
+  // If collapsedTitle is provided and title starts with it, split the title
+  const hasCollapsedTitle = collapsedTitle && title.startsWith(collapsedTitle);
+  const visiblePart = hasCollapsedTitle ? collapsedTitle : title;
+  const fadingPart = hasCollapsedTitle ? title.slice(collapsedTitle.length) : "";
+
   return (
-    <div className="group flex items-center justify-between pl-1.5">
-      <h2 className="text-xs">{title}</h2>
+    <motion.div
+      className="group flex h-4 items-center justify-between overflow-hidden pl-1.5"
+      initial={false}
+      animate={{
+        opacity: hasCollapsedTitle ? 1 : isCollapsed ? 0 : 1,
+      }}
+      transition={{ duration: 0.15, ease: "easeOut" }}
+    >
+      <h2 className="text-xs whitespace-nowrap">
+        {visiblePart}
+        {fadingPart && (
+          <motion.span
+            initial={false}
+            animate={{
+              opacity: isCollapsed ? 0 : 1,
+            }}
+            transition={{ duration: 0.15, ease: "easeOut" }}
+          >
+            {fadingPart}
+          </motion.span>
+        )}
+      </h2>
       {children !== undefined ? (
         <Popover onOpenChange={(open) => setHeaderMenuOpen(open)} open={isHeaderMenuOpen}>
           <PopoverCustomTrigger className="p-1">
@@ -27,6 +64,6 @@ export function SideMenuHeader({ title, children }: { title: string; children?:
           </PopoverContent>
         </Popover>
       ) : null}
-    </div>
+    </motion.div>
   );
 }
diff --git a/apps/webapp/app/components/navigation/SideMenuItem.tsx b/apps/webapp/app/components/navigation/SideMenuItem.tsx
index 1f893688292..26aad3908df 100644
--- a/apps/webapp/app/components/navigation/SideMenuItem.tsx
+++ b/apps/webapp/app/components/navigation/SideMenuItem.tsx
@@ -1,53 +1,122 @@
 import { type AnchorHTMLAttributes, type ReactNode } from "react";
+import { Link } from "@remix-run/react";
+import { motion } from "framer-motion";
 import { usePathName } from "~/hooks/usePathName";
 import { cn } from "~/utils/cn";
-import { LinkButton } from "../primitives/Buttons";
-import { type RenderIcon } from "../primitives/Icon";
+import { type RenderIcon, Icon } from "../primitives/Icon";
+import { SimpleTooltip } from "../primitives/Tooltip";
 
 export function SideMenuItem({
   icon,
   activeIconColor,
   inactiveIconColor,
+  iconClassName,
   trailingIcon,
   trailingIconClassName,
   name,
   to,
   badge,
   target,
+  isCollapsed = false,
+  action,
 }: {
   icon?: RenderIcon;
   activeIconColor?: string;
   inactiveIconColor?: string;
+  iconClassName?: string;
   trailingIcon?: RenderIcon;
   trailingIconClassName?: string;
   name: string;
   to: string;
   badge?: ReactNode;
   target?: AnchorHTMLAttributes<HTMLAnchorElement>["target"];
+  isCollapsed?: boolean;
+  action?: ReactNode;
 }) {
   const pathName = usePathName();
   const isActive = pathName === to;
 
-  return (
-    <LinkButton
-      variant="small-menu-item"
-      fullWidth
-      textAlignLeft
-      LeadingIcon={icon}
-      leadingIconClassName={isActive ? activeIconColor : inactiveIconColor ?? "text-text-dimmed"}
-      TrailingIcon={trailingIcon}
-      trailingIconClassName={trailingIconClassName}
+  const link = (
+    <Link
       to={to}
       target={target}
       className={cn(
-        "text-text-bright group-hover:bg-charcoal-750 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0",
-        isActive ? "bg-tertiary text-text-bright" : "group-hover:text-text-bright"
+        "flex h-8 w-full items-center gap-2 overflow-hidden rounded pr-2 pl-[0.4375rem] text-text-bright transition-colors hover:bg-charcoal-750 group-hover/menuitem:bg-charcoal-750",
+        isActive ? "bg-tertiary" : ""
       )}
     >
-      <div className="flex w-full items-center justify-between">
-        {name}
-        <div className="flex items-center gap-1">{badge !== undefined && badge}</div>
+      <Icon
+        icon={icon}
+        className={cn(
+          "size-5 shrink-0",
+          isActive ? activeIconColor : inactiveIconColor ?? "text-text-dimmed",
+          iconClassName
+        )}
+      />
+      <motion.div
+        className="flex min-w-0 flex-1 items-center justify-between overflow-hidden"
+        initial={false}
+        animate={{
+          width: isCollapsed ? 0 : "auto",
+          opacity: isCollapsed ? 0 : 1,
+        }}
+        transition={{ duration: 0.2, ease: "easeOut" }}
+      >
+        <span className="truncate select-none text-2sm">{name}</span>
+        {badge && !isCollapsed && (
+          <motion.div
+            className="ml-1 flex shrink-0 items-center gap-1"
+            initial={false}
+            animate={{
+              opacity: 1,
+            }}
+            transition={{ duration: 0.15, ease: "easeOut" }}
+          >
+            {badge}
+          </motion.div>
+        )}
+        {trailingIcon && !isCollapsed && (
+          <Icon
+            icon={trailingIcon}
+            className={cn("ml-1 size-4 shrink-0", trailingIconClassName)}
+          />
+        )}
+      </motion.div>
+    </Link>
+  );
+
+  if (action) {
+    return (
+      <div className="group/menuitem relative h-8 w-full">
+        <SimpleTooltip
+          button={link}
+          content={name}
+          side="right"
+          sideOffset={8}
+          buttonClassName="!h-8 block w-full"
+          hidden={!isCollapsed}
+          asChild
+          disableHoverableContent
+        />
+        {!isCollapsed && (
+          <div className="absolute top-1 right-1 bottom-1 flex aspect-square items-center justify-center rounded group-hover/menuitem:bg-charcoal-750">
+            {action}
+          </div>
+        )}
       </div>
-    </LinkButton>
+    );
+  }
+
+  return (
+    <SimpleTooltip
+      button={link}
+      content={name}
+      side="right"
+      sideOffset={8}
+      buttonClassName="!h-8 block w-full"
+      hidden={!isCollapsed}
+      asChild
+      disableHoverableContent
+    />
   );
 }
diff --git a/apps/webapp/app/components/navigation/SideMenuSection.tsx b/apps/webapp/app/components/navigation/SideMenuSection.tsx
index af370035753..1564716512d 100644
--- a/apps/webapp/app/components/navigation/SideMenuSection.tsx
+++ b/apps/webapp/app/components/navigation/SideMenuSection.tsx
@@ -7,6 +7,11 @@ type Props = {
   initialCollapsed?: boolean;
   onCollapseToggle?: (isCollapsed: boolean) => void;
   children: React.ReactNode;
+  /** When true, hides the section header and shows only children */
+  isSideMenuCollapsed?: boolean;
+  itemSpacingClassName?: string;
+  /** Optional action element (e.g., + button) to render on the right side of the header */
+  headerAction?: React.ReactNode;
 };
 
 /** A collapsible section for the side menu
@@ -17,6 +22,9 @@ export function SideMenuSection({
   initialCollapsed = false,
   onCollapseToggle,
   children,
+  isSideMenuCollapsed = false,
+  itemSpacingClassName = "space-y-px",
+  headerAction,
 }: Props) {
   const [isCollapsed, setIsCollapsed] = useState(initialCollapsed);
 
@@ -27,22 +35,45 @@ export function SideMenuSection({
   }, [isCollapsed, onCollapseToggle]);
 
   return (
-    <div>
-      <div
-        className="flex cursor-pointer items-center gap-1 rounded-sm py-1 pl-1.5 text-text-dimmed transition hover:bg-charcoal-750 hover:text-text-bright"
-        onClick={handleToggle}
-      >
-        <h2 className="text-xs">{title}</h2>
+    <div className="w-full overflow-hidden">
+      {/* Header container - stays in DOM to preserve height */}
+      <div className="relative w-full">
+        {/* Header - fades out when sidebar is collapsed */}
         <motion.div
-          initial={isCollapsed}
-          animate={{ rotate: isCollapsed ? -90 : 0 }}
-          transition={{ duration: 0.2 }}
+          className="group/section flex cursor-pointer items-center justify-between overflow-hidden rounded-sm py-1 pl-1.5 pr-1 transition hover:bg-charcoal-750"
+          initial={false}
+          animate={{
+            opacity: isSideMenuCollapsed ? 0 : 1,
+          }}
+          transition={{ duration: 0.15, ease: "easeOut" }}
+          onClick={isSideMenuCollapsed ? undefined : handleToggle}
+          style={{ cursor: isSideMenuCollapsed ? "default" : "pointer" }}
         >
-          <ToggleArrowIcon className="size-2" />
+          <div className="flex items-center gap-1 text-text-dimmed transition group-hover/section:text-text-bright">
+            <h2 className="whitespace-nowrap text-xs">{title}</h2>
+            <motion.div
+              initial={isCollapsed}
+              animate={{ rotate: isCollapsed ? -90 : 0 }}
+              transition={{ duration: 0.2 }}
+            >
+              <ToggleArrowIcon className="size-2" />
+            </motion.div>
+          </div>
+          {headerAction && <div className="flex items-center">{headerAction}</div>}
         </motion.div>
+        {/* Divider - absolutely positioned, visible when sidebar is collapsed but section is expanded */}
+        <motion.div
+          className="absolute left-2 right-2 top-1 h-px bg-charcoal-600"
+          initial={false}
+          animate={{
+            opacity: isSideMenuCollapsed && !isCollapsed ? 1 : 0,
+          }}
+          transition={{ duration: 0.15, ease: "easeOut" }}
+        />
       </div>
       <AnimatePresence initial={false}>
         <motion.div
+          className="w-full"
           initial={isCollapsed ? "collapsed" : "expanded"}
           animate={isCollapsed ? "collapsed" : "expanded"}
           exit="collapsed"
@@ -63,6 +94,7 @@ export function SideMenuSection({
           style={{ overflow: "hidden" }}
         >
           <motion.div
+            className={`w-full ${itemSpacingClassName}`}
             variants={{
               expanded: {
                 translateY: 0,
diff --git a/apps/webapp/app/components/navigation/TreeConnectors.tsx b/apps/webapp/app/components/navigation/TreeConnectors.tsx
new file mode 100644
index 00000000000..8479179a491
--- /dev/null
+++ b/apps/webapp/app/components/navigation/TreeConnectors.tsx
@@ -0,0 +1,29 @@
+import { cn } from "~/utils/cn";
+
+// Tree connector icons for sub-items. The SVG viewBox is 20x20 matching the size-5 icon area.
+// Lines extend to y=-6 and y=26 to fill the full 32px row height (6px gap above/below the 20px icon).
+export function TreeConnectorBranch({ className }: { className?: string }) {
+  return (
+    <svg
+      className={cn("overflow-visible", className, "text-charcoal-600")}
+      viewBox="0 0 20 20"
+      fill="none"
+    >
+      <line x1="10" y1="-6" x2="10" y2="26" stroke="currentColor" strokeWidth="1" />
+      <line x1="10" y1="10" x2="20" y2="10" stroke="currentColor" strokeWidth="1" />
+    </svg>
+  );
+}
+
+export function TreeConnectorEnd({ className }: { className?: string }) {
+  return (
+    <svg
+      className={cn("overflow-visible", className, "text-charcoal-600")}
+      viewBox="0 0 20 20"
+      fill="none"
+    >
+      <line x1="10" y1="-6" x2="10" y2="10" stroke="currentColor" strokeWidth="1" />
+      <line x1="10" y1="10" x2="20" y2="10" stroke="currentColor" strokeWidth="1" />
+    </svg>
+  );
+}
diff --git a/apps/webapp/app/components/navigation/sideMenuTypes.ts b/apps/webapp/app/components/navigation/sideMenuTypes.ts
new file mode 100644
index 00000000000..d9b0fba5af2
--- /dev/null
+++ b/apps/webapp/app/components/navigation/sideMenuTypes.ts
@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+// Valid section IDs that can have their collapsed state toggled
+export const SideMenuSectionIdSchema = z.enum(["ai", "manage", "metrics", "project-settings"]);
+
+// Inferred type from the schema
+export type SideMenuSectionId = z.infer<typeof SideMenuSectionIdSchema>;
diff --git a/apps/webapp/app/components/navigation/useReorderableList.ts b/apps/webapp/app/components/navigation/useReorderableList.ts
new file mode 100644
index 00000000000..b73a054ae98
--- /dev/null
+++ b/apps/webapp/app/components/navigation/useReorderableList.ts
@@ -0,0 +1,129 @@
+import { useFetcher } from "@remix-run/react";
+import { type Ref, useCallback, useEffect, useMemo, useState } from "react";
+import { type Layout, useContainerWidth } from "react-grid-layout";
+
+/**
+ * Generic hook for managing a reorderable list in the side menu.
+ *
+ * Handles order state, sorting, grid layout, drag callbacks, and persistence
+ * via the `/resources/preferences/sidemenu` resource route.
+ *
+ * @param organizationId - Organization ID for scoping the persisted order
+ * @param listId - Identifier for this list (e.g. "customDashboards")
+ * @param items - The items to reorder
+ * @param itemKey - Extract a stable string key from each item
+ * @param initialOrder - Initial order from stored preferences (if any)
+ * @param isImpersonating - Skip persistence when impersonating
+ */
+export function useReorderableList<T>({
+  organizationId,
+  listId,
+  items,
+  itemKey,
+  initialOrder,
+  isImpersonating,
+}: {
+  organizationId: string;
+  listId: string;
+  items: T[];
+  itemKey: (item: T) => string;
+  initialOrder: string[] | undefined;
+  isImpersonating: boolean;
+}) {
+  const orderFetcher = useFetcher();
+
+  const [order, setOrder] = useState<string[]>(
+    () => initialOrder ?? items.map(itemKey)
+  );
+
+  // Sync order when organizationId changes (component may not remount)
+  useEffect(() => {
+    setOrder(initialOrder ?? items.map(itemKey));
+  }, [organizationId]);
+
+  // Sort items by stored order, new items go to end
+  const orderedItems = useMemo(() => {
+    const orderMap = new Map(order.map((id, i) => [id, i]));
+    return [...items].sort((a, b) => {
+      const aIdx = orderMap.get(itemKey(a)) ?? Infinity;
+      const bIdx = orderMap.get(itemKey(b)) ?? Infinity;
+      return aIdx - bIdx;
+    });
+  }, [items, order, itemKey]);
+
+  // Layout for ReactGridLayout (1-column vertical list, each item h=1 row)
+  const layout = useMemo(
+    () =>
+      orderedItems.map((item, i) => ({
+        i: itemKey(item),
+        x: 0,
+        y: i,
+        w: 1,
+        h: 1,
+      })),
+    [orderedItems, itemKey]
+  );
+
+  // Width measurement for ReactGridLayout
+  const {
+    width: gridWidth,
+    containerRef,
+    mounted: gridMounted,
+  } = useContainerWidth({ initialWidth: 216 });
+
+  const canReorder = orderedItems.length >= 2;
+
+  // Track layout during drag for real-time visual updates
+  const [dragLayout, setDragLayout] = useState<Layout | null>(null);
+
+  const handleDrag = useCallback((layout: Layout) => {
+    setDragLayout(layout);
+  }, []);
+
+  // Handle drag stop - extract new order from layout y-positions
+  const handleDragStop = useCallback(
+    (layout: Layout) => {
+      setDragLayout(null);
+      const sorted = [...layout].sort((a, b) => a.y - b.y);
+      const newOrder = sorted.map((item) => item.i);
+      if (JSON.stringify(newOrder) === JSON.stringify(order)) return;
+      setOrder(newOrder);
+      // Persist immediately
+      if (!isImpersonating) {
+        const formData = new FormData();
+        formData.append("organizationId", organizationId);
+        formData.append("listId", listId);
+        formData.append("itemOrder", JSON.stringify(newOrder));
+        orderFetcher.submit(formData, {
+          method: "POST",
+          action: "/resources/preferences/sidemenu",
+        });
+      }
+    },
+    [order, organizationId, listId, isImpersonating, orderFetcher]
+  );
+
+  // Compute which item is visually last (during drag or at rest)
+  const getIsLast = useCallback(
+    (key: string, index: number) => {
+      if (dragLayout) {
+        const maxY = Math.max(...dragLayout.map((l) => l.y));
+        return dragLayout.find((l) => l.i === key)?.y === maxY;
+      }
+      return index === orderedItems.length - 1;
+    },
+    [dragLayout, orderedItems.length]
+  );
+
+  return {
+    orderedItems,
+    layout,
+    containerRef: containerRef as Ref<HTMLDivElement>,
+    gridWidth,
+    gridMounted,
+    canReorder,
+    handleDrag,
+    handleDragStop,
+    getIsLast,
+  };
+}
diff --git a/apps/webapp/app/components/onboarding/TechnologyPicker.tsx b/apps/webapp/app/components/onboarding/TechnologyPicker.tsx
new file mode 100644
index 00000000000..9c9f9a6b24a
--- /dev/null
+++ b/apps/webapp/app/components/onboarding/TechnologyPicker.tsx
@@ -0,0 +1,386 @@
+import * as Ariakit from "@ariakit/react";
+import {
+  XMarkIcon,
+  PlusIcon,
+  CubeIcon,
+  MagnifyingGlassIcon,
+  ChevronDownIcon,
+} from "@heroicons/react/20/solid";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { CheckboxIndicator } from "~/components/primitives/CheckboxIndicator";
+import { cn } from "~/utils/cn";
+import { matchSorter } from "match-sorter";
+import { ShortcutKey } from "~/components/primitives/ShortcutKey";
+
+const pillColors = [
+  "bg-green-800/40 border-green-600/50",
+  "bg-teal-800/40 border-teal-600/50",
+  "bg-blue-800/40 border-blue-600/50",
+  "bg-indigo-800/40 border-indigo-600/50",
+  "bg-violet-800/40 border-violet-600/50",
+  "bg-purple-800/40 border-purple-600/50",
+  "bg-fuchsia-800/40 border-fuchsia-600/50",
+  "bg-pink-800/40 border-pink-600/50",
+  "bg-rose-800/40 border-rose-600/50",
+  "bg-orange-800/40 border-orange-600/50",
+  "bg-amber-800/40 border-amber-600/50",
+  "bg-yellow-800/40 border-yellow-600/50",
+  "bg-lime-800/40 border-lime-600/50",
+  "bg-emerald-800/40 border-emerald-600/50",
+  "bg-cyan-800/40 border-cyan-600/50",
+  "bg-sky-800/40 border-sky-600/50",
+];
+
+function getPillColor(value: string): string {
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash << 5) - hash + value.charCodeAt(i);
+    hash |= 0;
+  }
+  return pillColors[Math.abs(hash) % pillColors.length];
+}
+
+export const TECHNOLOGY_OPTIONS = [
+  "Airflow",
+  "Angular",
+  "Anthropic",
+  "Astro",
+  "Auth0",
+  "AWS",
+  "AWS SQS",
+  "Azure",
+  "BigQuery",
+  "BullMQ",
+  "Bun",
+  "Cassandra",
+  "Celery",
+  "ClickHouse",
+  "Clerk",
+  "Cloudflare",
+  "CockroachDB",
+  "Cohere",
+  "Convex",
+  "Databricks",
+  "Datadog",
+  "DeepSeek",
+  "Deno",
+  "DigitalOcean",
+  "Django",
+  "Docker",
+  "Drizzle",
+  "DynamoDB",
+  "Elasticsearch",
+  "Electron",
+  "Elevenlabs",
+  "Expo",
+  "Express",
+  "FastAPI",
+  "Fastify",
+  "Firebase",
+  "Flask",
+  "Fly.io",
+  "Gatsby",
+  "GCP",
+  "Go",
+  "Google Cloud Tasks",
+  "Google Gemini",
+  "GraphQL",
+  "Groq",
+  "Heroku",
+  "Hono",
+  "htmx",
+  "Hugging Face",
+  "Inngest",
+  "Kafka",
+  "Kubernetes",
+  "LangChain",
+  "Laravel",
+  "LlamaIndex",
+  "MariaDB",
+  "Midjourney",
+  "Mistral",
+  "MongoDB",
+  "Mongoose",
+  "MySQL",
+  "Neo4j",
+  "Neon",
+  "Nest.js",
+  "Netlify",
+  "Next.js",
+  "Node.js",
+  "Nuxt",
+  "Ollama",
+  "OpenAI",
+  "Perplexity",
+  "PHP",
+  "Pinecone",
+  "PlanetScale",
+  "Python",
+  "PostHog",
+  "PostgreSQL",
+  "Prisma",
+  "Pulumi",
+  "RabbitMQ",
+  "Railway",
+  "React",
+  "React Native",
+  "Redis",
+  "Redshift",
+  "Remix",
+  "Render",
+  "Replicate",
+  "Resend",
+  "Ruby on Rails",
+  "Rust",
+  "SendGrid",
+  "Sentry",
+  "Sidekiq",
+  "Snowflake",
+  "Solid.js",
+  "Spring Boot",
+  "SQLite",
+  "Stability AI",
+  "Stripe",
+  "Supabase",
+  "Svelte",
+  "SvelteKit",
+  "Tailwind CSS",
+  "Temporal",
+  "Terraform",
+  "Together AI",
+  "tRPC",
+  "Turso",
+  "Twilio",
+  "TypeORM",
+  "Upstash",
+  "Vercel",
+  "Vercel AI SDK",
+  "Vite",
+  "Vue",
+  "Weaviate",
+] as const;
+
+type TechnologyPickerProps = {
+  value: string[];
+  onChange: (value: string[]) => void;
+  customValues: string[];
+  onCustomValuesChange: (values: string[]) => void;
+};
+
+export function TechnologyPicker({
+  value,
+  onChange,
+  customValues,
+  onCustomValuesChange,
+}: TechnologyPickerProps) {
+  const [open, setOpen] = useState(false);
+  const [searchValue, setSearchValue] = useState("");
+  const [otherInputValue, setOtherInputValue] = useState("");
+  const [showOtherInput, setShowOtherInput] = useState(false);
+  const otherInputRef = useRef<HTMLInputElement>(null);
+
+  const allSelected = useMemo(() => [...value, ...customValues], [value, customValues]);
+
+  const filteredOptions = useMemo(() => {
+    if (!searchValue) return TECHNOLOGY_OPTIONS;
+    return matchSorter([...TECHNOLOGY_OPTIONS], searchValue);
+  }, [searchValue]);
+
+  const toggleOption = useCallback(
+    (option: string) => {
+      if (value.includes(option)) {
+        onChange(value.filter((v) => v !== option));
+      } else {
+        onChange([...value, option]);
+      }
+    },
+    [value, onChange]
+  );
+
+  const removeItem = useCallback(
+    (item: string) => {
+      if (value.includes(item)) {
+        onChange(value.filter((v) => v !== item));
+      } else {
+        onCustomValuesChange(customValues.filter((v) => v !== item));
+      }
+    },
+    [value, onChange, customValues, onCustomValuesChange]
+  );
+
+  const addCustomValue = useCallback(() => {
+    const trimmed = otherInputValue.trim();
+    if (!trimmed) return;
+
+    const matchedOption = TECHNOLOGY_OPTIONS.find(
+      (opt) => opt.toLowerCase() === trimmed.toLowerCase()
+    );
+
+    if (matchedOption) {
+      if (!value.includes(matchedOption)) {
+        onChange([...value, matchedOption]);
+      }
+    } else if (!customValues.includes(trimmed) && !value.includes(trimmed)) {
+      onCustomValuesChange([...customValues, trimmed]);
+    }
+
+    setOtherInputValue("");
+  }, [otherInputValue, customValues, onCustomValuesChange, value, onChange]);
+
+  const handleOtherKeyDown = useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        e.stopPropagation();
+        addCustomValue();
+      }
+    },
+    [addCustomValue]
+  );
+
+  return (
+    <div className="flex flex-col gap-2">
+      {allSelected.length > 0 && (
+        <div className="flex flex-wrap gap-1.5">
+          {allSelected.map((item) => (
+            <span
+              key={item}
+              className={cn(
+                "flex items-center gap-1 rounded-sm border py-0.5 pl-1.5 pr-1 text-xs font-medium text-text-bright",
+                getPillColor(item)
+              )}
+            >
+              {item}
+              <button
+                type="button"
+                onClick={() => removeItem(item)}
+                aria-label={`Remove ${item}`}
+                className="ml-0.5 flex items-center transition hover:text-text-bright/70"
+              >
+                <XMarkIcon className="size-3.5" />
+              </button>
+            </span>
+          ))}
+        </div>
+      )}
+
+      <Ariakit.ComboboxProvider
+        resetValueOnHide
+        setValue={(val) => {
+          setSearchValue(val);
+        }}
+      >
+        <Ariakit.SelectProvider
+          open={open}
+          setOpen={setOpen}
+          value={value}
+          setValue={(v) => {
+            if (Array.isArray(v)) {
+              onChange(v);
+            }
+          }}
+          virtualFocus
+        >
+          <Ariakit.Select className="group flex h-8 w-full items-center rounded bg-charcoal-750 pl-2 pr-2.5 text-sm text-text-dimmed ring-charcoal-600 transition focus-custom hover:bg-charcoal-650 hover:ring-1">
+            <div className="flex grow items-center">
+              <CubeIcon className="mr-1.5 size-4 flex-none text-text-dimmed" />
+              <span>Select your technologies…</span>
+            </div>
+            <ChevronDownIcon className="size-4 flex-none text-text-dimmed transition group-hover:text-text-bright" />
+          </Ariakit.Select>
+
+          <Ariakit.SelectPopover
+            gutter={5}
+            unmountOnHide
+            className={cn(
+              "z-50 flex flex-col overflow-clip rounded border border-charcoal-700 bg-background-bright shadow-md outline-none animate-in fade-in-40",
+              "min-w-[max(180px,var(--popover-anchor-width))]",
+              "max-w-[min(480px,var(--popover-available-width))]",
+              "max-h-[min(400px,var(--popover-available-height))]"
+            )}
+          >
+            <div className="flex h-9 w-full flex-none items-center gap-2 border-b border-grid-dimmed bg-transparent px-3 text-xs text-text-dimmed outline-none">
+              <MagnifyingGlassIcon className="size-3.5 flex-none text-text-dimmed" />
+              <Ariakit.Combobox
+                autoSelect
+                placeholder="Search technologies…"
+                className="flex-1 bg-transparent text-xs text-text-dimmed outline-none"
+              />
+            </div>
+
+            <Ariakit.ComboboxList className="overflow-y-auto overscroll-contain scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600 focus-custom">
+              {filteredOptions.map((option) => (
+                <Ariakit.ComboboxItem
+                  key={option}
+                  className="group cursor-pointer px-1 pt-1 text-2sm text-text-dimmed focus-custom last:pb-1"
+                  onClick={(e) => {
+                    e.preventDefault();
+                    toggleOption(option);
+                  }}
+                >
+                  <div className="flex h-8 w-full items-center gap-2 rounded-sm px-2 group-data-[active-item=true]:bg-tertiary hover:bg-tertiary">
+                    <CheckboxIndicator checked={value.includes(option)} />
+                    <span className="grow truncate text-text-bright">{option}</span>
+                  </div>
+                </Ariakit.ComboboxItem>
+              ))}
+
+              {filteredOptions.length === 0 && searchValue && (
+                <div className="px-3 py-2 text-xs text-text-dimmed">
+                  No matches for &ldquo;{searchValue}&rdquo;
+                </div>
+              )}
+            </Ariakit.ComboboxList>
+
+            <div className="sticky bottom-0 border-t border-charcoal-700 bg-background-bright px-1 py-1">
+              {showOtherInput ? (
+                <div className="flex h-8 w-full items-center rounded-sm bg-tertiary pl-0 pr-2 ring-1 ring-charcoal-650">
+                  <input
+                    ref={otherInputRef}
+                    type="text"
+                    value={otherInputValue}
+                    onChange={(e) => setOtherInputValue(e.target.value)}
+                    onKeyDown={handleOtherKeyDown}
+                    placeholder="Type and press Enter to add"
+                    className="flex-1 border-none bg-transparent pl-2 text-2sm text-text-bright shadow-none outline-none ring-0 placeholder:text-text-dimmed focus:border-none focus:outline-none focus:ring-0"
+                    autoFocus
+                  />
+                  <ShortcutKey
+                    shortcut={{ key: "Enter" }}
+                    variant="small"
+                    className={cn(
+                      "mr-1.5 transition-opacity duration-150",
+                      otherInputValue.length > 0 ? "opacity-100" : "opacity-0"
+                    )}
+                  />
+                  <button
+                    type="button"
+                    onClick={() => {
+                      setOtherInputValue("");
+                      setShowOtherInput(false);
+                    }}
+                    className="flex items-center text-text-dimmed hover:text-text-bright"
+                  >
+                    <XMarkIcon className="size-4" />
+                  </button>
+                </div>
+              ) : (
+                <button
+                  type="button"
+                  className="flex h-8 w-full cursor-pointer items-center gap-2 rounded-sm px-2 text-2sm text-text-dimmed hover:bg-tertiary"
+                  onClick={() => {
+                    setShowOtherInput(true);
+                    setTimeout(() => otherInputRef.current?.focus(), 0);
+                  }}
+                >
+                  <PlusIcon className="size-4 flex-none" />
+                  <span>Other (not listed)</span>
+                </button>
+              )}
+            </div>
+          </Ariakit.SelectPopover>
+        </Ariakit.SelectProvider>
+      </Ariakit.ComboboxProvider>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/AnimatedNumber.tsx b/apps/webapp/app/components/primitives/AnimatedNumber.tsx
index f2f309a5264..fea0f9d8900 100644
--- a/apps/webapp/app/components/primitives/AnimatedNumber.tsx
+++ b/apps/webapp/app/components/primitives/AnimatedNumber.tsx
@@ -1,16 +1,71 @@
 import { animate, motion, useMotionValue, useTransform } from "framer-motion";
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 
-export function AnimatedNumber({ value }: { value: number }) {
+/**
+ * Determines the number of decimal places to display based on the value.
+ * - For integers or large numbers (>=100), no decimals
+ * - For numbers >= 10, 1 decimal place
+ * - For numbers >= 1, 2 decimal places
+ * - For smaller numbers, up to 4 decimal places
+ */
+function getDecimalPlaces(value: number): number {
+  if (Number.isInteger(value)) return 0;
+
+  const absValue = Math.abs(value);
+  if (absValue >= 100) return 0;
+  if (absValue >= 10) return 1;
+  if (absValue >= 1) return 2;
+  if (absValue >= 0.1) return 3;
+  return 4;
+}
+
+/**
+ * Sanitizes a decimal places value to ensure it's valid for toLocaleString.
+ * - Coerces to a finite number (handles NaN, Infinity, -Infinity)
+ * - Rounds to an integer
+ * - Clamps to the valid 0-20 range for toLocaleString options
+ */
+function sanitizeDecimals(decimals: number): number {
+  if (!Number.isFinite(decimals)) {
+    return 0;
+  }
+  return Math.min(20, Math.max(0, Math.round(decimals)));
+}
+
+export function AnimatedNumber({
+  value,
+  duration = 0.5,
+  decimalPlaces,
+}: {
+  value: number;
+  duration?: number;
+  /** Number of decimal places to display. If not provided, auto-detects based on value. */
+  decimalPlaces?: number;
+}) {
   const motionValue = useMotionValue(value);
-  let display = useTransform(motionValue, (current) => Math.round(current).toLocaleString());
+
+  // Determine decimal places - use provided value or auto-detect, then sanitize
+  const safeDecimals = useMemo(() => {
+    const rawDecimals = decimalPlaces !== undefined ? decimalPlaces : getDecimalPlaces(value);
+    return sanitizeDecimals(rawDecimals);
+  }, [decimalPlaces, value]);
+
+  const display = useTransform(motionValue, (current) => {
+    if (safeDecimals === 0) {
+      return Math.round(current).toLocaleString();
+    }
+    return current.toLocaleString(undefined, {
+      minimumFractionDigits: safeDecimals,
+      maximumFractionDigits: safeDecimals,
+    });
+  });
 
   useEffect(() => {
     animate(motionValue, value, {
-      duration: 0.5,
+      duration,
       ease: "easeInOut",
     });
-  }, [value]);
+  }, [value, duration]);
 
   return <motion.span>{display}</motion.span>;
 }
diff --git a/apps/webapp/app/components/primitives/AppliedFilter.tsx b/apps/webapp/app/components/primitives/AppliedFilter.tsx
index b1ba1cb81ec..2eab4b772f6 100644
--- a/apps/webapp/app/components/primitives/AppliedFilter.tsx
+++ b/apps/webapp/app/components/primitives/AppliedFilter.tsx
@@ -21,12 +21,13 @@ type Variant = keyof typeof variants;
 
 type AppliedFilterProps = {
   icon?: ReactNode;
-  label: ReactNode;
+  label?: ReactNode;
   value: ReactNode;
   removable?: boolean;
   onRemove?: () => void;
   variant?: Variant;
   className?: string;
+  valueClassName?: string;
 };
 
 export function AppliedFilter({
@@ -37,6 +38,7 @@ export function AppliedFilter({
   onRemove,
   variant = "secondary/small",
   className,
+  valueClassName,
 }: AppliedFilterProps) {
   const variantClassName = variants[variant];
   return (
@@ -48,14 +50,18 @@ export function AppliedFilter({
         className
       )}
     >
-      <div className="flex items-start gap-0.5 leading-4">
-        <div className="-mt-[0.5px] flex items-center gap-1">
+      <div
+        className={cn("flex items-start leading-4", label === undefined ? "gap-1.5" : "gap-0.5")}
+      >
+        <div className="-mt-[0.5px] flex items-center gap-1.5">
           {icon}
-          <div className="text-text-bright">
-            <span>{label}</span>:
-          </div>
+          {label && (
+            <div className="text-text-bright">
+              <span>{label}</span>:
+            </div>
+          )}
         </div>
-        <div className="text-text-dimmed">
+        <div className={cn("text-text-dimmed", valueClassName)}>
           <div>{value}</div>
         </div>
       </div>
diff --git a/apps/webapp/app/components/primitives/Avatar.tsx b/apps/webapp/app/components/primitives/Avatar.tsx
index 0cb74c2ba60..9bc95d55b16 100644
--- a/apps/webapp/app/components/primitives/Avatar.tsx
+++ b/apps/webapp/app/components/primitives/Avatar.tsx
@@ -1,8 +1,10 @@
 import {
+  BoltIcon,
   BuildingOffice2Icon,
   CodeBracketSquareIcon,
   FaceSmileIcon,
   FireIcon,
+  GlobeAltIcon,
   RocketLaunchIcon,
   StarIcon,
 } from "@heroicons/react/20/solid";
@@ -25,7 +27,8 @@ export const AvatarData = z.discriminatedUnion("type", [
   }),
   z.object({
     type: z.literal(AvatarType.enum.image),
-    url: z.string().url(),
+    url: z.string(),
+    lastIconHex: z.string().optional(),
   }),
 ]);
 
@@ -85,6 +88,7 @@ export const avatarIcons: Record<string, React.ComponentType<React.SVGProps<SVGS
   "hero:fire": FireIcon,
   "hero:star": StarIcon,
   "hero:face-smile": FaceSmileIcon,
+  "hero:bolt": BoltIcon,
 };
 
 export const defaultAvatarColors = [
@@ -179,9 +183,21 @@ function AvatarIcon({
 }
 
 function AvatarImage({ avatar, size }: { avatar: ImageAvatar; size: number }) {
+  if (!avatar.url) {
+    return (
+      <span className="grid shrink-0 place-items-center" style={styleFromSize(size)}>
+        <GlobeAltIcon className="size-[90%] text-text-dimmed" />
+      </span>
+    );
+  }
+
   return (
-    <span className="grid place-items-center" style={styleFromSize(size)}>
-      <img src={avatar.url} alt="Organization avatar" className="size-6" />
+    <span className="grid shrink-0 place-items-center" style={styleFromSize(size)}>
+      <img
+        src={avatar.url}
+        alt="Organization avatar"
+        className="size-full rounded-[10%] object-contain"
+      />
     </span>
   );
 }
diff --git a/apps/webapp/app/components/primitives/Buttons.tsx b/apps/webapp/app/components/primitives/Buttons.tsx
index c2845f1040a..86e23801e72 100644
--- a/apps/webapp/app/components/primitives/Buttons.tsx
+++ b/apps/webapp/app/components/primitives/Buttons.tsx
@@ -1,10 +1,18 @@
 import { Link, type LinkProps, NavLink, type NavLinkProps } from "@remix-run/react";
-import React, { forwardRef, type ReactNode, useImperativeHandle, useRef } from "react";
+import React, {
+  forwardRef,
+  type ReactNode,
+  useEffect,
+  useImperativeHandle,
+  useRef,
+  useState,
+} from "react";
 import { type ShortcutDefinition, useShortcutKeys } from "~/hooks/useShortcutKeys";
 import { cn } from "~/utils/cn";
 import { ShortcutKey } from "./ShortcutKey";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "./Tooltip";
 import { Icon, type RenderIcon } from "./Icon";
+import { Spinner } from "./Spinner";
 
 const sizes = {
   small: {
@@ -180,6 +188,7 @@ export type ButtonContentPropsType = {
   tooltip?: ReactNode;
   iconSpacing?: string;
   hideShortcutKey?: boolean;
+  isLoading?: boolean;
 };
 
 export function ButtonContent(props: ButtonContentPropsType) {
@@ -196,7 +205,19 @@ export function ButtonContent(props: ButtonContentPropsType) {
     tooltip,
     iconSpacing,
     hideShortcutKey,
+    isLoading,
   } = props;
+
+  const [showSpinner, setShowSpinner] = useState(false);
+  useEffect(() => {
+    if (!isLoading) {
+      setShowSpinner(false);
+      return;
+    }
+    const timer = setTimeout(() => setShowSpinner(true), 200);
+    return () => clearTimeout(timer);
+  }, [isLoading]);
+
   const variation = allVariants.variant[props.variant];
 
   const btnClassName = cn(allVariants.$all, variation.button);
@@ -217,56 +238,64 @@ export function ButtonContent(props: ButtonContentPropsType) {
 
   const buttonContent = (
     <div className={cn("flex", fullWidth ? "" : "w-fit text-xxs", btnClassName, className)}>
-      <div
-        className={cn(
-          textAlignLeft ? "text-left" : "justify-center",
-          "flex w-full items-center",
-          iconSpacingClassName,
-          iconSpacing
-        )}
-      >
-        {LeadingIcon && (
-          <Icon
-            icon={LeadingIcon}
-            className={cn(
-              iconClassName,
-              variation.icon,
-              leadingIconClassName,
-              "shrink-0 justify-start"
-            )}
-          />
-        )}
+      <div className={cn("relative", "flex w-full items-center")}>
+        <div
+          className={cn(
+            textAlignLeft ? "text-left" : "justify-center",
+            "flex w-full items-center",
+            iconSpacingClassName,
+            iconSpacing,
+            showSpinner && "invisible"
+          )}
+        >
+          {LeadingIcon && (
+            <Icon
+              icon={LeadingIcon}
+              className={cn(
+                iconClassName,
+                variation.icon,
+                leadingIconClassName,
+                "shrink-0 justify-start"
+              )}
+            />
+          )}
 
-        {text &&
-          (typeof text === "string" ? (
-            <span className={cn("mx-auto grow self-center truncate", textColorClassName)}>
-              {text}
-            </span>
-          ) : (
-            <>{text}</>
-          ))}
-
-        {shortcut &&
-          !tooltip &&
-          props.shortcutPosition === "before-trailing-icon" &&
-          renderShortcutKey()}
-
-        {TrailingIcon && (
-          <Icon
-            icon={TrailingIcon}
-            className={cn(
-              iconClassName,
-              variation.icon,
-              trailingIconClassName,
-              "shrink-0 justify-end"
-            )}
-          />
-        )}
+          {text &&
+            (typeof text === "string" ? (
+              <span className={cn("mx-auto grow self-center truncate", textColorClassName)}>
+                {text}
+              </span>
+            ) : (
+              <>{text}</>
+            ))}
+
+          {shortcut &&
+            !tooltip &&
+            props.shortcutPosition === "before-trailing-icon" &&
+            renderShortcutKey()}
 
-        {shortcut &&
-          !tooltip &&
-          (!props.shortcutPosition || props.shortcutPosition === "after-trailing-icon") &&
-          renderShortcutKey()}
+          {TrailingIcon && (
+            <Icon
+              icon={TrailingIcon}
+              className={cn(
+                iconClassName,
+                variation.icon,
+                trailingIconClassName,
+                "shrink-0 justify-end"
+              )}
+            />
+          )}
+
+          {shortcut &&
+            !tooltip &&
+            (!props.shortcutPosition || props.shortcutPosition === "after-trailing-icon") &&
+            renderShortcutKey()}
+        </div>
+        {showSpinner && (
+          <span className="absolute inset-0 flex items-center justify-center">
+            <Spinner className="size-3.5" color="white" />
+          </span>
+        )}
       </div>
     </div>
   );
@@ -298,6 +327,8 @@ export const Button = forwardRef<HTMLButtonElement, ButtonPropsType>(
     const innerRef = useRef<HTMLButtonElement>(null);
     useImperativeHandle(ref, () => innerRef.current as HTMLButtonElement);
 
+    const isDisabled = disabled || props.isLoading;
+
     useShortcutKeys({
       shortcut: props.shortcut,
       action: (e) => {
@@ -307,14 +338,14 @@ export const Button = forwardRef<HTMLButtonElement, ButtonPropsType>(
           e.stopPropagation();
         }
       },
-      disabled: disabled || !props.shortcut,
+      disabled: isDisabled || !props.shortcut,
     });
 
-    return (
+    const buttonElement = (
       <button
         className={cn("group/button outline-none focus-custom", props.fullWidth ? "w-full" : "")}
         type={type}
-        disabled={disabled}
+        disabled={isDisabled}
         onClick={onClick}
         name={props.name}
         value={props.value}
@@ -322,9 +353,30 @@ export const Button = forwardRef<HTMLButtonElement, ButtonPropsType>(
         form={props.form}
         autoFocus={autoFocus}
       >
-        <ButtonContent {...props} />
+        <ButtonContent {...props} tooltip={undefined} />
       </button>
     );
+
+    if (props.tooltip) {
+      return (
+        <TooltipProvider>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <span className={isDisabled ? "cursor-default" : undefined}>
+                {buttonElement}
+              </span>
+            </TooltipTrigger>
+            <TooltipContent className="flex items-center gap-3 py-1.5 pl-2.5 pr-3 text-xs text-text-bright">
+              {props.tooltip} {props.shortcut && !props.hideShortcutKey && (
+                <ShortcutKey shortcut={props.shortcut} variant="medium" className="ml-1" />
+              )}
+            </TooltipContent>
+          </Tooltip>
+        </TooltipProvider>
+      );
+    }
+
+    return buttonElement;
   }
 );
 
@@ -389,7 +441,7 @@ export const LinkButton = ({
         to={to}
         ref={innerRef}
         replace={replace}
-        className={cn("group/button block focus-custom", props.fullWidth ? "w-full" : "")}
+        className={cn("group/button block focus-custom", props.fullWidth ? "w-full" : "w-fit")}
         onClick={onClick}
         onMouseDown={onMouseDown}
         onMouseEnter={onMouseEnter}
diff --git a/apps/webapp/app/components/primitives/Calendar.tsx b/apps/webapp/app/components/primitives/Calendar.tsx
new file mode 100644
index 00000000000..5b72bd1c97a
--- /dev/null
+++ b/apps/webapp/app/components/primitives/Calendar.tsx
@@ -0,0 +1,126 @@
+"use client";
+
+import * as React from "react";
+import { ChevronLeftIcon, ChevronRightIcon } from "@heroicons/react/20/solid";
+import { format } from "date-fns";
+import { DayPicker, useDayPicker } from "react-day-picker";
+import { cn } from "~/utils/cn";
+
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+
+const navButtonClass =
+  "size-7 rounded-[3px] bg-secondary border border-charcoal-600 text-text-bright hover:bg-charcoal-600 hover:border-charcoal-550 transition inline-flex items-center justify-center";
+
+function CustomMonthCaption({ calendarMonth }: { calendarMonth: { date: Date } }) {
+  const { goToMonth, nextMonth, previousMonth } = useDayPicker();
+
+  return (
+    <div className="flex w-full items-center justify-between px-1">
+      <button
+        type="button"
+        className={navButtonClass}
+        disabled={!previousMonth}
+        onClick={() => previousMonth && goToMonth(previousMonth)}
+        aria-label="Go to previous month"
+      >
+        <ChevronLeftIcon className="size-4" />
+      </button>
+      <div className="flex items-center gap-2">
+        <select
+          className="rounded border border-charcoal-600 bg-charcoal-750 px-2 py-1 text-sm text-text-bright focus:border-charcoal-500 focus:outline-none"
+          value={calendarMonth.date.getMonth()}
+          onChange={(e) => {
+            const newDate = new Date(calendarMonth.date);
+            newDate.setMonth(parseInt(e.target.value));
+            goToMonth(newDate);
+          }}
+        >
+          {Array.from({ length: 12 }, (_, i) => (
+            <option key={i} value={i}>
+              {format(new Date(2000, i), "MMM")}
+            </option>
+          ))}
+        </select>
+        <select
+          className="rounded border border-charcoal-600 bg-charcoal-750 px-2 py-1 text-sm text-text-bright focus:border-charcoal-500 focus:outline-none"
+          value={calendarMonth.date.getFullYear()}
+          onChange={(e) => {
+            const newDate = new Date(calendarMonth.date);
+            newDate.setFullYear(parseInt(e.target.value));
+            goToMonth(newDate);
+          }}
+        >
+          {Array.from({ length: 100 }, (_, i) => {
+            const year = new Date().getFullYear() - 50 + i;
+            return (
+              <option key={year} value={year}>
+                {year}
+              </option>
+            );
+          })}
+        </select>
+      </div>
+      <button
+        type="button"
+        className={navButtonClass}
+        disabled={!nextMonth}
+        onClick={() => nextMonth && goToMonth(nextMonth)}
+        aria-label="Go to next month"
+      >
+        <ChevronRightIcon className="size-4" />
+      </button>
+    </div>
+  );
+}
+
+export function Calendar({
+  className,
+  classNames,
+  showOutsideDays = true,
+  ...props
+}: CalendarProps) {
+  return (
+    <DayPicker
+      showOutsideDays={showOutsideDays}
+      weekStartsOn={1}
+      className={cn("p-3", className)}
+      classNames={{
+        months: "flex flex-col sm:flex-row gap-2",
+        month: "flex flex-col gap-4",
+        month_caption: "flex justify-center pt-1 relative items-center w-full",
+        caption_label: "sr-only",
+        nav: "hidden",
+        month_grid: "w-full border-collapse",
+        weekdays: "flex",
+        weekday: "text-text-dimmed rounded-md w-8 font-normal text-[0.8rem]",
+        week: "flex w-full mt-2",
+        day: "relative p-0 text-center text-sm focus-within:relative focus-within:z-20 [&:has([aria-selected])]:bg-charcoal-700 [&:has([aria-selected].day-outside)]:bg-charcoal-700/50 [&:has([aria-selected].day-range-end)]:rounded-r-md first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md",
+        day_button: cn(
+          "size-8 p-0 font-normal text-text-bright rounded-md",
+          "hover:bg-charcoal-700 hover:text-text-bright",
+          "focus:bg-charcoal-700 focus:text-text-bright focus:outline-none",
+          "aria-selected:opacity-100"
+        ),
+        range_start: "day-range-start rounded-l-md",
+        range_end: "day-range-end rounded-r-md",
+        selected:
+          "bg-indigo-600 text-text-bright hover:bg-indigo-600 hover:text-text-bright focus:bg-indigo-600 focus:text-text-bright rounded-md",
+        today: "bg-charcoal-700 text-text-bright rounded-md",
+        outside:
+          "day-outside text-text-dimmed opacity-50 aria-selected:bg-charcoal-700/50 aria-selected:text-text-dimmed aria-selected:opacity-30",
+        disabled: "text-text-dimmed opacity-50",
+        range_middle: "aria-selected:bg-charcoal-700 aria-selected:text-text-bright",
+        hidden: "invisible",
+        dropdowns: "flex gap-2 items-center justify-center",
+        dropdown:
+          "bg-charcoal-750 border border-charcoal-600 rounded px-2 py-1 text-sm text-text-bright focus:outline-none focus:border-charcoal-500",
+        ...classNames,
+      }}
+      components={{
+        MonthCaption: CustomMonthCaption,
+      }}
+      {...props}
+    />
+  );
+}
+Calendar.displayName = "Calendar";
diff --git a/apps/webapp/app/components/primitives/Callout.tsx b/apps/webapp/app/components/primitives/Callout.tsx
index 207ad134b64..da2d2ea760e 100644
--- a/apps/webapp/app/components/primitives/Callout.tsx
+++ b/apps/webapp/app/components/primitives/Callout.tsx
@@ -1,4 +1,5 @@
 import {
+  CreditCardIcon,
   ExclamationCircleIcon,
   ExclamationTriangleIcon,
   InformationCircleIcon,
@@ -60,10 +61,10 @@ export const variantClasses = {
     linkClassName: "transition hover:bg-blue-400/20",
   },
   pricing: {
-    className: "border-charcoal-700 bg-charcoal-800",
-    icon: <ChartBarIcon className="h-5 w-5 shrink-0 text-text-dimmed" />,
-    textColor: "text-text-bright",
-    linkClassName: "transition hover:bg-charcoal-750",
+    className: "border-indigo-400/20 bg-indigo-800/30",
+    icon: <CreditCardIcon className="h-5 w-5 shrink-0 text-indigo-400" />,
+    textColor: "text-indigo-300",
+    linkClassName: "transition hover:bg-indigo-400/20",
   },
 } as const;
 
diff --git a/apps/webapp/app/components/primitives/Checkbox.tsx b/apps/webapp/app/components/primitives/Checkbox.tsx
index 59f12a40481..3b9ca1c532d 100644
--- a/apps/webapp/app/components/primitives/Checkbox.tsx
+++ b/apps/webapp/app/components/primitives/Checkbox.tsx
@@ -184,8 +184,8 @@ export const Checkbox = forwardRef<HTMLInputElement, SimpleCheckboxProps>(
       <input
         type="checkbox"
         className={cn(
-          props.readOnly || props.disabled ? "cursor-default" : "cursor-pointer",
-          "read-only:border-charcoal-650 disabled:border-charcoal-650 rounded-sm border border-charcoal-600 bg-transparent transition checked:!bg-indigo-500 read-only:!bg-charcoal-700 group-hover:bg-charcoal-900 group-hover:checked:bg-indigo-500 group-focus:ring-1 focus:ring-indigo-500 focus:ring-offset-0 focus:ring-offset-transparent focus-visible:outline-none  focus-visible:ring-indigo-500 disabled:!bg-charcoal-700"
+          props.disabled ? "cursor-not-allowed" : props.readOnly ? "cursor-default" : "cursor-pointer",
+          "read-only:border-charcoal-650 disabled:border-charcoal-650 disabled:opacity-50 rounded-sm border border-charcoal-600 bg-transparent transition checked:!bg-indigo-500 read-only:!bg-charcoal-700 group-hover:bg-charcoal-900 group-hover:checked:bg-indigo-500 group-focus:ring-1 focus:ring-indigo-500 focus:ring-offset-0 focus:ring-offset-transparent focus-visible:outline-none focus-visible:ring-indigo-500 disabled:!bg-charcoal-700"
         )}
         {...props}
         ref={ref}
diff --git a/apps/webapp/app/components/primitives/CheckboxIndicator.tsx b/apps/webapp/app/components/primitives/CheckboxIndicator.tsx
new file mode 100644
index 00000000000..0fe0f83b9aa
--- /dev/null
+++ b/apps/webapp/app/components/primitives/CheckboxIndicator.tsx
@@ -0,0 +1,24 @@
+import { cn } from "~/utils/cn";
+
+export function CheckboxIndicator({ checked }: { checked: boolean }) {
+  return (
+    <div
+      className={cn(
+        "flex size-4 flex-none items-center justify-center rounded border",
+        checked ? "border-indigo-500 bg-indigo-600" : "border-charcoal-600 bg-charcoal-700"
+      )}
+    >
+      {checked && (
+        <svg className="size-3 text-white" viewBox="0 0 12 12" fill="none">
+          <path
+            d="M2.5 6L5 8.5L9.5 3.5"
+            stroke="currentColor"
+            strokeWidth="1.5"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+          />
+        </svg>
+      )}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/ClientTabs.tsx b/apps/webapp/app/components/primitives/ClientTabs.tsx
index bc3943e82b2..aef45fe0cce 100644
--- a/apps/webapp/app/components/primitives/ClientTabs.tsx
+++ b/apps/webapp/app/components/primitives/ClientTabs.tsx
@@ -51,6 +51,7 @@ const ClientTabs = React.forwardRef<
     <ClientTabsContext.Provider value={contextValue}>
       <TabsPrimitive.Root
         ref={ref}
+        activationMode="manual"
         onValueChange={handleValueChange}
         {...controlledProps}
         {...props}
@@ -96,6 +97,7 @@ const ClientTabsTrigger = React.forwardRef<
     return (
       <TabsPrimitive.Trigger
         ref={ref}
+        tabIndex={0}
         className={cn(
           "group relative flex h-full grow items-center justify-center focus-custom disabled:pointer-events-none disabled:opacity-50",
           "flex-1 basis-0",
@@ -134,6 +136,7 @@ const ClientTabsTrigger = React.forwardRef<
     return (
       <TabsPrimitive.Trigger
         ref={ref}
+        tabIndex={0}
         className={cn(
           "group flex flex-col items-center pt-1 focus-custom disabled:pointer-events-none disabled:opacity-50",
           className
@@ -143,7 +146,7 @@ const ClientTabsTrigger = React.forwardRef<
         <span
           className={cn(
             "text-sm transition duration-200",
-            isActive ? "text-text-bright" : "text-text-dimmed hover:text-text-bright"
+            isActive ? "text-text-bright" : "text-text-dimmed group-hover:text-text-bright"
           )}
         >
           {children}
@@ -170,8 +173,9 @@ const ClientTabsTrigger = React.forwardRef<
   return (
     <TabsPrimitive.Trigger
       ref={ref}
+      tabIndex={0}
       className={cn(
-        "ring-offset-background focus-visible:ring-ring inline-flex items-center justify-center whitespace-nowrap border-r border-charcoal-700 px-2 text-sm transition-all first:pl-0 last:border-none data-[state=active]:text-indigo-500 data-[state=inactive]:text-text-dimmed data-[state=inactive]:hover:text-text-bright focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+        "inline-flex items-center justify-center whitespace-nowrap border-r border-charcoal-700 px-2 text-sm transition-all first:pl-0 last:border-none focus-custom data-[state=active]:text-indigo-500 data-[state=inactive]:text-text-dimmed data-[state=inactive]:hover:text-text-bright disabled:pointer-events-none disabled:opacity-50",
         className
       )}
       {...props}
@@ -188,9 +192,11 @@ const ClientTabsContent = React.forwardRef<
 >(({ className, ...props }, ref) => (
   <TabsPrimitive.Content
     ref={ref}
+    tabIndex={-1}
     className={cn(
-      "ring-offset-background focus-visible:ring-ring mt-1 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2",
-      className
+      "mt-1 outline-none",
+      className,
+      "data-[state=inactive]:hidden"
     )}
     {...props}
   />
diff --git a/apps/webapp/app/components/primitives/CopyTextLink.tsx b/apps/webapp/app/components/primitives/CopyTextLink.tsx
new file mode 100644
index 00000000000..33818fa6077
--- /dev/null
+++ b/apps/webapp/app/components/primitives/CopyTextLink.tsx
@@ -0,0 +1,33 @@
+import { ClipboardCheckIcon, ClipboardIcon } from "lucide-react";
+import { useCopy } from "~/hooks/useCopy";
+import { cn } from "~/utils/cn";
+
+type CopyTextLinkProps = {
+  value: string;
+  className?: string;
+};
+
+export function CopyTextLink({ value, className }: CopyTextLinkProps) {
+  const { copy, copied } = useCopy(value);
+
+  return (
+    <button
+      type="button"
+      onClick={copy}
+      className={cn(
+        "inline-flex cursor-pointer items-center gap-1 text-xs transition-colors",
+        copied
+          ? "text-success"
+          : "text-text-dimmed hover:text-text-bright",
+        className
+      )}
+    >
+      {copied ? "Copied" : "Copy"}
+      {copied ? (
+        <ClipboardCheckIcon className="size-3" />
+      ) : (
+        <ClipboardIcon className="size-3" />
+      )}
+    </button>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/CopyableText.tsx b/apps/webapp/app/components/primitives/CopyableText.tsx
index fa02e564727..9be81d4d64e 100644
--- a/apps/webapp/app/components/primitives/CopyableText.tsx
+++ b/apps/webapp/app/components/primitives/CopyableText.tsx
@@ -72,23 +72,24 @@ export function CopyableText({
         button={
           <Button
             variant="minimal/small"
-            onClick={(e) => { 
+            onClick={(e) => {
               e.stopPropagation();
-              copy(); 
+              copy();
             }}
             className={cn(
-              "cursor-pointer bg-transparent py-0 px-1 text-left text-text-bright transition-colors hover:text-white hover:bg-transparent",
+              "cursor-pointer bg-transparent px-1 py-0 text-left text-text-dimmed transition-colors hover:bg-transparent",
               className
             )}
           >
-            <span>{value}</span>
+            <span className="transition-colors group-hover/button:text-text-bright">{value}</span>
           </Button>
         }
-        content={copied ? "Copied" : "Click to copy"}
-        className="font-sans px-2 py-1"
+        content={copied ? "Copied" : "Copy"}
+        className="px-2 py-1 font-sans"
         disableHoverableContent
         open={isHovered || copied}
         onOpenChange={setIsHovered}
+        asChild
       />
     );
   }
diff --git a/apps/webapp/app/components/primitives/DateField.tsx b/apps/webapp/app/components/primitives/DateField.tsx
index dd53eb5d639..1fd6040f86a 100644
--- a/apps/webapp/app/components/primitives/DateField.tsx
+++ b/apps/webapp/app/components/primitives/DateField.tsx
@@ -1,9 +1,11 @@
-import { BellAlertIcon, XMarkIcon } from "@heroicons/react/20/solid";
 import { CalendarDateTime, createCalendar } from "@internationalized/date";
 import { useDateField, useDateSegment } from "@react-aria/datepicker";
-import type { DateFieldState, DateSegment } from "@react-stately/datepicker";
-import { useDateFieldState } from "@react-stately/datepicker";
-import { Granularity } from "@react-types/datepicker";
+import {
+  useDateFieldState,
+  type DateFieldState,
+  type DateSegment,
+} from "@react-stately/datepicker";
+import { type Granularity } from "@react-types/datepicker";
 import { useEffect, useRef, useState } from "react";
 import { cn } from "~/utils/cn";
 import { Button } from "./Buttons";
diff --git a/apps/webapp/app/components/primitives/DateTime.tsx b/apps/webapp/app/components/primitives/DateTime.tsx
index 258a18d5382..4dae92731af 100644
--- a/apps/webapp/app/components/primitives/DateTime.tsx
+++ b/apps/webapp/app/components/primitives/DateTime.tsx
@@ -1,16 +1,64 @@
 import { GlobeAltIcon, GlobeAmericasIcon } from "@heroicons/react/20/solid";
+import { useRouteLoaderData } from "@remix-run/react";
+import { formatDistanceToNow } from "date-fns";
 import { Laptop } from "lucide-react";
-import { Fragment, type ReactNode, useEffect, useState } from "react";
+import { memo, type ReactNode, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import { CopyButton } from "./CopyButton";
 import { useLocales } from "./LocaleProvider";
 import { Paragraph } from "./Paragraph";
 import { SimpleTooltip } from "./Tooltip";
 
+// Cache the browser's local timezone - resolved once and reused
+let cachedLocalTimeZone: string | null = null;
+
+function getLocalTimeZone(): string {
+  if (cachedLocalTimeZone === null) {
+    cachedLocalTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+  return cachedLocalTimeZone;
+}
+
+// For SSR compatibility: returns "UTC" on server, actual timezone on client
+function subscribeToTimeZone() {
+  // No-op - timezone doesn't change
+  return () => {};
+}
+
+function getTimeZoneSnapshot(): string {
+  return getLocalTimeZone();
+}
+
+function getServerTimeZoneSnapshot(): string {
+  return "UTC";
+}
+
+/**
+ * Hook to get the browser's local timezone.
+ * Uses useSyncExternalStore for SSR compatibility - returns "UTC" on server,
+ * actual timezone on client. The timezone is cached and only resolved once.
+ */
+export function useLocalTimeZone(): string {
+  return useSyncExternalStore(subscribeToTimeZone, getTimeZoneSnapshot, getServerTimeZoneSnapshot);
+}
+
+/**
+ * Hook to get the user's preferred timezone.
+ * Returns the timezone stored in the user's preferences cookie (from root loader),
+ * falling back to the browser's local timezone if not set.
+ */
+export function useUserTimeZone(): string {
+  const rootData = useRouteLoaderData("root") as { timezone?: string } | undefined;
+  const localTimeZone = useLocalTimeZone();
+  // Use stored timezone from cookie, or fall back to browser's local timezone
+  return rootData?.timezone && rootData.timezone !== "UTC" ? rootData.timezone : localTimeZone;
+}
+
 type DateTimeProps = {
   date: Date | string;
   timeZone?: string;
   includeSeconds?: boolean;
   includeTime?: boolean;
+  includeDate?: boolean;
   showTimezone?: boolean;
   showTooltip?: boolean;
   hideDate?: boolean;
@@ -23,46 +71,48 @@ export const DateTime = ({
   timeZone,
   includeSeconds = true,
   includeTime = true,
+  includeDate = true,
   showTimezone = false,
   showTooltip = true,
   hour12 = true,
 }: DateTimeProps) => {
   const locales = useLocales();
-  const [localTimeZone, setLocalTimeZone] = useState<string>("UTC");
-
-  const realDate = typeof date === "string" ? new Date(date) : date;
+  const userTimeZone = useUserTimeZone();
 
-  useEffect(() => {
-    const resolvedOptions = Intl.DateTimeFormat().resolvedOptions();
-    setLocalTimeZone(resolvedOptions.timeZone);
-  }, []);
-
-  const tooltipContent = (
-    <TooltipContent
-      realDate={realDate}
-      timeZone={timeZone}
-      localTimeZone={localTimeZone}
-      locales={locales}
-    />
-  );
+  const realDate = useMemo(() => (typeof date === "string" ? new Date(date) : date), [date]);
 
   const formattedDateTime = (
-    <Fragment>
+    <span suppressHydrationWarning>
       {formatDateTime(
         realDate,
-        timeZone ?? localTimeZone,
+        timeZone ?? userTimeZone,
         locales,
         includeSeconds,
         includeTime,
+        includeDate,
         hour12
       ).replace(/\s/g, String.fromCharCode(32))}
       {showTimezone ? ` (${timeZone ?? "UTC"})` : null}
-    </Fragment>
+    </span>
   );
 
   if (!showTooltip) return formattedDateTime;
 
-  return <SimpleTooltip button={formattedDateTime} content={tooltipContent} side="right" />;
+  return (
+    <SimpleTooltip
+      button={formattedDateTime}
+      content={
+        <TooltipContent
+          realDate={realDate}
+          timeZone={timeZone}
+          localTimeZone={userTimeZone}
+          locales={locales}
+        />
+      }
+      side="right"
+      asChild={true}
+    />
+  );
 };
 
 export function formatDateTime(
@@ -71,12 +121,13 @@ export function formatDateTime(
   locales: string[],
   includeSeconds: boolean,
   includeTime: boolean,
+  includeDate: boolean = true,
   hour12: boolean = true
 ): string {
   return new Intl.DateTimeFormat(locales, {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
+    year: includeDate ? "numeric" : undefined,
+    month: includeDate ? "short" : undefined,
+    day: includeDate ? "numeric" : undefined,
     hour: includeTime ? "numeric" : undefined,
     minute: includeTime ? "numeric" : undefined,
     second: includeTime && includeSeconds ? "numeric" : undefined,
@@ -128,8 +179,9 @@ export function formatDateTimeISO(date: Date, timeZone: string): string {
 }
 
 // New component that only shows date when it changes
-export const SmartDateTime = ({ date, previousDate = null, timeZone = "UTC", hour12 = true }: DateTimeProps) => {
+export const SmartDateTime = ({ date, previousDate = null, hour12 = true }: DateTimeProps) => {
   const locales = useLocales();
+  const userTimeZone = useUserTimeZone();
   const realDate = typeof date === "string" ? new Date(date) : date;
   const realPrevDate = previousDate
     ? typeof previousDate === "string"
@@ -137,31 +189,19 @@ export const SmartDateTime = ({ date, previousDate = null, timeZone = "UTC", hou
       : previousDate
     : null;
 
-  // Initial formatted values
-  const initialTimeOnly = formatTimeOnly(realDate, timeZone, locales, hour12);
-  const initialWithDate = formatSmartDateTime(realDate, timeZone, locales, hour12);
-
-  // State for the formatted time
-  const [formattedDateTime, setFormattedDateTime] = useState<string>(
-    realPrevDate && isSameDay(realDate, realPrevDate) ? initialTimeOnly : initialWithDate
-  );
-
-  useEffect(() => {
-    const resolvedOptions = Intl.DateTimeFormat().resolvedOptions();
-    const userTimeZone = resolvedOptions.timeZone;
-
-    // Check if we should show the date
-    const showDatePart = !realPrevDate || !isSameDay(realDate, realPrevDate);
+  // Check if we should show the date
+  const showDatePart = !realPrevDate || !isSameDay(realDate, realPrevDate);
 
-    // Format with appropriate function
-    setFormattedDateTime(
-      showDatePart
-        ? formatSmartDateTime(realDate, userTimeZone, locales, hour12)
-        : formatTimeOnly(realDate, userTimeZone, locales, hour12)
-    );
-  }, [locales, realDate, realPrevDate, hour12]);
+  // Format with appropriate function
+  const formattedDateTime = showDatePart
+    ? formatSmartDateTime(realDate, userTimeZone, locales, hour12)
+    : formatTimeOnly(realDate, userTimeZone, locales, hour12);
 
-  return <Fragment>{formattedDateTime.replace(/\s/g, String.fromCharCode(32))}</Fragment>;
+  return (
+    <span suppressHydrationWarning>
+      {formattedDateTime.replace(/\s/g, String.fromCharCode(32))}
+    </span>
+  );
 };
 
 // Helper function to check if two dates are on the same day
@@ -174,7 +214,12 @@ function isSameDay(date1: Date, date2: Date): boolean {
 }
 
 // Format with date and time
-function formatSmartDateTime(date: Date, timeZone: string, locales: string[], hour12: boolean = true): string {
+function formatSmartDateTime(
+  date: Date,
+  timeZone: string,
+  locales: string[],
+  hour12: boolean = true
+): string {
   return new Intl.DateTimeFormat(locales, {
     month: "short",
     day: "numeric",
@@ -189,7 +234,12 @@ function formatSmartDateTime(date: Date, timeZone: string, locales: string[], ho
 }
 
 // Format time only
-function formatTimeOnly(date: Date, timeZone: string, locales: string[], hour12: boolean = true): string {
+function formatTimeOnly(
+  date: Date,
+  timeZone: string,
+  locales: string[],
+  hour12: boolean = true
+): string {
   return new Intl.DateTimeFormat(locales, {
     hour: "2-digit",
     minute: "numeric",
@@ -201,16 +251,18 @@ function formatTimeOnly(date: Date, timeZone: string, locales: string[], hour12:
   }).format(date);
 }
 
-export const DateTimeAccurate = ({
+const DateTimeAccurateInner = ({
   date,
-  timeZone = "UTC",
+  timeZone,
   previousDate = null,
   showTooltip = true,
   hideDate = false,
   hour12 = true,
 }: DateTimeProps) => {
   const locales = useLocales();
-  const [localTimeZone, setLocalTimeZone] = useState<string>("UTC");
+  const userTimeZone = useUserTimeZone();
+  // Use provided timeZone prop if available, otherwise fall back to user's preferred timezone
+  const displayTimeZone = timeZone ?? userTimeZone;
   const realDate = typeof date === "string" ? new Date(date) : date;
   const realPrevDate = previousDate
     ? typeof previousDate === "string"
@@ -218,45 +270,82 @@ export const DateTimeAccurate = ({
       : previousDate
     : null;
 
-  useEffect(() => {
-    const resolvedOptions = Intl.DateTimeFormat().resolvedOptions();
-    setLocalTimeZone(resolvedOptions.timeZone);
-  }, []);
-
   // Smart formatting based on whether date changed
-  const formattedDateTime = hideDate
-    ? formatTimeOnly(realDate, localTimeZone, locales, hour12)
-    : realPrevDate
-    ? isSameDay(realDate, realPrevDate)
-      ? formatTimeOnly(realDate, localTimeZone, locales, hour12)
-      : formatDateTimeAccurate(realDate, localTimeZone, locales, hour12)
-    : formatDateTimeAccurate(realDate, localTimeZone, locales, hour12);
+  const formattedDateTime = useMemo(() => {
+    return hideDate
+      ? formatTimeOnly(realDate, displayTimeZone, locales, hour12)
+      : realPrevDate
+      ? isSameDay(realDate, realPrevDate)
+        ? formatTimeOnly(realDate, displayTimeZone, locales, hour12)
+        : formatDateTimeAccurate(realDate, displayTimeZone, locales, hour12)
+      : formatDateTimeAccurate(realDate, displayTimeZone, locales, hour12);
+  }, [realDate, displayTimeZone, locales, hour12, hideDate, previousDate]);
 
   if (!showTooltip)
-    return <Fragment>{formattedDateTime.replace(/\s/g, String.fromCharCode(32))}</Fragment>;
+    return (
+      <span suppressHydrationWarning>
+        {formattedDateTime.replace(/\s/g, String.fromCharCode(32))}
+      </span>
+    );
 
   const tooltipContent = (
     <TooltipContent
       realDate={realDate}
       timeZone={timeZone}
-      localTimeZone={localTimeZone}
+      localTimeZone={userTimeZone}
       locales={locales}
     />
   );
 
   return (
     <SimpleTooltip
-      button={<Fragment>{formattedDateTime.replace(/\s/g, String.fromCharCode(32))}</Fragment>}
+      button={
+        <span suppressHydrationWarning>
+          {formattedDateTime.replace(/\s/g, String.fromCharCode(32))}
+        </span>
+      }
       content={tooltipContent}
       side="right"
+      asChild={true}
     />
   );
 };
 
-function formatDateTimeAccurate(date: Date, timeZone: string, locales: string[], hour12: boolean = true): string {
-  const formattedDateTime = new Intl.DateTimeFormat(locales, {
+function areDateTimePropsEqual(prev: DateTimeProps, next: DateTimeProps): boolean {
+  // Compare Date objects by timestamp value, not reference
+  const prevTime = prev.date instanceof Date ? prev.date.getTime() : prev.date;
+  const nextTime = next.date instanceof Date ? next.date.getTime() : next.date;
+  if (prevTime !== nextTime) return false;
+
+  const prevPrevTime =
+    prev.previousDate instanceof Date ? prev.previousDate.getTime() : prev.previousDate;
+  const nextPrevTime =
+    next.previousDate instanceof Date ? next.previousDate.getTime() : next.previousDate;
+  if (prevPrevTime !== nextPrevTime) return false;
+
+  return (
+    prev.timeZone === next.timeZone &&
+    prev.showTooltip === next.showTooltip &&
+    prev.hideDate === next.hideDate &&
+    prev.hour12 === next.hour12
+  );
+}
+
+export const DateTimeAccurate = memo(DateTimeAccurateInner, areDateTimePropsEqual);
+
+function formatDateTimeAccurate(
+  date: Date,
+  timeZone: string,
+  locales: string[],
+  hour12: boolean = true
+): string {
+  const datePart = new Intl.DateTimeFormat(locales, {
     month: "short",
     day: "numeric",
+    timeZone,
+  }).format(date);
+
+  const timePart = new Intl.DateTimeFormat(locales, {
     hour: "numeric",
     minute: "numeric",
     second: "numeric",
@@ -266,24 +355,78 @@ function formatDateTimeAccurate(date: Date, timeZone: string, locales: string[],
     hour12,
   }).format(date);
 
-  return formattedDateTime;
+  return `${datePart} ${timePart}`;
 }
 
-export const DateTimeShort = ({ date, timeZone = "UTC", hour12 = true }: DateTimeProps) => {
+type RelativeDateTimeProps = {
+  date: Date | string;
+  timeZone?: string;
+  capitalize?: boolean;
+};
+
+function getRelativeText(date: Date, capitalize = true): string {
+  const text = formatDistanceToNow(date, { addSuffix: true });
+  if (!capitalize) return text;
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+export const RelativeDateTime = ({ date, timeZone, capitalize = true }: RelativeDateTimeProps) => {
   const locales = useLocales();
-  const realDate = typeof date === "string" ? new Date(date) : date;
-  const initialFormattedDateTime = formatDateTimeShort(realDate, timeZone, locales, hour12);
-  const [formattedDateTime, setFormattedDateTime] = useState<string>(initialFormattedDateTime);
+  const userTimeZone = useUserTimeZone();
+
+  const realDate = useMemo(() => (typeof date === "string" ? new Date(date) : date), [date]);
+
+  const [relativeText, setRelativeText] = useState(() => getRelativeText(realDate, capitalize));
 
+  // Every 60s refresh
   useEffect(() => {
-    const resolvedOptions = Intl.DateTimeFormat().resolvedOptions();
-    setFormattedDateTime(formatDateTimeShort(realDate, resolvedOptions.timeZone, locales, hour12));
-  }, [locales, realDate, hour12]);
+    const interval = setInterval(() => {
+      setRelativeText(getRelativeText(realDate, capitalize));
+    }, 60_000);
+    return () => clearInterval(interval);
+  }, [realDate, capitalize]);
 
-  return <Fragment>{formattedDateTime.replace(/\s/g, String.fromCharCode(32))}</Fragment>;
+  // On first render
+  useEffect(() => {
+    setRelativeText(getRelativeText(realDate, capitalize));
+  }, [realDate, capitalize]);
+
+  return (
+    <SimpleTooltip
+      button={<span suppressHydrationWarning>{relativeText}</span>}
+      content={
+        <TooltipContent
+          realDate={realDate}
+          timeZone={timeZone}
+          localTimeZone={userTimeZone}
+          locales={locales}
+        />
+      }
+      side="right"
+      asChild={true}
+    />
+  );
 };
 
-function formatDateTimeShort(date: Date, timeZone: string, locales: string[], hour12: boolean = true): string {
+export const DateTimeShort = ({ date, hour12 = true }: DateTimeProps) => {
+  const locales = useLocales();
+  const userTimeZone = useUserTimeZone();
+  const realDate = typeof date === "string" ? new Date(date) : date;
+  const formattedDateTime = formatDateTimeShort(realDate, userTimeZone, locales, hour12);
+
+  return (
+    <span suppressHydrationWarning>
+      {formattedDateTime.replace(/\s/g, String.fromCharCode(32))}
+    </span>
+  );
+};
+
+function formatDateTimeShort(
+  date: Date,
+  timeZone: string,
+  locales: string[],
+  hour12: boolean = true
+): string {
   const formattedDateTime = new Intl.DateTimeFormat(locales, {
     hour: "numeric",
     minute: "numeric",
@@ -310,14 +453,17 @@ function DateTimeTooltipContent({
   isoDateTime,
   icon,
 }: DateTimeTooltipContentProps) {
-  const getUtcOffset = () => {
-    if (title !== "Local") return "";
-    const offset = -new Date().getTimezoneOffset();
-    const sign = offset >= 0 ? "+" : "-";
-    const hours = Math.abs(Math.floor(offset / 60));
-    const minutes = Math.abs(offset % 60);
-    return `(UTC ${sign}${hours}${minutes ? `:${minutes.toString().padStart(2, "0")}` : ""})`;
-  };
+  const getUtcOffset = useMemo(
+    () => () => {
+      if (title !== "Local") return "";
+      const offset = -new Date().getTimezoneOffset();
+      const sign = offset >= 0 ? "+" : "-";
+      const hours = Math.abs(Math.floor(offset / 60));
+      const minutes = Math.abs(offset % 60);
+      return `(UTC ${sign}${hours}${minutes ? `:${minutes.toString().padStart(2, "0")}` : ""})`;
+    },
+    [title]
+  );
 
   return (
     <div className="flex flex-col gap-1">
@@ -353,20 +499,20 @@ function TooltipContent({
         {timeZone && timeZone !== "UTC" && (
           <DateTimeTooltipContent
             title={timeZone}
-            dateTime={formatDateTime(realDate, timeZone, locales, true, true)}
+            dateTime={formatDateTime(realDate, timeZone, locales, true, true, true)}
             isoDateTime={formatDateTimeISO(realDate, timeZone)}
             icon={<GlobeAmericasIcon className="size-4 text-purple-500" />}
           />
         )}
         <DateTimeTooltipContent
           title="UTC"
-          dateTime={formatDateTime(realDate, "UTC", locales, true, true)}
+          dateTime={formatDateTime(realDate, "UTC", locales, true, true, true)}
           isoDateTime={formatDateTimeISO(realDate, "UTC")}
           icon={<GlobeAltIcon className="size-4 text-blue-500" />}
         />
         <DateTimeTooltipContent
           title="Local"
-          dateTime={formatDateTime(realDate, localTimeZone, locales, true, true)}
+          dateTime={formatDateTime(realDate, localTimeZone, locales, true, true, true)}
           isoDateTime={formatDateTimeISO(realDate, localTimeZone)}
           icon={<Laptop className="size-4 text-green-500" />}
         />
diff --git a/apps/webapp/app/components/primitives/DateTimePicker.tsx b/apps/webapp/app/components/primitives/DateTimePicker.tsx
new file mode 100644
index 00000000000..20e62caf0e1
--- /dev/null
+++ b/apps/webapp/app/components/primitives/DateTimePicker.tsx
@@ -0,0 +1,145 @@
+"use client";
+
+import * as React from "react";
+import { ChevronUpDownIcon } from "@heroicons/react/20/solid";
+import { format } from "date-fns";
+import { Calendar } from "./Calendar";
+import { Popover, PopoverContent, PopoverTrigger } from "./Popover";
+import { Button } from "./Buttons";
+import { cn } from "~/utils/cn";
+import { SimpleTooltip } from "./Tooltip";
+import { XIcon } from "lucide-react";
+
+type DateTimePickerProps = {
+  label: string;
+  value?: Date;
+  onChange?: (date: Date | undefined) => void;
+  showSeconds?: boolean;
+  showNowButton?: boolean;
+  showClearButton?: boolean;
+  showInlineLabel?: boolean;
+  className?: string;
+};
+
+export function DateTimePicker({
+  label,
+  value,
+  onChange,
+  showSeconds = true,
+  showNowButton = false,
+  showClearButton = false,
+  showInlineLabel = false,
+  className,
+}: DateTimePickerProps) {
+  const [open, setOpen] = React.useState(false);
+
+  // Extract time parts from value
+  const hours = value ? value.getHours().toString().padStart(2, "0") : "";
+  const minutes = value ? value.getMinutes().toString().padStart(2, "0") : "";
+  const seconds = value ? value.getSeconds().toString().padStart(2, "0") : "";
+  const timeValue = showSeconds ? `${hours}:${minutes}:${seconds}` : `${hours}:${minutes}`;
+
+  const handleDateSelect = (date: Date | undefined) => {
+    if (date) {
+      // Preserve the time from the current value if it exists
+      if (value) {
+        date.setHours(value.getHours());
+        date.setMinutes(value.getMinutes());
+        date.setSeconds(value.getSeconds());
+      }
+      onChange?.(date);
+    } else {
+      onChange?.(undefined);
+    }
+    setOpen(false);
+  };
+
+  const handleTimeChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const timeString = e.target.value;
+    if (!timeString) return;
+
+    const [h, m, s] = timeString.split(":").map(Number);
+    const newDate = value ? new Date(value) : new Date();
+    newDate.setHours(h || 0);
+    newDate.setMinutes(m || 0);
+    newDate.setSeconds(s || 0);
+    onChange?.(newDate);
+  };
+
+  const handleNowClick = () => {
+    onChange?.(new Date());
+  };
+
+  const handleClearClick = () => {
+    onChange?.(undefined);
+  };
+
+  return (
+    <div className={cn("flex items-center gap-2", className)}>
+      {showInlineLabel && (
+        <span className="w-6 shrink-0 text-right text-xxs text-charcoal-500">{label}</span>
+      )}
+      <Popover open={open} onOpenChange={setOpen}>
+        <PopoverTrigger asChild>
+          <button
+            type="button"
+            className={cn(
+              "flex h-[1.8rem] w-full items-center justify-between gap-2 whitespace-nowrap rounded border border-charcoal-650 bg-charcoal-750 px-2 text-xs tabular-nums transition hover:border-charcoal-600",
+              value ? "text-text-bright" : "text-text-dimmed"
+            )}
+          >
+            {value ? format(value, "yyyy/MM/dd") : "Select date"}
+            <ChevronUpDownIcon className="size-3.5 text-text-dimmed" />
+          </button>
+        </PopoverTrigger>
+        <PopoverContent className="w-auto p-0" align="start">
+          <Calendar
+            mode="single"
+            selected={value}
+            onSelect={handleDateSelect}
+            captionLayout="dropdown"
+          />
+        </PopoverContent>
+      </Popover>
+      <input
+        type="time"
+        step={showSeconds ? "1" : "60"}
+        value={value ? timeValue : ""}
+        onChange={handleTimeChange}
+        className={cn(
+          "h-[1.8rem] rounded border border-charcoal-650 bg-charcoal-750 px-2 text-xs tabular-nums transition hover:border-charcoal-600",
+          value ? "text-text-bright" : "text-text-dimmed",
+          "focus:border-charcoal-500 focus:outline-none",
+          "[&::-webkit-calendar-picker-indicator]:hidden [&::-webkit-calendar-picker-indicator]:appearance-none"
+        )}
+        aria-label={`${label} time`}
+      />
+      {showNowButton && (
+        <Button
+          type="button"
+          variant="secondary/small"
+          className="h-[1.8rem]"
+          onClick={handleNowClick}
+        >
+          Now
+        </Button>
+      )}
+      {showClearButton && (
+        <SimpleTooltip
+          button={
+            <button
+              type="button"
+              className="flex h-[1.8rem] items-center justify-center px-1 text-text-dimmed transition hover:text-text-bright"
+              onClick={handleClearClick}
+            >
+              <XIcon className="size-3.5" />
+            </button>
+          }
+          content="Clear"
+          disableHoverableContent
+          asChild
+        />
+      )}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/Dialog.tsx b/apps/webapp/app/components/primitives/Dialog.tsx
index 7c28193717b..48fc59cfa78 100644
--- a/apps/webapp/app/components/primitives/Dialog.tsx
+++ b/apps/webapp/app/components/primitives/Dialog.tsx
@@ -38,14 +38,18 @@ const DialogContent = React.forwardRef<
   React.ElementRef<typeof DialogPrimitive.Content>,
   React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
     showCloseButton?: boolean;
+    fullscreen?: boolean;
   }
->(({ className, children, showCloseButton = true, ...props }, ref) => (
+>(({ className, children, showCloseButton = true, fullscreen = false, ...props }, ref) => (
   <DialogPortal>
     <DialogOverlay />
     <DialogPrimitive.Content
       ref={ref}
       className={cn(
-        "fixed z-50 grid w-full gap-4 rounded-b-lg border bg-background-dimmed px-4 pb-4 pt-2.5 shadow-lg animate-in data-[state=open]:fade-in-90 data-[state=open]:slide-in-from-bottom-10 sm:max-w-lg sm:rounded-lg sm:zoom-in-90 data-[state=open]:sm:slide-in-from-bottom-0",
+        "fixed z-50 grid gap-4 border bg-background-dimmed shadow-lg animate-in data-[state=open]:fade-in-90",
+        fullscreen
+          ? "inset-6 rounded-lg pt-2.5 px-4 pb-4"
+          : "w-full rounded-b-lg px-4 pb-4 pt-2.5 data-[state=open]:slide-in-from-bottom-10 sm:max-w-lg sm:rounded-lg sm:zoom-in-90 data-[state=open]:sm:slide-in-from-bottom-0",
         className
       )}
       {...props}
@@ -117,4 +121,6 @@ export {
   DialogFooter,
   DialogTitle,
   DialogDescription,
+  DialogPortal,
+  DialogOverlay
 };
diff --git a/apps/webapp/app/components/primitives/FormButtons.tsx b/apps/webapp/app/components/primitives/FormButtons.tsx
index e7d6db75d2d..ab4e07df455 100644
--- a/apps/webapp/app/components/primitives/FormButtons.tsx
+++ b/apps/webapp/app/components/primitives/FormButtons.tsx
@@ -3,10 +3,12 @@ import { cn } from "~/utils/cn";
 export function FormButtons({
   cancelButton,
   confirmButton,
+  defaultAction,
   className,
 }: {
   cancelButton?: React.ReactNode;
-  confirmButton: React.ReactNode;
+  confirmButton?: React.ReactNode;
+  defaultAction?: { name: string; value: string; disabled?: boolean };
   className?: string;
 }) {
   return (
@@ -16,7 +18,18 @@ export function FormButtons({
         className
       )}
     >
-      {cancelButton ? cancelButton : <div />} {confirmButton}
+      {defaultAction && (
+        <button
+          type="submit"
+          name={defaultAction.name}
+          value={defaultAction.value}
+          disabled={defaultAction.disabled}
+          className="hidden"
+          tabIndex={-1}
+          aria-hidden="true"
+        />
+      )}
+      {cancelButton ? cancelButton : <div />} {confirmButton ?? null}
     </div>
   );
 }
diff --git a/apps/webapp/app/components/primitives/LoadingBarDivider.tsx b/apps/webapp/app/components/primitives/LoadingBarDivider.tsx
index ee64ac4fc5a..52b4ff1da9c 100644
--- a/apps/webapp/app/components/primitives/LoadingBarDivider.tsx
+++ b/apps/webapp/app/components/primitives/LoadingBarDivider.tsx
@@ -1,13 +1,15 @@
 import { AnimatePresence, useAnimate, usePresence } from "framer-motion";
 import { useEffect } from "react";
+import { cn } from "~/utils/cn";
 
 type LoadingBarDividerProps = {
   isLoading: boolean;
+  className?: string;
 };
 
-export function LoadingBarDivider({ isLoading }: LoadingBarDividerProps) {
+export function LoadingBarDivider({ isLoading, className }: LoadingBarDividerProps) {
   return (
-    <div className="relative h-px w-full overflow-hidden bg-grid-bright">
+    <div className={cn("relative h-px w-full overflow-hidden bg-grid-bright", className)}>
       <AnimationDivider isLoading={isLoading} />
     </div>
   );
diff --git a/apps/webapp/app/components/primitives/MiddleTruncate.tsx b/apps/webapp/app/components/primitives/MiddleTruncate.tsx
new file mode 100644
index 00000000000..c116205aed9
--- /dev/null
+++ b/apps/webapp/app/components/primitives/MiddleTruncate.tsx
@@ -0,0 +1,168 @@
+import { useRef, useState, useLayoutEffect, useCallback } from "react";
+import { cn } from "~/utils/cn";
+import { SimpleTooltip } from "./Tooltip";
+
+type MiddleTruncateProps = {
+  text: string;
+  className?: string;
+};
+
+/**
+ * A component that truncates text in the middle, showing the beginning and end.
+ * Shows the full text in a tooltip on hover when truncated.
+ *
+ * Example: "namespace:category:subcategory:task-name" becomes "namespace:cat…task-name"
+ */
+export function MiddleTruncate({ text, className }: MiddleTruncateProps) {
+  const containerRef = useRef<HTMLSpanElement>(null);
+  const measureRef = useRef<HTMLSpanElement>(null);
+  const [displayText, setDisplayText] = useState(text);
+  const [isTruncated, setIsTruncated] = useState(false);
+
+  const calculateTruncation = useCallback(() => {
+    const container = containerRef.current;
+    const measure = measureRef.current;
+    if (!container || !measure) return;
+
+    const parent = container.parentElement;
+    if (!parent) return;
+
+    // Get the available width from the parent container
+    const parentStyle = getComputedStyle(parent);
+    const availableWidth =
+      parent.clientWidth -
+      parseFloat(parentStyle.paddingLeft) -
+      parseFloat(parentStyle.paddingRight);
+
+    // Measure full text width
+    measure.textContent = text;
+    const fullTextWidth = measure.offsetWidth;
+
+    // If text fits, no truncation needed
+    if (fullTextWidth <= availableWidth) {
+      setDisplayText(text);
+      setIsTruncated(false);
+      return;
+    }
+
+    // Text needs truncation - find optimal split
+    const ellipsis = "…";
+    measure.textContent = ellipsis;
+    const ellipsisWidth = measure.offsetWidth;
+
+    const targetWidth = availableWidth - ellipsisWidth - 4; // small buffer
+
+    if (targetWidth <= 0) {
+      setDisplayText(ellipsis);
+      setIsTruncated(true);
+      return;
+    }
+
+    // Incrementally find the optimal character counts
+    let startChars = 0;
+    let endChars = 0;
+
+    // Alternate adding characters from start and end
+    while (startChars + endChars < text.length) {
+      // Try adding to start
+      const testStart = text.slice(0, startChars + 1);
+      const testEnd = endChars > 0 ? text.slice(-endChars) : "";
+      measure.textContent = testStart + ellipsis + testEnd;
+
+      if (measure.offsetWidth > targetWidth) break;
+      startChars++;
+
+      if (startChars + endChars >= text.length) break;
+
+      // Try adding to end
+      const newTestEnd = text.slice(-(endChars + 1));
+      measure.textContent = text.slice(0, startChars) + ellipsis + newTestEnd;
+
+      if (measure.offsetWidth > targetWidth) break;
+      endChars++;
+    }
+
+    // Ensure minimum characters on each side for readability
+    const minChars = 4;
+    const prevStartChars = startChars;
+    const prevEndChars = endChars;
+
+    if (startChars < minChars && text.length > minChars * 2 + 1) {
+      startChars = minChars;
+    }
+    if (endChars < minChars && text.length > minChars * 2 + 1) {
+      endChars = minChars;
+    }
+
+    // Re-measure after enforcing minChars to prevent overflow
+    if (startChars !== prevStartChars || endChars !== prevEndChars) {
+      measure.textContent = text.slice(0, startChars) + ellipsis + text.slice(-endChars);
+      if (measure.offsetWidth > targetWidth) {
+        // Revert to previous values if minChars enforcement causes overflow
+        startChars = prevStartChars;
+        endChars = prevEndChars;
+      }
+    }
+
+    // If combined chars would exceed text length, show full text
+    if (startChars + endChars >= text.length) {
+      setDisplayText(text);
+      setIsTruncated(false);
+      return;
+    }
+
+    const result = text.slice(0, startChars) + ellipsis + text.slice(-endChars);
+    setDisplayText(result);
+    setIsTruncated(true);
+  }, [text]);
+
+  useLayoutEffect(() => {
+    calculateTruncation();
+
+    // Recalculate on resize (guard for jsdom/older browsers)
+    if (typeof ResizeObserver === "undefined") {
+      return;
+    }
+
+    const resizeObserver = new ResizeObserver(() => {
+      calculateTruncation();
+    });
+
+    const container = containerRef.current;
+    if (container?.parentElement) {
+      resizeObserver.observe(container.parentElement);
+    }
+
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [calculateTruncation]);
+
+  const content = (
+    <span
+      ref={containerRef}
+      className={cn("block", isTruncated && "min-w-[360px]", className)}
+    >
+      {/* Hidden span for measuring text width */}
+      <span
+        ref={measureRef}
+        className="invisible absolute whitespace-nowrap"
+        aria-hidden="true"
+      />
+      {displayText}
+    </span>
+  );
+
+  if (isTruncated) {
+    return (
+      <SimpleTooltip
+        button={content}
+        content={<span className="max-w-xs break-all font-mono text-xs">{text}</span>}
+        side="top"
+        asChild
+      />
+    );
+  }
+
+  return content;
+}
diff --git a/apps/webapp/app/components/primitives/Popover.tsx b/apps/webapp/app/components/primitives/Popover.tsx
index 7bdf9e902e7..623adbc4bb9 100644
--- a/apps/webapp/app/components/primitives/Popover.tsx
+++ b/apps/webapp/app/components/primitives/Popover.tsx
@@ -65,6 +65,11 @@ const PopoverMenuItem = React.forwardRef<
     className?: string;
     onClick?: React.MouseEventHandler;
     disabled?: boolean;
+    openInNewTab?: boolean;
+    name?: string;
+    value?: string;
+    type?: React.ComponentProps<"button">["type"];
+    danger?: boolean;
   }
 >(
   (
@@ -78,18 +83,27 @@ const PopoverMenuItem = React.forwardRef<
       className,
       onClick,
       disabled,
+      openInNewTab = false,
+      name,
+      value,
+      type,
+      danger = false,
     },
     ref
   ) => {
     const contentProps = {
       variant: variant.variant,
       LeadingIcon: icon,
-      leadingIconClassName,
+      leadingIconClassName: danger
+        ? cn(leadingIconClassName, "transition-colors group-hover/button:text-error")
+        : leadingIconClassName,
       fullWidth: true,
       textAlignLeft: true,
       TrailingIcon: isSelected ? CheckIcon : undefined,
       className: cn(
-        "group-hover:bg-charcoal-700",
+        danger
+          ? "transition-colors group-hover/button:bg-error/10 group-hover/button:text-error [&_span]:transition-colors [&_span]:group-hover/button:text-error"
+          : "group-hover:bg-charcoal-700",
         isSelected ? "bg-charcoal-750 group-hover:bg-charcoal-600/50" : undefined,
         className
       ),
@@ -102,6 +116,8 @@ const PopoverMenuItem = React.forwardRef<
           ref={ref as React.Ref<HTMLAnchorElement>}
           className={cn("group/button focus-custom", contentProps.fullWidth ? "w-full" : "")}
           onClick={onClick as any}
+          target={openInNewTab ? "_blank" : undefined}
+          rel={openInNewTab ? "noopener noreferrer" : undefined}
         >
           <ButtonContent {...contentProps}>{title}</ButtonContent>
         </Link>
@@ -110,7 +126,6 @@ const PopoverMenuItem = React.forwardRef<
 
     return (
       <button
-        type="button"
         ref={ref as React.Ref<HTMLButtonElement>}
         onClick={onClick}
         disabled={disabled}
@@ -118,6 +133,9 @@ const PopoverMenuItem = React.forwardRef<
           "group/button outline-none focus-custom",
           contentProps.fullWidth ? "w-full" : ""
         )}
+        name={name}
+        value={value}
+        type={type ?? "button"}
       >
         <ButtonContent {...contentProps}>{title}</ButtonContent>
       </button>
@@ -150,10 +168,12 @@ function PopoverSideMenuTrigger({
   children,
   className,
   shortcut,
+  hideShortcutKey = false,
   ...props
 }: {
   isOpen?: boolean;
   shortcut?: useShortcutKeys.ShortcutDefinition;
+  hideShortcutKey?: boolean;
 } & React.ComponentPropsWithoutRef<typeof PopoverTrigger>) {
   const ref = React.useRef<HTMLButtonElement>(null);
   useShortcutKeys.useShortcutKeys({
@@ -172,68 +192,117 @@ function PopoverSideMenuTrigger({
       {...props}
       ref={ref}
       className={cn(
-        "flex h-[1.8rem] shrink-0 select-none items-center gap-x-1.5 rounded-sm bg-transparent px-[0.4rem] text-center font-sans text-2sm font-normal text-text-bright transition duration-150 focus-custom hover:bg-charcoal-750",
-        shortcut ? "justify-between" : "",
+        "flex h-[1.8rem] shrink-0 select-none items-center rounded-sm bg-transparent pl-[0.4rem] pr-2.5 text-center font-sans text-2sm font-normal text-text-bright transition duration-150 focus-custom hover:bg-charcoal-750",
+        shortcut && !hideShortcutKey ? "justify-between gap-x-1.5" : "",
         className
       )}
     >
       {children}
-      {shortcut && (
-        <ShortcutKey className={cn("size-4 flex-none")} shortcut={shortcut} variant={"small"} />
+      {shortcut && !hideShortcutKey && (
+        <ShortcutKey className="size-4 flex-none" shortcut={shortcut} variant={"small"} />
       )}
     </PopoverTrigger>
   );
 }
 
+const popoverArrowTriggerVariants = {
+  minimal: {
+    trigger: "text-text-dimmed hover:bg-charcoal-700 hover:text-text-bright",
+    text: "group-hover:text-text-bright",
+    icon: "text-text-dimmed group-hover:text-text-bright",
+  },
+  primary: {
+    trigger:
+      "bg-indigo-600 border border-indigo-500 text-text-bright hover:bg-indigo-500 hover:border-indigo-400 disabled:opacity-50 disabled:pointer-events-none",
+    text: "text-text-bright hover:text-white",
+    icon: "text-text-bright",
+  },
+  secondary: {
+    trigger:
+      "bg-secondary border border-charcoal-600 text-text-bright hover:bg-charcoal-600 hover:border-charcoal-550 disabled:opacity-60 disabled:pointer-events-none",
+    text: "text-text-bright",
+    icon: "text-text-bright",
+  },
+  tertiary: {
+    trigger: "bg-tertiary text-text-bright hover:bg-charcoal-600",
+    text: "text-text-bright",
+    icon: "text-text-bright",
+  },
+} as const;
+
+type PopoverArrowTriggerVariant = keyof typeof popoverArrowTriggerVariants;
+
 function PopoverArrowTrigger({
   isOpen,
   children,
   fullWidth = false,
   overflowHidden = false,
+  variant = "minimal",
   className,
   ...props
 }: {
   isOpen?: boolean;
   fullWidth?: boolean;
   overflowHidden?: boolean;
+  variant?: PopoverArrowTriggerVariant;
 } & React.ComponentPropsWithoutRef<typeof PopoverTrigger>) {
+  const variantStyles = popoverArrowTriggerVariants[variant];
+
   return (
     <PopoverTrigger
       {...props}
       className={cn(
-        "group flex h-6 items-center gap-1 rounded pl-2 pr-1 text-text-dimmed transition focus-custom hover:bg-charcoal-700 hover:text-text-bright",
+        "group flex h-6 items-center gap-1 rounded pl-2 pr-1 transition focus-custom",
+        variantStyles.trigger,
         fullWidth && "w-full justify-between",
         className
       )}
     >
       <Paragraph
         variant="extra-small"
-        className={cn(
-          "flex transition group-hover:text-text-bright",
-          overflowHidden && "overflow-hidden"
-        )}
+        className={cn("flex transition", variantStyles.text, overflowHidden && "overflow-hidden")}
       >
         {children}
       </Paragraph>
-      <DropdownIcon className="size-4 min-w-4 text-text-dimmed transition group-hover:text-text-bright" />
+      <DropdownIcon className={cn("size-4 min-w-4 transition", variantStyles.icon)} />
     </PopoverTrigger>
   );
 }
 
+const popoverVerticalEllipseVariants = {
+  minimal: {
+    trigger: "size-6 rounded-[3px] text-text-dimmed hover:bg-tertiary hover:text-text-bright",
+    icon: "size-5",
+  },
+  secondary: {
+    trigger:
+      "size-6 rounded border border-charcoal-600 bg-secondary text-text-bright hover:bg-charcoal-600 hover:border-charcoal-550",
+    icon: "size-4",
+  },
+} as const;
+
+type PopoverVerticalEllipseVariant = keyof typeof popoverVerticalEllipseVariants;
+
 function PopoverVerticalEllipseTrigger({
   isOpen,
+  variant = "minimal",
   className,
   ...props
-}: { isOpen?: boolean } & React.ComponentPropsWithoutRef<typeof PopoverTrigger>) {
+}: {
+  isOpen?: boolean;
+  variant?: PopoverVerticalEllipseVariant;
+} & React.ComponentPropsWithoutRef<typeof PopoverTrigger>) {
+  const styles = popoverVerticalEllipseVariants[variant];
   return (
     <PopoverTrigger
       {...props}
       className={cn(
-        "group flex items-center justify-end gap-1 rounded-[3px] p-0.5 text-text-dimmed transition focus-custom hover:bg-tertiary hover:text-text-bright",
+        "group flex items-center justify-center transition focus-custom",
+        styles.trigger,
         className
       )}
     >
-      <EllipsisVerticalIcon className={cn("size-5 transition group-hover:text-text-bright")} />
+      <EllipsisVerticalIcon className={cn(styles.icon, "transition")} />
     </PopoverTrigger>
   );
 }
@@ -249,3 +318,5 @@ export {
   PopoverTrigger,
   PopoverVerticalEllipseTrigger,
 };
+
+export type { PopoverArrowTriggerVariant };
diff --git a/apps/webapp/app/components/primitives/Resizable.tsx b/apps/webapp/app/components/primitives/Resizable.tsx
index 22fb38d358a..2efaae4258e 100644
--- a/apps/webapp/app/components/primitives/Resizable.tsx
+++ b/apps/webapp/app/components/primitives/Resizable.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import React from "react";
+import React, { useRef } from "react";
 import { PanelGroup, Panel, PanelResizer } from "react-window-splitter";
 import { cn } from "~/utils/cn";
 
@@ -10,7 +10,6 @@ const ResizablePanelGroup = ({ className, ...props }: React.ComponentProps<typeo
       "flex w-full overflow-hidden data-[panel-group-direction=vertical]:flex-col",
       className
     )}
-    autosaveStrategy={props.autosaveId ? "cookie" : undefined}
     {...props}
   />
 );
@@ -25,24 +24,75 @@ const ResizableHandle = ({
   withHandle?: boolean;
 }) => (
   <PanelResizer
+    onMouseDown={(e: React.MouseEvent) => {
+      e.preventDefault();
+    }}
     className={cn(
-      "group relative flex w-0.75 items-center justify-center focus-custom after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 hover:w-0.75 [&[data-panel-group-direction=vertical]>div]:rotate-90",
+      "group relative flex items-center justify-center focus-custom",
+      // Horizontal size
+      "w-0.75",
+      // Vertical size
+      "data-[handle-orientation=vertical]:h-0.75 data-[handle-orientation=vertical]:w-full",
+      // Normal-state line (::before) — 1px, centered in the 3px handle
+      "before:absolute before:left-px before:top-0 before:h-full before:w-px before:bg-grid-bright",
+      "data-[handle-orientation=vertical]:before:left-0 data-[handle-orientation=vertical]:before:top-px data-[handle-orientation=vertical]:before:h-px data-[handle-orientation=vertical]:before:w-full",
+      // Hit area (::after pseudo) for easier grabbing
+      "after:absolute after:inset-y-0 after:left-1/2 after:w-3 after:-translate-x-1/2",
+      "data-[handle-orientation=vertical]:after:inset-x-0 data-[handle-orientation=vertical]:after:inset-y-auto",
+      "data-[handle-orientation=vertical]:after:left-0 data-[handle-orientation=vertical]:after:top-1/2",
+      "data-[handle-orientation=vertical]:after:h-3 data-[handle-orientation=vertical]:after:w-full",
+      "data-[handle-orientation=vertical]:after:-translate-y-1/2 data-[handle-orientation=vertical]:after:translate-x-0",
       className
     )}
     size="3px"
     {...props}
   >
-    <div className="absolute left-[0.0625rem] top-0 h-full w-px bg-grid-bright transition group-hover:left-0 group-hover:w-0.75 group-hover:bg-lavender-500" />
+    {/* Indigo hover overlay — absolutely positioned on top of everything */}
+    <div className="pointer-events-none absolute left-0 top-0 z-10 h-full w-0.75 bg-indigo-500 opacity-0 transition-opacity group-hover:opacity-100 group-data-[handle-orientation=vertical]:hidden" />
+    <div className="pointer-events-none absolute left-0 top-0 z-10 hidden h-0.75 w-full bg-indigo-500 opacity-0 transition-opacity group-hover:opacity-100 group-data-[handle-orientation=vertical]:block" />
     {withHandle && (
-      <div className="z-10 flex h-5 w-3 flex-col items-center justify-center gap-[0.1875rem] bg-background-dimmed group-hover:hidden">
-        {Array.from({ length: 3 }).map((_, index) => (
-          <div key={index} className="h-[0.1875rem] w-0.75 rounded-full bg-charcoal-600" />
-        ))}
-      </div>
+      <>
+        {/* Horizontal orientation dots (vertical arrangement) */}
+        <div className="relative z-[1] flex h-5 w-0.75 flex-col items-center justify-center gap-[0.1875rem] bg-background-dimmed transition-opacity group-hover:opacity-0 group-data-[handle-orientation=vertical]:hidden">
+          {Array.from({ length: 3 }).map((_, index) => (
+            <div key={index} className="h-[0.1875rem] w-0.75 rounded-full bg-charcoal-600" />
+          ))}
+        </div>
+        {/* Vertical orientation dots (horizontal arrangement) */}
+        <div className="relative z-[1] hidden h-0.75 w-5 flex-row items-center justify-center gap-[0.1875rem] bg-background-dimmed transition-opacity group-hover:opacity-0 group-data-[handle-orientation=vertical]:flex">
+          {Array.from({ length: 3 }).map((_, index) => (
+            <div key={index} className="h-0.75 w-[0.1875rem] rounded-full bg-charcoal-600" />
+          ))}
+        </div>
+      </>
     )}
   </PanelResizer>
 );
 
-export { ResizableHandle, ResizablePanel, ResizablePanelGroup };
+const RESIZABLE_PANEL_ANIMATION = {
+  easing: "ease-in-out" as const,
+  duration: 200,
+};
+
+const COLLAPSIBLE_HANDLE_CLASSNAME = "transition-opacity duration-200";
+
+function collapsibleHandleClassName(show: boolean) {
+  return cn(COLLAPSIBLE_HANDLE_CLASSNAME, !show && "pointer-events-none opacity-0");
+}
+
+function useFrozenValue<T>(value: T | null | undefined): T | null | undefined {
+  const ref = useRef(value);
+  if (value != null) ref.current = value;
+  return ref.current;
+}
+
+export {
+  RESIZABLE_PANEL_ANIMATION,
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  collapsibleHandleClassName,
+  useFrozenValue,
+};
 
 export type ResizableSnapshot = React.ComponentProps<typeof PanelGroup>["snapshot"];
diff --git a/apps/webapp/app/components/primitives/SearchInput.tsx b/apps/webapp/app/components/primitives/SearchInput.tsx
new file mode 100644
index 00000000000..639a4d1a737
--- /dev/null
+++ b/apps/webapp/app/components/primitives/SearchInput.tsx
@@ -0,0 +1,109 @@
+import { MagnifyingGlassIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { motion } from "framer-motion";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Input } from "~/components/primitives/Input";
+import { ShortcutKey } from "~/components/primitives/ShortcutKey";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { cn } from "~/utils/cn";
+
+export type SearchInputProps = {
+  placeholder?: string;
+  /** Additional URL params to reset when searching or clearing (e.g. pagination). Defaults to ["cursor", "direction"]. */
+  resetParams?: string[];
+  autoFocus?: boolean;
+};
+
+export function SearchInput({
+  placeholder = "Search logs…",
+  resetParams = ["cursor", "direction"],
+  autoFocus,
+}: SearchInputProps) {
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const { value, replace, del } = useSearchParams();
+
+  const initialSearch = value("search") ?? "";
+
+  const [text, setText] = useState(initialSearch);
+  const [isFocused, setIsFocused] = useState(false);
+
+  useEffect(() => {
+    const urlSearch = value("search") ?? "";
+    if (urlSearch !== text && !isFocused) {
+      setText(urlSearch);
+    }
+  }, [value, text, isFocused]);
+
+  const handleSubmit = useCallback(() => {
+    const resetValues = Object.fromEntries(resetParams.map((p) => [p, undefined]));
+    if (text.trim()) {
+      replace({ search: text.trim(), ...resetValues });
+    } else {
+      del(["search", ...resetParams]);
+    }
+  }, [text, replace, del, resetParams]);
+
+  const handleClear = useCallback(
+    (e: React.MouseEvent<HTMLButtonElement>) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setText("");
+      del(["search", ...resetParams]);
+    },
+    [del, resetParams]
+  );
+
+  return (
+    <div className="flex items-center gap-1">
+      <motion.div
+        initial={{ width: "auto" }}
+        animate={{ width: isFocused && text.length > 0 ? "24rem" : "auto" }}
+        transition={{
+          type: "spring",
+          stiffness: 300,
+          damping: 30,
+        }}
+        className="relative h-6 min-w-52"
+      >
+        <Input
+          type="text"
+          ref={inputRef}
+          variant="secondary-small"
+          placeholder={placeholder}
+          value={text}
+          onChange={(e) => setText(e.target.value)}
+          fullWidth
+          autoFocus={autoFocus}
+          className={cn("", isFocused && "placeholder:text-text-dimmed/70")}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              handleSubmit();
+            }
+            if (e.key === "Escape") {
+              e.currentTarget.blur();
+            }
+          }}
+          onFocus={() => setIsFocused(true)}
+          onBlur={() => setIsFocused(false)}
+          icon={<MagnifyingGlassIcon className="size-4" />}
+          accessory={
+            text.length > 0 ? (
+              <div className="-mr-1 flex items-center gap-1.5">
+                <ShortcutKey shortcut={{ key: "enter" }} variant="medium" className="border-none" />
+                <button
+                  type="button"
+                  onClick={handleClear}
+                  className="flex size-4.5 items-center justify-center rounded-[2px] border border-text-dimmed/40 text-text-dimmed transition hover:bg-charcoal-600 hover:text-text-bright"
+                  title="Clear search"
+                >
+                  <XMarkIcon className="size-3" />
+                </button>
+              </div>
+            ) : undefined
+          }
+        />
+      </motion.div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/SegmentedControl.tsx b/apps/webapp/app/components/primitives/SegmentedControl.tsx
index 51fc54e5af1..98561e41222 100644
--- a/apps/webapp/app/components/primitives/SegmentedControl.tsx
+++ b/apps/webapp/app/components/primitives/SegmentedControl.tsx
@@ -1,22 +1,70 @@
 import { RadioGroup } from "@headlessui/react";
 import { motion } from "framer-motion";
+import type { ReactNode } from "react";
 import { cn } from "~/utils/cn";
 
-const variants = {
+const sizes = {
+  small: {
+    control: "h-6",
+    option: "px-2 text-xs",
+    container: "gap-x-0.5",
+  },
+  medium: {
+    control: "h-10",
+    option: "px-3 py-[0.13rem] text-sm",
+    container: "p-1 gap-x-0.5",
+  },
+};
+
+const theme = {
   primary: {
     base: "bg-charcoal-700",
     active: "text-text-bright hover:bg-charcoal-750/50",
+    inactive: "text-text-dimmed transition hover:text-text-bright",
+    selected: "absolute inset-0 rounded-[2px] outline outline-3 outline-primary",
   },
   secondary: {
     base: "bg-charcoal-700/50",
-    active: "text-text-bright bg-charcoal-700 rounded-[2px] border border-charcoal-600/50",
+    active: "text-text-bright",
+    inactive: "text-text-dimmed transition hover:text-text-bright",
+    selected: "absolute inset-0 rounded bg-charcoal-700 border border-charcoal-600",
   },
 };
 
-type Variants = keyof typeof variants;
+type Size = keyof typeof sizes;
+type Theme = keyof typeof theme;
+
+type VariantStyle = {
+  base: string;
+  active: string;
+  inactive: string;
+  option: string;
+  container: string;
+  selected: string;
+};
+
+function createVariant(sizeName: Size, themeName: Theme): VariantStyle {
+  return {
+    base: cn(sizes[sizeName].control, theme[themeName].base),
+    active: theme[themeName].active,
+    inactive: theme[themeName].inactive,
+    option: sizes[sizeName].option,
+    container: sizes[sizeName].container,
+    selected: theme[themeName].selected,
+  };
+}
+
+const variants = {
+  "primary/small": createVariant("small", "primary"),
+  "primary/medium": createVariant("medium", "primary"),
+  "secondary/small": createVariant("small", "secondary"),
+  "secondary/medium": createVariant("medium", "secondary"),
+} as const;
+
+type VariantType = keyof typeof variants;
 
 type Options = {
-  label: string;
+  label: ReactNode;
   value: string;
 };
 
@@ -25,7 +73,7 @@ type SegmentedControlProps = {
   value?: string;
   defaultValue?: string;
   options: Options[];
-  variant?: Variants;
+  variant?: VariantType;
   fullWidth?: boolean;
   onChange?: (value: string) => void;
 };
@@ -35,15 +83,18 @@ export default function SegmentedControl({
   value,
   defaultValue,
   options,
-  variant = "secondary",
+  variant = "secondary/medium",
   fullWidth,
   onChange,
 }: SegmentedControlProps) {
+  const variantStyle = variants[variant];
+  const isPrimary = variant.startsWith("primary");
+
   return (
     <div
       className={cn(
-        "flex h-10 rounded text-text-bright",
-        variants[variant].base,
+        "flex rounded text-text-bright",
+        variantStyle.base,
         fullWidth ? "w-full" : "w-fit"
       )}
     >
@@ -58,31 +109,36 @@ export default function SegmentedControl({
         }}
         className="w-full"
       >
-        <div className="flex h-full w-full items-center justify-between gap-x-1 p-1">
+        <div
+          className={cn("flex h-full w-full items-center justify-between", variantStyle.container)}
+        >
           {options.map((option) => (
             <RadioGroup.Option
               key={option.value}
               value={option.value}
-              className={({ active, checked }) =>
+              className={({ checked }) =>
                 cn(
                   "relative flex h-full grow cursor-pointer text-center font-normal focus-custom",
-                  checked
-                    ? variants[variant].active
-                    : "text-text-dimmed transition hover:text-text-bright"
+                  checked ? variantStyle.active : variantStyle.inactive
                 )
               }
             >
               {({ checked }) => (
                 <>
-                  <div className="relative flex h-full w-full items-center justify-between px-3 py-[0.13rem]">
-                    <div className="z-10 flex h-full w-full items-center justify-center text-sm">
+                  <div
+                    className={cn(
+                      "relative flex h-full w-full items-center justify-between",
+                      variantStyle.option
+                    )}
+                  >
+                    <div className="z-10 flex h-full w-full items-center justify-center">
                       <RadioGroup.Label as="p">{option.label}</RadioGroup.Label>
                     </div>
-                    {checked && variant === "primary" && (
+                    {checked && (
                       <motion.div
                         layoutId={`segmented-control-${name}`}
                         transition={{ duration: 0.4, type: "spring" }}
-                        className="absolute inset-0 rounded-[2px] shadow-md outline outline-3 outline-primary"
+                        className={variantStyle.selected}
                       />
                     )}
                   </div>
diff --git a/apps/webapp/app/components/primitives/Select.tsx b/apps/webapp/app/components/primitives/Select.tsx
index 82f750c42ed..d3e4c866891 100644
--- a/apps/webapp/app/components/primitives/Select.tsx
+++ b/apps/webapp/app/components/primitives/Select.tsx
@@ -338,9 +338,9 @@ export function SelectTrigger({
           />
         }
       >
-        <div className="flex grow items-center gap-0.5">
-          {icon && <div className="-ml-1 flex-none">{icon}</div>}
-          <div className="truncate">{content}</div>
+        <div className="flex min-w-0 grow items-center gap-0.5 overflow-hidden">
+          {icon && <div className="flex-none">{icon}</div>}
+          <div className="min-w-0 truncate">{content}</div>
         </div>
         {dropdownIcon === true ? (
           <ChevronDown
@@ -443,21 +443,33 @@ export function SelectList(props: SelectListProps) {
 export interface SelectItemProps extends Ariakit.SelectItemProps {
   icon?: React.ReactNode;
   checkIcon?: React.ReactNode;
+  checkPosition?: "left" | "right";
   shortcut?: ShortcutDefinition;
 }
 
 const selectItemClasses =
   "group cursor-pointer px-1 pt-1 text-2sm text-text-dimmed focus-custom last:pb-1";
 
+import { CheckboxIndicator } from "./CheckboxIndicator";
+
 export function SelectItem({
   icon,
   checkIcon = <Ariakit.SelectItemCheck className="size-8 flex-none text-text-bright" />,
+  checkPosition = "right",
   shortcut,
   ...props
 }: SelectItemProps) {
   const combobox = Ariakit.useComboboxContext();
   const render = combobox ? <Ariakit.ComboboxItem render={props.render} /> : undefined;
   const ref = React.useRef<HTMLDivElement>(null);
+  const select = Ariakit.useSelectContext();
+  const selectValue = select?.useState("value");
+
+  const isChecked = React.useMemo(() => {
+    if (!props.value || selectValue == null) return false;
+    if (Array.isArray(selectValue)) return selectValue.includes(props.value);
+    return selectValue === props.value;
+  }, [selectValue, props.value]);
 
   useShortcutKeys({
     shortcut: shortcut,
@@ -484,10 +496,16 @@ export function SelectItem({
       )}
       ref={ref}
     >
-      <div className="flex h-8 w-full items-center gap-1 rounded-sm px-2 group-data-[active-item=true]:bg-tertiary">
+      <div
+        className={cn(
+          "flex h-8 w-full items-center rounded-sm px-2 group-data-[active-item=true]:bg-tertiary hover:bg-tertiary",
+          checkPosition === "left" ? "gap-2" : "gap-1"
+        )}
+      >
+        {checkPosition === "left" && <CheckboxIndicator checked={isChecked} />}
         {icon}
         <div className="grow truncate">{props.children || props.value}</div>
-        {checkIcon}
+        {checkPosition === "right" && checkIcon}
         {shortcut && (
           <ShortcutKey
             className={cn("size-4 flex-none transition duration-0 group-hover:border-charcoal-600")}
diff --git a/apps/webapp/app/components/primitives/ShortcutKey.tsx b/apps/webapp/app/components/primitives/ShortcutKey.tsx
index 567cf68d612..72d77c70da2 100644
--- a/apps/webapp/app/components/primitives/ShortcutKey.tsx
+++ b/apps/webapp/app/components/primitives/ShortcutKey.tsx
@@ -8,12 +8,15 @@ import { cn } from "~/utils/cn";
 import { useOperatingSystem } from "./OperatingSystemProvider";
 import { KeyboardEnterIcon } from "~/assets/icons/KeyboardEnterIcon";
 
+const small =
+  "justify-center text-[0.6rem] font-mono font-medium min-w-[1rem] min-h-[1rem] rounded-[2px] tabular-nums px-1 ml-1 -mr-0.5 flex items-center gap-x-1 border transition uppercase";
+
 const medium =
   "justify-center min-w-[1.25rem] min-h-[1.25rem] text-[0.65rem] font-mono font-medium rounded-[2px] tabular-nums px-1 ml-1 -mr-0.5 flex items-center gap-x-1.5 border border-dimmed/40 text-text-dimmed group-hover:text-text-bright/80 group-hover:border-dimmed/60 transition uppercase";
 
 export const variants = {
-  small:
-    "justify-center text-[0.6rem] font-mono font-medium min-w-[1rem] min-h-[1rem] rounded-[2px] tabular-nums px-1 ml-1 -mr-0.5 flex items-center gap-x-1 border border-text-dimmed/40 text-text-dimmed group-hover:text-text-bright/80 group-hover:border-text-dimmed/60 transition uppercase",
+  small: cn(small, "border-text-dimmed/40 text-text-dimmed group-hover:text-text-bright/80 group-hover:border-text-dimmed/60"),
+  "small/bright": cn(small, "bg-charcoal-750 text-text-bright border-charcoal-650"),
   medium: cn(medium, "group-hover:border-charcoal-550"),
   "medium/bright": cn(medium, "bg-charcoal-750 text-text-bright border-charcoal-650"),
 };
@@ -54,10 +57,10 @@ export function ShortcutKey({ shortcut, variant, className }: ShortcutKeyProps)
   );
 }
 
-function keyString(key: string, isMac: boolean, variant: "small" | "medium" | "medium/bright") {
+function keyString(key: string, isMac: boolean, variant: ShortcutKeyVariant) {
   key = key.toLowerCase();
 
-  const className = variant === "small" ? "w-2.5 h-4" : "w-2.5 h-4.5";
+  const className = variant.startsWith("small") ? "w-2.5 h-4" : "w-2.5 h-4.5";
 
   switch (key) {
     case "enter":
@@ -86,9 +89,9 @@ function keyString(key: string, isMac: boolean, variant: "small" | "medium" | "m
 function modifierString(
   modifier: Modifier,
   isMac: boolean,
-  variant: "small" | "medium" | "medium/bright"
+  variant: ShortcutKeyVariant
 ): string | JSX.Element {
-  const className = variant === "small" ? "w-2.5 h-4" : "w-3.5 h-5";
+  const className = variant.startsWith("small") ? "w-2.5 h-4" : "w-3.5 h-5";
 
   switch (modifier) {
     case "alt":
diff --git a/apps/webapp/app/components/primitives/Table.tsx b/apps/webapp/app/components/primitives/Table.tsx
index a51c78cc823..1a30bc82b8a 100644
--- a/apps/webapp/app/components/primitives/Table.tsx
+++ b/apps/webapp/app/components/primitives/Table.tsx
@@ -1,23 +1,54 @@
 import { ChevronRightIcon } from "@heroicons/react/24/solid";
 import { Link } from "@remix-run/react";
-import React, { type ReactNode, forwardRef, useState, useContext, createContext } from "react";
+import { ClipboardCheckIcon, ClipboardIcon } from "lucide-react";
+import React, { type ReactNode, createContext, forwardRef, useContext, useState } from "react";
+import { useCopy } from "~/hooks/useCopy";
 import { cn } from "~/utils/cn";
 import { Popover, PopoverContent, PopoverVerticalEllipseTrigger } from "./Popover";
-import { InfoIconTooltip } from "./Tooltip";
+import { InfoIconTooltip, SimpleTooltip } from "./Tooltip";
 
 const variants = {
   bright: {
     header: "bg-background-bright",
+    headerCell: "px-3 py-2.5 pb-3 text-sm",
     cell: "group-hover/table-row:bg-charcoal-750 group-has-[[tabindex='0']:focus]/table-row:bg-charcoal-750",
+    cellSize: "px-3 py-3",
+    cellText: "text-xs group-hover/table-row:text-text-bright",
     stickyCell: "bg-background-bright group-hover/table-row:bg-charcoal-750",
     menuButton:
       "bg-background-bright group-hover/table-row:bg-charcoal-750 group-hover/table-row:ring-charcoal-600/70 group-has-[[tabindex='0']:focus]/table-row:bg-charcoal-750",
     menuButtonDivider: "group-hover/table-row:border-charcoal-600/70",
     rowSelected: "bg-charcoal-750 group-hover/table-row:bg-charcoal-750",
   },
+  "bright/no-hover": {
+    header: "bg-transparent",
+    headerCell: "px-3 py-2.5 pb-3 text-sm",
+    cell: "group-hover/table-row:bg-transparent",
+    cellSize: "px-3 py-3",
+    cellText: "text-xs",
+    stickyCell: "bg-background-bright",
+    menuButton: "bg-background-bright",
+    menuButtonDivider: "",
+    rowSelected: "bg-charcoal-750",
+  },
   dimmed: {
     header: "bg-background-dimmed",
+    headerCell: "px-3 py-2.5 pb-3 text-sm",
     cell: "group-hover/table-row:bg-charcoal-800 group-has-[[tabindex='0']:focus]/table-row:bg-background-bright",
+    cellSize: "px-3 py-3",
+    cellText: "text-xs group-hover/table-row:text-text-bright",
+    stickyCell: "group-hover/table-row:bg-charcoal-800",
+    menuButton:
+      "bg-background-dimmed group-hover/table-row:bg-charcoal-800 group-hover/table-row:ring-grid-bright group-has-[[tabindex='0']:focus]/table-row:bg-background-bright",
+    menuButtonDivider: "group-hover/table-row:border-grid-bright",
+    rowSelected: "bg-charcoal-750 group-hover/table-row:bg-charcoal-750",
+  },
+  "compact/mono": {
+    header: "bg-background-dimmed",
+    headerCell: "px-2 py-1.5 text-sm",
+    cell: "group-hover/table-row:bg-charcoal-800 group-has-[[tabindex='0']:focus]/table-row:bg-background-bright",
+    cellSize: "px-2 py-1.5",
+    cellText: "text-xs font-mono group-hover/table-row:text-text-bright",
     stickyCell: "group-hover/table-row:bg-charcoal-800",
     menuButton:
       "bg-background-dimmed group-hover/table-row:bg-charcoal-800 group-hover/table-row:ring-grid-bright group-has-[[tabindex='0']:focus]/table-row:bg-background-bright",
@@ -33,18 +64,30 @@ type TableProps = {
   className?: string;
   children: ReactNode;
   fullWidth?: boolean;
+  showTopBorder?: boolean;
 };
 
 // Add TableContext
 const TableContext = createContext<{ variant: TableVariant }>({ variant: "dimmed" });
 
 export const Table = forwardRef<HTMLTableElement, TableProps & { variant?: TableVariant }>(
-  ({ className, containerClassName, children, fullWidth, variant = "dimmed" }, ref) => {
+  (
+    {
+      className,
+      containerClassName,
+      children,
+      fullWidth,
+      variant = "dimmed",
+      showTopBorder = true,
+    },
+    ref
+  ) => {
     return (
       <TableContext.Provider value={{ variant }}>
         <div
           className={cn(
-            "overflow-x-auto whitespace-nowrap border-t scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+            "overflow-x-auto whitespace-nowrap scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+            showTopBorder && "border-t",
             containerClassName,
             fullWidth && "w-full"
           )}
@@ -70,7 +113,7 @@ export const TableHeader = forwardRef<HTMLTableSectionElement, TableHeaderProps>
       <thead
         ref={ref}
         className={cn(
-          "sticky top-0 z-10 after:absolute after:bottom-0 after:left-0 after:right-0 after:h-px after:bg-grid-bright",
+          "safari-only sticky top-0 z-10 after:absolute after:bottom-0 after:left-0 after:right-0 after:h-px after:bg-grid-bright supports-[(-webkit-hyphens:none)]:after:content-none",
           variants[variant].header,
           className
         )}
@@ -96,7 +139,7 @@ export const TableBody = forwardRef<HTMLTableSectionElement, TableBodyProps>(
   }
 );
 
-type TableRowProps = {
+type TableRowProps = JSX.IntrinsicElements["tr"] & {
   className?: string;
   children: ReactNode;
   disabled?: boolean;
@@ -104,11 +147,12 @@ type TableRowProps = {
 };
 
 export const TableRow = forwardRef<HTMLTableRowElement, TableRowProps>(
-  ({ className, disabled, isSelected, children }, ref) => {
+  ({ className, disabled, isSelected, children, ...props }, ref) => {
     const { variant } = useContext(TableContext);
     return (
       <tr
         ref={ref}
+        {...props}
         className={cn(
           "group/table-row relative w-full outline-none after:absolute after:bottom-0 after:left-3 after:right-0 after:h-px after:bg-grid-dimmed",
           isSelected && variants[variant].rowSelected,
@@ -132,10 +176,23 @@ type TableCellBasicProps = {
 type TableHeaderCellProps = TableCellBasicProps & {
   hiddenLabel?: boolean;
   tooltip?: ReactNode;
+  disableTooltipHoverableContent?: boolean;
 };
 
 export const TableHeaderCell = forwardRef<HTMLTableCellElement, TableHeaderCellProps>(
-  ({ className, alignment = "left", children, colSpan, hiddenLabel = false, tooltip }, ref) => {
+  (
+    {
+      className,
+      alignment = "left",
+      children,
+      colSpan,
+      hiddenLabel = false,
+      tooltip,
+      disableTooltipHoverableContent = false,
+    },
+    ref
+  ) => {
+    const { variant } = useContext(TableContext);
     let alignmentClassName = "text-left";
     switch (alignment) {
       case "center":
@@ -146,17 +203,22 @@ export const TableHeaderCell = forwardRef<HTMLTableCellElement, TableHeaderCellP
         break;
     }
 
+    const [isHovered, setIsHovered] = useState(false);
+
     return (
       <th
         ref={ref}
         scope="col"
         className={cn(
-          "px-3 py-2.5 pb-3 align-middle text-sm font-medium text-text-bright",
+          "align-middle font-medium text-text-bright",
+          variants[variant].headerCell,
           alignmentClassName,
           className
         )}
         colSpan={colSpan}
         tabIndex={-1}
+        onMouseEnter={() => setIsHovered(true)}
+        onMouseLeave={() => setIsHovered(false)}
       >
         {hiddenLabel ? (
           <span className="sr-only">{children}</span>
@@ -168,7 +230,12 @@ export const TableHeaderCell = forwardRef<HTMLTableCellElement, TableHeaderCellP
             })}
           >
             {children}
-            <InfoIconTooltip content={tooltip} contentClassName="normal-case tracking-normal" />
+            <InfoIconTooltip
+              content={tooltip}
+              contentClassName="normal-case tracking-normal"
+              enabled={isHovered}
+              disableHoverableContent={disableTooltipHoverableContent}
+            />
           </div>
         ) : (
           children
@@ -188,6 +255,7 @@ type TableCellProps = TableCellBasicProps & {
   isSelected?: boolean;
   isTabbableCell?: boolean;
   children?: ReactNode;
+  style?: React.CSSProperties;
 };
 
 export const TableCell = forwardRef<HTMLTableCellElement, TableCellProps>(
@@ -204,6 +272,7 @@ export const TableCell = forwardRef<HTMLTableCellElement, TableCellProps>(
       isSticky = false,
       isSelected,
       isTabbableCell = false,
+      style,
     },
     ref
   ) => {
@@ -217,23 +286,28 @@ export const TableCell = forwardRef<HTMLTableCellElement, TableCellProps>(
         break;
     }
 
+    const { variant } = useContext(TableContext);
     const flexClasses = cn(
-      "flex w-full whitespace-nowrap px-3 py-3 items-center text-xs text-text-dimmed",
+      "flex w-full whitespace-nowrap items-center text-text-dimmed",
+      variants[variant].cellSize,
+      variants[variant].cellText,
       alignment === "left"
         ? "justify-start text-left"
         : alignment === "center"
         ? "justify-center text-center"
         : "justify-end text-right"
     );
-    const { variant } = useContext(TableContext);
 
     return (
       <td
         ref={ref}
         className={cn(
-          "text-xs text-charcoal-400 has-[[tabindex='0']:focus]:before:absolute has-[[tabindex='0']:focus]:before:-top-px has-[[tabindex='0']:focus]:before:left-0 has-[[tabindex='0']:focus]:before:h-px has-[[tabindex='0']:focus]:before:w-3 has-[[tabindex='0']:focus]:before:bg-grid-dimmed has-[[tabindex='0']:focus]:after:absolute has-[[tabindex='0']:focus]:after:bottom-0 has-[[tabindex='0']:focus]:after:left-0 has-[[tabindex='0']:focus]:after:right-0 has-[[tabindex='0']:focus]:after:h-px has-[[tabindex='0']:focus]:after:bg-grid-dimmed",
+          "safari-only text-xs text-charcoal-400 has-[[tabindex='0']:focus]:before:absolute has-[[tabindex='0']:focus]:before:-top-px has-[[tabindex='0']:focus]:before:left-0 has-[[tabindex='0']:focus]:before:h-px has-[[tabindex='0']:focus]:before:w-3 has-[[tabindex='0']:focus]:before:bg-grid-dimmed has-[[tabindex='0']:focus]:after:absolute has-[[tabindex='0']:focus]:after:bottom-0 has-[[tabindex='0']:focus]:after:left-0 has-[[tabindex='0']:focus]:after:right-0 has-[[tabindex='0']:focus]:after:h-px has-[[tabindex='0']:focus]:after:bg-grid-dimmed",
+          variants[variant].cellText,
           variants[variant].cell,
-          to || onClick || hasAction ? "cursor-pointer" : "cursor-default px-3 py-3 align-middle",
+          to || onClick || hasAction
+            ? "cursor-pointer"
+            : cn("cursor-default align-middle", variants[variant].cellSize),
           !to && !onClick && alignmentClassName,
           isSticky &&
             "[&:has(.group-hover/table-row:block)]:w-auto sticky right-0 bg-background-dimmed",
@@ -244,6 +318,7 @@ export const TableCell = forwardRef<HTMLTableCellElement, TableCellProps>(
           className
         )}
         colSpan={colSpan}
+        style={style}
       >
         {to ? (
           <Link
@@ -269,6 +344,60 @@ export const TableCell = forwardRef<HTMLTableCellElement, TableCellProps>(
   }
 );
 
+type CopyableTableCellProps = TableCellProps & {
+  value: string;
+};
+
+export const CopyableTableCell = forwardRef<HTMLTableCellElement, CopyableTableCellProps>(
+  ({ value, children, className, ...props }, ref) => {
+    const [isHovered, setIsHovered] = useState(false);
+    const { copy, copied } = useCopy(value);
+
+    return (
+      <TableCell ref={ref} className={className} {...props}>
+        <div
+          className="relative flex items-center"
+          onMouseEnter={() => setIsHovered(true)}
+          onMouseLeave={() => setIsHovered(false)}
+        >
+          {children}
+          {isHovered && (
+            <span
+              onClick={(e) => {
+                e.stopPropagation();
+                e.preventDefault();
+                copy();
+              }}
+              className="absolute -right-2 top-1/2 z-10 flex -translate-y-1/2 cursor-pointer"
+            >
+              <SimpleTooltip
+                button={
+                  <span
+                    className={cn(
+                      "flex size-6 items-center justify-center rounded border border-charcoal-650 bg-charcoal-750",
+                      copied
+                        ? "text-green-500"
+                        : "text-text-dimmed hover:border-charcoal-600 hover:bg-charcoal-700 hover:text-text-bright"
+                    )}
+                  >
+                    {copied ? (
+                      <ClipboardCheckIcon className="size-3.5" />
+                    ) : (
+                      <ClipboardIcon className="size-3.5" />
+                    )}
+                  </span>
+                }
+                content={copied ? "Copied!" : "Copy"}
+                disableHoverableContent
+              />
+            </span>
+          )}
+        </div>
+      </TableCell>
+    );
+  }
+);
+
 export const TableCellChevron = forwardRef<
   HTMLTableCellElement,
   {
@@ -302,7 +431,7 @@ export const TableCellMenu = forwardRef<
     onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
     visibleButtons?: ReactNode;
     hiddenButtons?: ReactNode;
-    popoverContent?: ReactNode;
+    popoverContent?: ReactNode | ((close: () => void) => ReactNode);
     children?: ReactNode;
     isSelected?: boolean;
   }
@@ -322,6 +451,8 @@ export const TableCellMenu = forwardRef<
   ) => {
     const [isOpen, setIsOpen] = useState(false);
     const { variant } = useContext(TableContext);
+    const resolvedContent =
+      typeof popoverContent === "function" ? popoverContent(() => setIsOpen(false)) : popoverContent;
 
     return (
       <TableCell
@@ -357,8 +488,8 @@ export const TableCellMenu = forwardRef<
             {/* Always visible buttons  */}
             {visibleButtons}
             {/* Always visible popover with ellipsis trigger */}
-            {popoverContent && (
-              <Popover onOpenChange={(open) => setIsOpen(open)}>
+            {resolvedContent && (
+              <Popover open={isOpen} onOpenChange={(open) => setIsOpen(open)}>
                 <PopoverVerticalEllipseTrigger
                   isOpen={isOpen}
                   className="duration-0 group-hover/table-row:text-text-bright"
@@ -367,7 +498,11 @@ export const TableCellMenu = forwardRef<
                   className="min-w-[10rem] max-w-[20rem] overflow-y-auto p-0 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
                   align="end"
                 >
-                  <div className="flex flex-col gap-1 p-1">{popoverContent}</div>
+                  {typeof popoverContent === "function" ? (
+                    resolvedContent
+                  ) : (
+                    <div className="flex flex-col gap-1 p-1">{resolvedContent}</div>
+                  )}
                 </PopoverContent>
               </Popover>
             )}
diff --git a/apps/webapp/app/components/primitives/TextArea.tsx b/apps/webapp/app/components/primitives/TextArea.tsx
index f5350a510bc..06dc84622da 100644
--- a/apps/webapp/app/components/primitives/TextArea.tsx
+++ b/apps/webapp/app/components/primitives/TextArea.tsx
@@ -8,7 +8,7 @@ export function TextArea({ className, rows, ...props }: TextAreaProps) {
       {...props}
       rows={rows ?? 6}
       className={cn(
-        "placeholder:text-muted-foreground w-full rounded border border-charcoal-800 bg-charcoal-750 px-3 text-sm text-text-bright transition focus-custom focus-custom file:border-0 file:bg-transparent file:text-base file:font-medium hover:border-charcoal-600 hover:bg-charcoal-650 disabled:cursor-not-allowed disabled:opacity-50",
+        "placeholder:text-muted-foreground w-full rounded border border-charcoal-800 bg-charcoal-750 px-3 text-sm text-text-bright transition focus-custom file:border-0 file:bg-transparent file:text-base file:font-medium hover:border-charcoal-600 hover:bg-charcoal-650 disabled:cursor-not-allowed disabled:opacity-50",
         className
       )}
     />
diff --git a/apps/webapp/app/components/primitives/Toast.tsx b/apps/webapp/app/components/primitives/Toast.tsx
index 5d8b002c49c..175d5ccb604 100644
--- a/apps/webapp/app/components/primitives/Toast.tsx
+++ b/apps/webapp/app/components/primitives/Toast.tsx
@@ -1,7 +1,7 @@
 import { EnvelopeIcon, ExclamationCircleIcon, XMarkIcon } from "@heroicons/react/20/solid";
 import { CheckCircleIcon } from "@heroicons/react/24/solid";
 import { useSearchParams } from "@remix-run/react";
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 import { useTypedLoaderData } from "remix-typedjson";
 import { Toaster, toast } from "sonner";
 import { type ToastMessageAction } from "~/models/message.server";
@@ -43,6 +43,32 @@ export function Toast() {
   return <Toaster />;
 }
 
+export function useToast() {
+  return useMemo(
+    () => ({
+      success(message: string, options?: { title?: string; ephemeral?: boolean }) {
+        const ephemeral = options?.ephemeral ?? true;
+        toast.custom(
+          (t) => (
+            <ToastUI variant="success" message={message} t={t as string} title={options?.title} />
+          ),
+          { duration: ephemeral ? defaultToastDuration : permanentToastDuration }
+        );
+      },
+      error(message: string, options?: { title?: string; ephemeral?: boolean }) {
+        const ephemeral = options?.ephemeral ?? true;
+        toast.custom(
+          (t) => (
+            <ToastUI variant="error" message={message} t={t as string} title={options?.title} />
+          ),
+          { duration: ephemeral ? defaultToastDuration : permanentToastDuration }
+        );
+      },
+    }),
+    []
+  );
+}
+
 export function ToastUI({
   variant,
   message,
@@ -69,21 +95,26 @@ export function ToastUI({
         width: toastWidth,
       }}
     >
-      <div className="flex w-full items-start gap-2 rounded-lg p-3">
+      <div
+        className={cn("flex w-full gap-2 rounded-lg p-3", title ? "items-start" : "items-center")}
+      >
         {variant === "success" ? (
-          <CheckCircleIcon className="mt-1 size-4 min-w-4 text-success" />
+          <CheckCircleIcon className={cn("size-4 min-w-4 text-success", title && "mt-1")} />
         ) : (
-          <ExclamationCircleIcon className="mt-1 size-4 min-w-4 text-error" />
+          <ExclamationCircleIcon className={cn("size-4 min-w-4 text-error", title && "mt-1")} />
         )}
         <div className="flex flex-col">
           {title && <Header2 className="pt-0">{title}</Header2>}
-          <Paragraph variant="small/dimmed" className="pb-1 pt-0.5">
+          <Paragraph
+            variant={title ? "small/dimmed" : "small/bright"}
+            className={title ? "pb-1 pt-0.5" : ""}
+          >
             {message}
           </Paragraph>
           <Action action={action} toastId={t} className="my-2" />
         </div>
         <button
-          className="hover:bg-midnight-800 -mr-1 -mt-1 ms-auto rounded p-2 text-text-dimmed transition hover:text-text-bright"
+          className={cn("-mr-1 ms-auto rounded p-2 text-text-dimmed transition hover:text-text-bright", title && "-mt-1")}
           onClick={() => toast.dismiss(t)}
         >
           <XMarkIcon className="size-4" />
diff --git a/apps/webapp/app/components/primitives/Tooltip.tsx b/apps/webapp/app/components/primitives/Tooltip.tsx
index 5c681927b5d..c03492abcfd 100644
--- a/apps/webapp/app/components/primitives/Tooltip.tsx
+++ b/apps/webapp/app/components/primitives/Tooltip.tsx
@@ -6,7 +6,7 @@ import { cn } from "~/utils/cn";
 const variantClasses = {
   basic:
     "bg-background-bright border border-grid-bright rounded px-3 py-2 text-sm text-text-bright shadow-md fade-in-50",
-  dark: "bg-background-dimmed border border-grid-bright rounded px-3 py-2 text-sm text-text-bright shadow-md fade-in-50"
+  dark: "bg-background-dimmed border border-grid-bright rounded px-3 py-2 text-sm text-text-bright shadow-md fade-in-50",
 };
 
 type Variant = keyof typeof variantClasses;
@@ -85,8 +85,9 @@ function SimpleTooltip({
     <TooltipProvider disableHoverableContent={disableHoverableContent}>
       <Tooltip open={open} onOpenChange={onOpenChange}>
         <TooltipTrigger
+          type="button"
           tabIndex={-1}
-          className={cn("h-fit", buttonClassName)}
+          className={cn(!asChild && "h-fit", buttonClassName)}
           style={buttonStyle}
           asChild={asChild}
         >
@@ -111,20 +112,28 @@ export function InfoIconTooltip({
   buttonClassName,
   contentClassName,
   variant = "basic",
+  disableHoverableContent = false,
+  enabled = true,
 }: {
   content: React.ReactNode;
   buttonClassName?: string;
   contentClassName?: string;
   variant?: Variant;
+  disableHoverableContent?: boolean;
+  enabled?: boolean;
 }) {
+  const icon = (
+    <InformationCircleIcon className={cn("size-3.5 text-text-dimmed flex-0", buttonClassName)} />
+  );
+
+  if (!enabled) return icon;
   return (
     <SimpleTooltip
-      button={
-        <InformationCircleIcon className={cn("size-3.5 text-text-dimmed", buttonClassName)} />
-      }
+      button={icon}
       content={content}
       variant={variant}
       className={contentClassName}
+      disableHoverableContent={disableHoverableContent}
     />
   );
 }
diff --git a/apps/webapp/app/components/primitives/TreeView/TreeView.tsx b/apps/webapp/app/components/primitives/TreeView/TreeView.tsx
index bb9ca4c4629..5f720c24fe9 100644
--- a/apps/webapp/app/components/primitives/TreeView/TreeView.tsx
+++ b/apps/webapp/app/components/primitives/TreeView/TreeView.tsx
@@ -197,6 +197,18 @@ export function useTree<TData, TFilterValue>({
     concreteStateFromInput({ tree, selectedId, collapsedIds, filter })
   );
 
+  //sync external selectedId prop into internal state
+  useEffect(() => {
+    const internalSelectedId = selectedIdFromState(state.nodes);
+    if (selectedId !== internalSelectedId) {
+      if (selectedId === undefined) {
+        dispatch({ type: "DESELECT_ALL_NODES" });
+      } else {
+        dispatch({ type: "SELECT_NODE", payload: { id: selectedId, scrollToNode: false, scrollToNodeFn } });
+      }
+    }
+  }, [selectedId]);
+
   //fire onSelectedIdChanged()
   useEffect(() => {
     const selectedId = selectedIdFromState(state.nodes);
@@ -527,6 +539,7 @@ export function useTree<TData, TFilterValue>({
 /** An actual tree structure with custom data */
 export type Tree<TData> = {
   id: string;
+  runId?: string;
   children?: Tree<TData>[];
   data: TData;
 };
@@ -535,6 +548,7 @@ export type Tree<TData> = {
 export type FlatTreeItem<TData> = {
   id: string;
   parentId?: string | undefined;
+  runId?: string;
   children: string[];
   hasChildren: boolean;
   /** The indentation level, the root is 0 */
@@ -552,6 +566,7 @@ export function flattenTree<TData>(tree: Tree<TData>): FlatTree<TData> {
     flatTree.push({
       id: node.id,
       parentId,
+      runId: node.runId,
       children,
       hasChildren: children.length > 0,
       level,
@@ -571,6 +586,7 @@ export function flattenTree<TData>(tree: Tree<TData>): FlatTree<TData> {
 type FlatTreeWithoutChildren<TData> = {
   id: string;
   parentId: string | undefined;
+  runId?: string;
   data: TData;
 };
 
@@ -580,7 +596,7 @@ export function createTreeFromFlatItems<TData>(
 ): Tree<TData> | undefined {
   // Index items by id
   const indexedItems: { [id: string]: Tree<TData> } = withoutChildren.reduce((acc, item) => {
-    acc[item.id] = { id: item.id, data: item.data, children: [] };
+    acc[item.id] = { id: item.id, runId: item.runId, data: item.data, children: [] };
     return acc;
   }, {} as { [id: string]: Tree<TData> });
 
diff --git a/apps/webapp/app/components/primitives/UnorderedList.tsx b/apps/webapp/app/components/primitives/UnorderedList.tsx
new file mode 100644
index 00000000000..e65dfe6673f
--- /dev/null
+++ b/apps/webapp/app/components/primitives/UnorderedList.tsx
@@ -0,0 +1,129 @@
+import { cn } from "~/utils/cn";
+import { type ParagraphVariant } from "./Paragraph";
+
+const listVariants: Record<
+  ParagraphVariant,
+  { text: string; spacing: string; items: string }
+> = {
+  base: {
+    text: "font-sans text-base font-normal text-text-dimmed",
+    spacing: "mb-3",
+    items: "space-y-1 [&>li]:gap-1.5",
+  },
+  "base/bright": {
+    text: "font-sans text-base font-normal text-text-bright",
+    spacing: "mb-3",
+    items: "space-y-1 [&>li]:gap-1.5",
+  },
+  small: {
+    text: "font-sans text-sm font-normal text-text-dimmed",
+    spacing: "mb-2",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "small/bright": {
+    text: "font-sans text-sm font-normal text-text-bright",
+    spacing: "mb-2",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "small/dimmed": {
+    text: "font-sans text-sm font-normal text-text-dimmed",
+    spacing: "mb-2",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small": {
+    text: "font-sans text-xs font-normal text-text-dimmed",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/bright": {
+    text: "font-sans text-xs font-normal text-text-bright",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/dimmed": {
+    text: "font-sans text-xs font-normal text-text-dimmed",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/dimmed/mono": {
+    text: "font-mono text-xs font-normal text-text-dimmed",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/mono": {
+    text: "font-mono text-xs font-normal text-text-dimmed",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/bright/mono": {
+    text: "font-mono text-xs text-text-bright",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/caps": {
+    text: "font-sans text-xs uppercase tracking-wider font-normal text-text-dimmed",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-small/bright/caps": {
+    text: "font-sans text-xs uppercase tracking-wider font-normal text-text-bright",
+    spacing: "mb-1.5",
+    items: "space-y-0.5 [&>li]:gap-1",
+  },
+  "extra-extra-small": {
+    text: "font-sans text-xxs font-normal text-text-dimmed",
+    spacing: "mb-1",
+    items: "space-y-0.5 [&>li]:gap-0.5",
+  },
+  "extra-extra-small/bright": {
+    text: "font-sans text-xxs font-normal text-text-bright",
+    spacing: "mb-1",
+    items: "space-y-0.5 [&>li]:gap-0.5",
+  },
+  "extra-extra-small/caps": {
+    text: "font-sans text-xxs uppercase tracking-wider font-normal text-text-dimmed",
+    spacing: "mb-1",
+    items: "space-y-0.5 [&>li]:gap-0.5",
+  },
+  "extra-extra-small/bright/caps": {
+    text: "font-sans text-xxs uppercase tracking-wider font-normal text-text-bright",
+    spacing: "mb-1",
+    items: "space-y-0.5 [&>li]:gap-0.5",
+  },
+  "extra-extra-small/dimmed/caps": {
+    text: "font-sans text-xxs uppercase tracking-wider font-normal text-text-dimmed",
+    spacing: "mb-1",
+    items: "space-y-0.5 [&>li]:gap-0.5",
+  },
+};
+
+type UnorderedListProps = {
+  variant?: ParagraphVariant;
+  className?: string;
+  spacing?: boolean;
+  children: React.ReactNode;
+} & React.HTMLAttributes<HTMLUListElement>;
+
+export function UnorderedList({
+  variant = "base",
+  className,
+  spacing = false,
+  children,
+  ...props
+}: UnorderedListProps) {
+  const v = listVariants[variant];
+  return (
+    <ul
+      className={cn(
+        "list-none [&>li]:flex [&>li]:items-baseline [&>li]:before:shrink-0 [&>li]:before:content-['•']",
+        v.text,
+        v.items,
+        spacing && v.spacing,
+        className
+      )}
+      {...props}
+    >
+      {children}
+    </ul>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/BigNumberCard.tsx b/apps/webapp/app/components/primitives/charts/BigNumberCard.tsx
new file mode 100644
index 00000000000..7ea88b3fe96
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/BigNumberCard.tsx
@@ -0,0 +1,191 @@
+import type { ColumnFormatType, OutputColumnMetadata } from "@internal/tsql";
+import { Hash } from "lucide-react";
+import { useMemo } from "react";
+import type {
+  BigNumberAggregationType,
+  BigNumberConfiguration,
+} from "~/components/metrics/QueryWidget";
+import { createValueFormatter } from "~/utils/columnFormat";
+import { AnimatedNumber } from "../AnimatedNumber";
+import { ChartBlankState } from "./ChartBlankState";
+import { Spinner } from "../Spinner";
+
+interface BigNumberCardProps {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+  config: BigNumberConfiguration;
+  isLoading?: boolean;
+}
+
+/**
+ * Extracts numeric values from a specific column across all rows,
+ * optionally sorting them first.
+ */
+function extractColumnValues(
+  rows: Record<string, unknown>[],
+  column: string,
+  sortDirection?: "asc" | "desc"
+): number[] {
+  const values: number[] = [];
+  const sortedRows = sortDirection
+    ? [...rows].sort((a, b) => {
+        const aVal = toNumber(a[column]);
+        const bVal = toNumber(b[column]);
+        return sortDirection === "asc" ? aVal - bVal : bVal - aVal;
+      })
+    : rows;
+
+  for (const row of sortedRows) {
+    const val = row[column];
+    if (typeof val === "number") {
+      values.push(val);
+    } else if (typeof val === "string") {
+      const parsed = parseFloat(val);
+      if (!isNaN(parsed)) {
+        values.push(parsed);
+      }
+    }
+  }
+  return values;
+}
+
+function toNumber(value: unknown): number {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? 0 : parsed;
+  }
+  return 0;
+}
+
+/**
+ * Aggregate an array of numbers using the specified aggregation function
+ */
+function aggregateValues(values: number[], aggregation: BigNumberAggregationType): number {
+  if (values.length === 0) return 0;
+  switch (aggregation) {
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "avg":
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    case "count":
+      return values.length;
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+    case "first":
+      return values[0];
+    case "last":
+      return values[values.length - 1];
+  }
+}
+
+/**
+ * Computes the display value and unit suffix for abbreviated display.
+ * Returns the divided-down number (e.g. 1.5 for 1500) and the suffix (e.g. "K"),
+ * along with the appropriate decimal places for formatting.
+ */
+function abbreviateValue(value: number): {
+  displayValue: number;
+  unitSuffix?: string;
+  decimalPlaces: number;
+} {
+  if (Math.abs(value) >= 1_000_000_000) {
+    const v = value / 1_000_000_000;
+    return { displayValue: v, unitSuffix: "B", decimalPlaces: v % 1 === 0 ? 0 : 1 };
+  }
+  if (Math.abs(value) >= 1_000_000) {
+    const v = value / 1_000_000;
+    return { displayValue: v, unitSuffix: "M", decimalPlaces: v % 1 === 0 ? 0 : 1 };
+  }
+  if (Math.abs(value) >= 1_000) {
+    const v = value / 1_000;
+    return { displayValue: v, unitSuffix: "K", decimalPlaces: v % 1 === 0 ? 0 : 1 };
+  }
+  return { displayValue: value, decimalPlaces: getDecimalPlaces(value) };
+}
+
+/**
+ * Determines decimal places for plain (non-abbreviated) display.
+ */
+function getDecimalPlaces(value: number): number {
+  if (Number.isInteger(value)) return 0;
+  const abs = Math.abs(value);
+  if (abs >= 100) return 0;
+  if (abs >= 10) return 1;
+  if (abs >= 1) return 2;
+  if (abs >= 0.01) return 3;
+  return 4;
+}
+
+export function BigNumberCard({ rows, columns, config, isLoading = false }: BigNumberCardProps) {
+  const { column, aggregation, sortDirection, abbreviate = true, prefix, suffix } = config;
+
+  const result = useMemo(() => {
+    if (rows.length === 0) return null;
+
+    const values = extractColumnValues(rows, column, sortDirection);
+    if (values.length === 0) return null;
+
+    return aggregateValues(values, aggregation);
+  }, [rows, column, aggregation, sortDirection]);
+
+  // Look up column format for format-aware display
+  const columnValueFormatter = useMemo(() => {
+    const columnMeta = columns.find((c) => c.name === column);
+    const formatType = (columnMeta?.format ?? columnMeta?.customRenderType) as
+      | ColumnFormatType
+      | undefined;
+    return createValueFormatter(formatType);
+  }, [columns, column]);
+
+  if (isLoading) {
+    return (
+      <div className="grid h-full place-items-center [container-type:size]">
+        <Spinner className="size-6" />
+      </div>
+    );
+  }
+
+  if (result === null) {
+    return <ChartBlankState icon={Hash} message="No data to display" />;
+  }
+
+  // Use format-aware formatter when available
+  if (columnValueFormatter) {
+    return (
+      <div className="h-full w-full [container-type:size]">
+        <div className="grid h-full w-full place-items-center">
+          <div className="flex items-baseline gap-[0.15em] whitespace-nowrap text-[clamp(24px,12cqw,96px)] font-normal tabular-nums leading-none text-text-bright">
+            {prefix && <span>{prefix}</span>}
+            <span>{columnValueFormatter(result)}</span>
+            {suffix && <span className="text-[0.4em] text-text-dimmed">{suffix}</span>}
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  const { displayValue, unitSuffix, decimalPlaces } = abbreviate
+    ? abbreviateValue(result)
+    : { displayValue: result, unitSuffix: undefined, decimalPlaces: getDecimalPlaces(result) };
+
+  return (
+    <div className="h-full w-full [container-type:size]">
+      <div className="grid h-full w-full place-items-center">
+        <div className="flex items-baseline gap-[0.15em] whitespace-nowrap text-[clamp(24px,12cqw,96px)] font-normal tabular-nums leading-none text-text-bright">
+          {prefix && <span>{prefix}</span>}
+          <AnimatedNumber value={displayValue} decimalPlaces={decimalPlaces} />
+          {(unitSuffix || suffix) && (
+            <span className="text-[0.4em] text-text-dimmed">
+              {unitSuffix}
+              {unitSuffix && suffix ? " " : ""}
+              {suffix}
+            </span>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/Card.tsx b/apps/webapp/app/components/primitives/charts/Card.tsx
new file mode 100644
index 00000000000..f4fb13b51bc
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/Card.tsx
@@ -0,0 +1,41 @@
+import { type ReactNode } from "react";
+import { cn } from "~/utils/cn";
+import { Header3 } from "../Headers";
+
+export const Card = ({ children, className }: { children: ReactNode; className?: string }) => {
+  return (
+    <div
+      className={cn(
+        "flex flex-col rounded-lg border border-grid-bright bg-background-bright pb-1.5 pt-3",
+        className
+      )}
+    >
+      {children}
+    </div>
+  );
+};
+
+const CardHeader = ({ children, draggable }: { children: ReactNode; draggable?: boolean }) => {
+  return (
+    <Header3
+      className={cn(
+        "drag-handle mb-3 flex items-center justify-between gap-2 pl-4 pr-3",
+        draggable && "cursor-grab active:cursor-grabbing"
+      )}
+    >
+      {children}
+    </Header3>
+  );
+};
+
+const CardContent = ({ children, className }: { children: ReactNode; className?: string }) => {
+  return <div className={cn("px-2", className)}>{children}</div>;
+};
+
+const CardAccessory = ({ children }: { children: ReactNode }) => {
+  return <div className="flex items-center gap-2">{children}</div>;
+};
+
+Card.Header = CardHeader;
+Card.Content = CardContent;
+Card.Accessory = CardAccessory;
diff --git a/apps/webapp/app/components/primitives/Chart.tsx b/apps/webapp/app/components/primitives/charts/Chart.tsx
similarity index 57%
rename from apps/webapp/app/components/primitives/Chart.tsx
rename to apps/webapp/app/components/primitives/charts/Chart.tsx
index 1f1fec3bbe3..ffed1a2bc12 100644
--- a/apps/webapp/app/components/primitives/Chart.tsx
+++ b/apps/webapp/app/components/primitives/charts/Chart.tsx
@@ -1,16 +1,18 @@
-"use client";
-
 import * as React from "react";
 import * as RechartsPrimitive from "recharts";
 import { cn } from "~/utils/cn";
+import { AnimatedNumber } from "../AnimatedNumber";
 
 // Format: { THEME_NAME: CSS_SELECTOR }
 const THEMES = { light: "", dark: ".dark" } as const;
 
+export type ChartState = "loading" | "noData" | "invalid" | "loaded" | undefined;
+
 export type ChartConfig = {
   [k in string]: {
     label?: React.ReactNode;
     icon?: React.ComponentType;
+    value?: number;
   } & (
     | { color?: string; theme?: never }
     | { color?: never; theme: Record<keyof typeof THEMES, string> }
@@ -49,15 +51,13 @@ const ChartContainer = React.forwardRef<
         data-chart={chartId}
         ref={ref}
         className={cn(
-          "flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-text-dimmed/50 [&_.recharts-cartesian-grid_line]:stroke-grid-bright/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-grid-dimmed [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-grid-dimmed [&_.recharts-radial-bar-background-sector]:fill-grid-dimmed [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-grid-dimmed [&_.recharts-reference-line-line]:stroke-grid-dimmed [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
+          "[&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border flex aspect-video justify-center text-xs [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
           className
         )}
         {...props}
       >
         <ChartStyle id={chartId} config={config} />
-        <RechartsPrimitive.ResponsiveContainer className="!h-auto">
-          {children}
-        </RechartsPrimitive.ResponsiveContainer>
+        <RechartsPrimitive.ResponsiveContainer>{children}</RechartsPrimitive.ResponsiveContainer>
       </div>
     </ChartContext.Provider>
   );
@@ -65,7 +65,7 @@ const ChartContainer = React.forwardRef<
 ChartContainer.displayName = "Chart";
 
 const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
-  const colorConfig = Object.entries(config).filter(([_, config]) => config.theme || config.color);
+  const colorConfig = Object.entries(config).filter(([, config]) => config.theme || config.color);
 
   if (!colorConfig.length) {
     return null;
@@ -74,8 +74,9 @@ const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
   return (
     <style
       dangerouslySetInnerHTML={{
-        __html: Object.entries(THEMES).map(
-          ([theme, prefix]) => `
+        __html: Object.entries(THEMES)
+          .map(
+            ([theme, prefix]) => `
 ${prefix} [data-chart=${id}] {
 ${colorConfig
   .map(([key, itemConfig]) => {
@@ -85,7 +86,8 @@ ${colorConfig
   .join("\n")}
 }
 `
-        ),
+          )
+          .join("\n"),
       }}
     />
   );
@@ -102,6 +104,8 @@ const ChartTooltipContent = React.forwardRef<
       indicator?: "line" | "dot" | "dashed";
       nameKey?: string;
       labelKey?: string;
+      /** Optional formatter for numeric values (e.g. bytes, duration) */
+      valueFormatter?: (value: number) => string;
     }
 >(
   (
@@ -119,6 +123,7 @@ const ChartTooltipContent = React.forwardRef<
       color,
       nameKey,
       labelKey,
+      valueFormatter,
     },
     ref
   ) => {
@@ -130,7 +135,7 @@ const ChartTooltipContent = React.forwardRef<
       }
 
       const [item] = payload;
-      const key = `${labelKey || item.dataKey || item.name || "value"}`;
+      const key = `${labelKey || item?.dataKey || item?.name || "value"}`;
       const itemConfig = getPayloadConfigFromPayload(config, item, key);
       const value =
         !labelKey && typeof label === "string"
@@ -160,7 +165,7 @@ const ChartTooltipContent = React.forwardRef<
       <div
         ref={ref}
         className={cn(
-          "grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-grid-bright/50 bg-background-dimmed px-2.5 py-1.5 text-xs shadow-xl",
+          "grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-grid-bright bg-background-bright px-2.5 py-1.5 text-xs shadow-xl",
           className
         )}
       >
@@ -175,11 +180,11 @@ const ChartTooltipContent = React.forwardRef<
               <div
                 key={item.dataKey}
                 className={cn(
-                  "flex w-full items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-text-dimmed",
+                  "[&>svg]:text-muted-foreground flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5",
                   indicator === "dot" && "items-center"
                 )}
               >
-                {formatter && item.value && item.name ? (
+                {formatter && item?.value !== undefined && item.name ? (
                   formatter(item.value, item.name, item, index, item.payload)
                 ) : (
                   <>
@@ -209,17 +214,21 @@ const ChartTooltipContent = React.forwardRef<
                     )}
                     <div
                       className={cn(
-                        "flex flex-1 justify-between gap-1.5 leading-none",
+                        "flex flex-1 justify-between leading-none",
                         nestLabel ? "items-end" : "items-center"
                       )}
                     >
                       <div className="grid gap-1.5">
                         {nestLabel ? tooltipLabel : null}
-                        <span className="text-text-dimmed">{itemConfig?.label || item.name}</span>
+                        <span className="text-muted-foreground">
+                          {itemConfig?.label || item.name}
+                        </span>
                       </div>
-                      {item.value && (
-                        <span className="font-mono font-medium tabular-nums text-text-bright">
-                          {item.value.toLocaleString()}
+                      {item.value != null && (
+                        <span className="text-foreground font-mono font-medium tabular-nums">
+                          {valueFormatter && typeof item.value === "number"
+                            ? valueFormatter(item.value)
+                            : item.value.toLocaleString()}
                         </span>
                       )}
                     </div>
@@ -237,6 +246,12 @@ ChartTooltipContent.displayName = "ChartTooltip";
 
 const ChartLegend = RechartsPrimitive.Legend;
 
+type ExtendedLegendPayload = Parameters<
+  NonNullable<RechartsPrimitive.LegendProps["formatter"]>
+>[0] & {
+  payload?: { remainingCount?: number };
+};
+
 const ChartLegendContent = React.forwardRef<
   HTMLDivElement,
   React.ComponentProps<"div"> &
@@ -268,7 +283,7 @@ const ChartLegendContent = React.forwardRef<
           <div
             key={item.value}
             className={cn(
-              "flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-text-dimmed"
+              "[&>svg]:text-muted-foreground flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3"
             )}
           >
             {itemConfig?.icon && !hideIcon ? (
@@ -290,6 +305,125 @@ const ChartLegendContent = React.forwardRef<
 });
 ChartLegendContent.displayName = "ChartLegend";
 
+const ChartLegendContentRows = React.forwardRef<
+  HTMLDivElement,
+  React.ComponentProps<"div"> &
+    Omit<Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign">, "payload"> & {
+      payload?: ExtendedLegendPayload[];
+      hideIcon?: boolean;
+      nameKey?: string;
+      onMouseEnter?: (e: any) => void;
+      onMouseLeave?: (e: any) => void;
+      data?: Record<string, number>;
+      activeKey?: string | null;
+      renderViewMore?: (remainingCount: number) => React.ReactNode;
+    }
+>(
+  (
+    {
+      className,
+      hideIcon = false,
+      payload,
+      verticalAlign = "bottom",
+      nameKey,
+      onMouseEnter,
+      onMouseLeave,
+      data,
+      activeKey,
+      renderViewMore,
+    },
+    ref
+  ) => {
+    const { config } = useChart();
+
+    if (!payload?.length) {
+      return null;
+    }
+
+    return (
+      <div
+        ref={ref}
+        className={cn(
+          "flex flex-col items-start justify-between",
+          verticalAlign === "top" ? "pb-4" : "pt-4",
+          className
+        )}
+      >
+        {payload.map((item) => {
+          const key = `${nameKey || item.dataKey || "value"}`;
+          const itemConfig = getPayloadConfigFromPayload(config, item, key);
+
+          // Handle view more button
+          if (item.dataKey === "view-more" && renderViewMore && item.payload?.remainingCount) {
+            return renderViewMore(item.payload.remainingCount);
+          }
+
+          const total = item.dataKey && data ? data[item.dataKey as string] : undefined;
+
+          return (
+            <div
+              key={key}
+              className={cn(
+                "relative flex w-full items-center justify-between gap-2 rounded px-2 py-1 transition",
+                total === 0 && "opacity-50"
+              )}
+              onMouseEnter={() => onMouseEnter?.(item)}
+              onMouseLeave={() => onMouseLeave?.(item)}
+            >
+              {activeKey === item.dataKey && item.color && (
+                <div
+                  className="absolute inset-0 rounded opacity-10"
+                  style={{ backgroundColor: item.color }}
+                />
+              )}
+              <div className="relative flex w-full items-center justify-between gap-2">
+                <div
+                  className={cn(
+                    "flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-text-dimmed"
+                  )}
+                >
+                  {itemConfig?.icon && !hideIcon ? (
+                    <itemConfig.icon />
+                  ) : (
+                    item.color && (
+                      <div
+                        className="h-3 w-1 shrink-0 rounded-[2px]"
+                        style={{
+                          backgroundColor: item.color,
+                        }}
+                      />
+                    )
+                  )}
+                  {itemConfig?.label && (
+                    <span
+                      className={
+                        activeKey === item.dataKey ? "text-text-bright" : "text-text-dimmed"
+                      }
+                    >
+                      {itemConfig.label}
+                    </span>
+                  )}
+                </div>
+                {total !== undefined && (
+                  <span
+                    className={cn(
+                      "tabular-nums",
+                      activeKey === item.dataKey ? "text-text-bright" : "text-text-dimmed"
+                    )}
+                  >
+                    <AnimatedNumber value={total} duration={0.25} />
+                  </span>
+                )}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    );
+  }
+);
+ChartLegendContentRows.displayName = "ChartLegendRows";
+
 // Helper to extract item config from a payload.
 function getPayloadConfigFromPayload(config: ChartConfig, payload: unknown, key: string) {
   if (typeof payload !== "object" || payload === null) {
@@ -322,5 +456,6 @@ export {
   ChartTooltipContent,
   ChartLegend,
   ChartLegendContent,
+  ChartLegendContentRows,
   ChartStyle,
 };
diff --git a/apps/webapp/app/components/primitives/charts/ChartBar.tsx b/apps/webapp/app/components/primitives/charts/ChartBar.tsx
new file mode 100644
index 00000000000..0b560747297
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartBar.tsx
@@ -0,0 +1,260 @@
+import React, { useCallback } from "react";
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  ReferenceArea,
+  ReferenceLine,
+  XAxis,
+  YAxis,
+  type XAxisProps,
+  type YAxisProps,
+} from "recharts";
+import { ChartTooltip, ChartTooltipContent } from "~/components/primitives/charts/Chart";
+import { useChartContext } from "./ChartContext";
+import { ChartBarInvalid, ChartBarLoading, ChartBarNoData } from "./ChartLoading";
+import { useHasNoData } from "./ChartRoot";
+import { ZoomTooltip, useZoomHandlers } from "./ChartZoom";
+
+//TODO: fix the first and last bars in a stack not having rounded corners
+
+type ReferenceLineProps = {
+  value: number;
+  label: string;
+};
+
+// ============================================================================
+// COMPOUND COMPONENT API
+// ============================================================================
+
+export type ChartBarRendererProps = {
+  /** Stack ID for stacked bar charts */
+  stackId?: string;
+  /** Custom X-axis props to merge with defaults */
+  xAxisProps?: Partial<XAxisProps>;
+  /** Custom Y-axis props to merge with defaults */
+  yAxisProps?: Partial<YAxisProps>;
+  /** Reference line (horizontal) */
+  referenceLine?: ReferenceLineProps;
+  /** Custom tooltip label formatter */
+  tooltipLabelFormatter?: (label: string, payload: any[]) => string;
+  /** Optional formatter for numeric tooltip values (e.g. bytes, duration) */
+  tooltipValueFormatter?: (value: number) => string;
+  /** Width injected by ResponsiveContainer */
+  width?: number;
+  /** Height injected by ResponsiveContainer */
+  height?: number;
+};
+
+/**
+ * Bar chart renderer for the compound component system.
+ * Must be used within a Chart.Root.
+ *
+ * @example
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day">
+ *   <Chart.Bar stackId="a" />
+ *   <Chart.Legend />
+ * </Chart.Root>
+ * ```
+ */
+export function ChartBarRenderer({
+  stackId,
+  xAxisProps: xAxisPropsProp,
+  yAxisProps: yAxisPropsProp,
+  referenceLine,
+  tooltipLabelFormatter,
+  tooltipValueFormatter,
+  width,
+  height,
+}: ChartBarRendererProps) {
+  const { config, data, dataKey, dataKeys, visibleSeries, state, highlight, setActivePayload, zoom, showLegend } = useChartContext();
+  const hasNoData = useHasNoData();
+  const zoomHandlers = useZoomHandlers();
+  const enableZoom = zoom !== null;
+
+  const handleBarClick = useCallback(
+    (barData: any, e: React.MouseEvent) => {
+      if (!enableZoom || !zoom) return;
+      e.stopPropagation();
+
+      if (!zoom.isSelecting) {
+        zoom.toggleInspectionLine(barData[dataKey]);
+      }
+    },
+    [enableZoom, zoom, dataKey]
+  );
+
+  // Handle mouse leave to also reset highlight
+  const handleMouseLeave = useCallback(() => {
+    zoomHandlers.onMouseLeave?.();
+    highlight.reset();
+  }, [zoomHandlers, highlight]);
+
+  // Render loading/error states
+  if (state === "loading") {
+    return <ChartBarLoading />;
+  } else if (state === "noData" || hasNoData) {
+    return <ChartBarNoData />;
+  } else if (state === "invalid") {
+    return <ChartBarInvalid />;
+  }
+
+  // Get the x-axis ticks based on tooltip state
+  // Only hide middle ticks when zoom is enabled (to make room for zoom instructions)
+  const xAxisTicks =
+    enableZoom && highlight.tooltipActive && data.length > 2
+      ? [data[0]?.[dataKey], data[data.length - 1]?.[dataKey]]
+      : undefined;
+
+  return (
+    <BarChart
+      data={data}
+      width={width}
+      height={height}
+      barCategoryGap={1}
+      onMouseDown={zoomHandlers.onMouseDown}
+      onMouseMove={(e: any) => {
+        zoomHandlers.onMouseMove?.(e);
+        if (e?.activePayload?.length) {
+          setActivePayload(e.activePayload, e.activeTooltipIndex);
+          highlight.setTooltipActive(true);
+        } else {
+          highlight.setTooltipActive(false);
+        }
+      }}
+      onMouseUp={zoomHandlers.onMouseUp}
+      onClick={zoomHandlers.onClick}
+      onMouseLeave={handleMouseLeave}
+    >
+      <CartesianGrid vertical={false} stroke="#272A2E" />
+      <XAxis
+        dataKey={dataKey}
+        tickLine={false}
+        tickMargin={10}
+        axisLine={false}
+        ticks={xAxisTicks}
+        interval="preserveStartEnd"
+        tick={{
+          fill: "#878C99",
+          fontSize: 11,
+          style: { fontVariantNumeric: "tabular-nums" },
+        }}
+        {...xAxisPropsProp}
+      />
+      <YAxis
+        axisLine={false}
+        tickLine={false}
+        tickMargin={8}
+        tick={{
+          fill: "#878C99",
+          fontSize: 11,
+          style: { fontVariantNumeric: "tabular-nums" },
+        }}
+        domain={["auto", (dataMax: number) => dataMax * 1.15]}
+        {...yAxisPropsProp}
+      />
+      {/* When legend is shown below the chart, render tooltip with cursor only (no content popup).
+          Otherwise render the full tooltip with zoom instructions. */}
+      <ChartTooltip
+        cursor={{ fill: "rgba(255, 255, 255, 0.06)" }}
+        content={
+          showLegend ? (
+            () => null
+          ) : tooltipLabelFormatter ? (
+            <ChartTooltipContent valueFormatter={tooltipValueFormatter} />
+          ) : (
+            <ZoomTooltip
+              isSelecting={zoom?.isSelecting}
+              refAreaLeft={zoom?.refAreaLeft}
+              refAreaRight={zoom?.refAreaRight}
+              invalidSelection={zoom?.invalidSelection}
+            />
+          )
+        }
+        labelFormatter={tooltipLabelFormatter}
+        allowEscapeViewBox={{ x: false, y: true }}
+        animationDuration={0}
+      />
+
+      {/* Zoom selection area - rendered before bars to appear behind them */}
+      {enableZoom && zoom?.refAreaLeft !== null && zoom?.refAreaRight !== null && (
+        <ReferenceArea
+          x1={zoom.refAreaLeft}
+          x2={zoom.refAreaRight}
+          strokeOpacity={0.4}
+          fill="#3B82F6"
+          fillOpacity={0.3}
+        />
+      )}
+
+      {visibleSeries.map((key, index, array) => {
+        const dimmed =
+          !zoom?.isSelecting &&
+          highlight.activeBarKey !== null &&
+          highlight.activeBarKey !== key;
+
+        return (
+          <Bar
+            key={key}
+            dataKey={key}
+            stackId={stackId}
+            fill={config[key]?.color}
+            radius={
+              [
+                index === array.length - 1 ? 2 : 0,
+                index === array.length - 1 ? 2 : 0,
+                index === 0 ? 2 : 0,
+                index === 0 ? 2 : 0,
+              ] as [number, number, number, number]
+            }
+            activeBar={false}
+            fillOpacity={dimmed ? 0.2 : 1}
+            onClick={(data, index, e) => handleBarClick(data, e)}
+            onMouseEnter={(entry, index) => {
+              if (entry.tooltipPayload?.[0]) {
+                const { dataKey: hoveredKey } = entry.tooltipPayload[0];
+                highlight.setHoveredBar(hoveredKey, index);
+              }
+            }}
+            onMouseLeave={highlight.reset}
+            isAnimationActive={false}
+          />
+        );
+      })}
+
+      {/* Horizontal reference line */}
+      {referenceLine && (
+        <ReferenceLine
+          y={referenceLine.value}
+          label={{
+            position: "top",
+            value: referenceLine.label,
+            fill: "#878C99",
+            fontSize: 11,
+          }}
+          isFront={true}
+          stroke="#3B3E45"
+          strokeDasharray="4 4"
+          className="pointer-events-none"
+        />
+      )}
+
+      {/* Zoom inspection line - rendered after bars to appear on top */}
+      {enableZoom && zoom?.inspectionLine && (
+        <ReferenceLine
+          x={zoom.inspectionLine}
+          stroke="#D7D9DD"
+          strokeWidth={2}
+          isFront={true}
+          onClick={(e: any) => {
+            e?.stopPropagation?.();
+            zoom.clearInspectionLine();
+          }}
+        />
+      )}
+
+      {/* Note: Legend is now rendered by ChartRoot outside the chart container */}
+    </BarChart>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartBlankState.tsx b/apps/webapp/app/components/primitives/charts/ChartBlankState.tsx
new file mode 100644
index 00000000000..9a093254e00
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartBlankState.tsx
@@ -0,0 +1,23 @@
+import { cn } from "~/utils/cn";
+import { Paragraph } from "../Paragraph";
+
+export function ChartBlankState({
+  icon: Icon,
+  message,
+  className,
+}: {
+  icon?: React.ComponentType<{ className?: string }>;
+  message: string;
+  className?: string;
+}) {
+  return (
+    <div className={cn("flex h-full w-full items-center justify-center", className)}>
+      <div className="-mt-3 flex flex-col items-center gap-2">
+        {Icon && <Icon className="size-12 text-charcoal-700" />}
+        <Paragraph variant="small" className="text-text-dimmed/70">
+          {message}
+        </Paragraph>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartCompound.tsx b/apps/webapp/app/components/primitives/charts/ChartCompound.tsx
new file mode 100644
index 00000000000..bbd78fc1b32
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartCompound.tsx
@@ -0,0 +1,106 @@
+/**
+ * Compound Chart Component System
+ *
+ * This module exports a unified Chart compound component that can render
+ * different chart types (bar, line, etc.) with optional features like
+ * zoom and legends.
+ *
+ * Note: Due to recharts' component hierarchy requirements, the Legend must be
+ * rendered inside the chart component (BarChart, LineChart). Use the showLegend
+ * prop on Chart.Bar or Chart.Line instead of Chart.Legend as a sibling.
+ *
+ * @example Simple bar chart with legend
+ * ```tsx
+ * import { Chart } from "~/components/primitives/charts/ChartCompound";
+ *
+ * <Chart.Root config={config} data={data} dataKey="day">
+ *   <Chart.Bar stackId="a" showLegend maxLegendItems={5} />
+ * </Chart.Root>
+ * ```
+ *
+ * @example Line chart
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day">
+ *   <Chart.Line lineType="step" showLegend />
+ * </Chart.Root>
+ * ```
+ *
+ * @example Bar chart with zoom (callback-based)
+ * ```tsx
+ * function MyChart() {
+ *   const handleZoomChange = (range: ZoomRange) => {
+ *     // Fetch new data based on range, update state
+ *   };
+ *
+ *   return (
+ *     <Chart.Root
+ *       config={config}
+ *       data={data}
+ *       dataKey="day"
+ *       enableZoom
+ *       onZoomChange={handleZoomChange}
+ *     >
+ *       <Chart.Bar stackId="a" showLegend />
+ *     </Chart.Root>
+ *   );
+ * }
+ * ```
+ *
+ * @example Dashboard with synced charts (using DateRangeContext)
+ * ```tsx
+ * <DateRangeProvider defaultStartDate={start} defaultEndDate={end}>
+ *   <DashboardControls />
+ *
+ *   <Chart.Root config={config1} data={data1} dataKey="day" enableZoom onZoomChange={handleZoom1}>
+ *     <Chart.Bar showLegend />
+ *   </Chart.Root>
+ *
+ *   <Chart.Root config={config2} data={data2} dataKey="day" enableZoom onZoomChange={handleZoom2}>
+ *     <Chart.Line showLegend />
+ *   </Chart.Root>
+ * </DateRangeProvider>
+ * ```
+ */
+
+import { ChartRoot } from "./ChartRoot";
+import { ChartBarRenderer } from "./ChartBar";
+import { ChartLineRenderer } from "./ChartLine";
+import { ChartLegendCompound } from "./ChartLegendCompound";
+import { ChartZoom } from "./ChartZoom";
+
+// Re-export types
+export type { ChartConfig, ChartState } from "./Chart";
+export type { ZoomRange } from "./hooks/useZoomSelection";
+export type { ChartRootProps } from "./ChartRoot";
+export type { ChartBarRendererProps } from "./ChartBar";
+export type { ChartLineRendererProps } from "./ChartLine";
+export type { ChartLegendCompoundProps } from "./ChartLegendCompound";
+export type { ChartZoomProps } from "./ChartZoom";
+
+/**
+ * Chart compound component for building flexible, composable charts.
+ *
+ * Components:
+ * - `Chart.Root` - Main wrapper that provides context
+ * - `Chart.Bar` - Bar chart renderer (use showLegend prop for legend)
+ * - `Chart.Line` - Line/area chart renderer (use showLegend prop for legend)
+ * - `Chart.Zoom` - Optional zoom overlay (rendered internally when enableZoom is set)
+ *
+ * Note: Chart.Legend is exported for advanced use cases but should typically
+ * be enabled via the showLegend prop on Chart.Bar or Chart.Line.
+ */
+export const Chart = {
+  Root: ChartRoot,
+  Bar: ChartBarRenderer,
+  Line: ChartLineRenderer,
+  Legend: ChartLegendCompound,
+  Zoom: ChartZoom,
+};
+
+// Also export individual components for direct imports
+export { ChartRoot, ChartBarRenderer, ChartLineRenderer, ChartLegendCompound, ChartZoom };
+
+// Re-export context hook for advanced usage
+export { useChartContext } from "./ChartContext";
+export { useHasNoData, useSeriesTotal } from "./ChartRoot";
+export { useZoomHandlers, ZoomTooltip } from "./ChartZoom";
diff --git a/apps/webapp/app/components/primitives/charts/ChartContext.tsx b/apps/webapp/app/components/primitives/charts/ChartContext.tsx
new file mode 100644
index 00000000000..b26d431dd92
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartContext.tsx
@@ -0,0 +1,166 @@
+import React, { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+import type { ChartConfig, ChartState } from "./Chart";
+import { useHighlightState, type UseHighlightStateReturn } from "./hooks/useHighlightState";
+import {
+  useZoomSelection,
+  type UseZoomSelectionReturn,
+  type ZoomRange,
+} from "./hooks/useZoomSelection";
+
+/** Function to format the x-axis label for display */
+export type LabelFormatter = (value: string) => string;
+
+export type ChartContextValue = {
+  // Core data
+  config: ChartConfig;
+  data: any[];
+  dataKey: string;
+  /** Computed series keys (all config keys except dataKey) */
+  dataKeys: string[];
+  /** Subset of dataKeys actually rendered as SVG elements (defaults to dataKeys) */
+  visibleSeries: string[];
+
+  // Display state
+  state?: ChartState;
+
+  // Formatters
+  /** Function to format the x-axis label (used in legend, tooltips, etc.) */
+  labelFormatter?: LabelFormatter;
+
+  // Highlight state (does NOT include activePayload — see PayloadContext)
+  highlight: UseHighlightStateReturn;
+
+  /** Update the active payload for the legend. Pass tooltipIndex to skip redundant updates. */
+  setActivePayload: (payload: any[] | null, tooltipIndex?: number | null) => void;
+
+  // Zoom state (only present when zoom is enabled)
+  zoom: UseZoomSelectionReturn | null;
+
+  // Zoom callback (only present when zoom is enabled)
+  onZoomChange?: (range: ZoomRange) => void;
+
+  // Whether the compound legend is shown (disables tooltip when true)
+  showLegend: boolean;
+};
+
+const ChartCompoundContext = createContext<ChartContextValue | null>(null);
+
+/**
+ * Separate context for activePayload so that frequent payload updates
+ * only re-render the legend, not the entire chart (bars, lines, etc.).
+ */
+const PayloadContext = createContext<any[] | null>(null);
+
+export function useChartContext(): ChartContextValue {
+  const context = useContext(ChartCompoundContext);
+  if (!context) {
+    throw new Error("useChartContext must be used within a Chart.Root component");
+  }
+  return context;
+}
+
+/** Read the active payload (only re-renders when payload changes). */
+export function useActivePayload(): any[] | null {
+  return useContext(PayloadContext);
+}
+
+export type ChartProviderProps = {
+  config: ChartConfig;
+  data: any[];
+  dataKey: string;
+  /** Series keys to render (if not provided, derived from config keys) */
+  series?: string[];
+  /** Subset of series to render as SVG elements on the chart (legend still shows all series) */
+  visibleSeries?: string[];
+  state?: ChartState;
+  /** Function to format the x-axis label (used in legend, tooltips, etc.) */
+  labelFormatter?: LabelFormatter;
+  /** Enable zoom functionality */
+  enableZoom?: boolean;
+  /** Callback when zoom range changes */
+  onZoomChange?: (range: ZoomRange) => void;
+  /** Whether the compound legend is shown (disables tooltip when true) */
+  showLegend?: boolean;
+  children: React.ReactNode;
+};
+
+export function ChartProvider({
+  config,
+  data,
+  dataKey,
+  series,
+  visibleSeries: visibleSeriesProp,
+  state,
+  labelFormatter,
+  enableZoom = false,
+  onZoomChange,
+  showLegend = false,
+  children,
+}: ChartProviderProps) {
+  const highlight = useHighlightState();
+  const zoomState = useZoomSelection();
+
+  // activePayload lives in its own state + context so updates don't re-render bars
+  const [activePayload, setActivePayloadRaw] = useState<any[] | null>(null);
+  const activeTooltipIndexRef = useRef<number | null>(null);
+
+  const setActivePayload = useCallback(
+    (payload: any[] | null, tooltipIndex?: number | null) => {
+      const idx = tooltipIndex ?? null;
+      if (idx !== null && idx === activeTooltipIndexRef.current) {
+        return;
+      }
+      activeTooltipIndexRef.current = idx;
+      setActivePayloadRaw(payload);
+    },
+    []
+  );
+
+  // Reset the tooltip index ref when highlight resets (mouse leaves chart)
+  const originalReset = highlight.reset;
+  const resetWithPayload = useCallback(() => {
+    activeTooltipIndexRef.current = null;
+    setActivePayloadRaw(null);
+    originalReset();
+  }, [originalReset]);
+
+  const highlightWithReset = useMemo(
+    () => ({ ...highlight, reset: resetWithPayload }),
+    [highlight, resetWithPayload]
+  );
+
+  // Compute series keys (use provided series or derive from config)
+  const dataKeys = useMemo(
+    () => series ?? Object.keys(config).filter((k) => k !== dataKey),
+    [series, config, dataKey]
+  );
+
+  const visibleSeries = useMemo(
+    () => visibleSeriesProp ?? dataKeys,
+    [visibleSeriesProp, dataKeys]
+  );
+
+  const value = useMemo<ChartContextValue>(
+    () => ({
+      config,
+      data,
+      dataKey,
+      dataKeys,
+      visibleSeries,
+      state,
+      labelFormatter,
+      highlight: highlightWithReset,
+      setActivePayload,
+      zoom: enableZoom ? zoomState : null,
+      onZoomChange: enableZoom ? onZoomChange : undefined,
+      showLegend,
+    }),
+    [config, data, dataKey, dataKeys, visibleSeries, state, labelFormatter, highlightWithReset, setActivePayload, zoomState, enableZoom, onZoomChange, showLegend]
+  );
+
+  return (
+    <ChartCompoundContext.Provider value={value}>
+      <PayloadContext.Provider value={activePayload}>{children}</PayloadContext.Provider>
+    </ChartCompoundContext.Provider>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartLegendCompound.tsx b/apps/webapp/app/components/primitives/charts/ChartLegendCompound.tsx
new file mode 100644
index 00000000000..7fe77d97e81
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartLegendCompound.tsx
@@ -0,0 +1,367 @@
+import React, { useMemo } from "react";
+import type { AggregationType } from "~/components/metrics/QueryWidget";
+import { useActivePayload, useChartContext } from "./ChartContext";
+import { useSeriesTotal } from "./ChartRoot";
+import { aggregateValues } from "./aggregation";
+import { cn } from "~/utils/cn";
+import { AnimatedNumber } from "../AnimatedNumber";
+import { SimpleTooltip } from "../Tooltip";
+
+const aggregationLabels: Record<AggregationType, string> = {
+  sum: "Sum",
+  avg: "Average",
+  count: "Count",
+  min: "Min",
+  max: "Max",
+};
+
+export type ChartLegendCompoundProps = {
+  /** Maximum number of legend items to show before collapsing */
+  maxItems?: number;
+  /** Hide the legend entirely (useful for conditional rendering) */
+  hidden?: boolean;
+  /** Additional className */
+  className?: string;
+  /** Label for the total row (derived from aggregation when not provided) */
+  totalLabel?: string;
+  /** Aggregation method – controls the header label and how totals are computed */
+  aggregation?: AggregationType;
+  /** Optional formatter for numeric values (e.g. bytes, duration) */
+  valueFormatter?: (value: number) => string;
+  /** Callback when "View all" button is clicked */
+  onViewAllLegendItems?: () => void;
+  /** When true, constrains legend to max 50% height with scrolling */
+  scrollable?: boolean;
+};
+
+/**
+ * Legend component for the chart compound system.
+ * Renders as a permanent element below the chart (not inside recharts).
+ * Automatically connects to chart context for highlighting.
+ *
+ * @example Using via Chart.Root showLegend prop (recommended)
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day" showLegend maxLegendItems={5}>
+ *   <Chart.Bar />
+ * </Chart.Root>
+ * ```
+ */
+export function ChartLegendCompound({
+  maxItems = Infinity,
+  hidden = false,
+  className,
+  totalLabel,
+  aggregation,
+  valueFormatter,
+  onViewAllLegendItems,
+  scrollable = false,
+}: ChartLegendCompoundProps) {
+  const { config, dataKey, dataKeys, highlight, labelFormatter } = useChartContext();
+  const activePayload = useActivePayload();
+  const totals = useSeriesTotal(aggregation);
+
+  // Derive the effective label from the aggregation type when no explicit label is provided
+  const effectiveTotalLabel = totalLabel ?? (aggregation ? aggregationLabels[aggregation] : "Total");
+
+  // Calculate grand total by aggregating across all per-series values
+  const grandTotal = useMemo(() => {
+    const values = dataKeys.map((key) => totals[key] || 0);
+    if (!aggregation) {
+      // Default: sum
+      return values.reduce((a, b) => a + b, 0);
+    }
+    return aggregateValues(values, aggregation);
+  }, [totals, dataKeys, aggregation]);
+
+  // Calculate current total based on hover state (null when hovering a gap-filled point)
+  const currentTotal = useMemo((): number | null => {
+    if (!activePayload?.length) return grandTotal;
+
+    // Use the full data row so the total covers ALL dataKeys, not just visibleSeries
+    const dataRow = activePayload[0]?.payload;
+    if (!dataRow) return grandTotal;
+
+    const rawValues = dataKeys.map((key) => dataRow[key]);
+
+    const values = rawValues
+      .filter((v): v is number => v != null)
+      .map((v) => Number(v) || 0);
+
+    // All null → gap-filled point, return null to show dash
+    if (values.length === 0) return null;
+
+    if (!aggregation) {
+      return values.reduce((a, b) => a + b, 0);
+    }
+    return aggregateValues(values, aggregation);
+  }, [activePayload, grandTotal, dataKeys, aggregation]);
+
+  // Get the label for the total row - x-axis value when hovering, effectiveTotalLabel otherwise
+  const currentTotalLabel = useMemo(() => {
+    if (!activePayload?.length) return effectiveTotalLabel;
+
+    // Get the x-axis label from the payload's original data
+    const firstPayloadItem = activePayload[0];
+    const xAxisValue = firstPayloadItem?.payload?.[dataKey];
+
+    if (xAxisValue === undefined) return effectiveTotalLabel;
+
+    // Apply the formatter if provided, otherwise just stringify the value
+    const stringValue = String(xAxisValue);
+    return labelFormatter ? labelFormatter(stringValue) : stringValue;
+  }, [activePayload, dataKey, effectiveTotalLabel, labelFormatter]);
+
+  // Get current data for the legend based on hover state (values may be null for gap-filled points)
+  const currentData = useMemo((): Record<string, number | null> => {
+    if (!activePayload?.length) return totals;
+
+    // Use the full data row so ALL dataKeys are resolved from the hovered point,
+    // not just the visibleSeries present in activePayload.
+    const dataRow = activePayload[0]?.payload;
+    if (!dataRow) return totals;
+
+    const hoverData: Record<string, number | null> = {};
+    for (const key of dataKeys) {
+      const value = dataRow[key];
+      if (value !== undefined) {
+        hoverData[key] = value != null ? Number(value) || 0 : null;
+      }
+    }
+
+    return {
+      ...totals,
+      ...hoverData,
+    };
+  }, [activePayload, totals, dataKeys]);
+
+  // Prepare legend items with capped display
+  const legendItems = useMemo(() => {
+    const allItems = dataKeys.map((key) => ({
+      dataKey: key,
+      color: config[key]?.color,
+      label: config[key]?.label ?? key,
+    }));
+
+    if (allItems.length <= maxItems) {
+      return { visible: allItems, remaining: 0, hoveredHiddenItem: undefined };
+    }
+
+    const visibleItems = allItems.slice(0, maxItems);
+    const remainingCount = allItems.length - maxItems;
+
+    // If we're hovering over an item that's not visible in the legend,
+    // pass it separately to replace the "view more" row
+    let hoveredHiddenItem: (typeof allItems)[0] | undefined;
+    if (
+      highlight.activeBarKey &&
+      !visibleItems.some((item) => item.dataKey === highlight.activeBarKey)
+    ) {
+      hoveredHiddenItem = allItems.find((item) => item.dataKey === highlight.activeBarKey);
+    }
+
+    return { visible: visibleItems, remaining: remainingCount, hoveredHiddenItem };
+  }, [config, dataKeys, maxItems, highlight.activeBarKey]);
+
+  if (hidden || dataKeys.length === 0) {
+    return null;
+  }
+
+  const isHovering = (activePayload?.length ?? 0) > 0;
+
+  return (
+    <div
+      className={cn("flex flex-col px-2 pb-2 pt-4 text-sm", scrollable && "max-h-[50%] min-h-0", className)}
+    >
+      {/* Total row */}
+      <div
+        className={cn(
+          "flex w-full shrink-0 items-center justify-between gap-2 rounded px-2 py-1 transition",
+          isHovering ? "text-text-bright" : "text-text-dimmed"
+        )}
+      >
+        <span className="font-medium">{currentTotalLabel}</span>
+        <span className="shrink-0 font-medium tabular-nums">
+          {currentTotal != null ? (
+            valueFormatter ? (
+              valueFormatter(currentTotal)
+            ) : (
+              <AnimatedNumber value={currentTotal} duration={0.25} />
+            )
+          ) : (
+            "\u2013"
+          )}
+        </span>
+      </div>
+
+      {/* Separator */}
+      <div className="mx-2 my-1 shrink-0 border-t border-charcoal-750" />
+
+      {/* Legend items - scrollable when scrollable prop is true */}
+      <div
+        className={cn(
+          "flex flex-col",
+          scrollable &&
+            "min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        )}
+      >
+        {legendItems.visible.map((item) => {
+          const total = currentData[item.dataKey] ?? null;
+          const isActive = highlight.activeBarKey === item.dataKey;
+
+          return (
+            <div
+              key={item.dataKey}
+              className={cn(
+                "relative flex w-full cursor-default items-center justify-between gap-2 rounded px-2 py-1 transition",
+                (total == null || total === 0) && "opacity-50"
+              )}
+              onMouseEnter={() => highlight.setHoveredLegendItem(item.dataKey)}
+              onMouseLeave={() => highlight.reset()}
+            >
+              {/* Active highlight background */}
+              {isActive && item.color && (
+                <div
+                  className="absolute inset-0 rounded opacity-10"
+                  style={{ backgroundColor: item.color }}
+                />
+              )}
+              <div className="relative flex w-full items-center justify-between gap-3 overflow-hidden">
+                <SimpleTooltip
+                  button={
+                    <div className="flex min-w-0 items-center gap-1.5">
+                      {item.color && (
+                        <div
+                          className="w-1 shrink-0 self-stretch rounded-[2px]"
+                          style={{ backgroundColor: item.color }}
+                        />
+                      )}
+                      <span
+                        className={cn(
+                          "truncate",
+                          isActive ? "text-text-bright" : "text-text-dimmed"
+                        )}
+                      >
+                        {item.label}
+                      </span>
+                    </div>
+                  }
+                  content={item.label}
+                  side="top"
+                  disableHoverableContent
+                  className="max-w-xs break-words"
+                  buttonClassName="cursor-default min-w-0"
+                />
+                <span
+                  className={cn(
+                    "shrink-0 self-start tabular-nums",
+                    isActive ? "text-text-bright" : "text-text-dimmed"
+                  )}
+                >
+                  {total != null ? (
+                    valueFormatter ? (
+                      valueFormatter(total)
+                    ) : (
+                      <AnimatedNumber value={total} duration={0.25} />
+                    )
+                  ) : (
+                    "\u2013"
+                  )}
+                </span>
+              </div>
+            </div>
+          );
+        })}
+
+        {/* View more row - replaced by hovered hidden item when applicable */}
+        {legendItems.remaining > 0 &&
+          (legendItems.hoveredHiddenItem ? (
+            <HoveredHiddenItemRow
+              item={legendItems.hoveredHiddenItem}
+              value={currentData[legendItems.hoveredHiddenItem.dataKey] ?? null}
+              remainingCount={legendItems.remaining - 1}
+              valueFormatter={valueFormatter}
+            />
+          ) : (
+            <ViewAllDataRow
+              remainingCount={legendItems.remaining}
+              onViewAll={onViewAllLegendItems}
+            />
+          ))}
+      </div>
+    </div>
+  );
+}
+
+type ViewAllDataRowProps = {
+  remainingCount: number;
+  onViewAll?: () => void;
+};
+
+function ViewAllDataRow({ remainingCount, onViewAll }: ViewAllDataRowProps) {
+  return (
+    <div
+      className="relative flex w-full cursor-pointer items-center justify-between gap-2 rounded px-2 py-1 transition hover:bg-charcoal-850"
+      onClick={onViewAll}
+      role="button"
+      tabIndex={0}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          onViewAll?.();
+        }
+      }}
+    >
+      <div className="relative flex w-full items-center justify-between gap-3">
+        <div className="flex items-center gap-1.5">
+          <div className="w-1 shrink-0 self-stretch rounded-[2px] border border-charcoal-600" />
+          <span className="text-text-dimmed tabular-nums">{remainingCount} more…</span>
+        </div>
+        <span className="self-start text-indigo-500">View all</span>
+      </div>
+    </div>
+  );
+}
+
+type HoveredHiddenItemRowProps = {
+  item: { dataKey: string; color?: string; label: React.ReactNode };
+  value: number | null;
+  remainingCount: number;
+  valueFormatter?: (value: number) => string;
+};
+
+function HoveredHiddenItemRow({ item, value, remainingCount, valueFormatter }: HoveredHiddenItemRowProps) {
+  return (
+    <div className="relative flex w-full items-center justify-between gap-2 rounded px-2 py-1">
+      {/* Active highlight background */}
+      {item.color && (
+        <div
+          className="absolute inset-0 rounded opacity-10"
+          style={{ backgroundColor: item.color }}
+        />
+      )}
+      <div className="relative flex w-full items-center justify-between gap-3">
+        <div className="flex items-center gap-1.5">
+          {item.color && (
+            <div
+              className="w-1 shrink-0 self-stretch rounded-[2px]"
+              style={{ backgroundColor: item.color }}
+            />
+          )}
+          <span className="text-text-bright">{item.label}</span>
+          {remainingCount > 0 && <span className="text-text-dimmed">+{remainingCount} more</span>}
+        </div>
+        <span className="shrink-0 tabular-nums text-text-bright">
+          {value != null ? (
+            valueFormatter ? (
+              valueFormatter(value)
+            ) : (
+              <AnimatedNumber value={value} duration={0.25} />
+            )
+          ) : (
+            "\u2013"
+          )}
+        </span>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartLine.tsx b/apps/webapp/app/components/primitives/charts/ChartLine.tsx
new file mode 100644
index 00000000000..e52e6fa398f
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartLine.tsx
@@ -0,0 +1,241 @@
+import React from "react";
+import {
+  Area,
+  AreaChart,
+  CartesianGrid,
+  Line,
+  LineChart,
+  XAxis,
+  YAxis,
+  type XAxisProps,
+  type YAxisProps,
+} from "recharts";
+import {
+  type ChartConfig,
+  ChartTooltip,
+  ChartTooltipContent,
+  type ChartState,
+} from "~/components/primitives/charts/Chart";
+import { ChartLineLoading, ChartLineNoData, ChartLineInvalid } from "./ChartLoading";
+import { useChartContext } from "./ChartContext";
+import { ChartRoot, useHasNoData } from "./ChartRoot";
+// Legend is now rendered by ChartRoot outside the chart container
+import type { ZoomRange } from "./hooks/useZoomSelection";
+
+type CurveType =
+  | "basis"
+  | "basisClosed"
+  | "basisOpen"
+  | "linear"
+  | "linearClosed"
+  | "natural"
+  | "monotoneX"
+  | "monotoneY"
+  | "monotone"
+  | "step"
+  | "stepBefore"
+  | "stepAfter";
+
+// ============================================================================
+// COMPOUND COMPONENT API
+// ============================================================================
+
+export type ChartLineRendererProps = {
+  /** Line curve type */
+  lineType?: CurveType;
+  /** Custom X-axis props to merge with defaults */
+  xAxisProps?: Partial<XAxisProps>;
+  /** Custom Y-axis props to merge with defaults */
+  yAxisProps?: Partial<YAxisProps>;
+  /** Render as stacked area chart instead of line chart */
+  stacked?: boolean;
+  /** Custom tooltip label formatter */
+  tooltipLabelFormatter?: (label: string, payload: any[]) => string;
+  /** Optional formatter for numeric tooltip values (e.g. bytes, duration) */
+  tooltipValueFormatter?: (value: number) => string;
+  /** Width injected by ResponsiveContainer */
+  width?: number;
+  /** Height injected by ResponsiveContainer */
+  height?: number;
+};
+
+/**
+ * Line chart renderer for the compound component system.
+ * Must be used within a Chart.Root.
+ *
+ * @example
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day">
+ *   <Chart.Line type="step" />
+ *   <Chart.Legend simple />
+ * </Chart.Root>
+ * ```
+ */
+export function ChartLineRenderer({
+  lineType = "step",
+  xAxisProps: xAxisPropsProp,
+  yAxisProps: yAxisPropsProp,
+  stacked = false,
+  tooltipLabelFormatter,
+  tooltipValueFormatter,
+  width,
+  height,
+}: ChartLineRendererProps) {
+  const { config, data, dataKey, dataKeys, visibleSeries, state, highlight, setActivePayload, showLegend } = useChartContext();
+  const hasNoData = useHasNoData();
+
+  // Render loading/error states
+  if (state === "loading") {
+    return <ChartLineLoading />;
+  } else if (state === "noData" || hasNoData) {
+    return <ChartLineNoData />;
+  } else if (state === "invalid") {
+    return <ChartLineInvalid />;
+  }
+
+  // Get the x-axis ticks based on tooltip state
+  const xAxisTicks =
+    highlight.tooltipActive && data.length > 2
+      ? [data[0]?.[dataKey], data[data.length - 1]?.[dataKey]]
+      : undefined;
+
+  const xAxisConfig = {
+    dataKey,
+    tickLine: false,
+    axisLine: false,
+    tickMargin: 10,
+    ticks: xAxisTicks,
+    interval: "preserveStartEnd" as const,
+    tick: {
+      fill: "#878C99",
+      fontSize: 11,
+      style: { fontVariantNumeric: "tabular-nums" },
+    },
+    ...xAxisPropsProp,
+  };
+
+  const yAxisConfig = {
+    axisLine: false,
+    tickLine: false,
+    tickMargin: 8,
+    tick: {
+      fill: "#878C99",
+      fontSize: 11,
+      style: { fontVariantNumeric: "tabular-nums" },
+    },
+    ...yAxisPropsProp,
+  };
+
+  // Handle mouse leave to also reset highlight
+  const handleMouseLeave = () => {
+    highlight.setTooltipActive(false);
+    highlight.reset();
+  };
+
+  // Render stacked area chart if stacked prop is true
+  if (stacked && visibleSeries.length > 1) {
+    return (
+      <AreaChart
+        data={data}
+        width={width}
+        height={height}
+        stackOffset="none"
+        margin={{
+          left: 12,
+          right: 12,
+        }}
+        onMouseMove={(e: any) => {
+          if (e?.activePayload?.length) {
+            setActivePayload(e.activePayload, e.activeTooltipIndex);
+            highlight.setTooltipActive(true);
+          } else {
+            highlight.setTooltipActive(false);
+          }
+        }}
+        onMouseLeave={handleMouseLeave}
+      >
+        <CartesianGrid vertical={false} stroke="#272A2E" strokeDasharray="3 3" />
+        <XAxis {...xAxisConfig} />
+        <YAxis {...yAxisConfig} />
+        {/* When legend is shown below, render tooltip with cursor only (no content popup) */}
+        <ChartTooltip
+          cursor={{ stroke: "rgba(255, 255, 255, 0.1)", strokeWidth: 1 }}
+          content={
+            showLegend ? (
+              () => null
+            ) : (
+              <ChartTooltipContent indicator="line" valueFormatter={tooltipValueFormatter} />
+            )
+          }
+          labelFormatter={tooltipLabelFormatter}
+        />
+        {/* Note: Legend is now rendered by ChartRoot outside the chart container */}
+        {visibleSeries.map((key) => (
+          <Area
+            key={key}
+            type={lineType}
+            dataKey={key}
+            stroke={config[key]?.color}
+            fill={config[key]?.color}
+            fillOpacity={0.6}
+            strokeWidth={1}
+            stackId="stack"
+            isAnimationActive={false}
+          />
+        ))}
+      </AreaChart>
+    );
+  }
+
+  return (
+    <LineChart
+      accessibilityLayer
+      data={data}
+      width={width}
+      height={height}
+      margin={{
+        top: 5,
+        left: 12,
+        right: 12,
+      }}
+      onMouseMove={(e: any) => {
+        if (e?.activePayload?.length) {
+          setActivePayload(e.activePayload, e.activeTooltipIndex);
+          highlight.setTooltipActive(true);
+        } else {
+          highlight.setTooltipActive(false);
+        }
+      }}
+      onMouseLeave={handleMouseLeave}
+    >
+      <CartesianGrid vertical={false} stroke="#272A2E" strokeDasharray="3 3" />
+      <XAxis {...xAxisConfig} />
+      <YAxis {...yAxisConfig} />
+      {/* When legend is shown below, render tooltip with cursor only (no content popup) */}
+      <ChartTooltip
+        cursor={{ stroke: "rgba(255, 255, 255, 0.1)", strokeWidth: 1 }}
+        content={
+          showLegend ? (
+            () => null
+          ) : (
+            <ChartTooltipContent valueFormatter={tooltipValueFormatter} />
+          )
+        }
+        labelFormatter={tooltipLabelFormatter}
+      />
+      {/* Note: Legend is now rendered by ChartRoot outside the chart container */}
+      {visibleSeries.map((key) => (
+        <Line
+          key={key}
+          dataKey={key}
+          type={lineType}
+          stroke={config[key]?.color}
+          strokeWidth={1}
+          dot={{ r: 1.5, fill: config[key]?.color, strokeWidth: 0 }}
+          activeDot={{ r: 4 }}
+          isAnimationActive={false}
+        />
+      ))}
+    </LineChart>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartLoading.tsx b/apps/webapp/app/components/primitives/charts/ChartLoading.tsx
new file mode 100644
index 00000000000..8046f3045f7
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartLoading.tsx
@@ -0,0 +1,340 @@
+import { motion } from "framer-motion";
+import { Button } from "../Buttons";
+import { Paragraph } from "../Paragraph";
+import { Spinner } from "../Spinner";
+import { useDateRange } from "./DateRangeContext";
+import { useMemo } from "react";
+import { ClientOnly } from "remix-utils/client-only";
+
+export function ChartBarLoading() {
+  return (
+    <div className="relative grid h-full place-items-center p-2 pt-0">
+      <ChartBarLoadingBackground />
+      <div className="absolute z-10 mb-16 flex items-center gap-2">
+        <Spinner className="size-6" />
+        <Paragraph variant="base/bright">Loading data…</Paragraph>
+      </div>
+    </div>
+  );
+}
+
+export function ChartBarNoData() {
+  const dateRange = useDateRange();
+
+  return (
+    <div className="relative grid h-full place-items-center p-2 pt-0">
+      <ChartBarLoadingBackground />
+      <div className="absolute z-10 mb-16 flex flex-col items-center gap-2">
+        <Paragraph variant="small/bright">No data</Paragraph>
+        <Paragraph variant="small" spacing>
+          There's no data available for the filters you've set.
+        </Paragraph>
+        {dateRange && (
+          <Button variant="secondary/small" onClick={dateRange.resetDateRange}>
+            Clear filters
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export function ChartBarInvalid() {
+  const dateRange = useDateRange();
+
+  return (
+    <div className="relative grid h-full place-items-center p-2 pt-0">
+      <ChartBarLoadingBackground />
+      <div className="absolute z-10 mb-16 flex flex-col items-center gap-2">
+        <Paragraph variant="small/bright">Chart not applicable</Paragraph>
+        <Paragraph variant="small" spacing>
+          Your current filter settings don't apply to this chart's data type.
+        </Paragraph>
+        {dateRange && (
+          <Button variant="secondary/small" onClick={dateRange.resetDateRange}>
+            Clear filters
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export function ChartLineLoading() {
+  return (
+    <div className="relative mb-16 grid h-full place-items-center p-2 pt-0">
+      <ChartLineLoadingBackground />
+      <div className="absolute z-10 flex items-center gap-2">
+        <Spinner className="size-6" />
+        <Paragraph variant="base/bright">Loading data…</Paragraph>
+      </div>
+    </div>
+  );
+}
+
+export function ChartLineNoData() {
+  const dateRange = useDateRange();
+
+  return (
+    <div className="relative grid h-full place-items-center p-2 pt-0">
+      <ChartLineLoadingBackground />
+      <div className="absolute z-10 mb-16 flex flex-col items-center gap-2">
+        <Paragraph variant="small/bright">No data</Paragraph>
+        <Paragraph variant="small" spacing>
+          There's no data available for the filters you've set.
+        </Paragraph>
+        {dateRange && (
+          <Button variant="secondary/small" onClick={dateRange.resetDateRange}>
+            Clear filters
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export function ChartLineInvalid() {
+  const dateRange = useDateRange();
+
+  return (
+    <div className="relative grid h-full place-items-center p-2 pt-0">
+      <ChartLineLoadingBackground />
+      <div className="absolute z-10 mb-16 flex flex-col items-center gap-2">
+        <Paragraph variant="small/bright">Chart not applicable</Paragraph>
+        <Paragraph variant="small" spacing>
+          Your current filter settings don't apply to this chart's data type.
+        </Paragraph>
+        {dateRange && (
+          <Button variant="secondary/small" onClick={dateRange.resetDateRange}>
+            Clear filters
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function ChartBarLoadingBackground() {
+  return (
+    <motion.div
+      className="flex h-full w-full flex-col"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      transition={{ duration: 0.5 }}
+    >
+      <ClientOnly fallback={<div />}>
+      {() => (<>
+        <motion.div
+        className="flex flex-1 items-end gap-1"
+        initial={{ opacity: 0 }}
+        animate={{ opacity: 1 }}
+        transition={{ duration: 0.6, delay: 0.1 }}
+      >
+        {Array.from({ length: 30 }).map((_, i) => {
+          const height = Math.max(15, Math.floor(Math.random() * 100));
+          return (
+            <motion.div
+              key={i}
+              className="flex-1 rounded-sm bg-charcoal-750/50"
+              style={{ height: `${height}%` }}
+              initial={{ height: 0, opacity: 0 }}
+              animate={{ height: `${height}%`, opacity: 1 }}
+              transition={{
+                type: "spring",
+                stiffness: 120,
+                damping: 14,
+                mass: 1,
+                delay: 0.1 + i * 0.02,
+              }}
+            />
+          );
+        })}
+      </motion.div>
+      <motion.div
+        className="mt-2 flex flex-col justify-center gap-1"
+        initial={{ y: 10, opacity: 0 }}
+        animate={{ y: 0, opacity: 1 }}
+        transition={{
+          type: "spring",
+          stiffness: 100,
+          damping: 15,
+          delay: 0.2,
+        }}
+      >
+        {Array.from({ length: 5 }).map((_, i) => (
+          <motion.div
+            className="flex items-center gap-1"
+            key={i}
+            initial={{ x: -10, opacity: 0 }}
+            animate={{ x: 0, opacity: 1 }}
+            transition={{
+              type: "spring",
+              stiffness: 100,
+              damping: 12,
+              delay: 0.3 + i * 0.08,
+            }}
+          >
+            <div className="h-5 w-2 rounded-sm bg-charcoal-750/50" />
+            <div className="h-5 w-full rounded-sm bg-charcoal-750/50" />
+          </motion.div>
+        ))}
+      </motion.div>
+      </>)}
+    </ClientOnly>
+      
+    </motion.div>
+  );
+}
+
+function ChartLineLoadingBackground() {
+  // Generate line points with configurable starting position and constraints
+  const generateLinePoints = (startY: number, minY: number, maxY: number) => {
+    const numPoints = 10;
+    const points = [];
+    let lastY = startY;
+
+    for (let i = 0; i < numPoints; i++) {
+      // Calculate x value that spreads points across the full width
+      const x = i * (9 / (numPoints - 1));
+
+      // Create less extreme variations that move smoothly
+      const change = Math.random() * 6 - 3; // Range from -3 to +3
+      const y = Math.max(minY, Math.min(maxY, lastY + change)); // Apply constraints
+
+      points.push({ x, y });
+      lastY = y;
+    }
+
+    return points;
+  };
+
+  // Generate points for both lines
+  const points = useMemo(() => generateLinePoints(30, 10, 90), []);
+  const secondPoints = useMemo(() => generateLinePoints(40, 30, 90), []);
+
+  const generateSmoothPath = (points: Array<{ x: number; y: number }>) => {
+    if (points.length < 2) return "";
+
+    let path = `M0,${50 - points[0].y}`;
+
+    // Use curve command for smooth lines
+    for (let i = 0; i < points.length - 1; i++) {
+      const x1 = points[i].x;
+      const y1 = 50 - points[i].y;
+      const x2 = points[i + 1].x;
+      const y2 = 50 - points[i + 1].y;
+
+      // Bezier control points (create smooth curve)
+      const cx1 = (x1 + x2) / 2;
+      const cy1 = y1;
+      const cx2 = (x1 + x2) / 2;
+      const cy2 = y2;
+
+      path += ` C${cx1},${cy1} ${cx2},${cy2} ${x2},${y2}`;
+    }
+
+    return path;
+  };
+
+  const generateAreaPath = (points: Array<{ x: number; y: number }>) => {
+    const curvePath = generateSmoothPath(points);
+    const lastX = 9;
+    return `${curvePath} L${lastX},50 L0,50 Z`;
+  };
+
+  // Component to render a line with area fill and animation
+  const AnimatedLine = ({
+    points,
+    gradientId,
+    delay = 0,
+  }: {
+    points: Array<{ x: number; y: number }>;
+    gradientId: string;
+    delay?: number;
+  }) => (
+    <>
+      <motion.path
+        d={generateAreaPath(points)}
+        fill={`url(#${gradientId})`}
+        initial={{ opacity: 0 }}
+        animate={{ opacity: 1 }}
+        transition={{ duration: 1, ease: "easeInOut", delay }}
+      />
+      <motion.path
+        d={generateSmoothPath(points)}
+        stroke="#212327"
+        strokeWidth="1"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        fill="none"
+        initial={{ opacity: 0 }}
+        animate={{ opacity: 0.8 }}
+        transition={{ duration: 1.5, ease: "easeInOut", delay }}
+        vectorEffect="non-scaling-stroke"
+      />
+    </>
+  );
+
+  return (
+    <motion.div
+      className="flex h-full w-full flex-col"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      transition={{ duration: 0.5 }}
+    >
+      <div className="relative flex-1">
+        <svg
+          className="absolute inset-0 h-full w-full"
+          viewBox="0 0 9 50"
+          preserveAspectRatio="none"
+        >
+          <defs>
+            <linearGradient id="areaGradient" x1="0" y1="0" x2="0" y2="1">
+              <stop offset="0%" stopColor="#212327" stopOpacity={0.3} />
+              <stop offset="100%" stopColor="#212327" stopOpacity={0} />
+            </linearGradient>
+            <linearGradient id="secondAreaGradient" x1="0" y1="0" x2="0" y2="1">
+              <stop offset="0%" stopColor="#212327" stopOpacity={0.3} />
+              <stop offset="100%" stopColor="#212327" stopOpacity={0} />
+            </linearGradient>
+          </defs>
+
+          <g>
+            <AnimatedLine points={points} gradientId="areaGradient" />
+            <AnimatedLine points={secondPoints} gradientId="secondAreaGradient" delay={0.2} />
+          </g>
+        </svg>
+      </div>
+
+      <motion.div
+        className="mt-2 flex flex-col justify-center gap-1"
+        initial={{ y: 10, opacity: 0 }}
+        animate={{ y: 0, opacity: 1 }}
+        transition={{
+          type: "spring",
+          stiffness: 100,
+          damping: 15,
+          delay: 0.2,
+        }}
+      >
+        {Array.from({ length: 5 }).map((_, i) => (
+          <motion.div
+            className="flex items-center gap-1"
+            key={i}
+            initial={{ x: -10, opacity: 0 }}
+            animate={{ x: 0, opacity: 1 }}
+            transition={{
+              type: "spring",
+              stiffness: 100,
+              damping: 12,
+              delay: 0.3 + i * 0.08,
+            }}
+          >
+            <div className="h-5 w-2 rounded-sm bg-charcoal-750/50" />
+            <div className="h-5 w-full rounded-sm bg-charcoal-750/50" />
+          </motion.div>
+        ))}
+      </motion.div>
+    </motion.div>
+  );
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartRoot.tsx b/apps/webapp/app/components/primitives/charts/ChartRoot.tsx
new file mode 100644
index 00000000000..3b2a2c6a3c1
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartRoot.tsx
@@ -0,0 +1,305 @@
+import React, { useMemo } from "react";
+import type * as RechartsPrimitive from "recharts";
+import type { AggregationType } from "~/components/metrics/QueryWidget";
+import { ChartContainer, type ChartConfig, type ChartState } from "./Chart";
+import { ChartProvider, useChartContext, type LabelFormatter } from "./ChartContext";
+import { ChartLegendCompound } from "./ChartLegendCompound";
+import type { ZoomRange } from "./hooks/useZoomSelection";
+import { cn } from "~/utils/cn";
+
+export type ChartRootProps = {
+  config: ChartConfig;
+  data: any[];
+  dataKey: string;
+  /** Series keys to render (if not provided, derived from config keys) */
+  series?: string[];
+  /** Subset of series to render as SVG elements on the chart (legend still shows all series) */
+  visibleSeries?: string[];
+  state?: ChartState;
+  /** Function to format the x-axis label (used in legend, tooltips, etc.) */
+  labelFormatter?: LabelFormatter;
+  /** Enable zoom functionality */
+  enableZoom?: boolean;
+  /** Callback when zoom range changes */
+  onZoomChange?: (range: ZoomRange) => void;
+  /** Minimum height for the chart */
+  minHeight?: string;
+  /** Additional className for the container */
+  className?: string;
+  /** Show the compound legend below the chart */
+  showLegend?: boolean;
+  /** Maximum items in the legend before showing "view more" */
+  maxLegendItems?: number;
+  /** Label for the total row in the legend */
+  legendTotalLabel?: string;
+  /** Aggregation method used by the legend to compute totals (defaults to sum behavior) */
+  legendAggregation?: AggregationType;
+  /** Optional formatter for numeric legend values (e.g. bytes, duration) */
+  legendValueFormatter?: (value: number) => string;
+  /** Callback when "View all" legend button is clicked */
+  onViewAllLegendItems?: () => void;
+  /** When true, constrains legend to max 50% height with scrolling */
+  legendScrollable?: boolean;
+  /** Additional className for the legend */
+  legendClassName?: string;
+  /** When true, chart fills its parent container height and distributes space between chart and legend */
+  fillContainer?: boolean;
+  /** Content rendered between the chart and the legend */
+  beforeLegend?: React.ReactNode;
+  children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+};
+
+/**
+ * Root component for the chart compound component system.
+ * Provides shared context for all child chart components.
+ *
+ * @example Simple bar chart
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day">
+ *   <Chart.Bar stackId="a" />
+ *   <Chart.Legend />
+ * </Chart.Root>
+ * ```
+ *
+ * @example Chart with zoom
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day" enableZoom onZoomChange={handleZoom}>
+ *   <Chart.Bar stackId="a" />
+ *   <Chart.Zoom />
+ *   <Chart.Legend />
+ * </Chart.Root>
+ * ```
+ */
+export function ChartRoot({
+  config,
+  data,
+  dataKey,
+  series,
+  visibleSeries,
+  state,
+  labelFormatter,
+  enableZoom = false,
+  onZoomChange,
+  minHeight,
+  className,
+  showLegend = false,
+  maxLegendItems = 5,
+  legendTotalLabel,
+  legendAggregation,
+  legendValueFormatter,
+  onViewAllLegendItems,
+  legendScrollable = false,
+  legendClassName,
+  fillContainer = false,
+  beforeLegend,
+  children,
+}: ChartRootProps) {
+  return (
+    <ChartProvider
+      config={config}
+      data={data}
+      dataKey={dataKey}
+      series={series}
+      visibleSeries={visibleSeries}
+      state={state}
+      labelFormatter={labelFormatter}
+      enableZoom={enableZoom}
+      onZoomChange={onZoomChange}
+      showLegend={showLegend}
+    >
+      <ChartRootInner
+        minHeight={minHeight}
+        className={className}
+        showLegend={showLegend}
+        maxLegendItems={maxLegendItems}
+        legendTotalLabel={legendTotalLabel}
+        legendAggregation={legendAggregation}
+        legendValueFormatter={legendValueFormatter}
+        onViewAllLegendItems={onViewAllLegendItems}
+        legendScrollable={legendScrollable}
+        legendClassName={legendClassName}
+        fillContainer={fillContainer}
+        beforeLegend={beforeLegend}
+      >
+        {children}
+      </ChartRootInner>
+    </ChartProvider>
+  );
+}
+
+type ChartRootInnerProps = {
+  minHeight?: string;
+  className?: string;
+  showLegend?: boolean;
+  maxLegendItems?: number;
+  legendTotalLabel?: string;
+  legendAggregation?: AggregationType;
+  legendValueFormatter?: (value: number) => string;
+  onViewAllLegendItems?: () => void;
+  legendScrollable?: boolean;
+  legendClassName?: string;
+  fillContainer?: boolean;
+  beforeLegend?: React.ReactNode;
+  children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+};
+
+function ChartRootInner({
+  minHeight,
+  className,
+  showLegend = false,
+  maxLegendItems = 5,
+  legendTotalLabel,
+  legendAggregation,
+  legendValueFormatter,
+  onViewAllLegendItems,
+  legendScrollable = false,
+  legendClassName,
+  fillContainer = false,
+  beforeLegend,
+  children,
+}: ChartRootInnerProps) {
+  const { config, zoom } = useChartContext();
+  const enableZoom = zoom !== null;
+
+  return (
+    <div
+      className={cn(
+        "relative flex w-full flex-col",
+        fillContainer && "h-full",
+        className
+      )}
+    >
+      <div
+        className={cn(
+          fillContainer ? "min-h-0 flex-1" : "h-full w-full",
+          enableZoom && "mt-8 cursor-crosshair"
+        )}
+        style={{ touchAction: "none", userSelect: "none" }}
+      >
+        <ChartContainer
+          config={config}
+          className={cn(
+            "h-full w-full",
+            fillContainer && "!aspect-auto",
+            enableZoom &&
+            "[&_.recharts-surface]:cursor-crosshair [&_.recharts-wrapper]:cursor-crosshair"
+          )}
+          style={fillContainer ? undefined : minHeight ? { minHeight } : undefined}
+        >
+          {children}
+        </ChartContainer>
+      </div>
+      {beforeLegend}
+      {/* Legend rendered outside the chart container */}
+      {showLegend && (
+        <ChartLegendCompound
+          maxItems={maxLegendItems}
+          totalLabel={legendTotalLabel}
+          aggregation={legendAggregation}
+          valueFormatter={legendValueFormatter}
+          onViewAllLegendItems={onViewAllLegendItems}
+          scrollable={legendScrollable}
+          className={legendClassName}
+        />
+      )}
+    </div>
+  );
+}
+
+/**
+ * Hook to check if all data in the visible range is empty (null or undefined).
+ * Zero values are considered valid data and will render.
+ * Useful for rendering "no data" states.
+ */
+export function useHasNoData(): boolean {
+  const { data, dataKey, dataKeys } = useChartContext();
+
+  return useMemo(() => {
+    if (data.length === 0) return true;
+
+    return data.every((item) => {
+      return dataKeys.every((key) => {
+        const value = item[key];
+        return value === null || value === undefined;
+      });
+    });
+  }, [data, dataKeys]);
+}
+
+/**
+ * Hook to calculate aggregated values for each series across all data points.
+ * When no aggregation is provided, defaults to sum (original behavior).
+ * Useful for legend displays.
+ */
+export function useSeriesTotal(aggregation?: AggregationType): Record<string, number> {
+  const { data, dataKeys } = useChartContext();
+
+  return useMemo(() => {
+    // Sum (default) and count use additive accumulation
+    if (!aggregation || aggregation === "sum" || aggregation === "count") {
+      return data.reduce(
+        (acc, item) => {
+          for (const seriesKey of dataKeys) {
+            acc[seriesKey] = (acc[seriesKey] || 0) + Number(item[seriesKey] || 0);
+          }
+          return acc;
+        },
+        {} as Record<string, number>
+      );
+    }
+
+    if (aggregation === "avg") {
+      const sums: Record<string, number> = {};
+      const counts: Record<string, number> = {};
+      for (const item of data) {
+        for (const seriesKey of dataKeys) {
+          const rawVal = item[seriesKey];
+          if (rawVal == null) continue; // skip gap-filled nulls
+          const val = Number(rawVal);
+          sums[seriesKey] = (sums[seriesKey] || 0) + val;
+          counts[seriesKey] = (counts[seriesKey] || 0) + 1;
+        }
+      }
+      const result: Record<string, number> = {};
+      for (const key of dataKeys) {
+        result[key] = counts[key] ? sums[key]! / counts[key]! : 0;
+      }
+      return result;
+    }
+
+    if (aggregation === "min") {
+      const result: Record<string, number> = {};
+      for (const item of data) {
+        for (const seriesKey of dataKeys) {
+          if (item[seriesKey] == null) continue; // skip gap-filled nulls
+          const val = Number(item[seriesKey]);
+          if (result[seriesKey] === undefined || val < result[seriesKey]) {
+            result[seriesKey] = val;
+          }
+        }
+      }
+      // Default to 0 for series with no data
+      for (const key of dataKeys) {
+        if (result[key] === undefined) result[key] = 0;
+      }
+      return result;
+    }
+
+    // aggregation === "max"
+    const result: Record<string, number> = {};
+    for (const item of data) {
+      for (const seriesKey of dataKeys) {
+        if (item[seriesKey] == null) continue; // skip gap-filled nulls
+        const val = Number(item[seriesKey]);
+        if (result[seriesKey] === undefined || val > result[seriesKey]) {
+          result[seriesKey] = val;
+        }
+      }
+    }
+    // Default to 0 for series with no data
+    for (const key of dataKeys) {
+      if (result[key] === undefined) result[key] = 0;
+    }
+    return result;
+  }, [data, dataKeys, aggregation]);
+}
diff --git a/apps/webapp/app/components/primitives/charts/ChartZoom.tsx b/apps/webapp/app/components/primitives/charts/ChartZoom.tsx
new file mode 100644
index 00000000000..4b2e921630b
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/ChartZoom.tsx
@@ -0,0 +1,244 @@
+import React, { useCallback } from "react";
+import { ReferenceArea, ReferenceLine } from "recharts";
+import { useChartContext } from "./ChartContext";
+import { useDateRange } from "./DateRangeContext";
+import { cn } from "~/utils/cn";
+
+export type ChartZoomProps = {
+  /** Sync zoom with DateRangeContext (for dashboard-level syncing) */
+  syncWithDateRange?: boolean;
+  /** Minimum number of data points required for a valid zoom selection */
+  minDataPoints?: number;
+};
+
+/**
+ * Zoom overlay component for charts.
+ * Renders the zoom selection area and inspection line.
+ *
+ * Must be used within a Chart.Root with enableZoom={true}.
+ *
+ * @example Basic zoom
+ * ```tsx
+ * <Chart.Root config={config} data={data} dataKey="day" enableZoom onZoomChange={handleZoom}>
+ *   <Chart.Bar />
+ *   <Chart.Zoom />
+ * </Chart.Root>
+ * ```
+ *
+ * @example Synced with DateRangeContext
+ * ```tsx
+ * <DateRangeProvider>
+ *   <Chart.Root config={config} data={data} dataKey="day" enableZoom onZoomChange={handleZoom}>
+ *     <Chart.Bar />
+ *     <Chart.Zoom syncWithDateRange />
+ *   </Chart.Root>
+ * </DateRangeProvider>
+ * ```
+ */
+export function ChartZoom({ syncWithDateRange = false, minDataPoints = 3 }: ChartZoomProps) {
+  const { zoom, data, dataKey, onZoomChange } = useChartContext();
+  const globalDateRange = useDateRange();
+
+  if (!zoom) {
+    console.warn("ChartZoom: zoom is not enabled. Add enableZoom to Chart.Root.");
+    return null;
+  }
+
+  const { inspectionLine, refAreaLeft, refAreaRight } = zoom;
+
+  return (
+    <>
+      {/* Inspection line (click to inspect) */}
+      {inspectionLine && (
+        <ReferenceLine
+          x={inspectionLine}
+          stroke="#D7D9DD"
+          strokeWidth={2}
+          isFront={true}
+          onClick={(e: any) => {
+            e?.stopPropagation?.();
+            zoom.clearInspectionLine();
+          }}
+        />
+      )}
+
+      {/* Zoom selection area */}
+      {refAreaLeft && refAreaRight && (
+        <ReferenceArea
+          x1={refAreaLeft}
+          x2={refAreaRight}
+          strokeOpacity={0.4}
+          fill="#3B82F6"
+          fillOpacity={0.2}
+        />
+      )}
+    </>
+  );
+}
+
+/**
+ * Tooltip component for showing zoom selection feedback.
+ * Can be used inside ChartTooltip content prop.
+ *
+ * Note: This component receives zoom state as props because recharts
+ * may render tooltips outside the normal React tree where context isn't available.
+ */
+export type ZoomTooltipProps = {
+  active?: boolean;
+  payload?: any[];
+  label?: string;
+  viewBox?: {
+    height: number;
+    width: number;
+  };
+  coordinate?: {
+    x: number;
+    y: number;
+  };
+  // Zoom state passed as props (since context might not be available in tooltip)
+  isSelecting?: boolean;
+  refAreaLeft?: string | null;
+  refAreaRight?: string | null;
+  invalidSelection?: boolean;
+};
+
+export function ZoomTooltip({
+  active,
+  payload,
+  label,
+  viewBox,
+  coordinate,
+  isSelecting,
+  refAreaLeft,
+  refAreaRight,
+  invalidSelection,
+}: ZoomTooltipProps) {
+  if (!active) return null;
+
+  // Show zoom range when selecting
+  if (isSelecting && refAreaLeft && refAreaRight) {
+    const message = invalidSelection
+      ? "Zoom: Drag a wider range"
+      : `Zoom: ${refAreaLeft} to ${refAreaRight}`;
+
+    return (
+      <div
+        className={cn(
+          "absolute whitespace-nowrap rounded border px-2 py-1 text-xxs tabular-nums",
+          invalidSelection
+            ? "border-amber-800 bg-amber-950 text-amber-400"
+            : "border-blue-800 bg-[#1B2334] text-blue-400"
+        )}
+        style={{
+          left: coordinate?.x,
+          top: viewBox?.height ? viewBox.height + 14 : 0,
+          transform: "translateX(-50%)",
+        }}
+      >
+        {message}
+        <div
+          className={cn(
+            "absolute -top-[5px] left-1/2 h-2 w-2 -translate-x-1/2 rotate-45",
+            invalidSelection
+              ? "border-l border-t border-amber-800 bg-amber-950"
+              : "border-l border-t border-blue-800 bg-[#1B2334]"
+          )}
+        />
+      </div>
+    );
+  }
+
+  // Default tooltip behavior (show label)
+  if (!payload?.length) return null;
+
+  return (
+    <div
+      className="absolute whitespace-nowrap rounded border border-charcoal-600 bg-charcoal-700 px-2 py-1 text-xxs tabular-nums text-text-bright"
+      style={{
+        left: coordinate?.x,
+        top: viewBox?.height ? viewBox.height + 13 : 0,
+        transform: "translateX(-50%)",
+      }}
+    >
+      {label}
+      <div className="absolute -top-[5px] left-1/2 h-2 w-2 -translate-x-1/2 rotate-45 border-l border-t border-charcoal-600 bg-charcoal-700" />
+    </div>
+  );
+}
+
+/**
+ * Hook that returns event handlers for zoom interactions.
+ * Use these on your chart component (BarChart, LineChart, etc.).
+ */
+export function useZoomHandlers(
+  options: { minDataPoints?: number; syncWithDateRange?: boolean } = {}
+) {
+  const { minDataPoints = 3, syncWithDateRange = false } = options;
+  const { zoom, data, dataKey, onZoomChange } = useChartContext();
+  const globalDateRange = useDateRange();
+
+  const handleMouseDown = useCallback(
+    (e: any) => {
+      if (!zoom || !e?.activeLabel) return;
+      zoom.startSelection(e.activeLabel);
+    },
+    [zoom]
+  );
+
+  const handleMouseMove = useCallback(
+    (e: any) => {
+      if (!zoom || !e?.activeLabel) return;
+      if (zoom.isSelecting) {
+        zoom.updateSelection(e.activeLabel, data, dataKey, minDataPoints);
+      }
+    },
+    [zoom, data, dataKey, minDataPoints]
+  );
+
+  const handleMouseUp = useCallback(() => {
+    if (!zoom) return;
+
+    const range = zoom.finishSelection(data, dataKey, minDataPoints);
+
+    if (range) {
+      // If syncing with DateRangeContext, update it
+      if (syncWithDateRange && globalDateRange) {
+        globalDateRange.setDateRange(range.start, range.end);
+      }
+
+      // Call the onZoomChange callback
+      onZoomChange?.(range);
+    }
+  }, [zoom, data, dataKey, minDataPoints, syncWithDateRange, globalDateRange, onZoomChange]);
+
+  const handleClick = useCallback(
+    (e: any) => {
+      if (!zoom || zoom.isSelecting || !e?.activeLabel) return;
+      zoom.toggleInspectionLine(e.activeLabel);
+    },
+    [zoom]
+  );
+
+  const handleMouseLeave = useCallback(() => {
+    if (!zoom) return;
+    zoom.cancelSelection();
+  }, [zoom]);
+
+  if (!zoom) {
+    return {
+      onMouseDown: undefined,
+      onMouseMove: undefined,
+      onMouseUp: undefined,
+      onClick: undefined,
+      onMouseLeave: undefined,
+    };
+  }
+
+  return {
+    onMouseDown: handleMouseDown,
+    onMouseMove: handleMouseMove,
+    onMouseUp: handleMouseUp,
+    onClick: handleClick,
+    onMouseLeave: handleMouseLeave,
+  };
+}
diff --git a/apps/webapp/app/components/primitives/charts/DateRangeContext.tsx b/apps/webapp/app/components/primitives/charts/DateRangeContext.tsx
new file mode 100644
index 00000000000..4b6d8210596
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/DateRangeContext.tsx
@@ -0,0 +1,120 @@
+import React, { createContext, useState, useContext, type ReactNode } from "react";
+
+type DateRangeContextType = {
+  /** Start date as ISO string (YYYY-MM-DD) or custom format */
+  startDate: string;
+  /** End date as ISO string (YYYY-MM-DD) or custom format */
+  endDate: string;
+  setDateRange: (startDate: string, endDate: string) => void;
+  resetDateRange: () => void;
+};
+
+// Formatters for displaying dates
+const shortDateFormatter = new Intl.DateTimeFormat("en-US", {
+  month: "short",
+  day: "numeric",
+});
+
+const longDateFormatter = new Intl.DateTimeFormat("en-US", {
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+});
+
+/**
+ * Format a Date object as a short date string (e.g., "Nov 1")
+ */
+export function formatChartDate(date: Date): string {
+  return shortDateFormatter.format(date);
+}
+
+/**
+ * Format a Date object as a long date string (e.g., "Nov 1, 2023")
+ */
+export function formatChartDateLong(date: Date): string {
+  return longDateFormatter.format(date);
+}
+
+/**
+ * Convert a Date to ISO date string (YYYY-MM-DD) using local date components
+ */
+export function toISODateString(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Parse an ISO date string (YYYY-MM-DD) to a local Date object
+ */
+export function parseISODateString(isoString: string): Date {
+  const [year, month, day] = isoString.split("-").map(Number);
+  return new Date(year, month - 1, day);
+}
+
+/**
+ * Format an ISO date string for display (e.g., "2023-11-01" -> "Nov 1")
+ */
+export function formatISODate(isoString: string): string {
+  const date = parseISODateString(isoString);
+  return formatChartDate(date);
+}
+
+/**
+ * Format an ISO date string for display with year (e.g., "2023-11-01" -> "Nov 1, 2023")
+ */
+export function formatISODateLong(isoString: string): string {
+  const date = parseISODateString(isoString);
+  return formatChartDateLong(date);
+}
+
+const DateRangeContext = createContext<DateRangeContextType | null>(null);
+
+export function DateRangeProvider({
+  children,
+  defaultStartDate,
+  defaultEndDate,
+}: {
+  children: ReactNode;
+  defaultStartDate: Date;
+  defaultEndDate: Date;
+}) {
+  // Store dates as ISO strings for consistent data matching
+  const defaultStartISO = toISODateString(defaultStartDate);
+  const defaultEndISO = toISODateString(defaultEndDate);
+
+  const [startDate, setStartDate] = useState<string>(defaultStartISO);
+  const [endDate, setEndDate] = useState<string>(defaultEndISO);
+
+  const setDateRange = (start: string, end: string) => {
+    setStartDate(start);
+    setEndDate(end);
+  };
+
+  const resetDateRange = () => {
+    setStartDate(defaultStartISO);
+    setEndDate(defaultEndISO);
+  };
+
+  return (
+    <DateRangeContext.Provider
+      value={{
+        startDate,
+        endDate,
+        setDateRange,
+        resetDateRange,
+      }}
+    >
+      {children}
+    </DateRangeContext.Provider>
+  );
+}
+
+export function useDateRange(): DateRangeContextType | null {
+  const context = useContext(DateRangeContext);
+  if (!context) {
+    return null;
+  }
+  return context;
+}
diff --git a/apps/webapp/app/components/primitives/charts/aggregation.ts b/apps/webapp/app/components/primitives/charts/aggregation.ts
new file mode 100644
index 00000000000..48269833d24
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/aggregation.ts
@@ -0,0 +1,23 @@
+import type { AggregationType } from "~/components/metrics/QueryWidget";
+
+/**
+ * Aggregate an array of numbers using the specified aggregation function.
+ *
+ * Shared utility so both QueryResultsChart (data transformation) and chart
+ * legend components can reuse the same logic without circular imports.
+ */
+export function aggregateValues(values: number[], aggregation: AggregationType): number {
+  if (values.length === 0) return 0;
+  switch (aggregation) {
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "avg":
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    case "count":
+      return values.length;
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+  }
+}
diff --git a/apps/webapp/app/components/primitives/charts/hooks/useHighlightState.ts b/apps/webapp/app/components/primitives/charts/hooks/useHighlightState.ts
new file mode 100644
index 00000000000..02baac0ca8f
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/hooks/useHighlightState.ts
@@ -0,0 +1,106 @@
+import { useCallback, useMemo, useState } from "react";
+
+export type HighlightState = {
+  /** The currently highlighted series key (e.g., "completed", "failed") */
+  activeBarKey: string | null;
+  /** The index of the specific data point being hovered (null when hovering legend) */
+  activeDataPointIndex: number | null;
+  /** Whether the tooltip is currently active */
+  tooltipActive: boolean;
+};
+
+export type HighlightActions = {
+  /** Set the hovered bar (specific data point) */
+  setHoveredBar: (key: string, index: number) => void;
+  /** Set the hovered legend item (highlights all bars of that type) */
+  setHoveredLegendItem: (key: string) => void;
+  /** Set tooltip active state */
+  setTooltipActive: (active: boolean) => void;
+  /** Reset all highlight state */
+  reset: () => void;
+};
+
+export type UseHighlightStateReturn = HighlightState & HighlightActions;
+
+const initialState: HighlightState = {
+  activeBarKey: null,
+  activeDataPointIndex: null,
+  tooltipActive: false,
+};
+
+/**
+ * Hook to manage highlight state for chart elements.
+ * Handles both bar hover (specific data point) and legend hover (all bars of a type).
+ *
+ * activePayload is intentionally NOT managed here — it lives in a separate context
+ * so that payload updates (frequent during mouse movement) don't cause bar re-renders.
+ */
+export function useHighlightState(): UseHighlightStateReturn {
+  const [state, setState] = useState<HighlightState>(initialState);
+
+  const setHoveredBar = useCallback((key: string, index: number) => {
+    setState({
+      activeBarKey: key,
+      activeDataPointIndex: index,
+      tooltipActive: true,
+    });
+  }, []);
+
+  const setHoveredLegendItem = useCallback((key: string) => {
+    setState((prev) => {
+      if (prev.activeBarKey === key && prev.activeDataPointIndex === null) return prev;
+      return { ...prev, activeBarKey: key, activeDataPointIndex: null };
+    });
+  }, []);
+
+  const setTooltipActive = useCallback((active: boolean) => {
+    setState((prev) => {
+      if (prev.tooltipActive === active) return prev;
+      return { ...prev, tooltipActive: active };
+    });
+  }, []);
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  return useMemo(
+    () => ({
+      ...state,
+      setHoveredBar,
+      setHoveredLegendItem,
+      setTooltipActive,
+      reset,
+    }),
+    [state, setHoveredBar, setHoveredLegendItem, setTooltipActive, reset]
+  );
+}
+
+/**
+ * Calculate the opacity for a bar based on highlight state.
+ * @param key - The series key of this bar
+ * @param dataIndex - The data point index of this bar
+ * @param highlight - The current highlight state
+ * @param dimmedOpacity - The opacity to use for dimmed bars (default 0.2)
+ */
+export function getBarOpacity(
+  key: string,
+  dataIndex: number,
+  highlight: HighlightState,
+  dimmedOpacity = 0.2
+): number {
+  const { activeBarKey, activeDataPointIndex } = highlight;
+
+  // No highlight active - full opacity
+  if (activeBarKey === null) {
+    return 1;
+  }
+
+  // Hovering a specific bar (from chart)
+  if (activeDataPointIndex !== null) {
+    return key === activeBarKey && dataIndex === activeDataPointIndex ? 1 : dimmedOpacity;
+  }
+
+  // Hovering a legend item (all bars of this type)
+  return key === activeBarKey ? 1 : dimmedOpacity;
+}
diff --git a/apps/webapp/app/components/primitives/charts/hooks/useZoomSelection.ts b/apps/webapp/app/components/primitives/charts/hooks/useZoomSelection.ts
new file mode 100644
index 00000000000..fda078f1183
--- /dev/null
+++ b/apps/webapp/app/components/primitives/charts/hooks/useZoomSelection.ts
@@ -0,0 +1,191 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+
+export type ZoomRange = {
+  start: string;
+  end: string;
+};
+
+export type ZoomSelectionState = {
+  /** Starting point of drag selection (x-axis value) */
+  refAreaLeft: string | null;
+  /** Ending point of drag selection (x-axis value) */
+  refAreaRight: string | null;
+  /** Whether user is currently dragging to select */
+  isSelecting: boolean;
+  /** Whether the current selection is too small to be valid */
+  invalidSelection: boolean;
+  /** X-axis value for the inspection line (click to inspect) */
+  inspectionLine: string | null;
+};
+
+export type ZoomSelectionActions = {
+  /** Start a new selection at the given x-axis value */
+  startSelection: (label: string) => void;
+  /** Update the selection as the user drags */
+  updateSelection: (label: string, data: any[], dataKey: string, minDataPoints?: number) => void;
+  /** Finish the selection and return the range if valid */
+  finishSelection: (data: any[], dataKey: string, minDataPoints?: number) => ZoomRange | null;
+  /** Cancel the current selection */
+  cancelSelection: () => void;
+  /** Toggle the inspection line at the given x-axis value */
+  toggleInspectionLine: (label: string) => void;
+  /** Clear the inspection line */
+  clearInspectionLine: () => void;
+  /** Reset all zoom state */
+  reset: () => void;
+};
+
+export type UseZoomSelectionReturn = ZoomSelectionState & ZoomSelectionActions;
+
+const initialState: ZoomSelectionState = {
+  refAreaLeft: null,
+  refAreaRight: null,
+  isSelecting: false,
+  invalidSelection: false,
+  inspectionLine: null,
+};
+
+/**
+ * Hook to manage zoom selection state for charts.
+ * Handles drag-to-zoom and click-to-inspect functionality.
+ */
+export function useZoomSelection(): UseZoomSelectionReturn {
+  const [state, setState] = useState<ZoomSelectionState>(initialState);
+  // Ref to track current state synchronously (needed for finishSelection)
+  const stateRef = useRef<ZoomSelectionState>(state);
+
+  // Keep ref in sync with state
+  stateRef.current = state;
+
+  const startSelection = useCallback((label: string) => {
+    const next = {
+      ...stateRef.current,
+      refAreaLeft: label,
+      refAreaRight: null,
+      isSelecting: true,
+      invalidSelection: false,
+    };
+    // Update ref synchronously first
+    stateRef.current = next;
+    setState(next);
+  }, []);
+
+  const updateSelection = useCallback(
+    (label: string, data: any[], dataKey: string, minDataPoints = 3) => {
+      const prev = stateRef.current;
+      if (!prev.isSelecting || !prev.refAreaLeft) {
+        return;
+      }
+
+      // Check if selection is valid (has enough data points)
+      const allLabels = data.map((item) => item[dataKey] as string).filter(Boolean);
+      const leftIndex = allLabels.indexOf(prev.refAreaLeft);
+      const rightIndex = allLabels.indexOf(label);
+
+      let invalidSelection = false;
+      if (leftIndex !== -1 && rightIndex !== -1) {
+        const [start, end] = [leftIndex, rightIndex].sort((a, b) => a - b);
+        invalidSelection = end - start < minDataPoints - 1;
+      } else {
+        invalidSelection = true;
+      }
+
+      const next = {
+        ...prev,
+        refAreaRight: label,
+        invalidSelection,
+      };
+      // Update ref synchronously first
+      stateRef.current = next;
+      setState(next);
+    },
+    []
+  );
+
+  const finishSelection = useCallback(
+    (data: any[], dataKey: string, minDataPoints = 3): ZoomRange | null => {
+      // Get current state synchronously to calculate result
+      const currentState = stateRef.current;
+
+      if (!currentState.refAreaLeft || !currentState.refAreaRight) {
+        const next = { ...initialState, inspectionLine: currentState.inspectionLine };
+        stateRef.current = next;
+        setState(next);
+        return null;
+      }
+
+      const allLabels = data.map((item) => item[dataKey] as string).filter(Boolean);
+      const leftIndex = allLabels.indexOf(currentState.refAreaLeft);
+      const rightIndex = allLabels.indexOf(currentState.refAreaRight);
+
+      let result: ZoomRange | null = null;
+
+      if (leftIndex !== -1 && rightIndex !== -1) {
+        const [startIdx, endIdx] = [leftIndex, rightIndex].sort((a, b) => a - b);
+
+        // Only create a valid range if we have enough data points
+        if (endIdx - startIdx >= minDataPoints - 1) {
+          result = {
+            start: allLabels[startIdx],
+            end: allLabels[endIdx],
+          };
+        }
+      }
+
+      // Reset the state (preserve inspection line)
+      const next = { ...initialState, inspectionLine: currentState.inspectionLine };
+      stateRef.current = next;
+      setState(next);
+
+      return result;
+    },
+    []
+  );
+
+  const cancelSelection = useCallback(() => {
+    const next = {
+      ...initialState,
+      inspectionLine: stateRef.current.inspectionLine,
+    };
+    stateRef.current = next;
+    setState(next);
+  }, []);
+
+  const toggleInspectionLine = useCallback((label: string) => {
+    const prev = stateRef.current;
+    const next = {
+      ...prev,
+      inspectionLine: prev.inspectionLine === label ? null : label,
+    };
+    stateRef.current = next;
+    setState(next);
+  }, []);
+
+  const clearInspectionLine = useCallback(() => {
+    const next = {
+      ...stateRef.current,
+      inspectionLine: null,
+    };
+    stateRef.current = next;
+    setState(next);
+  }, []);
+
+  const reset = useCallback(() => {
+    stateRef.current = initialState;
+    setState(initialState);
+  }, []);
+
+  return useMemo(
+    () => ({
+      ...state,
+      startSelection,
+      updateSelection,
+      finishSelection,
+      cancelSelection,
+      toggleInspectionLine,
+      clearInspectionLine,
+      reset,
+    }),
+    [state, startSelection, updateSelection, finishSelection, cancelSelection, toggleInspectionLine, clearInspectionLine, reset]
+  );
+}
diff --git a/apps/webapp/app/components/query/QueryEditor.tsx b/apps/webapp/app/components/query/QueryEditor.tsx
new file mode 100644
index 00000000000..bb9ed036267
--- /dev/null
+++ b/apps/webapp/app/components/query/QueryEditor.tsx
@@ -0,0 +1,1491 @@
+import {
+  ArrowDownTrayIcon,
+  BookmarkIcon,
+  CalendarIcon,
+  ClipboardIcon,
+  PencilIcon,
+  PencilSquareIcon,
+} from "@heroicons/react/20/solid";
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { useFetcher } from "@remix-run/react";
+import { IconChartHistogram } from "@tabler/icons-react";
+import { formatDurationNanoseconds } from "@trigger.dev/core/v3";
+import { Clipboard } from "lucide-react";
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
+import { flushSync } from "react-dom";
+import { useTypedFetcher } from "remix-typedjson";
+import simplur from "simplur";
+import { AISparkleIcon } from "~/assets/icons/AISparkleIcon";
+import { ChartConfigPanel, defaultChartConfig } from "~/components/code/ChartConfigPanel";
+import { autoFormatSQL, TSQLEditor } from "~/components/code/TSQLEditor";
+import { EnvironmentLabel } from "~/components/environments/EnvironmentLabel";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import {
+  QueryWidget,
+  type BigNumberConfiguration,
+  type ChartConfiguration,
+  type QueryWidgetConfig,
+  type QueryWidgetData,
+} from "~/components/metrics/QueryWidget";
+import { SaveToDashboardDialog } from "~/components/metrics/SaveToDashboardDialog";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import {
+  ClientTabs,
+  ClientTabsContent,
+  ClientTabsList,
+  ClientTabsTrigger,
+} from "~/components/primitives/ClientTabs";
+import { Dialog, DialogContent, DialogFooter, DialogHeader } from "~/components/primitives/Dialog";
+import { Header3 } from "~/components/primitives/Headers";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Popover,
+  PopoverArrowTrigger,
+  PopoverContent,
+  PopoverMenuItem,
+} from "~/components/primitives/Popover";
+import {
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+} from "~/components/primitives/Resizable";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { Spinner } from "~/components/primitives/Spinner";
+import { Switch } from "~/components/primitives/Switch";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { TimeFilter } from "~/components/runs/v3/SharedFilters";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import type { QueryHistoryItem } from "~/presenters/v3/QueryPresenter.server";
+import { QueryHelpSidebar } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHelpSidebar";
+import { QueryHistoryPopover } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHistoryPopover";
+import type { AITimeFilter } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types";
+import type { action as titleAction } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-title";
+import type { QueryScope } from "~/services/queryService.server";
+import { downloadFile, rowsToCSV, rowsToJSON } from "~/utils/dataExport";
+import { organizationBillingPath } from "~/utils/pathBuilder";
+import { querySchemas } from "~/v3/querySchemas";
+
+/** Convert a Date or ISO string to ISO string format */
+function toISOString(value: Date | string): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.toISOString();
+}
+
+const scopeOptions = [
+  { value: "environment", label: "Environment" },
+  { value: "project", label: "Project" },
+  { value: "organization", label: "Organization" },
+] as const;
+
+// Type for the query action response
+type QueryActionResponse = {
+  error: string | null;
+  rows: Record<string, unknown>[] | null;
+  columns: OutputColumnMetadata[] | null;
+  stats: { elapsed_ns: string } | null;
+  hiddenColumns: string[] | null;
+  reachedMaxRows: boolean | null;
+  explainOutput: string | null;
+  generatedSql: string | null;
+  queryId?: string | null;
+  periodClipped: number | null;
+  maxQueryPeriod?: number;
+};
+
+export type QueryEditorMode =
+  | { type: "standalone" }
+  | { type: "dashboard-add"; dashboardId: string; dashboardName: string }
+  | {
+      type: "dashboard-edit";
+      dashboardId: string;
+      dashboardName: string;
+      widgetId: string;
+      widgetName: string;
+    };
+
+/** Data passed to the save render prop */
+export type QueryEditorSaveData = {
+  title: string;
+  query: string;
+  config: QueryWidgetConfig;
+};
+
+export type QueryEditorProps = {
+  // Default values - used to initialize state
+  defaultQuery: string;
+  defaultScope: QueryScope;
+  defaultPeriod: string;
+  defaultTimeFilter?: { period?: string; from?: string; to?: string };
+  defaultResultsView?: "table" | "graph" | "bignumber";
+  defaultChartConfig?: ChartConfiguration;
+  defaultBigNumberConfig?: BigNumberConfiguration;
+  /** Initial result data to display (e.g., when editing an existing widget) */
+  defaultData?: QueryWidgetData;
+
+  // Other required data
+  history: QueryHistoryItem[];
+  isAdmin: boolean;
+  maxRows: number;
+
+  // The URL to post query execution requests to
+  queryActionUrl: string;
+
+  // Mode determines NavBar and save behavior
+  mode: QueryEditorMode;
+
+  // Max period days (from plan)
+  maxPeriodDays?: number;
+
+  // Render prop for save functionality - receives current data, returns ReactNode
+  save?: (data: QueryEditorSaveData) => ReactNode;
+  onClose?: () => void;
+};
+
+/** Handle for imperatively setting the query from outside */
+interface QueryEditorFormHandle {
+  setQuery: (query: string) => void;
+  setScope: (scope: QueryScope) => void;
+  getQuery: () => string;
+  setTimeFilter: (filter: { period?: string; from?: string; to?: string }) => void;
+}
+
+/** Self-contained query editor with form - isolates query state from parent */
+const QueryEditorForm = forwardRef<
+  QueryEditorFormHandle,
+  {
+    defaultPeriod: string;
+    defaultQuery: string;
+    defaultScope: QueryScope;
+    defaultTimeFilter?: { period?: string; from?: string; to?: string };
+    history: QueryHistoryItem[];
+    fetcher: ReturnType<typeof useTypedFetcher<QueryActionResponse>>;
+    isAdmin: boolean;
+    queryActionUrl: string;
+    maxPeriodDays?: number;
+    onQuerySubmit?: () => void;
+    onHistorySelected?: (item: QueryHistoryItem) => void;
+  }
+>(function QueryEditorForm(
+  {
+    defaultPeriod,
+    defaultQuery,
+    defaultScope,
+    defaultTimeFilter,
+    history,
+    fetcher,
+    isAdmin,
+    queryActionUrl,
+    maxPeriodDays,
+    onQuerySubmit,
+    onHistorySelected,
+  },
+  ref
+) {
+  const isLoading = fetcher.state === "submitting" || fetcher.state === "loading";
+  const [query, setQuery] = useState(defaultQuery);
+  const [scope, setScope] = useState<QueryScope>(defaultScope);
+  const formRef = useRef<HTMLFormElement>(null);
+  const prevFetcherState = useRef(fetcher.state);
+
+  // Notify parent when query is submitted (for title generation)
+  useEffect(() => {
+    if (prevFetcherState.current !== "submitting" && fetcher.state === "submitting") {
+      onQuerySubmit?.();
+    }
+    prevFetcherState.current = fetcher.state;
+  }, [fetcher.state, onQuerySubmit]);
+
+  // Get time filter values - initialize from props (which may come from history)
+  const [period, setPeriod] = useState<string | undefined>(defaultTimeFilter?.period);
+  const [from, setFrom] = useState<string | undefined>(defaultTimeFilter?.from);
+  const [to, setTo] = useState<string | undefined>(defaultTimeFilter?.to);
+
+  // Check if the query contains triggered_at in a WHERE clause
+  // This disables the time filter UI since the user is filtering in their query
+  const queryHasTriggeredAt = /\bWHERE\b[\s\S]*\btriggered_at\b/i.test(query);
+
+  // Expose methods to parent for external query setting (history, AI, examples)
+  useImperativeHandle(
+    ref,
+    () => ({
+      setQuery,
+      setScope,
+      getQuery: () => query,
+      setTimeFilter: (filter: { period?: string; from?: string; to?: string }) => {
+        setPeriod(filter.period);
+        setFrom(filter.from);
+        setTo(filter.to);
+      },
+    }),
+    [query]
+  );
+
+  const handleHistorySelected = useCallback(
+    (item: QueryHistoryItem) => {
+      setQuery(item.query);
+      setScope(item.scope);
+      // Apply time filter from history item
+      // Note: filterFrom/filterTo might be Date objects or ISO strings depending on serialization
+      setPeriod(item.filterPeriod ?? undefined);
+      setFrom(item.filterFrom ? toISOString(item.filterFrom) : undefined);
+      setTo(item.filterTo ? toISOString(item.filterTo) : undefined);
+      // Notify parent about history selection (for title)
+      onHistorySelected?.(item);
+    },
+    [onHistorySelected]
+  );
+
+  return (
+    <div className="flex h-full flex-col gap-2 bg-charcoal-900 pb-2">
+      <TSQLEditor
+        defaultValue={query}
+        onChange={setQuery}
+        schema={querySchemas}
+        linterEnabled={true}
+        showCopyButton={true}
+        showClearButton={true}
+        className="min-h-0 flex-1"
+      />
+      <fetcher.Form
+        ref={formRef}
+        method="post"
+        action={queryActionUrl}
+        className="flex items-center justify-between gap-2 px-2"
+      >
+        <input type="hidden" name="query" value={query} />
+        <input type="hidden" name="scope" value={scope} />
+        {/* Pass time filter values to action */}
+        <input type="hidden" name="period" value={period ?? ""} />
+        <input type="hidden" name="from" value={from ?? ""} />
+        <input type="hidden" name="to" value={to ?? ""} />
+        <QueryHistoryPopover history={history} onQuerySelected={handleHistorySelected} />
+        <div className="flex items-center gap-1">
+          {isAdmin && (
+            <Button
+              type="submit"
+              name="explain"
+              value="true"
+              variant="minimal/small"
+              disabled={isLoading || !query.trim()}
+            >
+              Explain
+            </Button>
+          )}
+          <Select
+            value={scope}
+            setValue={(value) => setScope(value as QueryScope)}
+            variant="secondary/small"
+            dropdownIcon={true}
+            items={[...scopeOptions]}
+            text={(value) => {
+              return <ScopeItem scope={value as QueryScope} />;
+            }}
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  <ScopeItem scope={item.value as QueryScope} />
+                </SelectItem>
+              ))
+            }
+          </Select>
+          {queryHasTriggeredAt ? (
+            <SimpleTooltip
+              asChild
+              button={
+                <span>
+                  <Button
+                    variant="secondary/small"
+                    disabled={true}
+                    type="button"
+                    LeadingIcon={CalendarIcon}
+                    leadingIconClassName="text-text-dimmed/70"
+                  >
+                    Set in query
+                  </Button>
+                </span>
+              }
+              className="max-w-48"
+              content="Your query includes a WHERE clause with triggered_at so this filter is disabled."
+            />
+          ) : (
+            <TimeFilter
+              defaultPeriod={defaultPeriod}
+              labelName="Triggered"
+              hideLabel
+              valueClassName="text-text-bright"
+              period={period}
+              from={from}
+              to={to}
+              applyShortcut={{ key: "enter", enabledOnInputElements: true }}
+              onValueChange={(values) => {
+                flushSync(() => {
+                  setPeriod(values.period);
+                  setFrom(values.from);
+                  setTo(values.to);
+                });
+                if (formRef.current) {
+                  fetcher.submit(formRef.current);
+                }
+              }}
+              maxPeriodDays={maxPeriodDays}
+            />
+          )}
+          <Button
+            type="submit"
+            variant="primary/small"
+            disabled={isLoading || !query.trim()}
+            shortcut={{ modifiers: ["mod"], key: "enter", enabledOnInputElements: true }}
+            className={
+              isLoading
+                ? "relative !text-transparent [&_*]:!border-transparent [&_*]:!text-transparent"
+                : undefined
+            }
+          >
+            {isLoading ? (
+              <>
+                Query
+                <span className="pointer-events-none absolute inset-0 flex items-center justify-center">
+                  <Spinner className="size-4 opacity-50" color="white" />
+                </span>
+              </>
+            ) : (
+              "Query"
+            )}
+          </Button>
+        </div>
+      </fetcher.Form>
+    </div>
+  );
+});
+
+export function QueryEditor({
+  defaultQuery,
+  defaultScope,
+  defaultPeriod,
+  defaultTimeFilter,
+  defaultResultsView = "table",
+  defaultChartConfig: initialChartConfig,
+  defaultBigNumberConfig: initialBigNumberConfig,
+  defaultData,
+  history,
+  isAdmin,
+  maxRows,
+  queryActionUrl,
+  mode,
+  maxPeriodDays,
+  save,
+  onClose,
+}: QueryEditorProps) {
+  const fetcher = useTypedFetcher<QueryActionResponse>();
+
+  // Use defaultData as initial results, then switch to fetcher data once a query is run
+  const fetcherResults = fetcher.data;
+  const results =
+    fetcherResults ??
+    (defaultData
+      ? {
+          error: null,
+          rows: defaultData.rows,
+          columns: defaultData.columns,
+          stats: null,
+          hiddenColumns: null,
+          reachedMaxRows: false,
+          explainOutput: null,
+          generatedSql: null,
+          queryId: null,
+          periodClipped: null,
+        }
+      : null);
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const editorRef = useRef<QueryEditorFormHandle>(null);
+  const [prettyFormatting, setPrettyFormatting] = useState(true);
+  const [resultsView, setResultsView] = useState<"table" | "graph" | "bignumber">(
+    defaultResultsView
+  );
+  const [chartConfig, setChartConfig] = useState<ChartConfiguration>(
+    initialChartConfig ?? defaultChartConfig
+  );
+  const [bigNumberConfig, setBigNumberConfig] = useState<BigNumberConfiguration>(
+    initialBigNumberConfig ?? { column: "", aggregation: "sum", abbreviate: true }
+  );
+  const [sidebarTab, setSidebarTab] = useState<string>("ai");
+  const [aiFixRequest, setAiFixRequest] = useState<{ prompt: string; key: number } | null>(null);
+
+  // Save to dashboard dialog state (only for standalone mode)
+  const [isSaveDialogOpen, setIsSaveDialogOpen] = useState(false);
+
+  // Title generation state
+  const titleFetcher = useFetcher<typeof titleAction>();
+  const isTitleLoading = titleFetcher.state !== "idle";
+  const generatedTitle = titleFetcher.data?.title;
+  const [historyTitle, setHistoryTitle] = useState<string | null>(
+    history.length > 0 ? history[0].title ?? null : null
+  );
+
+  // For edit mode, use the widget name as initial title
+  const initialTitle = mode.type === "dashboard-edit" ? mode.widgetName : null;
+  const [editModeTitle, setEditModeTitle] = useState<string | null>(initialTitle);
+
+  // User-set title (takes priority, and disables AI regeneration)
+  const [userTitle, setUserTitle] = useState<string | null>(null);
+
+  // Effective title: user title > edit mode title > history title > generated title
+  const queryTitle =
+    userTitle ??
+    (mode.type === "dashboard-edit"
+      ? editModeTitle ?? historyTitle ?? generatedTitle ?? null
+      : historyTitle ?? generatedTitle ?? null);
+
+  // Track if user has manually set a title (disables AI regeneration)
+  const hasUserTitle = userTitle !== null;
+
+  // Track whether we should generate a title for the current results
+  const [shouldGenerateTitle, setShouldGenerateTitle] = useState(false);
+
+  // Trigger title generation when query succeeds (only for new queries, not history, not if user set title)
+  useEffect(() => {
+    if (
+      results?.rows &&
+      !results.error &&
+      results.queryId &&
+      shouldGenerateTitle &&
+      !historyTitle &&
+      !hasUserTitle &&
+      titleFetcher.state === "idle"
+    ) {
+      const currentQuery = editorRef.current?.getQuery();
+      if (currentQuery) {
+        titleFetcher.submit(
+          { query: currentQuery, queryId: results.queryId },
+          {
+            method: "POST",
+            action: `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/query/ai-title`,
+            encType: "application/json",
+          }
+        );
+        setShouldGenerateTitle(false);
+      }
+    }
+  }, [
+    results,
+    shouldGenerateTitle,
+    historyTitle,
+    hasUserTitle,
+    titleFetcher,
+    organization.slug,
+    project.slug,
+    environment.slug,
+  ]);
+
+  const handleTryFixError = useCallback((errorMessage: string) => {
+    setSidebarTab("ai");
+    setAiFixRequest((prev) => ({
+      prompt: `Fix this query error: ${errorMessage}`,
+      key: (prev?.key ?? 0) + 1,
+    }));
+  }, []);
+
+  // Handle time filter changes from AI
+  const handleTimeFilterChange = useCallback((filter: AITimeFilter) => {
+    editorRef.current?.setTimeFilter({
+      period: filter.period,
+      from: filter.from,
+      to: filter.to,
+    });
+  }, []);
+
+  const isLoading = fetcher.state === "submitting" || fetcher.state === "loading";
+
+  // Stable string key of result column names (types excluded — they can vary between runs)
+  const columnNamesKey = results?.columns ? results.columns.map((c) => c.name).join(",") : "";
+
+  // Use a ref so the effect can read chartConfig without re-firing on every config tweak
+  const chartConfigRef = useRef(chartConfig);
+  chartConfigRef.current = chartConfig;
+
+  // Reset chart config only when a column referenced by the current config is no
+  // longer present in the results. This means:
+  // - Re-running the same query preserves all settings
+  // - Adding new columns preserves settings (existing config columns still exist)
+  // - Removing/renaming a column used in the config triggers a reset
+  useEffect(() => {
+    if (!columnNamesKey || initialChartConfig) return;
+
+    const config = chartConfigRef.current;
+    const configColumns = [
+      config.xAxisColumn,
+      ...config.yAxisColumns,
+      config.groupByColumn,
+      config.sortByColumn,
+    ].filter((col): col is string => col != null);
+
+    // Nothing configured yet — ChartConfigPanel will auto-select defaults
+    if (configColumns.length === 0) return;
+
+    const availableColumns = new Set(columnNamesKey.split(","));
+    if (configColumns.some((col) => !availableColumns.has(col))) {
+      setChartConfig(defaultChartConfig);
+    }
+  }, [columnNamesKey, initialChartConfig]);
+
+  const handleChartConfigChange = useCallback((config: ChartConfiguration) => {
+    setChartConfig(config);
+  }, []);
+
+  // Handle query submission - prepare for title generation
+  const handleQuerySubmit = useCallback(() => {
+    setHistoryTitle(null); // Clear history title when running a new query
+    setEditModeTitle(null); // Clear edit mode title when running a new query
+    // Only enable title generation if user hasn't manually set a title
+    // userTitle persists across query edits once set
+    setShouldGenerateTitle(!hasUserTitle);
+  }, [hasUserTitle]);
+
+  // Handle history selection - use existing title if available
+  const handleHistorySelected = useCallback((item: QueryHistoryItem) => {
+    setHistoryTitle(item.title ?? null);
+    setEditModeTitle(null);
+    setUserTitle(null); // Clear user title when selecting from history
+    setShouldGenerateTitle(false); // Don't generate title for history items
+  }, []);
+
+  // Handle user renaming the title
+  const handleRenameTitle = useCallback((newTitle: string) => {
+    setUserTitle(newTitle);
+    // Clear other title sources since user has explicitly set the title
+    setHistoryTitle(null);
+    setEditModeTitle(null);
+  }, []);
+
+  // Compute current save data for the save render prop
+  const currentQuery = editorRef.current?.getQuery() ?? "";
+  const saveData: QueryEditorSaveData = {
+    title: queryTitle ?? "Untitled Query",
+    query: currentQuery,
+    config:
+      resultsView === "table"
+        ? { type: "table", prettyFormatting, sorting: [] }
+        : resultsView === "bignumber"
+        ? { type: "bignumber", ...bigNumberConfig }
+        : { type: "chart", ...chartConfig },
+  };
+
+  // Render NavBar based on mode
+  const renderNavBar = () => {
+    switch (mode.type) {
+      case "standalone":
+        return (
+          <NavBar>
+            <PageTitle title="Query" />
+          </NavBar>
+        );
+      case "dashboard-add":
+        return (
+          <NavBar>
+            <PageTitle title={`Add chart to ${mode.dashboardName}`} />
+            <PageAccessories>
+              <Button
+                variant="secondary/small"
+                onClick={onClose}
+                shortcut={{ key: "esc" }}
+                shortcutPosition="before-trailing-icon"
+                // className="pl-1"
+              >
+                Cancel
+              </Button>
+            </PageAccessories>
+          </NavBar>
+        );
+      case "dashboard-edit":
+        return (
+          <NavBar>
+            <PageTitle title={`Editing "${mode.widgetName}"`} />
+            <PageAccessories>
+              <Button
+                variant="secondary/small"
+                onClick={onClose}
+                shortcut={{ key: "esc" }}
+                shortcutPosition="before-trailing-icon"
+                // className="pl-1"
+              >
+                Cancel
+              </Button>
+            </PageAccessories>
+          </NavBar>
+        );
+    }
+  };
+
+  return (
+    <PageContainer>
+      {renderNavBar()}
+      <PageBody scrollable={false}>
+        <ResizablePanelGroup orientation="horizontal" className="h-full max-h-full bg-charcoal-800">
+          <ResizablePanel id="query-main" className="h-full">
+            <ResizablePanelGroup orientation="vertical" className="h-full overflow-hidden">
+              {/* Query editor - isolated component to prevent re-renders */}
+              <ResizablePanel
+                id="query-editor"
+                min="100px"
+                default="300px"
+                className="overflow-hidden"
+              >
+                <QueryEditorForm
+                  ref={editorRef}
+                  defaultPeriod={defaultPeriod}
+                  defaultQuery={defaultQuery}
+                  defaultScope={defaultScope}
+                  defaultTimeFilter={defaultTimeFilter}
+                  history={history}
+                  fetcher={fetcher}
+                  isAdmin={isAdmin}
+                  queryActionUrl={queryActionUrl}
+                  maxPeriodDays={maxPeriodDays}
+                  onQuerySubmit={handleQuerySubmit}
+                  onHistorySelected={handleHistorySelected}
+                />
+              </ResizablePanel>
+              <ResizableHandle id="query-editor-handle" />
+              {/* Results */}
+              <ResizablePanel
+                id="query-results"
+                min="200px"
+                className="overflow-hidden bg-charcoal-800"
+              >
+                <ClientTabs
+                  value={resultsView}
+                  onValueChange={(v) => setResultsView(v as "table" | "graph" | "bignumber")}
+                  className="grid h-full max-h-full min-h-0 grid-rows-[auto_1fr] overflow-hidden"
+                >
+                  <ClientTabsList
+                    variant="underline"
+                    className="shrink-0 overflow-hidden pl-3 pr-1"
+                  >
+                    <ClientTabsTrigger value="table" variant="underline" layoutId="results-tabs">
+                      Table
+                    </ClientTabsTrigger>
+                    <ClientTabsTrigger
+                      value="graph"
+                      variant="underline"
+                      layoutId="results-tabs"
+                      disabled={!results?.rows || results.rows.length === 0}
+                    >
+                      Graph
+                    </ClientTabsTrigger>
+                    <ClientTabsTrigger
+                      value="bignumber"
+                      variant="underline"
+                      layoutId="results-tabs"
+                      disabled={!results?.rows || results.rows.length === 0}
+                    >
+                      Big number
+                    </ClientTabsTrigger>
+                    {results?.rows ? (
+                      <div className="flex flex-1 items-center justify-end gap-2 overflow-hidden border-b border-grid-dimmed pl-3">
+                        <div className="flex items-center gap-2 overflow-hidden truncate">
+                          {results.reachedMaxRows ? (
+                            <SimpleTooltip
+                              buttonClassName="text-warning text-xs"
+                              button={`${results.rows.length.toLocaleString()} Results`}
+                              content={`Results are limited to ${maxRows.toLocaleString()} rows maximum.`}
+                            />
+                          ) : (
+                            <span className="text-xs text-text-dimmed">
+                              {results.rows.length > 0
+                                ? `${results.rows.length.toLocaleString()} Results`
+                                : "Results"}
+                            </span>
+                          )}
+                          {results?.stats && (
+                            <span className="text-xs text-text-dimmed">
+                              {formatDurationNanoseconds(parseInt(results.stats.elapsed_ns, 10))}
+                            </span>
+                          )}
+                        </div>
+                        <div className="flex items-center gap-1">
+                          {results?.rows && results?.columns && results.rows.length > 0 && (
+                            <ExportResultsButton rows={results.rows} columns={results.columns} />
+                          )}
+                          {resultsView === "table" && (
+                            <Switch
+                              variant="tertiary/small"
+                              label="Pretty formatting"
+                              checked={prettyFormatting}
+                              onCheckedChange={setPrettyFormatting}
+                            />
+                          )}
+                        </div>
+                      </div>
+                    ) : null}
+                  </ClientTabsList>
+                  <ClientTabsContent value="table" className="m-0 min-h-0 overflow-y-hidden">
+                    {isLoading ? (
+                      <div className="flex items-center gap-2 p-4 text-sm text-text-dimmed">
+                        <Spinner className="size-4" />
+                        <span>Executing query…</span>
+                      </div>
+                    ) : results?.error ? (
+                      <div className="p-4">
+                        <pre className="whitespace-pre-wrap text-sm text-red-400">
+                          {results.error}
+                        </pre>
+                        <Button
+                          variant="tertiary/small"
+                          className="mt-3"
+                          LeadingIcon={AISparkleIcon}
+                          onClick={() => handleTryFixError(results.error!)}
+                        >
+                          Try fix error
+                        </Button>
+                      </div>
+                    ) : results?.explainOutput ? (
+                      <div className="flex h-full flex-col gap-4 overflow-auto p-3">
+                        {results.generatedSql && (
+                          <div>
+                            <Header3 className="mb-2">Generated ClickHouse SQL</Header3>
+                            <div className="overflow-auto rounded border border-grid-dimmed bg-charcoal-900 p-3">
+                              <pre className="whitespace-pre font-mono text-xs text-text-bright">
+                                {results.generatedSql}
+                              </pre>
+                            </div>
+                          </div>
+                        )}
+                        <div className="flex min-h-0 flex-1 flex-col">
+                          <Header3 className="mb-2">Query Execution Plan</Header3>
+                          <div className="min-h-0 flex-1 overflow-auto rounded border border-grid-dimmed bg-charcoal-900 p-3">
+                            <pre className="whitespace-pre font-mono text-xs text-text-bright">
+                              {results.explainOutput}
+                            </pre>
+                          </div>
+                        </div>
+                      </div>
+                    ) : results?.rows && results?.columns ? (
+                      <div
+                        className={`grid h-full max-h-full overflow-hidden bg-background-bright ${
+                          hasQueryResultsCallouts(results.hiddenColumns, results.periodClipped)
+                            ? "grid-rows-[auto_1fr]"
+                            : "grid-rows-[1fr]"
+                        }`}
+                      >
+                        <QueryResultsCallouts
+                          hiddenColumns={results.hiddenColumns}
+                          periodClipped={results.periodClipped}
+                          organizationSlug={organization.slug}
+                        />
+                        <div className="overflow-hidden">
+                          <QueryWidget
+                            className="border-0"
+                            showTableHeaderOnEmpty
+                            title={
+                              <QueryTitle
+                                isTitleLoading={isTitleLoading}
+                                title={queryTitle}
+                                onRename={handleRenameTitle}
+                              />
+                            }
+                            query={editorRef.current?.getQuery() ?? defaultQuery}
+                            data={{
+                              rows: results.rows,
+                              columns: results.columns,
+                            }}
+                            config={{
+                              type: "table",
+                              prettyFormatting,
+                              sorting: [],
+                            }}
+                            accessory={
+                              mode.type === "standalone" ? (
+                                <Button
+                                  variant="primary/small"
+                                  onClick={() => setIsSaveDialogOpen(true)}
+                                >
+                                  Add to dashboard
+                                </Button>
+                              ) : save ? (
+                                save(saveData)
+                              ) : undefined
+                            }
+                          />
+                        </div>
+                      </div>
+                    ) : (
+                      <div className="flex h-full flex-col items-center justify-center gap-3">
+                        <IconChartHistogram className="size-16 text-charcoal-650" />
+                        <Paragraph className="max-w-48 text-center text-text-dimmed">
+                          Run a query to visualize the results.
+                        </Paragraph>
+                      </div>
+                    )}
+                  </ClientTabsContent>
+                  <ClientTabsContent
+                    value="graph"
+                    className={`m-0 grid h-full max-h-full min-h-0 overflow-hidden bg-background-bright ${
+                      results?.rows &&
+                      results.rows.length > 0 &&
+                      hasQueryResultsCallouts(results.hiddenColumns, results.periodClipped)
+                        ? "grid-rows-[auto_1fr]"
+                        : "grid-rows-[1fr]"
+                    }`}
+                  >
+                    {results?.rows && results?.columns && results.rows.length > 0 ? (
+                      <>
+                        <QueryResultsCallouts
+                          hiddenColumns={results.hiddenColumns}
+                          periodClipped={results.periodClipped}
+                          organizationSlug={organization.slug}
+                        />
+                        <ResultsChart
+                          rows={results.rows}
+                          columns={results.columns}
+                          query={editorRef.current?.getQuery() ?? defaultQuery}
+                          chartConfig={chartConfig}
+                          onChartConfigChange={handleChartConfigChange}
+                          queryTitle={queryTitle}
+                          isTitleLoading={isTitleLoading}
+                          onRenameTitle={handleRenameTitle}
+                          accessory={
+                            mode.type === "standalone" ? (
+                              <Button
+                                variant="primary/small"
+                                onClick={() => setIsSaveDialogOpen(true)}
+                              >
+                                Add to dashboard
+                              </Button>
+                            ) : save ? (
+                              save(saveData)
+                            ) : undefined
+                          }
+                        />
+                      </>
+                    ) : (
+                      <div className="flex h-full flex-col items-center justify-center gap-3">
+                        <IconChartHistogram className="size-16 text-charcoal-650" />
+                        <Paragraph className="max-w-48 text-center text-text-dimmed">
+                          Run a query to visualize the results.
+                        </Paragraph>
+                      </div>
+                    )}
+                  </ClientTabsContent>
+                  <ClientTabsContent
+                    value="bignumber"
+                    className={`m-0 grid h-full max-h-full min-h-0 overflow-hidden bg-background-bright ${
+                      results?.rows &&
+                      results.rows.length > 0 &&
+                      hasQueryResultsCallouts(results.hiddenColumns, results.periodClipped)
+                        ? "grid-rows-[auto_1fr]"
+                        : "grid-rows-[1fr]"
+                    }`}
+                  >
+                    {results?.rows && results?.columns && results.rows.length > 0 ? (
+                      <>
+                        <QueryResultsCallouts
+                          hiddenColumns={results.hiddenColumns}
+                          periodClipped={results.periodClipped}
+                          organizationSlug={organization.slug}
+                        />
+                        <ResultsBigNumber
+                          rows={results.rows}
+                          columns={results.columns}
+                          query={editorRef.current?.getQuery() ?? defaultQuery}
+                          bigNumberConfig={bigNumberConfig}
+                          onBigNumberConfigChange={setBigNumberConfig}
+                          queryTitle={queryTitle}
+                          isTitleLoading={isTitleLoading}
+                          onRenameTitle={handleRenameTitle}
+                          accessory={
+                            mode.type === "standalone" ? (
+                              <Button
+                                variant="primary/small"
+                                onClick={() => setIsSaveDialogOpen(true)}
+                              >
+                                Add to dashboard
+                              </Button>
+                            ) : save ? (
+                              save(saveData)
+                            ) : undefined
+                          }
+                        />
+                      </>
+                    ) : (
+                      <div className="flex h-full flex-col items-center justify-center gap-3">
+                        <IconChartHistogram className="size-16 text-charcoal-650" />
+                        <Paragraph className="max-w-48 text-center text-text-dimmed">
+                          Run a query to visualize the results.
+                        </Paragraph>
+                      </div>
+                    )}
+                  </ClientTabsContent>
+                </ClientTabs>
+              </ResizablePanel>
+            </ResizablePanelGroup>
+          </ResizablePanel>
+          <ResizableHandle id="query-handle" />
+          <ResizablePanel
+            id="query-help"
+            min="380px"
+            default="400px"
+            max="800px"
+            className="w-full"
+          >
+            <QueryHelpSidebar
+              onTryExample={(exampleQuery, exampleScope) => {
+                editorRef.current?.setQuery(exampleQuery);
+                editorRef.current?.setScope(exampleScope);
+              }}
+              onQueryGenerated={(query) => {
+                const formatted = autoFormatSQL(query);
+                editorRef.current?.setQuery(formatted);
+              }}
+              onTimeFilterChange={handleTimeFilterChange}
+              getCurrentQuery={() => editorRef.current?.getQuery() ?? ""}
+              activeTab={sidebarTab}
+              onTabChange={setSidebarTab}
+              aiFixRequest={aiFixRequest}
+            />
+          </ResizablePanel>
+        </ResizablePanelGroup>
+      </PageBody>
+      {mode.type === "standalone" && (
+        <SaveToDashboardDialog
+          title={queryTitle ?? "Untitled Query"}
+          query={editorRef.current?.getQuery() ?? ""}
+          config={
+            resultsView === "table"
+              ? { type: "table", prettyFormatting, sorting: [] }
+              : resultsView === "bignumber"
+              ? { type: "bignumber", ...bigNumberConfig }
+              : { type: "chart", ...chartConfig }
+          }
+          isOpen={isSaveDialogOpen}
+          onOpenChange={setIsSaveDialogOpen}
+        />
+      )}
+    </PageContainer>
+  );
+}
+
+function QueryTitle({
+  isTitleLoading,
+  title,
+  onRename,
+}: {
+  isTitleLoading: boolean;
+  title: string | null;
+  onRename?: (newTitle: string) => void;
+}) {
+  const [isDialogOpen, setIsDialogOpen] = useState(false);
+  const [renameValue, setRenameValue] = useState(title ?? "");
+
+  // Update rename value when title changes
+  useEffect(() => {
+    setRenameValue(title ?? "");
+  }, [title]);
+
+  if (isTitleLoading)
+    return (
+      <span className="flex items-center gap-2 text-text-dimmed">
+        <Spinner className="size-4" /> Generating title…
+      </span>
+    );
+
+  return (
+    <>
+      <span className="group flex items-center gap-1">
+        {title ?? "Results"}
+        {onRename && title && (
+          <Button
+            variant="minimal/small"
+            LeadingIcon={PencilSquareIcon}
+            leadingIconClassName="text-text-dimmed group-hover/button:text-text-bright"
+            className="opacity-0 transition-opacity group-hover:opacity-100"
+            onClick={() => {
+              setRenameValue(title);
+              setIsDialogOpen(true);
+            }}
+          />
+        )}
+      </span>
+      {onRename && (
+        <Dialog open={isDialogOpen} onOpenChange={setIsDialogOpen}>
+          <DialogContent className="sm:max-w-md">
+            <DialogHeader>Rename chart</DialogHeader>
+            <form
+              className="space-y-4 pt-3"
+              onSubmit={(e) => {
+                e.preventDefault();
+                if (renameValue.trim()) {
+                  onRename(renameValue.trim());
+                  setIsDialogOpen(false);
+                }
+              }}
+            >
+              <InputGroup>
+                <Label>Title</Label>
+                <Input
+                  value={renameValue}
+                  onChange={(e) => setRenameValue(e.target.value)}
+                  placeholder="Chart title"
+                  autoFocus
+                />
+              </InputGroup>
+              <DialogFooter>
+                <DialogClose asChild>
+                  <Button variant="secondary/medium">Cancel</Button>
+                </DialogClose>
+                <Button type="submit" variant="primary/medium" disabled={!renameValue.trim()}>
+                  Save
+                </Button>
+              </DialogFooter>
+            </form>
+          </DialogContent>
+        </Dialog>
+      )}
+    </>
+  );
+}
+
+function ExportResultsButton({
+  rows,
+  columns,
+}: {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+
+  const handleCopyCSV = () => {
+    const csv = rowsToCSV(rows, columns);
+    navigator.clipboard.writeText(csv);
+    setIsOpen(false);
+  };
+
+  const handleExportCSV = () => {
+    const csv = rowsToCSV(rows, columns);
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/[:-]/g, "");
+    downloadFile(csv, `query-results-${timestamp}.csv`, "text/csv");
+    setIsOpen(false);
+  };
+
+  const handleCopyJSON = () => {
+    const json = rowsToJSON(rows);
+    navigator.clipboard.writeText(json);
+    setIsOpen(false);
+  };
+
+  const handleExportJSON = () => {
+    const json = rowsToJSON(rows);
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/[:-]/g, "");
+    downloadFile(json, `query-results-${timestamp}.json`, "application/json");
+    setIsOpen(false);
+  };
+
+  return (
+    <Popover open={isOpen} onOpenChange={setIsOpen}>
+      <PopoverArrowTrigger variant="minimal" isOpen={isOpen}>
+        Export
+      </PopoverArrowTrigger>
+      <PopoverContent className="min-w-[10rem] p-1" align="end">
+        <div className="flex flex-col gap-1">
+          <PopoverMenuItem
+            icon={Clipboard}
+            title="Copy CSV"
+            onClick={handleCopyCSV}
+            className="pl-1"
+          />
+          <PopoverMenuItem icon={ArrowDownTrayIcon} title="Export CSV" onClick={handleExportCSV} />
+          <PopoverMenuItem
+            icon={Clipboard}
+            title="Copy JSON"
+            onClick={handleCopyJSON}
+            className="pl-1"
+          />
+          <PopoverMenuItem
+            icon={ArrowDownTrayIcon}
+            title="Export JSON"
+            onClick={handleExportJSON}
+          />
+        </div>
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function ScopeItem({ scope }: { scope: QueryScope }) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  switch (scope) {
+    case "organization":
+      return <span className="text-text-bright">{`Org: ${organization.title}`}</span>;
+    case "project":
+      return <span className="text-text-bright">{`Project: ${project.name}`}</span>;
+    case "environment":
+      return (
+        <span className="text-text-bright">
+          Env: <EnvironmentLabel environment={environment} />
+        </span>
+      );
+    default:
+      return <span className="text-text-bright">{scope}</span>;
+  }
+}
+
+function QueryResultsCallouts({
+  hiddenColumns,
+  periodClipped,
+  organizationSlug,
+}: {
+  hiddenColumns: string[] | null | undefined;
+  periodClipped: number | null;
+  organizationSlug: string;
+}) {
+  const hasCallouts = (hiddenColumns && hiddenColumns.length > 0) || periodClipped;
+
+  if (!hasCallouts) {
+    return null;
+  }
+
+  return (
+    <div className="flex flex-col gap-2 px-2 pt-2">
+      {hiddenColumns && hiddenColumns.length > 0 && (
+        <Callout variant="warning" className="shrink-0 text-sm">
+          <code>SELECT *</code> returns core columns only. To include{" "}
+          <span className="font-mono text-xs">{hiddenColumns.join(", ")}</span>, add them to your
+          SELECT explicitly.
+        </Callout>
+      )}
+      {periodClipped && (
+        <Callout
+          variant="pricing"
+          cta={
+            <LinkButton
+              variant="primary/small"
+              to={organizationBillingPath({ slug: organizationSlug })}
+            >
+              Upgrade
+            </LinkButton>
+          }
+          className="items-center"
+        >
+          {simplur`Results are limited to the last ${periodClipped} day[|s] based on your plan.`}
+        </Callout>
+      )}
+    </div>
+  );
+}
+
+function hasQueryResultsCallouts(
+  hiddenColumns: string[] | null | undefined,
+  periodClipped: number | null
+): boolean {
+  return (hiddenColumns && hiddenColumns.length > 0) || !!periodClipped;
+}
+
+function ResultsChart({
+  rows,
+  columns,
+  query,
+  chartConfig,
+  onChartConfigChange,
+  queryTitle,
+  isTitleLoading,
+  onRenameTitle,
+  accessory,
+}: {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+  query?: string;
+  chartConfig: ChartConfiguration;
+  onChartConfigChange: (config: ChartConfiguration) => void;
+  queryTitle: string | null;
+  isTitleLoading: boolean;
+  onRenameTitle?: (newTitle: string) => void;
+  accessory?: ReactNode;
+}) {
+  return (
+    <>
+      <ResizablePanelGroup className="overflow-hidden">
+        <ResizablePanel id="chart-results">
+          <div className="h-full overflow-hidden bg-background-bright">
+            <QueryWidget
+              className="border-0"
+              title={
+                <QueryTitle
+                  isTitleLoading={isTitleLoading}
+                  title={queryTitle}
+                  onRename={onRenameTitle}
+                />
+              }
+              query={query}
+              data={{
+                rows,
+                columns,
+              }}
+              config={{
+                type: "chart",
+                ...chartConfig,
+              }}
+              accessory={accessory}
+            />
+          </div>
+        </ResizablePanel>
+        <ResizableHandle id="chart-split" />
+        <ResizablePanel id="chart-config" min="50px" default="200px">
+          <ChartConfigPanel columns={columns} config={chartConfig} onChange={onChartConfigChange} />
+        </ResizablePanel>
+      </ResizablePanelGroup>
+    </>
+  );
+}
+
+function isNumericColumnType(type: string): boolean {
+  return (
+    type.startsWith("Int") ||
+    type.startsWith("UInt") ||
+    type.startsWith("Float") ||
+    type.startsWith("Decimal") ||
+    type.startsWith("Nullable(Int") ||
+    type.startsWith("Nullable(UInt") ||
+    type.startsWith("Nullable(Float") ||
+    type.startsWith("Nullable(Decimal")
+  );
+}
+
+function ResultsBigNumber({
+  rows,
+  columns,
+  query,
+  bigNumberConfig,
+  onBigNumberConfigChange,
+  queryTitle,
+  isTitleLoading,
+  onRenameTitle,
+  accessory,
+}: {
+  rows: Record<string, unknown>[];
+  columns: OutputColumnMetadata[];
+  query?: string;
+  bigNumberConfig: BigNumberConfiguration;
+  onBigNumberConfigChange: (config: BigNumberConfiguration) => void;
+  queryTitle: string | null;
+  isTitleLoading: boolean;
+  onRenameTitle?: (newTitle: string) => void;
+  accessory?: ReactNode;
+}) {
+  // Auto-select first numeric column if none selected
+  const numericColumns = columns.filter((c) => isNumericColumnType(c.type));
+
+  useEffect(() => {
+    if (!bigNumberConfig.column && numericColumns.length > 0) {
+      onBigNumberConfigChange({ ...bigNumberConfig, column: numericColumns[0].name });
+    }
+  }, [columns]);
+
+  return (
+    <>
+      <ResizablePanelGroup className="overflow-hidden">
+        <ResizablePanel id="bignumber-results">
+          <div className="h-full overflow-hidden bg-background-bright">
+            <QueryWidget
+              className="border-0"
+              title={
+                <QueryTitle
+                  isTitleLoading={isTitleLoading}
+                  title={queryTitle}
+                  onRename={onRenameTitle}
+                />
+              }
+              query={query}
+              data={{
+                rows,
+                columns,
+              }}
+              config={{
+                type: "bignumber",
+                ...bigNumberConfig,
+              }}
+              accessory={accessory}
+            />
+          </div>
+        </ResizablePanel>
+        <ResizableHandle id="bignumber-split" />
+        <ResizablePanel id="bignumber-config" min="50px" default="200px">
+          <BigNumberConfigPanel
+            columns={columns}
+            config={bigNumberConfig}
+            onChange={onBigNumberConfigChange}
+          />
+        </ResizablePanel>
+      </ResizablePanelGroup>
+    </>
+  );
+}
+
+const bigNumberAggregationOptions = [
+  { value: "sum", label: "Sum" },
+  { value: "avg", label: "Average" },
+  { value: "count", label: "Count" },
+  { value: "min", label: "Min" },
+  { value: "max", label: "Max" },
+  { value: "first", label: "First" },
+  { value: "last", label: "Last" },
+] as const;
+
+const bigNumberSortOptions = [
+  { value: "", label: "Unsorted" },
+  { value: "asc", label: "Ascending" },
+  { value: "desc", label: "Descending" },
+] as const;
+
+function BigNumberConfigPanel({
+  columns,
+  config,
+  onChange,
+}: {
+  columns: OutputColumnMetadata[];
+  config: BigNumberConfiguration;
+  onChange: (config: BigNumberConfiguration) => void;
+}) {
+  const numericColumns = columns.filter((c) => isNumericColumnType(c.type));
+  const allColumns = columns;
+
+  // For count aggregation, any column works; for others, prefer numeric
+  const availableColumns = config.aggregation === "count" ? allColumns : numericColumns;
+
+  return (
+    <div className="flex h-full flex-col gap-2 overflow-y-auto p-2">
+      <div className="flex flex-col gap-3">
+        <div className="flex flex-col gap-1">
+          <Paragraph variant="extra-small" className="text-text-bright">
+            Column
+          </Paragraph>
+          <Select
+            value={config.column || ""}
+            setValue={(value) => onChange({ ...config, column: value })}
+            variant="tertiary/small"
+            dropdownIcon={true}
+            items={availableColumns.map((c) => ({ value: c.name, label: c.name }))}
+            text={(value) => value || "Select column"}
+            placeholder="Select column"
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  {item.label}
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </div>
+        <div className="flex flex-col gap-1">
+          <Paragraph variant="extra-small" className="text-text-bright">
+            Sort order
+          </Paragraph>
+          <Select
+            value={config.sortDirection ?? ""}
+            setValue={(value) =>
+              onChange({
+                ...config,
+                sortDirection: value === "" ? undefined : (value as "asc" | "desc"),
+              })
+            }
+            variant="tertiary/small"
+            dropdownIcon={true}
+            items={[...bigNumberSortOptions]}
+            text={(value) =>
+              bigNumberSortOptions.find((o) => o.value === value)?.label ?? "Unsorted"
+            }
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  {item.label}
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </div>
+        <div className="flex flex-col gap-1">
+          <Paragraph variant="extra-small" className="text-text-bright">
+            Aggregation
+          </Paragraph>
+          <Select
+            value={config.aggregation}
+            setValue={(value) =>
+              onChange({ ...config, aggregation: value as BigNumberConfiguration["aggregation"] })
+            }
+            variant="tertiary/small"
+            dropdownIcon={true}
+            items={[...bigNumberAggregationOptions]}
+            text={(value) =>
+              bigNumberAggregationOptions.find((o) => o.value === value)?.label ?? value
+            }
+          >
+            {(items) =>
+              items.map((item) => (
+                <SelectItem key={item.value} value={item.value}>
+                  {item.label}
+                </SelectItem>
+              ))
+            }
+          </Select>
+        </div>
+        <div className="flex items-center justify-between">
+          <Switch
+            label="Abbreviate large values"
+            labelPosition="right"
+            variant="small"
+            checked={config.abbreviate ?? false}
+            onCheckedChange={(checked) => onChange({ ...config, abbreviate: checked })}
+          />
+        </div>
+        <div className="flex flex-col gap-1">
+          <Paragraph variant="extra-small" className="text-text-bright">
+            Prefix
+          </Paragraph>
+          <Input
+            value={config.prefix ?? ""}
+            onChange={(e) => onChange({ ...config, prefix: e.target.value || undefined })}
+            placeholder="e.g. $"
+            variant="small"
+          />
+        </div>
+        <div className="flex flex-col gap-1">
+          <Paragraph variant="extra-small" className="text-text-bright">
+            Suffix
+          </Paragraph>
+          <Input
+            value={config.suffix ?? ""}
+            onChange={(e) => onChange({ ...config, suffix: e.target.value || undefined })}
+            placeholder="e.g. ms"
+            variant="small"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/EnabledStatus.tsx b/apps/webapp/app/components/runs/v3/EnabledStatus.tsx
index 9e1f7163239..ff902147f19 100644
--- a/apps/webapp/app/components/runs/v3/EnabledStatus.tsx
+++ b/apps/webapp/app/components/runs/v3/EnabledStatus.tsx
@@ -1,4 +1,4 @@
-import { BoltSlashIcon, CheckCircleIcon } from "@heroicons/react/20/solid";
+import { NoSymbolIcon, CheckIcon } from "@heroicons/react/20/solid";
 
 type EnabledStatusProps = {
   enabled: boolean;
@@ -8,8 +8,8 @@ type EnabledStatusProps = {
 
 export function EnabledStatus({
   enabled,
-  enabledIcon = CheckCircleIcon,
-  disabledIcon = BoltSlashIcon,
+  enabledIcon = CheckIcon,
+  disabledIcon = NoSymbolIcon,
 }: EnabledStatusProps) {
   const EnabledIcon = enabledIcon;
   const DisabledIcon = disabledIcon;
diff --git a/apps/webapp/app/components/runs/v3/PacketDisplay.tsx b/apps/webapp/app/components/runs/v3/PacketDisplay.tsx
index 24a9b66b679..82deae8a1be 100644
--- a/apps/webapp/app/components/runs/v3/PacketDisplay.tsx
+++ b/apps/webapp/app/components/runs/v3/PacketDisplay.tsx
@@ -11,10 +11,14 @@ export function PacketDisplay({
   data,
   dataType,
   title,
+  searchTerm,
+  wrap,
 }: {
   data: string;
   dataType: string;
   title: string;
+  searchTerm?: string;
+  wrap?: boolean;
 }) {
   switch (dataType) {
     case "application/store": {
@@ -51,6 +55,8 @@ export function PacketDisplay({
           maxLines={20}
           showLineNumbers={false}
           showTextWrapping
+          searchTerm={searchTerm}
+          wrap={wrap}
         />
       );
     }
@@ -63,6 +69,8 @@ export function PacketDisplay({
           maxLines={20}
           showLineNumbers={false}
           showTextWrapping
+          searchTerm={searchTerm}
+          wrap={wrap}
         />
       );
     }
diff --git a/apps/webapp/app/components/runs/v3/PromptSpanDetails.tsx b/apps/webapp/app/components/runs/v3/PromptSpanDetails.tsx
new file mode 100644
index 00000000000..9645087b859
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/PromptSpanDetails.tsx
@@ -0,0 +1,158 @@
+import { lazy, Suspense, useState } from "react";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { Header3 } from "~/components/primitives/Headers";
+import { TextLink } from "~/components/primitives/TextLink";
+import { tryPrettyJson } from "./ai/aiHelpers";
+import { SpanMetricRow as MetricRow } from "./ai/SpanMetricRow";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { v3PromptPath } from "~/utils/pathBuilder";
+import { TabButton, TabContainer } from "~/components/primitives/Tabs";
+import type { PromptSpanData } from "~/presenters/v3/SpanPresenter.server";
+import { SpanHorizontalTimeline } from "~/components/runs/v3/SpanHorizontalTimeline";
+
+const StreamdownRenderer = lazy(() =>
+  import("streamdown").then((mod) => ({
+    default: ({ children }: { children: string }) => (
+      <mod.ShikiThemeContext.Provider value={["one-dark-pro", "one-dark-pro"]}>
+        <mod.Streamdown isAnimating={false}>{children}</mod.Streamdown>
+      </mod.ShikiThemeContext.Provider>
+    ),
+  }))
+);
+
+type PromptTab = "overview" | "input" | "template";
+
+export function PromptSpanDetails({
+  promptData,
+  startTime,
+  duration,
+}: {
+  promptData: PromptSpanData;
+  startTime?: string | Date;
+  duration?: number | null;
+}) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const promptPath =
+    organization && project && environment
+      ? v3PromptPath(organization, project, environment, promptData.slug, promptData.version)
+      : undefined;
+
+  const hasInput = !!promptData.input;
+  const hasTemplate = !!promptData.template;
+
+  const availableTabs: PromptTab[] = [
+    "overview",
+    ...(hasInput ? (["input"] as const) : []),
+    ...(hasTemplate ? (["template"] as const) : []),
+  ];
+  const [tab, setTab] = useState<PromptTab>("overview");
+
+  const labels = promptData.labels
+    ? promptData.labels
+        .split(",")
+        .map((l) => l.trim())
+        .filter(Boolean)
+    : [];
+
+  return (
+    <div className="flex h-full flex-col overflow-hidden">
+      <div className="shrink-0 overflow-x-auto px-3 py-1 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <TabContainer>
+          {availableTabs.map((t) => (
+            <TabButton
+              key={t}
+              isActive={tab === t}
+              layoutId="prompt-span"
+              onClick={() => setTab(t)}
+              shortcut={
+                t === "overview" ? { key: "o" } : t === "input" ? { key: "i" } : { key: "t" }
+              }
+            >
+              {t === "overview" ? "Overview" : t === "input" ? "Input" : "Template"}
+            </TabButton>
+          ))}
+        </TabContainer>
+      </div>
+
+      <div className="scrollbar-gutter-stable min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        {tab === "overview" && (
+          <div className="flex flex-col px-3">
+            {startTime && <SpanHorizontalTimeline startTime={startTime} duration={duration ?? null} />}
+            <div className="flex flex-col gap-1 py-2.5">
+              <div className="flex flex-col text-xs @container">
+                <MetricRow
+                  label="Prompt"
+                  value={
+                    promptPath ? (
+                      <TextLink to={promptPath}>{promptData.slug}</TextLink>
+                    ) : (
+                      promptData.slug
+                    )
+                  }
+                />
+                <MetricRow label="Version" value={`v${promptData.version}`} />
+                {labels.length > 0 && <MetricRow label="Labels" value={labels.join(", ")} />}
+                {promptData.model && <MetricRow label="Model" value={promptData.model} />}
+              </div>
+            </div>
+
+            {promptData.text && (
+              <div className="flex flex-col gap-1.5 py-2.5">
+                <Header3>Resolved content</Header3>
+                <div className="rounded-md border border-grid-bright bg-charcoal-750/50 px-3.5 py-2">
+                  <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+                    <Suspense
+                      fallback={
+                        <span className="whitespace-pre-wrap">
+                          {promptData.text.length > 300
+                            ? promptData.text.slice(0, 300) + "..."
+                            : promptData.text}
+                        </span>
+                      }
+                    >
+                      <StreamdownRenderer>{promptData.text}</StreamdownRenderer>
+                    </Suspense>
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+        )}
+
+        {tab === "input" && hasInput && (
+          <div className="px-3 py-2.5">
+            <CodeBlock
+              code={tryPrettyJson(promptData.input!)}
+              maxLines={30}
+              showLineNumbers={false}
+              showCopyButton
+              language="json"
+            />
+          </div>
+        )}
+
+        {tab === "template" && hasTemplate && (
+          <div className="px-3 py-2.5">
+            <div className="rounded-md border border-grid-bright bg-charcoal-750/50 px-3.5 py-2">
+              <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+                <Suspense
+                  fallback={
+                    <span className="whitespace-pre-wrap">{promptData.template!}</span>
+                  }
+                >
+                  <StreamdownRenderer>{promptData.template!}</StreamdownRenderer>
+                </Suspense>
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
diff --git a/apps/webapp/app/components/runs/v3/QueueName.tsx b/apps/webapp/app/components/runs/v3/QueueName.tsx
new file mode 100644
index 00000000000..c5d8feeb46b
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/QueueName.tsx
@@ -0,0 +1,41 @@
+import { TaskIconSmall } from "~/assets/icons/TaskIcon";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { cn } from "~/utils/cn";
+import { RectangleStackIcon } from "@heroicons/react/20/solid";
+
+export function QueueName({
+  name,
+  type,
+  paused,
+  className,
+}: {
+  name: string;
+  type: "task" | "custom";
+  paused?: boolean;
+  className?: string;
+}) {
+  return (
+    <span className={cn("flex items-center gap-1", className)}>
+      {type === "task" ? (
+        <SimpleTooltip
+          button={
+            <TaskIconSmall
+              className={cn("size-[1.125rem] text-blue-500", paused && "opacity-50")}
+            />
+          }
+          content={`This queue was automatically created from your "${name}" task`}
+        />
+      ) : (
+        <SimpleTooltip
+          button={
+            <RectangleStackIcon
+              className={cn("size-[1.125rem] text-purple-500", paused && "opacity-50")}
+            />
+          }
+          content={`This is a custom queue you added in your code.`}
+        />
+      )}
+      <span className={paused ? "opacity-50" : undefined}>{name}</span>
+    </span>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx b/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx
index 83490aee11c..e42a2122abe 100644
--- a/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx
+++ b/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx
@@ -201,6 +201,8 @@ function ReplayForm({
       tags,
       version,
       machine,
+      region,
+      prioritySeconds,
     },
   ] = useForm({
     id: "replay-task",
@@ -356,6 +358,35 @@ function ReplayForm({
                 )}
                 <FormError id={version.errorId}>{version.error}</FormError>
               </InputGroup>
+              {replayData.regions.length > 1 && (
+                <InputGroup>
+                  <Label htmlFor={region.id} variant="small">
+                    Region
+                  </Label>
+                  <Select
+                    {...conform.select(region)}
+                    variant="tertiary/small"
+                    placeholder={replayData.disableVersionSelection ? "–" : undefined}
+                    dropdownIcon
+                    items={replayData.regions}
+                    defaultValue={replayData.region ?? undefined}
+                    disabled={replayData.disableVersionSelection}
+                  >
+                    {replayData.regions.map((r) => (
+                      <SelectItem key={r.name} value={r.name}>
+                        {r.description ? `${r.name} — ${r.description}` : r.name}
+                        {r.isDefault ? " (default)" : ""}
+                      </SelectItem>
+                    ))}
+                  </Select>
+                  {replayData.disableVersionSelection ? (
+                    <Hint>Region is not available in the development environment.</Hint>
+                  ) : (
+                    <Hint>Overrides the region for this run.</Hint>
+                  )}
+                  <FormError id={region.errorId}>{region.error}</FormError>
+                </InputGroup>
+              )}
               <InputGroup>
                 <Label htmlFor={queue.id} variant="small">
                   Queue
@@ -499,6 +530,12 @@ function ReplayForm({
                 <Hint>Delays run by a specific duration.</Hint>
                 <FormError id={delaySeconds.errorId}>{delaySeconds.error}</FormError>
               </InputGroup>
+              <InputGroup>
+                <Label variant="small">Priority</Label>
+                <DurationPicker name={prioritySeconds.name} id={prioritySeconds.id} />
+                <Hint>Sets the priority of the run. Higher values mean higher priority.</Hint>
+                <FormError id={prioritySeconds.errorId}>{prioritySeconds.error}</FormError>
+              </InputGroup>
               <InputGroup>
                 <Label variant="small">TTL</Label>
                 <DurationPicker
diff --git a/apps/webapp/app/components/runs/v3/RunFilters.tsx b/apps/webapp/app/components/runs/v3/RunFilters.tsx
index 297d95be0b1..dc3657b42a9 100644
--- a/apps/webapp/app/components/runs/v3/RunFilters.tsx
+++ b/apps/webapp/app/components/runs/v3/RunFilters.tsx
@@ -9,7 +9,7 @@ import {
   XMarkIcon,
 } from "@heroicons/react/20/solid";
 import { Form, useFetcher } from "@remix-run/react";
-import { IconRotateClockwise2, IconToggleLeft } from "@tabler/icons-react";
+import { IconBugFilled, IconRotateClockwise2, IconToggleLeft } from "@tabler/icons-react";
 import { MachinePresetName } from "@trigger.dev/core/v3";
 import type { BulkActionType, TaskRunStatus, TaskTriggerSource } from "@trigger.dev/database";
 import { ListFilterIcon } from "lucide-react";
@@ -31,6 +31,7 @@ import { DateTime } from "~/components/primitives/DateTime";
 import { FormError } from "~/components/primitives/FormError";
 import { Input } from "~/components/primitives/Input";
 import { Label } from "~/components/primitives/Label";
+import { MiddleTruncate } from "~/components/primitives/MiddleTruncate";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
   ComboBox,
@@ -180,6 +181,7 @@ export const TaskRunListSearchFilters = z.object({
   machines: MachinePresetOrMachinePresetArray.describe(
     `Machine presets to filter by (${machines.join(", ")})`
   ),
+  errorId: z.string().optional().describe("Error ID to filter runs by (e.g. error_abc123)"),
 });
 
 export type TaskRunListSearchFilters = z.infer<typeof TaskRunListSearchFilters>;
@@ -219,6 +221,8 @@ export function filterTitle(filterKey: string) {
       return "Machine";
     case "versions":
       return "Version";
+    case "errorId":
+      return "Error ID";
     default:
       return filterKey;
   }
@@ -257,6 +261,8 @@ export function filterIcon(filterKey: string): ReactNode | undefined {
       return <MachineDefaultIcon className="size-4" />;
     case "versions":
       return <IconRotateClockwise2 className="size-4" />;
+    case "errorId":
+      return <IconBugFilled className="size-4" />;
     default:
       return undefined;
   }
@@ -303,6 +309,7 @@ export function getRunFiltersFromSearchParams(
       searchParams.getAll("versions").filter((v) => v.length > 0).length > 0
         ? searchParams.getAll("versions")
         : undefined,
+    errorId: searchParams.get("errorId") ?? undefined,
   };
 
   const parsed = TaskRunListSearchFilters.safeParse(params);
@@ -324,6 +331,10 @@ type RunFiltersProps = {
   }[];
   rootOnlyDefault: boolean;
   hasFilters: boolean;
+  /** Hide the AI search input (useful when replacing with a custom search component) */
+  hideSearch?: boolean;
+  /** Custom default period for the time filter (e.g., "1h", "7d") */
+  defaultPeriod?: string;
 };
 
 export function RunsFilters(props: RunFiltersProps) {
@@ -339,14 +350,15 @@ export function RunsFilters(props: RunFiltersProps) {
     searchParams.has("scheduleId") ||
     searchParams.has("queues") ||
     searchParams.has("machines") ||
-    searchParams.has("versions");
+    searchParams.has("versions") ||
+    searchParams.has("errorId");
 
   return (
     <div className="flex flex-row flex-wrap items-center gap-1">
       <FilterMenu {...props} />
-      <AIFilterInput />
+      {!props.hideSearch && <AIFilterInput />}
       <RootOnlyToggle defaultValue={props.rootOnlyDefault} />
-      <TimeFilter />
+      <TimeFilter defaultPeriod={props.defaultPeriod} />
       <AppliedFilters {...props} />
       {hasFilters && (
         <Form className="h-6">
@@ -375,6 +387,7 @@ const filterTypes = [
   { name: "batch", title: "Batch ID", icon: <Squares2X2Icon className="size-4" /> },
   { name: "schedule", title: "Schedule ID", icon: <ClockIcon className="size-4" /> },
   { name: "bulk", title: "Bulk action", icon: <ListCheckedIcon className="size-4" /> },
+  { name: "error", title: "Error ID", icon: <IconBugFilled className="size-4" /> },
 ] as const;
 
 type FilterType = (typeof filterTypes)[number]["name"];
@@ -429,6 +442,7 @@ function AppliedFilters({ possibleTasks, bulkActions }: RunFiltersProps) {
       <AppliedBatchIdFilter />
       <AppliedScheduleIdFilter />
       <AppliedBulkActionsFilter bulkActions={bulkActions} />
+      <AppliedErrorIdFilter />
     </>
   );
 }
@@ -465,6 +479,8 @@ function Menu(props: MenuProps) {
       return <ScheduleIdDropdown onClose={() => props.setFilterType(undefined)} {...props} />;
     case "versions":
       return <VersionsDropdown onClose={() => props.setFilterType(undefined)} {...props} />;
+    case "error":
+      return <ErrorIdDropdown onClose={() => props.setFilterType(undefined)} {...props} />;
   }
 }
 
@@ -630,7 +646,7 @@ function TasksDropdown({
     <SelectProvider value={values("tasks")} setValue={handleChange} virtualFocus={true}>
       {trigger}
       <SelectPopover
-        className="min-w-0 max-w-[min(240px,var(--popover-available-width))]"
+        className="min-w-0 max-w-[min(360px,var(--popover-available-width))]"
         hideOnEscape={() => {
           if (onClose) {
             onClose();
@@ -650,7 +666,7 @@ function TasksDropdown({
                 <TaskTriggerSourceIcon source={item.triggerSource} className="size-4 flex-none" />
               }
             >
-              {item.slug}
+              <MiddleTruncate text={item.slug} />
             </SelectItem>
           ))}
         </SelectList>
@@ -1200,7 +1216,7 @@ function AppliedMachinesFilter() {
   );
 }
 
-function VersionsDropdown({
+export function VersionsDropdown({
   trigger,
   clearSearchValue,
   searchValue,
@@ -1735,3 +1751,121 @@ function AppliedScheduleIdFilter() {
     </FilterMenuProvider>
   );
 }
+
+function ErrorIdDropdown({
+  trigger,
+  clearSearchValue,
+  searchValue,
+  onClose,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+}) {
+  const [open, setOpen] = useState<boolean | undefined>();
+  const { value, replace } = useSearchParams();
+  const errorIdValue = value("errorId");
+
+  const [errorId, setErrorId] = useState(errorIdValue);
+
+  const apply = useCallback(() => {
+    clearSearchValue();
+    replace({
+      cursor: undefined,
+      direction: undefined,
+      errorId: errorId === "" ? undefined : errorId?.toString(),
+    });
+
+    setOpen(false);
+  }, [errorId, replace]);
+
+  let error: string | undefined = undefined;
+  if (errorId) {
+    if (!errorId.startsWith("error_")) {
+      error = "Error IDs start with 'error_'";
+    }
+  }
+
+  return (
+    <SelectProvider virtualFocus={true} open={open} setOpen={setOpen}>
+      {trigger}
+      <SelectPopover
+        hideOnEnter={false}
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+
+          return true;
+        }}
+        className="max-w-[min(32ch,var(--popover-available-width))]"
+      >
+        <div className="flex flex-col gap-4 p-3">
+          <div className="flex flex-col gap-1">
+            <Label>Error ID</Label>
+            <Input
+              placeholder="error_"
+              value={errorId ?? ""}
+              onChange={(e) => setErrorId(e.target.value)}
+              variant="small"
+              className="w-[29ch] font-mono"
+              spellCheck={false}
+            />
+            {error ? <FormError>{error}</FormError> : null}
+          </div>
+          <div className="flex justify-between gap-1 border-t border-grid-dimmed pt-3">
+            <Button variant="tertiary/small" onClick={() => setOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              disabled={error !== undefined || !errorId}
+              variant="secondary/small"
+              shortcut={{
+                modifiers: ["mod"],
+                key: "Enter",
+                enabledOnInputElements: true,
+              }}
+              onClick={() => apply()}
+            >
+              Apply
+            </Button>
+          </div>
+        </div>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function AppliedErrorIdFilter() {
+  const { value, del } = useSearchParams();
+
+  if (value("errorId") === undefined) {
+    return null;
+  }
+
+  const errorId = value("errorId");
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <ErrorIdDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Error ID"
+                icon={filterIcon("errorId")}
+                value={errorId}
+                onRemove={() => del(["errorId", "cursor", "direction"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/RunIcon.tsx b/apps/webapp/app/components/runs/v3/RunIcon.tsx
index 615def59cdb..572435f75c9 100644
--- a/apps/webapp/app/components/runs/v3/RunIcon.tsx
+++ b/apps/webapp/app/components/runs/v3/RunIcon.tsx
@@ -3,9 +3,25 @@ import {
   HandRaisedIcon,
   InformationCircleIcon,
   RectangleStackIcon,
+  SparklesIcon,
   Squares2X2Icon,
+  TableCellsIcon,
   TagIcon,
+  WrenchIcon,
 } from "@heroicons/react/20/solid";
+import { AnthropicLogoIcon } from "~/assets/icons/AnthropicLogoIcon";
+import {
+  AnthropicIcon,
+  AzureIcon,
+  CerebrasIcon,
+  DeepseekIcon,
+  GeminiIcon,
+  LlamaIcon,
+  MistralIcon,
+  OpenAIIcon,
+  PerplexityIcon,
+  XAIIcon,
+} from "~/assets/icons/AiProviderIcons";
 import { AttemptIcon } from "~/assets/icons/AttemptIcon";
 import { TaskIcon } from "~/assets/icons/TaskIcon";
 import { cn } from "~/utils/cn";
@@ -47,8 +63,6 @@ export function RunIcon({ name, className, spanName }: TaskIconProps) {
     ) {
       return <TablerIcon name={spanNameIcon.iconName} className={className} />;
     }
-
-    <InformationCircleIcon className={cn(className, "text-text-dimmed")} />;
   }
 
   if (!name) return <Squares2X2Icon className={cn(className, "text-text-dimmed")} />;
@@ -81,6 +95,8 @@ export function RunIcon({ name, className, spanName }: TaskIconProps) {
       return <WaitpointTokenIcon className={cn(className, "text-sky-500")} />;
     case "function":
       return <FunctionIcon className={cn(className, "text-text-dimmed")} />;
+    case "query":
+      return <TableCellsIcon className={cn(className, "text-query")} />;
     //log levels
     case "debug":
     case "log":
@@ -110,7 +126,32 @@ export function RunIcon({ name, className, spanName }: TaskIconProps) {
     case "task-hook-catchError":
       return <FunctionIcon className={cn(className, "text-error")} />;
     case "streams":
-        return <StreamsIcon className={cn(className, "text-text-dimmed")} />;
+      return <StreamsIcon className={cn(className, "text-text-dimmed")} />;
+    case "hero-sparkles":
+      return <SparklesIcon className={cn(className, "text-text-dimmed")} />;
+    case "hero-wrench":
+      return <WrenchIcon className={cn(className, "text-text-dimmed")} />;
+    case "tabler-brand-anthropic":
+    case "ai-provider-anthropic":
+      return <AnthropicIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-openai":
+      return <OpenAIIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-gemini":
+      return <GeminiIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-llama":
+      return <LlamaIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-deepseek":
+      return <DeepseekIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-xai":
+      return <XAIIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-perplexity":
+      return <PerplexityIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-cerebras":
+      return <CerebrasIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-mistral":
+      return <MistralIcon className={cn(className, "text-text-dimmed")} />;
+    case "ai-provider-azure":
+      return <AzureIcon className={cn(className, "text-text-dimmed")} />;
   }
 
   return <InformationCircleIcon className={cn(className, "text-text-dimmed")} />;
diff --git a/apps/webapp/app/components/runs/v3/SharedFilters.tsx b/apps/webapp/app/components/runs/v3/SharedFilters.tsx
index 14edfa3c7d6..3e24f601f2a 100644
--- a/apps/webapp/app/components/runs/v3/SharedFilters.tsx
+++ b/apps/webapp/app/components/runs/v3/SharedFilters.tsx
@@ -1,21 +1,35 @@
 import * as Ariakit from "@ariakit/react";
 import type { RuntimeEnvironment } from "@trigger.dev/database";
+import {
+  endOfDay,
+  endOfMonth,
+  endOfWeek,
+  startOfDay,
+  startOfMonth,
+  startOfWeek,
+  subDays,
+  subWeeks,
+} from "date-fns";
 import parse from "parse-duration";
-import type { ReactNode } from "react";
-import { startTransition, useCallback, useState } from "react";
+import { startTransition, useCallback, useEffect, useRef, useState, type ReactNode } from "react";
+import simplur from "simplur";
 import { AppliedFilter } from "~/components/primitives/AppliedFilter";
-import { DateField } from "~/components/primitives/DateField";
+import { Callout } from "~/components/primitives/Callout";
 import { DateTime } from "~/components/primitives/DateTime";
+import { DateTimePicker } from "~/components/primitives/DateTimePicker";
 import { Label } from "~/components/primitives/Label";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { RadioButtonCircle } from "~/components/primitives/RadioButton";
 import { ComboboxProvider, SelectPopover, SelectProvider } from "~/components/primitives/Select";
+import { useOptionalOrganization } from "~/hooks/useOrganizations";
 import { useSearchParams } from "~/hooks/useSearchParam";
-import { Button } from "../../primitives/Buttons";
+import { type ShortcutDefinition, useShortcutKeys } from "~/hooks/useShortcutKeys";
+import { ShortcutKey } from "~/components/primitives/ShortcutKey";
+import { cn } from "~/utils/cn";
+import { organizationBillingPath } from "~/utils/pathBuilder";
+import { Button, LinkButton } from "../../primitives/Buttons";
 import { filterIcon } from "./RunFilters";
 
-export type DisplayableEnvironment = Pick<RuntimeEnvironment, "type" | "id"> & {
-  userName?: string;
-};
-
 export function FilterMenuProvider({
   children,
   onClose,
@@ -77,6 +91,10 @@ const timePeriods = [
     label: "3 days",
     value: "3d",
   },
+  {
+    label: "5 days",
+    value: "5d",
+  },
   {
     label: "7 days",
     value: "7d",
@@ -89,14 +107,41 @@ const timePeriods = [
     label: "30 days",
     value: "30d",
   },
-  {
-    label: "1 year",
-    value: "365d",
-  },
 ];
 
-const defaultPeriod = "7d";
-const defaultPeriodMs = parse(defaultPeriod);
+const timeUnits = [
+  { label: "minutes", value: "m", singular: "minute", shortLabel: "mins" },
+  { label: "hours", value: "h", singular: "hour", shortLabel: "hours" },
+  { label: "days", value: "d", singular: "day", shortLabel: "days" },
+];
+
+// Parse a period string (e.g., "90m", "2h", "7d") into value and unit
+function parsePeriodString(period: string): { value: number; unit: string } | null {
+  const match = period.match(/^(\d+)([mhd])$/);
+  if (match) {
+    return { value: parseInt(match[1], 10), unit: match[2] };
+  }
+  return null;
+}
+
+const MS_PER_DAY = 1000 * 60 * 60 * 24;
+
+// Convert a period string to days using parse-duration
+function periodToDays(period: string): number {
+  const ms = parse(period);
+  if (!ms) return 0;
+  return ms / MS_PER_DAY;
+}
+
+// Calculate the number of days a date range spans from now
+function dateRangeToDays(from?: Date): number {
+  if (!from) return 0;
+  const now = new Date();
+  return Math.ceil((now.getTime() - from.getTime()) / MS_PER_DAY);
+}
+
+const DEFAULT_PERIOD = "7d";
+const defaultPeriodMs = parse(DEFAULT_PERIOD);
 if (!defaultPeriodMs) {
   throw new Error("Invalid default period");
 }
@@ -107,10 +152,14 @@ export const timeFilters = ({
   period,
   from,
   to,
+  defaultPeriod = DEFAULT_PERIOD,
+  labelName = "Created",
 }: {
   period?: string;
   from?: string | number;
   to?: string | number;
+  defaultPeriod?: string;
+  labelName?: string;
 }): {
   period?: string;
   from?: Date;
@@ -121,7 +170,11 @@ export const timeFilters = ({
   valueLabel: ReactNode;
 } => {
   if (period) {
-    return { period, isDefault: period === defaultPeriod, ...timeFilterRenderValues({ period }) };
+    return {
+      period,
+      isDefault: period === defaultPeriod,
+      ...timeFilterRenderValues({ period, labelName }),
+    };
   }
 
   if (from && to) {
@@ -131,7 +184,7 @@ export const timeFilters = ({
       from: fromDate,
       to: toDate,
       isDefault: false,
-      ...timeFilterRenderValues({ from: fromDate, to: toDate }),
+      ...timeFilterRenderValues({ from: fromDate, to: toDate, labelName }),
     };
   }
 
@@ -141,7 +194,7 @@ export const timeFilters = ({
     return {
       from: fromDate,
       isDefault: false,
-      ...timeFilterRenderValues({ from: fromDate }),
+      ...timeFilterRenderValues({ from: fromDate, labelName }),
     };
   }
 
@@ -151,40 +204,116 @@ export const timeFilters = ({
     return {
       to: toDate,
       isDefault: false,
-      ...timeFilterRenderValues({ to: toDate }),
+      ...timeFilterRenderValues({ to: toDate, labelName }),
     };
   }
 
   return {
     period: defaultPeriod,
     isDefault: true,
-    ...timeFilterRenderValues({ period: defaultPeriod }),
+    ...timeFilterRenderValues({ period: defaultPeriod, labelName }),
   };
 };
 
+export function timeFilterFromTo(props: {
+  period?: string;
+  from?: string | number;
+  to?: string | number;
+  defaultPeriod: string;
+}): { from: Date; to: Date; isDefault: boolean } {
+  const time = timeFilters(props);
+
+  const periodMs = time.period ? parse(time.period) : undefined;
+
+  if (periodMs) {
+    return {
+      from: new Date(Date.now() - periodMs),
+      to: new Date(),
+      isDefault: time.isDefault,
+    };
+  }
+
+  if (time.from && time.to) {
+    return {
+      from: time.from,
+      to: time.to,
+      isDefault: time.isDefault,
+    };
+  }
+
+  if (time.from) {
+    return {
+      from: time.from,
+      to: new Date(),
+      isDefault: time.isDefault,
+    };
+  }
+
+  const defaultPeriodMs = parse(props.defaultPeriod) ?? 24 * 60 * 60 * 1_000;
+  return {
+    from: new Date(Date.now() - defaultPeriodMs),
+    to: time.to ?? new Date(),
+    isDefault: time.isDefault,
+  };
+}
+
 export function timeFilterRenderValues({
   from,
   to,
   period,
+  defaultPeriod = DEFAULT_PERIOD,
+  labelName = "Created",
 }: {
   from?: Date;
   to?: Date;
   period?: string;
+  defaultPeriod?: string;
+  labelName?: string;
 }) {
   const rangeType: TimeRangeType = from && to ? "range" : from ? "from" : to ? "to" : "period";
 
   let valueLabel: ReactNode;
   switch (rangeType) {
-    case "period":
-      valueLabel = timePeriods.find((t) => t.value === period)?.label ?? period ?? defaultPeriod;
+    case "period": {
+      // First check if it's a preset period
+      const preset = timePeriods.find((t) => t.value === period);
+      if (preset) {
+        valueLabel = preset.label;
+      } else if (period) {
+        // Parse custom period and format nicely (e.g., "90m" -> "90 mins")
+        const parsed = parsePeriodString(period);
+        if (parsed) {
+          const unit = timeUnits.find((u) => u.value === parsed.unit);
+          if (unit) {
+            valueLabel = `${parsed.value} ${parsed.value === 1 ? unit.singular : unit.label}`;
+          } else {
+            valueLabel = period;
+          }
+        } else {
+          valueLabel = period;
+        }
+      } else {
+        valueLabel = defaultPeriod;
+      }
       break;
+    }
     case "range":
-      valueLabel = (
-        <span>
-          <DateTime date={from!} includeTime includeSeconds /> –{" "}
-          <DateTime date={to!} includeTime includeSeconds />
-        </span>
-      );
+      {
+        //If the day is the same, only show the time for the `to` date
+        const isSameDay =
+          from &&
+          to &&
+          from.getDate() === to.getDate() &&
+          from.getMonth() === to.getMonth() &&
+          from.getFullYear() === to.getFullYear();
+
+        valueLabel = (
+          <span>
+            <DateTime date={from!} includeTime includeSeconds /> –{" "}
+            <DateTime date={to!} includeTime includeSeconds includeDate={!isSameDay} />
+          </span>
+        );
+      }
       break;
     case "from":
       valueLabel = <DateTime date={from!} includeTime includeSeconds />;
@@ -196,21 +325,74 @@ export function timeFilterRenderValues({
 
   let label =
     rangeType === "range" || rangeType === "period"
-      ? "Created"
+      ? labelName
       : rangeType === "from"
-      ? "Created after"
-      : "Created before";
+      ? `${labelName} after`
+      : `${labelName} before`;
 
   return { label, valueLabel, rangeType };
 }
 
-export function TimeFilter() {
-  const { value, del } = useSearchParams();
+/** Values passed to onApply callback when a time filter is applied */
+export interface TimeFilterApplyValues {
+  period?: string;
+  from?: string;
+  to?: string;
+}
+
+export interface TimeFilterProps {
+  defaultPeriod?: string;
+  period?: string;
+  from?: string;
+  to?: string;
+  /** Label name used in the filter display, defaults to "Created" */
+  labelName?: string;
+  hideLabel?: boolean;
+  /** Keyboard shortcut to open the dropdown */
+  shortcut?: ShortcutDefinition;
+  applyShortcut?: ShortcutDefinition | undefined;
+  /** Callback when the user applies a time filter selection, receives the applied values */
+  onValueChange?: (values: TimeFilterApplyValues) => void;
+  /** When set an upgrade message will be shown if you select a period further back than this number of days */
+  maxPeriodDays?: number;
+  /** Optional className override for the value text in the filter pill */
+  valueClassName?: string;
+}
 
-  const { period, from, to, label, valueLabel } = timeFilters({
-    period: value("period"),
-    from: value("from"),
-    to: value("to"),
+export function TimeFilter({
+  defaultPeriod,
+  period,
+  from,
+  to,
+  labelName = "Created",
+  hideLabel = false,
+  shortcut,
+  applyShortcut,
+  onValueChange,
+  maxPeriodDays,
+  valueClassName,
+}: TimeFilterProps = {}) {
+  const { value } = useSearchParams();
+  const periodValue = period ?? value("period");
+  const fromValue = from ?? value("from");
+  const toValue = to ?? value("to");
+  const triggerRef = useRef<HTMLButtonElement>(null);
+
+  useShortcutKeys({
+    shortcut,
+    action: (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      triggerRef.current?.click();
+    },
+  });
+
+  const constrained = timeFilters({
+    period: periodValue,
+    from: fromValue,
+    to: toValue,
+    defaultPeriod,
+    labelName,
   });
 
   return (
@@ -218,71 +400,252 @@ export function TimeFilter() {
       {() => (
         <TimeDropdown
           trigger={
-            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
-              <AppliedFilter
-                label={label}
-                icon={filterIcon("period")}
-                value={valueLabel}
-                removable={false}
-                variant="secondary/small"
-              />
-            </Ariakit.Select>
+            <Ariakit.TooltipProvider timeout={200}>
+              <Ariakit.TooltipAnchor
+                render={
+                  <Ariakit.Select
+                    ref={triggerRef}
+                    render={<div className="group cursor-pointer focus-custom" />}
+                  />
+                }
+              >
+                <AppliedFilter
+                  label={hideLabel ? undefined : constrained.label}
+                  icon={filterIcon("period")}
+                  value={constrained.valueLabel}
+                  removable={false}
+                  variant="secondary/small"
+                  valueClassName={valueClassName}
+                />
+              </Ariakit.TooltipAnchor>
+              {shortcut && (
+                <Ariakit.Tooltip className="z-40 cursor-default rounded border border-charcoal-700 bg-background-bright px-2 py-1.5 text-xs">
+                  <div className="flex items-center gap-2">
+                    <span>Filter by time period</span>
+                    <ShortcutKey
+                      className="size-4 flex-none"
+                      shortcut={shortcut}
+                      variant="small"
+                    />
+                  </div>
+                </Ariakit.Tooltip>
+              )}
+            </Ariakit.TooltipProvider>
           }
-          period={period}
-          from={from}
-          to={to}
+          period={constrained.period}
+          from={constrained.from}
+          to={constrained.to}
+          defaultPeriod={defaultPeriod}
+          labelName={labelName}
+          applyShortcut={applyShortcut}
+          onValueChange={onValueChange}
+          maxPeriodDays={maxPeriodDays}
         />
       )}
     </FilterMenuProvider>
   );
 }
 
+// Get initial custom duration state from a period string
+function getInitialCustomDuration(period?: string): { value: string; unit: string } {
+  if (period) {
+    const parsed = parsePeriodString(period);
+    if (parsed) {
+      return { value: parsed.value.toString(), unit: parsed.unit };
+    }
+  }
+  return { value: "", unit: "m" };
+}
+
+type SectionType = "duration" | "dateRange";
+
 export function TimeDropdown({
   trigger,
   period,
   from,
   to,
+  defaultPeriod = DEFAULT_PERIOD,
+  labelName = "Created",
+  applyShortcut,
+  onApply,
+  onValueChange,
+  maxPeriodDays,
 }: {
   trigger: ReactNode;
   period?: string;
   from?: Date;
   to?: Date;
+  defaultPeriod?: string;
+  labelName?: string;
+  applyShortcut?: ShortcutDefinition | undefined;
+  onApply?: (values: TimeFilterApplyValues) => void;
+  /** When provided, the component operates in controlled mode and skips URL navigation */
+  onValueChange?: (values: TimeFilterApplyValues) => void;
+  /** When set an upgrade message will be shown if you select a period further back than this number of days */
+  maxPeriodDays?: number;
 }) {
+  const organization = useOptionalOrganization();
   const [open, setOpen] = useState<boolean | undefined>();
   const { replace } = useSearchParams();
   const [fromValue, setFromValue] = useState(from);
   const [toValue, setToValue] = useState(to);
 
-  const apply = useCallback(() => {
-    replace({
-      period: undefined,
-      cursor: undefined,
-      direction: undefined,
-      from: fromValue?.getTime().toString(),
-      to: toValue?.getTime().toString(),
-    });
-
-    setOpen(false);
-  }, [fromValue, toValue, replace]);
-
-  const handlePeriodClick = useCallback(
-    (period: string) => {
-      replace({
-        period,
-        cursor: undefined,
-        direction: undefined,
+  // Section selection state: "duration" or "dateRange"
+  const initialSection: SectionType = from || to ? "dateRange" : "duration";
+  const [activeSection, setActiveSection] = useState<SectionType>(initialSection);
+  const [validationError, setValidationError] = useState<string | null>(null);
+  const [selectedQuickDate, setSelectedQuickDate] = useState<string | null>(null);
+
+  // Selection state: preset value or "custom"
+  const initialCustom = getInitialCustomDuration(period);
+  const isInitialCustom =
+    period && !timePeriods.some((p) => p.value === period) && initialCustom.value !== "";
+  const [selectedPeriod, setSelectedPeriod] = useState<string>(
+    isInitialCustom ? "custom" : period ?? defaultPeriod
+  );
+
+  // Custom duration state
+  const [customValue, setCustomValue] = useState(initialCustom.value);
+  const [customUnit, setCustomUnit] = useState(initialCustom.unit);
+
+  // Sync state when props change
+  useEffect(() => {
+    const parsed = getInitialCustomDuration(period);
+    setCustomValue(parsed.value);
+    setCustomUnit(parsed.unit);
+
+    const isCustom = period && !timePeriods.some((p) => p.value === period) && parsed.value !== "";
+    setSelectedPeriod(isCustom ? "custom" : period ?? defaultPeriod);
+    setActiveSection(from || to ? "dateRange" : "duration");
+  }, [period, from, to, defaultPeriod]);
+
+  const isCustomDurationValid = (() => {
+    const value = parseInt(customValue, 10);
+    return !isNaN(value) && value > 0;
+  })();
+
+  // Calculate if the current selection exceeds maxPeriodDays
+  const exceedsMaxPeriod = (() => {
+    if (!maxPeriodDays) return false;
+
+    if (activeSection === "duration") {
+      const periodToCheck =
+        selectedPeriod === "custom" ? `${customValue}${customUnit}` : selectedPeriod;
+      if (!periodToCheck) return false;
+      return periodToDays(periodToCheck) > maxPeriodDays;
+    } else {
+      // For date range, check if fromValue is further back than maxPeriodDays
+      return dateRangeToDays(fromValue) > maxPeriodDays;
+    }
+  })();
+
+  const applyPeriod = useCallback(
+    (periodToApply: string) => {
+      setValidationError(null);
+
+      if (maxPeriodDays && periodToDays(periodToApply) > maxPeriodDays) {
+        setValidationError(
+          `Your plan allows a maximum of ${maxPeriodDays} days. Upgrade for longer retention.`
+        );
+        return;
+      }
+
+      const values: TimeFilterApplyValues = {
+        period: periodToApply,
         from: undefined,
         to: undefined,
-      });
+      };
+
+      if (onValueChange) {
+        onValueChange(values);
+      } else {
+        replace({
+          period: periodToApply,
+          cursor: undefined,
+          direction: undefined,
+          from: undefined,
+          to: undefined,
+        });
+      }
 
       setFromValue(undefined);
       setToValue(undefined);
-
       setOpen(false);
+      onApply?.(values);
     },
-    [replace]
+    [maxPeriodDays, onValueChange, replace, onApply]
   );
 
+  const applySelection = useCallback(() => {
+    setValidationError(null);
+
+    if (exceedsMaxPeriod) {
+      setValidationError(
+        `Your plan allows a maximum of ${maxPeriodDays} days. Upgrade for longer retention.`
+      );
+      return;
+    }
+
+    if (activeSection === "duration") {
+      // Validate custom duration
+      if (selectedPeriod === "custom" && !isCustomDurationValid) {
+        setValidationError("Please enter a valid custom duration");
+        return;
+      }
+
+      const periodToApply =
+        selectedPeriod === "custom" ? `${customValue}${customUnit}` : selectedPeriod;
+      applyPeriod(periodToApply);
+    } else {
+      // Validate date range
+      if (!fromValue && !toValue) {
+        setValidationError("Please specify at least one date");
+        return;
+      }
+
+      if (fromValue && toValue && fromValue > toValue) {
+        setValidationError("From date must be before To date");
+        return;
+      }
+
+      const fromStr = fromValue?.getTime().toString();
+      const toStr = toValue?.getTime().toString();
+
+      const values: TimeFilterApplyValues = { period: undefined, from: fromStr, to: toStr };
+
+      if (onValueChange) {
+        // Controlled mode - just call the handler
+        onValueChange(values);
+      } else {
+        // URL mode - navigate
+        replace({
+          period: undefined,
+          cursor: undefined,
+          direction: undefined,
+          from: fromStr,
+          to: toStr,
+        });
+      }
+
+      setOpen(false);
+      onApply?.(values);
+    }
+  }, [
+    activeSection,
+    selectedPeriod,
+    isCustomDurationValid,
+    customValue,
+    customUnit,
+    fromValue,
+    toValue,
+    replace,
+    onApply,
+    onValueChange,
+    exceedsMaxPeriod,
+    maxPeriodDays,
+    applyPeriod,
+  ]);
+
   return (
     <SelectProvider virtualFocus={true} open={open} setOpen={setOpen}>
       {trigger}
@@ -292,92 +655,306 @@ export function TimeDropdown({
           return true;
         }}
       >
-        <div className="flex flex-col gap-6 p-3">
-          <div className="flex flex-col gap-1">
-            <Label>Runs created in the last</Label>
-            <div className="grid grid-cols-4 gap-2">
-              {timePeriods.map((p) => (
-                <Button
-                  key={p.value}
-                  variant="secondary/small"
-                  className={
-                    p.value === period
-                      ? "border-indigo-500 group-hover/button:border-indigo-500"
-                      : undefined
-                  }
-                  onClick={(e) => {
-                    e.preventDefault();
-                    handlePeriodClick(p.value);
-                  }}
-                  fullWidth
-                  type="button"
+        <div className="flex flex-col gap-4 p-3">
+          {/* Duration section */}
+          <div
+            onClick={() => {
+              setActiveSection("duration");
+              setValidationError(null);
+              setSelectedQuickDate(null);
+            }}
+            className="flex cursor-pointer gap-3 rounded-md pb-3"
+          >
+            <RadioButtonCircle checked={activeSection === "duration"} />
+            <div className="flex flex-1 flex-col gap-1">
+              <Label
+                className={cn(
+                  "mb-2 transition-colors",
+                  activeSection === "duration" && "text-indigo-500"
+                )}
+              >
+                {labelName} in the last
+              </Label>
+              <div className="grid grid-cols-4 gap-2">
+                {/* Custom duration row */}
+                <div
+                  className={cn(
+                    "col-span-4 flex h-[1.8rem] w-full items-center gap-2 rounded border bg-charcoal-750 py-0.5 pl-0 pr-2 transition-colors",
+                    activeSection === "duration" && selectedPeriod === "custom"
+                      ? "border-indigo-500 "
+                      : "border-charcoal-650 hover:border-charcoal-600",
+                    validationError &&
+                      activeSection === "duration" &&
+                      selectedPeriod === "custom" &&
+                      "border-error"
+                  )}
+                  onClick={(e) => e.stopPropagation()}
                 >
-                  {p.label}
-                </Button>
-              ))}
+                  <input
+                    type="number"
+                    min="1"
+                    step="1"
+                    placeholder="Custom"
+                    value={customValue}
+                    autoFocus
+                    onChange={(e) => {
+                      setCustomValue(e.target.value);
+                      setSelectedPeriod("custom");
+                      setActiveSection("duration");
+                      setValidationError(null);
+                    }}
+                    onFocus={() => {
+                      setSelectedPeriod("custom");
+                      setActiveSection("duration");
+                      setValidationError(null);
+                    }}
+                    className="h-full w-full translate-y-px border-none bg-transparent py-0 pl-2 pr-0 text-xs leading-none text-text-bright outline-none placeholder:text-text-dimmed focus:outline-none focus:ring-0 [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
+                  />
+                  <div className="flex items-center gap-2">
+                    {timeUnits.map((unit) => (
+                      <button
+                        key={unit.value}
+                        type="button"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setCustomUnit(unit.value);
+                          setSelectedPeriod("custom");
+                          setActiveSection("duration");
+                          setValidationError(null);
+                        }}
+                        className={cn(
+                          "text-xs transition-colors",
+                          customUnit === unit.value
+                            ? "text-indigo-500"
+                            : "text-text-dimmed hover:text-text-bright"
+                        )}
+                      >
+                        {unit.shortLabel}
+                      </button>
+                    ))}
+                  </div>
+                </div>
+                {timePeriods.map((p) => {
+                  const parsed = parsePeriodString(p.value);
+                  return (
+                    <Button
+                      key={p.value}
+                      variant="secondary/small"
+                      className={
+                        activeSection === "duration" && p.value === selectedPeriod
+                          ? "border-indigo-500 group-hover/button:border-indigo-500"
+                          : undefined
+                      }
+                      onClick={(e) => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        setActiveSection("duration");
+                        setSelectedPeriod(p.value);
+                        if (parsed) {
+                          setCustomValue(parsed.value.toString());
+                          setCustomUnit(parsed.unit);
+                        }
+                        applyPeriod(p.value);
+                      }}
+                      fullWidth
+                      type="button"
+                    >
+                      {p.label}
+                    </Button>
+                  );
+                })}
+              </div>
+              {validationError && activeSection === "duration" && selectedPeriod === "custom" && (
+                <p className="mt-1 text-xs text-error">{validationError}</p>
+              )}
             </div>
           </div>
 
-          <div className="flex flex-col gap-4">
-            <div className="flex flex-col gap-1">
-              <Label>
-                From <span className="text-text-dimmed">(local time)</span>
-              </Label>
-              <DateField
-                label="From time"
-                defaultValue={fromValue}
-                onValueChange={setFromValue}
-                granularity="second"
-                showNowButton
-                showClearButton
-                variant="small"
-              />
-            </div>
-            <div className="flex flex-col gap-1">
-              <Label>
-                To <span className="text-text-dimmed">(local time)</span>
-              </Label>
-              <DateField
-                label="To time"
-                defaultValue={toValue}
-                onValueChange={setToValue}
-                granularity="second"
-                showNowButton
-                showClearButton
-                variant="small"
-              />
-            </div>
-            <div className="flex justify-between gap-1 border-t border-grid-bright pt-3">
-              <Button
-                variant="tertiary/small"
-                onClick={(e) => {
-                  e.preventDefault();
-                  setFromValue(from);
-                  setToValue(to);
-                  setOpen(false);
-                }}
-                type="button"
+          {/* Date range section */}
+          <div
+            onClick={() => {
+              setActiveSection("dateRange");
+              setValidationError(null);
+            }}
+            className="flex cursor-pointer gap-3"
+          >
+            <RadioButtonCircle checked={activeSection === "dateRange"} />
+            <div className="flex flex-1 flex-col">
+              <Label
+                className={cn(
+                  "mb-3 transition-colors",
+                  activeSection === "dateRange" && "text-indigo-500"
+                )}
               >
-                Cancel
-              </Button>
-              <Button
-                variant="secondary/small"
-                shortcut={{
-                  modifiers: ["mod"],
-                  key: "Enter",
-                  enabledOnInputElements: true,
-                }}
-                disabled={!fromValue && !toValue}
-                onClick={(e) => {
-                  e.preventDefault();
-                  apply();
-                }}
-                type="button"
-              >
-                Apply
-              </Button>
+                Or specify exact time range{" "}
+                <span
+                  className={cn(
+                    "transition-colors",
+                    activeSection === "dateRange" ? "text-indigo-500" : "text-text-dimmed"
+                  )}
+                >
+                  (in local time)
+                </span>
+              </Label>
+              <div className="-ml-8 mb-2" onClick={(e) => e.stopPropagation()}>
+                <DateTimePicker
+                  label="From"
+                  value={fromValue}
+                  onChange={(value) => {
+                    setFromValue(value);
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate(null);
+                  }}
+                  showSeconds
+                  showNowButton
+                  showClearButton
+                  showInlineLabel
+                />
+              </div>
+              <div onClick={(e) => e.stopPropagation()} className="-ml-8">
+                <DateTimePicker
+                  label="To"
+                  value={toValue}
+                  onChange={(value) => {
+                    setToValue(value);
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate(null);
+                  }}
+                  showSeconds
+                  showNowButton
+                  showClearButton
+                  showInlineLabel
+                />
+              </div>
+              {/* Quick select date ranges */}
+              <div className="mt-2 grid grid-cols-2 gap-2" onClick={(e) => e.stopPropagation()}>
+                <QuickDateButton
+                  label="Yesterday"
+                  isActive={selectedQuickDate === "yesterday"}
+                  onClick={() => {
+                    const yesterday = subDays(new Date(), 1);
+                    setFromValue(startOfDay(yesterday));
+                    setToValue(endOfDay(yesterday));
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate("yesterday");
+                  }}
+                />
+                <QuickDateButton
+                  label="Today"
+                  isActive={selectedQuickDate === "today"}
+                  onClick={() => {
+                    const today = new Date();
+                    setFromValue(startOfDay(today));
+                    setToValue(endOfDay(today));
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate("today");
+                  }}
+                />
+              </div>
+              <div className="mt-2 grid grid-cols-3 gap-2" onClick={(e) => e.stopPropagation()}>
+                <QuickDateButton
+                  label="This week"
+                  isActive={selectedQuickDate === "thisWeek"}
+                  onClick={() => {
+                    const now = new Date();
+                    setFromValue(startOfWeek(now, { weekStartsOn: 1 }));
+                    setToValue(endOfWeek(now, { weekStartsOn: 1 }));
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate("thisWeek");
+                  }}
+                />
+                <QuickDateButton
+                  label="Last week"
+                  isActive={selectedQuickDate === "lastWeek"}
+                  onClick={() => {
+                    const lastWeek = subWeeks(new Date(), 1);
+                    setFromValue(startOfWeek(lastWeek, { weekStartsOn: 1 }));
+                    setToValue(endOfWeek(lastWeek, { weekStartsOn: 1 }));
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate("lastWeek");
+                  }}
+                />
+                <QuickDateButton
+                  label="This month"
+                  isActive={selectedQuickDate === "thisMonth"}
+                  onClick={() => {
+                    const now = new Date();
+                    setFromValue(startOfMonth(now));
+                    setToValue(endOfMonth(now));
+                    setActiveSection("dateRange");
+                    setValidationError(null);
+                    setSelectedQuickDate("thisMonth");
+                  }}
+                />
+              </div>
+              {validationError && activeSection === "dateRange" && (
+                <Paragraph variant="extra-small" className="mt-2 text-error">
+                  {validationError}
+                </Paragraph>
+              )}
             </div>
           </div>
+
+          {/* Upgrade callout when exceeding maxPeriodDays */}
+          {exceedsMaxPeriod && organization && (
+            <Callout
+              variant="pricing"
+              cta={
+                <LinkButton
+                  variant="primary/small"
+                  to={organizationBillingPath({ slug: organization.slug })}
+                >
+                  Upgrade
+                </LinkButton>
+              }
+              className="items-center"
+            >
+              {simplur`Your plan allows a maximum of ${maxPeriodDays} day[|s].`}
+            </Callout>
+          )}
+
+          {/* Action buttons */}
+          <div className="flex justify-between gap-1 border-t border-grid-bright px-0 pt-3">
+            <Button
+              variant="secondary/small"
+              onClick={(e) => {
+                e.preventDefault();
+                setFromValue(from);
+                setToValue(to);
+                setValidationError(null);
+                setOpen(false);
+              }}
+              type="button"
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary/small"
+              shortcut={
+                applyShortcut
+                  ? applyShortcut
+                  : {
+                      modifiers: ["mod"],
+                      key: "Enter",
+                      enabledOnInputElements: true,
+                    }
+              }
+              onClick={(e) => {
+                e.preventDefault();
+                applySelection();
+              }}
+              type="button"
+              disabled={exceedsMaxPeriod}
+            >
+              Apply
+            </Button>
+          </div>
         </div>
       </SelectPopover>
     </SelectProvider>
@@ -399,11 +976,32 @@ export function appliedSummary(values: string[], maxValues = 3) {
 export function dateFromString(value: string | undefined | null): Date | undefined {
   if (!value) return;
 
-  //is it an int?
-  const int = parseInt(value);
-  if (!isNaN(int)) {
-    return new Date(int);
+  // Only treat as timestamp if the string is purely numeric
+  if (/^\d+$/.test(value)) {
+    return new Date(parseInt(value));
   }
 
   return new Date(value);
 }
+
+function QuickDateButton({
+  label,
+  onClick,
+  isActive,
+}: {
+  label: string;
+  onClick: () => void;
+  isActive?: boolean;
+}) {
+  return (
+    <Button
+      type="button"
+      variant="secondary/small"
+      onClick={onClick}
+      fullWidth
+      className={isActive ? "border-indigo-500 group-hover/button:border-indigo-500" : undefined}
+    >
+      {label}
+    </Button>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/SpanHorizontalTimeline.tsx b/apps/webapp/app/components/runs/v3/SpanHorizontalTimeline.tsx
new file mode 100644
index 00000000000..b4acf2a1e7b
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/SpanHorizontalTimeline.tsx
@@ -0,0 +1,54 @@
+import { DateTimeAccurate } from "~/components/primitives/DateTime";
+
+function formatSpanDuration(nanoseconds: number): string {
+  const ms = nanoseconds / 1_000_000;
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const totalSecs = Math.round(ms / 1000);
+  const mins = Math.floor(totalSecs / 60);
+  const secs = totalSecs % 60;
+  return `${mins}m ${secs}s`;
+}
+
+export function SpanHorizontalTimeline({
+  startTime,
+  duration,
+}: {
+  startTime: string | Date;
+  duration: number | null;
+}) {
+  const startDate = startTime instanceof Date ? startTime : new Date(startTime);
+  const endDate = duration != null ? new Date(startDate.getTime() + duration / 1_000_000) : null;
+
+  return (
+    <div className="@container/timeline">
+      <div className="flex flex-col gap-0.5 px-1 py-3">
+        <div className="flex items-center justify-between">
+          <span className="text-xs font-medium text-text-bright">Started</span>
+          <span className="text-xs font-medium text-text-bright">Finished</span>
+        </div>
+        <div className="flex items-center">
+          <span className="shrink-0 tabular-nums text-xxs text-text-dimmed @[350px]/timeline:text-xs">
+            <DateTimeAccurate date={startDate} showTooltip={false} />
+          </span>
+          <div className="ml-2 h-3 w-px bg-charcoal-600" />
+          <div className="h-px flex-1 bg-charcoal-600" />
+          {duration != null && (
+            <span className="shrink-0 tabular-nums px-2 text-xxs text-text-dimmed @[350px]/timeline:text-xs">
+              {formatSpanDuration(duration)}
+            </span>
+          )}
+          <div className="h-px flex-1 bg-charcoal-600" />
+          <div className="mr-2 h-3 w-px bg-charcoal-600" />
+          <span className="shrink-0 tabular-nums text-xxs text-text-dimmed @[350px]/timeline:text-xs">
+            {endDate ? (
+              <DateTimeAccurate date={endDate} previousDate={startDate} showTooltip={false} />
+            ) : (
+              <span className="text-charcoal-500">—</span>
+            )}
+          </span>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/SpanTitle.tsx b/apps/webapp/app/components/runs/v3/SpanTitle.tsx
index fb0105c45db..4c25fc7b9ae 100644
--- a/apps/webapp/app/components/runs/v3/SpanTitle.tsx
+++ b/apps/webapp/app/components/runs/v3/SpanTitle.tsx
@@ -3,6 +3,8 @@ import { TaskEventStyle } from "@trigger.dev/core/v3";
 import type { TaskEventLevel } from "@trigger.dev/database";
 import { Fragment } from "react";
 import { cn } from "~/utils/cn";
+import { tablerIcons } from "~/utils/tablerIcons";
+import tablerSpritePath from "~/components/primitives/tabler-sprite.svg";
 
 type SpanTitleProps = {
   message: string;
@@ -12,11 +14,16 @@ type SpanTitleProps = {
   isPartial: boolean;
   size: "small" | "large";
   hideAccessory?: boolean;
+  overrideDimmed?: boolean;
 };
 
 export function SpanTitle(event: SpanTitleProps) {
+  const textClass = eventTextClassName(event);
+  const finalTextClass =
+    event.overrideDimmed && textClass === "text-text-dimmed" ? "text-text-bright" : textClass;
+
   return (
-    <span className={cn("flex items-center gap-x-2 overflow-x-hidden", eventTextClassName(event))}>
+    <span className={cn("flex items-center gap-x-2 overflow-x-hidden", finalTextClass)}>
       <span className="truncate">{event.message}</span>{" "}
       {!event.hideAccessory && (
         <SpanAccessory accessory={event.style.accessory} size={event.size} />
@@ -45,20 +52,44 @@ function SpanAccessory({
         />
       );
     }
+    case "pills": {
+      return (
+        <span className="flex items-center gap-1">
+          {accessory.items.map((item, index) => (
+            <SpanPill key={index} text={item.text} icon={item.icon} />
+          ))}
+        </span>
+      );
+    }
     default: {
       return (
-        <div className={cn("flex gap-1")}>
+        <span className={cn("flex gap-1")}>
           {accessory.items.map((item, index) => (
             <span key={index} className={cn("inline-flex items-center gap-1")}>
               {item.text}
             </span>
           ))}
-        </div>
+        </span>
       );
     }
   }
 }
 
+function SpanPill({ text, icon }: { text: string; icon?: string }) {
+  const hasIcon = icon && tablerIcons.has(icon);
+
+  return (
+    <span className="inline-flex items-center gap-0.5 rounded-full border border-charcoal-700 bg-charcoal-850 px-1.5 py-px text-xxs text-text-dimmed">
+      {hasIcon && (
+        <svg className="size-3 stroke-[1.5] text-text-dimmed/70">
+          <use xlinkHref={`${tablerSpritePath}#${icon}`} />
+        </svg>
+      )}
+      <span className="truncate">{text}</span>
+    </span>
+  );
+}
+
 export function SpanCodePathAccessory({
   accessory,
   className,
diff --git a/apps/webapp/app/components/runs/v3/TaskRunStatus.tsx b/apps/webapp/app/components/runs/v3/TaskRunStatus.tsx
index ae5a6b28af5..73363e0daa6 100644
--- a/apps/webapp/app/components/runs/v3/TaskRunStatus.tsx
+++ b/apps/webapp/app/components/runs/v3/TaskRunStatus.tsx
@@ -12,6 +12,7 @@ import {
   XCircleIcon,
 } from "@heroicons/react/20/solid";
 import type { TaskRunStatus } from "@trigger.dev/database";
+import { runFriendlyStatus, type RunFriendlyStatus } from "@trigger.dev/core/v3";
 import assertNever from "assert-never";
 import { HourglassIcon } from "lucide-react";
 import { TimedOutIcon } from "~/assets/icons/TimedOutIcon";
@@ -236,43 +237,93 @@ export function runStatusClassNameColor(status: TaskRunStatus): string {
   }
 }
 
-export function runStatusTitle(status: TaskRunStatus): string {
-  switch (status) {
-    case "DELAYED":
-      return "Delayed";
-    case "PENDING":
-      return "Queued";
-    case "PENDING_VERSION":
-    case "WAITING_FOR_DEPLOY":
-      return "Pending version";
-    case "DEQUEUED":
-      return "Dequeued";
-    case "EXECUTING":
-      return "Executing";
-    case "WAITING_TO_RESUME":
-      return "Waiting";
-    case "RETRYING_AFTER_FAILURE":
-      return "Reattempting";
-    case "PAUSED":
-      return "Paused";
-    case "CANCELED":
-      return "Canceled";
-    case "INTERRUPTED":
-      return "Interrupted";
-    case "COMPLETED_SUCCESSFULLY":
-      return "Completed";
-    case "COMPLETED_WITH_ERRORS":
-      return "Failed";
-    case "SYSTEM_FAILURE":
-      return "System failure";
-    case "CRASHED":
-      return "Crashed";
-    case "EXPIRED":
-      return "Expired";
-    case "TIMED_OUT":
-      return "Timed out";
-    default: {
-      assertNever(status);
-    }
+export function runStatusTitle(status: TaskRunStatus): RunFriendlyStatus {
+  return runStatusTitleFromStatus[status];
+}
+
+export function runStatusFromFriendlyTitle(friendly: RunFriendlyStatus): TaskRunStatus {
+  const result = titlesStatusesArray.find(([_, f]) => f === friendly);
+  if (!result) {
+    throw new Error(`Unknown friendly status: ${friendly}`);
+  }
+  return result[0] as TaskRunStatus;
+}
+
+// runFriendlyStatus and RunFriendlyStatus are imported from @trigger.dev/core/v3
+// and re-exported here for backward compatibility.
+export { runFriendlyStatus, type RunFriendlyStatus } from "@trigger.dev/core/v3";
+
+/**
+ * Check if a value is a valid TaskRunStatus
+ */
+export function isTaskRunStatus(value: unknown): value is TaskRunStatus {
+  return typeof value === "string" && allTaskRunStatuses.includes(value as TaskRunStatus);
+}
+
+/**
+ * Check if a value is a valid RunFriendlyStatus
+ */
+export function isRunFriendlyStatus(value: unknown): value is RunFriendlyStatus {
+  return typeof value === "string" && runFriendlyStatus.includes(value as RunFriendlyStatus);
+}
+
+export const runStatusTitleFromStatus: Record<TaskRunStatus, RunFriendlyStatus> = {
+  DELAYED: "Delayed",
+  PENDING: "Queued",
+  PENDING_VERSION: "Pending version",
+  WAITING_FOR_DEPLOY: "Pending version",
+  DEQUEUED: "Dequeued",
+  EXECUTING: "Executing",
+  WAITING_TO_RESUME: "Waiting",
+  RETRYING_AFTER_FAILURE: "Reattempting",
+  PAUSED: "Paused",
+  CANCELED: "Canceled",
+  INTERRUPTED: "Interrupted",
+  COMPLETED_SUCCESSFULLY: "Completed",
+  COMPLETED_WITH_ERRORS: "Failed",
+  SYSTEM_FAILURE: "System failure",
+  CRASHED: "Crashed",
+  EXPIRED: "Expired",
+  TIMED_OUT: "Timed out",
+};
+
+const titlesStatusesArray = Object.entries(runStatusTitleFromStatus);
+
+/**
+ * Hex color for each TaskRunStatus, mirroring `runStatusClassNameColor` but as
+ * concrete hex values for non-CSS contexts (e.g. chart series colors).
+ */
+const RUN_STATUS_HEX_COLORS: Record<TaskRunStatus, string> = {
+  PENDING: "#5F6570", // charcoal-500
+  DELAYED: "#6B7580", // charcoal ~450
+  PENDING_VERSION: "#f59e0b", // amber-500
+  WAITING_FOR_DEPLOY: "#d97706", // amber-600
+  EXECUTING: "#3b82f6", // blue-500
+  RETRYING_AFTER_FAILURE: "#2f6fec", // blue ~550
+  DEQUEUED: "#4D8EF5", // blue ~475
+  WAITING_TO_RESUME: "#555D67", // charcoal ~550
+  PAUSED: "#fbbf24", // amber-400
+  CANCELED: "#78828C", // charcoal ~400
+  EXPIRED: "#848D96", // charcoal ~350
+  INTERRUPTED: "#D52C4D", // rose — evenly spaced (error)
+  COMPLETED_SUCCESSFULLY: "#28BF5C", // mint-500 (success)
+  COMPLETED_WITH_ERRORS: "#DE405C", // rose — evenly spaced (error)
+  SYSTEM_FAILURE: "#E7536C", // rose — evenly spaced (error)
+  CRASHED: "#cc193d", // rose — darkest (error)
+  TIMED_OUT: "#F0667B", // rose — lightest (error)
+};
+
+/**
+ * Get the hex color for a run status value. Accepts either a raw TaskRunStatus
+ * (e.g. "COMPLETED_SUCCESSFULLY") or a friendly name (e.g. "Completed").
+ * Returns `undefined` when the value is not a recognised status.
+ */
+export function getRunStatusHexColor(value: string): string | undefined {
+  if (isTaskRunStatus(value)) {
+    return RUN_STATUS_HEX_COLORS[value];
+  }
+  if (isRunFriendlyStatus(value)) {
+    return RUN_STATUS_HEX_COLORS[runStatusFromFriendlyTitle(value)];
   }
+  return undefined;
 }
diff --git a/apps/webapp/app/components/runs/v3/TaskRunsTable.tsx b/apps/webapp/app/components/runs/v3/TaskRunsTable.tsx
index 14cdf5a67b8..fbede0e7cec 100644
--- a/apps/webapp/app/components/runs/v3/TaskRunsTable.tsx
+++ b/apps/webapp/app/components/runs/v3/TaskRunsTable.tsx
@@ -69,6 +69,7 @@ type RunsTableProps = {
   allowSelection?: boolean;
   variant?: TableVariant;
   disableAdjacentRows?: boolean;
+  additionalTableState?: Record<string, string>;
 };
 
 export function TaskRunsTable({
@@ -81,6 +82,7 @@ export function TaskRunsTable({
   isLoading = false,
   allowSelection = false,
   variant = "dimmed",
+  additionalTableState,
 }: RunsTableProps) {
   const organization = useOrganization();
   const project = useProject();
@@ -89,8 +91,16 @@ export function TaskRunsTable({
   const { isManagedCloud } = useFeatures();
   const { value } = useSearchParams();
   const location = useOptimisticLocation();
-  const rootOnly = value("rootOnly") ? `` : `rootOnly=${rootOnlyDefault}`;
-  const search = rootOnly ? `${rootOnly}&${location.search}` : location.search;
+  const params = new URLSearchParams(location.search || "");
+  if (!value("rootOnly")) {
+    params.set("rootOnly", String(rootOnlyDefault));
+  }
+  if (additionalTableState) {
+    for (const [key, val] of Object.entries(additionalTableState)) {
+      params.set(key, val);
+    }
+  }
+  const search = params.toString();
   /** TableState has to be encoded as a separate URI component, so it's merged under one, 'tableState' param */
   const tableStateParam = disableAdjacentRows ? '' : encodeURIComponent(search);
 
diff --git a/apps/webapp/app/components/runs/v3/ai/AIChatMessages.tsx b/apps/webapp/app/components/runs/v3/ai/AIChatMessages.tsx
new file mode 100644
index 00000000000..297234b8d05
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AIChatMessages.tsx
@@ -0,0 +1,353 @@
+import {
+  CheckIcon,
+  ChevronDownIcon,
+  ChevronUpIcon,
+  ClipboardDocumentIcon,
+  CodeBracketSquareIcon,
+} from "@heroicons/react/20/solid";
+import { lazy, Suspense, useState } from "react";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Header3 } from "~/components/primitives/Headers";
+import tablerSpritePath from "~/components/primitives/tabler-sprite.svg";
+import type { DisplayItem, ToolUse } from "./types";
+
+// Lazy load streamdown to avoid SSR issues
+const StreamdownRenderer = lazy(() =>
+  import("streamdown").then((mod) => ({
+    default: ({ children }: { children: string }) => (
+      <mod.ShikiThemeContext.Provider value={["one-dark-pro", "one-dark-pro"]}>
+        <mod.Streamdown isAnimating={false}>{children}</mod.Streamdown>
+      </mod.ShikiThemeContext.Provider>
+    ),
+  }))
+);
+
+export type PromptLink = {
+  slug: string;
+  version?: string;
+  path: string;
+};
+
+export function AIChatMessages({
+  items,
+  promptLink,
+}: {
+  items: DisplayItem[];
+  promptLink?: PromptLink;
+}) {
+  return (
+    <div className="flex flex-col gap-1">
+      {items.map((item, i) => {
+        switch (item.type) {
+          case "system":
+            return <SystemSection key={i} text={item.text} promptLink={promptLink} />;
+          case "user":
+            return <UserSection key={i} text={item.text} />;
+          case "tool-use":
+            return <ToolUseSection key={i} tools={item.tools} />;
+          case "assistant":
+            return <AssistantResponse key={i} text={item.text} />;
+        }
+      })}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Section header (shared across all sections)
+// ---------------------------------------------------------------------------
+
+function SectionHeader({ label, right }: { label: string; right?: React.ReactNode }) {
+  return (
+    <div className="flex items-center justify-between">
+      <Header3>{label}</Header3>
+      {right && <div className="flex items-center gap-2">{right}</div>}
+    </div>
+  );
+}
+
+export function ChatBubble({ children }: { children: React.ReactNode }) {
+  return (
+    <div className="rounded-md border border-grid-bright bg-charcoal-750/50 px-3.5 py-2">
+      {children}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// System
+// ---------------------------------------------------------------------------
+
+function SystemSection({
+  text,
+  promptLink,
+}: {
+  text: string;
+  promptLink?: PromptLink;
+}) {
+  const [expanded, setExpanded] = useState(false);
+  const isLong = text.length > 150;
+  const preview = isLong ? text.slice(0, 150) + "..." : text;
+  const displayText = expanded || !isLong ? text : preview;
+
+  return (
+    <div className="flex flex-col gap-1.5 py-2.5">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-1.5">
+          <Header3>System</Header3>
+          {promptLink && (
+            <LinkButton to={promptLink.path} variant="minimal/small">
+              <span className="flex items-center gap-1">
+                <svg className="size-3.5 shrink-0 text-text-dimmed">
+                  <use xlinkHref={`${tablerSpritePath}#tabler-file-text-ai`} />
+                </svg>
+                {promptLink.slug}
+                {promptLink.version ? ` v${promptLink.version}` : ""}
+              </span>
+            </LinkButton>
+          )}
+        </div>
+        {isLong && (
+          <Button
+            variant="minimal/small"
+            onClick={() => setExpanded(!expanded)}
+            LeadingIcon={expanded ? ChevronUpIcon : ChevronDownIcon}
+            aria-label={expanded ? "Collapse" : "Expand"}
+            aria-expanded={expanded}
+          />
+        )}
+      </div>
+      <ChatBubble>
+        <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+          <Suspense fallback={<span className="whitespace-pre-wrap">{displayText}</span>}>
+            <StreamdownRenderer>{displayText}</StreamdownRenderer>
+          </Suspense>
+        </div>
+      </ChatBubble>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// User
+// ---------------------------------------------------------------------------
+
+function UserSection({ text }: { text: string }) {
+  return (
+    <div className="flex flex-col gap-1.5 py-2.5">
+      <SectionHeader label="User" />
+      <ChatBubble>
+        <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+          <Suspense fallback={<span className="whitespace-pre-wrap">{text}</span>}>
+            <StreamdownRenderer>{text}</StreamdownRenderer>
+          </Suspense>
+        </div>
+      </ChatBubble>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Assistant response (with markdown/raw toggle)
+// ---------------------------------------------------------------------------
+
+function isJsonString(value: string): boolean {
+  const trimmed = value.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function AssistantResponse({
+  text,
+  headerLabel = "Assistant",
+}: {
+  text: string;
+  headerLabel?: string;
+}) {
+  const isJson = isJsonString(text);
+  const [mode, setMode] = useState<"rendered" | "raw">("rendered");
+  const [copied, setCopied] = useState(false);
+
+  function handleCopy() {
+    navigator.clipboard.writeText(text);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2000);
+  }
+
+  if (isJson) {
+    return (
+      <div className="flex flex-col gap-1.5 py-2.5">
+        <SectionHeader label={headerLabel} />
+        <CodeBlock
+          code={text}
+          maxLines={20}
+          showLineNumbers={false}
+          showCopyButton
+          language="json"
+        />
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-1.5 py-2.5">
+      <SectionHeader
+        label={headerLabel}
+        right={
+          <div className="flex items-center">
+            <Button
+              variant="minimal/small"
+              onClick={() => setMode(mode === "rendered" ? "raw" : "rendered")}
+              LeadingIcon={CodeBracketSquareIcon}
+            >
+              {mode === "rendered" ? "Raw" : "Rendered"}
+            </Button>
+            <Button
+              variant="minimal/small"
+              onClick={handleCopy}
+              LeadingIcon={copied ? CheckIcon : ClipboardDocumentIcon}
+              leadingIconClassName={copied ? "text-green-500" : undefined}
+            >
+              Copy
+            </Button>
+          </div>
+        }
+      />
+      {mode === "rendered" ? (
+        <ChatBubble>
+          <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+            <Suspense fallback={<span className="whitespace-pre-wrap">{text}</span>}>
+              <StreamdownRenderer>{text}</StreamdownRenderer>
+            </Suspense>
+          </div>
+        </ChatBubble>
+      ) : (
+        <CodeBlock
+          code={text}
+          maxLines={20}
+          showLineNumbers={false}
+          showCopyButton={false}
+          className="pl-2"
+        />
+      )}
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tool use (merged calls + results)
+// ---------------------------------------------------------------------------
+
+function ToolUseSection({ tools }: { tools: ToolUse[] }) {
+  return (
+    <div className="flex flex-col gap-1.5 py-2.5">
+      <SectionHeader label={tools.length === 1 ? "Tool call" : `Tool calls (${tools.length})`} />
+      <div className="flex flex-col gap-2">
+        {tools.map((tool) => (
+          <ToolUseRow key={tool.toolCallId} tool={tool} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+type ToolTab = "input" | "output" | "details";
+
+function ToolUseRow({ tool }: { tool: ToolUse }) {
+  const hasInput = tool.inputJson !== "{}";
+  const hasResult = !!tool.resultOutput;
+  const hasDetails = !!tool.description || !!tool.parametersJson;
+
+  const availableTabs: ToolTab[] = [
+    ...(hasInput ? (["input"] as const) : []),
+    ...(hasResult ? (["output"] as const) : []),
+    ...(hasDetails ? (["details"] as const) : []),
+  ];
+
+  const defaultTab: ToolTab | null = hasInput ? "input" : null;
+  const [activeTab, setActiveTab] = useState<ToolTab | null>(defaultTab);
+
+  function handleTabClick(tab: ToolTab) {
+    setActiveTab(activeTab === tab ? null : tab);
+  }
+
+  return (
+    <div className="rounded-sm border border-grid-bright bg-charcoal-800/40">
+      <div className="flex items-center gap-2 px-2.5 py-1.5">
+        <code className="font-mono text-xs text-text-bright">{tool.toolName}</code>
+        {tool.resultSummary && (
+          <span className="ml-auto text-[10px] text-text-dimmed">{tool.resultSummary}</span>
+        )}
+      </div>
+
+      {availableTabs.length > 0 && (
+        <>
+          <div className="flex gap-0 border-t border-grid-bright">
+            {availableTabs.map((tab) => (
+              <button
+                key={tab}
+                onClick={() => handleTabClick(tab)}
+                className={`px-2.5 py-1 text-[11px] capitalize transition-colors ${
+                  activeTab === tab
+                    ? "bg-charcoal-750 text-text-bright"
+                    : "text-text-dimmed hover:text-text-bright"
+                }`}
+              >
+                {tab}
+              </button>
+            ))}
+          </div>
+
+          {activeTab === "input" && hasInput && (
+            <div className="border-t border-grid-dimmed">
+              <CodeBlock
+                code={tool.inputJson}
+                maxLines={12}
+                showLineNumbers={false}
+                showCopyButton
+              />
+            </div>
+          )}
+
+          {activeTab === "output" && hasResult && (
+            <div className="border-t border-grid-dimmed">
+              <CodeBlock
+                code={tool.resultOutput!}
+                maxLines={16}
+                showLineNumbers={false}
+                showCopyButton
+              />
+            </div>
+          )}
+
+          {activeTab === "details" && hasDetails && (
+            <div className="flex flex-col gap-2 border-t border-grid-dimmed px-2.5 py-2">
+              {tool.description && (
+                <p className="text-xs leading-relaxed text-text-dimmed">{tool.description}</p>
+              )}
+              {tool.parametersJson && (
+                <div>
+                  <span className="text-[10px] font-medium uppercase tracking-wide text-text-dimmed">
+                    Parameters schema
+                  </span>
+                  <CodeBlock
+                    code={tool.parametersJson}
+                    maxLines={16}
+                    showLineNumbers={false}
+                    showCopyButton
+                  />
+                </div>
+              )}
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/ai/AIEmbedSpanDetails.tsx b/apps/webapp/app/components/runs/v3/ai/AIEmbedSpanDetails.tsx
new file mode 100644
index 00000000000..26794e2f9db
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AIEmbedSpanDetails.tsx
@@ -0,0 +1,66 @@
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { formatDuration } from "./aiHelpers";
+import { SpanMetricRow as MetricRow } from "./SpanMetricRow";
+
+export type AIEmbedData = {
+  model: string;
+  provider: string;
+  value?: string;
+  durationMs: number;
+};
+
+export function extractAIEmbedData(
+  properties: Record<string, unknown>,
+  durationMs: number
+): AIEmbedData | undefined {
+  const ai = properties.ai;
+  if (!ai || typeof ai !== "object") return undefined;
+
+  const a = ai as Record<string, unknown>;
+  if (a.operationId !== "ai.embed") return undefined;
+
+  const aiModel = a.model;
+  if (!aiModel || typeof aiModel !== "object") return undefined;
+
+  const m = aiModel as Record<string, unknown>;
+  const model = typeof m.id === "string" ? m.id : undefined;
+  if (!model) return undefined;
+
+  return {
+    model,
+    provider: typeof m.provider === "string" ? m.provider : "unknown",
+    value: typeof a.value === "string" ? a.value : undefined,
+    durationMs,
+  };
+}
+
+export function AIEmbedSpanDetails({ data }: { data: AIEmbedData }) {
+  return (
+    <div className="flex h-full flex-col overflow-hidden">
+      <div className="flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <div className="flex flex-col px-3">
+          {/* Model info */}
+          <div className="flex flex-col gap-1 py-2.5">
+            <div className="flex flex-col text-xs @container">
+              <MetricRow label="Model" value={data.model} />
+              <MetricRow label="Provider" value={data.provider} />
+              <MetricRow label="Duration" value={formatDuration(data.durationMs)} />
+            </div>
+          </div>
+
+          {/* Input value */}
+          {data.value && (
+            <div className="flex flex-col gap-1.5 py-2.5">
+              <Header3>Input</Header3>
+              <div className="rounded-md border border-grid-bright bg-charcoal-750/50 px-3.5 py-2">
+                <Paragraph variant="small/dimmed">{data.value}</Paragraph>
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
diff --git a/apps/webapp/app/components/runs/v3/ai/AIModelSummary.tsx b/apps/webapp/app/components/runs/v3/ai/AIModelSummary.tsx
new file mode 100644
index 00000000000..95cf0001824
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AIModelSummary.tsx
@@ -0,0 +1,148 @@
+import type { ReactNode } from "react";
+import { formatCurrencyAccurate } from "~/utils/numberFormatter";
+import { Header3 } from "~/components/primitives/Headers";
+import { TextLink } from "~/components/primitives/TextLink";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { v3PromptPath } from "~/utils/pathBuilder";
+import { TruncatedCopyableValue } from "~/components/primitives/TruncatedCopyableValue";
+import type { AISpanData } from "./types";
+
+export function AITagsRow({ aiData }: { aiData: AISpanData }) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const promptLink =
+    aiData.promptSlug && organization && project && environment
+      ? v3PromptPath(organization, project, environment, aiData.promptSlug, aiData.promptVersion)
+      : undefined;
+
+  return (
+    <div className="flex flex-col gap-1 py-2.5">
+      <div className="flex flex-col text-xs @container">
+        {aiData.responseId && (
+          <MetricRow label="Response ID" value={<TruncatedCopyableValue value={aiData.responseId} />} />
+        )}
+        <MetricRow label="Model" value={aiData.model} />
+        {aiData.provider !== "unknown" && <MetricRow label="Provider" value={aiData.provider} />}
+        {aiData.resolvedProvider && (
+          <MetricRow label="Resolved provider" value={aiData.resolvedProvider} />
+        )}
+        {aiData.promptSlug && (
+          <MetricRow
+            label="Prompt"
+            value={
+              promptLink ? (
+                <TextLink to={promptLink}>
+                  {aiData.promptSlug}
+                  {aiData.promptVersion ? ` v${aiData.promptVersion}` : ""}
+                </TextLink>
+              ) : (
+                `${aiData.promptSlug}${aiData.promptVersion ? ` v${aiData.promptVersion}` : ""}`
+              )
+            }
+          />
+        )}
+        {aiData.finishReason && <MetricRow label="Finish reason" value={aiData.finishReason} />}
+        {aiData.serviceTier && <MetricRow label="Service tier" value={aiData.serviceTier} />}
+        {aiData.toolChoice && <MetricRow label="Tool choice" value={aiData.toolChoice} />}
+        {aiData.toolCount != null && aiData.toolCount > 0 && (
+          <MetricRow
+            label="Tools provided"
+            value={`${aiData.toolCount} ${aiData.toolCount === 1 ? "tool" : "tools"}`}
+          />
+        )}
+        {aiData.messageCount != null && (
+          <MetricRow
+            label="Messages"
+            value={`${aiData.messageCount} ${aiData.messageCount === 1 ? "message" : "messages"}`}
+          />
+        )}
+        {aiData.telemetryMetadata &&
+          Object.entries(aiData.telemetryMetadata)
+            .filter(([key]) => key !== "prompt")
+            .map(([key, value]) => <MetricRow key={key} label={key} value={value} />)}
+      </div>
+    </div>
+  );
+}
+
+export function AIStatsSummary({ aiData }: { aiData: AISpanData }) {
+  return (
+    <div className="flex flex-col gap-1 py-2.5">
+      <Header3>Stats</Header3>
+      <div className="flex flex-col text-xs @container">
+        <MetricRow label="Input" value={aiData.inputTokens.toLocaleString()} unit="tokens" />
+        <MetricRow label="Output" value={aiData.outputTokens.toLocaleString()} unit="tokens" />
+        {aiData.cachedTokens != null && aiData.cachedTokens > 0 && (
+          <MetricRow
+            label="Cache read"
+            value={aiData.cachedTokens.toLocaleString()}
+            unit="tokens"
+          />
+        )}
+        {aiData.cacheCreationTokens != null && aiData.cacheCreationTokens > 0 && (
+          <MetricRow
+            label="Cache write"
+            value={aiData.cacheCreationTokens.toLocaleString()}
+            unit="tokens"
+          />
+        )}
+        {aiData.reasoningTokens != null && aiData.reasoningTokens > 0 && (
+          <MetricRow
+            label="Reasoning"
+            value={aiData.reasoningTokens.toLocaleString()}
+            unit="tokens"
+          />
+        )}
+        <MetricRow label="Total" value={aiData.totalTokens.toLocaleString()} unit="tokens" bold />
+
+        {aiData.totalCost != null && (
+          <MetricRow label="Cost" value={formatCurrencyAccurate(aiData.totalCost)} />
+        )}
+        {aiData.msToFirstChunk != null && (
+          <MetricRow label="TTFC" value={formatTtfc(aiData.msToFirstChunk)} />
+        )}
+        {aiData.tokensPerSecond != null && (
+          <MetricRow label="Speed" value={`${Math.round(aiData.tokensPerSecond)} tok/s`} />
+        )}
+      </div>
+    </div>
+  );
+}
+
+function MetricRow({
+  label,
+  value,
+  unit,
+  bold,
+}: {
+  label: string;
+  value: ReactNode;
+  unit?: string;
+  bold?: boolean;
+}) {
+  return (
+    <div className="grid h-7 grid-cols-[1fr_auto] items-center gap-4 rounded-sm px-1.5 transition odd:bg-charcoal-750/40 @[28rem]:grid-cols-[8rem_1fr] hover:bg-white/[0.04]">
+      <span className="text-text-dimmed">{label}</span>
+      <span
+        className={`text-right @[28rem]:text-left ${
+          bold ? "font-medium text-text-bright" : "text-text-bright"
+        }`}
+      >
+        {value}
+        {unit && <span className="ml-1 text-text-dimmed">{unit}</span>}
+      </span>
+    </div>
+  );
+}
+
+function formatTtfc(ms: number): string {
+  if (ms >= 10_000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+  return `${Math.round(ms)}ms`;
+}
+
diff --git a/apps/webapp/app/components/runs/v3/ai/AISpanDetails.tsx b/apps/webapp/app/components/runs/v3/ai/AISpanDetails.tsx
new file mode 100644
index 00000000000..5e8bb65688f
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AISpanDetails.tsx
@@ -0,0 +1,360 @@
+import { CheckIcon, ClipboardDocumentIcon } from "@heroicons/react/20/solid";
+import { lazy, Suspense, useState } from "react";
+import { Button } from "~/components/primitives/Buttons";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { TabButton, TabContainer } from "~/components/primitives/Tabs";
+import { TextLink } from "~/components/primitives/TextLink";
+import { tryPrettyJson } from "./aiHelpers";
+import { SpanMetricRow as PromptMetricRow } from "./SpanMetricRow";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useHasAdminAccess } from "~/hooks/useUser";
+import { v3PromptPath } from "~/utils/pathBuilder";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { AIChatMessages, AssistantResponse, ChatBubble, type PromptLink } from "./AIChatMessages";
+import { AIStatsSummary, AITagsRow } from "./AIModelSummary";
+import { AIToolsInventory } from "./AIToolsInventory";
+import type { AISpanData, DisplayItem } from "./types";
+import type { PromptSpanData } from "~/presenters/v3/SpanPresenter.server";
+import { SpanHorizontalTimeline } from "~/components/runs/v3/SpanHorizontalTimeline";
+
+const StreamdownRenderer = lazy(() =>
+  import("streamdown").then((mod) => ({
+    default: ({ children }: { children: string }) => (
+      <mod.ShikiThemeContext.Provider value={["one-dark-pro", "one-dark-pro"]}>
+        <mod.Streamdown isAnimating={false}>{children}</mod.Streamdown>
+      </mod.ShikiThemeContext.Provider>
+    ),
+  }))
+);
+
+type AITab = "overview" | "messages" | "tools" | "prompt";
+
+export function AISpanDetails({
+  aiData,
+  promptVersionData,
+  rawProperties,
+  startTime,
+  duration,
+}: {
+  aiData: AISpanData;
+  promptVersionData?: PromptSpanData;
+  rawProperties?: string;
+  startTime?: string | Date;
+  duration?: number | null;
+}) {
+  const [tab, setTab] = useState<AITab>("overview");
+  const isAdmin = useHasAdminAccess();
+  const toolCount = aiData.toolCount ?? aiData.toolDefinitions?.length ?? 0;
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const promptLink: PromptLink | undefined =
+    aiData.promptSlug && organization && project && environment
+      ? {
+          slug: aiData.promptSlug,
+          version: aiData.promptVersion,
+          path: v3PromptPath(organization, project, environment, aiData.promptSlug, aiData.promptVersion),
+        }
+      : undefined;
+
+  return (
+    <div className="flex h-full flex-col overflow-hidden">
+      {/* Tab bar */}
+      <div className="shrink-0 overflow-x-auto px-3 py-1 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <TabContainer>
+          <TabButton
+            isActive={tab === "overview"}
+            layoutId="ai-span"
+            onClick={() => setTab("overview")}
+            shortcut={{ key: "o" }}
+          >
+            Overview
+          </TabButton>
+          <TabButton
+            isActive={tab === "messages"}
+            layoutId="ai-span"
+            onClick={() => setTab("messages")}
+            shortcut={{ key: "m" }}
+          >
+            Messages
+          </TabButton>
+          <TabButton
+            isActive={tab === "tools"}
+            layoutId="ai-span"
+            onClick={() => setTab("tools")}
+            shortcut={{ key: "t" }}
+          >
+            <span className="inline-flex items-center whitespace-nowrap">
+              Tools
+              {toolCount > 0 && (
+                <span className="ml-1 inline-flex min-w-4 -translate-y-px items-center justify-center rounded-full border border-charcoal-600 bg-charcoal-650 px-1 py-0.5 text-[0.625rem] font-medium leading-none text-text-bright">
+                  {toolCount}
+                </span>
+              )}
+            </span>
+          </TabButton>
+          {promptVersionData && (
+            <TabButton
+              isActive={tab === "prompt"}
+              layoutId="ai-span"
+              onClick={() => setTab("prompt")}
+              shortcut={{ key: "p" }}
+            >
+              Prompt
+            </TabButton>
+          )}
+        </TabContainer>
+      </div>
+
+      {/* Tab content */}
+      <div className="scrollbar-gutter-stable min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        {tab === "overview" && (
+          <>
+            {startTime && <div className="px-3"><SpanHorizontalTimeline startTime={startTime} duration={duration ?? null} /></div>}
+            <OverviewTab aiData={aiData} />
+          </>
+        )}
+        {tab === "messages" && <MessagesTab aiData={aiData} promptLink={promptLink} />}
+        {tab === "tools" && <ToolsTab aiData={aiData} />}
+        {tab === "prompt" && promptVersionData && (
+          <PromptTab promptData={promptVersionData} promptLink={promptLink} />
+        )}
+      </div>
+
+      {/* Footer: Copy raw (admin only) */}
+      {isAdmin && rawProperties && <CopyRawFooter rawProperties={rawProperties} />}
+    </div>
+  );
+}
+
+function OverviewTab({ aiData }: { aiData: AISpanData }) {
+  const { userText, outputText, outputObject, outputToolNames } = extractInputOutput(aiData);
+
+  return (
+    <div className="flex flex-col px-3">
+      <AITagsRow aiData={aiData} />
+      <AIStatsSummary aiData={aiData} />
+
+      {userText && (
+        <div className="flex flex-col gap-1.5 py-2.5">
+          <Header3>Input</Header3>
+          <ChatBubble>
+            <Paragraph variant="small/dimmed">{userText}</Paragraph>
+          </ChatBubble>
+        </div>
+      )}
+
+      {outputText && <AssistantResponse text={outputText} headerLabel="Output" />}
+      {!outputText && outputObject && (
+        <div className="flex flex-col gap-1.5 py-2.5">
+          <Header3>Output</Header3>
+          <CodeBlock
+            code={outputObject}
+            maxLines={20}
+            showLineNumbers={false}
+            showCopyButton
+            language="json"
+          />
+        </div>
+      )}
+      {outputToolNames.length > 0 && !outputText && !outputObject && (
+        <div className="flex flex-col gap-1.5 py-2.5">
+          <Header3>Output</Header3>
+          <ChatBubble>
+            <Paragraph variant="small/dimmed">
+              Called {outputToolNames.length === 1 ? "tool" : "tools"}:{" "}
+              <span className="font-mono text-text-bright">{outputToolNames.join(", ")}</span>
+            </Paragraph>
+          </ChatBubble>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function MessagesTab({
+  aiData,
+  promptLink,
+}: {
+  aiData: AISpanData;
+  promptLink?: PromptLink;
+}) {
+  const showFallbackText = aiData.responseText && !hasAssistantItem(aiData.items);
+  const showFallbackObject =
+    !showFallbackText && aiData.responseObject && !hasAssistantItem(aiData.items);
+
+  return (
+    <div className="px-3">
+      <div className="flex flex-col">
+        {aiData.items && aiData.items.length > 0 && (
+          <AIChatMessages items={aiData.items} promptLink={promptLink} />
+        )}
+        {showFallbackText && <AssistantResponse text={aiData.responseText!} />}
+        {showFallbackObject && (
+          <div className="flex flex-col gap-1.5 py-2.5">
+            <Header3>Assistant</Header3>
+            <CodeBlock
+              code={aiData.responseObject!}
+              maxLines={20}
+              showLineNumbers={false}
+              showCopyButton
+              language="json"
+            />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function ToolsTab({ aiData }: { aiData: AISpanData }) {
+  return <AIToolsInventory aiData={aiData} />;
+}
+
+function CopyRawFooter({ rawProperties }: { rawProperties: string }) {
+  const [copied, setCopied] = useState(false);
+
+  function handleCopy() {
+    navigator.clipboard.writeText(rawProperties);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2000);
+  }
+
+  return (
+    <div className="flex h-[3.25rem] shrink-0 items-center justify-end border-t border-grid-dimmed px-2">
+      <Button
+        variant="minimal/medium"
+        onClick={handleCopy}
+        LeadingIcon={copied ? CheckIcon : ClipboardDocumentIcon}
+        leadingIconClassName={copied ? "text-green-500" : undefined}
+      >
+        Copy raw properties
+      </Button>
+    </div>
+  );
+}
+
+function PromptTab({
+  promptData,
+  promptLink,
+}: {
+  promptData: PromptSpanData;
+  promptLink?: PromptLink;
+}) {
+  const labels = promptData.labels
+    ? promptData.labels.split(",").map((l) => l.trim()).filter(Boolean)
+    : [];
+
+  return (
+    <div className="flex flex-col px-3">
+      {/* Prompt properties */}
+      <div className="flex flex-col gap-1 py-2.5">
+        <div className="flex flex-col text-xs @container">
+          <PromptMetricRow
+            label="Prompt"
+            value={
+              promptLink ? (
+                <TextLink to={promptLink.path}>{promptData.slug}</TextLink>
+              ) : (
+                promptData.slug
+              )
+            }
+          />
+          <PromptMetricRow label="Version" value={`v${promptData.version}`} />
+          {labels.length > 0 && <PromptMetricRow label="Labels" value={labels.join(", ")} />}
+          {promptData.model && <PromptMetricRow label="Model" value={promptData.model} />}
+        </div>
+      </div>
+
+      {/* Prompt input (variables passed to resolve()) */}
+      {promptData.input && (
+        <div className="flex flex-col gap-1.5 py-2.5">
+          <Header3>Input</Header3>
+          <CodeBlock
+            code={tryPrettyJson(promptData.input)}
+            maxLines={20}
+            showLineNumbers={false}
+            showCopyButton
+            language="json"
+          />
+        </div>
+      )}
+
+      {/* Template (from the prompt version) */}
+      {promptData.template && (
+        <div className="flex flex-col gap-1.5 py-2.5">
+          <Header3>Template</Header3>
+          <div className="rounded-md border border-grid-bright bg-charcoal-750/50 px-3.5 py-2">
+            <div className="font-sans text-sm font-normal text-text-dimmed streamdown-container">
+              <Suspense
+                fallback={<span className="whitespace-pre-wrap">{promptData.template}</span>}
+              >
+                <StreamdownRenderer>{promptData.template}</StreamdownRenderer>
+              </Suspense>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function extractInputOutput(aiData: AISpanData): {
+  userText: string | undefined;
+  outputText: string | undefined;
+  outputObject: string | undefined;
+  outputToolNames: string[];
+} {
+  let userText: string | undefined;
+  let outputText: string | undefined;
+  const outputToolNames: string[] = [];
+
+  if (aiData.items) {
+    for (let i = aiData.items.length - 1; i >= 0; i--) {
+      if (aiData.items[i].type === "user") {
+        userText = (aiData.items[i] as { type: "user"; text: string }).text;
+        break;
+      }
+    }
+
+    for (let i = aiData.items.length - 1; i >= 0; i--) {
+      const item = aiData.items[i];
+      if (item.type === "assistant") {
+        outputText = item.text;
+        break;
+      }
+      if (item.type === "tool-use") {
+        for (const tool of item.tools) {
+          outputToolNames.push(tool.toolName);
+        }
+        break;
+      }
+    }
+  }
+
+  if (!outputText && aiData.responseText) {
+    outputText = aiData.responseText;
+  }
+
+  return {
+    userText,
+    outputText,
+    outputObject: aiData.responseObject ? tryPrettyJson(aiData.responseObject) : undefined,
+    outputToolNames,
+  };
+}
+
+function hasAssistantItem(items: DisplayItem[] | undefined): boolean {
+  if (!items) return false;
+  return items.some((item) => item.type === "assistant");
+}
diff --git a/apps/webapp/app/components/runs/v3/ai/AIToolCallSpanDetails.tsx b/apps/webapp/app/components/runs/v3/ai/AIToolCallSpanDetails.tsx
new file mode 100644
index 00000000000..078f0b18d47
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AIToolCallSpanDetails.tsx
@@ -0,0 +1,76 @@
+import { Header3 } from "~/components/primitives/Headers";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { TruncatedCopyableValue } from "~/components/primitives/TruncatedCopyableValue";
+import { formatDuration, tryPrettyJson } from "./aiHelpers";
+import { SpanMetricRow as MetricRow } from "./SpanMetricRow";
+
+export type AIToolCallData = {
+  toolName: string;
+  toolCallId: string;
+  args?: string;
+  durationMs: number;
+};
+
+export function extractAIToolCallData(
+  properties: Record<string, unknown>,
+  durationMs: number
+): AIToolCallData | undefined {
+  const ai = properties.ai;
+  if (!ai || typeof ai !== "object") return undefined;
+
+  const a = ai as Record<string, unknown>;
+  if (a.operationId !== "ai.toolCall") return undefined;
+
+  const toolCall = a.toolCall;
+  if (!toolCall || typeof toolCall !== "object") return undefined;
+
+  const tc = toolCall as Record<string, unknown>;
+  const toolName = typeof tc.name === "string" ? tc.name : undefined;
+  if (!toolName) return undefined;
+
+  return {
+    toolName,
+    toolCallId: typeof tc.id === "string" ? tc.id : "",
+    args: typeof tc.args === "string" ? tc.args : undefined,
+    durationMs,
+  };
+}
+
+export function AIToolCallSpanDetails({ data }: { data: AIToolCallData }) {
+  return (
+    <div className="flex h-full flex-col overflow-hidden">
+      <div className="flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <div className="flex flex-col px-3">
+          {/* Tool info */}
+          <div className="flex flex-col gap-1 py-2.5">
+            <div className="flex flex-col text-xs @container">
+              <MetricRow label="Tool" value={data.toolName} />
+              {data.toolCallId && (
+                <MetricRow
+                  label="Call ID"
+                  value={<TruncatedCopyableValue value={data.toolCallId} />}
+                />
+              )}
+              <MetricRow label="Duration" value={formatDuration(data.durationMs)} />
+            </div>
+          </div>
+
+          {/* Input args */}
+          {data.args && (
+            <div className="flex flex-col gap-1.5 py-2.5">
+              <Header3>Input</Header3>
+              <CodeBlock
+                code={tryPrettyJson(data.args)}
+                maxLines={20}
+                showLineNumbers={false}
+                showCopyButton
+                language="json"
+              />
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
diff --git a/apps/webapp/app/components/runs/v3/ai/AIToolsInventory.tsx b/apps/webapp/app/components/runs/v3/ai/AIToolsInventory.tsx
new file mode 100644
index 00000000000..a329698dd5e
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/AIToolsInventory.tsx
@@ -0,0 +1,84 @@
+import { useState } from "react";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import type { AISpanData, ToolDefinition } from "./types";
+import { Paragraph } from "~/components/primitives/Paragraph";
+
+export function AIToolsInventory({ aiData }: { aiData: AISpanData }) {
+  const defs = aiData.toolDefinitions ?? [];
+  const calledNames = getCalledToolNames(aiData);
+
+  if (defs.length === 0) {
+    return (
+      <div className="px-3 py-6 text-center">
+        <Paragraph variant="small/dimmed">No tool definitions available for this span.</Paragraph>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col divide-y divide-grid-bright px-3">
+      {defs.map((def) => {
+        const wasCalled = calledNames.has(def.name);
+        return <ToolDefRow key={def.name} def={def} wasCalled={wasCalled} />;
+      })}
+    </div>
+  );
+}
+
+function ToolDefRow({ def, wasCalled }: { def: ToolDefinition; wasCalled: boolean }) {
+  const [showSchema, setShowSchema] = useState(false);
+
+  return (
+    <div className="flex flex-col gap-1.5 py-2.5">
+      <div className="flex items-center gap-2">
+        <div
+          className={`size-1.5 shrink-0 rounded-full ${
+            wasCalled ? "bg-success" : "bg-charcoal-600"
+          }`}
+        />
+        <code className="font-mono text-xs text-text-bright">{def.name}</code>
+        <span className="text-[10px] text-text-dimmed">{wasCalled ? "called" : "not called"}</span>
+      </div>
+
+      {def.description && (
+        <p className="pl-3.5 text-xs leading-relaxed text-text-dimmed">{def.description}</p>
+      )}
+
+      {def.parametersJson && (
+        <div className="pl-3.5">
+          <button
+            onClick={() => setShowSchema(!showSchema)}
+            className="text-[10px] text-text-link hover:underline"
+          >
+            {showSchema ? "Hide schema" : "Show schema"}
+          </button>
+          {showSchema && (
+            <div className="mt-1">
+              <CodeBlock
+                code={def.parametersJson}
+                maxLines={16}
+                showLineNumbers={false}
+                showCopyButton
+              />
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function getCalledToolNames(aiData: AISpanData): Set<string> {
+  const names = new Set<string>();
+  if (!aiData.items) return names;
+
+  for (const item of aiData.items) {
+    if (item.type === "tool-use") {
+      for (const tool of item.tools) {
+        names.add(tool.toolName);
+      }
+    }
+  }
+
+  return names;
+}
diff --git a/apps/webapp/app/components/runs/v3/ai/SpanMetricRow.tsx b/apps/webapp/app/components/runs/v3/ai/SpanMetricRow.tsx
new file mode 100644
index 00000000000..81a96affdb6
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/SpanMetricRow.tsx
@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+
+export function SpanMetricRow({ label, value }: { label: string; value: ReactNode }) {
+  return (
+    <div className="grid h-7 grid-cols-[1fr_auto] items-center gap-4 rounded-sm px-1.5 transition odd:bg-charcoal-750/40 @[28rem]:grid-cols-[8rem_1fr] hover:bg-white/[0.04]">
+      <span className="text-text-dimmed">{label}</span>
+      <span className="text-right text-text-bright @[28rem]:text-left">{value}</span>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/components/runs/v3/ai/aiHelpers.ts b/apps/webapp/app/components/runs/v3/ai/aiHelpers.ts
new file mode 100644
index 00000000000..f9891aaa23d
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/aiHelpers.ts
@@ -0,0 +1,100 @@
+// Shared primitive helpers for AI span data extraction
+
+export function rec(v: unknown): Record<string, unknown> {
+  return v && typeof v === "object" ? (v as Record<string, unknown>) : {};
+}
+
+export function str(v: unknown): string | undefined {
+  return typeof v === "string" ? v : undefined;
+}
+
+export function num(v: unknown): number | undefined {
+  return typeof v === "number" ? v : undefined;
+}
+
+export function tryPrettyJson(value: string): string {
+  try {
+    return JSON.stringify(JSON.parse(value), null, 2);
+  } catch {
+    return value;
+  }
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60_000);
+  const secs = ((ms % 60_000) / 1000).toFixed(0);
+  return `${mins}m ${secs}s`;
+}
+
+/**
+ * Parse provider metadata from a JSON string.
+ * Handles Anthropic, Azure, OpenAI, Gateway, and OpenRouter formats.
+ */
+export function parseProviderMetadata(
+  raw: unknown
+): {
+  serviceTier?: string;
+  resolvedProvider?: string;
+  gatewayCost?: string;
+  responseId?: string;
+} | undefined {
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    if (!parsed || typeof parsed !== "object") return undefined;
+
+    let serviceTier: string | undefined;
+    let resolvedProvider: string | undefined;
+    let gatewayCost: string | undefined;
+    let responseId: string | undefined;
+
+    // Anthropic: { anthropic: { usage: { service_tier: "standard" } } }
+    const anthropic = rec(parsed.anthropic);
+    serviceTier = str(rec(anthropic.usage).service_tier);
+
+    // Azure/OpenAI: { azure: { serviceTier: "default" } } or { openai: { serviceTier: "..." } }
+    const openai = rec(parsed.openai);
+    if (!serviceTier) {
+      serviceTier = str(rec(parsed.azure).serviceTier) ?? str(openai.serviceTier);
+    }
+
+    // OpenAI response ID
+    responseId = str(openai.responseId);
+
+    // Gateway: { gateway: { routing: { finalProvider, resolvedProvider }, cost } }
+    const gateway = rec(parsed.gateway);
+    const routing = rec(gateway.routing);
+    resolvedProvider = str(routing.finalProvider) ?? str(routing.resolvedProvider);
+    gatewayCost = str(gateway.cost);
+
+    // OpenRouter: { openrouter: { provider: "xAI" } }
+    if (!resolvedProvider) {
+      resolvedProvider = str(rec(parsed.openrouter).provider);
+    }
+
+    if (!serviceTier && !resolvedProvider && !gatewayCost && !responseId) return undefined;
+    return { serviceTier, resolvedProvider, gatewayCost, responseId };
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Extract user-defined telemetry metadata, coercing non-string values.
+ * Skips the "prompt" key which is handled separately.
+ */
+export function extractTelemetryMetadata(raw: unknown): Record<string, string> | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+
+  const result: Record<string, string> = {};
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (key === "prompt") continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      result[key] = String(value);
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
diff --git a/apps/webapp/app/components/runs/v3/ai/extractAISpanData.ts b/apps/webapp/app/components/runs/v3/ai/extractAISpanData.ts
new file mode 100644
index 00000000000..73c5418e488
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/extractAISpanData.ts
@@ -0,0 +1,452 @@
+import { rec, str, num, parseProviderMetadata, extractTelemetryMetadata } from "./aiHelpers";
+import type { AISpanData, DisplayItem, ToolDefinition, ToolUse } from "./types";
+
+/**
+ * Extracts structured AI span data from unflattened OTEL span properties.
+ *
+ * Works with the nested object produced by `unflattenAttributes()` — expects
+ * keys like `gen_ai.response.model`, `ai.prompt.messages`, `trigger.llm.total_cost`, etc.
+ *
+ * @param properties  Unflattened span properties object
+ * @param durationMs  Span duration in milliseconds
+ * @returns Structured AI data, or undefined if this isn't an AI generation span
+ */
+export function extractAISpanData(
+  properties: Record<string, unknown>,
+  durationMs: number
+): AISpanData | undefined {
+  const genAi = properties.gen_ai;
+  if (!genAi || typeof genAi !== "object") return undefined;
+
+  const g = genAi as Record<string, unknown>;
+  const ai = rec(properties.ai);
+  const trigger = rec(properties.trigger);
+
+  const gResponse = rec(g.response);
+  const gRequest = rec(g.request);
+  const gUsage = rec(g.usage);
+  const gOperation = rec(g.operation);
+  const aiModel = rec(ai.model);
+  const aiResponse = rec(ai.response);
+  const aiPrompt = rec(ai.prompt);
+  const aiUsage = rec(ai.usage);
+  const triggerLlm = rec(trigger.llm);
+
+  const model = str(gResponse.model) ?? str(gRequest.model) ?? str(aiModel.id);
+  if (!model) return undefined;
+
+  // Prefer ai.usage (richer) over gen_ai.usage.
+  // Gateway/some providers emit promptTokens/completionTokens instead of inputTokens/outputTokens.
+  const inputTokens =
+    num(aiUsage.inputTokens) ?? num(aiUsage.promptTokens) ?? num(gUsage.input_tokens) ?? 0;
+  const outputTokens =
+    num(aiUsage.outputTokens) ?? num(aiUsage.completionTokens) ?? num(gUsage.output_tokens) ?? 0;
+  const totalTokens = num(aiUsage.totalTokens) ?? inputTokens + outputTokens;
+
+  const tokensPerSecond =
+    num(aiResponse.avgOutputTokensPerSecond) ??
+    (outputTokens > 0 && durationMs > 0
+      ? Math.round((outputTokens / (durationMs / 1000)) * 10) / 10
+      : undefined);
+
+  const toolDefs = parseToolDefinitions(aiPrompt.tools);
+  const providerMeta = parseProviderMetadata(aiResponse.providerMetadata);
+  const aiTelemetry = rec(ai.telemetry);
+  const telemetryMetaRaw = rec(aiTelemetry.metadata);
+  const promptMeta = rec(telemetryMetaRaw.prompt);
+  const promptSlug = str(promptMeta.slug);
+  const promptVersion = str(promptMeta.version);
+  const promptModel = str(promptMeta.model);
+  const promptLabels = str(promptMeta.labels);
+  const promptInput = str(promptMeta.input);
+  const telemetryMeta = extractTelemetryMetadata(aiTelemetry.metadata);
+
+  return {
+    model,
+    provider: str(g.system) ?? "unknown",
+    operationName: str(gOperation.name) ?? str(ai.operationId) ?? "",
+    responseId: str(gResponse.id) || undefined,
+    finishReason: str(aiResponse.finishReason),
+    serviceTier: providerMeta?.serviceTier,
+    resolvedProvider: providerMeta?.resolvedProvider,
+    toolChoice: parseToolChoice(aiPrompt.toolChoice),
+    toolCount: toolDefs?.length,
+    messageCount: countMessages(aiPrompt.messages),
+    telemetryMetadata: telemetryMeta,
+    promptSlug: promptSlug || undefined,
+    promptVersion: promptVersion || undefined,
+    promptModel: promptModel || undefined,
+    promptLabels: promptLabels || undefined,
+    promptInput: promptInput || undefined,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedTokens: num(aiUsage.cachedInputTokens) ?? num(gUsage.cache_read_input_tokens),
+    cacheCreationTokens:
+      num(aiUsage.cacheCreationInputTokens) ?? num(gUsage.cache_creation_input_tokens),
+    reasoningTokens: num(aiUsage.reasoningTokens) ?? num(gUsage.reasoning_tokens),
+    tokensPerSecond,
+    msToFirstChunk: num(aiResponse.msToFirstChunk),
+    durationMs,
+    inputCost: num(triggerLlm.input_cost),
+    outputCost: num(triggerLlm.output_cost),
+    totalCost: num(triggerLlm.total_cost),
+    responseText: str(aiResponse.text) || undefined,
+    responseObject: str(aiResponse.object) || undefined,
+    toolDefinitions: toolDefs,
+    items: buildDisplayItems(aiPrompt.messages, aiResponse.toolCalls, toolDefs),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Message → DisplayItem transformation
+// ---------------------------------------------------------------------------
+
+type RawMessage = {
+  role: string;
+  content: unknown;
+  toolCallId?: string;
+  name?: string;
+};
+
+/**
+ * Build display items from prompt messages and optionally response tool calls.
+ * - Parses ai.prompt.messages and merges consecutive tool-call + tool-result pairs
+ * - If ai.response.toolCalls is present (finishReason=tool-calls), appends those too
+ */
+function buildDisplayItems(
+  messagesRaw: unknown,
+  responseToolCallsRaw: unknown,
+  toolDefs?: ToolDefinition[]
+): DisplayItem[] | undefined {
+  const items = parseMessagesToDisplayItems(messagesRaw);
+  const responseToolCalls = parseResponseToolCalls(responseToolCallsRaw);
+
+  if (!items && !responseToolCalls) return undefined;
+
+  const result = items ?? [];
+
+  if (responseToolCalls && responseToolCalls.length > 0) {
+    result.push({ type: "tool-use", tools: responseToolCalls });
+  }
+
+  if (toolDefs && toolDefs.length > 0) {
+    const defsByName = new Map(toolDefs.map((d) => [d.name, d]));
+    for (const item of result) {
+      if (item.type === "tool-use") {
+        for (const tool of item.tools) {
+          const def = defsByName.get(tool.toolName);
+          if (def) {
+            tool.description = def.description;
+            tool.parametersJson = def.parametersJson;
+          }
+        }
+      }
+    }
+  }
+
+  return result.length > 0 ? result : undefined;
+}
+
+function parseMessagesToDisplayItems(raw: unknown): DisplayItem[] | undefined {
+  if (typeof raw !== "string") return undefined;
+
+  let messages: RawMessage[];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    messages = parsed.map((item: unknown) => {
+      const m = rec(item);
+      return {
+        role: str(m.role) ?? "user",
+        content: m.content,
+        toolCallId: str(m.toolCallId),
+        name: str(m.name),
+      };
+    });
+  } catch {
+    return undefined;
+  }
+
+  const items: DisplayItem[] = [];
+  let i = 0;
+
+  while (i < messages.length) {
+    const msg = messages[i];
+
+    if (msg.role === "system") {
+      items.push({ type: "system", text: extractTextContent(msg.content) });
+      i++;
+      continue;
+    }
+
+    if (msg.role === "user") {
+      items.push({ type: "user", text: extractTextContent(msg.content) });
+      i++;
+      continue;
+    }
+
+    // Assistant message — check if it contains tool calls
+    if (msg.role === "assistant") {
+      const toolCalls = extractToolCalls(msg.content);
+
+      if (toolCalls.length > 0) {
+        // Collect subsequent tool result messages that match these tool calls
+        const toolCallIds = new Set(toolCalls.map((tc) => tc.toolCallId));
+        let j = i + 1;
+        while (j < messages.length && messages[j].role === "tool") {
+          j++;
+        }
+        // Gather tool result messages between i+1 and j
+        const toolResultMsgs = messages.slice(i + 1, j);
+
+        // Build ToolUse entries by pairing calls with results
+        const tools: ToolUse[] = toolCalls.map((tc) => {
+          const resultMsg = toolResultMsgs.find((m) => {
+            // Match by toolCallId in the message's content parts
+            const results = extractToolResults(m.content);
+            return results.some((r) => r.toolCallId === tc.toolCallId);
+          });
+
+          const result = resultMsg
+            ? extractToolResults(resultMsg.content).find(
+              (r) => r.toolCallId === tc.toolCallId
+            )
+            : undefined;
+
+          return {
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            inputJson: JSON.stringify(tc.input, null, 2),
+            resultSummary: result?.summary,
+            resultOutput: result?.formattedOutput,
+          };
+        });
+
+        items.push({ type: "tool-use", tools });
+        i = j; // skip past the tool result messages
+        continue;
+      }
+
+      // Assistant message with just text
+      const text = extractTextContent(msg.content);
+      if (text) {
+        items.push({ type: "assistant", text });
+      }
+      i++;
+      continue;
+    }
+
+    // Skip any other message types (tool messages that weren't consumed above)
+    i++;
+  }
+
+  return items.length > 0 ? items : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Response tool calls (from ai.response.toolCalls, used when finishReason=tool-calls)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse ai.response.toolCalls JSON string into ToolUse entries.
+ * These are tool calls the model requested but haven't been executed yet in this span.
+ */
+function parseResponseToolCalls(raw: unknown): ToolUse[] | undefined {
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const tools: ToolUse[] = [];
+    for (const item of parsed) {
+      const tc = rec(item);
+      if (tc.type === "tool-call" || tc.toolName || tc.toolCallId) {
+        tools.push({
+          toolCallId: str(tc.toolCallId) ?? "",
+          toolName: str(tc.toolName) ?? "",
+          inputJson: JSON.stringify(
+            tc.input && typeof tc.input === "object" ? tc.input : {},
+            null,
+            2
+          ),
+        });
+      }
+    }
+    return tools.length > 0 ? tools : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Content part extraction
+// ---------------------------------------------------------------------------
+
+function extractTextContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  const texts: string[] = [];
+  for (const raw of content) {
+    const p = rec(raw);
+    if (p.type === "text" && typeof p.text === "string") {
+      texts.push(p.text);
+    } else if (typeof p.text === "string") {
+      texts.push(p.text);
+    }
+  }
+  return texts.join("\n");
+}
+
+type ParsedToolCall = {
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+};
+
+function extractToolCalls(content: unknown): ParsedToolCall[] {
+  if (!Array.isArray(content)) return [];
+  const calls: ParsedToolCall[] = [];
+  for (const raw of content) {
+    const p = rec(raw);
+    if (p.type === "tool-call") {
+      calls.push({
+        toolCallId: str(p.toolCallId) ?? "",
+        toolName: str(p.toolName) ?? "",
+        input: p.input && typeof p.input === "object" ? (p.input as Record<string, unknown>) : {},
+      });
+    }
+  }
+  return calls;
+}
+
+type ParsedToolResult = {
+  toolCallId: string;
+  toolName: string;
+  summary: string;
+  formattedOutput: string;
+};
+
+function extractToolResults(content: unknown): ParsedToolResult[] {
+  if (!Array.isArray(content)) return [];
+  const results: ParsedToolResult[] = [];
+  for (const raw of content) {
+    const p = rec(raw);
+    if (p.type === "tool-result") {
+      const { summary, formattedOutput } = summarizeToolOutput(p.output);
+      results.push({
+        toolCallId: str(p.toolCallId) ?? "",
+        toolName: str(p.toolName) ?? "",
+        summary,
+        formattedOutput,
+      });
+    }
+  }
+  return results;
+}
+
+/**
+ * Summarize a tool output into a short label and a formatted string for display.
+ * Handles the AI SDK's `{ type: "json", value: { status, contentType, body, truncated } }` shape.
+ */
+function summarizeToolOutput(output: unknown): { summary: string; formattedOutput: string } {
+  if (typeof output === "string") {
+    return {
+      summary: output.length > 80 ? output.slice(0, 80) + "..." : output,
+      formattedOutput: output,
+    };
+  }
+
+  if (!output || typeof output !== "object") {
+    return { summary: "result", formattedOutput: JSON.stringify(output, null, 2) };
+  }
+
+  const o = output as Record<string, unknown>;
+
+  // AI SDK wraps tool results as { type: "json", value: { status, contentType, body, ... } }
+  if (o.type === "json" && o.value && typeof o.value === "object") {
+    const v = o.value as Record<string, unknown>;
+    const parts: string[] = [];
+    if (typeof v.status === "number") parts.push(`${v.status}`);
+    if (typeof v.contentType === "string") parts.push(v.contentType);
+    if (v.truncated === true) parts.push("truncated");
+    return {
+      summary: parts.length > 0 ? parts.join(" · ") : "json result",
+      formattedOutput: JSON.stringify(v, null, 2),
+    };
+  }
+
+  return { summary: "result", formattedOutput: JSON.stringify(output, null, 2) };
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions (from ai.prompt.tools)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse ai.prompt.tools — after the array fix, this arrives as a JSON array string
+ * where each element is itself a JSON string of a tool definition.
+ */
+function parseToolDefinitions(raw: unknown): ToolDefinition[] | undefined {
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const defs: ToolDefinition[] = [];
+    for (const item of parsed) {
+      // Each item is either a JSON string or already an object
+      const obj = typeof item === "string" ? JSON.parse(item) : item;
+      if (!obj || typeof obj !== "object") continue;
+      const o = obj as Record<string, unknown>;
+      const name = str(o.name);
+      if (!name) continue;
+      const schema = o.parameters ?? o.inputSchema;
+      defs.push({
+        name,
+        description: str(o.description),
+        parametersJson:
+          schema && typeof schema === "object"
+            ? JSON.stringify(schema, null, 2)
+            : undefined,
+      });
+    }
+    return defs.length > 0 ? defs : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tool choice parsing
+// ---------------------------------------------------------------------------
+
+function parseToolChoice(raw: unknown): string | undefined {
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "string") return parsed;
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed as Record<string, unknown>;
+      if (typeof obj.type === "string") return obj.type;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Message count
+// ---------------------------------------------------------------------------
+
+function countMessages(raw: unknown): number | undefined {
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    return parsed.length > 0 ? parsed.length : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
diff --git a/apps/webapp/app/components/runs/v3/ai/extractAISummarySpanData.ts b/apps/webapp/app/components/runs/v3/ai/extractAISummarySpanData.ts
new file mode 100644
index 00000000000..7851ac996f2
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/extractAISummarySpanData.ts
@@ -0,0 +1,195 @@
+import { rec, str, num, parseProviderMetadata, extractTelemetryMetadata } from "./aiHelpers";
+import type { AISpanData, DisplayItem } from "./types";
+
+/**
+ * Extracts structured AI data from top-level AI SDK parent spans.
+ *
+ * These spans (ai.generateText, ai.streamText, ai.generateObject, ai.streamObject)
+ * use `ai.*` attributes instead of `gen_ai.*`. They contain the full prompt,
+ * aggregated response, and total usage across all steps.
+ */
+export function extractAISummarySpanData(
+  properties: Record<string, unknown>,
+  durationMs: number
+): AISpanData | undefined {
+  const ai = rec(properties.ai);
+  if (!ai.operationId) return undefined;
+
+  // Skip child spans that have gen_ai.* (those use extractAISpanData)
+  if (properties.gen_ai && typeof properties.gen_ai === "object") return undefined;
+
+  const aiModel = rec(ai.model);
+  const aiResponse = rec(ai.response);
+  const aiUsage = rec(ai.usage);
+  const aiSettings = rec(ai.settings);
+  const aiRequest = rec(ai.request);
+  const aiTelemetry = rec(ai.telemetry);
+  const trigger = rec(properties.trigger);
+  const triggerLlm = rec(trigger.llm);
+
+  const model = str(aiModel.id);
+  if (!model) return undefined;
+
+  const provider = str(aiModel.provider) ?? "unknown";
+  const operationName = str(ai.operationId) ?? "";
+
+  // Token usage
+  const inputTokens =
+    num(aiUsage.inputTokens) ?? num(aiUsage.promptTokens) ?? 0;
+  const outputTokens =
+    num(aiUsage.outputTokens) ?? num(aiUsage.completionTokens) ?? 0;
+  const totalTokens = num(aiUsage.totalTokens) ?? inputTokens + outputTokens;
+
+  const tokensPerSecond =
+    outputTokens > 0 && durationMs > 0
+      ? Math.round((outputTokens / (durationMs / 1000)) * 10) / 10
+      : undefined;
+
+  // Provider metadata
+  const providerMeta = parseProviderMetadata(aiResponse.providerMetadata);
+
+  // Response ID from provider metadata
+  const responseId = providerMeta?.responseId;
+
+  // Telemetry metadata (prompt info, custom metadata)
+  const telemetryMetaRaw = rec(aiTelemetry.metadata);
+  const promptMeta = rec(telemetryMetaRaw.prompt);
+  const promptSlug = str(promptMeta.slug);
+  const promptVersion = str(promptMeta.version);
+  const promptModel = str(promptMeta.model);
+  const promptLabels = str(promptMeta.labels);
+  const promptInput = str(promptMeta.input);
+  const telemetryMeta = extractTelemetryMetadata(aiTelemetry.metadata);
+
+  // Parse the prompt JSON to build display items
+  const promptJson = str(ai.prompt);
+  const items = promptJson ? parsePromptToDisplayItems(promptJson, str(aiResponse.text)) : undefined;
+
+  // Count messages from the parsed prompt
+  let messageCount: number | undefined;
+  if (promptJson) {
+    try {
+      const parsed = JSON.parse(promptJson) as Record<string, unknown>;
+      if (parsed.messages && Array.isArray(parsed.messages)) {
+        messageCount = parsed.messages.length;
+      } else {
+        // system + prompt = 2 messages
+        messageCount = (parsed.system ? 1 : 0) + (parsed.prompt ? 1 : 0);
+      }
+    } catch {}
+  }
+
+  return {
+    model,
+    provider,
+    operationName,
+    responseId,
+    finishReason: str(aiResponse.finishReason),
+    serviceTier: providerMeta?.serviceTier,
+    resolvedProvider: providerMeta?.resolvedProvider,
+    toolChoice: undefined,
+    toolCount: undefined,
+    messageCount,
+    telemetryMetadata: telemetryMeta,
+    promptSlug: promptSlug || undefined,
+    promptVersion: promptVersion || undefined,
+    promptModel: promptModel || undefined,
+    promptLabels: promptLabels || undefined,
+    promptInput: promptInput || undefined,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedTokens: num(aiUsage.cachedInputTokens),
+    cacheCreationTokens: num(aiUsage.cacheCreationInputTokens),
+    reasoningTokens: num(aiUsage.reasoningTokens),
+    tokensPerSecond,
+    msToFirstChunk: undefined, // Only on child doStream spans
+    durationMs,
+    inputCost: num(triggerLlm.input_cost),
+    outputCost: num(triggerLlm.output_cost),
+    totalCost: num(triggerLlm.total_cost),
+    responseText: str(aiResponse.text) || undefined,
+    responseObject: str(aiResponse.object) || undefined,
+    toolDefinitions: undefined,
+    items,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Prompt parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Parses the `ai.prompt` JSON string into display items.
+ * Parent spans store the prompt as a JSON object with either:
+ * - { system: "...", prompt: "..." }
+ * - { system: "...", messages: [...] }
+ * - { messages: [...] }
+ */
+function parsePromptToDisplayItems(
+  promptJson: string,
+  responseText?: string
+): DisplayItem[] | undefined {
+  try {
+    const parsed = JSON.parse(promptJson) as Record<string, unknown>;
+    if (!parsed || typeof parsed !== "object") return undefined;
+
+    const items: DisplayItem[] = [];
+
+    if (typeof parsed.system === "string" && parsed.system) {
+      items.push({ type: "system", text: parsed.system });
+    }
+
+    if (typeof parsed.prompt === "string" && parsed.prompt) {
+      items.push({ type: "user", text: parsed.prompt });
+    }
+
+    if (Array.isArray(parsed.messages)) {
+      for (const msg of parsed.messages) {
+        if (!msg || typeof msg !== "object") continue;
+        const m = msg as Record<string, unknown>;
+        const role = m.role;
+        const content = extractMessageContent(m.content);
+        if (!content) continue;
+
+        switch (role) {
+          case "system":
+            items.push({ type: "system", text: content });
+            break;
+          case "user":
+            items.push({ type: "user", text: content });
+            break;
+          case "assistant":
+            items.push({ type: "assistant", text: content });
+            break;
+        }
+      }
+    }
+
+    // Add response as assistant item if not already present
+    if (responseText && !items.some((i) => i.type === "assistant")) {
+      items.push({ type: "assistant", text: responseText });
+    }
+
+    return items.length > 0 ? items : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function extractMessageContent(content: unknown): string | undefined {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    // Extract text parts from content array [{type: "text", text: "..."}]
+    return content
+      .filter((p): p is { type: string; text: string } => {
+        if (!p || typeof p !== "object") return false;
+        const o = p as Record<string, unknown>;
+        return o.type === "text" && typeof o.text === "string";
+      })
+      .map((p) => p.text)
+      .join("\n");
+  }
+  return undefined;
+}
+
diff --git a/apps/webapp/app/components/runs/v3/ai/index.ts b/apps/webapp/app/components/runs/v3/ai/index.ts
new file mode 100644
index 00000000000..5acb9ff17a2
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/index.ts
@@ -0,0 +1,8 @@
+export { AISpanDetails } from "./AISpanDetails";
+export { extractAISpanData } from "./extractAISpanData";
+export { extractAISummarySpanData } from "./extractAISummarySpanData";
+export { AIToolCallSpanDetails, extractAIToolCallData } from "./AIToolCallSpanDetails";
+export type { AIToolCallData } from "./AIToolCallSpanDetails";
+export { AIEmbedSpanDetails, extractAIEmbedData } from "./AIEmbedSpanDetails";
+export type { AIEmbedData } from "./AIEmbedSpanDetails";
+export type { AISpanData, DisplayItem, ToolUse } from "./types";
diff --git a/apps/webapp/app/components/runs/v3/ai/types.ts b/apps/webapp/app/components/runs/v3/ai/types.ts
new file mode 100644
index 00000000000..bb0fd7e74b1
--- /dev/null
+++ b/apps/webapp/app/components/runs/v3/ai/types.ts
@@ -0,0 +1,113 @@
+// ---------------------------------------------------------------------------
+// Tool use (merged assistant tool-call + tool result)
+// ---------------------------------------------------------------------------
+
+export type ToolDefinition = {
+  name: string;
+  description?: string;
+  /** JSON schema as formatted string */
+  parametersJson?: string;
+};
+
+export type ToolUse = {
+  toolCallId: string;
+  toolName: string;
+  /** Tool description from the definition, if available */
+  description?: string;
+  /** JSON schema of the tool's parameters, pretty-printed */
+  parametersJson?: string;
+  /** Formatted input args as JSON string */
+  inputJson: string;
+  /** Short summary of the result (e.g. "200 · text/html · truncated") */
+  resultSummary?: string;
+  /** Full formatted result for display in a code block */
+  resultOutput?: string;
+};
+
+// ---------------------------------------------------------------------------
+// Display items — what the UI actually renders
+// ---------------------------------------------------------------------------
+
+/** System prompt text (collapsible) */
+export type SystemItem = {
+  type: "system";
+  text: string;
+};
+
+/** User message text */
+export type UserItem = {
+  type: "user";
+  text: string;
+};
+
+/** One or more tool calls with their results, grouped */
+export type ToolUseItem = {
+  type: "tool-use";
+  tools: ToolUse[];
+};
+
+/** Final assistant text response */
+export type AssistantItem = {
+  type: "assistant";
+  text: string;
+};
+
+export type DisplayItem = SystemItem | UserItem | ToolUseItem | AssistantItem;
+
+// ---------------------------------------------------------------------------
+// Span-level AI data
+// ---------------------------------------------------------------------------
+
+export type AISpanData = {
+  model: string;
+  provider: string;
+  operationName: string;
+  responseId?: string;
+
+  // Categorical tags
+  finishReason?: string;
+  serviceTier?: string;
+  /** Resolved downstream provider for gateway/openrouter spans (e.g. "xAI", "mistral") */
+  resolvedProvider?: string;
+  toolChoice?: string;
+  toolCount?: number;
+  messageCount?: number;
+  /** User-defined telemetry metadata (from ai.telemetry.metadata) */
+  telemetryMetadata?: Record<string, string>;
+
+  // Prompt metadata (from ai.telemetry.metadata.prompt)
+  promptSlug?: string;
+  promptVersion?: string;
+  promptModel?: string;
+  promptLabels?: string;
+  promptInput?: string;
+
+  // Token counts
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cachedTokens?: number;
+  cacheCreationTokens?: number;
+  reasoningTokens?: number;
+
+  // Performance
+  tokensPerSecond?: number;
+  msToFirstChunk?: number;
+  durationMs: number;
+
+  // Cost
+  inputCost?: number;
+  outputCost?: number;
+  totalCost?: number;
+
+  // Response text (final assistant output)
+  responseText?: string;
+  // Structured object response (JSON) — mutually exclusive with responseText
+  responseObject?: string;
+
+  // Tool definitions (from ai.prompt.tools)
+  toolDefinitions?: ToolDefinition[];
+
+  // Display-ready message items (system, user, tool-use groups, assistant text)
+  items?: DisplayItem[];
+};
diff --git a/apps/webapp/app/db.server.ts b/apps/webapp/app/db.server.ts
index 47b67a1a406..4668b58fb02 100644
--- a/apps/webapp/app/db.server.ts
+++ b/apps/webapp/app/db.server.ts
@@ -113,6 +113,7 @@ function getClient() {
     connection_limit: env.DATABASE_CONNECTION_LIMIT.toString(),
     pool_timeout: env.DATABASE_POOL_TIMEOUT.toString(),
     connection_timeout: env.DATABASE_CONNECTION_TIMEOUT.toString(),
+    application_name: env.SERVICE_NAME,
   });
 
   console.log(`🔌 setting up prisma client to ${redactUrlSecrets(databaseUrl)}`);
@@ -236,6 +237,7 @@ function getReplicaClient() {
     connection_limit: env.DATABASE_CONNECTION_LIMIT.toString(),
     pool_timeout: env.DATABASE_POOL_TIMEOUT.toString(),
     connection_timeout: env.DATABASE_CONNECTION_TIMEOUT.toString(),
+    application_name: env.SERVICE_NAME,
   });
 
   console.log(`🔌 setting up read replica connection to ${redactUrlSecrets(replicaUrl)}`);
diff --git a/apps/webapp/app/env.server.ts b/apps/webapp/app/env.server.ts
index 1cc0db0bf0e..8d72b2e51b2 100644
--- a/apps/webapp/app/env.server.ts
+++ b/apps/webapp/app/env.server.ts
@@ -39,6 +39,7 @@ const S2EnvSchema = z.preprocess(
       S2_ENABLED: z.literal("1"),
       S2_ACCESS_TOKEN: z.string(),
       S2_DEPLOYMENT_LOGS_BASIN_NAME: z.string(),
+      S2_DEPLOYMENT_STREAMS_LOCAL: z.string().default("0"),
     }),
     z.object({
       S2_ENABLED: z.literal("0"),
@@ -332,6 +333,11 @@ const EnvironmentSchema = z
       .optional()
       .transform((v) => v ?? process.env.DEPLOY_REGISTRY_ECR_ASSUME_ROLE_EXTERNAL_ID),
 
+    // Compute gateway (template creation during deploy finalize)
+    COMPUTE_GATEWAY_URL: z.string().optional(),
+    COMPUTE_GATEWAY_AUTH_TOKEN: z.string().optional(),
+    COMPUTE_TEMPLATE_SHADOW_ROLLOUT_PCT: z.string().optional(),
+
     DEPLOY_IMAGE_PLATFORM: z.string().default("linux/amd64"),
     DEPLOY_TIMEOUT_MS: z.coerce
       .number()
@@ -343,11 +349,18 @@ const EnvironmentSchema = z
       .default(60 * 1000 * 15), // 15 minutes
 
     OBJECT_STORE_BASE_URL: z.string().optional(),
+    OBJECT_STORE_BUCKET: z.string().optional(),
     OBJECT_STORE_ACCESS_KEY_ID: z.string().optional(),
     OBJECT_STORE_SECRET_ACCESS_KEY: z.string().optional(),
     OBJECT_STORE_REGION: z.string().optional(),
     OBJECT_STORE_SERVICE: z.string().default("s3"),
 
+    // Protocol to use for new uploads (e.g., "s3", "r2"). Data without protocol uses default provider above.
+    // If specified, you must configure the corresponding provider using OBJECT_STORE_{PROTOCOL}_* env vars.
+    // Example: OBJECT_STORE_DEFAULT_PROTOCOL=s3 requires OBJECT_STORE_S3_BASE_URL, OBJECT_STORE_S3_ACCESS_KEY_ID, etc.
+    // Enables zero-downtime migration between providers (old data keeps working, new data uses new provider).
+    OBJECT_STORE_DEFAULT_PROTOCOL: z.string().regex(/^[a-z0-9]+$/).optional(),
+
     ARTIFACTS_OBJECT_STORE_BUCKET: z.string().optional(),
     ARTIFACTS_OBJECT_STORE_BASE_URL: z.string().optional(),
     ARTIFACTS_OBJECT_STORE_ACCESS_KEY_ID: z.string().optional(),
@@ -372,6 +385,7 @@ const EnvironmentSchema = z
 
     // Development OTEL environment variables
     DEV_OTEL_EXPORTER_OTLP_ENDPOINT: z.string().optional(),
+    DEV_OTEL_METRICS_ENDPOINT: z.string().optional(),
     // If this is set to 1, then the below variables are used to configure the batch processor for spans and logs
     DEV_OTEL_BATCH_PROCESSING_ENABLED: z.string().default("0"),
     DEV_OTEL_SPAN_MAX_EXPORT_BATCH_SIZE: z.string().default("64"),
@@ -382,6 +396,9 @@ const EnvironmentSchema = z
     DEV_OTEL_LOG_SCHEDULED_DELAY_MILLIS: z.string().default("200"),
     DEV_OTEL_LOG_EXPORT_TIMEOUT_MILLIS: z.string().default("30000"),
     DEV_OTEL_LOG_MAX_QUEUE_SIZE: z.string().default("512"),
+    DEV_OTEL_METRICS_EXPORT_INTERVAL_MILLIS: z.string().optional(),
+    DEV_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS: z.string().optional(),
+    DEV_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS: z.string().optional(),
 
     PROD_OTEL_BATCH_PROCESSING_ENABLED: z.string().default("0"),
     PROD_OTEL_SPAN_MAX_EXPORT_BATCH_SIZE: z.string().default("64"),
@@ -392,6 +409,9 @@ const EnvironmentSchema = z
     PROD_OTEL_LOG_SCHEDULED_DELAY_MILLIS: z.string().default("200"),
     PROD_OTEL_LOG_EXPORT_TIMEOUT_MILLIS: z.string().default("30000"),
     PROD_OTEL_LOG_MAX_QUEUE_SIZE: z.string().default("512"),
+    PROD_OTEL_METRICS_EXPORT_INTERVAL_MILLIS: z.string().optional(),
+    PROD_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS: z.string().optional(),
+    PROD_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS: z.string().optional(),
 
     TRIGGER_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: z.string().default("1024"),
     TRIGGER_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT: z.string().default("1024"),
@@ -425,6 +445,11 @@ const EnvironmentSchema = z
     ORG_SLACK_INTEGRATION_CLIENT_ID: z.string().optional(),
     ORG_SLACK_INTEGRATION_CLIENT_SECRET: z.string().optional(),
 
+    /** Vercel integration OAuth credentials */
+    VERCEL_INTEGRATION_CLIENT_ID: z.string().optional(),
+    VERCEL_INTEGRATION_CLIENT_SECRET: z.string().optional(),
+    VERCEL_INTEGRATION_APP_SLUG: z.string().optional(),
+
     /** These enable the alerts feature in v3 */
     ALERT_EMAIL_TRANSPORT: z.enum(["resend", "smtp", "aws-ses"]).optional(),
     ALERT_FROM_EMAIL: z.string().optional(),
@@ -535,6 +560,9 @@ const EnvironmentSchema = z
 
     MAXIMUM_DEV_QUEUE_SIZE: z.coerce.number().int().optional(),
     MAXIMUM_DEPLOYED_QUEUE_SIZE: z.coerce.number().int().optional(),
+    QUEUE_SIZE_CACHE_TTL_MS: z.coerce.number().int().optional().default(1_000), // 1 second
+    QUEUE_SIZE_CACHE_MAX_SIZE: z.coerce.number().int().optional().default(5_000),
+    QUEUE_SIZE_CACHE_ENABLED: z.coerce.number().int().optional().default(1),
     MAX_BATCH_V2_TRIGGER_ITEMS: z.coerce.number().int().default(500),
     MAX_BATCH_AND_WAIT_V2_TRIGGER_ITEMS: z.coerce.number().int().default(500),
 
@@ -544,7 +572,7 @@ const EnvironmentSchema = z
     BATCH_RATE_LIMIT_REFILL_RATE: z.coerce.number().int().default(100),
     BATCH_RATE_LIMIT_MAX: z.coerce.number().int().default(1200),
     BATCH_RATE_LIMIT_REFILL_INTERVAL: z.string().default("10s"),
-    BATCH_CONCURRENCY_LIMIT_DEFAULT: z.coerce.number().int().default(1),
+    BATCH_CONCURRENCY_LIMIT_DEFAULT: z.coerce.number().int().default(5),
 
     REALTIME_STREAM_VERSION: z.enum(["v1", "v2"]).default("v1"),
     REALTIME_STREAM_MAX_LENGTH: z.coerce.number().int().default(1000),
@@ -591,6 +619,20 @@ const EnvironmentSchema = z
     RUN_ENGINE_CONCURRENCY_SWEEPER_SCAN_JITTER_IN_MS: z.coerce.number().int().optional(),
     RUN_ENGINE_CONCURRENCY_SWEEPER_PROCESS_MARKED_JITTER_IN_MS: z.coerce.number().int().optional(),
 
+    // TTL System settings for automatic run expiration
+    RUN_ENGINE_TTL_SYSTEM_DISABLED: BoolEnv.default(false),
+    RUN_ENGINE_TTL_SYSTEM_SHARD_COUNT: z.coerce.number().int().optional(),
+    RUN_ENGINE_TTL_SYSTEM_POLL_INTERVAL_MS: z.coerce.number().int().default(1_000),
+    RUN_ENGINE_TTL_SYSTEM_BATCH_SIZE: z.coerce.number().int().default(100),
+    RUN_ENGINE_TTL_WORKER_CONCURRENCY: z.coerce.number().int().default(1),
+    RUN_ENGINE_TTL_WORKER_BATCH_MAX_SIZE: z.coerce.number().int().default(50),
+    RUN_ENGINE_TTL_CONSUMERS_DISABLED: BoolEnv.default(false),
+    RUN_ENGINE_TTL_WORKER_BATCH_MAX_WAIT_MS: z.coerce.number().int().default(5_000),
+
+    /** Optional maximum TTL for all runs (e.g. "14d"). If set, runs without an explicit TTL
+     *  will use this as their TTL, and runs with a TTL larger than this will be clamped. */
+    RUN_ENGINE_DEFAULT_MAX_TTL: z.string().optional(),
+
     RUN_ENGINE_RUN_LOCK_DURATION: z.coerce.number().int().default(5000),
     RUN_ENGINE_RUN_LOCK_AUTOMATIC_EXTENSION_THRESHOLD: z.coerce.number().int().default(1000),
     RUN_ENGINE_RUN_LOCK_MAX_RETRIES: z.coerce.number().int().default(10),
@@ -951,9 +993,21 @@ const EnvironmentSchema = z
     BATCH_QUEUE_MAX_DEFICIT: z.coerce.number().int().default(100),
     BATCH_QUEUE_CONSUMER_COUNT: z.coerce.number().int().default(3),
     BATCH_QUEUE_CONSUMER_INTERVAL_MS: z.coerce.number().int().default(50),
+    BATCH_QUEUE_WORKER_ENABLED: BoolEnv.default(true),
+    // Number of master queue shards for horizontal scaling
+    BATCH_QUEUE_SHARD_COUNT: z.coerce.number().int().default(1),
+    // Maximum queues to fetch from master queue per iteration
+    BATCH_QUEUE_MASTER_QUEUE_LIMIT: z.coerce.number().int().default(1000),
+    // Enable worker queue for two-stage processing (claim messages, push to worker queue, process from worker queue)
+    BATCH_QUEUE_WORKER_QUEUE_ENABLED: BoolEnv.default(true),
+    // Worker queue blocking timeout in seconds (for two-stage processing, only used when BATCH_QUEUE_WORKER_QUEUE_ENABLED is true)
+    BATCH_QUEUE_WORKER_QUEUE_TIMEOUT_SECONDS: z.coerce.number().int().default(10),
     // Global rate limit: max items processed per second across all consumers
     // If not set, no global rate limiting is applied
     BATCH_QUEUE_GLOBAL_RATE_LIMIT: z.coerce.number().int().positive().optional(),
+    // Max items in the worker queue before claiming pauses (protects visibility timeouts)
+    // If not set, no depth limit is applied
+    BATCH_QUEUE_WORKER_QUEUE_MAX_DEPTH: z.coerce.number().int().positive().optional(),
 
     ADMIN_WORKER_ENABLED: z.string().default(process.env.WORKER_ENABLED ?? "true"),
     ADMIN_WORKER_CONCURRENCY_WORKERS: z.coerce.number().int().default(2),
@@ -1157,6 +1211,7 @@ const EnvironmentSchema = z
     RUN_REPLICATION_INSERT_MAX_DELAY_MS: z.coerce.number().int().default(2000),
     RUN_REPLICATION_INSERT_STRATEGY: z.enum(["insert", "insert_async"]).default("insert"),
     RUN_REPLICATION_DISABLE_PAYLOAD_INSERT: z.string().default("0"),
+    RUN_REPLICATION_DISABLE_ERROR_FINGERPRINTING: z.string().default("0"),
 
     // Clickhouse
     CLICKHOUSE_URL: z.string(),
@@ -1166,6 +1221,53 @@ const EnvironmentSchema = z
     CLICKHOUSE_LOG_LEVEL: z.enum(["log", "error", "warn", "info", "debug"]).default("info"),
     CLICKHOUSE_COMPRESSION_REQUEST: z.string().default("1"),
 
+    // Logs Query Settings
+    CLICKHOUSE_LOGS_LIST_MAX_MEMORY_USAGE: z.coerce.number().int().default(1_000_000_000),
+    CLICKHOUSE_LOGS_LIST_MAX_BYTES_BEFORE_EXTERNAL_SORT: z.coerce
+      .number()
+      .int()
+      .default(256_000_000),
+    CLICKHOUSE_LOGS_LIST_MAX_THREADS: z.coerce.number().int().default(2),
+    CLICKHOUSE_LOGS_LIST_MAX_ROWS_TO_READ: z.coerce.number().int().default(10_000_000),
+    CLICKHOUSE_LOGS_LIST_MAX_EXECUTION_TIME: z.coerce.number().int().default(120),
+
+    // Query feature flag
+    QUERY_FEATURE_ENABLED: z.string().default("1"),
+
+    // AI features (Prompts, Models, AI Metrics sidebar section)
+    AI_FEATURES_ENABLED: z.string().default("0"),
+
+    // Logs page ClickHouse URL (for logs queries)
+    LOGS_CLICKHOUSE_URL: z
+      .string()
+      .optional()
+      .transform((v) => v ?? process.env.CLICKHOUSE_URL),
+
+    // Query page ClickHouse limits (for TSQL queries)
+    QUERY_CLICKHOUSE_URL: z
+      .string()
+      .optional()
+      .transform((v) => v ?? process.env.CLICKHOUSE_URL),
+    QUERY_CLICKHOUSE_MAX_EXECUTION_TIME: z.coerce.number().int().default(10),
+    QUERY_CLICKHOUSE_MAX_MEMORY_USAGE: z.coerce.number().int().default(1_073_741_824), // 1GB in bytes
+    QUERY_CLICKHOUSE_MAX_AST_ELEMENTS: z.coerce.number().int().default(4_000_000),
+    QUERY_CLICKHOUSE_MAX_EXPANDED_AST_ELEMENTS: z.coerce.number().int().default(4_000_000),
+    QUERY_CLICKHOUSE_MAX_BYTES_BEFORE_EXTERNAL_GROUP_BY: z.coerce.number().int().default(0),
+    QUERY_CLICKHOUSE_MAX_RETURNED_ROWS: z.coerce.number().int().default(10_000),
+
+    // Query page concurrency limits
+    QUERY_DEFAULT_ORG_CONCURRENCY_LIMIT: z.coerce.number().int().default(3),
+    QUERY_GLOBAL_CONCURRENCY_LIMIT: z.coerce.number().int().default(100),
+
+    // Metric widget concurrency limits
+    METRIC_WIDGET_DEFAULT_ORG_CONCURRENCY_LIMIT: z.coerce.number().int().default(30),
+
+    // Admin ClickHouse URL (for admin dashboard queries like missing models)
+    ADMIN_CLICKHOUSE_URL: z
+      .string()
+      .optional()
+      .transform((v) => v ?? process.env.CLICKHOUSE_URL),
+
     EVENTS_CLICKHOUSE_URL: z
       .string()
       .optional()
@@ -1177,6 +1279,9 @@ const EnvironmentSchema = z
     EVENTS_CLICKHOUSE_COMPRESSION_REQUEST: z.string().default("1"),
     EVENTS_CLICKHOUSE_BATCH_SIZE: z.coerce.number().int().default(1000),
     EVENTS_CLICKHOUSE_FLUSH_INTERVAL_MS: z.coerce.number().int().default(1000),
+    METRICS_CLICKHOUSE_BATCH_SIZE: z.coerce.number().int().default(10000),
+    METRICS_CLICKHOUSE_FLUSH_INTERVAL_MS: z.coerce.number().int().default(1000),
+    METRICS_CLICKHOUSE_MAX_CONCURRENCY: z.coerce.number().int().default(3),
     EVENTS_CLICKHOUSE_INSERT_STRATEGY: z.enum(["insert", "insert_async"]).default("insert"),
     EVENTS_CLICKHOUSE_WAIT_FOR_ASYNC_INSERT: z.string().default("1"),
     EVENTS_CLICKHOUSE_ASYNC_INSERT_MAX_DATA_SIZE: z.coerce.number().int().default(10485760),
@@ -1185,7 +1290,6 @@ const EnvironmentSchema = z
       .number()
       .int()
       .default(60_000 * 5), // 5 minutes
-    EVENT_REPOSITORY_CLICKHOUSE_ROLLOUT_PERCENT: z.coerce.number().optional(),
     EVENT_REPOSITORY_DEFAULT_STORE: z
       .enum(["postgres", "clickhouse", "clickhouse_v2"])
       .default("postgres"),
@@ -1194,6 +1298,16 @@ const EnvironmentSchema = z
     EVENTS_CLICKHOUSE_MAX_TRACE_DETAILED_SUMMARY_VIEW_COUNT: z.coerce.number().int().default(5_000),
     EVENTS_CLICKHOUSE_MAX_LIVE_RELOADING_SETTING: z.coerce.number().int().default(2000),
 
+    // LLM cost tracking
+    LLM_COST_TRACKING_ENABLED: BoolEnv.default(true),
+    LLM_PRICING_RELOAD_INTERVAL_MS: z.coerce.number().int().default(5 * 60 * 1000), // 5 minutes
+    LLM_PRICING_SEED_ON_STARTUP: BoolEnv.default(false),
+    LLM_PRICING_READY_TIMEOUT_MS: z.coerce.number().int().default(500),
+    LLM_METRICS_BATCH_SIZE: z.coerce.number().int().default(5000),
+    LLM_METRICS_FLUSH_INTERVAL_MS: z.coerce.number().int().default(2000),
+    LLM_METRICS_MAX_BATCH_SIZE: z.coerce.number().int().default(10000),
+    LLM_METRICS_MAX_CONCURRENCY: z.coerce.number().int().default(2),
+
     // Bootstrap
     TRIGGER_BOOTSTRAP_ENABLED: z.string().default("0"),
     TRIGGER_BOOTSTRAP_WORKER_GROUP_NAME: z.string().optional(),
@@ -1260,11 +1374,14 @@ const EnvironmentSchema = z
     EVENT_LOOP_MONITOR_THRESHOLD_MS: z.coerce.number().int().default(100),
     EVENT_LOOP_MONITOR_UTILIZATION_INTERVAL_MS: z.coerce.number().int().default(1000),
     EVENT_LOOP_MONITOR_UTILIZATION_SAMPLE_RATE: z.coerce.number().default(0.05),
+    EVENT_LOOP_MONITOR_NOTIFY_ENABLED: z.string().default("0"),
 
     VERY_SLOW_QUERY_THRESHOLD_MS: z.coerce.number().int().optional(),
 
     REALTIME_STREAMS_S2_BASIN: z.string().optional(),
     REALTIME_STREAMS_S2_ACCESS_TOKEN: z.string().optional(),
+    REALTIME_STREAMS_S2_ENDPOINT: z.string().optional(),
+    REALTIME_STREAMS_S2_SKIP_ACCESS_TOKENS: z.enum(["true", "false"]).default("false"),
     REALTIME_STREAMS_S2_ACCESS_TOKEN_EXPIRATION_IN_MS: z.coerce
       .number()
       .int()
@@ -1277,6 +1394,10 @@ const EnvironmentSchema = z
     REALTIME_STREAMS_S2_WAIT_SECONDS: z.coerce.number().int().default(60),
     REALTIME_STREAMS_DEFAULT_VERSION: z.enum(["v1", "v2"]).default("v1"),
     WAIT_UNTIL_TIMEOUT_MS: z.coerce.number().int().default(600_000),
+
+    // Private connections
+    PRIVATE_CONNECTIONS_ENABLED: z.string().optional(),
+    PRIVATE_CONNECTIONS_AWS_ACCOUNT_IDS: z.string().optional(),
   })
   .and(GithubAppEnvSchema)
   .and(S2EnvSchema);
diff --git a/apps/webapp/app/eventLoopMonitor.server.ts b/apps/webapp/app/eventLoopMonitor.server.ts
index b86ea3d31ae..0a1b33690bb 100644
--- a/apps/webapp/app/eventLoopMonitor.server.ts
+++ b/apps/webapp/app/eventLoopMonitor.server.ts
@@ -9,6 +9,23 @@ import { signalsEmitter } from "./services/signals.server";
 
 const THRESHOLD_NS = env.EVENT_LOOP_MONITOR_THRESHOLD_MS * 1e6;
 
+// ANSI color codes for terminal output
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+
+function notifyEventLoopBlocked(timeMs: number, asyncType: string): void {
+  if (env.EVENT_LOOP_MONITOR_NOTIFY_ENABLED !== "1") {
+    return;
+  }
+
+  console.warn(
+    `${RED}⚠️  Event loop blocked${RESET} for ${YELLOW}${timeMs.toFixed(
+      1
+    )}ms${RESET} (${asyncType})`
+  );
+}
+
 const cache = new Map<number, { type: string; start?: [number, number]; parentCtx?: Context }>();
 
 function init(asyncId: number, type: string, triggerAsyncId: number, resource: any) {
@@ -66,6 +83,8 @@ function after(asyncId: number) {
     );
 
     newSpan.end();
+
+    notifyEventLoopBlocked(time, cached.type);
   }
 }
 
diff --git a/apps/webapp/app/features.server.ts b/apps/webapp/app/features.server.ts
index e55f91e213f..36a134dfe99 100644
--- a/apps/webapp/app/features.server.ts
+++ b/apps/webapp/app/features.server.ts
@@ -1,7 +1,9 @@
+import { env } from "./env.server";
 import { requestUrl } from "./utils/requestUrl.server";
 
 export type TriggerFeatures = {
   isManagedCloud: boolean;
+  hasPrivateConnections: boolean;
 };
 
 function isManagedCloud(host: string): boolean {
@@ -13,9 +15,17 @@ function isManagedCloud(host: string): boolean {
   );
 }
 
+function hasPrivateConnections(host: string): boolean {
+  if (env.PRIVATE_CONNECTIONS_ENABLED === "1") {
+    return isManagedCloud(host);
+  }
+  return false;
+}
+
 function featuresForHost(host: string): TriggerFeatures {
   return {
     isManagedCloud: isManagedCloud(host),
+    hasPrivateConnections: hasPrivateConnections(host),
   };
 }
 
diff --git a/apps/webapp/app/hooks/useCanViewLogsPage.ts b/apps/webapp/app/hooks/useCanViewLogsPage.ts
new file mode 100644
index 00000000000..3eb36b0641b
--- /dev/null
+++ b/apps/webapp/app/hooks/useCanViewLogsPage.ts
@@ -0,0 +1,16 @@
+import { useEffect } from "react";
+import { useTypedFetcher } from "remix-typedjson";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { type loader as canViewLogsPageLoader } from "~/routes/resources.orgs.$organizationSlug.can-view-logs-page/route";
+
+export function useCanViewLogsPage(): boolean | undefined {
+  const organization = useOrganization();
+  const fetcher = useTypedFetcher<typeof canViewLogsPageLoader>();
+
+  useEffect(() => {
+    const url = `/resources/orgs/${organization.slug}/can-view-logs-page`;
+    fetcher.load(url);
+  }, [organization.slug]);
+
+  return fetcher.data?.canViewLogsPage;
+}
diff --git a/apps/webapp/app/hooks/useDashboardEditor.ts b/apps/webapp/app/hooks/useDashboardEditor.ts
new file mode 100644
index 00000000000..65b2ccca6bb
--- /dev/null
+++ b/apps/webapp/app/hooks/useDashboardEditor.ts
@@ -0,0 +1,515 @@
+import { useReducer, useCallback, useRef, useEffect } from "react";
+import { nanoid } from "nanoid";
+import type {
+  DashboardLayout,
+  LayoutItem,
+  Widget,
+} from "~/presenters/v3/MetricDashboardPresenter.server";
+import type { WidgetData, QueryWidgetConfig } from "~/components/metrics/QueryWidget";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type EditorMode =
+  | null
+  | { type: "add" }
+  | { type: "edit"; widgetId: string; widget: WidgetData };
+
+type DashboardState = {
+  /** The layout items (positions/sizes) */
+  layout: LayoutItem[];
+  /** The widget configurations keyed by widget ID */
+  widgets: Record<string, Widget>;
+  /** Current editor mode (add/edit/closed) */
+  editorMode: EditorMode;
+};
+
+// ============================================================================
+// Actions
+// ============================================================================
+
+type DashboardAction =
+  | { type: "ADD_WIDGET"; payload: { id: string; widget: Widget; layoutItem: LayoutItem } }
+  | { type: "UPDATE_WIDGET"; payload: { id: string; widget: Widget } }
+  | { type: "RENAME_WIDGET"; payload: { id: string; title: string } }
+  | { type: "DELETE_WIDGET"; payload: { id: string } }
+  | { type: "DUPLICATE_WIDGET"; payload: { id: string; newId: string } }
+  | { type: "UPDATE_LAYOUT"; payload: { layout: LayoutItem[] } }
+  | { type: "RESET_STATE"; payload: { layout: LayoutItem[]; widgets: Record<string, Widget> } }
+  | { type: "OPEN_ADD_EDITOR" }
+  | { type: "OPEN_EDIT_EDITOR"; payload: { widgetId: string; widget: WidgetData } }
+  | { type: "CLOSE_EDITOR" };
+
+// ============================================================================
+// Reducer
+// ============================================================================
+
+function dashboardReducer(state: DashboardState, action: DashboardAction): DashboardState {
+  switch (action.type) {
+    case "ADD_WIDGET":
+      return {
+        ...state,
+        layout: [...state.layout, action.payload.layoutItem],
+        widgets: {
+          ...state.widgets,
+          [action.payload.id]: action.payload.widget,
+        },
+        editorMode: null,
+      };
+
+    case "UPDATE_WIDGET":
+      return {
+        ...state,
+        widgets: {
+          ...state.widgets,
+          [action.payload.id]: action.payload.widget,
+        },
+        editorMode: null,
+      };
+
+    case "RENAME_WIDGET": {
+      const existingWidget = state.widgets[action.payload.id];
+      if (!existingWidget) return state;
+      return {
+        ...state,
+        widgets: {
+          ...state.widgets,
+          [action.payload.id]: {
+            ...existingWidget,
+            title: action.payload.title,
+          },
+        },
+      };
+    }
+
+    case "DELETE_WIDGET": {
+      const { [action.payload.id]: _, ...remainingWidgets } = state.widgets;
+      return {
+        ...state,
+        layout: state.layout.filter((item) => item.i !== action.payload.id),
+        widgets: remainingWidgets,
+      };
+    }
+
+    case "DUPLICATE_WIDGET": {
+      const original = state.widgets[action.payload.id];
+      const originalLayout = state.layout.find((l) => l.i === action.payload.id);
+      if (!original || !originalLayout) return state;
+
+      const maxBottom = Math.max(0, ...state.layout.map((l) => l.y + l.h));
+
+      // Deep copy the widget to ensure no shared references
+      // This prevents edits to one widget from affecting the duplicate
+      const duplicatedWidget: Widget = {
+        title: `${original.title} (Copy)`,
+        query: original.query,
+        display: JSON.parse(JSON.stringify(original.display)) as QueryWidgetConfig,
+      };
+
+      return {
+        ...state,
+        layout: [
+          ...state.layout,
+          { ...originalLayout, i: action.payload.newId, y: maxBottom, x: 0 },
+        ],
+        widgets: {
+          ...state.widgets,
+          [action.payload.newId]: duplicatedWidget,
+        },
+      };
+    }
+
+    case "UPDATE_LAYOUT":
+      return { ...state, layout: action.payload.layout };
+
+    case "RESET_STATE":
+      return {
+        ...state,
+        layout: action.payload.layout,
+        widgets: action.payload.widgets,
+      };
+
+    case "OPEN_ADD_EDITOR":
+      return { ...state, editorMode: { type: "add" } };
+
+    case "OPEN_EDIT_EDITOR":
+      return {
+        ...state,
+        editorMode: { type: "edit", widgetId: action.payload.widgetId, widget: action.payload.widget },
+      };
+
+    case "CLOSE_EDITOR":
+      return { ...state, editorMode: null };
+
+    default:
+      return state;
+  }
+}
+
+// ============================================================================
+// Hook Options
+// ============================================================================
+
+export type UseDashboardEditorOptions = {
+  /** Initial dashboard layout data from the server */
+  initialData: DashboardLayout;
+  /** URL for widget actions (add, update, delete, duplicate) */
+  widgetActionUrl: string;
+  /** URL for layout updates. If empty or not provided, uses current page URL. */
+  layoutActionUrl?: string;
+  /** Maximum number of widgets allowed per dashboard. If not provided, no limit is enforced. */
+  widgetLimit?: number;
+  /** Callback when a sync error occurs */
+  onSyncError?: (error: Error, action: string) => void;
+  /** Callback when a widget action is blocked by the limit */
+  onWidgetLimitReached?: () => void;
+};
+
+// ============================================================================
+// Sync Queue Types
+// ============================================================================
+
+type WidgetSyncTask = {
+  type: "widget";
+  action: string;
+  data: Record<string, string>;
+};
+
+type LayoutSyncTask = {
+  type: "layout";
+  layout: LayoutItem[];
+};
+
+type SyncTask = WidgetSyncTask | LayoutSyncTask;
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export function useDashboardEditor({
+  initialData,
+  widgetActionUrl,
+  layoutActionUrl,
+  widgetLimit,
+  onSyncError,
+  onWidgetLimitReached,
+}: UseDashboardEditorOptions) {
+  const [state, dispatch] = useReducer(dashboardReducer, {
+    layout: initialData.layout,
+    widgets: initialData.widgets,
+    editorMode: null,
+  });
+
+  // Refs for debouncing and tracking initialization
+  const layoutDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const isInitializedRef = useRef(false);
+  const currentLayoutJsonRef = useRef<string>(JSON.stringify(initialData.layout));
+
+  // Sync queue to prevent race conditions
+  const syncQueueRef = useRef<SyncTask[]>([]);
+  const isSyncingRef = useRef(false);
+
+  // Reset state when initialData changes (e.g., navigating to different dashboard)
+  const initialDataJson = JSON.stringify({ layout: initialData.layout, widgets: initialData.widgets });
+  useEffect(() => {
+    // Cancel any pending layout save
+    if (layoutDebounceRef.current) {
+      clearTimeout(layoutDebounceRef.current);
+      layoutDebounceRef.current = null;
+    }
+
+    // Clear the sync queue when switching dashboards
+    syncQueueRef.current = [];
+
+    // Reset state to new initial data
+    dispatch({
+      type: "RESET_STATE",
+      payload: { layout: initialData.layout, widgets: initialData.widgets },
+    });
+
+    // Update refs
+    currentLayoutJsonRef.current = JSON.stringify(initialData.layout);
+    isInitializedRef.current = false;
+
+    // Allow saves after a short delay to skip initial mount callbacks
+    const initTimeout = setTimeout(() => {
+      isInitializedRef.current = true;
+    }, 100);
+
+    return () => {
+      clearTimeout(initTimeout);
+      if (layoutDebounceRef.current) {
+        clearTimeout(layoutDebounceRef.current);
+      }
+    };
+  }, [initialDataJson]);
+
+  // -------------------------------------------------------------------------
+  // Sync queue processor - ensures only one sync runs at a time
+  // -------------------------------------------------------------------------
+
+  const processNextSync = useCallback(async () => {
+    // If already syncing or queue is empty, do nothing
+    if (isSyncingRef.current || syncQueueRef.current.length === 0) {
+      return;
+    }
+
+    isSyncingRef.current = true;
+    const task = syncQueueRef.current.shift()!;
+
+    try {
+      if (task.type === "widget") {
+        const formData = new FormData();
+        formData.set("action", task.action);
+        Object.entries(task.data).forEach(([k, v]) => formData.set(k, v));
+
+        const response = await fetch(widgetActionUrl, {
+          method: "POST",
+          body: formData,
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Failed to ${task.action} widget: ${errorText}`);
+        }
+      } else if (task.type === "layout") {
+        const formData = new FormData();
+        formData.set("action", "layout");
+        formData.set("layout", JSON.stringify(task.layout));
+
+        // Use current page URL if layoutActionUrl is not provided
+        const url = layoutActionUrl || window.location.pathname;
+
+        const response = await fetch(url, {
+          method: "POST",
+          body: formData,
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error("Failed to update layout: " + errorText);
+        }
+      }
+    } catch (error) {
+      console.error(`Dashboard sync error:`, error);
+      const actionName = task.type === "widget" ? task.action : "layout";
+      onSyncError?.(error instanceof Error ? error : new Error(String(error)), actionName);
+    } finally {
+      isSyncingRef.current = false;
+      // Process next item in queue
+      processNextSync();
+    }
+  }, [widgetActionUrl, layoutActionUrl, onSyncError]);
+
+  // -------------------------------------------------------------------------
+  // Queue helpers
+  // -------------------------------------------------------------------------
+
+  const queueWidgetSync = useCallback(
+    (action: string, data: Record<string, string>) => {
+      syncQueueRef.current.push({ type: "widget", action, data });
+      processNextSync();
+    },
+    [processNextSync]
+  );
+
+  const queueLayoutSync = useCallback(
+    (layout: LayoutItem[]) => {
+      // For layout syncs, we only care about the latest state
+      // Remove any pending layout syncs and add the new one
+      syncQueueRef.current = syncQueueRef.current.filter((task) => task.type !== "layout");
+      syncQueueRef.current.push({ type: "layout", layout });
+      processNextSync();
+    },
+    [processNextSync]
+  );
+
+  // -------------------------------------------------------------------------
+  // Action handlers
+  // -------------------------------------------------------------------------
+
+  // Count only non-title widgets for limit checks (title widgets are free)
+  const countedWidgets = Object.values(state.widgets).filter(
+    (w) => w.display.type !== "title"
+  ).length;
+
+  const addWidget = useCallback(
+    (title: string, query: string, config: QueryWidgetConfig) => {
+      // Guard: check widget limit (title widgets don't count)
+      if (widgetLimit !== undefined && countedWidgets >= widgetLimit) {
+        onWidgetLimitReached?.();
+        return;
+      }
+
+      const id = nanoid(8);
+      const maxBottom = Math.max(0, ...state.layout.map((l) => l.y + l.h));
+      const layoutItem: LayoutItem = { i: id, x: 0, y: maxBottom, w: 12, h: 15 };
+      const widget: Widget = { title, query, display: config };
+
+      // Update local state immediately
+      dispatch({ type: "ADD_WIDGET", payload: { id, widget, layoutItem } });
+
+      // Queue sync to server (processed sequentially)
+      // Send the client-generated ID so the server uses the same ID
+      queueWidgetSync("add", {
+        widgetId: id,
+        title,
+        query,
+        config: JSON.stringify(config),
+      });
+    },
+    [state.layout, countedWidgets, widgetLimit, onWidgetLimitReached, queueWidgetSync]
+  );
+
+  const addTitleWidget = useCallback(
+    (title: string) => {
+      const id = nanoid(8);
+      const maxBottom = Math.max(0, ...state.layout.map((l) => l.y + l.h));
+      // Title widgets are fixed at h=2 and full width
+      const layoutItem: LayoutItem = { i: id, x: 0, y: maxBottom, w: 12, h: 2 };
+      const config: QueryWidgetConfig = { type: "title" };
+      const widget: Widget = { title, query: "", display: config };
+
+      // Update local state immediately
+      dispatch({ type: "ADD_WIDGET", payload: { id, widget, layoutItem } });
+
+      // Queue sync to server (processed sequentially)
+      // Send the client-generated ID so the server uses the same ID
+      queueWidgetSync("add", {
+        widgetId: id,
+        title,
+        query: "",
+        config: JSON.stringify(config),
+      });
+    },
+    [state.layout, queueWidgetSync]
+  );
+
+  const updateWidget = useCallback(
+    (widgetId: string, title: string, query: string, config: QueryWidgetConfig) => {
+      const widget: Widget = { title, query, display: config };
+
+      // Update local state immediately
+      dispatch({ type: "UPDATE_WIDGET", payload: { id: widgetId, widget } });
+
+      // Queue sync to server (processed sequentially)
+      queueWidgetSync("update", {
+        widgetId,
+        title,
+        query,
+        config: JSON.stringify(config),
+      });
+    },
+    [queueWidgetSync]
+  );
+
+  const deleteWidget = useCallback(
+    (widgetId: string) => {
+      // Update local state immediately
+      dispatch({ type: "DELETE_WIDGET", payload: { id: widgetId } });
+
+      // Queue sync to server (processed sequentially)
+      queueWidgetSync("delete", { widgetId });
+    },
+    [queueWidgetSync]
+  );
+
+  const duplicateWidget = useCallback(
+    (widgetId: string) => {
+      // Guard: check widget limit (title widgets don't count)
+      if (widgetLimit !== undefined && countedWidgets >= widgetLimit) {
+        onWidgetLimitReached?.();
+        return;
+      }
+
+      const newId = nanoid(8);
+
+      // Update local state immediately
+      dispatch({ type: "DUPLICATE_WIDGET", payload: { id: widgetId, newId } });
+
+      // Queue sync to server (processed sequentially)
+      // Send the client-generated newId so the server uses the same ID for the duplicate
+      queueWidgetSync("duplicate", { widgetId, newId });
+    },
+    [countedWidgets, widgetLimit, onWidgetLimitReached, queueWidgetSync]
+  );
+
+  const renameWidget = useCallback(
+    (widgetId: string, title: string) => {
+      // Update local state immediately
+      dispatch({ type: "RENAME_WIDGET", payload: { id: widgetId, title } });
+
+      // Queue sync to server (processed sequentially)
+      queueWidgetSync("rename", { widgetId, title });
+    },
+    [queueWidgetSync]
+  );
+
+  const updateLayout = useCallback(
+    (newLayout: LayoutItem[]) => {
+      // Skip if not yet initialized (prevents saving during mount/navigation)
+      if (!isInitializedRef.current) {
+        return;
+      }
+
+      const newLayoutJson = JSON.stringify(newLayout);
+
+      // Skip if layout hasn't actually changed
+      if (newLayoutJson === currentLayoutJsonRef.current) {
+        return;
+      }
+
+      // Update local state immediately
+      dispatch({ type: "UPDATE_LAYOUT", payload: { layout: newLayout } });
+
+      // Clear existing debounce timeout
+      if (layoutDebounceRef.current) {
+        clearTimeout(layoutDebounceRef.current);
+      }
+
+      // Debounce before queueing - this ensures rapid layout changes
+      // (like dragging) don't queue up many requests
+      layoutDebounceRef.current = setTimeout(() => {
+        currentLayoutJsonRef.current = newLayoutJson;
+        // Queue layout sync (replaces any pending layout sync in queue)
+        queueLayoutSync(newLayout);
+      }, 500);
+    },
+    [queueLayoutSync]
+  );
+
+  const openAddEditor = useCallback(() => {
+    dispatch({ type: "OPEN_ADD_EDITOR" });
+  }, []);
+
+  const openEditEditor = useCallback((widgetId: string, widget: WidgetData) => {
+    dispatch({ type: "OPEN_EDIT_EDITOR", payload: { widgetId, widget } });
+  }, []);
+
+  const closeEditor = useCallback(() => {
+    dispatch({ type: "CLOSE_EDITOR" });
+  }, []);
+
+  // -------------------------------------------------------------------------
+  // Return value
+  // -------------------------------------------------------------------------
+
+  return {
+    /** Current dashboard state */
+    state,
+    /** Action dispatchers */
+    actions: {
+      addWidget,
+      addTitleWidget,
+      updateWidget,
+      renameWidget,
+      deleteWidget,
+      duplicateWidget,
+      updateLayout,
+      openAddEditor,
+      openEditEditor,
+      closeEditor,
+    },
+  };
+}
diff --git a/apps/webapp/app/hooks/useElementVisibility.ts b/apps/webapp/app/hooks/useElementVisibility.ts
new file mode 100644
index 00000000000..3e01cb99c26
--- /dev/null
+++ b/apps/webapp/app/hooks/useElementVisibility.ts
@@ -0,0 +1,35 @@
+import { useEffect, useRef } from "react";
+
+type UseElementVisibilityOptions = {
+  onVisibilityChange?: (isVisible: boolean) => void;
+};
+
+export function useElementVisibility({
+  onVisibilityChange,
+}: UseElementVisibilityOptions = {}) {
+  const ref = useRef<HTMLDivElement>(null);
+  const isVisibleRef = useRef(false);
+  const callbackRef = useRef(onVisibilityChange);
+  callbackRef.current = onVisibilityChange;
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        const nowVisible = entry.isIntersecting;
+        if (isVisibleRef.current !== nowVisible) {
+          isVisibleRef.current = nowVisible;
+          callbackRef.current?.(nowVisible);
+        }
+      },
+      { threshold: 0 }
+    );
+
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+
+  return { ref, isVisibleRef };
+}
diff --git a/apps/webapp/app/hooks/useFaviconUrl.ts b/apps/webapp/app/hooks/useFaviconUrl.ts
new file mode 100644
index 00000000000..fadf6b18228
--- /dev/null
+++ b/apps/webapp/app/hooks/useFaviconUrl.ts
@@ -0,0 +1,24 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { extractDomain, faviconUrl } from "~/utils/favicon";
+
+function resolve(input: string, size: number): string | null {
+  const domain = extractDomain(input);
+  return domain && domain.includes(".") ? faviconUrl(domain, size) : null;
+}
+
+export function useFaviconUrl(urlInput: string, size: number = 64) {
+  const [url, setUrl] = useState<string | null>(() => resolve(urlInput, size));
+  const timeoutRef = useRef<ReturnType<typeof setTimeout>>();
+
+  useEffect(() => {
+    if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    timeoutRef.current = setTimeout(() => {
+      setUrl(resolve(urlInput, size));
+    }, 400);
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, [urlInput, size]);
+
+  return url;
+}
diff --git a/apps/webapp/app/hooks/useFeatureFlags.ts b/apps/webapp/app/hooks/useFeatureFlags.ts
new file mode 100644
index 00000000000..ea8bde1b26c
--- /dev/null
+++ b/apps/webapp/app/hooks/useFeatureFlags.ts
@@ -0,0 +1,11 @@
+import { type UIMatch } from "@remix-run/react";
+import { useOptionalOrganization } from "./useOrganizations";
+
+/**
+ * Hook to access organization-level feature flags.
+ * Returns the feature flags from the current organization, or an empty object if no organization is found.
+ */
+export function useFeatureFlags(matches?: UIMatch[]) {
+  const org = useOptionalOrganization(matches);
+  return org?.featureFlags ?? {};
+}
diff --git a/apps/webapp/app/hooks/useFeatures.ts b/apps/webapp/app/hooks/useFeatures.ts
index d2e1ac699f5..5ae3dfbf34c 100644
--- a/apps/webapp/app/hooks/useFeatures.ts
+++ b/apps/webapp/app/hooks/useFeatures.ts
@@ -5,5 +5,5 @@ import type { TriggerFeatures } from "~/features.server";
 export function useFeatures(): TriggerFeatures {
   const routeMatch = useTypedRouteLoaderData<typeof loader>("root");
 
-  return routeMatch?.features ?? { isManagedCloud: false };
+  return routeMatch?.features ?? { isManagedCloud: false, hasPrivateConnections: false };
 }
diff --git a/apps/webapp/app/hooks/useFuzzyFilter.ts b/apps/webapp/app/hooks/useFuzzyFilter.ts
index 1c0f6048268..3f0797179f2 100644
--- a/apps/webapp/app/hooks/useFuzzyFilter.ts
+++ b/apps/webapp/app/hooks/useFuzzyFilter.ts
@@ -8,7 +8,7 @@ import { matchSorter } from "match-sorter";
  *
  * @param params - The parameters object
  * @param params.items - Array of objects to filter
- * @param params.keys - Array of object keys to perform the fuzzy search on
+ * @param params.keys - Array of object keys to perform the fuzzy search on (supports dot-notation for nested properties)
  * @returns An object containing:
  *   - filterText: The current filter text
  *   - setFilterText: Function to update the filter text
@@ -28,7 +28,7 @@ export function useFuzzyFilter<T extends Object>({
   keys,
 }: {
   items: T[];
-  keys: Extract<keyof T, string>[];
+  keys: (Extract<keyof T, string> | (string & {}))[];
 }) {
   const [filterText, setFilterText] = useState("");
 
diff --git a/apps/webapp/app/hooks/useInterval.ts b/apps/webapp/app/hooks/useInterval.ts
new file mode 100644
index 00000000000..4d5413e977e
--- /dev/null
+++ b/apps/webapp/app/hooks/useInterval.ts
@@ -0,0 +1,63 @@
+import { useEffect, useRef } from "react";
+
+type UseIntervalOptions = {
+  /** If passed, will refresh every interval MS */
+  interval?: number;
+  onLoad?: boolean;
+  onFocus?: boolean;
+  disabled?: boolean;
+  callback: () => void;
+};
+
+export function useInterval({
+  interval,
+  onLoad = true,
+  onFocus = true,
+  disabled = false,
+  callback,
+}: UseIntervalOptions) {
+  // Always keep the latest callback in a ref so the effects below
+  // never close over a stale version.
+  const latestCallback = useRef(callback);
+  useEffect(() => {
+    latestCallback.current = callback;
+  }, [callback]);
+
+  // On interval
+  useEffect(() => {
+    if (!interval || interval <= 0 || disabled) return;
+
+    const intervalId = setInterval(() => {
+      latestCallback.current();
+    }, interval);
+
+    return () => clearInterval(intervalId);
+  }, [interval, disabled]);
+
+  // On focus
+  useEffect(() => {
+    if (!onFocus || disabled) return;
+
+    const handleFocus = () => {
+      if (document.visibilityState === "visible") {
+        latestCallback.current();
+      }
+    };
+
+    // Revalidate when the page becomes visible
+    document.addEventListener("visibilitychange", handleFocus);
+    // Revalidate when the window gains focus
+    window.addEventListener("focus", handleFocus);
+
+    return () => {
+      document.removeEventListener("visibilitychange", handleFocus);
+      window.removeEventListener("focus", handleFocus);
+    };
+  }, [onFocus, disabled]);
+
+  // On load
+  useEffect(() => {
+    if (disabled || !onLoad) return;
+    latestCallback.current();
+  }, [disabled, onLoad]);
+}
diff --git a/apps/webapp/app/hooks/useOrganizations.ts b/apps/webapp/app/hooks/useOrganizations.ts
index 877605b954b..1aa81b11048 100644
--- a/apps/webapp/app/hooks/useOrganizations.ts
+++ b/apps/webapp/app/hooks/useOrganizations.ts
@@ -61,3 +61,29 @@ export function useIsImpersonating(matches?: UIMatch[]) {
   });
   return data?.isImpersonating === true;
 }
+
+export type CustomDashboard = UseDataFunctionReturn<typeof orgLoader>["customDashboards"][number];
+
+export function useCustomDashboards(matches?: UIMatch[]) {
+  const data = useTypedMatchesData<typeof orgLoader>({
+    id: "routes/_app.orgs.$organizationSlug",
+    matches,
+  });
+  return data?.customDashboards ?? [];
+}
+
+export function useDashboardLimits(matches?: UIMatch[]) {
+  const data = useTypedMatchesData<typeof orgLoader>({
+    id: "routes/_app.orgs.$organizationSlug",
+    matches,
+  });
+  return data?.dashboardLimits ?? { used: 0, limit: 3 };
+}
+
+export function useWidgetLimitPerDashboard(matches?: UIMatch[]) {
+  const data = useTypedMatchesData<typeof orgLoader>({
+    id: "routes/_app.orgs.$organizationSlug",
+    matches,
+  });
+  return data?.widgetLimitPerDashboard ?? 16;
+}
diff --git a/apps/webapp/app/hooks/usePostHog.ts b/apps/webapp/app/hooks/usePostHog.ts
index 99e2597dfe4..f52663ec014 100644
--- a/apps/webapp/app/hooks/usePostHog.ts
+++ b/apps/webapp/app/hooks/usePostHog.ts
@@ -1,6 +1,6 @@
 import { useLocation } from "@remix-run/react";
 import posthog from "posthog-js";
-import { useEffect, useRef } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useOrganizationChanged } from "./useOrganizations";
 import { useOptionalUser, useUserChanged } from "./useUser";
 import { useProjectChanged } from "./useProject";
@@ -68,3 +68,18 @@ export const usePostHog = (apiKey?: string, logging = false, debug = false): voi
     posthog.capture("$pageview");
   }, [location, logging]);
 };
+
+export function usePostHogTracking() {
+  const capture = useCallback(
+    (eventName: string, properties?: Record<string, unknown>) => {
+      posthog.capture(eventName, properties);
+    },
+    []
+  );
+
+  const startSessionRecording = useCallback(() => {
+    posthog.startSessionRecording();
+  }, []);
+
+  return { capture, startSessionRecording };
+}
diff --git a/apps/webapp/app/hooks/useRevalidateOnParam.ts b/apps/webapp/app/hooks/useRevalidateOnParam.ts
new file mode 100644
index 00000000000..de05141d95e
--- /dev/null
+++ b/apps/webapp/app/hooks/useRevalidateOnParam.ts
@@ -0,0 +1,57 @@
+import { useEffect } from "react";
+import { useRevalidator, useSearchParams } from "@remix-run/react";
+
+type UseRevalidateOnParamOptions = {
+  /** The query param(s) that trigger revalidation */
+  param: string | string[];
+  /** Callback fired when revalidation is triggered */
+  onRevalidate?: () => void;
+};
+
+/**
+ * Hook that triggers revalidation when specific query params are present,
+ * then removes those params from the URL.
+ *
+ * Usage:
+ * ```ts
+ * // Revalidate when ?_revalidate is present
+ * useRevalidateOnParam({ param: "_revalidate" });
+ *
+ * // With callback to close a modal
+ * useRevalidateOnParam({
+ *   param: "_revalidate",
+ *   onRevalidate: () => setEditorMode(null),
+ * });
+ * ```
+ *
+ * The redirect should include the param:
+ * ```ts
+ * return redirect(`${dashboardPath}?_revalidate=${Date.now()}`);
+ * ```
+ */
+export function useRevalidateOnParam({ param, onRevalidate }: UseRevalidateOnParamOptions) {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const revalidator = useRevalidator();
+
+  const paramArray = Array.isArray(param) ? param : [param];
+
+  useEffect(() => {
+    // Check if any of the trigger params are present
+    const hasParam = paramArray.some((p) => searchParams.has(p));
+
+    if (hasParam) {
+      // Trigger revalidation
+      revalidator.revalidate();
+
+      // Call the callback if provided
+      onRevalidate?.();
+
+      // Remove the trigger params from the URL
+      const newParams = new URLSearchParams(searchParams);
+      paramArray.forEach((p) => newParams.delete(p));
+
+      // Update URL without the params (replace to avoid adding to history)
+      setSearchParams(newParams, { replace: true });
+    }
+  }, [searchParams, setSearchParams, revalidator, paramArray, onRevalidate]);
+}
diff --git a/apps/webapp/app/hooks/useShortcutKeys.tsx b/apps/webapp/app/hooks/useShortcutKeys.tsx
index 0674b5bc0b4..319a91cad84 100644
--- a/apps/webapp/app/hooks/useShortcutKeys.tsx
+++ b/apps/webapp/app/hooks/useShortcutKeys.tsx
@@ -43,8 +43,10 @@ export function useShortcutKeys({
 
   useHotkeys(
     keys,
-    (event, hotkeysEvent) => {
-      action(event);
+    (event) => {
+      if (!event.repeat) {
+        action(event);
+      }
     },
     {
       enabled: isEnabled,
diff --git a/apps/webapp/app/hooks/useUser.ts b/apps/webapp/app/hooks/useUser.ts
index e31455cf92a..fd9938fdb9a 100644
--- a/apps/webapp/app/hooks/useUser.ts
+++ b/apps/webapp/app/hooks/useUser.ts
@@ -1,10 +1,12 @@
-import { UIMatch } from "@remix-run/react";
-import type { User } from "~/models/user.server";
-import { loader } from "~/root";
+import { type UIMatch } from "@remix-run/react";
+import type { UserWithDashboardPreferences } from "~/models/user.server";
+import { type loader } from "~/root";
 import { useChanged } from "./useChanged";
 import { useTypedMatchesData } from "./useTypedMatchData";
 import { useIsImpersonating } from "./useOrganizations";
 
+export type User = UserWithDashboardPreferences;
+
 export function useOptionalUser(matches?: UIMatch[]): User | undefined {
   const routeMatch = useTypedMatchesData<typeof loader>({
     id: "root",
diff --git a/apps/webapp/app/models/admin.server.ts b/apps/webapp/app/models/admin.server.ts
index 434bcf8ffe5..bd3adc8cbf2 100644
--- a/apps/webapp/app/models/admin.server.ts
+++ b/apps/webapp/app/models/admin.server.ts
@@ -1,12 +1,16 @@
 import { redirect } from "@remix-run/server-runtime";
 import { prisma } from "~/db.server";
+import { logger } from "~/services/logger.server";
 import { SearchParams } from "~/routes/admin._index";
 import {
   clearImpersonationId,
   commitImpersonationSession,
+  getImpersonationId,
   setImpersonationId,
 } from "~/services/impersonation.server";
+import { authenticator } from "~/services/auth.server";
 import { requireUser } from "~/services/session.server";
+import { extractClientIp } from "~/utils/extractClientIp.server";
 
 const pageSize = 20;
 
@@ -212,6 +216,26 @@ export async function redirectWithImpersonation(request: Request, userId: string
     throw new Error("Unauthorized");
   }
 
+  const xff = request.headers.get("x-forwarded-for");
+  const ipAddress = extractClientIp(xff);
+
+  try {
+    await prisma.impersonationAuditLog.create({
+      data: {
+        action: "START",
+        adminId: user.id,
+        targetId: userId,
+        ipAddress,
+      },
+    });
+  } catch (error) {
+    logger.error("Failed to create impersonation audit log", {
+      error,
+      adminId: user.id,
+      targetId: userId,
+    });
+  }
+
   const session = await setImpersonationId(userId, request);
 
   return redirect(path, {
@@ -220,6 +244,31 @@ export async function redirectWithImpersonation(request: Request, userId: string
 }
 
 export async function clearImpersonation(request: Request, path: string) {
+  const authUser = await authenticator.isAuthenticated(request);
+  const targetId = await getImpersonationId(request);
+
+  if (targetId && authUser?.userId) {
+    const xff = request.headers.get("x-forwarded-for");
+    const ipAddress = extractClientIp(xff);
+
+    try {
+      await prisma.impersonationAuditLog.create({
+        data: {
+          action: "STOP",
+          adminId: authUser.userId,
+          targetId,
+          ipAddress,
+        },
+      });
+    } catch (error) {
+      logger.error("Failed to create impersonation audit log", {
+        error,
+        adminId: authUser.userId,
+        targetId,
+      });
+    }
+  }
+
   const session = await clearImpersonationId(request);
 
   return redirect(path, {
diff --git a/apps/webapp/app/models/orgIntegration.server.ts b/apps/webapp/app/models/orgIntegration.server.ts
index 343da2701d9..a69aa917671 100644
--- a/apps/webapp/app/models/orgIntegration.server.ts
+++ b/apps/webapp/app/models/orgIntegration.server.ts
@@ -47,6 +47,13 @@ export type AuthenticatableIntegration = OrganizationIntegration & {
   tokenReference: SecretReference;
 };
 
+export function isIntegrationForService<TService extends IntegrationService>(
+  integration: AuthenticatableIntegration,
+  service: TService
+): integration is OrganizationIntegrationForService<TService> {
+  return (integration.service satisfies IntegrationService) === service;
+}
+
 export class OrgIntegrationRepository {
   static async getAuthenticatedClientForIntegration<TService extends IntegrationService>(
     integration: OrganizationIntegrationForService<TService>,
@@ -89,6 +96,23 @@ export class OrgIntegrationRepository {
   static isSlackSupported =
     !!env.ORG_SLACK_INTEGRATION_CLIENT_ID && !!env.ORG_SLACK_INTEGRATION_CLIENT_SECRET;
 
+  static isVercelSupported =
+    !!env.VERCEL_INTEGRATION_CLIENT_ID && !!env.VERCEL_INTEGRATION_CLIENT_SECRET && !!env.VERCEL_INTEGRATION_APP_SLUG;
+
+  /**
+   * Generate the URL to install the Vercel integration.
+   * Users are redirected to Vercel's marketplace to complete the installation.
+   *
+   * @param state - Base64-encoded state containing org/project info for the callback
+   */
+  static vercelInstallUrl(state: string): string {
+    // The user goes to Vercel's marketplace to install the integration
+    // After installation, Vercel redirects to our callback with the authorization code
+    const redirectUri = encodeURIComponent(`${env.APP_ORIGIN}/vercel/callback`);
+    const encodedState = encodeURIComponent(state);
+    return `https://vercel.com/integrations/${env.VERCEL_INTEGRATION_APP_SLUG}/new?state=${encodedState}&redirect_uri=${redirectUri}`;
+  }
+
   static slackAuthorizationUrl(
     state: string,
     scopes: string[] = [
diff --git a/apps/webapp/app/models/organization.server.ts b/apps/webapp/app/models/organization.server.ts
index 66b1d5c5b20..14315dd337c 100644
--- a/apps/webapp/app/models/organization.server.ts
+++ b/apps/webapp/app/models/organization.server.ts
@@ -1,6 +1,7 @@
 import type {
   Organization,
   OrgMember,
+  Prisma,
   Project,
   RuntimeEnvironment,
   User,
@@ -22,8 +23,12 @@ export async function createOrganization(
     title,
     userId,
     companySize,
+    onboardingData,
+    avatar,
   }: Pick<Organization, "title" | "companySize"> & {
     userId: User["id"];
+    onboardingData?: Prisma.InputJsonValue;
+    avatar?: Prisma.InputJsonValue;
   },
   attemptCount = 0
 ): Promise<Organization> {
@@ -47,6 +52,8 @@ export async function createOrganization(
         title,
         userId,
         companySize,
+        onboardingData,
+        avatar,
       },
       attemptCount + 1
     );
@@ -59,6 +66,8 @@ export async function createOrganization(
       title,
       slug: uniqueOrgSlug,
       companySize,
+      onboardingData: onboardingData ?? undefined,
+      avatar: avatar ?? undefined,
       maximumConcurrencyLimit: env.DEFAULT_ORG_EXECUTION_CONCURRENCY_LIMIT,
       members: {
         create: {
diff --git a/apps/webapp/app/models/project.server.ts b/apps/webapp/app/models/project.server.ts
index 736df96ba10..0dc634b5ab7 100644
--- a/apps/webapp/app/models/project.server.ts
+++ b/apps/webapp/app/models/project.server.ts
@@ -1,8 +1,8 @@
 import { nanoid, customAlphabet } from "nanoid";
 import slug from "slug";
-import { prisma } from "~/db.server";
-import type { Project } from "@trigger.dev/database";
-import { Organization, createEnvironment } from "./organization.server";
+import { $replica, prisma } from "~/db.server";
+import type { Prisma, Project } from "@trigger.dev/database";
+import { type Organization, createEnvironment } from "./organization.server";
 import { env } from "~/env.server";
 import { projectCreated } from "~/services/platform.v3.server";
 export type { Project } from "@trigger.dev/database";
@@ -14,6 +14,7 @@ type Options = {
   name: string;
   userId: string;
   version: "v2" | "v3";
+  onboardingData?: Prisma.InputJsonValue;
 };
 
 export class ExceededProjectLimitError extends Error {
@@ -24,7 +25,7 @@ export class ExceededProjectLimitError extends Error {
 }
 
 export async function createProject(
-  { organizationSlug, name, userId, version }: Options,
+  { organizationSlug, name, userId, version, onboardingData }: Options,
   attemptCount = 0
 ): Promise<Project & { organization: Organization }> {
   //check the user has permissions to do this
@@ -84,6 +85,7 @@ export async function createProject(
         name,
         userId,
         version,
+        onboardingData,
       },
       attemptCount + 1
     );
@@ -100,6 +102,7 @@ export async function createProject(
       },
       externalRef: `proj_${externalRefGenerator()}`,
       version: version === "v3" ? "V3" : "V2",
+      onboardingData,
     },
     include: {
       organization: {
@@ -135,7 +138,7 @@ export async function createProject(
 
 export async function findProjectBySlug(orgSlug: string, projectSlug: string, userId: string) {
   // Find the project scoped to the organization, making sure the user belongs to that org
-  return await prisma.project.findFirst({
+  return await $replica.project.findFirst({
     where: {
       slug: projectSlug,
       organization: {
@@ -148,7 +151,7 @@ export async function findProjectBySlug(orgSlug: string, projectSlug: string, us
 
 export async function findProjectByRef(externalRef: string, userId: string) {
   // Find the project scoped to the organization, making sure the user belongs to that org
-  return await prisma.project.findFirst({
+  return await $replica.project.findFirst({
     where: {
       externalRef,
       organization: {
diff --git a/apps/webapp/app/models/projectAlert.server.ts b/apps/webapp/app/models/projectAlert.server.ts
index d2ab0be1d1a..dbcb672ad7d 100644
--- a/apps/webapp/app/models/projectAlert.server.ts
+++ b/apps/webapp/app/models/projectAlert.server.ts
@@ -32,3 +32,9 @@ export const ProjectAlertSlackStorage = z.object({
 });
 
 export type ProjectAlertSlackStorage = z.infer<typeof ProjectAlertSlackStorage>;
+
+export const ErrorAlertConfig = z.object({
+  evaluationIntervalMs: z.number().min(60_000).default(300_000),
+});
+
+export type ErrorAlertConfig = z.infer<typeof ErrorAlertConfig>;
diff --git a/apps/webapp/app/models/runtimeEnvironment.server.ts b/apps/webapp/app/models/runtimeEnvironment.server.ts
index 67119acd08a..f65112b71fc 100644
--- a/apps/webapp/app/models/runtimeEnvironment.server.ts
+++ b/apps/webapp/app/models/runtimeEnvironment.server.ts
@@ -1,6 +1,6 @@
 import type { AuthenticatedEnvironment } from "@internal/run-engine";
 import type { Prisma, PrismaClientOrTransaction, RuntimeEnvironment } from "@trigger.dev/database";
-import { prisma } from "~/db.server";
+import { $replica, prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
 import { getUsername } from "~/utils/username";
 import { sanitizeBranchName } from "~/v3/gitBranch";
@@ -11,7 +11,7 @@ export async function findEnvironmentByApiKey(
   apiKey: string,
   branchName: string | undefined
 ): Promise<AuthenticatedEnvironment | null> {
-  const environment = await prisma.runtimeEnvironment.findFirst({
+  const environment = await $replica.runtimeEnvironment.findFirst({
     where: {
       apiKey,
     },
@@ -67,7 +67,7 @@ export async function findEnvironmentByPublicApiKey(
   apiKey: string,
   branchName: string | undefined
 ): Promise<AuthenticatedEnvironment | null> {
-  const environment = await prisma.runtimeEnvironment.findFirst({
+  const environment = await $replica.runtimeEnvironment.findFirst({
     where: {
       pkApiKey: apiKey,
     },
@@ -89,7 +89,7 @@ export async function findEnvironmentByPublicApiKey(
 export async function findEnvironmentById(
   id: string
 ): Promise<(AuthenticatedEnvironment & { parentEnvironment: { apiKey: string } | null }) | null> {
-  const environment = await prisma.runtimeEnvironment.findFirst({
+  const environment = await $replica.runtimeEnvironment.findFirst({
     where: {
       id,
     },
@@ -118,7 +118,7 @@ export async function findEnvironmentBySlug(
   envSlug: string,
   userId: string
 ): Promise<AuthenticatedEnvironment | null> {
-  return prisma.runtimeEnvironment.findFirst({
+  return $replica.runtimeEnvironment.findFirst({
     where: {
       projectId: projectId,
       slug: envSlug,
@@ -148,7 +148,7 @@ export async function findEnvironmentFromRun(
   runId: string,
   tx?: PrismaClientOrTransaction
 ): Promise<AuthenticatedEnvironment | null> {
-  const taskRun = await (tx ?? prisma).taskRun.findFirst({
+  const taskRun = await (tx ?? $replica).taskRun.findFirst({
     where: {
       id: runId,
     },
@@ -223,7 +223,7 @@ export async function disconnectSession(environmentId: string) {
 }
 
 export async function findLatestSession(environmentId: string) {
-  const session = await prisma.runtimeEnvironmentSession.findFirst({
+  const session = await $replica.runtimeEnvironmentSession.findFirst({
     where: {
       environmentId,
     },
@@ -280,7 +280,7 @@ export async function findDisplayableEnvironment(
   environmentId: string,
   userId: string | undefined
 ) {
-  const environment = await prisma.runtimeEnvironment.findFirst({
+  const environment = await $replica.runtimeEnvironment.findFirst({
     where: {
       id: environmentId,
     },
@@ -308,3 +308,26 @@ export async function findDisplayableEnvironment(
 
   return displayableEnvironment(environment, userId);
 }
+
+export async function hasAccessToEnvironment({
+  environmentId,
+  projectId,
+  organizationId,
+  userId,
+}: {
+  environmentId: string;
+  projectId: string;
+  organizationId: string;
+  userId: string;
+}): Promise<boolean> {
+  const environment = await $replica.runtimeEnvironment.findFirst({
+    where: {
+      id: environmentId,
+      projectId: projectId,
+      organizationId: organizationId,
+      organization: { members: { some: { userId } } },
+    },
+  });
+
+  return environment !== null;
+}
diff --git a/apps/webapp/app/models/user.server.ts b/apps/webapp/app/models/user.server.ts
index 3c5fbe16883..68550f6e98c 100644
--- a/apps/webapp/app/models/user.server.ts
+++ b/apps/webapp/app/models/user.server.ts
@@ -332,13 +332,15 @@ export function updateUser({
   email,
   marketingEmails,
   referralSource,
+  onboardingData,
 }: Pick<User, "id" | "name" | "email"> & {
   marketingEmails?: boolean;
   referralSource?: string;
+  onboardingData?: Prisma.InputJsonValue;
 }) {
   return prisma.user.update({
     where: { id },
-    data: { name, email, marketingEmails, referralSource, confirmedBasicDetails: true },
+    data: { name, email, marketingEmails, referralSource, onboardingData, confirmedBasicDetails: true },
   });
 }
 
diff --git a/apps/webapp/app/models/vercelIntegration.server.ts b/apps/webapp/app/models/vercelIntegration.server.ts
new file mode 100644
index 00000000000..82bedc6430f
--- /dev/null
+++ b/apps/webapp/app/models/vercelIntegration.server.ts
@@ -0,0 +1,1819 @@
+import pLimit from "p-limit";
+import { Vercel } from "@vercel/sdk";
+import type {
+  ResponseBodyEnvs,
+  FilterProjectEnvsResponseBody,
+} from "@vercel/sdk/models/filterprojectenvsop";
+import type {
+  GetV9ProjectsIdOrNameCustomEnvironmentsEnvironments,
+} from "@vercel/sdk/models/getv9projectsidornamecustomenvironmentsop";
+import type { ResponseBodyProjects } from "@vercel/sdk/models/getprojectsop";
+import {
+  Organization,
+  OrganizationIntegration,
+  SecretReference,
+} from "@trigger.dev/database";
+import { z } from "zod";
+import { ResultAsync, errAsync, okAsync } from "neverthrow";
+import { $transaction, prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { logger } from "~/services/logger.server";
+import { getSecretStore } from "~/services/secrets/secretStore.server";
+import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
+import {
+  SyncEnvVarsMapping,
+  shouldSyncEnvVar,
+  TriggerEnvironmentType,
+  envTypeToVercelTarget,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+import { EnvironmentVariablesRepository } from "~/v3/environmentVariables/environmentVariablesRepository.server";
+import {
+  callVercelWithRecovery,
+  wrapVercelCallWithRecovery,
+  VercelSchemas,
+} from "./vercelSdkRecovery.server";
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+function normalizeTarget(target: string[] | string | undefined): string[] {
+  if (Array.isArray(target)) return target.filter(Boolean);
+  if (typeof target === 'string') return [target];
+  return [];
+}
+
+function extractVercelEnvs(
+  response: FilterProjectEnvsResponseBody
+): ResponseBodyEnvs[] {
+  if ("envs" in response && Array.isArray(response.envs)) {
+    return response.envs;
+  }
+  return [];
+}
+
+function isVercelSecretType(type: string): boolean {
+  return type === "secret" || type === "sensitive";
+}
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+export type VercelApiError = {
+  message: string;
+  authInvalid: boolean;
+};
+
+const VercelErrorSchema = z.union([
+  z.object({ status: z.number() }),
+  z.object({ response: z.object({ status: z.number() }) }),
+  z.object({ statusCode: z.number() }),
+]);
+
+function extractVercelErrorStatus(error: unknown): number | null {
+  if (error && typeof error === 'object' && 'status' in error) {
+    const parsed = VercelErrorSchema.safeParse(error);
+    if (parsed.success && 'status' in parsed.data) {
+      return parsed.data.status;
+    }
+  }
+
+  if (error && typeof error === 'object' && 'response' in error) {
+    const parsed = VercelErrorSchema.safeParse(error);
+    if (parsed.success && 'response' in parsed.data) {
+      return parsed.data.response.status;
+    }
+  }
+
+  if (error && typeof error === 'object' && 'statusCode' in error) {
+    const parsed = VercelErrorSchema.safeParse(error);
+    if (parsed.success && 'statusCode' in parsed.data) {
+      return parsed.data.statusCode;
+    }
+  }
+
+  if (typeof error === 'string') {
+    if (error.includes('401')) return 401;
+    if (error.includes('403')) return 403;
+  }
+
+  return null;
+}
+
+function isVercelAuthError(error: unknown): boolean {
+  const status = extractVercelErrorStatus(error);
+  return status === 401 || status === 403;
+}
+
+function toVercelApiError(error: unknown): VercelApiError {
+  if (isVercelApiErrorShape(error)) return error;
+  return {
+    message: error instanceof Error ? error.message : "Unknown error",
+    authInvalid: isVercelAuthError(error),
+  };
+}
+
+function isVercelApiErrorShape(error: unknown): error is VercelApiError {
+  return (
+    error !== null &&
+    typeof error === "object" &&
+    "message" in error &&
+    "authInvalid" in error &&
+    typeof (error as VercelApiError).message === "string" &&
+    typeof (error as VercelApiError).authInvalid === "boolean"
+  );
+}
+
+/**
+ * Wrap a Vercel SDK call in ResultAsync with structured error logging.
+ */
+function wrapVercelCall<T>(
+  promise: Promise<T>,
+  message: string,
+  context: Record<string, unknown>
+): ResultAsync<T, VercelApiError> {
+  return ResultAsync.fromPromise(promise, (error) => {
+    const apiError = toVercelApiError(error);
+    logger.error(message, { ...context, error, authInvalid: apiError.authInvalid });
+    return apiError;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Schemas & token types
+// ---------------------------------------------------------------------------
+
+export const VercelSecretSchema = z.object({
+  accessToken: z.string(),
+  tokenType: z.string().optional(),
+  teamId: z.string().nullable().optional(),
+  userId: z.string().optional(),
+  installationId: z.string().optional(),
+  raw: z.record(z.any()).optional(),
+});
+
+export type VercelSecret = z.infer<typeof VercelSecretSchema>;
+
+export type TokenResponse = {
+  accessToken: string;
+  tokenType: string;
+  teamId?: string;
+  userId?: string;
+  raw: Record<string, unknown>;
+};
+
+// ---------------------------------------------------------------------------
+// Domain types narrowed from Vercel SDK response types.
+//
+// Using Pick and indexed-access types ties these definitions to the SDK so
+// that any upstream type change surfaces as a compile error here rather than
+// silently breaking at runtime.
+// ---------------------------------------------------------------------------
+
+/** Narrowed env-var type from the SDK's FilterProjectEnvs response. */
+export type VercelEnvironmentVariable = {
+  id: string; // narrowed from ResponseBodyEnvs["id"] (string | undefined)
+  key: ResponseBodyEnvs["key"];
+  type: ResponseBodyEnvs["type"];
+  isSecret: boolean;
+  target: string[];
+  isShared?: boolean;
+  customEnvironmentIds: string[];
+};
+
+/** Narrowed custom-environment type – only the fields we consume. */
+export type VercelCustomEnvironment = Pick<
+  GetV9ProjectsIdOrNameCustomEnvironmentsEnvironments,
+  "id" | "slug" | "description" | "branchMatcher"
+>;
+
+/** Narrowed env-var-with-value type from the SDK's FilterProjectEnvs response. */
+export type VercelEnvironmentVariableValue = {
+  key: ResponseBodyEnvs["key"];
+  value: string; // narrowed from ResponseBodyEnvs["value"] – only present after null-check
+  target: string[];
+  type: ResponseBodyEnvs["type"];
+  isSecret: boolean;
+};
+
+/** Narrowed Vercel project type – only id and name. */
+export type VercelProject = Pick<ResponseBodyProjects, "id" | "name">;
+
+// ---------------------------------------------------------------------------
+// Mapper functions – narrow wide SDK responses into our domain types.
+// ---------------------------------------------------------------------------
+
+function toVercelEnvironmentVariable(
+  env: ResponseBodyEnvs
+): VercelEnvironmentVariable {
+  return {
+    id: env.id ?? "",
+    key: env.key,
+    type: env.type,
+    isSecret: isVercelSecretType(env.type),
+    target: normalizeTarget(env.target),
+    customEnvironmentIds: env.customEnvironmentIds ?? [],
+  };
+}
+
+function toVercelCustomEnvironment({
+  id,
+  slug,
+  description,
+  branchMatcher,
+}: GetV9ProjectsIdOrNameCustomEnvironmentsEnvironments): VercelCustomEnvironment {
+  return { id, slug, description, branchMatcher };
+}
+
+function toVercelEnvironmentVariableValue(
+  env: ResponseBodyEnvs
+): VercelEnvironmentVariableValue | null {
+  if (!env.value) return null;
+  return {
+    key: env.key,
+    value: env.value,
+    target: normalizeTarget(env.target),
+    type: env.type,
+    isSecret: isVercelSecretType(env.type),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Repository
+// ---------------------------------------------------------------------------
+
+export class VercelIntegrationRepository {
+  static exchangeCodeForToken(code: string): ResultAsync<TokenResponse, VercelApiError> {
+    const clientId = env.VERCEL_INTEGRATION_CLIENT_ID;
+    const clientSecret = env.VERCEL_INTEGRATION_CLIENT_SECRET;
+    const redirectUri = `${env.APP_ORIGIN}/vercel/callback`;
+
+    if (!clientId || !clientSecret) {
+      logger.error("Vercel integration not configured");
+      return errAsync({ message: "Vercel integration not configured", authInvalid: false });
+    }
+
+    return ResultAsync.fromPromise(
+      fetch("https://api.vercel.com/v2/oauth/access_token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: new URLSearchParams({
+          client_id: clientId,
+          client_secret: clientSecret,
+          code,
+          redirect_uri: redirectUri,
+        }),
+      }).then(async (response) => {
+        if (!response.ok) {
+          const errorText = await response.text();
+          logger.error("Failed to exchange Vercel OAuth code", {
+            status: response.status,
+            error: errorText,
+          });
+          throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        return response.json() as Promise<{
+          access_token: string;
+          token_type: string;
+          team_id?: string;
+          user_id?: string;
+        }>;
+      }),
+      (error) => {
+        logger.error("Error exchanging Vercel OAuth code", { error });
+        return toVercelApiError(error);
+      }
+    ).map((data): TokenResponse => ({
+      accessToken: data.access_token,
+      tokenType: data.token_type,
+      teamId: data.team_id,
+      userId: data.user_id,
+      raw: data as Record<string, unknown>,
+    }));
+  }
+
+  static getVercelClient(
+    integration: OrganizationIntegration & { tokenReference: SecretReference }
+  ): ResultAsync<Vercel, VercelApiError> {
+    return ResultAsync.fromPromise(
+      (async () => {
+        const secretStore = getSecretStore(integration.tokenReference.provider);
+        const secret = await secretStore.getSecret(
+          VercelSecretSchema,
+          integration.tokenReference.key
+        );
+        if (!secret) {
+          throw new Error("Failed to get Vercel access token");
+        }
+        return new Vercel({ bearerToken: secret.accessToken });
+      })(),
+      (error) => toVercelApiError(error)
+    );
+  }
+
+  static getTeamSlug(
+    client: Vercel,
+    teamId: string | null
+  ): ResultAsync<string, VercelApiError> {
+    if (teamId) {
+      return wrapVercelCallWithRecovery(
+        client.teams.getTeam({ teamId }),
+        VercelSchemas.getTeam,
+        "Failed to fetch Vercel team",
+        { teamId },
+        toVercelApiError
+      ).map((response) => response.slug);
+    }
+
+    return wrapVercelCallWithRecovery(
+      client.user.getAuthUser(),
+      VercelSchemas.getAuthUser,
+      "Failed to fetch Vercel user",
+      {},
+      toVercelApiError
+    ).map((response) => response?.user.username ?? "unknown");
+  }
+
+  static validateVercelToken(
+    integration: OrganizationIntegration & { tokenReference: SecretReference }
+  ): ResultAsync<{ isValid: boolean }, VercelApiError> {
+    return this.getVercelClient(integration)
+      .andThen((client) =>
+        callVercelWithRecovery(
+          client.user.getAuthUser(),
+          VercelSchemas.getAuthUser,
+          { context: "validateVercelToken" }
+        ).mapErr(toVercelApiError)
+      )
+      .map(() => ({ isValid: true }))
+      .orElse((error) =>
+        error.authInvalid
+          ? okAsync({ isValid: false })
+          : errAsync(error)
+      );
+  }
+
+  static async getTeamIdFromIntegration(
+    integration: OrganizationIntegration & { tokenReference: SecretReference }
+  ): Promise<string | null> {
+    const secretStore = getSecretStore(integration.tokenReference.provider);
+
+    const secret = await secretStore.getSecret(
+      VercelSecretSchema,
+      integration.tokenReference.key
+    );
+
+    if (!secret) {
+      return null;
+    }
+
+    return secret.teamId ?? null;
+  }
+
+  static getVercelIntegrationConfiguration(
+    accessToken: string,
+    configurationId: string,
+    teamId?: string | null
+  ): ResultAsync<{
+    id: string;
+    teamId: string | null;
+    projects: string[];
+  }, VercelApiError> {
+    return ResultAsync.fromPromise(
+      fetch(
+        `https://api.vercel.com/v1/integrations/configuration/${configurationId}${teamId ? `?teamId=${teamId}` : ""}`,
+        {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/json",
+          },
+        }
+      ).then(async (response) => {
+        if (!response.ok) {
+          const errorText = await response.text();
+          logger.error("Failed to fetch Vercel integration configuration", {
+            status: response.status,
+            error: errorText,
+            configurationId,
+            teamId,
+          });
+          throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        return response.json() as Promise<{
+          id: string;
+          teamId?: string | null;
+          projects?: string[];
+          [key: string]: any;
+        }>;
+      }),
+      (error) => {
+        logger.error("Error fetching Vercel integration configuration", {
+          configurationId,
+          teamId,
+          error,
+        });
+        return toVercelApiError(error);
+      }
+    ).map((data) => ({
+      id: data.id,
+      teamId: data.teamId ?? null,
+      projects: data.projects || [],
+    }));
+  }
+
+  static getVercelCustomEnvironments(
+    client: Vercel,
+    projectId: string,
+    teamId?: string | null
+  ): ResultAsync<VercelCustomEnvironment[], VercelApiError> {
+    return wrapVercelCallWithRecovery(
+      client.environment.getV9ProjectsIdOrNameCustomEnvironments({
+        idOrName: projectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.getCustomEnvironments,
+      "Failed to fetch Vercel custom environments",
+      { projectId, teamId },
+      toVercelApiError
+    ).map((response) => (response.environments || []).map(toVercelCustomEnvironment));
+  }
+
+  static getVercelEnvironmentVariables(
+    client: Vercel,
+    projectId: string,
+    teamId?: string | null,
+  ): ResultAsync<VercelEnvironmentVariable[], VercelApiError> {
+    return wrapVercelCallWithRecovery(
+      client.projects.filterProjectEnvs({
+        idOrName: projectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.filterProjectEnvs,
+      "Failed to fetch Vercel environment variables",
+      { projectId, teamId },
+      toVercelApiError
+    ).map((response) => {
+      // Warn if response is paginated (more data exists that we're not fetching)
+      if (
+        "pagination" in response &&
+        response.pagination &&
+        "next" in response.pagination &&
+        response.pagination.next !== null
+      ) {
+        logger.warn(
+          "Vercel filterProjectEnvs returned paginated response - some env vars may be missing",
+          { projectId, count: response.pagination.count }
+        );
+      }
+      return extractVercelEnvs(response).map(toVercelEnvironmentVariable);
+    });
+  }
+
+  static getVercelEnvironmentVariableValues(
+    client: Vercel,
+    projectId: string,
+    teamId?: string | null,
+    target?: string,
+    /** If provided, only include keys that pass this filter */
+    shouldIncludeKey?: (key: string) => boolean
+  ): ResultAsync<VercelEnvironmentVariableValue[], VercelApiError> {
+    return wrapVercelCallWithRecovery(
+      client.projects.filterProjectEnvs({
+        idOrName: projectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.filterProjectEnvs,
+      "Failed to fetch Vercel environment variable values",
+      { projectId, teamId, target },
+      toVercelApiError
+    ).andThen((response) => {
+      // Apply all filters BEFORE decryption to avoid unnecessary API calls
+      const filteredEnvs = extractVercelEnvs(response).filter((env) => {
+        if (target && !normalizeTarget(env.target).includes(target)) return false;
+        if (shouldIncludeKey && !shouldIncludeKey(env.key)) return false;
+        if (isVercelSecretType(env.type)) return false;
+        return true;
+      });
+
+      // Fetch decrypted values for encrypted vars, use list values for others
+      const concurrencyLimit = pLimit(5);
+      return ResultAsync.fromPromise(
+        Promise.all(
+          filteredEnvs.map((env) =>
+            concurrencyLimit(() => this.#resolveEnvVarValue(client, projectId, teamId, env))
+          )
+        ),
+        (error) => toVercelApiError(error)
+      ).map((results) => results.filter((v): v is VercelEnvironmentVariableValue => v !== null));
+    });
+  }
+
+  static async #resolveEnvVarValue(
+    client: Vercel,
+    projectId: string,
+    teamId: string | null | undefined,
+    env: ResponseBodyEnvs
+  ): Promise<VercelEnvironmentVariableValue | null> {
+    // Non-encrypted vars: use value from list response if present
+    if (env.type !== "encrypted" || !env.id) {
+      if (env.value === undefined || env.value === null) return null;
+      return toVercelEnvironmentVariableValue(env);
+    }
+
+    // Encrypted vars: fetch decrypted value via individual endpoint
+    // (list endpoint's decrypt param is deprecated)
+    const result = await callVercelWithRecovery(
+      client.projects.getProjectEnv({
+        idOrName: projectId,
+        id: env.id,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.getProjectEnv,
+      { context: "resolveEnvVarValue" }
+    );
+
+    if (result.isErr()) {
+      logger.warn("Failed to decrypt Vercel env var", {
+        projectId,
+        envVarKey: env.key,
+        error: result.error instanceof Error ? result.error.message : String(result.error),
+      });
+      return null;
+    }
+
+    // API returns union: ResponseBody1 has no value, ResponseBody2/3 have value
+    const decryptedValue = (result.value as { value?: string }).value;
+    if (typeof decryptedValue !== "string") return null;
+
+    return {
+      key: env.key,
+      value: decryptedValue,
+      target: normalizeTarget(env.target),
+      type: env.type,
+      isSecret: false,
+    };
+  }
+
+  static getVercelSharedEnvironmentVariables(
+    client: Vercel,
+    teamId: string,
+    projectId?: string // Optional: filter by project
+  ): ResultAsync<Array<{
+      id: string;
+      key: string;
+      type: string;
+      isSecret: boolean;
+      target: string[];
+    }>, VercelApiError> {
+    return wrapVercelCallWithRecovery(
+      client.environment.listSharedEnvVariable({
+        teamId,
+        ...(projectId && { projectId }),
+      }),
+      VercelSchemas.listSharedEnvVariable,
+      "Failed to fetch Vercel shared environment variables",
+      { teamId, projectId },
+      toVercelApiError
+    ).map((response) => {
+      const envVars = response.data || [];
+      return envVars
+        .filter((env): env is typeof env & { id: string; key: string } =>
+          typeof env.id === "string" && typeof env.key === "string"
+        )
+        .map((env) => {
+          const type = env.type || "plain";
+          return {
+            id: env.id,
+            key: env.key,
+            type,
+            isSecret: isVercelSecretType(type),
+            target: normalizeTarget(env.target),
+          };
+        });
+    });
+  }
+
+  static getVercelSharedEnvironmentVariableValues(
+    client: Vercel,
+    teamId: string,
+    projectId?: string // Optional: filter by project
+  ): ResultAsync<
+    Array<{
+      key: string;
+      value: string;
+      target: string[];
+      type: string;
+      isSecret: boolean;
+      applyToAllCustomEnvironments?: boolean;
+    }>,
+    VercelApiError
+  > {
+    return wrapVercelCallWithRecovery(
+      client.environment.listSharedEnvVariable({
+        teamId,
+        ...(projectId && { projectId }),
+      }),
+      VercelSchemas.listSharedEnvVariable,
+      "Failed to fetch Vercel shared environment variable values",
+      { teamId, projectId },
+      toVercelApiError
+    ).andThen((listResponse) => {
+      const envVars = listResponse.data || [];
+      if (envVars.length === 0) {
+        return okAsync([]);
+      }
+
+      const concurrencyLimit = pLimit(5);
+      return ResultAsync.fromPromise(
+        Promise.all(
+          envVars.map((env) =>
+            concurrencyLimit(async () => {
+              if (!env.id || !env.key) return null;
+
+              const envId = env.id;
+              const envKey = env.key;
+              const type = env.type || "plain";
+              const isSecret = isVercelSecretType(type);
+
+              if (isSecret) return null;
+
+              const listValue = (env as any).value as string | undefined;
+              const applyToAllCustomEnvs = (env as any).applyToAllCustomEnvironments as boolean | undefined;
+
+              if (listValue) {
+                return {
+                  key: envKey,
+                  value: listValue,
+                  target: normalizeTarget(env.target),
+                  type,
+                  isSecret,
+                  applyToAllCustomEnvironments: applyToAllCustomEnvs,
+                };
+              }
+
+              // Try to get the decrypted value for this shared env var
+              const getResult = await callVercelWithRecovery(
+                client.environment.getSharedEnvVar({
+                  id: envId,
+                  teamId,
+                }),
+                VercelSchemas.getSharedEnvVar,
+                { context: "getSharedEnvVar" }
+              );
+
+              if (getResult.isOk()) {
+                if (!getResult.value.value) return null;
+                return {
+                  key: envKey,
+                  value: getResult.value.value,
+                  target: normalizeTarget(env.target),
+                  type,
+                  isSecret,
+                  applyToAllCustomEnvironments: applyToAllCustomEnvs,
+                };
+              }
+
+              logger.warn("Failed to get decrypted value for shared env var", {
+                teamId,
+                projectId,
+                envId,
+                envKey,
+                error: getResult.error instanceof Error ? getResult.error.message : String(getResult.error),
+              });
+              return null;
+            })
+          )
+        ),
+        (error) => {
+          logger.error("Failed to process shared environment variable values", {
+            teamId,
+            projectId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          return toVercelApiError(error);
+        }
+      ).map((results) => results.filter((r): r is NonNullable<typeof r> => r !== null));
+    });
+  }
+
+  static getVercelProjects(
+    client: Vercel,
+    teamId?: string | null
+  ): ResultAsync<VercelProject[], VercelApiError> {
+    return ResultAsync.fromPromise(
+      (async () => {
+        const allProjects: VercelProject[] = [];
+        let from: string | undefined;
+
+        do {
+          const response = await callVercelWithRecovery(
+            client.projects.getProjects({
+              ...(teamId && { teamId }),
+              limit: "100",
+              ...(from && { from }),
+            }),
+            VercelSchemas.getProjects,
+            { context: "getVercelProjects" }
+          ).match(
+            (val) => val,
+            (err) => { throw err; }
+          );
+
+          const projects = Array.isArray(response)
+            ? response
+            : "projects" in response
+              ? response.projects
+              : [];
+          allProjects.push(...projects.map(({ id, name }): VercelProject => ({ id, name })));
+
+          // Get pagination token for next page
+          const pagination =
+            !Array.isArray(response) && "pagination" in response
+              ? response.pagination
+              : undefined;
+          from =
+            pagination && "next" in pagination && pagination.next !== null
+              ? String(pagination.next)
+              : undefined;
+        } while (from);
+
+        return allProjects;
+      })(),
+      (error) => {
+        logger.error("Failed to fetch Vercel projects", { teamId, error });
+        return toVercelApiError(error);
+      }
+    );
+  }
+
+  static async updateVercelOrgIntegrationToken(params: {
+    integrationId: string;
+    accessToken: string;
+    tokenType?: string;
+    teamId: string | null;
+    userId?: string;
+    installationId?: string;
+    raw?: Record<string, any>;
+  }): Promise<void> {
+    await $transaction(prisma, async (tx) => {
+      const integration = await tx.organizationIntegration.findUnique({
+        where: { id: params.integrationId },
+        include: { tokenReference: true },
+      });
+
+      if (!integration) {
+        throw new Error("Vercel integration not found");
+      }
+
+      const secretStore = getSecretStore(integration.tokenReference.provider, {
+        prismaClient: tx,
+      });
+
+      const secretValue: VercelSecret = {
+        accessToken: params.accessToken,
+        tokenType: params.tokenType,
+        teamId: params.teamId,
+        userId: params.userId,
+        installationId: params.installationId,
+        raw: params.raw,
+      };
+
+      await secretStore.setSecret(integration.tokenReference.key, secretValue);
+
+      await tx.organizationIntegration.update({
+        where: { id: params.integrationId },
+        data: {
+          integrationData: {
+            teamId: params.teamId,
+            userId: params.userId,
+            installationId: params.installationId,
+          } as any,
+        },
+      });
+    });
+  }
+
+  static async createVercelOrgIntegration(params: {
+    accessToken: string;
+    tokenType?: string;
+    teamId: string | null;
+    userId?: string;
+    installationId?: string;
+    organization: Pick<Organization, "id">;
+    raw?: Record<string, any>;
+    origin: 'marketplace' | 'dashboard';
+  }): Promise<OrganizationIntegration> {
+    const result = await $transaction(prisma, async (tx) => {
+      const secretStore = getSecretStore("DATABASE", {
+        prismaClient: tx,
+      });
+
+      const integrationFriendlyId = generateFriendlyId("org_integration");
+
+      const secretValue: VercelSecret = {
+        accessToken: params.accessToken,
+        tokenType: params.tokenType,
+        teamId: params.teamId,
+        userId: params.userId,
+        installationId: params.installationId,
+        raw: params.raw,
+      };
+
+      await secretStore.setSecret(integrationFriendlyId, secretValue);
+
+      const reference = await tx.secretReference.create({
+        data: {
+          provider: "DATABASE",
+          key: integrationFriendlyId,
+        },
+      });
+
+      return await tx.organizationIntegration.create({
+        data: {
+          friendlyId: integrationFriendlyId,
+          organizationId: params.organization.id,
+          service: "VERCEL",
+          externalOrganizationId: params.teamId,
+          tokenReferenceId: reference.id,
+          integrationData: {
+            teamId: params.teamId,
+            userId: params.userId,
+            installationId: params.installationId,
+            origin: params.origin,
+          } as any,
+        },
+      });
+    });
+
+    if (!result) {
+      throw new Error("Failed to create Vercel organization integration");
+    }
+
+    return result;
+  }
+
+  static async findVercelOrgIntegrationByTeamId(
+    organizationId: string,
+    teamId: string | null
+  ): Promise<(OrganizationIntegration & { tokenReference: SecretReference }) | null> {
+    return prisma.organizationIntegration.findFirst({
+      where: {
+        organizationId,
+        service: "VERCEL",
+        externalOrganizationId: teamId,
+        deletedAt: null,
+      },
+      include: {
+        tokenReference: true,
+      },
+    });
+  }
+
+  static async findVercelOrgIntegrationForProject(
+    projectId: string
+  ): Promise<(OrganizationIntegration & { tokenReference: SecretReference }) | null> {
+    const projectIntegration = await prisma.organizationProjectIntegration.findFirst({
+      where: {
+        projectId,
+        deletedAt: null,
+        organizationIntegration: {
+          service: "VERCEL",
+          deletedAt: null,
+        },
+      },
+      include: {
+        organizationIntegration: {
+          include: {
+            tokenReference: true,
+          },
+        },
+      },
+    });
+
+    return projectIntegration?.organizationIntegration ?? null;
+  }
+
+  static async findVercelOrgIntegrationByOrganization(
+    organizationId: string
+  ): Promise<(OrganizationIntegration & { tokenReference: SecretReference }) | null> {
+    return prisma.organizationIntegration.findFirst({
+      where: {
+        organizationId,
+        service: "VERCEL",
+        deletedAt: null,
+      },
+      include: {
+        tokenReference: true,
+      },
+    });
+  }
+
+  static syncApiKeysToVercel(params: {
+    projectId: string;
+    vercelProjectId: string;
+    teamId: string | null;
+    vercelStagingEnvironment?: { environmentId: string; displayName: string } | null;
+    orgIntegration: OrganizationIntegration & { tokenReference: SecretReference };
+  }): ResultAsync<{ created: number; updated: number; errors: string[] }, VercelApiError> {
+    return this.getVercelClient(params.orgIntegration).andThen((client) =>
+      ResultAsync.fromPromise(
+        (async () => {
+          // Get all environments for the project (exclude DEVELOPMENT — we don't push keys to Vercel's development target)
+          const environments = await prisma.runtimeEnvironment.findMany({
+            where: {
+              projectId: params.projectId,
+              type: {
+                in: ["PRODUCTION", "STAGING", "PREVIEW"],
+              },
+            },
+            select: {
+              id: true,
+              type: true,
+              apiKey: true,
+            },
+          });
+
+          // Build the list of env vars to sync
+          const envVarsToSync: Array<{
+            key: string;
+            value: string;
+            target: string[];
+            type: "sensitive" | "encrypted" | "plain";
+            environmentType: string;
+          }> = [];
+
+          for (const runtimeEnv of environments) {
+            const vercelTarget = envTypeToVercelTarget(
+              runtimeEnv.type as TriggerEnvironmentType,
+              params.vercelStagingEnvironment?.environmentId
+            );
+
+            if (!vercelTarget) {
+              continue;
+            }
+
+            envVarsToSync.push({
+              key: "TRIGGER_SECRET_KEY",
+              value: runtimeEnv.apiKey,
+              target: vercelTarget,
+              type: "encrypted",
+              environmentType: runtimeEnv.type,
+            });
+          }
+
+          if (envVarsToSync.length === 0) {
+            return { created: 0, updated: 0, errors: [] as string[] };
+          }
+
+          await this.removeAllVercelEnvVarsByKey({
+            client,
+            vercelProjectId: params.vercelProjectId,
+            teamId: params.teamId,
+            key: "TRIGGER_SECRET_KEY",
+          });
+
+          const result = await this.batchUpsertVercelEnvVars({
+            client,
+            vercelProjectId: params.vercelProjectId,
+            teamId: params.teamId,
+            envVars: envVarsToSync,
+          });
+
+          logger.info("Synced API keys to Vercel", {
+            projectId: params.projectId,
+            vercelProjectId: params.vercelProjectId,
+            syncedCount: result.created + result.updated,
+            created: result.created,
+            updated: result.updated,
+            errors: result.errors,
+          });
+
+          return result;
+        })(),
+        (error) => {
+          logger.error("Failed to sync API keys to Vercel", {
+            projectId: params.projectId,
+            vercelProjectId: params.vercelProjectId,
+            error,
+          });
+          return toVercelApiError(error);
+        }
+      )
+    );
+  }
+
+  static syncSingleApiKeyToVercel(params: {
+    projectId: string;
+    environmentType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT";
+    apiKey: string;
+  }): ResultAsync<void, VercelApiError> {
+    return ResultAsync.fromPromise(
+      (async () => {
+        const projectIntegration = await prisma.organizationProjectIntegration.findFirst({
+          where: {
+            projectId: params.projectId,
+            deletedAt: null,
+            organizationIntegration: {
+              service: "VERCEL",
+              deletedAt: null,
+            },
+          },
+          include: {
+            organizationIntegration: {
+              include: {
+                tokenReference: true,
+              },
+            },
+          },
+        });
+
+        if (!projectIntegration) {
+          return; // No integration, nothing to sync
+        }
+
+        const orgIntegration = projectIntegration.organizationIntegration;
+        const clientResult = await this.getVercelClient(orgIntegration);
+        if (clientResult.isErr()) throw clientResult.error;
+        const client = clientResult.value;
+
+        const teamId = await this.getTeamIdFromIntegration(orgIntegration);
+
+        const integrationData = projectIntegration.integrationData as any;
+        const vercelStagingEnvironment = integrationData?.config?.vercelStagingEnvironment;
+
+        const vercelTarget = envTypeToVercelTarget(
+          params.environmentType,
+          vercelStagingEnvironment?.environmentId
+        );
+
+        if (!vercelTarget) {
+          return;
+        }
+
+        await this.upsertVercelEnvVar({
+          client,
+          vercelProjectId: projectIntegration.externalEntityId,
+          teamId,
+          key: "TRIGGER_SECRET_KEY",
+          value: params.apiKey,
+          target: vercelTarget,
+          type: "encrypted",
+        });
+
+        logger.info("Synced regenerated API key to Vercel", {
+          projectId: params.projectId,
+          vercelProjectId: projectIntegration.externalEntityId,
+          environmentType: params.environmentType,
+          target: vercelTarget,
+        });
+      })(),
+      (error) => {
+        logger.error("Failed to sync API key to Vercel", {
+          projectId: params.projectId,
+          environmentType: params.environmentType,
+          error,
+        });
+        return toVercelApiError(error);
+      }
+    );
+  }
+
+  static upsertEnvVarForCustomEnvironment(params: {
+    orgIntegration: OrganizationIntegration & { tokenReference: SecretReference };
+    vercelProjectId: string;
+    teamId: string | null;
+    key: string;
+    value: string;
+    customEnvironmentId: string;
+    type: "sensitive" | "encrypted" | "plain";
+  }): ResultAsync<void, VercelApiError> {
+    return this.getVercelClient(params.orgIntegration).andThen((client) =>
+      ResultAsync.fromPromise(
+        (async () => {
+          const { vercelProjectId, teamId, key, value, customEnvironmentId, type } = params;
+
+          const existingEnvs = await callVercelWithRecovery(
+            client.projects.filterProjectEnvs({
+              idOrName: vercelProjectId,
+              ...(teamId && { teamId }),
+            }),
+            VercelSchemas.filterProjectEnvs,
+            { context: "upsertEnvVarForCustomEnvironment" }
+          ).match(
+            (val) => val,
+            (err) => { throw err; }
+          );
+
+          const envs = extractVercelEnvs(existingEnvs);
+
+          const existingEnv = envs.find((env) => {
+            if (env.key !== key) return false;
+            return (env as any).customEnvironmentIds?.includes(customEnvironmentId);
+          });
+
+          if (existingEnv && existingEnv.id) {
+            await client.projects.editProjectEnv({
+              idOrName: vercelProjectId,
+              id: existingEnv.id,
+              ...(teamId && { teamId }),
+              requestBody: {
+                value,
+                type,
+              },
+            });
+          } else {
+            await client.projects.createProjectEnv({
+              idOrName: vercelProjectId,
+              ...(teamId && { teamId }),
+              requestBody: {
+                key,
+                value,
+                type,
+                customEnvironmentIds: [customEnvironmentId],
+              } as any,
+            });
+          }
+        })(),
+        (error) => toVercelApiError(error)
+      )
+    );
+  }
+
+  static removeEnvVarForCustomEnvironment(params: {
+    orgIntegration: OrganizationIntegration & { tokenReference: SecretReference };
+    vercelProjectId: string;
+    teamId: string | null;
+    key: string;
+    customEnvironmentId: string;
+  }): ResultAsync<void, VercelApiError> {
+    return this.getVercelClient(params.orgIntegration).andThen((client) =>
+      ResultAsync.fromPromise(
+        (async () => {
+          const { vercelProjectId, teamId, key, customEnvironmentId } = params;
+
+          const existingEnvs = await callVercelWithRecovery(
+            client.projects.filterProjectEnvs({
+              idOrName: vercelProjectId,
+              ...(teamId && { teamId }),
+            }),
+            VercelSchemas.filterProjectEnvs,
+            { context: "removeEnvVarForCustomEnvironment" }
+          ).match(
+            (val) => val,
+            (err) => { throw err; }
+          );
+
+          const envs = extractVercelEnvs(existingEnvs);
+
+          const existingEnv = envs.find((env) => {
+            if (env.key !== key) return false;
+            return (env as any).customEnvironmentIds?.includes(customEnvironmentId);
+          });
+
+          if (existingEnv && existingEnv.id) {
+            await client.projects.batchRemoveProjectEnv({
+              idOrName: vercelProjectId,
+              ...(teamId && { teamId }),
+              requestBody: { ids: [existingEnv.id] },
+            });
+          }
+        })(),
+        (error) => toVercelApiError(error)
+      )
+    );
+  }
+
+  static pullEnvVarsFromVercel(params: {
+    projectId: string;
+    vercelProjectId: string;
+    teamId: string | null;
+    vercelStagingEnvironment?: { environmentId: string; displayName: string } | null;
+    syncEnvVarsMapping: SyncEnvVarsMapping;
+    orgIntegration: OrganizationIntegration & { tokenReference: SecretReference };
+  }): ResultAsync<{ syncedCount: number; errors: string[] }, VercelApiError> {
+    logger.info("pullEnvVarsFromVercel: Starting", {
+      projectId: params.projectId,
+      vercelProjectId: params.vercelProjectId,
+      teamId: params.teamId,
+      vercelStagingEnvironment: params.vercelStagingEnvironment,
+      syncEnvVarsMappingKeys: Object.keys(params.syncEnvVarsMapping),
+    });
+
+    return this.getVercelClient(params.orgIntegration).andThen((client) =>
+      ResultAsync.fromPromise(
+        (async () => {
+          const errors: string[] = [];
+          let syncedCount = 0;
+
+          // Get all runtime environments for the project
+          const runtimeEnvironments = await prisma.runtimeEnvironment.findMany({
+            where: {
+              projectId: params.projectId,
+              type: {
+                in: ["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"],
+              },
+            },
+            select: {
+              id: true,
+              type: true,
+            },
+          });
+
+          const envMapping: Array<{
+            triggerEnvType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT";
+            vercelTarget: string;
+            runtimeEnvironmentId: string;
+          }> = [];
+
+          for (const runtimeEnv of runtimeEnvironments) {
+            const vercelTarget = envTypeToVercelTarget(
+              runtimeEnv.type as TriggerEnvironmentType,
+              params.vercelStagingEnvironment?.environmentId
+            );
+
+            if (!vercelTarget) {
+              continue;
+            }
+
+            envMapping.push({
+              triggerEnvType: runtimeEnv.type as "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT",
+              vercelTarget: vercelTarget[0],
+              runtimeEnvironmentId: runtimeEnv.id,
+            });
+          }
+
+          if (envMapping.length === 0) {
+            logger.warn("No environments to sync for Vercel integration", {
+              projectId: params.projectId,
+              vercelProjectId: params.vercelProjectId,
+            });
+            return { syncedCount: 0, errors: [] as string[] };
+          }
+
+          const envVarRepository = new EnvironmentVariablesRepository();
+
+          // Fetch shared env vars once (they apply across all targets)
+          let sharedEnvVars: Array<{
+            key: string;
+            value: string;
+            target: string[];
+            type: string;
+            isSecret: boolean;
+            applyToAllCustomEnvironments?: boolean;
+          }> = [];
+
+          if (params.teamId) {
+            const sharedResult = await this.getVercelSharedEnvironmentVariableValues(
+              client,
+              params.teamId,
+              params.vercelProjectId
+            );
+            sharedEnvVars = sharedResult.unwrapOr([]);
+          }
+
+          // Process each environment mapping
+          for (const mapping of envMapping) {
+            const iterResult = await ResultAsync.fromPromise(
+              (async () => {
+                // Build filter to avoid decrypting vars that will be filtered out anyway
+                const excludeKeys = new Set(["TRIGGER_SECRET_KEY", "TRIGGER_VERSION"]);
+                const shouldIncludeKey = (key: string) =>
+                  !excludeKeys.has(key) &&
+                  shouldSyncEnvVar(params.syncEnvVarsMapping, key, mapping.triggerEnvType as TriggerEnvironmentType);
+
+                const envVarsResult = await this.getVercelEnvironmentVariableValues(
+                  client,
+                  params.vercelProjectId,
+                  params.teamId,
+                  mapping.vercelTarget,
+                  shouldIncludeKey
+                );
+
+                if (envVarsResult.isErr()) {
+                  logger.warn("pullEnvVarsFromVercel: Failed to get env vars", {
+                    triggerEnvType: mapping.triggerEnvType,
+                    vercelTarget: mapping.vercelTarget,
+                    error: envVarsResult.error.message,
+                  });
+                  errors.push(`Failed to get env vars for ${mapping.triggerEnvType}: ${envVarsResult.error.message}`);
+                  return;
+                }
+
+                const projectEnvVars = envVarsResult.value;
+                const standardTargets = ["production", "preview", "development"];
+                const isCustomEnvironment = !standardTargets.includes(mapping.vercelTarget);
+
+                const filteredSharedEnvVars = sharedEnvVars.filter((envVar) => {
+                  const matchesTarget = envVar.target.includes(mapping.vercelTarget);
+                  const matchesCustomEnv = isCustomEnvironment && envVar.applyToAllCustomEnvironments === true;
+                  return matchesTarget || matchesCustomEnv;
+                });
+
+                const projectEnvVarKeys = new Set(projectEnvVars.map((v) => v.key));
+                const sharedEnvVarsToAdd = filteredSharedEnvVars.filter((v) => !projectEnvVarKeys.has(v.key));
+                const mergedEnvVars = [
+                  ...projectEnvVars,
+                  ...sharedEnvVarsToAdd,
+                ];
+
+                if (mergedEnvVars.length === 0) {
+                  return;
+                }
+
+                const varsToSync = mergedEnvVars.filter((envVar) => {
+                  if (envVar.isSecret) {
+                    return false;
+                  }
+                  if (envVar.key === "TRIGGER_SECRET_KEY" || envVar.key === "TRIGGER_VERSION") {
+                    return false;
+                  }
+                  return shouldSyncEnvVar(
+                    params.syncEnvVarsMapping,
+                    envVar.key,
+                    mapping.triggerEnvType as TriggerEnvironmentType
+                  );
+                });
+
+                if (varsToSync.length === 0) {
+                  return;
+                }
+
+                const existingSecretKeys = new Set<string>();
+                const existingValues = new Map<string, string>();
+
+                const existingVarValues = await prisma.environmentVariableValue.findMany({
+                  where: {
+                    environmentId: mapping.runtimeEnvironmentId,
+                    variable: {
+                      projectId: params.projectId,
+                      key: {
+                        in: varsToSync.map((v) => v.key),
+                      },
+                    },
+                  },
+                  select: {
+                    isSecret: true,
+                    valueReference: {
+                      select: {
+                        key: true,
+                      },
+                    },
+                    variable: {
+                      select: {
+                        key: true,
+                      },
+                    },
+                  },
+                });
+
+                if (existingVarValues.length > 0) {
+                  const secretStore = getSecretStore("DATABASE", { prismaClient: prisma });
+                  const SecretValue = z.object({ secret: z.string() });
+
+                  for (const varValue of existingVarValues) {
+                    if (varValue.isSecret) {
+                      existingSecretKeys.add(varValue.variable.key);
+                    }
+
+                    if (varValue.valueReference?.key) {
+                      const existingSecret = await ResultAsync.fromPromise(
+                        secretStore.getSecret(SecretValue, varValue.valueReference.key),
+                        () => null
+                      ).unwrapOr(null);
+                      if (existingSecret) {
+                        existingValues.set(varValue.variable.key, existingSecret.secret);
+                      }
+                    }
+                  }
+                }
+
+                const changedVars = varsToSync.filter((v) => {
+                  const existingValue = existingValues.get(v.key);
+                  return existingValue === undefined || existingValue !== v.value;
+                });
+
+                if (changedVars.length === 0) {
+                  return;
+                }
+
+                const secretVars = changedVars.filter((v) => existingSecretKeys.has(v.key));
+                const nonSecretVars = changedVars.filter((v) => !existingSecretKeys.has(v.key));
+
+                if (nonSecretVars.length > 0) {
+                  const result = await envVarRepository.create(params.projectId, {
+                    override: true,
+                    environmentIds: [mapping.runtimeEnvironmentId],
+                    isSecret: false,
+                    variables: nonSecretVars.map((v) => ({
+                      key: v.key,
+                      value: v.value,
+                    })),
+                    lastUpdatedBy: {
+                      type: "integration",
+                      integration: "vercel",
+                    },
+                  });
+
+                  if (result.success) {
+                    syncedCount += nonSecretVars.length;
+                  } else {
+                    const errorMsg = `Failed to sync env vars for ${mapping.triggerEnvType}: ${result.error}`;
+                    errors.push(errorMsg);
+                    logger.error(errorMsg, {
+                      projectId: params.projectId,
+                      vercelProjectId: params.vercelProjectId,
+                      vercelTarget: mapping.vercelTarget,
+                      error: result.error,
+                      variableErrors: result.variableErrors,
+                      attemptedKeys: nonSecretVars.map((v) => v.key),
+                    });
+                  }
+                }
+
+                if (secretVars.length > 0) {
+                  const result = await envVarRepository.create(params.projectId, {
+                    override: true,
+                    environmentIds: [mapping.runtimeEnvironmentId],
+                    isSecret: true,
+                    variables: secretVars.map((v) => ({
+                      key: v.key,
+                      value: v.value,
+                    })),
+                    lastUpdatedBy: {
+                      type: "integration",
+                      integration: "vercel",
+                    },
+                  });
+
+                  if (result.success) {
+                    syncedCount += secretVars.length;
+                  } else {
+                    const errorMsg = `Failed to sync secret env vars for ${mapping.triggerEnvType}: ${result.error}`;
+                    errors.push(errorMsg);
+                    logger.error(errorMsg, {
+                      projectId: params.projectId,
+                      vercelProjectId: params.vercelProjectId,
+                      vercelTarget: mapping.vercelTarget,
+                      error: result.error,
+                      variableErrors: result.variableErrors,
+                      attemptedKeys: secretVars.map((v) => v.key),
+                    });
+                  }
+                }
+              })(),
+              (error) => error
+            );
+
+            if (iterResult.isErr()) {
+              const errorMsg = `Failed to process env vars for ${mapping.triggerEnvType}: ${iterResult.error instanceof Error ? iterResult.error.message : "Unknown error"}`;
+              errors.push(errorMsg);
+              logger.error(errorMsg, {
+                projectId: params.projectId,
+                vercelProjectId: params.vercelProjectId,
+                vercelTarget: mapping.vercelTarget,
+                error: iterResult.error,
+              });
+            }
+          }
+
+          return { syncedCount, errors };
+        })(),
+        (error) => {
+          logger.error("Failed to pull env vars from Vercel", {
+            projectId: params.projectId,
+            vercelProjectId: params.vercelProjectId,
+            error,
+          });
+          return toVercelApiError(error);
+        }
+      )
+    );
+  }
+
+  static async batchUpsertVercelEnvVars(params: {
+    client: Vercel;
+    vercelProjectId: string;
+    teamId: string | null;
+    envVars: Array<{
+      key: string;
+      value: string;
+      target: string[];
+      type: "sensitive" | "encrypted" | "plain";
+      environmentType?: string; // For logging purposes
+    }>;
+  }): Promise<{ created: number; updated: number; errors: string[] }> {
+    const { client, vercelProjectId, teamId, envVars } = params;
+    const errors: string[] = [];
+    let created = 0;
+    let updated = 0;
+
+    if (envVars.length === 0) {
+      return { created: 0, updated: 0, errors: [] };
+    }
+
+    const existingEnvs = await callVercelWithRecovery(
+      client.projects.filterProjectEnvs({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.filterProjectEnvs,
+      { context: "batchUpsertVercelEnvVars" }
+    ).match(
+      (val) => val,
+      (err) => { throw err; }
+    );
+
+    const existingEnvsList = extractVercelEnvs(existingEnvs);
+
+    const toCreate: Array<{
+      key: string;
+      value: string;
+      target: string[];
+      type: "sensitive" | "encrypted" | "plain";
+    }> = [];
+
+    const toUpdate: Array<{
+      id: string;
+      key: string;
+      value: string;
+      target: string[];
+      type: "sensitive" | "encrypted" | "plain";
+      environmentType?: string;
+    }> = [];
+
+    for (const envVar of envVars) {
+      const existingEnv = existingEnvsList.find((existing) => {
+        if (existing.key !== envVar.key) {
+          return false;
+        }
+        const envTargets = normalizeTarget(existing.target);
+        return (
+          envVar.target.length === envTargets.length &&
+          envVar.target.every((t) => envTargets.includes(t))
+        );
+      });
+
+      if (existingEnv && existingEnv.id) {
+        toUpdate.push({
+          id: existingEnv.id,
+          key: envVar.key,
+          value: envVar.value,
+          target: envVar.target,
+          type: envVar.type,
+          environmentType: envVar.environmentType,
+        });
+      } else {
+        toCreate.push({
+          key: envVar.key,
+          value: envVar.value,
+          target: envVar.target,
+          type: envVar.type,
+        });
+      }
+    }
+
+    if (toCreate.length > 0) {
+      const createResult = await ResultAsync.fromPromise(
+        client.projects.createProjectEnv({
+          idOrName: vercelProjectId,
+          ...(teamId && { teamId }),
+          requestBody: toCreate.map((item) => ({
+            key: item.key,
+            value: item.value,
+            target: item.target as any,
+            type: item.type,
+          })) as any,
+        }),
+        (error) => error
+      );
+
+      if (createResult.isOk()) {
+        created = toCreate.length;
+      } else {
+        const errorMsg = `Failed to batch create env vars: ${createResult.error instanceof Error ? createResult.error.message : "Unknown error"}`;
+        errors.push(errorMsg);
+        logger.error(errorMsg, {
+          vercelProjectId,
+          teamId,
+          count: toCreate.length,
+          error: createResult.error,
+        });
+      }
+    }
+
+    // Update existing env vars (Vercel doesn't support batch updates)
+    for (const envVar of toUpdate) {
+      const updateResult = await ResultAsync.fromPromise(
+        client.projects.editProjectEnv({
+          idOrName: vercelProjectId,
+          id: envVar.id,
+          ...(teamId && { teamId }),
+          requestBody: {
+            value: envVar.value,
+            target: envVar.target as any,
+            type: envVar.type,
+          },
+        }),
+        (error) => error
+      );
+
+      if (updateResult.isOk()) {
+        updated++;
+      } else {
+        const errorMsg = `Failed to update ${envVar.environmentType || envVar.key} env var: ${updateResult.error instanceof Error ? updateResult.error.message : "Unknown error"}`;
+        errors.push(errorMsg);
+        logger.error(errorMsg, {
+          vercelProjectId,
+          teamId,
+          envVarId: envVar.id,
+          key: envVar.key,
+          error: updateResult.error,
+        });
+      }
+    }
+
+    return { created, updated, errors };
+  }
+
+  private static async removeAllVercelEnvVarsByKey(params: {
+    client: Vercel;
+    vercelProjectId: string;
+    teamId: string | null;
+    key: string;
+  }): Promise<void> {
+    const { client, vercelProjectId, teamId, key } = params;
+
+    const existingEnvs = await callVercelWithRecovery(
+      client.projects.filterProjectEnvs({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.filterProjectEnvs,
+      { context: "removeAllVercelEnvVarsByKey" }
+    ).match(
+      (val) => val,
+      (err) => { throw err; }
+    );
+
+    const envs = extractVercelEnvs(existingEnvs);
+    const idsToRemove = envs
+      .filter((env) => env.key === key && env.id)
+      .map((env) => env.id!);
+
+    if (idsToRemove.length === 0) {
+      return;
+    }
+
+    await client.projects.batchRemoveProjectEnv({
+      idOrName: vercelProjectId,
+      ...(teamId && { teamId }),
+      requestBody: { ids: idsToRemove },
+    });
+  }
+
+  private static async upsertVercelEnvVar(params: {
+    client: Vercel;
+    vercelProjectId: string;
+    teamId: string | null;
+    key: string;
+    value: string;
+    target: string[];
+    type: "sensitive" | "encrypted" | "plain";
+  }): Promise<void> {
+    const { client, vercelProjectId, teamId, key, value, target, type } = params;
+
+    const existingEnvs = await callVercelWithRecovery(
+      client.projects.filterProjectEnvs({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+      }),
+      VercelSchemas.filterProjectEnvs,
+      { context: "upsertVercelEnvVar" }
+    ).match(
+      (val) => val,
+      (err) => { throw err; }
+    );
+
+    const envs = extractVercelEnvs(existingEnvs);
+
+    // Vercel can have multiple env vars with the same key but different targets
+    const existingEnv = envs.find((existing) => {
+      if (existing.key !== key) {
+        return false;
+      }
+      const envTargets = normalizeTarget(existing.target);
+      return target.length === envTargets.length && target.every((t) => envTargets.includes(t));
+    });
+
+    if (existingEnv && existingEnv.id) {
+      await client.projects.editProjectEnv({
+        idOrName: vercelProjectId,
+        id: existingEnv.id,
+        ...(teamId && { teamId }),
+        requestBody: {
+          value,
+          target: target as any,
+          type,
+        },
+      });
+    } else {
+      await client.projects.createProjectEnv({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        requestBody: {
+          key,
+          value,
+          target: target as any,
+          type,
+        },
+      });
+    }
+  }
+
+  static getAutoAssignCustomDomains(
+    client: Vercel,
+    vercelProjectId: string,
+    teamId?: string | null
+  ): ResultAsync<boolean | null, VercelApiError> {
+    // Vercel SDK lacks a getProject method — updateProject with empty body reads without modifying.
+    return wrapVercelCallWithRecovery(
+      client.projects.updateProject({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        requestBody: {},
+      }),
+      VercelSchemas.updateProject,
+      "Failed to get Vercel project autoAssignCustomDomains",
+      { vercelProjectId, teamId },
+      toVercelApiError
+    ).map((project) => project.autoAssignCustomDomains ?? null);
+  }
+
+  /** Disable autoAssignCustomDomains — required for atomic deployments. */
+  static disableAutoAssignCustomDomains(
+    client: Vercel,
+    vercelProjectId: string,
+    teamId?: string | null
+  ): ResultAsync<void, VercelApiError> {
+    return wrapVercelCallWithRecovery(
+      client.projects.updateProject({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        requestBody: {
+          autoAssignCustomDomains: false,
+        },
+      }),
+      VercelSchemas.updateProject,
+      "Failed to disable autoAssignCustomDomains",
+      { vercelProjectId, teamId },
+      toVercelApiError
+    ).map(() => undefined);
+  }
+
+  static uninstallVercelIntegration(
+    integration: OrganizationIntegration & { tokenReference: SecretReference }
+  ): ResultAsync<{ authInvalid: boolean }, VercelApiError> {
+    return this.getVercelClient(integration).andThen((client) =>
+      ResultAsync.fromPromise(
+        (async () => {
+          const secret = await getSecretStore(integration.tokenReference.provider).getSecret(
+            VercelSecretSchema,
+            integration.tokenReference.key
+          );
+
+          if (!secret?.installationId) {
+            throw new Error("Installation ID not found in Vercel integration");
+          }
+
+          return secret.installationId;
+        })(),
+        toVercelApiError
+      ).andThen((installationId) =>
+        ResultAsync.fromPromise(
+          client.integrations.deleteConfiguration({
+            id: installationId,
+          }),
+          (error) => error
+        )
+          .map(() => ({ authInvalid: false }))
+          .orElse((error) => {
+            const isAuthError = isVercelAuthError(error);
+            logger.error("Failed to uninstall Vercel integration", {
+              installationId,
+              error: error instanceof Error ? error.message : "Unknown error",
+              isAuthError,
+            });
+            // Auth errors (401/403): still clean up on our side, return flag for caller
+            if (isAuthError) {
+              return okAsync({ authInvalid: true });
+            }
+            return errAsync(toVercelApiError(error));
+          })
+      )
+    );
+  }
+}
diff --git a/apps/webapp/app/models/vercelSdkRecovery.server.ts b/apps/webapp/app/models/vercelSdkRecovery.server.ts
new file mode 100644
index 00000000000..2fc2fb32b6a
--- /dev/null
+++ b/apps/webapp/app/models/vercelSdkRecovery.server.ts
@@ -0,0 +1,195 @@
+import { z } from "zod";
+import { ResultAsync, okAsync, errAsync } from "neverthrow";
+import { logger } from "~/services/logger.server";
+import type { VercelApiError } from "./vercelIntegration.server";
+
+// ---------------------------------------------------------------------------
+// Recovery utilities for Vercel SDK validation errors
+// ---------------------------------------------------------------------------
+//
+// The Vercel SDK (Speakeasy-generated) validates API responses with strict Zod
+// schemas. When the API returns valid data but a field doesn't match the SDK's
+// type (e.g., `deletedAt: null` vs `number`), a `ResponseValidationError` is
+// thrown — even though the response contains all the data we need.
+//
+// Error hierarchy:
+//   VercelError.body         → raw HTTP body text (HTTP errors — never recover)
+//   ResponseValidationError.rawValue → parsed JSON that failed validation
+//   SDKValidationError.rawValue      → same pattern, different base class
+//
+// Recovery: gate on validation error type → extract rawValue → validate → return.
+// ---------------------------------------------------------------------------
+
+/**
+ * Only attempt recovery for SDK validation errors — not HTTP errors (401/403).
+ *
+ * ResponseValidationError and SDKValidationError both carry `rawValue` with the
+ * parsed JSON that failed schema validation. VercelError (HTTP errors) carries
+ * `body` instead — we must NOT recover from those since the response is an error
+ * payload, not the data we asked for.
+ */
+function isValidationError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  if (!(error instanceof Error)) return false;
+
+  return (
+    error.constructor.name === "ResponseValidationError" ||
+    error.constructor.name === "SDKValidationError" ||
+    "rawValue" in error
+  );
+}
+
+function extractRawValue(error: unknown): unknown | undefined {
+  if (!error || typeof error !== "object") return undefined;
+  if ("rawValue" in error) {
+    return (error as { rawValue: unknown }).rawValue;
+  }
+  return undefined;
+}
+
+/**
+ * Attempt to recover usable data from a Vercel SDK error.
+ *
+ * Returns the validated data on success, or `undefined` if recovery fails.
+ */
+export function recoverFromVercelSdkError<T>(
+  error: unknown,
+  schema: z.ZodType<any>,
+  options?: { context?: string }
+): T | undefined {
+  if (!isValidationError(error)) return undefined;
+
+  const raw = extractRawValue(error);
+  if (raw === undefined) return undefined;
+
+  const result = schema.safeParse(raw);
+  if (!result.success) return undefined;
+
+  logger.warn("Recovered data from Vercel SDK validation error", {
+    context: options?.context,
+    errorMessage: error instanceof Error ? error.message : String(error),
+    errorType: error?.constructor?.name,
+  });
+
+  return result.data;
+}
+
+/**
+ * Wrap a Vercel SDK promise with automatic recovery on validation errors.
+ *
+ * On success: returns the SDK result as-is.
+ * On error: attempts recovery via rawValue + schema validation (validation errors only).
+ */
+export function callVercelWithRecovery<T>(
+  sdkCall: Promise<T>,
+  schema: z.ZodType<any>,
+  options?: { context?: string }
+): ResultAsync<T, unknown> {
+  return ResultAsync.fromPromise(sdkCall, (error) => error).orElse((error) => {
+    const recovered = recoverFromVercelSdkError<T>(error, schema, options);
+    if (recovered !== undefined) {
+      return okAsync(recovered);
+    }
+    return errAsync(error);
+  });
+}
+
+/**
+ * Drop-in replacement for `wrapVercelCall` with SDK error recovery.
+ *
+ * Wraps a Vercel SDK promise in ResultAsync with structured error logging,
+ * attempting to recover from validation errors before treating as failure.
+ */
+export function wrapVercelCallWithRecovery<T>(
+  promise: Promise<T>,
+  schema: z.ZodType<any>,
+  message: string,
+  context: Record<string, unknown>,
+  toError: (error: unknown) => VercelApiError
+): ResultAsync<T, VercelApiError> {
+  return callVercelWithRecovery(promise, schema, { context: message }).mapErr((error) => {
+    const apiError = toError(error);
+    logger.error(message, { ...context, error, authInvalid: apiError.authInvalid });
+    return apiError;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Minimal Zod schemas — validate only the fields we actually use.
+// All use .passthrough() to preserve extra fields from the API response.
+// ---------------------------------------------------------------------------
+
+export const VercelSchemas = {
+  getTeam: z.object({ slug: z.string() }).passthrough(),
+
+  getAuthUser: z
+    .object({ user: z.object({ username: z.string() }).passthrough() })
+    .passthrough(),
+
+  getCustomEnvironments: z
+    .object({
+      environments: z
+        .array(
+          z
+            .object({
+              id: z.string(),
+              slug: z.string(),
+              description: z.string().optional(),
+              branchMatcher: z.unknown().optional(),
+            })
+            .passthrough()
+        )
+        .optional(),
+    })
+    .passthrough(),
+
+  filterProjectEnvs: z
+    .union([
+      z
+        .object({
+          envs: z.array(z.record(z.unknown())),
+          pagination: z.unknown().optional(),
+        })
+        .passthrough(),
+      z.array(z.record(z.unknown())),
+    ])
+    .transform((val) => (Array.isArray(val) ? { envs: val } : val)),
+
+  getProjectEnv: z.object({ key: z.string(), value: z.string().optional() }).passthrough(),
+
+  getProjects: z.union([
+    z.array(z.object({ id: z.string(), name: z.string() }).passthrough()),
+    z
+      .object({
+        projects: z.array(
+          z.object({ id: z.string(), name: z.string() }).passthrough()
+        ),
+        pagination: z.unknown().optional(),
+      })
+      .passthrough(),
+  ]),
+
+  listSharedEnvVariable: z
+    .object({
+      data: z
+        .array(
+          z
+            .object({
+              id: z.string().optional(),
+              key: z.string().optional(),
+              type: z.string().optional(),
+              target: z.unknown().optional(),
+              value: z.string().optional(),
+            })
+            .passthrough()
+        )
+        .optional(),
+    })
+    .passthrough(),
+
+  getSharedEnvVar: z.object({ value: z.string().optional() }).passthrough(),
+
+  updateProject: z
+    .object({ id: z.string(), name: z.string(), autoAssignCustomDomains: z.boolean().optional() })
+    .passthrough(),
+} as const;
diff --git a/apps/webapp/app/presenters/OrganizationsPresenter.server.ts b/apps/webapp/app/presenters/OrganizationsPresenter.server.ts
index 5949aebc5d6..99ced5e3efb 100644
--- a/apps/webapp/app/presenters/OrganizationsPresenter.server.ts
+++ b/apps/webapp/app/presenters/OrganizationsPresenter.server.ts
@@ -1,4 +1,4 @@
-import { RuntimeEnvironment, type PrismaClient } from "@trigger.dev/database";
+import type { RuntimeEnvironment, PrismaClient } from "@trigger.dev/database";
 import { redirect } from "remix-typedjson";
 import { prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
@@ -10,6 +10,9 @@ import {
 } from "./SelectBestEnvironmentPresenter.server";
 import { sortEnvironments } from "~/utils/environmentSort";
 import { defaultAvatar, parseAvatar } from "~/components/primitives/Avatar";
+import { env } from "~/env.server";
+import { flags } from "~/v3/featureFlags.server";
+import { validatePartialFeatureFlags } from "~/v3/featureFlags";
 
 export class OrganizationsPresenter {
   #prismaClient: PrismaClient;
@@ -111,6 +114,7 @@ export class OrganizationsPresenter {
       organization,
       project: {
         ...fullProject,
+        createdAt: fullProject.createdAt,
         environments: sortEnvironments(
           fullProject.environments.filter((env) => {
             if (env.type !== "DEVELOPMENT") return true;
@@ -132,6 +136,7 @@ export class OrganizationsPresenter {
         slug: true,
         title: true,
         avatar: true,
+        featureFlags: true,
         projects: {
           where: { deletedAt: null, version: "V3" },
           select: {
@@ -139,6 +144,7 @@ export class OrganizationsPresenter {
             slug: true,
             name: true,
             updatedAt: true,
+            externalRef: true,
           },
           orderBy: { name: "asc" },
         },
@@ -150,17 +156,35 @@ export class OrganizationsPresenter {
       },
     });
 
+    // Get global feature flags with env-var-based defaults
+    const globalFlags = await flags({
+      defaultValues: {
+        hasAiAccess: env.AI_FEATURES_ENABLED === "1",
+        hasPrivateConnections: env.PRIVATE_CONNECTIONS_ENABLED === "1",
+      },
+    });
+
     return orgs.map((org) => {
+      const orgFlagsResult = org.featureFlags
+        ? validatePartialFeatureFlags(org.featureFlags as Record<string, unknown>)
+        : ({ success: false } as const);
+      const orgFlags = orgFlagsResult.success ? orgFlagsResult.data : {};
+
+      // Combine global flags with org flags (org flags win)
+      const combinedFlags = { ...globalFlags, ...orgFlags };
+
       return {
         id: org.id,
         slug: org.slug,
         title: org.title,
         avatar: parseAvatar(org.avatar, defaultAvatar),
+        featureFlags: combinedFlags,
         projects: org.projects.map((project) => ({
           id: project.id,
           slug: project.slug,
           name: project.name,
           updatedAt: project.updatedAt,
+          externalRef: project.externalRef,
         })),
         membersCount: org._count.members,
       };
@@ -193,7 +217,11 @@ export class OrganizationsPresenter {
     })[];
   }) {
     if (environmentSlug) {
-      const env = environments.find((e) => e.slug === environmentSlug);
+      const env = environments.find(
+        (e) =>
+          e.slug === environmentSlug &&
+          (e.type !== "DEVELOPMENT" || e.orgMember?.userId === user.id)
+      );
       if (env) {
         return env;
       }
diff --git a/apps/webapp/app/presenters/RunFilters.server.ts b/apps/webapp/app/presenters/RunFilters.server.ts
index 8d70b4d3bdf..ff9f53429eb 100644
--- a/apps/webapp/app/presenters/RunFilters.server.ts
+++ b/apps/webapp/app/presenters/RunFilters.server.ts
@@ -1,3 +1,4 @@
+import { type TaskRunStatus } from "@trigger.dev/database";
 import {
   getRunFiltersFromSearchParams,
   TaskRunListSearchFilters,
@@ -34,12 +35,13 @@ export async function getRunFiltersFromRequest(request: Request): Promise<Filter
     scheduleId,
     queues,
     machines,
+    errorId,
   } = TaskRunListSearchFilters.parse(s);
 
   return {
     tasks,
     versions,
-    statuses,
+    statuses: statuses as TaskRunStatus[] | undefined,
     tags,
     period,
     bulkId,
@@ -53,5 +55,6 @@ export async function getRunFiltersFromRequest(request: Request): Promise<Filter
     cursor: cursor,
     queues,
     machines,
+    errorId,
   };
 }
diff --git a/apps/webapp/app/presenters/TeamPresenter.server.ts b/apps/webapp/app/presenters/TeamPresenter.server.ts
index 25300af191d..8b84a65a67c 100644
--- a/apps/webapp/app/presenters/TeamPresenter.server.ts
+++ b/apps/webapp/app/presenters/TeamPresenter.server.ts
@@ -1,5 +1,5 @@
 import { getTeamMembersAndInvites } from "~/models/member.server";
-import { getLimit } from "~/services/platform.v3.server";
+import { getCurrentPlan, getLimit, getPlans } from "~/services/platform.v3.server";
 import { BasePresenter } from "./v3/basePresenter.server";
 
 export class TeamPresenter extends BasePresenter {
@@ -13,7 +13,19 @@ export class TeamPresenter extends BasePresenter {
       return;
     }
 
-    const limit = await getLimit(organizationId, "teamMembers", 100_000_000);
+    const [baseLimit, currentPlan, plans] = await Promise.all([
+      getLimit(organizationId, "teamMembers", 100_000_000),
+      getCurrentPlan(organizationId),
+      getPlans(),
+    ]);
+
+    const canPurchaseSeats =
+      currentPlan?.v3Subscription?.plan?.limits.teamMembers.canExceed === true;
+    const extraSeats = currentPlan?.v3Subscription?.addOns?.seats?.purchased ?? 0;
+    const maxSeatQuota = currentPlan?.v3Subscription?.addOns?.seats?.quota ?? 0;
+    const planSeatLimit = currentPlan?.v3Subscription?.plan?.limits.teamMembers.number ?? 0;
+    const seatPricing = plans?.addOnPricing.seats ?? null;
+    const limit = baseLimit + extraSeats;
 
     return {
       ...result,
@@ -21,6 +33,11 @@ export class TeamPresenter extends BasePresenter {
         used: result.members.length + result.invites.length,
         limit,
       },
+      canPurchaseSeats,
+      extraSeats,
+      seatPricing,
+      maxSeatQuota,
+      planSeatLimit,
     };
   }
 }
diff --git a/apps/webapp/app/presenters/v3/ApiAlertChannelPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiAlertChannelPresenter.server.ts
index 4bc4c776e85..83ab09c177c 100644
--- a/apps/webapp/app/presenters/v3/ApiAlertChannelPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/ApiAlertChannelPresenter.server.ts
@@ -17,6 +17,7 @@ export const ApiAlertType = z.enum([
   "attempt_failure",
   "deployment_failure",
   "deployment_success",
+  "error_group",
 ]);
 
 export type ApiAlertType = z.infer<typeof ApiAlertType>;
@@ -85,6 +86,8 @@ export class ApiAlertChannelPresenter {
         return "deployment_failure";
       case "DEPLOYMENT_SUCCESS":
         return "deployment_success";
+      case "ERROR_GROUP":
+        return "error_group";
       default:
         assertNever(alertType);
     }
@@ -100,6 +103,8 @@ export class ApiAlertChannelPresenter {
         return "DEPLOYMENT_FAILURE";
       case "deployment_success":
         return "DEPLOYMENT_SUCCESS";
+      case "error_group":
+        return "ERROR_GROUP";
       default:
         assertNever(alertType);
     }
diff --git a/apps/webapp/app/presenters/v3/ApiKeysPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiKeysPresenter.server.ts
index 1ff560586a9..78e64403e74 100644
--- a/apps/webapp/app/presenters/v3/ApiKeysPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/ApiKeysPresenter.server.ts
@@ -38,6 +38,11 @@ export class ApiKeysPresenter {
             apiKey: true,
           },
         },
+        project: {
+          select: {
+            id: true,
+          },
+        },
       },
       where: {
         project: {
@@ -64,11 +69,22 @@ export class ApiKeysPresenter {
       throw new Error("Environment not found");
     }
 
+    const vercelIntegration =
+      await this.#prismaClient.organizationProjectIntegration.findFirst({
+        where: {
+          projectId: environment.project.id,
+          deletedAt: null,
+          organizationIntegration: { service: "VERCEL", deletedAt: null },
+        },
+        select: { id: true },
+      });
+
     return {
       environment: {
         ...environment,
         apiKey: environment?.parentEnvironment?.apiKey ?? environment?.apiKey,
       },
+      hasVercelIntegration: vercelIntegration !== null,
     };
   }
 }
diff --git a/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts
index 671496586ab..dc19457cdd1 100644
--- a/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts
@@ -9,12 +9,13 @@ import {
   logger,
 } from "@trigger.dev/core/v3";
 import { parsePacketAsJson } from "@trigger.dev/core/v3/utils/ioSerialization";
+import { getUserProvidedIdempotencyKey } from "@trigger.dev/core/v3/serverOnly";
 import { Prisma, TaskRunAttemptStatus, TaskRunStatus } from "@trigger.dev/database";
 import assertNever from "assert-never";
 import { API_VERSIONS, CURRENT_API_VERSION, RunStatusUnspecifiedApiVersion } from "~/api/versions";
 import { $replica, prisma } from "~/db.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { generatePresignedUrl } from "~/v3/r2.server";
+import { generatePresignedUrl } from "~/v3/objectStore.server";
 import { tracer } from "~/v3/tracer.server";
 import { startSpanWithEnv } from "~/v3/tracing.server";
 
@@ -38,6 +39,7 @@ const commonRunSelect = {
   baseCostInCents: true,
   usageDurationMs: true,
   idempotencyKey: true,
+  idempotencyKeyOptions: true,
   isTest: true,
   depth: true,
   scheduleId: true,
@@ -442,7 +444,7 @@ async function createCommonRunStructure(run: CommonRelatedRun, apiVersion: API_V
   return {
     id: run.friendlyId,
     taskIdentifier: run.taskIdentifier,
-    idempotencyKey: run.idempotencyKey ?? undefined,
+    idempotencyKey: getUserProvidedIdempotencyKey(run),
     version: run.lockedToVersion?.version,
     status: ApiRetrieveRunPresenter.apiStatusFromRunStatus(run.status, apiVersion),
     createdAt: run.createdAt,
diff --git a/apps/webapp/app/presenters/v3/BranchesPresenter.server.ts b/apps/webapp/app/presenters/v3/BranchesPresenter.server.ts
index 4aafc1844b0..fb094a98092 100644
--- a/apps/webapp/app/presenters/v3/BranchesPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/BranchesPresenter.server.ts
@@ -4,6 +4,7 @@ import { type Prisma, type PrismaClient, prisma } from "~/db.server";
 import { type Project } from "~/models/project.server";
 import { type User } from "~/models/user.server";
 import { type BranchesOptions } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route";
+import { getCurrentPlan, getPlans } from "~/services/platform.v3.server";
 import { checkBranchLimit } from "~/services/upsertBranch.server";
 
 type Result = Awaited<ReturnType<BranchesPresenter["call"]>>;
@@ -110,6 +111,11 @@ export class BranchesPresenter {
           limit: 0,
           isAtLimit: true,
         },
+        canPurchaseBranches: false,
+        extraBranches: 0,
+        branchPricing: null,
+        maxBranchQuota: 0,
+        planBranchLimit: 0,
       };
     }
 
@@ -131,6 +137,18 @@ export class BranchesPresenter {
     // Limits
     const limits = await checkBranchLimit(this.#prismaClient, project.organizationId, project.id);
 
+    const [currentPlan, plans] = await Promise.all([
+      getCurrentPlan(project.organizationId),
+      getPlans(),
+    ]);
+
+    const canPurchaseBranches =
+      currentPlan?.v3Subscription?.plan?.limits.branches.canExceed === true;
+    const extraBranches = currentPlan?.v3Subscription?.addOns?.branches?.purchased ?? 0;
+    const maxBranchQuota = currentPlan?.v3Subscription?.addOns?.branches?.quota ?? 0;
+    const planBranchLimit = currentPlan?.v3Subscription?.plan?.limits.branches.number ?? 0;
+    const branchPricing = plans?.addOnPricing.branches ?? null;
+
     const branches = await this.#prismaClient.runtimeEnvironment.findMany({
       select: {
         id: true,
@@ -191,6 +209,11 @@ export class BranchesPresenter {
       }),
       hasFilters,
       limits,
+      canPurchaseBranches,
+      extraBranches,
+      branchPricing,
+      maxBranchQuota,
+      planBranchLimit,
     };
   }
 }
diff --git a/apps/webapp/app/presenters/v3/BuiltInDashboards.server.ts b/apps/webapp/app/presenters/v3/BuiltInDashboards.server.ts
new file mode 100644
index 00000000000..2ec34614533
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/BuiltInDashboards.server.ts
@@ -0,0 +1,523 @@
+import { type BuiltInDashboard } from "./MetricDashboardPresenter.server";
+import { z } from "zod";
+
+const overviewDashboard: BuiltInDashboard = {
+  key: "overview",
+  title: "Metrics",
+  filters: ["tasks", "queues"],
+  layout: {
+    version: "1",
+    layout: [
+      { i: "9lDDdebQ", x: 3, y: 0, w: 3, h: 4 },
+      { i: "VhAgNlB0", x: 0, y: 0, w: 3, h: 4 },
+      { i: "iI5EnhJW", x: 6, y: 0, w: 3, h: 4 },
+      { i: "HtSgJEmp", x: 0, y: 17, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "rRbzv-Aq", x: 6, y: 4, w: 6, h: 13 },
+      { i: "j3yFSxLM", x: 0, y: 33, w: 6, h: 11 },
+      { i: "IKB8cENo", x: 6, y: 33, w: 6, h: 11 },
+      { i: "-fHz3CyQ", x: 0, y: 56, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "hnKsN482", x: 0, y: 58, w: 12, h: 15 },
+      { i: "if6dds8T", x: 0, y: 19, w: 12, h: 14 },
+      { i: "i3q1Awfz", x: 0, y: 4, w: 6, h: 13 },
+      { i: "Kh0w0fjy", x: 6, y: 44, w: 6, h: 12 },
+      { i: "zybRTAdz", x: 0, y: 44, w: 6, h: 12 },
+      { i: "ff2nVxxt", x: 0, y: 73, w: 12, h: 15 },
+      { i: "Dib0ywb4", x: 0, y: 88, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "YsWiQENd", x: 0, y: 90, w: 12, h: 15 },
+      { i: "lc-guCvo", x: 0, y: 105, w: 12, h: 15 },
+      { i: "xyQl3FAd", x: 9, y: 0, w: 3, h: 4 },
+    ],
+    widgets: {
+      "9lDDdebQ": {
+        title: "Total runs",
+        query: "SELECT\r\n  count() AS total_runs\r\nFROM\r\n  runs",
+        display: { type: "bignumber", column: "total_runs", aggregation: "sum", abbreviate: false },
+      },
+      VhAgNlB0: {
+        title: "Success %",
+        query:
+          "SELECT\r\n  round(countIf (status = 'Completed') * 100.0 / countIf (is_finished = 1), 2) AS success_percentage\r\nFROM\r\n  runs",
+        display: {
+          type: "bignumber",
+          column: "success_percentage",
+          aggregation: "avg",
+          abbreviate: true,
+          suffix: "%",
+        },
+      },
+      iI5EnhJW: {
+        title: "Failed runs",
+        query:
+          "SELECT\r\n  count() AS total_runs\r\nFROM\r\n  runs\r\nWHERE status IN ('Failed', 'System failure', 'Crashed')",
+        display: { type: "bignumber", column: "total_runs", aggregation: "sum", abbreviate: false },
+      },
+      HtSgJEmp: { title: "Failed runs", query: "", display: { type: "title" } },
+      "rRbzv-Aq": {
+        title: "Runs by status",
+        query:
+          "SELECT\r\n  timeBucket (),\r\n  status,\r\n  count() AS run_count\r\nFROM\r\n  runs\r\nGROUP BY\r\n  timeBucket,\r\n  status\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["run_count"],
+          groupByColumn: "status",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      j3yFSxLM: {
+        title: "Top failing tasks",
+        query:
+          "SELECT\r\n  task_identifier AS task,\r\n  count() AS runs,\r\n  countIf (status IN ('Failed', 'Crashed', 'System failure')) AS failures,\r\n  concat(round((countIf (status IN ('Failed', 'Crashed', 'System failure')) / count()) * 100, 2), '%') AS failure_rate,\r\n  avg(attempt_count - 1) AS avg_retries\r\nFROM\r\n  runs\r\nGROUP BY\r\n  task_identifier\r\nORDER BY\r\n  (countIf (status IN ('Failed', 'Crashed', 'System failure')) / count()) DESC;",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      IKB8cENo: {
+        title: "Top failing tags",
+        query:
+          "SELECT\r\n  arrayJoin(tags) AS tag,\r\n  count() AS runs,\r\n  countIf (status IN ('Failed', 'Crashed', 'System failure')) AS failures,\r\n  concat(round((countIf (status IN ('Failed', 'Crashed', 'System failure')) / count()) * 100, 2), '%') AS failure_rate,\r\n  avg(attempt_count - 1) AS avg_retries\r\nFROM\r\n  runs\r\nGROUP BY\r\n  tag\r\nORDER BY\r\n  (countIf (status IN ('Failed', 'Crashed', 'System failure')) / count()) DESC;",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "-fHz3CyQ": { title: "Usage and cost", query: "", display: { type: "title" } },
+      hnKsN482: {
+        title: "Cost by task",
+        query:
+          "SELECT\r\n  timeBucket() as time_period,\r\n  task_identifier,\r\n  sum(total_cost) AS total_cost\r\nFROM\r\n  runs\r\nGROUP BY\r\n  time_period,\r\n  task_identifier\r\nORDER BY\r\n  time_period",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "time_period",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: "task_identifier",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      if6dds8T: {
+        title: "Failed runs by task",
+        query:
+          "SELECT\r\n  timeBucket () as time_period,\r\n  task_identifier,\r\n  count() AS run_count\r\nFROM\r\n  runs\r\nWHERE status IN ('Failed', 'Crashed', 'System failure')\r\nGROUP BY\r\n  time_period,\r\n  task_identifier\r\nORDER BY\r\n  time_period",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "time_period",
+          yAxisColumns: ["run_count"],
+          groupByColumn: "task_identifier",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      i3q1Awfz: {
+        title: "Run success %",
+        query:
+          "SELECT\r\n  timeBucket (),\r\n  count() as total,\r\n  countIf (status = 'Completed') / total * 100 AS completed,\r\n  countIf (status IN ('Failed', 'Crashed', 'System failure')) / total * 100 AS failed,\r\nFROM\r\n  runs\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["failed", "completed"],
+          groupByColumn: null,
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+          seriesColors: { failed: "#f43f5e" },
+        },
+      },
+      Kh0w0fjy: {
+        title: "Top errors",
+        query:
+          "SELECT\r\n  concat(error.name, '(\"', error.message, '\")') AS error,\r\n  count() AS count\r\nFROM\r\n  runs\r\nWHERE\r\n  runs.error != NULL\r\n  AND runs.error.name != NULL\r\nGROUP BY\r\n  error\r\nORDER BY\r\n  count DESC",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      zybRTAdz: {
+        title: "Top errors over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  concat(error.name, '(\"', error.message, '\")') AS error,\r\n  count() AS count\r\nFROM\r\n  runs\r\nWHERE\r\n  runs.error != NULL\r\n  AND runs.error.name != NULL\r\nGROUP BY\r\n  timeBucket,\r\n  error\r\nORDER BY\r\n  count DESC",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["count"],
+          groupByColumn: "error",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+          seriesColors: { count: "#ef4343" },
+        },
+      },
+      ff2nVxxt: {
+        title: "Cost by machine",
+        query:
+          "SELECT\r\n  timeBucket() as time_period,\r\n  machine,\r\n  sum(total_cost) AS total_cost\r\nFROM\r\n  runs\r\nWHERE machine != ''\r\nGROUP BY\r\n  time_period,\r\n  machine\r\nORDER BY\r\n  time_period",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "time_period",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: "machine",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      Dib0ywb4: { title: "Versions", query: "", display: { type: "title" } },
+      YsWiQENd: {
+        title: "Runs by version",
+        query:
+          "SELECT\r\n  timeBucket (),\r\n  task_version,\r\n  count() as runs\r\nFROM\r\n  runs\r\nWHERE task_version != ''\r\nGROUP BY\r\n  timeBucket,\r\n  task_version\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["runs"],
+          groupByColumn: "task_version",
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+          seriesColors: {},
+        },
+      },
+      "lc-guCvo": {
+        title: "Version success %",
+        query:
+          "SELECT\r\n  timeBucket (),\r\n  task_version,\r\n  count() as total,\r\n  countIf (status = 'Completed') / total * 100 AS success\r\nFROM\r\n  runs\r\nWHERE task_version != ''\r\nGROUP BY\r\n  timeBucket,\r\n  task_version\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["success"],
+          groupByColumn: "task_version",
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+          seriesColors: {},
+        },
+      },
+      xyQl3FAd: {
+        title: "Queued",
+        query:
+          "SELECT\r\n  count() AS queued\r\nFROM\r\n  runs\r\nWHERE status IN ('Dequeued', 'Queued')",
+        display: { type: "bignumber", column: "queued", aggregation: "sum", abbreviate: false },
+      },
+    },
+  },
+};
+
+const llmDashboard: BuiltInDashboard = {
+  key: "llm",
+  title: "AI Metrics",
+  filters: ["tasks", "models", "prompts", "operations", "providers"],
+  layout: {
+    version: "1",
+    layout: [
+      // Big numbers row
+      { i: "llm-cost", x: 0, y: 0, w: 3, h: 4 },
+      { i: "llm-calls", x: 3, y: 0, w: 3, h: 4 },
+      { i: "llm-ttfc", x: 6, y: 0, w: 3, h: 4 },
+      { i: "llm-tps", x: 9, y: 0, w: 3, h: 4 },
+      // Cost section
+      { i: "llm-title-cost", x: 0, y: 4, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-cost-time", x: 0, y: 6, w: 6, h: 13 },
+      { i: "llm-cost-model", x: 6, y: 6, w: 6, h: 13 },
+      // Usage section
+      { i: "llm-title-usage", x: 0, y: 19, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-tokens-time", x: 0, y: 21, w: 6, h: 13 },
+      { i: "llm-calls-model", x: 6, y: 21, w: 6, h: 13 },
+      // Performance section
+      { i: "llm-title-perf", x: 0, y: 34, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-ttfc-time", x: 0, y: 36, w: 6, h: 13 },
+      { i: "llm-tps-model", x: 6, y: 36, w: 6, h: 13 },
+      { i: "llm-latency-pct", x: 0, y: 49, w: 6, h: 13 },
+      { i: "llm-latency-time", x: 6, y: 49, w: 6, h: 13 },
+      // Behavior section
+      { i: "llm-title-behavior", x: 0, y: 62, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-finish-reasons", x: 0, y: 64, w: 6, h: 13 },
+      { i: "llm-top-runs", x: 6, y: 64, w: 6, h: 13 },
+      // Attribution section
+      { i: "llm-title-attribution", x: 0, y: 77, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-cost-task", x: 0, y: 79, w: 6, h: 13 },
+      { i: "llm-cost-provider", x: 6, y: 79, w: 6, h: 13 },
+      { i: "llm-cost-prompt", x: 0, y: 92, w: 6, h: 13 },
+      { i: "llm-cost-user", x: 6, y: 92, w: 6, h: 13 },
+      // Efficiency section
+      { i: "llm-title-efficiency", x: 0, y: 105, w: 12, h: 2, minH: 2, maxH: 2 },
+      { i: "llm-cost-operation", x: 0, y: 107, w: 6, h: 13 },
+      { i: "llm-cache-util", x: 6, y: 107, w: 6, h: 13 },
+    ],
+    widgets: {
+      "llm-cost": {
+        title: "Total LLM cost",
+        query: "SELECT\r\n  SUM(total_cost) AS total_cost\r\nFROM\r\n  llm_metrics",
+        display: {
+          type: "bignumber",
+          column: "total_cost",
+          aggregation: "sum",
+          abbreviate: true,
+        },
+      },
+      "llm-calls": {
+        title: "Total calls",
+        query: "SELECT\r\n  count() AS total_calls\r\nFROM\r\n  llm_metrics",
+        display: {
+          type: "bignumber",
+          column: "total_calls",
+          aggregation: "sum",
+          abbreviate: false,
+        },
+      },
+      "llm-ttfc": {
+        title: "Avg TTFC",
+        query:
+          "SELECT\r\n  round(avg(ms_to_first_chunk), 1) AS avg_ttfc\r\nFROM\r\n  llm_metrics\r\nWHERE ms_to_first_chunk > 0",
+        display: {
+          type: "bignumber",
+          column: "avg_ttfc",
+          aggregation: "avg",
+          abbreviate: false,
+          suffix: "ms",
+        },
+      },
+      "llm-tps": {
+        title: "Avg tokens/sec",
+        query:
+          "SELECT\r\n  round(avg(tokens_per_second), 1) AS avg_tps\r\nFROM\r\n  llm_metrics\r\nWHERE tokens_per_second > 0",
+        display: {
+          type: "bignumber",
+          column: "avg_tps",
+          aggregation: "avg",
+          abbreviate: false,
+          suffix: "/s",
+        },
+      },
+      "llm-title-cost": { title: "Cost", query: "", display: { type: "title" } },
+      "llm-cost-time": {
+        title: "Cost over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  SUM(total_cost) AS total_cost\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: null,
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-cost-model": {
+        title: "Cost by model",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  response_model,\r\n  SUM(total_cost) AS total_cost\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  timeBucket,\r\n  response_model\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: "response_model",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-title-usage": { title: "Usage", query: "", display: { type: "title" } },
+      "llm-tokens-time": {
+        title: "Tokens over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  SUM(input_tokens) AS input_tokens,\r\n  SUM(output_tokens) AS output_tokens\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["input_tokens", "output_tokens"],
+          groupByColumn: null,
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-calls-model": {
+        title: "Calls by model",
+        query:
+          "SELECT\r\n  response_model,\r\n  count() AS calls,\r\n  SUM(total_tokens) AS tokens,\r\n  SUM(total_cost) AS cost\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  response_model\r\nORDER BY\r\n  cost DESC",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-title-perf": { title: "Performance", query: "", display: { type: "title" } },
+      "llm-ttfc-time": {
+        title: "TTFC over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  round(avg(ms_to_first_chunk), 1) AS avg_ttfc\r\nFROM\r\n  llm_metrics\r\nWHERE ms_to_first_chunk > 0\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["avg_ttfc"],
+          groupByColumn: null,
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+        },
+      },
+      "llm-tps-model": {
+        title: "Tokens/sec by model",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  response_model,\r\n  round(avg(tokens_per_second), 1) AS avg_tps\r\nFROM\r\n  llm_metrics\r\nWHERE tokens_per_second > 0\r\nGROUP BY\r\n  timeBucket,\r\n  response_model\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["avg_tps"],
+          groupByColumn: "response_model",
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+        },
+      },
+      "llm-latency-pct": {
+        title: "Latency percentiles by model",
+        query:
+          "SELECT\r\n  response_model,\r\n  round(quantile(0.5)(ms_to_first_chunk), 1) AS p50,\r\n  round(quantile(0.9)(ms_to_first_chunk), 1) AS p90,\r\n  round(quantile(0.95)(ms_to_first_chunk), 1) AS p95,\r\n  round(quantile(0.99)(ms_to_first_chunk), 1) AS p99,\r\n  count() AS calls\r\nFROM\r\n  llm_metrics\r\nWHERE ms_to_first_chunk > 0\r\nGROUP BY\r\n  response_model\r\nORDER BY\r\n  p50 DESC",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-latency-time": {
+        title: "Latency percentiles over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  round(quantile(0.5)(ms_to_first_chunk), 1) AS p50,\r\n  round(quantile(0.95)(ms_to_first_chunk), 1) AS p95\r\nFROM\r\n  llm_metrics\r\nWHERE ms_to_first_chunk > 0\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["p50", "p95"],
+          groupByColumn: null,
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+          seriesColors: { p95: "#f43f5e" },
+        },
+      },
+      "llm-title-behavior": { title: "Behavior", query: "", display: { type: "title" } },
+      "llm-finish-reasons": {
+        title: "Finish reasons over time",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  finish_reason,\r\n  count() AS calls\r\nFROM\r\n  llm_metrics\r\nWHERE finish_reason != ''\r\nGROUP BY\r\n  timeBucket,\r\n  finish_reason\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["calls"],
+          groupByColumn: "finish_reason",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-top-runs": {
+        title: "Most expensive runs",
+        query:
+          "SELECT\r\n  run_id,\r\n  task_identifier,\r\n  SUM(total_cost) AS llm_cost,\r\n  SUM(total_tokens) AS tokens\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  run_id,\r\n  task_identifier\r\nORDER BY\r\n  llm_cost DESC\r\nLIMIT 50",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-title-attribution": { title: "Attribution", query: "", display: { type: "title" } },
+      "llm-cost-task": {
+        title: "Cost by task",
+        query:
+          "SELECT\r\n  task_identifier,\r\n  SUM(total_cost) AS cost,\r\n  SUM(total_tokens) AS tokens,\r\n  count() AS calls\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  task_identifier\r\nORDER BY\r\n  cost DESC",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-cost-provider": {
+        title: "Cost by provider",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  gen_ai_system,\r\n  SUM(total_cost) AS total_cost\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  timeBucket,\r\n  gen_ai_system\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: "gen_ai_system",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-cost-prompt": {
+        title: "Cost by prompt",
+        query:
+          "SELECT\r\n  prompt_slug,\r\n  SUM(total_cost) AS cost,\r\n  SUM(total_tokens) AS tokens,\r\n  count() AS calls\r\nFROM\r\n  llm_metrics\r\nWHERE prompt_slug != ''\r\nGROUP BY\r\n  prompt_slug\r\nORDER BY\r\n  cost DESC",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-cost-user": {
+        title: "Cost by user",
+        query:
+          "SELECT\r\n  metadata['userId'] AS user_id,\r\n  SUM(total_cost) AS cost,\r\n  SUM(total_tokens) AS tokens,\r\n  count() AS calls\r\nFROM\r\n  llm_metrics\r\nWHERE metadata['userId'] != ''\r\nGROUP BY\r\n  user_id\r\nORDER BY\r\n  cost DESC\r\nLIMIT 20",
+        display: { type: "table", prettyFormatting: true, sorting: [] },
+      },
+      "llm-title-efficiency": { title: "Efficiency", query: "", display: { type: "title" } },
+      "llm-cost-operation": {
+        title: "Cost by operation type",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  operation_id,\r\n  SUM(total_cost) AS total_cost\r\nFROM\r\n  llm_metrics\r\nWHERE operation_id != ''\r\nGROUP BY\r\n  timeBucket,\r\n  operation_id\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "bar",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["total_cost"],
+          groupByColumn: "operation_id",
+          stacked: true,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "sum",
+        },
+      },
+      "llm-cache-util": {
+        title: "Cache utilization",
+        query:
+          "SELECT\r\n  timeBucket(),\r\n  round(countIf(cached_read_tokens > 0) * 100.0 / count(), 1) AS cache_hit_pct,\r\n  round(avg(cached_read_tokens), 0) AS avg_cached_tokens\r\nFROM\r\n  llm_metrics\r\nGROUP BY\r\n  timeBucket\r\nORDER BY\r\n  timeBucket",
+        display: {
+          type: "chart",
+          chartType: "line",
+          xAxisColumn: "timebucket",
+          yAxisColumns: ["cache_hit_pct"],
+          groupByColumn: null,
+          stacked: false,
+          sortByColumn: null,
+          sortDirection: "asc",
+          aggregation: "avg",
+        },
+      },
+    },
+  },
+};
+
+const builtInDashboards: BuiltInDashboard[] = [overviewDashboard, llmDashboard];
+
+export function builtInDashboardList(): BuiltInDashboard[] {
+  return builtInDashboards;
+}
+
+export function builtInDashboard(key: string): BuiltInDashboard {
+  const dashboard = builtInDashboards.find((d) => d.key === key);
+  if (!dashboard) {
+    throw new Error(`No built-in dashboard "${key}"`);
+  }
+
+  return dashboard;
+}
diff --git a/apps/webapp/app/presenters/v3/DeploymentListPresenter.server.ts b/apps/webapp/app/presenters/v3/DeploymentListPresenter.server.ts
index 0b920e29421..9abc0ed0ab9 100644
--- a/apps/webapp/app/presenters/v3/DeploymentListPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/DeploymentListPresenter.server.ts
@@ -1,5 +1,5 @@
 import {
-  type Prisma,
+  Prisma,
   type WorkerDeploymentStatus,
   type WorkerInstanceGroupType,
 } from "@trigger.dev/database";
@@ -10,6 +10,10 @@ import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import { type User } from "~/models/user.server";
 import { processGitMetadata } from "./BranchesPresenter.server";
 import { BranchTrackingConfigSchema, getTrackedBranchForEnvironment } from "~/v3/github";
+import {
+  VercelProjectIntegrationDataSchema,
+  buildVercelDeploymentUrl,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
 
 const pageSize = 20;
 
@@ -105,6 +109,51 @@ export class DeploymentListPresenter {
       },
     });
 
+    // Check for Vercel integration before the main query so we can conditionally LEFT JOIN
+    let hasVercelIntegration = false;
+    let vercelTeamSlug: string | undefined;
+    let vercelProjectName: string | undefined;
+
+    const vercelProjectIntegration =
+      await this.#prismaClient.organizationProjectIntegration.findFirst({
+        where: {
+          projectId: project.id,
+          deletedAt: null,
+          organizationIntegration: {
+            service: "VERCEL",
+            deletedAt: null,
+          },
+        },
+        select: {
+          integrationData: true,
+        },
+      });
+
+    if (vercelProjectIntegration) {
+      const parsed = VercelProjectIntegrationDataSchema.safeParse(
+        vercelProjectIntegration.integrationData
+      );
+
+      if (parsed.success && parsed.data.vercelTeamSlug) {
+        hasVercelIntegration = true;
+        vercelTeamSlug = parsed.data.vercelTeamSlug;
+        vercelProjectName = parsed.data.vercelProjectName;
+      }
+    }
+
+    const vercelSelect = hasVercelIntegration
+      ? Prisma.sql`, id_dep."integrationDeploymentId"`
+      : Prisma.sql``;
+    const vercelJoin = hasVercelIntegration
+      ? Prisma.sql`LEFT JOIN LATERAL (
+        SELECT id_inner."integrationDeploymentId"
+        FROM ${sqlDatabaseSchema}."IntegrationDeployment" as id_inner
+        WHERE id_inner."deploymentId" = wd."id" AND id_inner."integrationName" = 'vercel'
+        ORDER BY id_inner."createdAt" DESC
+        LIMIT 1
+      ) id_dep ON true`
+      : Prisma.sql``;
+
     const deployments = await this.#prismaClient.$queryRaw<
       {
         id: string;
@@ -123,6 +172,7 @@ export class DeploymentListPresenter {
         userAvatarUrl: string | null;
         type: WorkerInstanceGroupType;
         git: Prisma.JsonValue | null;
+        integrationDeploymentId: string | null;
       }[]
     >`
     SELECT
@@ -142,10 +192,12 @@ export class DeploymentListPresenter {
   wd."deployedAt",
   wd."type",
   wd."git"
+  ${vercelSelect}
 FROM
   ${sqlDatabaseSchema}."WorkerDeployment" as wd
 LEFT JOIN
   ${sqlDatabaseSchema}."User" as u ON wd."triggeredById" = u."id"
+${vercelJoin}
 WHERE
   wd."projectId" = ${project.id}
   AND wd."environmentId" = ${environment.id}
@@ -173,6 +225,7 @@ LIMIT ${pageSize} OFFSET ${pageSize * (page - 1)};`;
     return {
       currentPage: page,
       totalPages: Math.ceil(totalCount / pageSize),
+      hasVercelIntegration,
       connectedGithubRepository: project.connectedGithubRepository ?? undefined,
       environmentGitHubBranch,
       deployments: deployments.map((deployment, index) => {
@@ -180,6 +233,15 @@ LIMIT ${pageSize} OFFSET ${pageSize * (page - 1)};`;
           (labeledDeployment) => labeledDeployment.deploymentId === deployment.id
         );
 
+        let vercelDeploymentUrl: string | null = null;
+        if (hasVercelIntegration && deployment.integrationDeploymentId && vercelTeamSlug && vercelProjectName) {
+          vercelDeploymentUrl = buildVercelDeploymentUrl(
+            vercelTeamSlug,
+            vercelProjectName,
+            deployment.integrationDeploymentId
+          );
+        }
+
         return {
           id: deployment.id,
           shortCode: deployment.shortCode,
@@ -210,6 +272,7 @@ LIMIT ${pageSize} OFFSET ${pageSize * (page - 1)};`;
               }
             : undefined,
           git: processGitMetadata(deployment.git),
+          vercelDeploymentUrl,
         };
       }),
     };
diff --git a/apps/webapp/app/presenters/v3/DeploymentPresenter.server.ts b/apps/webapp/app/presenters/v3/DeploymentPresenter.server.ts
index ea59c657228..9a15f8b4ac0 100644
--- a/apps/webapp/app/presenters/v3/DeploymentPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/DeploymentPresenter.server.ts
@@ -12,6 +12,7 @@ import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import { type User } from "~/models/user.server";
 import { getUsername } from "~/utils/username";
 import { processGitMetadata } from "./BranchesPresenter.server";
+import { VercelProjectIntegrationDataSchema } from "~/v3/vercel/vercelProjectIntegrationSchema";
 import { S2 } from "@s2-dev/streamstore";
 import { env } from "~/env.server";
 import { createRedisClient } from "~/redis.server";
@@ -156,10 +157,56 @@ export class DeploymentPresenter {
           },
         },
         buildServerMetadata: true,
+        triggeredVia: true,
       },
     });
 
     const gitMetadata = processGitMetadata(deployment.git);
+
+    // Look up Vercel integration data to construct a deployment URL
+    let vercelDeploymentUrl: string | undefined;
+    const vercelProjectIntegration =
+      await this.#prismaClient.organizationProjectIntegration.findFirst({
+        where: {
+          projectId: project.id,
+          deletedAt: null,
+          organizationIntegration: {
+            service: "VERCEL",
+            deletedAt: null,
+          },
+        },
+        select: {
+          integrationData: true,
+        },
+      });
+
+    if (vercelProjectIntegration) {
+      const parsed = VercelProjectIntegrationDataSchema.safeParse(
+        vercelProjectIntegration.integrationData
+      );
+
+      if (parsed.success && parsed.data.vercelTeamSlug) {
+        const integrationDeployment =
+          await this.#prismaClient.integrationDeployment.findFirst({
+            where: {
+              deploymentId: deployment.id,
+              integrationName: "vercel",
+            },
+            select: {
+              integrationDeploymentId: true,
+            },
+            orderBy: {
+              createdAt: "desc",
+            },
+          });
+
+        if (integrationDeployment) {
+          const vercelId = integrationDeployment.integrationDeploymentId;
+          vercelDeploymentUrl = `https://vercel.com/${parsed.data.vercelTeamSlug}/${parsed.data.vercelProjectName}/${vercelId}`;
+        }
+      }
+    }
+
     const externalBuildData = deployment.externalBuildData
       ? ExternalBuildData.safeParse(deployment.externalBuildData)
       : undefined;
@@ -170,7 +217,7 @@ export class DeploymentPresenter {
     let eventStream = undefined;
     if (
       env.S2_ENABLED === "1" &&
-      (buildServerMetadata || gitMetadata?.source === "trigger_github_app")
+      (buildServerMetadata || gitMetadata?.source === "trigger_github_app" || env.S2_DEPLOYMENT_STREAMS_LOCAL === "1")
     ) {
       const [error, accessToken] = await tryCatch(this.getS2AccessToken(project.externalRef));
 
@@ -225,6 +272,8 @@ export class DeploymentPresenter {
         isBuilt: !!deployment.builtAt,
         type: deployment.type,
         git: gitMetadata,
+        triggeredVia: deployment.triggeredVia,
+        vercelDeploymentUrl,
       },
     };
   }
@@ -241,9 +290,9 @@ export class DeploymentPresenter {
       return cachedToken;
     }
 
-    const { access_token: accessToken } = await s2.accessTokens.issue({
+    const { accessToken } = await s2.accessTokens.issue({
       id: `${projectRef}-${new Date().getTime()}`,
-      expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour
+      expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 1 hour
       scope: {
         ops: ["read"],
         basins: {
diff --git a/apps/webapp/app/presenters/v3/EnvironmentQueuePresenter.server.ts b/apps/webapp/app/presenters/v3/EnvironmentQueuePresenter.server.ts
index f408511a832..10201094376 100644
--- a/apps/webapp/app/presenters/v3/EnvironmentQueuePresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/EnvironmentQueuePresenter.server.ts
@@ -1,6 +1,7 @@
 import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { marqs } from "~/v3/marqs/index.server";
 import { engine } from "~/v3/runEngine.server";
+import { getQueueSizeLimit } from "~/v3/utils/queueLimits.server";
 import { BasePresenter } from "./basePresenter.server";
 
 export type Environment = {
@@ -9,6 +10,7 @@ export type Environment = {
   concurrencyLimit: number;
   burstFactor: number;
   runsEnabled: boolean;
+  queueSizeLimit: number | null;
 };
 
 export class EnvironmentQueuePresenter extends BasePresenter {
@@ -30,6 +32,8 @@ export class EnvironmentQueuePresenter extends BasePresenter {
       },
       select: {
         runsEnabled: true,
+        maximumDevQueueSize: true,
+        maximumDeployedQueueSize: true,
       },
     });
 
@@ -37,12 +41,15 @@ export class EnvironmentQueuePresenter extends BasePresenter {
       throw new Error("Organization not found");
     }
 
+    const queueSizeLimit = getQueueSizeLimit(environment.type, organization);
+
     return {
       running,
       queued,
       concurrencyLimit: environment.maximumConcurrencyLimit,
       burstFactor: environment.concurrencyLimitBurstFactor.toNumber(),
       runsEnabled: environment.type === "DEVELOPMENT" || organization.runsEnabled,
+      queueSizeLimit,
     };
   }
 }
diff --git a/apps/webapp/app/presenters/v3/EnvironmentVariablesPresenter.server.ts b/apps/webapp/app/presenters/v3/EnvironmentVariablesPresenter.server.ts
index 730591f4ebc..aff55263fec 100644
--- a/apps/webapp/app/presenters/v3/EnvironmentVariablesPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/EnvironmentVariablesPresenter.server.ts
@@ -1,9 +1,14 @@
-import { flipCauseOption } from "effect/Cause";
 import { PrismaClient, prisma } from "~/db.server";
 import { Project } from "~/models/project.server";
 import { User } from "~/models/user.server";
 import { filterOrphanedEnvironments, sortEnvironments } from "~/utils/environmentSort";
 import { EnvironmentVariablesRepository } from "~/v3/environmentVariables/environmentVariablesRepository.server";
+import type { EnvironmentVariableUpdater } from "~/v3/environmentVariables/repository";
+import {
+  SyncEnvVarsMapping,
+  EnvSlug,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
 
 type Result = Awaited<ReturnType<EnvironmentVariablesPresenter["call"]>>;
 export type EnvironmentVariableWithSetValues = Result["environmentVariables"][number];
@@ -44,6 +49,9 @@ export class EnvironmentVariablesPresenter {
           select: {
             id: true,
             environmentId: true,
+            version: true,
+            lastUpdatedBy: true,
+            updatedAt: true,
             valueReference: {
               select: {
                 key: true,
@@ -67,6 +75,42 @@ export class EnvironmentVariablesPresenter {
       },
     });
 
+    const userIds = new Set(
+      environmentVariables
+        .flatMap((envVar) => envVar.values)
+        .map((value) => value.lastUpdatedBy)
+        .filter(
+          (lastUpdatedBy): lastUpdatedBy is { type: "user"; userId: string } =>
+            lastUpdatedBy !== null &&
+            typeof lastUpdatedBy === "object" &&
+            "type" in lastUpdatedBy &&
+            lastUpdatedBy.type === "user" &&
+            "userId" in lastUpdatedBy &&
+            typeof lastUpdatedBy.userId === "string"
+        )
+        .map((lastUpdatedBy) => lastUpdatedBy.userId)
+    );
+
+    const users =
+      userIds.size > 0
+        ? await this.#prismaClient.user.findMany({
+            where: {
+              id: {
+                in: Array.from(userIds),
+              },
+            },
+            select: {
+              id: true,
+              name: true,
+              displayName: true,
+              avatarUrl: true,
+            },
+          })
+        : [];
+
+    const usersRecord: Record<string, { id: string; name: string | null; displayName: string | null; avatarUrl: string | null }> =
+      Object.fromEntries(users.map((u) => [u.id, u]));
+
     const environments = await this.#prismaClient.runtimeEnvironment.findMany({
       select: {
         id: true,
@@ -94,6 +138,18 @@ export class EnvironmentVariablesPresenter {
     const repository = new EnvironmentVariablesRepository(this.#prismaClient);
     const variables = await repository.getProject(project.id);
 
+    // Get Vercel integration data if it exists
+    const vercelService = new VercelIntegrationService(this.#prismaClient);
+    const vercelIntegration = await vercelService.getVercelProjectIntegration(project.id);
+
+    let vercelSyncEnvVarsMapping: SyncEnvVarsMapping = {};
+    let vercelPullEnvVarsBeforeBuild: EnvSlug[] | null = null;
+
+    if (vercelIntegration) {
+      vercelSyncEnvVarsMapping = vercelIntegration.parsedIntegrationData.syncEnvVarsMapping;
+      vercelPullEnvVarsBeforeBuild = vercelIntegration.parsedIntegrationData.config.pullEnvVarsBeforeBuild ?? null;
+    }
+
     return {
       environmentVariables: environmentVariables
         .flatMap((environmentVariable) => {
@@ -101,13 +157,29 @@ export class EnvironmentVariablesPresenter {
 
           return sortedEnvironments.flatMap((env) => {
             const val = variable?.values.find((v) => v.environment.id === env.id);
-            const isSecret =
-              environmentVariable.values.find((v) => v.environmentId === env.id)?.isSecret ?? false;
+            const valueRecord = environmentVariable.values.find((v) => v.environmentId === env.id);
+            const isSecret = valueRecord?.isSecret ?? false;
 
-            if (!val) {
+            if (!val || !valueRecord) {
               return [];
             }
 
+            const lastUpdatedBy = valueRecord.lastUpdatedBy as EnvironmentVariableUpdater | null;
+
+            const updatedByUser =
+              lastUpdatedBy?.type === "user"
+                ? (() => {
+                    const user = usersRecord[lastUpdatedBy.userId];
+                    return user
+                      ? {
+                          id: user.id,
+                          name: user.displayName || user.name || "Unknown",
+                          avatarUrl: user.avatarUrl,
+                        }
+                      : null;
+                  })()
+                : null;
+
             return [
               {
                 id: environmentVariable.id,
@@ -115,6 +187,10 @@ export class EnvironmentVariablesPresenter {
                 environment: { type: env.type, id: env.id, branchName: env.branchName },
                 value: isSecret ? "" : val.value,
                 isSecret,
+                version: valueRecord.version,
+                lastUpdatedBy,
+                updatedByUser,
+                updatedAt: valueRecord.updatedAt,
               },
             ];
           });
@@ -127,6 +203,14 @@ export class EnvironmentVariablesPresenter {
         branchName: environment.branchName,
       })),
       hasStaging: environments.some((environment) => environment.type === "STAGING"),
+      // Vercel integration data
+      vercelIntegration: vercelIntegration
+        ? {
+            enabled: true,
+            pullEnvVarsBeforeBuild: vercelPullEnvVarsBeforeBuild,
+            syncEnvVarsMapping: vercelSyncEnvVarsMapping,
+          }
+        : null,
     };
   }
 }
diff --git a/apps/webapp/app/presenters/v3/ErrorAlertChannelPresenter.server.ts b/apps/webapp/app/presenters/v3/ErrorAlertChannelPresenter.server.ts
new file mode 100644
index 00000000000..e2d207555fe
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/ErrorAlertChannelPresenter.server.ts
@@ -0,0 +1,73 @@
+import type { RuntimeEnvironmentType } from "@trigger.dev/database";
+import {
+  ProjectAlertEmailProperties,
+  ProjectAlertSlackProperties,
+  ProjectAlertWebhookProperties,
+} from "~/models/projectAlert.server";
+import { BasePresenter } from "./basePresenter.server";
+import { NewAlertChannelPresenter } from "./NewAlertChannelPresenter.server";
+import { env } from "~/env.server";
+
+export type ErrorAlertChannelData = Awaited<ReturnType<ErrorAlertChannelPresenter["call"]>>;
+
+export class ErrorAlertChannelPresenter extends BasePresenter {
+  public async call(projectId: string, environmentType: RuntimeEnvironmentType) {
+    const channels = await this._prisma.projectAlertChannel.findMany({
+      where: {
+        projectId,
+        alertTypes: { has: "ERROR_GROUP" },
+        environmentTypes: { has: environmentType },
+      },
+      orderBy: { createdAt: "asc" },
+    });
+
+    const emails: Array<{ id: string; email: string }> = [];
+    const webhooks: Array<{ id: string; url: string }> = [];
+    let slackChannel: { id: string; channelId: string; channelName: string } | null = null;
+
+    for (const channel of channels) {
+      switch (channel.type) {
+        case "EMAIL": {
+          const parsed = ProjectAlertEmailProperties.safeParse(channel.properties);
+          if (parsed.success) {
+            emails.push({ id: channel.id, email: parsed.data.email });
+          }
+          break;
+        }
+        case "SLACK": {
+          if (!channel.enabled) break;
+          const parsed = ProjectAlertSlackProperties.safeParse(channel.properties);
+          if (parsed.success) {
+            slackChannel = {
+              id: channel.id,
+              channelId: parsed.data.channelId,
+              channelName: parsed.data.channelName,
+            };
+          }
+          break;
+        }
+        case "WEBHOOK": {
+          const parsed = ProjectAlertWebhookProperties.safeParse(channel.properties);
+          if (parsed.success) {
+            webhooks.push({ id: channel.id, url: parsed.data.url });
+          }
+          break;
+        }
+      }
+    }
+
+    const slackPresenter = new NewAlertChannelPresenter(this._prisma, this._replica);
+    const slackResult = await slackPresenter.call(projectId);
+
+    const emailAlertsEnabled =
+      env.ALERT_FROM_EMAIL !== undefined && env.ALERT_RESEND_API_KEY !== undefined;
+
+    return {
+      emails,
+      webhooks,
+      slackChannel,
+      slack: slackResult.slack,
+      emailAlertsEnabled,
+    };
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/ErrorGroupPresenter.server.ts b/apps/webapp/app/presenters/v3/ErrorGroupPresenter.server.ts
new file mode 100644
index 00000000000..5e9df362e4c
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/ErrorGroupPresenter.server.ts
@@ -0,0 +1,434 @@
+import { z } from "zod";
+import { type ClickHouse, msToClickHouseInterval } from "@internal/clickhouse";
+import { TimeGranularity } from "~/utils/timeGranularity";
+import { ErrorId } from "@trigger.dev/core/v3/isomorphic";
+import { type ErrorGroupStatus, type PrismaClientOrTransaction } from "@trigger.dev/database";
+import { timeFilterFromTo } from "~/components/runs/v3/SharedFilters";
+import { type Direction, DirectionSchema } from "~/components/ListPagination";
+import { findDisplayableEnvironment } from "~/models/runtimeEnvironment.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { BasePresenter } from "~/presenters/v3/basePresenter.server";
+import {
+  NextRunListPresenter,
+  type NextRunList,
+} from "~/presenters/v3/NextRunListPresenter.server";
+import { sortVersionsDescending } from "~/utils/semver";
+
+const errorGroupGranularity = new TimeGranularity([
+  { max: "1h", granularity: "1m" },
+  { max: "1d", granularity: "20m" },
+  { max: "1w", granularity: "2h" },
+  { max: "31d", granularity: "12h" },
+  { max: "60d", granularity: "1w" },
+  { max: "Infinity", granularity: "30d" },
+]);
+
+export type ErrorGroupOptions = {
+  userId?: string;
+  projectId: string;
+  fingerprint: string;
+  versions?: string[];
+  runsPageSize?: number;
+  period?: string;
+  from?: number;
+  to?: number;
+  cursor?: string;
+  direction?: Direction;
+};
+
+export const ErrorGroupOptionsSchema = z.object({
+  userId: z.string().optional(),
+  projectId: z.string(),
+  fingerprint: z.string(),
+  versions: z.array(z.string()).optional(),
+  runsPageSize: z.number().int().positive().max(1000).optional(),
+  period: z.string().optional(),
+  from: z.number().int().nonnegative().optional(),
+  to: z.number().int().nonnegative().optional(),
+  cursor: z.string().optional(),
+  direction: DirectionSchema.optional(),
+});
+
+const DEFAULT_RUNS_PAGE_SIZE = 25;
+
+export type ErrorGroupDetail = Awaited<ReturnType<ErrorGroupPresenter["call"]>>;
+
+function parseClickHouseDateTime(value: string): Date {
+  const asNum = Number(value);
+  if (!isNaN(asNum) && asNum > 1e12) {
+    return new Date(asNum);
+  }
+  return new Date(value.replace(" ", "T") + "Z");
+}
+
+export type ErrorGroupState = {
+  status: ErrorGroupStatus;
+  resolvedAt: Date | null;
+  resolvedInVersion: string | null;
+  resolvedBy: string | null;
+  ignoredAt: Date | null;
+  ignoredUntil: Date | null;
+  ignoredReason: string | null;
+  ignoredByUserId: string | null;
+  ignoredByUserDisplayName: string | null;
+  ignoredUntilOccurrenceRate: number | null;
+  ignoredUntilTotalOccurrences: number | null;
+  ignoredAtOccurrenceCount: number | null;
+};
+
+export type ErrorGroupSummary = {
+  fingerprint: string;
+  errorType: string;
+  errorMessage: string;
+  taskIdentifier: string;
+  count: number;
+  firstSeen: Date;
+  lastSeen: Date;
+  affectedVersions: string[];
+  state: ErrorGroupState;
+};
+
+export type ErrorGroupOccurrences = Awaited<ReturnType<ErrorGroupPresenter["getOccurrences"]>>;
+export type ErrorGroupActivity = ErrorGroupOccurrences["data"];
+export type ErrorGroupActivityVersions = ErrorGroupOccurrences["versions"];
+
+export class ErrorGroupPresenter extends BasePresenter {
+  constructor(
+    private readonly replica: PrismaClientOrTransaction,
+    private readonly logsClickhouse: ClickHouse,
+    private readonly clickhouse: ClickHouse
+  ) {
+    super(undefined, replica);
+  }
+
+  public async call(
+    organizationId: string,
+    environmentId: string,
+    {
+      userId,
+      projectId,
+      fingerprint,
+      versions,
+      runsPageSize = DEFAULT_RUNS_PAGE_SIZE,
+      period,
+      from,
+      to,
+      cursor,
+      direction,
+    }: ErrorGroupOptions
+  ) {
+    const displayableEnvironment = await findDisplayableEnvironment(environmentId, userId);
+
+    if (!displayableEnvironment) {
+      throw new ServiceValidationError("No environment found");
+    }
+
+    const time = timeFilterFromTo({
+      period,
+      from,
+      to,
+      defaultPeriod: "7d",
+    });
+
+    const summary = await this.getSummary(organizationId, projectId, environmentId, fingerprint);
+
+    const [affectedVersions, runList, stateRow] = await Promise.all([
+      this.getAffectedVersions(organizationId, projectId, environmentId, fingerprint),
+      this.getRunList(organizationId, environmentId, {
+        userId,
+        projectId,
+        fingerprint,
+        versions,
+        pageSize: runsPageSize,
+        from: time.from.getTime(),
+        to: time.to.getTime(),
+        cursor,
+        direction,
+      }),
+      this.getState(environmentId, summary?.taskIdentifier, fingerprint),
+    ]);
+
+    if (summary) {
+      summary.affectedVersions = affectedVersions;
+      summary.state = stateRow ?? {
+        status: "UNRESOLVED",
+        resolvedAt: null,
+        resolvedInVersion: null,
+        resolvedBy: null,
+        ignoredAt: null,
+        ignoredUntil: null,
+        ignoredReason: null,
+        ignoredByUserId: null,
+        ignoredByUserDisplayName: null,
+        ignoredUntilOccurrenceRate: null,
+        ignoredUntilTotalOccurrences: null,
+        ignoredAtOccurrenceCount: null,
+      };
+    }
+
+    return {
+      errorGroup: summary,
+      runList,
+      filters: {
+        from: time.from,
+        to: time.to,
+      },
+    };
+  }
+
+  /**
+   * Returns bucketed occurrence counts for a single fingerprint over a time range,
+   * grouped by task_version for stacked charts.
+   */
+  public async getOccurrences(
+    organizationId: string,
+    projectId: string,
+    environmentId: string,
+    fingerprint: string,
+    from: Date,
+    to: Date,
+    versions?: string[]
+  ): Promise<{
+    data: Array<Record<string, number | Date>>;
+    versions: string[];
+  }> {
+    const granularityMs = errorGroupGranularity.getTimeGranularityMs(from, to);
+    const intervalExpr = msToClickHouseInterval(granularityMs);
+
+    const queryBuilder =
+      this.logsClickhouse.errors.createOccurrencesByVersionQueryBuilder(intervalExpr);
+
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+    queryBuilder.where("error_fingerprint = {fingerprint: String}", { fingerprint });
+    queryBuilder.where("minute >= toStartOfMinute(fromUnixTimestamp64Milli({fromTimeMs: Int64}))", {
+      fromTimeMs: from.getTime(),
+    });
+    queryBuilder.where("minute <= toStartOfMinute(fromUnixTimestamp64Milli({toTimeMs: Int64}))", {
+      toTimeMs: to.getTime(),
+    });
+
+    if (versions && versions.length > 0) {
+      queryBuilder.where("task_version IN {versions: Array(String)}", { versions });
+    }
+
+    queryBuilder.groupBy("error_fingerprint, task_version, bucket_epoch");
+    queryBuilder.orderBy("bucket_epoch ASC");
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    // Build time buckets covering the full range
+    const buckets: number[] = [];
+    const startEpoch = Math.floor(from.getTime() / granularityMs) * (granularityMs / 1000);
+    const endEpoch = Math.ceil(to.getTime() / 1000);
+    for (let epoch = startEpoch; epoch <= endEpoch; epoch += granularityMs / 1000) {
+      buckets.push(epoch);
+    }
+
+    // Collect distinct versions and index results by (epoch, version)
+    const versionSet = new Set<string>();
+    const byBucketVersion = new Map<string, number>();
+    for (const row of records ?? []) {
+      const version = row.task_version || "unknown";
+      versionSet.add(version);
+      const key = `${row.bucket_epoch}:${version}`;
+      byBucketVersion.set(key, (byBucketVersion.get(key) ?? 0) + row.count);
+    }
+
+    const sortedVersions = sortVersionsDescending([...versionSet]);
+
+    const data = buckets.map((epoch) => {
+      const point: Record<string, number | Date> = { date: new Date(epoch * 1000) };
+      for (const version of sortedVersions) {
+        point[version] = byBucketVersion.get(`${epoch}:${version}`) ?? 0;
+      }
+      return point;
+    });
+
+    return { data, versions: sortedVersions };
+  }
+
+  private async getSummary(
+    organizationId: string,
+    projectId: string,
+    environmentId: string,
+    fingerprint: string
+  ): Promise<ErrorGroupSummary | undefined> {
+    const queryBuilder = this.logsClickhouse.errors.listQueryBuilder();
+
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+    queryBuilder.where("error_fingerprint = {fingerprint: String}", { fingerprint });
+
+    queryBuilder.groupBy("error_fingerprint, task_identifier");
+    queryBuilder.limit(1);
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    if (!records || records.length === 0) {
+      return undefined;
+    }
+
+    const record = records[0];
+    return {
+      fingerprint: record.error_fingerprint,
+      errorType: record.error_type,
+      errorMessage: record.error_message,
+      taskIdentifier: record.task_identifier,
+      count: record.occurrence_count,
+      firstSeen: parseClickHouseDateTime(record.first_seen),
+      lastSeen: parseClickHouseDateTime(record.last_seen),
+      affectedVersions: [],
+      state: {
+        status: "UNRESOLVED" as const,
+        resolvedAt: null,
+        resolvedInVersion: null,
+        resolvedBy: null,
+        ignoredAt: null,
+        ignoredUntil: null,
+        ignoredReason: null,
+        ignoredByUserId: null,
+        ignoredByUserDisplayName: null,
+        ignoredUntilOccurrenceRate: null,
+        ignoredUntilTotalOccurrences: null,
+        ignoredAtOccurrenceCount: null,
+      },
+    };
+  }
+
+  /**
+   * Returns the most recent distinct task_version values for an error fingerprint,
+   * sorted by semantic version descending (newest first).
+   * Queries error_occurrences_v1 where task_version is part of the ORDER BY key.
+   */
+  private async getAffectedVersions(
+    organizationId: string,
+    projectId: string,
+    environmentId: string,
+    fingerprint: string
+  ): Promise<string[]> {
+    const queryBuilder = this.logsClickhouse.errors.affectedVersionsQueryBuilder();
+
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+    queryBuilder.where("error_fingerprint = {fingerprint: String}", { fingerprint });
+    queryBuilder.where("task_version != ''");
+    queryBuilder.limit(100);
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError || !records) {
+      return [];
+    }
+
+    const versions = records.map((r) => r.task_version).filter((v) => v.length > 0);
+    return sortVersionsDescending(versions).slice(0, 5);
+  }
+
+  private async getState(
+    environmentId: string,
+    taskIdentifier: string | undefined,
+    fingerprint: string
+  ): Promise<ErrorGroupState | null> {
+    const row = await this.replica.errorGroupState.findFirst({
+      where: {
+        environmentId,
+        ...(taskIdentifier ? { taskIdentifier } : {}),
+        errorFingerprint: fingerprint,
+      },
+      select: {
+        status: true,
+        resolvedAt: true,
+        resolvedInVersion: true,
+        resolvedBy: true,
+        ignoredAt: true,
+        ignoredUntil: true,
+        ignoredReason: true,
+        ignoredByUserId: true,
+        ignoredUntilOccurrenceRate: true,
+        ignoredUntilTotalOccurrences: true,
+        ignoredAtOccurrenceCount: true,
+      },
+    });
+
+    if (!row) {
+      return null;
+    }
+
+    let ignoredByUserDisplayName: string | null = null;
+    if (row.ignoredByUserId) {
+      const user = await this.replica.user.findFirst({
+        where: { id: row.ignoredByUserId },
+        select: { displayName: true, name: true, email: true },
+      });
+      if (user) {
+        ignoredByUserDisplayName = user.displayName ?? user.name ?? user.email;
+      }
+    }
+
+    return {
+      status: row.status,
+      resolvedAt: row.resolvedAt,
+      resolvedInVersion: row.resolvedInVersion,
+      resolvedBy: row.resolvedBy,
+      ignoredAt: row.ignoredAt,
+      ignoredUntil: row.ignoredUntil,
+      ignoredReason: row.ignoredReason,
+      ignoredByUserId: row.ignoredByUserId,
+      ignoredByUserDisplayName,
+      ignoredUntilOccurrenceRate: row.ignoredUntilOccurrenceRate,
+      ignoredUntilTotalOccurrences: row.ignoredUntilTotalOccurrences,
+      ignoredAtOccurrenceCount: row.ignoredAtOccurrenceCount
+        ? Number(row.ignoredAtOccurrenceCount)
+        : null,
+    };
+  }
+
+  private async getRunList(
+    organizationId: string,
+    environmentId: string,
+    options: {
+      userId?: string;
+      projectId: string;
+      fingerprint: string;
+      versions?: string[];
+      pageSize: number;
+      from?: number;
+      to?: number;
+      cursor?: string;
+      direction?: Direction;
+    }
+  ): Promise<NextRunList | undefined> {
+    const runListPresenter = new NextRunListPresenter(this.replica, this.clickhouse);
+
+    const result = await runListPresenter.call(organizationId, environmentId, {
+      userId: options.userId,
+      projectId: options.projectId,
+      rootOnly: false,
+      errorId: ErrorId.toFriendlyId(options.fingerprint),
+      versions: options.versions,
+      pageSize: options.pageSize,
+      from: options.from,
+      to: options.to,
+      cursor: options.cursor,
+      direction: options.direction,
+    });
+
+    if (result.runs.length === 0) {
+      return undefined;
+    }
+
+    return result;
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/ErrorsListPresenter.server.ts b/apps/webapp/app/presenters/v3/ErrorsListPresenter.server.ts
new file mode 100644
index 00000000000..13da4ff91f8
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/ErrorsListPresenter.server.ts
@@ -0,0 +1,568 @@
+import { z } from "zod";
+import { type ClickHouse, msToClickHouseInterval } from "@internal/clickhouse";
+import { TimeGranularity } from "~/utils/timeGranularity";
+
+const errorsListGranularity = new TimeGranularity([
+  { max: "2h", granularity: "1m" },
+  { max: "2d", granularity: "1h" },
+  { max: "2w", granularity: "1d" },
+  { max: "3 months", granularity: "1w" },
+  { max: "Infinity", granularity: "30d" },
+]);
+import { type ErrorGroupStatus, type PrismaClientOrTransaction } from "@trigger.dev/database";
+import { type Direction } from "~/components/ListPagination";
+import { timeFilterFromTo } from "~/components/runs/v3/SharedFilters";
+import { findDisplayableEnvironment } from "~/models/runtimeEnvironment.server";
+import { getAllTaskIdentifiers } from "~/models/task.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { BasePresenter } from "~/presenters/v3/basePresenter.server";
+
+export type ErrorsListOptions = {
+  userId?: string;
+  projectId: string;
+  // filters
+  tasks?: string[];
+  versions?: string[];
+  statuses?: ErrorGroupStatus[];
+  period?: string;
+  from?: number;
+  to?: number;
+  defaultPeriod?: string;
+  retentionLimitDays?: number;
+  // search
+  search?: string;
+  // pagination
+  direction?: Direction;
+  cursor?: string;
+  pageSize?: number;
+};
+
+export const ErrorsListOptionsSchema = z.object({
+  userId: z.string().optional(),
+  projectId: z.string(),
+  tasks: z.array(z.string()).optional(),
+  versions: z.array(z.string()).optional(),
+  statuses: z.array(z.enum(["UNRESOLVED", "RESOLVED", "IGNORED"])).optional(),
+  period: z.string().optional(),
+  from: z.number().int().nonnegative().optional(),
+  to: z.number().int().nonnegative().optional(),
+  defaultPeriod: z.string().optional(),
+  retentionLimitDays: z.number().int().positive().optional(),
+  search: z.string().max(1000).optional(),
+  direction: z.enum(["forward", "backward"]).optional(),
+  cursor: z.string().optional(),
+  pageSize: z.number().int().positive().max(1000).optional(),
+});
+
+const DEFAULT_PAGE_SIZE = 25;
+
+export type ErrorsList = Awaited<ReturnType<ErrorsListPresenter["call"]>>;
+export type ErrorGroup = ErrorsList["errorGroups"][0];
+export type ErrorsListAppliedFilters = ErrorsList["filters"];
+export type ErrorOccurrences = Awaited<ReturnType<ErrorsListPresenter["getOccurrences"]>>;
+export type ErrorOccurrenceActivity = ErrorOccurrences["data"][string];
+
+type ErrorGroupCursor = {
+  occurrenceCount: number;
+  fingerprint: string;
+  taskIdentifier: string;
+};
+
+const ErrorGroupCursorSchema = z.object({
+  occurrenceCount: z.number(),
+  fingerprint: z.string(),
+  taskIdentifier: z.string(),
+});
+
+function encodeCursor(cursor: ErrorGroupCursor): string {
+  return Buffer.from(JSON.stringify(cursor)).toString("base64");
+}
+
+function decodeCursor(cursor: string): ErrorGroupCursor | null {
+  try {
+    const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+    const parsed = JSON.parse(decoded);
+    const validated = ErrorGroupCursorSchema.safeParse(parsed);
+    if (!validated.success) {
+      return null;
+    }
+    return validated.data as ErrorGroupCursor;
+  } catch {
+    return null;
+  }
+}
+
+function cursorFromRow(row: {
+  occurrence_count: number;
+  error_fingerprint: string;
+  task_identifier: string;
+}): string {
+  return encodeCursor({
+    occurrenceCount: row.occurrence_count,
+    fingerprint: row.error_fingerprint,
+    taskIdentifier: row.task_identifier,
+  });
+}
+
+function parseClickHouseDateTime(value: string): Date {
+  const asNum = Number(value);
+  if (!isNaN(asNum) && asNum > 1e12) {
+    return new Date(asNum);
+  }
+  return new Date(value.replace(" ", "T") + "Z");
+}
+
+function escapeClickHouseString(val: string): string {
+  return val.replace(/\\/g, "\\\\").replace(/\//g, "\\/").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+
+export class ErrorsListPresenter extends BasePresenter {
+  constructor(
+    private readonly replica: PrismaClientOrTransaction,
+    private readonly clickhouse: ClickHouse
+  ) {
+    super(undefined, replica);
+  }
+
+  public async call(
+    organizationId: string,
+    environmentId: string,
+    {
+      userId,
+      projectId,
+      tasks,
+      versions,
+      statuses,
+      period,
+      search,
+      from,
+      to,
+      direction,
+      cursor,
+      pageSize = DEFAULT_PAGE_SIZE,
+      defaultPeriod,
+      retentionLimitDays,
+    }: ErrorsListOptions
+  ) {
+    const time = timeFilterFromTo({
+      period,
+      from,
+      to,
+      defaultPeriod: defaultPeriod ?? "1d",
+    });
+
+    let effectiveFrom = time.from;
+    let effectiveTo = time.to;
+
+    let wasClampedByRetention = false;
+    if (retentionLimitDays !== undefined && effectiveFrom) {
+      const retentionCutoffDate = new Date(Date.now() - retentionLimitDays * 24 * 60 * 60 * 1000);
+
+      if (effectiveFrom < retentionCutoffDate) {
+        effectiveFrom = retentionCutoffDate;
+        wasClampedByRetention = true;
+      }
+    }
+
+    const hasFilters =
+      (tasks !== undefined && tasks.length > 0) ||
+      (versions !== undefined && versions.length > 0) ||
+      (search !== undefined && search !== "") ||
+      (statuses !== undefined && statuses.length > 0);
+
+    const possibleTasksAsync = getAllTaskIdentifiers(this.replica, environmentId);
+
+    // Pre-filter by status: since status lives in Postgres (ErrorGroupState) and the error
+    // list comes from ClickHouse, we resolve inclusion/exclusion sets upfront so that
+    // ClickHouse pagination operates on the correctly filtered dataset.
+    const statusFilterAsync = this.resolveStatusFilter(environmentId, statuses);
+
+    const [possibleTasks, displayableEnvironment, statusFilter] = await Promise.all([
+      possibleTasksAsync,
+      findDisplayableEnvironment(environmentId, userId),
+      statusFilterAsync,
+    ]);
+
+    if (!displayableEnvironment) {
+      throw new ServiceValidationError("No environment found");
+    }
+
+    if (statusFilter.empty) {
+      return {
+        errorGroups: [],
+        pagination: {
+          next: undefined,
+          previous: undefined,
+        },
+        filters: {
+          tasks,
+          versions,
+          statuses,
+          search,
+          period: time,
+          from: effectiveFrom,
+          to: effectiveTo,
+          hasFilters,
+          possibleTasks,
+          wasClampedByRetention,
+        },
+      };
+    }
+
+    // Query the per-minute error_occurrences_v1 table for time-scoped counts
+    const queryBuilder = this.clickhouse.errors.occurrencesListQueryBuilder();
+
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+
+    // Precise time range filtering via WHERE on the minute column
+    queryBuilder.where("minute >= toStartOfMinute(fromUnixTimestamp64Milli({fromTimeMs: Int64}))", {
+      fromTimeMs: effectiveFrom.getTime(),
+    });
+    queryBuilder.where("minute <= toStartOfMinute(fromUnixTimestamp64Milli({toTimeMs: Int64}))", {
+      toTimeMs: effectiveTo.getTime(),
+    });
+
+    if (tasks && tasks.length > 0) {
+      queryBuilder.where("task_identifier IN {tasks: Array(String)}", { tasks });
+    }
+
+    if (versions && versions.length > 0) {
+      queryBuilder.where("task_version IN {versions: Array(String)}", { versions });
+    }
+
+    if (statusFilter.includeKeys) {
+      queryBuilder.where(
+        "concat(task_identifier, '::', error_fingerprint) IN {statusIncludeKeys: Array(String)}",
+        { statusIncludeKeys: statusFilter.includeKeys }
+      );
+    }
+    if (statusFilter.excludeKeys) {
+      queryBuilder.where(
+        "concat(task_identifier, '::', error_fingerprint) NOT IN {statusExcludeKeys: Array(String)}",
+        { statusExcludeKeys: statusFilter.excludeKeys }
+      );
+    }
+
+    queryBuilder.groupBy("error_fingerprint, task_identifier");
+
+    // Text search via HAVING (operates on aggregated values)
+    if (search && search.trim() !== "") {
+      const searchTerm = escapeClickHouseString(search.trim()).toLowerCase();
+      queryBuilder.having(
+        "(lower(error_type) like {searchPattern: String} OR lower(error_message) like {searchPattern: String})",
+        {
+          searchPattern: `%${searchTerm}%`,
+        }
+      );
+    }
+
+    const isBackward = direction === "backward";
+    const decodedCursor = cursor ? decodeCursor(cursor) : null;
+
+    if (decodedCursor) {
+      const cmp = isBackward ? ">" : "<";
+      queryBuilder.having(
+        `(occurrence_count ${cmp} {cursorOccurrenceCount: UInt64}
+          OR (occurrence_count = {cursorOccurrenceCount: UInt64} AND error_fingerprint ${cmp} {cursorFingerprint: String})
+          OR (occurrence_count = {cursorOccurrenceCount: UInt64} AND error_fingerprint = {cursorFingerprint: String} AND task_identifier ${cmp} {cursorTaskIdentifier: String}))`,
+        {
+          cursorOccurrenceCount: decodedCursor.occurrenceCount,
+          cursorFingerprint: decodedCursor.fingerprint,
+          cursorTaskIdentifier: decodedCursor.taskIdentifier,
+        }
+      );
+    }
+
+    const sortDir = isBackward ? "ASC" : "DESC";
+    queryBuilder.orderBy(
+      `occurrence_count ${sortDir}, error_fingerprint ${sortDir}, task_identifier ${sortDir}`
+    );
+    queryBuilder.limit(pageSize + 1);
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    const results = records || [];
+    const hasMore = results.length > pageSize;
+    const page = results.slice(0, pageSize);
+
+    if (isBackward) {
+      page.reverse();
+    }
+
+    let nextCursor: string | undefined;
+    let previousCursor: string | undefined;
+
+    if (isBackward) {
+      previousCursor = hasMore && page.length > 0 ? cursorFromRow(page[0]) : undefined;
+      nextCursor = page.length > 0 ? cursorFromRow(page[page.length - 1]) : undefined;
+    } else {
+      previousCursor = decodedCursor && page.length > 0 ? cursorFromRow(page[0]) : undefined;
+      nextCursor = hasMore && page.length > 0 ? cursorFromRow(page[page.length - 1]) : undefined;
+    }
+
+    const errorGroups = page;
+
+    // Fetch global first_seen / last_seen from the errors_v1 summary table
+    const fingerprints = errorGroups.map((e) => e.error_fingerprint);
+    const [globalSummaryMap, stateMap] = await Promise.all([
+      this.getGlobalSummary(organizationId, projectId, environmentId, fingerprints),
+      this.getErrorGroupStates(environmentId, errorGroups),
+    ]);
+
+    let transformedErrorGroups = errorGroups.map((error) => {
+      const global = globalSummaryMap.get(error.error_fingerprint);
+      const state = stateMap.get(`${error.task_identifier}:${error.error_fingerprint}`);
+      return {
+        errorType: error.error_type,
+        errorMessage: error.error_message,
+        fingerprint: error.error_fingerprint,
+        taskIdentifier: error.task_identifier,
+        firstSeen: global?.firstSeen ?? new Date(),
+        lastSeen: global?.lastSeen ?? new Date(),
+        count: error.occurrence_count,
+        status: state?.status ?? "UNRESOLVED",
+        resolvedAt: state?.resolvedAt ?? null,
+        ignoredUntil: state?.ignoredUntil ?? null,
+      };
+    });
+
+    return {
+      errorGroups: transformedErrorGroups,
+      pagination: {
+        next: nextCursor,
+        previous: previousCursor,
+      },
+      filters: {
+        tasks,
+        versions,
+        statuses,
+        search,
+        period: time,
+        from: effectiveFrom,
+        to: effectiveTo,
+        hasFilters,
+        possibleTasks,
+        wasClampedByRetention,
+      },
+    };
+  }
+
+  /**
+   * Returns bucketed occurrence counts for the given fingerprints over a time range.
+   * Granularity is determined automatically from the range span.
+   */
+  public async getOccurrences(
+    organizationId: string,
+    projectId: string,
+    environmentId: string,
+    fingerprints: string[],
+    from: Date,
+    to: Date
+  ): Promise<{
+    data: Record<string, Array<{ date: Date; count: number }>>;
+  }> {
+    if (fingerprints.length === 0) {
+      return { data: {} };
+    }
+
+    const granularityMs = errorsListGranularity.getTimeGranularityMs(from, to);
+    const intervalExpr = msToClickHouseInterval(granularityMs);
+
+    const queryBuilder = this.clickhouse.errors.createOccurrencesQueryBuilder(intervalExpr);
+
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+    queryBuilder.where("error_fingerprint IN {fingerprints: Array(String)}", { fingerprints });
+    queryBuilder.where("minute >= toStartOfMinute(fromUnixTimestamp64Milli({fromTimeMs: Int64}))", {
+      fromTimeMs: from.getTime(),
+    });
+    queryBuilder.where("minute <= toStartOfMinute(fromUnixTimestamp64Milli({toTimeMs: Int64}))", {
+      toTimeMs: to.getTime(),
+    });
+
+    queryBuilder.groupBy("error_fingerprint, bucket_epoch");
+    queryBuilder.orderBy("error_fingerprint ASC, bucket_epoch ASC");
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    // Build time buckets covering the full range
+    const buckets: number[] = [];
+    const startEpoch = Math.floor(from.getTime() / granularityMs) * (granularityMs / 1000);
+    const endEpoch = Math.ceil(to.getTime() / 1000);
+    for (let epoch = startEpoch; epoch <= endEpoch; epoch += granularityMs / 1000) {
+      buckets.push(epoch);
+    }
+
+    // Index results by fingerprint -> epoch -> count
+    const grouped = new Map<string, Map<number, number>>();
+    for (const row of records ?? []) {
+      let byBucket = grouped.get(row.error_fingerprint);
+      if (!byBucket) {
+        byBucket = new Map();
+        grouped.set(row.error_fingerprint, byBucket);
+      }
+      byBucket.set(row.bucket_epoch, (byBucket.get(row.bucket_epoch) ?? 0) + row.count);
+    }
+
+    const data: Record<string, Array<{ date: Date; count: number }>> = {};
+    for (const fp of fingerprints) {
+      const byBucket = grouped.get(fp);
+      data[fp] = buckets.map((epoch) => ({
+        date: new Date(epoch * 1000),
+        count: byBucket?.get(epoch) ?? 0,
+      }));
+    }
+
+    return { data };
+  }
+
+  /**
+   * Determines which (task, fingerprint) pairs to include or exclude from the ClickHouse
+   * query based on the requested status filter. Since status lives in Postgres and errors
+   * live in ClickHouse, we resolve the filter set here so ClickHouse pagination is correct.
+   *
+   * - UNRESOLVED is the default (no ErrorGroupState row), so filtering FOR it means
+   *   excluding groups with non-matching explicit statuses.
+   * - RESOLVED/IGNORED are explicit, so filtering for them means including only matching groups.
+   */
+  private async resolveStatusFilter(
+    environmentId: string,
+    statuses?: ErrorGroupStatus[]
+  ): Promise<{
+    includeKeys?: string[];
+    excludeKeys?: string[];
+    empty: boolean;
+  }> {
+    if (!statuses || statuses.length === 0) {
+      return { empty: false };
+    }
+
+    const allStatuses: ErrorGroupStatus[] = ["UNRESOLVED", "RESOLVED", "IGNORED"];
+    const excludedStatuses = allStatuses.filter((s) => !statuses.includes(s));
+
+    if (excludedStatuses.length === 0) {
+      return { empty: false };
+    }
+
+    if (statuses.includes("UNRESOLVED")) {
+      const excluded = await this.replica.errorGroupState.findMany({
+        where: { environmentId, status: { in: excludedStatuses } },
+        select: { taskIdentifier: true, errorFingerprint: true },
+      });
+      if (excluded.length === 0) {
+        return { empty: false };
+      }
+      return {
+        excludeKeys: excluded.map((g) => `${g.taskIdentifier}::${g.errorFingerprint}`),
+        empty: false,
+      };
+    }
+
+    const included = await this.replica.errorGroupState.findMany({
+      where: { environmentId, status: { in: statuses } },
+      select: { taskIdentifier: true, errorFingerprint: true },
+    });
+    if (included.length === 0) {
+      return { empty: true };
+    }
+    return {
+      includeKeys: included.map((g) => `${g.taskIdentifier}::${g.errorFingerprint}`),
+      empty: false,
+    };
+  }
+
+  /**
+   * Batch-fetch ErrorGroupState rows from Postgres for the given ClickHouse error groups.
+   * Returns a map keyed by `${taskIdentifier}:${errorFingerprint}`.
+   */
+  private async getErrorGroupStates(
+    environmentId: string,
+    errorGroups: Array<{ task_identifier: string; error_fingerprint: string }>
+  ) {
+    type StateValue = {
+      status: ErrorGroupStatus;
+      resolvedAt: Date | null;
+      ignoredUntil: Date | null;
+    };
+
+    const result = new Map<string, StateValue>();
+    if (errorGroups.length === 0) return result;
+
+    const states = await this.replica.errorGroupState.findMany({
+      where: {
+        environmentId,
+        OR: errorGroups.map((e) => ({
+          taskIdentifier: e.task_identifier,
+          errorFingerprint: e.error_fingerprint,
+        })),
+      },
+      select: {
+        taskIdentifier: true,
+        errorFingerprint: true,
+        status: true,
+        resolvedAt: true,
+        ignoredUntil: true,
+      },
+    });
+
+    for (const state of states) {
+      result.set(`${state.taskIdentifier}:${state.errorFingerprint}`, {
+        status: state.status,
+        resolvedAt: state.resolvedAt,
+        ignoredUntil: state.ignoredUntil,
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Fetches global first_seen / last_seen for a set of fingerprints from errors_v1.
+   */
+  private async getGlobalSummary(
+    organizationId: string,
+    projectId: string,
+    environmentId: string,
+    fingerprints: string[]
+  ): Promise<Map<string, { firstSeen: Date; lastSeen: Date }>> {
+    const result = new Map<string, { firstSeen: Date; lastSeen: Date }>();
+    if (fingerprints.length === 0) return result;
+
+    const queryBuilder = this.clickhouse.errors.listQueryBuilder();
+    queryBuilder.where("organization_id = {organizationId: String}", { organizationId });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("environment_id = {environmentId: String}", { environmentId });
+    queryBuilder.where("error_fingerprint IN {fingerprints: Array(String)}", { fingerprints });
+    queryBuilder.groupBy("error_fingerprint, task_identifier");
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError || !records) return result;
+
+    for (const record of records) {
+      const firstSeen = parseClickHouseDateTime(record.first_seen);
+      const lastSeen = parseClickHouseDateTime(record.last_seen);
+      const existing = result.get(record.error_fingerprint);
+
+      if (existing) {
+        if (firstSeen < existing.firstSeen) existing.firstSeen = firstSeen;
+        if (lastSeen > existing.lastSeen) existing.lastSeen = lastSeen;
+      } else {
+        result.set(record.error_fingerprint, { firstSeen, lastSeen });
+      }
+    }
+
+    return result;
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/LimitsPresenter.server.ts b/apps/webapp/app/presenters/v3/LimitsPresenter.server.ts
new file mode 100644
index 00000000000..cca3522dc4e
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/LimitsPresenter.server.ts
@@ -0,0 +1,524 @@
+import { Ratelimit } from "@upstash/ratelimit";
+import { RuntimeEnvironmentType } from "@trigger.dev/database";
+import { createHash } from "node:crypto";
+import { env } from "~/env.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+import {
+  RateLimiterConfig,
+  createLimiterFromConfig,
+  type RateLimitTokenBucketConfig,
+} from "~/services/authorizationRateLimitMiddleware.server";
+import { createRedisRateLimitClient, type Duration } from "~/services/rateLimiter.server";
+import { BasePresenter } from "./basePresenter.server";
+import { singleton } from "~/utils/singleton";
+import { logger } from "~/services/logger.server";
+import { CheckScheduleService } from "~/v3/services/checkSchedule.server";
+import { engine } from "~/v3/runEngine.server";
+import { getQueueSizeLimit, getQueueSizeLimitSource } from "~/v3/utils/queueLimits.server";
+
+// Create a singleton Redis client for rate limit queries
+const rateLimitRedisClient = singleton("rateLimitQueryRedisClient", () =>
+  createRedisRateLimitClient({
+    port: env.RATE_LIMIT_REDIS_PORT,
+    host: env.RATE_LIMIT_REDIS_HOST,
+    username: env.RATE_LIMIT_REDIS_USERNAME,
+    password: env.RATE_LIMIT_REDIS_PASSWORD,
+    tlsDisabled: env.RATE_LIMIT_REDIS_TLS_DISABLED === "true",
+    clusterMode: env.RATE_LIMIT_REDIS_CLUSTER_MODE_ENABLED === "1",
+  })
+);
+
+// Types for rate limit display
+export type RateLimitInfo = {
+  name: string;
+  description: string;
+  config: RateLimiterConfig;
+  currentTokens: number | null;
+};
+
+// Types for quota display
+export type QuotaInfo = {
+  name: string;
+  description: string;
+  limit: number | null;
+  currentUsage: number;
+  source: "default" | "plan" | "override";
+  canExceed?: boolean;
+  isUpgradable?: boolean;
+};
+
+// Types for feature flags
+export type FeatureInfo = {
+  name: string;
+  description: string;
+  enabled: boolean;
+  value?: string | number;
+};
+
+export type LimitsResult = {
+  rateLimits: {
+    api: RateLimitInfo;
+    batch: RateLimitInfo;
+  };
+  quotas: {
+    projects: QuotaInfo;
+    schedules: QuotaInfo | null;
+    teamMembers: QuotaInfo | null;
+    alerts: QuotaInfo | null;
+    branches: QuotaInfo | null;
+    logRetentionDays: QuotaInfo | null;
+    realtimeConnections: QuotaInfo | null;
+    batchProcessingConcurrency: QuotaInfo;
+    queueSize: QuotaInfo;
+    metricDashboards: QuotaInfo | null;
+    metricWidgetsPerDashboard: QuotaInfo | null;
+    queryPeriodDays: QuotaInfo | null;
+  };
+  features: {
+    hasStagingEnvironment: FeatureInfo;
+    support: FeatureInfo;
+    includedUsage: FeatureInfo;
+  };
+  planName: string | null;
+  organizationId: string;
+  isOnTopPlan: boolean;
+};
+
+export class LimitsPresenter extends BasePresenter {
+  public async call({
+    organizationId,
+    projectId,
+    environmentId,
+    environmentType,
+    environmentApiKey,
+  }: {
+    organizationId: string;
+    projectId: string;
+    environmentId: string;
+    environmentType: RuntimeEnvironmentType;
+    environmentApiKey: string;
+  }): Promise<LimitsResult> {
+    // Get organization with all limit-related fields
+    const organization = await this._replica.organization.findFirstOrThrow({
+      where: { id: organizationId },
+      select: {
+        id: true,
+        maximumConcurrencyLimit: true,
+        maximumProjectCount: true,
+        maximumDevQueueSize: true,
+        maximumDeployedQueueSize: true,
+        apiRateLimiterConfig: true,
+        batchRateLimitConfig: true,
+        batchQueueConcurrencyConfig: true,
+        _count: {
+          select: {
+            projects: {
+              where: { deletedAt: null },
+            },
+            members: true,
+          },
+        },
+      },
+    });
+
+    // Get current plan from billing service
+    const currentPlan = await getCurrentPlan(organizationId);
+    const limits = currentPlan?.v3Subscription?.plan?.limits;
+    const isOnTopPlan = currentPlan?.v3Subscription?.plan?.code === "v3_pro_1";
+
+    // Resolve rate limit configs (org override or default)
+    const apiRateLimitConfig = resolveApiRateLimitConfig(organization.apiRateLimiterConfig);
+    const batchRateLimitConfig = resolveBatchRateLimitConfig(organization.batchRateLimitConfig);
+
+    // Resolve batch concurrency config
+    const batchConcurrencyConfig = resolveBatchConcurrencyConfig(
+      organization.batchQueueConcurrencyConfig
+    );
+    const batchConcurrencySource = organization.batchQueueConcurrencyConfig
+      ? "override"
+      : "default";
+
+    // Get schedule count for this org
+    const scheduleCount = await CheckScheduleService.getUsedSchedulesCount({
+      prisma: this._replica,
+      projectId,
+    });
+
+    // Get alert channel count for this org
+    const alertChannelCount = await this._replica.projectAlertChannel.count({
+      where: {
+        projectId,
+      },
+    });
+
+    // Get active branches count for this org (uses @@index([organizationId]))
+    const activeBranchCount = await this._replica.runtimeEnvironment.count({
+      where: {
+        projectId,
+        branchName: {
+          not: null,
+        },
+        archivedAt: null,
+      },
+    });
+
+    // Get metric dashboard count for this org
+    const metricDashboardCount = await this._replica.metricsDashboard.count({
+      where: { organizationId },
+    });
+
+    // Get current rate limit tokens for this environment's API key
+    const apiRateLimitTokens = await getRateLimitRemainingTokens(
+      "api",
+      environmentApiKey,
+      apiRateLimitConfig
+    );
+    // Batch rate limiter uses environment ID directly (not hashed) with a different key prefix
+    const batchRateLimitTokens = await getBatchRateLimitRemainingTokens(
+      environmentId,
+      batchRateLimitConfig
+    );
+
+    // Get current queue size for this environment
+    // We need the runtime environment fields for the engine query
+    const runtimeEnv = await this._replica.runtimeEnvironment.findFirst({
+      where: { id: environmentId },
+      select: {
+        id: true,
+        maximumConcurrencyLimit: true,
+        concurrencyLimitBurstFactor: true,
+      },
+    });
+
+    let currentQueueSize = 0;
+    if (runtimeEnv) {
+      const engineEnv = {
+        id: runtimeEnv.id,
+        type: environmentType,
+        maximumConcurrencyLimit: runtimeEnv.maximumConcurrencyLimit,
+        concurrencyLimitBurstFactor: runtimeEnv.concurrencyLimitBurstFactor,
+        organization: { id: organizationId },
+        project: { id: projectId },
+      };
+      currentQueueSize = (await engine.lengthOfEnvQueue(engineEnv)) ?? 0;
+    }
+
+    // Get plan-level limits
+    const schedulesLimit = limits?.schedules?.number ?? null;
+    const teamMembersLimit = limits?.teamMembers?.number ?? null;
+    const alertsLimit = limits?.alerts?.number ?? null;
+    const branchesLimit = limits?.branches?.number ?? null;
+    const logRetentionDaysLimit = limits?.logRetentionDays?.number ?? null;
+    const realtimeConnectionsLimit = limits?.realtimeConcurrentConnections?.number ?? null;
+    const metricDashboardsLimit = limits?.metricDashboards?.number ?? null;
+    const metricWidgetsPerDashboardLimit = limits?.metricWidgetsPerDashboard?.number ?? null;
+    const queryPeriodDaysLimit = limits?.queryPeriodDays?.number ?? null;
+    const includedUsage = limits?.includedUsage ?? null;
+    const hasStagingEnvironment = limits?.hasStagingEnvironment ?? false;
+    const supportLevel = limits?.support ?? "community";
+
+    return {
+      isOnTopPlan,
+      rateLimits: {
+        api: {
+          name: "API rate limit",
+          description: "Rate limit for API requests (trigger, batch, etc.)",
+          config: apiRateLimitConfig,
+          currentTokens: apiRateLimitTokens,
+        },
+        batch: {
+          name: "Batch rate limit",
+          description: "Rate limit for batch trigger operations",
+          config: batchRateLimitConfig,
+          currentTokens: batchRateLimitTokens,
+        },
+      },
+      quotas: {
+        projects: {
+          name: "Projects",
+          description: "Maximum number of projects in this organization",
+          limit: organization.maximumProjectCount,
+          currentUsage: organization._count.projects,
+          source: "default",
+          isUpgradable: true,
+        },
+        schedules:
+          schedulesLimit !== null
+            ? {
+              name: "Schedules",
+              description: "Maximum number of schedules per project",
+              limit: schedulesLimit,
+              currentUsage: scheduleCount,
+              source: "plan",
+              canExceed: limits?.schedules?.canExceed,
+              isUpgradable: true,
+            }
+            : null,
+        teamMembers:
+          teamMembersLimit !== null
+            ? {
+              name: "Team members",
+              description: "Maximum number of team members in this organization",
+              limit: teamMembersLimit,
+              currentUsage: organization._count.members,
+              source: "plan",
+              canExceed: limits?.teamMembers?.canExceed,
+              isUpgradable: true,
+            }
+            : null,
+        alerts:
+          alertsLimit !== null
+            ? {
+              name: "Alert channels",
+              description: "Maximum number of alert channels per project",
+              limit: alertsLimit,
+              currentUsage: alertChannelCount,
+              source: "plan",
+              canExceed: limits?.alerts?.canExceed,
+              isUpgradable: true,
+            }
+            : null,
+        branches:
+          branchesLimit !== null
+            ? {
+              name: "Preview branches",
+              description: "Maximum number of active preview branches per project",
+              limit: branchesLimit,
+              currentUsage: activeBranchCount,
+              source: "plan",
+              canExceed: limits?.branches?.canExceed,
+              isUpgradable: true,
+            }
+            : null,
+        logRetentionDays:
+          logRetentionDaysLimit !== null
+            ? {
+              name: "Log retention",
+              description: "Number of days logs are retained",
+              limit: logRetentionDaysLimit,
+              currentUsage: 0, // Not applicable - this is a duration, not a count
+              source: "plan",
+            }
+            : null,
+        realtimeConnections:
+          realtimeConnectionsLimit !== null
+            ? {
+              name: "Realtime connections",
+              description: "Maximum concurrent Realtime connections",
+              limit: realtimeConnectionsLimit,
+              currentUsage: 0, // Would need to query realtime service for this
+              source: "plan",
+              canExceed: limits?.realtimeConcurrentConnections?.canExceed,
+              isUpgradable: true,
+            }
+            : null,
+        batchProcessingConcurrency: {
+          name: "Batch trigger processing concurrency",
+          description:
+            "When you send a batch trigger, we convert it into individual runs in parallel. This is the maximum number of batches being converted into runs at once. It does not limit how many batch runs can be executing.",
+          limit: batchConcurrencyConfig.processingConcurrency,
+          currentUsage: 0,
+          source: batchConcurrencySource,
+          canExceed: true,
+          isUpgradable: true,
+        },
+        queueSize: {
+          name: "Max queued runs",
+          description: "Maximum pending runs per individual queue in this environment",
+          limit: getQueueSizeLimit(environmentType, organization),
+          currentUsage: currentQueueSize,
+          source: getQueueSizeLimitSource(environmentType, organization),
+          isUpgradable: true,
+        },
+        metricDashboards:
+          metricDashboardsLimit !== null
+            ? {
+                name: "Metric dashboards",
+                description: "Maximum number of custom metric dashboards per organization",
+                limit: metricDashboardsLimit,
+                currentUsage: metricDashboardCount,
+                source: "plan",
+                canExceed: limits?.metricDashboards?.canExceed,
+                isUpgradable: true,
+              }
+            : null,
+        metricWidgetsPerDashboard:
+          metricWidgetsPerDashboardLimit !== null
+            ? {
+                name: "Charts per dashboard",
+                description: "Maximum number of charts per metrics dashboard",
+                limit: metricWidgetsPerDashboardLimit,
+                currentUsage: 0, // Varies per dashboard
+                source: "plan",
+                canExceed: limits?.metricWidgetsPerDashboard?.canExceed,
+                isUpgradable: true,
+              }
+            : null,
+        queryPeriodDays:
+          queryPeriodDaysLimit !== null
+            ? {
+                name: "Query period",
+                description: "Maximum number of days a query can look back",
+                limit: queryPeriodDaysLimit,
+                currentUsage: 0, // Not applicable - this is a duration, not a count
+                source: "plan",
+              }
+            : null,
+      },
+      features: {
+        hasStagingEnvironment: {
+          name: "Staging/Preview environments",
+          description: "Access to staging/preview environments for testing before production",
+          enabled: hasStagingEnvironment,
+        },
+        support: {
+          name: "Support level",
+          description: "Type of support available for your plan",
+          enabled: true,
+          value: supportLevel === "slack" ? "Slack" : "Community",
+        },
+        includedUsage: {
+          name: "Included compute",
+          description: "Monthly included compute credits",
+          enabled: includedUsage !== null && includedUsage > 0,
+          value: includedUsage ?? 0,
+        },
+      },
+      planName: currentPlan?.v3Subscription?.plan?.title ?? null,
+      organizationId,
+    };
+  }
+}
+
+function resolveApiRateLimitConfig(apiRateLimiterConfig?: unknown): RateLimiterConfig {
+  const defaultConfig: RateLimitTokenBucketConfig = {
+    type: "tokenBucket",
+    refillRate: env.API_RATE_LIMIT_REFILL_RATE,
+    interval: env.API_RATE_LIMIT_REFILL_INTERVAL as Duration,
+    maxTokens: env.API_RATE_LIMIT_MAX,
+  };
+
+  if (!apiRateLimiterConfig) {
+    return defaultConfig;
+  }
+
+  const parsed = RateLimiterConfig.safeParse(apiRateLimiterConfig);
+  if (!parsed.success) {
+    return defaultConfig;
+  }
+
+  return parsed.data;
+}
+
+function resolveBatchRateLimitConfig(batchRateLimitConfig?: unknown): RateLimiterConfig {
+  const defaultConfig: RateLimitTokenBucketConfig = {
+    type: "tokenBucket",
+    refillRate: env.BATCH_RATE_LIMIT_REFILL_RATE,
+    interval: env.BATCH_RATE_LIMIT_REFILL_INTERVAL as Duration,
+    maxTokens: env.BATCH_RATE_LIMIT_MAX,
+  };
+
+  if (!batchRateLimitConfig) {
+    return defaultConfig;
+  }
+
+  const parsed = RateLimiterConfig.safeParse(batchRateLimitConfig);
+  if (!parsed.success) {
+    return defaultConfig;
+  }
+
+  return parsed.data;
+}
+
+function resolveBatchConcurrencyConfig(batchConcurrencyConfig?: unknown): {
+  processingConcurrency: number;
+} {
+  const defaultConfig = {
+    processingConcurrency: env.BATCH_CONCURRENCY_LIMIT_DEFAULT,
+  };
+
+  if (!batchConcurrencyConfig) {
+    return defaultConfig;
+  }
+
+  if (typeof batchConcurrencyConfig === "object" && batchConcurrencyConfig !== null) {
+    const config = batchConcurrencyConfig as Record<string, unknown>;
+    if (typeof config.processingConcurrency === "number") {
+      return { processingConcurrency: config.processingConcurrency };
+    }
+  }
+
+  return defaultConfig;
+}
+
+/**
+ * Query the current remaining tokens for a rate limiter using the Upstash getRemaining method.
+ * This uses the same configuration and hashing logic as the rate limit middleware.
+ */
+async function getRateLimitRemainingTokens(
+  keyPrefix: string,
+  apiKey: string,
+  config: RateLimiterConfig
+): Promise<number | null> {
+  try {
+    // Hash the authorization header the same way the rate limiter does
+    const authorizationValue = `Bearer ${apiKey}`;
+    const hash = createHash("sha256");
+    hash.update(authorizationValue);
+    const hashedKey = hash.digest("hex");
+
+    // Create a Ratelimit instance with the same configuration
+    const limiter = createLimiterFromConfig(config);
+    const ratelimit = new Ratelimit({
+      redis: rateLimitRedisClient,
+      limiter,
+      ephemeralCache: new Map(),
+      analytics: false,
+      prefix: `ratelimit:${keyPrefix}`,
+    });
+
+    // Use the getRemaining method to get the current remaining tokens
+    // getRemaining returns a Promise<number>
+    const remaining = await ratelimit.getRemaining(hashedKey);
+    return remaining;
+  } catch (error) {
+    logger.warn("Failed to get rate limit remaining tokens", {
+      keyPrefix,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+}
+
+/**
+ * Query the current remaining tokens for the batch rate limiter.
+ * The batch rate limiter uses environment ID directly (not hashed) and has a different key prefix.
+ */
+async function getBatchRateLimitRemainingTokens(
+  environmentId: string,
+  config: RateLimiterConfig
+): Promise<number | null> {
+  try {
+    // Create a Ratelimit instance with the same configuration as the batch rate limiter
+    const limiter = createLimiterFromConfig(config);
+    const ratelimit = new Ratelimit({
+      redis: rateLimitRedisClient,
+      limiter,
+      ephemeralCache: new Map(),
+      analytics: false,
+      // The batch rate limiter uses "ratelimit:batch" as keyPrefix in RateLimiter,
+      // which adds another "ratelimit:" prefix, resulting in "ratelimit:ratelimit:batch"
+      prefix: `ratelimit:ratelimit:batch`,
+    });
+
+    // Batch rate limiter uses environment ID directly (not hashed)
+    const remaining = await ratelimit.getRemaining(environmentId);
+    return remaining;
+  } catch (error) {
+    logger.warn("Failed to get batch rate limit remaining tokens", {
+      environmentId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/LogDetailPresenter.server.ts b/apps/webapp/app/presenters/v3/LogDetailPresenter.server.ts
new file mode 100644
index 00000000000..d354018b82e
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/LogDetailPresenter.server.ts
@@ -0,0 +1,108 @@
+import { type ClickHouse } from "@internal/clickhouse";
+import { type PrismaClientOrTransaction } from "@trigger.dev/database";
+import { convertClickhouseDateTime64ToJsDate } from "~/v3/eventRepository/clickhouseEventRepository.server";
+import { kindToLevel } from "~/utils/logUtils";
+import { getConfiguredEventRepository } from "~/v3/eventRepository/index.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+
+export type LogDetailOptions = {
+  environmentId: string;
+  organizationId: string;
+  projectId: string;
+  spanId: string;
+  traceId: string;
+  // The exact start_time from the log id - used to uniquely identify the event
+  startTime: string;
+};
+
+export type LogDetail = Awaited<ReturnType<LogDetailPresenter["call"]>>;
+
+export class LogDetailPresenter {
+  constructor(
+    private readonly replica: PrismaClientOrTransaction,
+    private readonly clickhouse: ClickHouse
+  ) {}
+
+  public async call(options: LogDetailOptions) {
+    const { environmentId, organizationId, projectId, spanId, traceId, startTime } = options;
+
+    // Determine which store to use based on organization configuration
+    const { store } = await getConfiguredEventRepository(organizationId);
+
+    // Throw error if postgres is detected
+    if (store === "postgres") {
+      throw new ServiceValidationError(
+        "Log details are not available for PostgreSQL event store. Please contact support."
+      );
+    }
+
+    const queryBuilder = this.clickhouse.taskEventsV2.logDetailQueryBuilder();
+
+    // Required filters - spanId, traceId, and startTime uniquely identify the log
+    // Multiple events can share the same spanId (span, span events, logs), so startTime is needed
+    queryBuilder.where("environment_id = {environmentId: String}", {
+      environmentId,
+    });
+    queryBuilder.where("organization_id = {organizationId: String}", {
+      organizationId,
+    });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+    queryBuilder.where("span_id = {spanId: String}", { spanId });
+    queryBuilder.where("trace_id = {traceId: String}", { traceId });
+    queryBuilder.where("start_time = {startTime: String}", { startTime });
+
+    queryBuilder.limit(1);
+
+    // Execute query
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    if (!records || records.length === 0) {
+      return null;
+    }
+
+    const log = records[0];
+
+
+    let parsedAttributes: Record<string, unknown> = {};
+    let rawAttributesString = "";
+
+
+    try {
+      // Handle attributes_text which is a string
+      if (log.attributes_text) {
+        parsedAttributes = JSON.parse(log.attributes_text) as Record<string, unknown>;
+        rawAttributesString = log.attributes_text;
+      }
+    } catch {
+      // Ignore parse errors
+    }
+
+    const durationMs = (typeof log.duration === "number" ? log.duration : Number(log.duration)) / 1_000_000;
+
+    return {
+      // Use :: separator to match LogsListPresenter format
+      id: `${log.trace_id}::${log.span_id}::${log.run_id}::${log.start_time}`,
+      runId: log.run_id,
+      taskIdentifier: log.task_identifier,
+      startTime: convertClickhouseDateTime64ToJsDate(log.start_time).toISOString(),
+      triggeredTimestamp: new Date(
+        convertClickhouseDateTime64ToJsDate(log.start_time).getTime() + durationMs
+      ).toISOString(),
+      traceId: log.trace_id,
+      spanId: log.span_id,
+      parentSpanId: log.parent_span_id || null,
+      message: log.message,
+      kind: log.kind,
+      status: log.status,
+      duration: typeof log.duration === "number" ? log.duration : Number(log.duration),
+      level: kindToLevel(log.kind, log.status),
+      attributes: parsedAttributes,
+      // Raw strings for display
+      rawAttributes: rawAttributesString,
+    };
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/LogsListPresenter.server.ts b/apps/webapp/app/presenters/v3/LogsListPresenter.server.ts
new file mode 100644
index 00000000000..8a3bf692b5b
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/LogsListPresenter.server.ts
@@ -0,0 +1,419 @@
+import { z } from "zod";
+import { type ClickHouse, type WhereCondition } from "@internal/clickhouse";
+import { type PrismaClientOrTransaction } from "@trigger.dev/database";
+import { EVENT_STORE_TYPES, getConfiguredEventRepository } from "~/v3/eventRepository/index.server";
+
+import parseDuration from "parse-duration";
+import { type Direction } from "~/components/ListPagination";
+import { timeFilterFromTo, timeFilters } from "~/components/runs/v3/SharedFilters";
+import { findDisplayableEnvironment } from "~/models/runtimeEnvironment.server";
+import { getAllTaskIdentifiers } from "~/models/task.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { kindToLevel, type LogLevel, LogLevelSchema } from "~/utils/logUtils";
+import { BasePresenter } from "~/presenters/v3/basePresenter.server";
+import {
+  convertDateToClickhouseDateTime,
+  convertClickhouseDateTime64ToJsDate,
+} from "~/v3/eventRepository/clickhouseEventRepository.server";
+
+export type { LogLevel };
+
+type ErrorAttributes = {
+  error?: {
+    message?: unknown;
+  };
+  [key: string]: unknown;
+};
+
+function escapeClickHouseString(val: string): string {
+  return val.replace(/\\/g, "\\\\").replace(/\//g, "\\/").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+
+export type LogsListOptions = {
+  userId?: string;
+  projectId: string;
+  // filters
+  tasks?: string[];
+  runId?: string;
+  period?: string;
+  from?: number;
+  to?: number;
+  levels?: LogLevel[];
+  defaultPeriod?: string;
+  retentionLimitDays?: number;
+  // search
+  search?: string;
+  // pagination
+  direction?: Direction;
+  cursor?: string;
+  pageSize?: number;
+};
+
+export const LogsListOptionsSchema = z.object({
+  userId: z.string().optional(),
+  projectId: z.string(),
+  tasks: z.array(z.string()).optional(),
+  runId: z.string().optional(),
+  period: z.string().optional(),
+  from: z.number().int().nonnegative().optional(),
+  to: z.number().int().nonnegative().optional(),
+  levels: z.array(LogLevelSchema).optional(),
+  defaultPeriod: z.string().optional(),
+  retentionLimitDays: z.number().int().positive().optional(),
+  search: z.string().max(1000).optional(),
+  direction: z.enum(["forward", "backward"]).optional(),
+  cursor: z.string().optional(),
+  pageSize: z.number().int().positive().max(1000).optional(),
+});
+
+const DEFAULT_PAGE_SIZE = 50;
+
+export type LogsList = Awaited<ReturnType<LogsListPresenter["call"]>>;
+export type LogEntry = LogsList["logs"][0];
+export type LogsListAppliedFilters = LogsList["filters"];
+
+// Cursor is a base64 encoded JSON of the pagination keys
+type LogCursor = {
+  organizationId: string;
+  environmentId: string;
+  triggeredTimestamp: string; // DateTime64(9) string
+  traceId: string;
+};
+
+const LogCursorSchema = z.object({
+  organizationId: z.string(),
+  environmentId: z.string(),
+  triggeredTimestamp: z.string(),
+  traceId: z.string(),
+});
+
+function encodeCursor(cursor: LogCursor): string {
+  return Buffer.from(JSON.stringify(cursor)).toString("base64");
+}
+
+function decodeCursor(cursor: string): LogCursor | null {
+  try {
+    const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+    const parsed = JSON.parse(decoded);
+    const validated = LogCursorSchema.safeParse(parsed);
+    if (!validated.success) {
+      return null;
+    }
+    return validated.data;
+  } catch {
+    return null;
+  }
+}
+
+// Convert display level to ClickHouse kinds and statuses
+function levelToKindsAndStatuses(level: LogLevel): { kinds?: string[]; statuses?: string[] } {
+  switch (level) {
+    case "TRACE":
+      return { kinds: ["SPAN"] };
+    case "DEBUG":
+      return { kinds: ["LOG_DEBUG"] };
+    case "INFO":
+      return { kinds: ["LOG_INFO", "LOG_LOG"] };
+    case "WARN":
+      return { kinds: ["LOG_WARN"] };
+    case "ERROR":
+      return { kinds: ["LOG_ERROR", "SPAN_EVENT"], statuses: ["ERROR"] };
+  }
+}
+
+export class LogsListPresenter extends BasePresenter {
+  constructor(
+    private readonly replica: PrismaClientOrTransaction,
+    private readonly clickhouse: ClickHouse
+  ) {
+    super(undefined, replica);
+  }
+
+  public async call(
+    organizationId: string,
+    environmentId: string,
+    {
+      userId,
+      projectId,
+      tasks,
+      runId,
+      period,
+      levels,
+      search,
+      from,
+      to,
+      cursor,
+      pageSize = DEFAULT_PAGE_SIZE,
+      defaultPeriod,
+      retentionLimitDays,
+    }: LogsListOptions
+  ) {
+    const time = timeFilterFromTo({
+      period,
+      from,
+      to,
+      defaultPeriod: defaultPeriod ?? "1h",
+    });
+
+    let effectiveFrom = time.from;
+    let effectiveTo = time.to;
+
+    // Apply retention limit if provided
+    let wasClampedByRetention = false;
+    if (retentionLimitDays !== undefined && effectiveFrom) {
+      const retentionCutoffDate = new Date(Date.now() - retentionLimitDays * 24 * 60 * 60 * 1000);
+
+      if (effectiveFrom < retentionCutoffDate) {
+        effectiveFrom = retentionCutoffDate;
+        wasClampedByRetention = true;
+      }
+    }
+
+    const hasFilters =
+      (tasks !== undefined && tasks.length > 0) ||
+      (runId !== undefined && runId !== "") ||
+      (levels !== undefined && levels.length > 0) ||
+      (search !== undefined && search !== "") ||
+      !time.isDefault;
+
+    const possibleTasksAsync = getAllTaskIdentifiers(this.replica, environmentId);
+
+    const bulkActionsAsync = this.replica.bulkActionGroup.findMany({
+      select: {
+        friendlyId: true,
+        type: true,
+        createdAt: true,
+        name: true,
+      },
+      where: {
+        projectId: projectId,
+        environmentId,
+      },
+      orderBy: {
+        createdAt: "desc",
+      },
+      take: 20,
+    });
+
+    const [possibleTasks, bulkActions, displayableEnvironment] = await Promise.all([
+      possibleTasksAsync,
+      bulkActionsAsync,
+      findDisplayableEnvironment(environmentId, userId),
+    ]);
+
+    if (!displayableEnvironment) {
+      throw new ServiceValidationError("No environment found");
+    }
+
+    // Determine which store to use based on organization configuration
+    const { store } = await getConfiguredEventRepository(organizationId);
+
+    // Throw error if postgres is detected
+    if (store === EVENT_STORE_TYPES.POSTGRES) {
+      throw new ServiceValidationError(
+        "Logs are not available for PostgreSQL event store. Please contact support."
+      );
+    }
+
+    if (store === EVENT_STORE_TYPES.CLICKHOUSE) {
+      throw new ServiceValidationError(
+        "Logs are not available for ClickHouse event store. Please contact support."
+      );
+    }
+
+    const queryBuilder = this.clickhouse.taskEventsSearch.logsListQueryBuilder();
+
+    // This should be removed once we clear the old inserts, 30 DAYS, the materialized view excludes events without trace_id)
+    queryBuilder.where("trace_id != ''", {
+      environmentId,
+    });
+
+    queryBuilder.where("environment_id = {environmentId: String}", {
+      environmentId,
+    });
+
+    queryBuilder.where("organization_id = {organizationId: String}", {
+      organizationId,
+    });
+    queryBuilder.where("project_id = {projectId: String}", { projectId });
+
+    if (effectiveFrom) {
+      queryBuilder.where("triggered_timestamp >= {triggeredAtStart: DateTime64(3)}", {
+        triggeredAtStart: convertDateToClickhouseDateTime(effectiveFrom),
+      });
+    }
+
+    if (effectiveTo) {
+      const clampedTo = effectiveTo > new Date() ? new Date() : effectiveTo;
+
+      queryBuilder.where("triggered_timestamp <= {triggeredAtEnd: DateTime64(3)}", {
+        triggeredAtEnd: convertDateToClickhouseDateTime(clampedTo),
+      });
+    }
+
+    // Task filter (applies directly to ClickHouse)
+    if (tasks && tasks.length > 0) {
+      queryBuilder.where("task_identifier IN {tasks: Array(String)}", {
+        tasks,
+      });
+    }
+
+    // Run ID filter
+    if (runId && runId !== "") {
+      queryBuilder.where("run_id = {runId: String}", { runId });
+    }
+
+    // Case-insensitive search in message, attributes, and status fields
+    if (search && search.trim() !== "") {
+      const searchTerm = escapeClickHouseString(search.trim()).toLowerCase();
+      queryBuilder.where(
+        "(lower(message) like {searchPattern: String} OR lower(attributes_text) like {searchPattern: String})",
+        {
+          searchPattern: `%${searchTerm}%`,
+        }
+      );
+    }
+
+    if (levels && levels.length > 0) {
+      const conditions: WhereCondition[] = [];
+
+      for (let i = 0; i < levels.length; i++) {
+        const filter = levelToKindsAndStatuses(levels[i]);
+
+        if (filter.kinds && filter.kinds.length > 0) {
+          conditions.push({
+            clause: `kind IN {kinds_${i}: Array(String)} AND status NOT IN {excluded_statuses: Array(String)}`,
+            params: {
+              [`kinds_${i}`]: filter.kinds,
+              excluded_statuses: ["ERROR", "CANCELLED"],
+            },
+          });
+        }
+
+        if (filter.statuses && filter.statuses.length > 0) {
+          conditions.push({
+            clause: `status IN {statuses_${i}: Array(String)}`,
+            params: { [`statuses_${i}`]: filter.statuses },
+          });
+        }
+      }
+
+      queryBuilder.whereOr(conditions);
+    }
+
+    // Cursor-based pagination using lexicographic comparison on (triggered_timestamp, trace_id).
+    // Since ORDER BY is DESC, "next page" means rows that sort *after* the cursor, i.e. less-than.
+    // The OR handles the tiebreaker: rows with an earlier timestamp always qualify, and rows
+    // with the *same* timestamp only qualify if their trace_id is also smaller.
+    // Equivalent to: WHERE (triggered_timestamp, trace_id) < (cursor.triggered_timestamp, cursor.trace_id)
+    const decodedCursor = cursor ? decodeCursor(cursor) : null;
+    if (decodedCursor) {
+      queryBuilder.where(
+        `(triggered_timestamp < {cursorTriggeredTimestamp: String} OR (triggered_timestamp = {cursorTriggeredTimestamp: String} AND trace_id < {cursorTraceId: String}))`,
+        {
+          cursorTriggeredTimestamp: decodedCursor.triggeredTimestamp,
+          cursorTraceId: decodedCursor.traceId,
+        }
+      );
+    }
+
+    queryBuilder.orderBy("triggered_timestamp DESC, trace_id DESC");
+    // Limit + 1 to check if there are more results
+    queryBuilder.limit(pageSize + 1);
+
+    const [queryError, records] = await queryBuilder.execute();
+
+    if (queryError) {
+      throw queryError;
+    }
+
+    const results = records || [];
+    const hasMore = results.length > pageSize;
+    const logs = results.slice(0, pageSize);
+
+    // Build next cursor from the last item
+    let nextCursor: string | undefined;
+    if (hasMore && logs.length > 0) {
+      const lastLog = logs[logs.length - 1];
+      nextCursor = encodeCursor({
+        organizationId,
+        environmentId,
+        triggeredTimestamp: lastLog.triggered_timestamp,
+        traceId: lastLog.trace_id,
+      });
+    }
+
+    // Transform results
+    // Use :: as separator since dash conflicts with date format in start_time
+    const transformedLogs = logs.map((log) => {
+      let displayMessage = log.message;
+
+      // For error logs with status ERROR, try to extract error message from attributes
+      if (log.status === "ERROR" && log.attributes_text) {
+        try {
+          const attributes = JSON.parse(log.attributes_text) as ErrorAttributes;
+
+          if (attributes?.error?.message && typeof attributes.error.message === "string") {
+            displayMessage = attributes.error.message;
+          }
+        } catch {
+          // If attributes parsing fails, use the regular message
+        }
+      }
+
+      return {
+        id: `${log.trace_id}::${log.span_id}::${log.run_id}::${log.start_time}`,
+        runId: log.run_id,
+        taskIdentifier: log.task_identifier,
+        startTime: convertClickhouseDateTime64ToJsDate(log.start_time).toISOString(),
+        triggeredTimestamp: convertClickhouseDateTime64ToJsDate(
+          log.triggered_timestamp
+        ).toISOString(),
+        traceId: log.trace_id,
+        spanId: log.span_id,
+        parentSpanId: log.parent_span_id || null,
+        message: displayMessage,
+        kind: log.kind,
+        status: log.status,
+        duration: typeof log.duration === "number" ? log.duration : Number(log.duration),
+        level: kindToLevel(log.kind, log.status),
+      };
+    });
+
+    return {
+      logs: transformedLogs,
+      pagination: {
+        next: nextCursor,
+        previous: undefined, // For now, only support forward pagination
+      },
+      possibleTasks: possibleTasks
+        .map((task) => ({
+          slug: task.slug,
+          triggerSource: task.triggerSource,
+        }))
+        .sort((a, b) => a.slug.localeCompare(b.slug)),
+      bulkActions: bulkActions.map((bulkAction) => ({
+        id: bulkAction.friendlyId,
+        type: bulkAction.type,
+        createdAt: bulkAction.createdAt,
+        name: bulkAction.name || bulkAction.friendlyId,
+      })),
+      filters: {
+        tasks: tasks || [],
+        levels: levels || [],
+        from: effectiveFrom,
+        to: effectiveTo,
+      },
+      hasFilters,
+      hasAnyLogs: transformedLogs.length > 0,
+      searchTerm: search,
+      retention:
+        retentionLimitDays !== undefined
+          ? {
+              limitDays: retentionLimitDays,
+              wasClamped: wasClampedByRetention,
+            }
+          : undefined,
+    };
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/MetricDashboardPresenter.server.ts b/apps/webapp/app/presenters/v3/MetricDashboardPresenter.server.ts
new file mode 100644
index 00000000000..dd2c58edb2e
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/MetricDashboardPresenter.server.ts
@@ -0,0 +1,127 @@
+import { BasePresenter } from "./basePresenter.server";
+import { type QueryScope } from "~/services/queryService.server";
+import { getLimit } from "~/services/platform.v3.server";
+import { z } from "zod";
+import { fromZodError } from "zod-validation-error";
+import { builtInDashboard } from "./BuiltInDashboards.server";
+import { QueryWidgetConfig } from "~/components/metrics/QueryWidget";
+
+export type MetricFilters = {
+  /** Org, project, environment */
+  scope: QueryScope;
+  /** Time filter settings */
+  filterPeriod: string | null;
+  filterFrom: Date | null;
+  filterTo: Date | null;
+  /** Tasks */
+  taskIdentifiers?: string[];
+  /** Queues */
+  queues?: string[];
+  /** Tags */
+  tags?: string[];
+};
+
+export const LayoutItem = z.object({
+  i: z.string(),
+  x: z.number(),
+  y: z.number(),
+  w: z.number(),
+  h: z.number(),
+  minH: z.number().optional(),
+  maxH: z.number().optional(),
+});
+
+export type LayoutItem = z.infer<typeof LayoutItem>;
+
+export const Widget = z.object({
+  title: z.string(),
+  query: z.string().default(""),
+  display: QueryWidgetConfig,
+});
+
+export type Widget = z.infer<typeof Widget>;
+
+export const DashboardLayout = z.discriminatedUnion("version", [
+  z.object({
+    version: z.literal("1"),
+    layout: z.array(LayoutItem),
+    widgets: z.record(Widget),
+  }),
+]);
+
+export type DashboardLayout = z.infer<typeof DashboardLayout>;
+
+export type CustomDashboard = {
+  friendlyId: string;
+  title: string;
+  layout: DashboardLayout;
+  defaultPeriod: string;
+};
+
+export type BuiltInDashboardFilter = "tasks" | "queues" | "models" | "prompts" | "operations" | "providers";
+
+export type BuiltInDashboard = {
+  key: string;
+  title: string;
+  layout: DashboardLayout;
+  /** Which filters to show in the toolbar. Defaults to ["tasks", "queues"] if not specified. */
+  filters?: BuiltInDashboardFilter[];
+};
+
+/** Returns the dashboard layout */
+export class MetricDashboardPresenter extends BasePresenter {
+  public async customDashboard({
+    friendlyId,
+    organizationId,
+  }: {
+    friendlyId: string;
+    organizationId: string;
+  }): Promise<CustomDashboard> {
+    const dashboard = await this._replica.metricsDashboard.findFirst({
+      where: { friendlyId, organizationId },
+    });
+    if (!dashboard) {
+      throw new Error("No dashboard found");
+    }
+
+    const layout = this.#getLayout(dashboard.layout);
+
+    const defaultPeriod = await getDashboardDefaultPeriod(organizationId);
+
+    return {
+      friendlyId: dashboard.friendlyId,
+      title: dashboard.title,
+      layout,
+      defaultPeriod,
+    };
+  }
+
+  public async builtInDashboard({ organizationId, key }: { organizationId: string; key: string }) {
+    const defaultPeriod = await getDashboardDefaultPeriod(organizationId);
+    const dashboard = builtInDashboard(key);
+    return {
+      ...dashboard,
+      defaultPeriod,
+    };
+  }
+
+  #getLayout(layoutData: string): DashboardLayout {
+    const json = JSON.parse(layoutData);
+    const parsedLayout = DashboardLayout.safeParse(json);
+    if (!parsedLayout.success) {
+      throw fromZodError(parsedLayout.error);
+    }
+
+    return parsedLayout.data;
+  }
+}
+
+/** Dashboard-specific default period (1 day), capped to the org's max query period */
+async function getDashboardDefaultPeriod(organizationId: string): Promise<string> {
+  const idealDefaultPeriodDays = 1;
+  const maxQueryPeriod = await getLimit(organizationId, "queryPeriodDays", 30);
+  if (maxQueryPeriod < idealDefaultPeriodDays) {
+    return `${maxQueryPeriod}d`;
+  }
+  return `${idealDefaultPeriodDays}d`;
+}
diff --git a/apps/webapp/app/presenters/v3/ModelRegistryPresenter.server.ts b/apps/webapp/app/presenters/v3/ModelRegistryPresenter.server.ts
new file mode 100644
index 00000000000..16a0aa75046
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/ModelRegistryPresenter.server.ts
@@ -0,0 +1,552 @@
+import { ClickHouse } from "@internal/clickhouse";
+import { modelCatalog } from "@internal/llm-model-catalog";
+import { PrismaClientOrTransaction } from "~/db.server";
+import { BasePresenter } from "./basePresenter.server";
+import { z } from "zod";
+
+/** Format a Date for ClickHouse DateTime64 string params. */
+function formatDateForCH(date: Date): string {
+  return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+}
+
+// --- Helpers ---
+
+/** Infer provider from model name when not stored in the DB. */
+function inferProvider(modelName: string): string {
+  const lower = modelName.toLowerCase();
+  // OpenAI
+  if (/^(gpt-|o[1-9]|chatgpt|davinci|babbage|curie|ada|text-embedding|text-davinci|text-ada|text-babbage|text-curie|ft:)/.test(lower)) return "openai";
+  // Anthropic
+  if (lower.startsWith("claude-")) return "anthropic";
+  // Google
+  if (/^(gemini-|palm-|text-bison|chat-bison|code-bison|codechat-bison|text-unicorn|textembedding-gecko)/.test(lower)) return "google";
+  // Meta
+  if (/^(llama|code-llama|codellama)/.test(lower)) return "meta";
+  // Mistral
+  if (/^(mistral|mixtral|codestral|pixtral|ministral)/.test(lower)) return "mistral";
+  // xAI
+  if (lower.startsWith("grok")) return "xai";
+  // DeepSeek
+  if (lower.startsWith("deepseek")) return "deepseek";
+  // Cohere
+  if (/^(command|embed-|rerank-)/.test(lower)) return "cohere";
+  // AI21
+  if (/^(jamba|j2-)/.test(lower)) return "ai21";
+  // Amazon
+  if (/^(amazon\.|titan)/.test(lower)) return "amazon";
+  // Qwen (Alibaba)
+  if (lower.startsWith("qwen")) return "qwen";
+  // Perplexity
+  if (/^(pplx-|sonar-)/.test(lower)) return "perplexity";
+  // Nous
+  if (lower.startsWith("nous-")) return "nous";
+  // Provider prefix format: "provider/model" (e.g. "openai/gpt-4o")
+  if (lower.includes("/")) {
+    return lower.split("/")[0];
+  }
+  return "unknown";
+}
+
+/** Format a model as provider:name (e.g. "openai:gpt-5"). */
+export function formatModelId(provider: string, modelName: string): string {
+  return `${provider}:${modelName}`;
+}
+
+// --- Types ---
+
+export type ModelCatalogItem = {
+  friendlyId: string;
+  modelName: string;
+  /** Always resolved — from DB, inferred from name, or "unknown". */
+  provider: string;
+  /** Display identifier in provider:name format (e.g. "openai:gpt-5"). */
+  displayId: string;
+  description: string | null;
+  contextWindow: number | null;
+  maxOutputTokens: number | null;
+  /** Combined capabilities (from DB) and boolean feature flags (from catalog) as slug strings. */
+  features: string[];
+  inputPrice: number | null;
+  outputPrice: number | null;
+  /** When the model was publicly released (from startDate on LlmModel). */
+  releaseDate: string | null;
+  /** Dated variants of this model (only populated on base models). */
+  variants: ModelVariant[];
+};
+
+export type ModelVariant = {
+  friendlyId: string;
+  modelName: string;
+  displayId: string;
+  releaseDate: string | null;
+};
+
+export type ModelCatalogGroup = {
+  provider: string;
+  models: ModelCatalogItem[];
+};
+
+export type ModelDetail = ModelCatalogItem & {
+  matchPattern: string;
+  source: string;
+  pricingTiers: Array<{
+    name: string;
+    isDefault: boolean;
+    prices: Record<string, number>;
+  }>;
+};
+
+function buildFeatures(
+  capabilities: string[],
+  catalogEntry: { supportsStructuredOutput: boolean; supportsParallelToolCalls: boolean; supportsStreamingToolCalls: boolean } | undefined
+): string[] {
+  const features = new Set(capabilities);
+  if (catalogEntry?.supportsStructuredOutput) features.add("structured_output");
+  if (catalogEntry?.supportsParallelToolCalls) features.add("parallel_tool_calls");
+  if (catalogEntry?.supportsStreamingToolCalls) features.add("streaming_tool_calls");
+  return Array.from(features);
+}
+
+export type ModelMetricsPoint = {
+  minute: string;
+  callCount: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCost: number;
+  ttfcP50: number;
+  ttfcP90: number;
+  ttfcP95: number;
+  ttfcP99: number;
+  tpsP50: number;
+  tpsP90: number;
+  tpsP95: number;
+  tpsP99: number;
+  durationP50: number;
+  durationP90: number;
+  durationP95: number;
+  durationP99: number;
+};
+
+export type UserModelMetrics = {
+  totalCalls: number;
+  totalCost: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  avgTtfc: number;
+  avgTps: number;
+  taskBreakdown: Array<{
+    taskIdentifier: string;
+    calls: number;
+    cost: number;
+  }>;
+};
+
+export type ModelComparisonItem = {
+  responseModel: string;
+  genAiSystem: string;
+  callCount: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCost: number;
+  ttfcP50: number;
+  ttfcP90: number;
+  tpsP50: number;
+  tpsP90: number;
+};
+
+export type PopularModel = {
+  responseModel: string;
+  genAiSystem: string;
+  callCount: number;
+  totalCost: number;
+  ttfcP50: number;
+};
+
+// --- ClickHouse schemas for user metrics ---
+
+const UserMetricsSummaryRow = z.object({
+  total_calls: z.coerce.number(),
+  total_cost: z.coerce.number(),
+  total_input_tokens: z.coerce.number(),
+  total_output_tokens: z.coerce.number(),
+  avg_ttfc: z.coerce.number(),
+  avg_tps: z.coerce.number(),
+});
+
+const UserTaskBreakdownRow = z.object({
+  task_identifier: z.string(),
+  calls: z.coerce.number(),
+  cost: z.coerce.number(),
+});
+
+// --- Presenter ---
+
+export class ModelRegistryPresenter extends BasePresenter {
+  private readonly clickhouse: ClickHouse;
+
+  constructor(clickhouse: ClickHouse, replica?: PrismaClientOrTransaction) {
+    super(undefined, replica);
+    this.clickhouse = clickhouse;
+  }
+
+  /** List all visible global models with pricing, grouped by provider. */
+  async getModelCatalog(): Promise<ModelCatalogGroup[]> {
+    const models = await this._replica.llmModel.findMany({
+      where: {
+        projectId: null,
+        isHidden: false,
+      },
+      include: {
+        pricingTiers: {
+          where: { isDefault: true },
+          include: { prices: true },
+          take: 1,
+        },
+      },
+      orderBy: { modelName: "asc" },
+    });
+
+    type CatalogItemWithBase = ModelCatalogItem & { _baseModelName: string | null };
+    const items: CatalogItemWithBase[] = models.map((m) => {
+      const defaultTier = m.pricingTiers[0];
+      const prices = defaultTier?.prices ?? [];
+      const inputPrice = prices.find((p) => p.usageType === "input");
+      const outputPrice = prices.find((p) => p.usageType === "output");
+      const provider = m.provider ?? inferProvider(m.modelName);
+      const catalogEntry = modelCatalog[m.modelName];
+
+      return {
+        friendlyId: m.friendlyId,
+        modelName: m.modelName,
+        provider,
+        displayId: formatModelId(provider, m.modelName),
+        description: m.description,
+        contextWindow: m.contextWindow,
+        maxOutputTokens: m.maxOutputTokens,
+        features: buildFeatures(m.capabilities, catalogEntry),
+        inputPrice: inputPrice ? Number(inputPrice.price) : null,
+        outputPrice: outputPrice ? Number(outputPrice.price) : null,
+        releaseDate: m.startDate ? m.startDate.toISOString().split("T")[0] : null,
+        variants: [],
+        _baseModelName: m.baseModelName,
+      };
+    });
+
+    // Normalize version dots for grouping: "3.5" → "3-5", "4.1" → "4-1"
+    const normalizeForGrouping = (name: string) => name.replace(/(\d)\.(\d)/g, "$1-$2");
+
+    // Group variants by their normalized base model name
+    const variantGroups = new Map<string, CatalogItemWithBase[]>();
+
+    for (const item of items) {
+      const groupKey = normalizeForGrouping(item._baseModelName ?? item.modelName);
+      const group = variantGroups.get(groupKey) ?? [];
+      group.push(item);
+      variantGroups.set(groupKey, group);
+    }
+
+    // For each group, pick the best representative as the "card" model
+    // and nest the rest as variants
+    const baseModels: ModelCatalogItem[] = [];
+
+    for (const [groupKey, group] of variantGroups) {
+      if (group.length === 1) {
+        // Standalone model, no variants
+        baseModels.push(group[0]);
+        continue;
+      }
+
+      // Pick representative: prefer the actual base model (no _baseModelName),
+      // then "-latest" variant, then the newest by release date
+      let representative = group.find((m) => !m._baseModelName)
+        ?? group.find((m) => m.modelName.endsWith("-latest"))
+        ?? group.sort((a, b) => {
+            if (!a.releaseDate && !b.releaseDate) return 0;
+            if (!a.releaseDate) return 1;
+            if (!b.releaseDate) return -1;
+            return b.releaseDate.localeCompare(a.releaseDate);
+          })[0];
+
+      // Nest the others as variants, sorted newest first
+      const others = group
+        .filter((m) => m !== representative)
+        .sort((a, b) => {
+          if (!a.releaseDate && !b.releaseDate) return a.modelName.localeCompare(b.modelName);
+          if (!a.releaseDate) return 1;
+          if (!b.releaseDate) return -1;
+          return b.releaseDate.localeCompare(a.releaseDate);
+        });
+
+      representative.variants = others.map((m) => ({
+        friendlyId: m.friendlyId,
+        modelName: m.modelName,
+        displayId: m.displayId,
+        releaseDate: m.releaseDate,
+      }));
+
+      baseModels.push(representative);
+    }
+
+    // Group by provider, sort models within each group by release date (newest first)
+    const groups = new Map<string, ModelCatalogItem[]>();
+    for (const item of baseModels) {
+      const group = groups.get(item.provider) ?? [];
+      group.push(item);
+      groups.set(item.provider, group);
+    }
+
+    return Array.from(groups.entries())
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([provider, models]) => ({
+        provider,
+        models: models.sort((a, b) => {
+          if (!a.releaseDate && !b.releaseDate) return a.modelName.localeCompare(b.modelName);
+          if (!a.releaseDate) return 1;
+          if (!b.releaseDate) return -1;
+          return b.releaseDate.localeCompare(a.releaseDate);
+        }),
+      }));
+  }
+
+  /** Get a single model with full pricing details. */
+  async getModelDetail(friendlyId: string): Promise<ModelDetail | null> {
+    const model = await this._replica.llmModel.findFirst({
+      where: { friendlyId },
+      include: {
+        pricingTiers: {
+          include: { prices: true },
+          orderBy: { priority: "asc" },
+        },
+      },
+    });
+
+    if (!model) return null;
+
+    const defaultTier = model.pricingTiers.find((t) => t.isDefault) ?? model.pricingTiers[0];
+    const defaultPrices = defaultTier?.prices ?? [];
+    const inputPrice = defaultPrices.find((p) => p.usageType === "input");
+    const outputPrice = defaultPrices.find((p) => p.usageType === "output");
+    const provider = model.provider ?? inferProvider(model.modelName);
+    const catalogEntry = modelCatalog[model.modelName];
+
+    return {
+      friendlyId: model.friendlyId,
+      modelName: model.modelName,
+      provider,
+      displayId: formatModelId(provider, model.modelName),
+      description: model.description,
+      contextWindow: model.contextWindow,
+      maxOutputTokens: model.maxOutputTokens,
+      features: buildFeatures(model.capabilities, catalogEntry),
+      inputPrice: inputPrice ? Number(inputPrice.price) : null,
+      outputPrice: outputPrice ? Number(outputPrice.price) : null,
+      releaseDate: model.startDate ? model.startDate.toISOString().split("T")[0] : null,
+      variants: [],
+      matchPattern: model.matchPattern,
+      source: model.source,
+      pricingTiers: model.pricingTiers.map((t) => ({
+        name: t.name,
+        isDefault: t.isDefault,
+        prices: Object.fromEntries(t.prices.map((p) => [p.usageType, Number(p.price)])),
+      })),
+    };
+  }
+
+  /** Get global aggregate metrics for a model (no tenant info). */
+  async getGlobalMetrics(
+    responseModel: string,
+    startTime: Date,
+    endTime: Date
+  ): Promise<ModelMetricsPoint[]> {
+    const [error, rows] = await this.clickhouse.llmModelAggregates.globalMetrics
+      .setParams({
+        responseModel,
+        startTime: formatDateForCH(startTime),
+        endTime: formatDateForCH(endTime),
+      })
+      .execute();
+
+    if (error || !rows) return [];
+
+    return rows.map((r) => ({
+      minute: r.minute,
+      callCount: r.call_count,
+      totalInputTokens: r.total_input_tokens,
+      totalOutputTokens: r.total_output_tokens,
+      totalCost: r.total_cost,
+      ttfcP50: r.ttfc_p50,
+      ttfcP90: r.ttfc_p90,
+      ttfcP95: r.ttfc_p95,
+      ttfcP99: r.ttfc_p99,
+      tpsP50: r.tps_p50,
+      tpsP90: r.tps_p90,
+      tpsP95: 0,
+      tpsP99: 0,
+      durationP50: r.duration_p50,
+      durationP90: r.duration_p90,
+      durationP95: 0,
+      durationP99: 0,
+    }));
+  }
+
+  /** Get per-project usage metrics for a model. */
+  async getUserMetrics(
+    responseModel: string,
+    projectId: string,
+    environmentId: string,
+    startTime: Date,
+    endTime: Date
+  ): Promise<UserModelMetrics> {
+    const summaryQuery = this.clickhouse.reader.query({
+      name: "modelRegistryUserSummary",
+      query: `
+        SELECT
+          count() AS total_calls,
+          sum(total_cost) AS total_cost,
+          sum(input_tokens) AS total_input_tokens,
+          sum(output_tokens) AS total_output_tokens,
+          round(avg(ms_to_first_chunk), 1) AS avg_ttfc,
+          round(avg(tokens_per_second), 1) AS avg_tps
+        FROM trigger_dev.llm_metrics_v1
+        WHERE response_model = {responseModel: String}
+          AND project_id = {projectId: String}
+          AND environment_id = {environmentId: String}
+          AND start_time >= {startTime: String}
+          AND start_time <= {endTime: String}
+      `,
+      params: z.object({
+        responseModel: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+        startTime: z.string(),
+        endTime: z.string(),
+      }),
+      schema: UserMetricsSummaryRow,
+    });
+
+    const taskQuery = this.clickhouse.reader.query({
+      name: "modelRegistryUserTasks",
+      query: `
+        SELECT
+          task_identifier,
+          count() AS calls,
+          sum(total_cost) AS cost
+        FROM trigger_dev.llm_metrics_v1
+        WHERE response_model = {responseModel: String}
+          AND project_id = {projectId: String}
+          AND environment_id = {environmentId: String}
+          AND start_time >= {startTime: String}
+          AND start_time <= {endTime: String}
+        GROUP BY task_identifier
+        ORDER BY cost DESC
+        LIMIT 20
+      `,
+      params: z.object({
+        responseModel: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+        startTime: z.string(),
+        endTime: z.string(),
+      }),
+      schema: UserTaskBreakdownRow,
+    });
+
+    const queryParams = {
+      responseModel,
+      projectId,
+      environmentId,
+      startTime: formatDateForCH(startTime),
+      endTime: formatDateForCH(endTime),
+    };
+
+    const [summaryResult, taskResult] = await Promise.all([
+      summaryQuery(queryParams),
+      taskQuery(queryParams),
+    ]);
+
+    const [summaryError, summaryRows] = summaryResult;
+    const [taskError, taskRows] = taskResult;
+
+    const defaultSummary = {
+      total_calls: 0,
+      total_cost: 0,
+      total_input_tokens: 0,
+      total_output_tokens: 0,
+      avg_ttfc: 0,
+      avg_tps: 0,
+    };
+
+    const summary = !summaryError && summaryRows?.[0] ? summaryRows[0] : defaultSummary;
+
+    return {
+      totalCalls: summary.total_calls,
+      totalCost: summary.total_cost,
+      totalInputTokens: summary.total_input_tokens,
+      totalOutputTokens: summary.total_output_tokens,
+      avgTtfc: summary.avg_ttfc,
+      avgTps: summary.avg_tps,
+      taskBreakdown: !taskError && taskRows
+        ? taskRows.map((r) => ({
+            taskIdentifier: r.task_identifier,
+            calls: r.calls,
+            cost: r.cost,
+          }))
+        : [],
+    };
+  }
+
+  /** Get comparison data for 2-4 models. */
+  async getModelComparison(
+    responseModels: string[],
+    startTime: Date,
+    endTime: Date
+  ): Promise<ModelComparisonItem[]> {
+    const [error, rows] = await this.clickhouse.llmModelAggregates.comparison
+      .setParams({
+        responseModels,
+        startTime: formatDateForCH(startTime),
+        endTime: formatDateForCH(endTime),
+      })
+      .execute();
+
+    if (error || !rows) return [];
+
+    return rows.map((r) => ({
+      responseModel: r.response_model,
+      genAiSystem: r.gen_ai_system,
+      callCount: r.call_count,
+      totalInputTokens: r.total_input_tokens,
+      totalOutputTokens: r.total_output_tokens,
+      totalCost: r.total_cost,
+      ttfcP50: r.ttfc_p50,
+      ttfcP90: r.ttfc_p90,
+      tpsP50: r.tps_p50,
+      tpsP90: r.tps_p90,
+    }));
+  }
+
+  /** Get the most popular models by call count. */
+  async getPopularModels(
+    startTime: Date,
+    endTime: Date,
+    limit: number = 20
+  ): Promise<PopularModel[]> {
+    const [error, rows] = await this.clickhouse.llmModelAggregates.popular
+      .setParams({
+        startTime: formatDateForCH(startTime),
+        endTime: formatDateForCH(endTime),
+        limit,
+      })
+      .execute();
+
+    if (error || !rows) return [];
+
+    return rows.map((r) => ({
+      responseModel: r.response_model,
+      genAiSystem: r.gen_ai_system,
+      callCount: r.call_count,
+      totalCost: r.total_cost,
+      ttfcP50: r.ttfc_p50,
+    }));
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/NewAlertChannelPresenter.server.ts b/apps/webapp/app/presenters/v3/NewAlertChannelPresenter.server.ts
index 08bccc66ef7..bde51bda91f 100644
--- a/apps/webapp/app/presenters/v3/NewAlertChannelPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/NewAlertChannelPresenter.server.ts
@@ -20,6 +20,7 @@ export class NewAlertChannelPresenter extends BasePresenter {
       where: {
         service: "SLACK",
         organizationId: project.organizationId,
+        deletedAt: null,
       },
       orderBy: {
         createdAt: "desc",
diff --git a/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts b/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts
index 2375ea161a9..f22c7ccf340 100644
--- a/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts
@@ -33,6 +33,7 @@ export type RunListOptions = {
   runId?: string[];
   queues?: string[];
   machines?: MachinePresetName[];
+  errorId?: string;
   //pagination
   direction?: Direction;
   cursor?: string;
@@ -70,6 +71,7 @@ export class NextRunListPresenter {
       runId,
       queues,
       machines,
+      errorId,
       from,
       to,
       direction = "forward",
@@ -97,6 +99,7 @@ export class NextRunListPresenter {
       (runId !== undefined && runId.length > 0) ||
       (queues !== undefined && queues.length > 0) ||
       (machines !== undefined && machines.length > 0) ||
+      (errorId !== undefined && errorId !== "") ||
       typeof isTest === "boolean" ||
       rootOnly === true ||
       !time.isDefault;
@@ -182,6 +185,7 @@ export class NextRunListPresenter {
       bulkId,
       queues,
       machines,
+      errorId,
       page: {
         size: pageSize,
         cursor,
diff --git a/apps/webapp/app/presenters/v3/PromptPresenter.server.ts b/apps/webapp/app/presenters/v3/PromptPresenter.server.ts
new file mode 100644
index 00000000000..80b6af18a09
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/PromptPresenter.server.ts
@@ -0,0 +1,433 @@
+import { ClickHouse } from "@internal/clickhouse";
+import { PrismaClientOrTransaction } from "~/db.server";
+import { BasePresenter } from "./basePresenter.server";
+import { z } from "zod";
+
+const GenerationRowSchema = z.object({
+  run_id: z.string(),
+  span_id: z.string(),
+  operation_id: z.string(),
+  task_identifier: z.string(),
+  response_model: z.string(),
+  prompt_version: z.coerce.number(),
+  input_tokens: z.coerce.number(),
+  output_tokens: z.coerce.number(),
+  total_cost: z.coerce.number(),
+  duration_ms: z.coerce.number(),
+  started_at: z.string(),
+});
+
+export type GenerationRow = {
+  run_id: string;
+  span_id: string;
+  operation_id: string;
+  task_identifier: string;
+  response_model: string;
+  prompt_version: number;
+  input_tokens: number;
+  output_tokens: number;
+  total_cost: number;
+  duration_ms: number;
+  start_time: string;
+};
+
+export type GenerationsPagination = {
+  next?: string;
+};
+
+export class PromptPresenter extends BasePresenter {
+  private readonly clickhouse: ClickHouse;
+
+  constructor(clickhouse: ClickHouse, replica?: PrismaClientOrTransaction) {
+    super(undefined, replica);
+    this.clickhouse = clickhouse;
+  }
+
+  async listPrompts(projectId: string, environmentId: string) {
+    const prompts = await this._replica.prompt.findMany({
+      where: {
+        projectId,
+        runtimeEnvironmentId: environmentId,
+        archivedAt: null,
+      },
+      include: {
+        versions: {
+          where: {
+            labels: { hasSome: ["current", "override"] },
+          },
+          select: {
+            version: true,
+            labels: true,
+            model: true,
+          },
+        },
+      },
+      orderBy: { updatedAt: "desc" },
+    });
+
+    return prompts.map((p) => {
+      const currentVersion = p.versions.find((v) => v.labels.includes("current"));
+      const overrideVersion = p.versions.find((v) => v.labels.includes("override"));
+      const hasOverride = !!overrideVersion;
+
+      // Effective model: override > current version > prompt default
+      const effectiveModel =
+        overrideVersion?.model ?? currentVersion?.model ?? p.defaultModel;
+
+      return {
+        id: p.id,
+        friendlyId: p.friendlyId,
+        slug: p.slug,
+        description: p.description,
+        tags: p.tags,
+        defaultModel: effectiveModel,
+        currentVersion: currentVersion ? { version: currentVersion.version } : null,
+        overrideVersion: overrideVersion ? { version: overrideVersion.version } : null,
+        hasOverride,
+        updatedAt: p.updatedAt,
+      };
+    });
+  }
+
+  async getUsageSparklines(
+    environmentId: string,
+    promptSlugs: string[]
+  ): Promise<Record<string, number[]>> {
+    if (promptSlugs.length === 0) return {};
+
+    const queryFn = this.clickhouse.reader.query({
+      name: "promptUsageSparklines",
+      query: `SELECT
+          prompt_slug,
+          toStartOfHour(start_time) AS bucket,
+          count() AS cnt
+        FROM trigger_dev.llm_metrics_v1
+        WHERE environment_id = {environmentId: String}
+          AND prompt_slug IN {promptSlugs: Array(String)}
+          AND start_time >= now() - INTERVAL 24 HOUR
+        GROUP BY prompt_slug, bucket
+        ORDER BY prompt_slug, bucket`,
+      params: z.object({
+        environmentId: z.string(),
+        promptSlugs: z.array(z.string()),
+      }),
+      schema: z.object({
+        prompt_slug: z.string(),
+        bucket: z.string(),
+        cnt: z.coerce.number(),
+      }),
+    });
+
+    const [error, rows] = await queryFn({ environmentId, promptSlugs });
+    if (error) {
+      console.error("Prompt usage sparkline query failed:", error);
+      return {};
+    }
+
+    // Build a map of slug -> 24 hourly buckets (use UTC to match ClickHouse)
+    const now = new Date();
+    const startHour = new Date(Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate(),
+      now.getUTCHours() - 23,
+      0, 0, 0
+    ));
+
+    const bucketKeys: string[] = [];
+    for (let i = 0; i < 24; i++) {
+      const h = new Date(startHour.getTime() + i * 3600_000);
+      // Format to match ClickHouse's toStartOfHour output: "YYYY-MM-DD HH:MM:SS"
+      bucketKeys.push(
+        h.toISOString().slice(0, 13).replace("T", " ") + ":00:00"
+      );
+    }
+
+    // Index rows by slug+bucket for fast lookup
+    const rowMap = new Map<string, number>();
+    for (const row of rows) {
+      rowMap.set(`${row.prompt_slug}|${row.bucket}`, row.cnt);
+    }
+
+    const result: Record<string, number[]> = {};
+    for (const slug of promptSlugs) {
+      result[slug] = bucketKeys.map((key) => rowMap.get(`${slug}|${key}`) ?? 0);
+    }
+
+    return result;
+  }
+
+  async resolveVersion(
+    promptId: string,
+    options?: { version?: number; label?: string }
+  ) {
+    if (options?.version != null) {
+      return this._replica.promptVersion.findUnique({
+        where: {
+          promptId_version: {
+            promptId,
+            version: options.version,
+          },
+        },
+      });
+    }
+
+    // Check for override first — dashboard edits take precedence
+    const override = await this._replica.promptVersion.findFirst({
+      where: {
+        promptId,
+        labels: { has: "override" },
+      },
+      orderBy: { version: "desc" },
+    });
+
+    if (override) {
+      return override;
+    }
+
+    const label = options?.label ?? "current";
+    return this._replica.promptVersion.findFirst({
+      where: {
+        promptId,
+        labels: { has: label },
+      },
+      orderBy: { version: "desc" },
+    });
+  }
+
+  async listVersions(promptId: string, limit: number = 50) {
+    return this._replica.promptVersion.findMany({
+      where: { promptId },
+      orderBy: { version: "desc" },
+      take: limit,
+      select: {
+        id: true,
+        version: true,
+        labels: true,
+        source: true,
+        model: true,
+        textContent: true,
+        commitMessage: true,
+        contentHash: true,
+        createdAt: true,
+      },
+    });
+  }
+
+  async listGenerations(options: {
+    environmentId: string;
+    promptSlug: string;
+    promptVersions?: number[];
+    startTime: Date;
+    endTime: Date;
+    cursor?: string;
+    pageSize?: number;
+    responseModels?: string[];
+    operations?: string[];
+    providers?: string[];
+  }): Promise<{ generations: GenerationRow[]; pagination: GenerationsPagination }> {
+    const pageSize = options.pageSize ?? 25;
+    const decodedCursor = options.cursor ? decodeCursor(options.cursor) : null;
+
+    const cursorClause = decodedCursor
+      ? `AND (start_time < parseDateTimeBestEffort({cursorStartTime: String})
+             OR (start_time = parseDateTimeBestEffort({cursorStartTime: String})
+                 AND span_id < {cursorSpanId: String}))`
+      : "";
+
+    const versionClause = options.promptVersions?.length
+      ? `AND prompt_version IN {promptVersions: Array(UInt32)}`
+      : "";
+    const modelClause = options.responseModels?.length
+      ? `AND response_model IN {responseModels: Array(String)}`
+      : "";
+    const operationClause = options.operations?.length
+      ? `AND operation_id IN {operations: Array(String)}`
+      : "";
+    const providerClause = options.providers?.length
+      ? `AND gen_ai_system IN {providers: Array(String)}`
+      : "";
+
+    // Build a unique query name based on which optional filters are active
+    const filterKey = [
+      decodedCursor ? "c" : "",
+      options.promptVersions?.length ? "v" : "",
+      options.responseModels?.length ? "m" : "",
+      options.operations?.length ? "o" : "",
+      options.providers?.length ? "p" : "",
+    ].join("");
+
+    const queryFn = this.clickhouse.reader.query({
+      name: `promptGenerationsList${filterKey}`,
+      query: `SELECT
+          run_id, span_id, operation_id, task_identifier, response_model,
+          prompt_version,
+          input_tokens, output_tokens, total_cost,
+          duration / 1000000 AS duration_ms,
+          formatDateTime(start_time, '%Y-%m-%d %H:%i:%S') AS started_at
+        FROM trigger_dev.llm_metrics_v1
+        WHERE environment_id = {environmentId: String}
+          AND prompt_slug = {promptSlug: String}
+          ${versionClause}
+          AND start_time >= parseDateTimeBestEffort({startTime: String})
+          AND start_time <= parseDateTimeBestEffort({endTime: String})
+          ${cursorClause}
+          ${modelClause}
+          ${operationClause}
+          ${providerClause}
+        ORDER BY start_time DESC, span_id DESC
+        LIMIT {fetchLimit: UInt32}`,
+      params: z.object({
+        environmentId: z.string(),
+        promptSlug: z.string(),
+        startTime: z.string(),
+        endTime: z.string(),
+        fetchLimit: z.number(),
+        ...(decodedCursor
+          ? {
+              cursorStartTime: z.string(),
+              cursorSpanId: z.string(),
+            }
+          : {}),
+        ...(options.promptVersions?.length ? { promptVersions: z.array(z.number()) } : {}),
+        ...(options.responseModels?.length ? { responseModels: z.array(z.string()) } : {}),
+        ...(options.operations?.length ? { operations: z.array(z.string()) } : {}),
+        ...(options.providers?.length ? { providers: z.array(z.string()) } : {}),
+      }),
+      schema: GenerationRowSchema,
+    });
+
+    const queryParams: Record<string, unknown> = {
+      environmentId: options.environmentId,
+      promptSlug: options.promptSlug,
+      startTime: options.startTime.toISOString(),
+      endTime: options.endTime.toISOString(),
+      fetchLimit: pageSize + 1,
+    };
+
+    if (decodedCursor) {
+      queryParams.cursorStartTime = decodedCursor.startTime;
+      queryParams.cursorSpanId = decodedCursor.spanId;
+    }
+    if (options.promptVersions?.length) {
+      queryParams.promptVersions = options.promptVersions;
+    }
+    if (options.responseModels?.length) {
+      queryParams.responseModels = options.responseModels;
+    }
+    if (options.operations?.length) {
+      queryParams.operations = options.operations;
+    }
+    if (options.providers?.length) {
+      queryParams.providers = options.providers;
+    }
+
+    const [error, rows] = await queryFn(queryParams as any);
+
+    if (error) {
+      console.error("Prompt generations query failed:", error);
+      return { generations: [], pagination: {} };
+    }
+
+    const hasMore = rows.length > pageSize;
+    const pageRows = hasMore ? rows.slice(0, pageSize) : rows;
+
+    const generations: GenerationRow[] = pageRows.map((r) => ({
+      ...r,
+      start_time: r.started_at,
+    }));
+
+    const pagination: GenerationsPagination = {};
+    if (hasMore) {
+      const lastRow = pageRows[pageRows.length - 1];
+      pagination.next = encodeCursor(lastRow.started_at, lastRow.span_id);
+    }
+
+    return { generations, pagination };
+  }
+
+  async getDistinctPromptSlugs(
+    organizationId: string,
+    projectId: string,
+    environmentId: string
+  ): Promise<string[]> {
+    const queryFn = this.clickhouse.reader.query({
+      name: "getDistinctPromptSlugs",
+      query: `SELECT DISTINCT prompt_slug FROM trigger_dev.llm_metrics_v1 WHERE organization_id = {organizationId: String} AND project_id = {projectId: String} AND environment_id = {environmentId: String} AND prompt_slug != '' ORDER BY prompt_slug`,
+      params: z.object({
+        organizationId: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+      }),
+      schema: z.object({ prompt_slug: z.string() }),
+    });
+
+    const [error, rows] = await queryFn({ organizationId, projectId, environmentId });
+    if (error) {
+      return [];
+    }
+    return rows.map((r) => r.prompt_slug);
+  }
+
+  async getDistinctOperations(
+    organizationId: string,
+    projectId: string,
+    environmentId: string
+  ): Promise<string[]> {
+    const queryFn = this.clickhouse.reader.query({
+      name: "getDistinctOperations",
+      query: `SELECT DISTINCT operation_id FROM trigger_dev.llm_metrics_v1 WHERE organization_id = {organizationId: String} AND project_id = {projectId: String} AND environment_id = {environmentId: String} AND operation_id != '' ORDER BY operation_id`,
+      params: z.object({
+        organizationId: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+      }),
+      schema: z.object({ operation_id: z.string() }),
+    });
+
+    const [error, rows] = await queryFn({ organizationId, projectId, environmentId });
+    if (error) {
+      return [];
+    }
+    return rows.map((r) => r.operation_id);
+  }
+
+  async getDistinctProviders(
+    organizationId: string,
+    projectId: string,
+    environmentId: string
+  ): Promise<string[]> {
+    const queryFn = this.clickhouse.reader.query({
+      name: "getDistinctProviders",
+      query: `SELECT DISTINCT gen_ai_system FROM trigger_dev.llm_metrics_v1 WHERE organization_id = {organizationId: String} AND project_id = {projectId: String} AND environment_id = {environmentId: String} AND gen_ai_system != '' ORDER BY gen_ai_system`,
+      params: z.object({
+        organizationId: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+      }),
+      schema: z.object({ gen_ai_system: z.string() }),
+    });
+
+    const [error, rows] = await queryFn({ organizationId, projectId, environmentId });
+    if (error) {
+      return [];
+    }
+    return rows.map((r) => r.gen_ai_system);
+  }
+}
+
+function encodeCursor(startTime: string, spanId: string): string {
+  return Buffer.from(JSON.stringify({ s: startTime, i: spanId })).toString("base64");
+}
+
+function decodeCursor(cursor: string): { startTime: string; spanId: string } | null {
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64").toString("utf-8")) as Record<string, unknown>;
+    if (typeof parsed.s === "string" && typeof parsed.i === "string") {
+      return { startTime: parsed.s, spanId: parsed.i };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
diff --git a/apps/webapp/app/presenters/v3/QueryPresenter.server.ts b/apps/webapp/app/presenters/v3/QueryPresenter.server.ts
new file mode 100644
index 00000000000..53ebb3ccdff
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/QueryPresenter.server.ts
@@ -0,0 +1,58 @@
+import { defaultQuery } from "~/v3/querySchemas";
+import { BasePresenter } from "./basePresenter.server";
+import type { QueryScope } from "~/services/queryService.server";
+
+export type QueryHistoryItem = {
+  id: string;
+  query: string;
+  scope: QueryScope;
+  createdAt: Date;
+  userName: string | null;
+  /** AI-generated title summarizing the query */
+  title: string | null;
+  /** Time filter settings */
+  filterPeriod: string | null;
+  filterFrom: Date | null;
+  filterTo: Date | null;
+};
+
+export class QueryPresenter extends BasePresenter {
+  public async call({ organizationId }: { organizationId: string }) {
+    const history = await this._replica.customerQuery.findMany({
+      where: { organizationId },
+      orderBy: { createdAt: "desc" },
+      take: 20,
+      select: {
+        id: true,
+        query: true,
+        scope: true,
+        title: true,
+        createdAt: true,
+        filterPeriod: true,
+        filterFrom: true,
+        filterTo: true,
+        user: {
+          select: { name: true, displayName: true },
+        },
+      },
+    });
+
+    return {
+      defaultQuery,
+      history: history.map(
+        (q): QueryHistoryItem => ({
+          id: q.id,
+          query: q.query,
+          scope: q.scope.toLowerCase() as QueryScope,
+          createdAt: q.createdAt,
+          userName: q.user?.displayName ?? q.user?.name ?? null,
+          title: q.title,
+          filterPeriod: q.filterPeriod,
+          filterFrom: q.filterFrom,
+          filterTo: q.filterTo,
+        })
+      ),
+    };
+  }
+}
+
diff --git a/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts b/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts
index c304597bb1f..f72b8d2fc53 100644
--- a/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts
@@ -1,6 +1,7 @@
 import { type Project } from "~/models/project.server";
 import { type User } from "~/models/user.server";
-import { FEATURE_FLAG, makeFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
 import { BasePresenter } from "./basePresenter.server";
 import { getCurrentPlan } from "~/services/platform.v3.server";
 
@@ -48,7 +49,7 @@ export class RegionsPresenter extends BasePresenter {
       throw new Error("Project not found");
     }
 
-    const getFlag = makeFlags(this._replica);
+    const getFlag = makeFlag(this._replica);
     const defaultWorkerInstanceGroupId = await getFlag({
       key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
     });
diff --git a/apps/webapp/app/presenters/v3/RunPresenter.server.ts b/apps/webapp/app/presenters/v3/RunPresenter.server.ts
index 437d6b64585..5e8dab2d0b6 100644
--- a/apps/webapp/app/presenters/v3/RunPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/RunPresenter.server.ts
@@ -209,6 +209,10 @@ export class RunPresenter {
     //we need the start offset for each item, and the total duration of the entire tree
     const treeRootStartTimeMs = tree ? tree?.data.startTime.getTime() : 0;
     let totalDuration = tree?.data.duration ?? 0;
+
+    // Build the linkedRunIdBySpanId map during the same walk
+    const linkedRunIdBySpanId: Record<string, string> = {};
+
     const events = tree
       ? flattenTree(tree).map((n) => {
           const offset = millisecondsToNanoseconds(
@@ -218,6 +222,12 @@ export class RunPresenter {
           if (!n.data.isDebug) {
             totalDuration = Math.max(totalDuration, offset + n.data.duration);
           }
+
+          // For cached spans, store the mapping from spanId to the linked run's ID
+          if (n.data.style?.icon === "task-cached" && n.runId) {
+            linkedRunIdBySpanId[n.id] = n.runId;
+          }
+
           return {
             ...n,
             data: {
@@ -260,6 +270,7 @@ export class RunPresenter {
           ? millisecondsToNanoseconds(run.startedAt.getTime() - run.createdAt.getTime())
           : undefined,
         overridesBySpanId: traceSummary.overridesBySpanId,
+        linkedRunIdBySpanId,
       },
       maximumLiveReloadingSetting: eventRepository.maximumLiveReloadingSetting,
     };
diff --git a/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts b/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts
index 9197b2c9d1a..1dd4edc6233 100644
--- a/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts
@@ -1,11 +1,12 @@
-import { TaskRun } from "@trigger.dev/database";
-import { eventStream } from "remix-utils/sse/server";
-import { PrismaClient, prisma } from "~/db.server";
+import { type PrismaClient, prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
+import { singleton } from "~/utils/singleton";
+import { createSSELoader, SendFunction } from "~/utils/sse";
 import { throttle } from "~/utils/throttle";
 import { tracePubSub } from "~/v3/services/tracePubSub.server";
 
-const pingInterval = 1000;
+const PING_INTERVAL = 5_000;
+const STREAM_TIMEOUT = 30_000;
 
 export class RunStreamPresenter {
   #prismaClient: PrismaClient;
@@ -14,105 +15,131 @@ export class RunStreamPresenter {
     this.#prismaClient = prismaClient;
   }
 
-  public async call({
-    request,
-    runFriendlyId,
-  }: {
-    request: Request;
-    runFriendlyId: TaskRun["friendlyId"];
-  }) {
-    const run = await this.#prismaClient.taskRun.findFirst({
-      where: {
-        friendlyId: runFriendlyId,
-      },
-      select: {
-        traceId: true,
-      },
-    });
-
-    if (!run) {
-      return new Response("Not found", { status: 404 });
-    }
-
-    logger.info("RunStreamPresenter.call", {
-      runFriendlyId,
-      traceId: run.traceId,
-    });
+  public createLoader() {
+    const prismaClient = this.#prismaClient;
 
-    let pinger: NodeJS.Timeout | undefined = undefined;
-
-    const { unsubscribe, eventEmitter } = await tracePubSub.subscribeToTrace(run.traceId);
-
-    return eventStream(request.signal, (send, close) => {
-      const safeSend = (args: { event?: string; data: string }) => {
-        try {
-          send(args);
-        } catch (error) {
-          if (error instanceof Error) {
-            if (error.name !== "TypeError") {
-              logger.debug("Error sending SSE, aborting", {
-                error: {
-                  name: error.name,
-                  message: error.message,
-                  stack: error.stack,
-                },
-                args,
-              });
-            }
-          } else {
-            logger.debug("Unknown error sending SSE, aborting", {
-              error,
-              args,
-            });
-          }
+    return createSSELoader({
+      timeout: STREAM_TIMEOUT,
+      interval: PING_INTERVAL,
+      handler: async (context) => {
+        const runFriendlyId = context.params.runParam;
 
-          close();
+        if (!runFriendlyId) {
+          throw new Response("Missing runParam", { status: 400 });
         }
-      };
 
-      const throttledSend = throttle(safeSend, 1000);
-
-      eventEmitter.addListener("message", (event) => {
-        throttledSend({ data: event });
-      });
+        const run = await prismaClient.taskRun.findFirst({
+          where: {
+            friendlyId: runFriendlyId,
+          },
+          select: {
+            traceId: true,
+          },
+        });
 
-      pinger = setInterval(() => {
-        if (request.signal.aborted) {
-          return close();
+        if (!run) {
+          throw new Response("Not found", { status: 404 });
         }
 
-        safeSend({ event: "ping", data: new Date().toISOString() });
-      }, pingInterval);
-
-      return function clear() {
-        logger.info("RunStreamPresenter.abort", {
+        logger.info("RunStreamPresenter.start", {
           runFriendlyId,
           traceId: run.traceId,
         });
 
-        clearInterval(pinger);
-
-        eventEmitter.removeAllListeners();
+        // Subscribe to trace updates
+        const { unsubscribe, eventEmitter } = await tracePubSub.subscribeToTrace(run.traceId);
+
+        // Only send max every 1 second
+        const throttledSend = throttle(
+          (args: { send: SendFunction; event?: string; data: string }) => {
+            try {
+              args.send({ event: args.event, data: args.data });
+            } catch (error) {
+              if (error instanceof Error) {
+                if (error.name !== "TypeError") {
+                  logger.debug("Error sending SSE in RunStreamPresenter", {
+                    error: {
+                      name: error.name,
+                      message: error.message,
+                      stack: error.stack,
+                    },
+                  });
+                }
+              }
+              // Abort the stream on send error
+              context.controller.abort("Send error");
+            }
+          },
+          1000
+        );
+
+        let messageListener: ((event: string) => void) | undefined;
+
+        return {
+          initStream: ({ send }) => {
+            // Create throttled send function
+            throttledSend({ send, event: "message", data: new Date().toISOString() });
+
+            // Set up message listener for pub/sub events
+            messageListener = (event: string) => {
+              throttledSend({ send, event: "message", data: event });
+            };
+            eventEmitter.addListener("message", messageListener);
+
+            context.debug("Subscribed to trace pub/sub");
+          },
+
+          iterator: ({ send }) => {
+            // Send ping to keep connection alive
+            try {
+              // Send an actual message so the client refreshes
+              throttledSend({ send, event: "message", data: new Date().toISOString() });
+            } catch (error) {
+              // If we can't send a ping, the connection is likely dead
+              return false;
+            }
+          },
 
-        unsubscribe()
-          .then(() => {
-            logger.info("RunStreamPresenter.abort.unsubscribe succeeded", {
-              runFriendlyId,
-              traceId: run.traceId,
-            });
-          })
-          .catch((error) => {
-            logger.error("RunStreamPresenter.abort.unsubscribe failed", {
+          cleanup: () => {
+            logger.info("RunStreamPresenter.cleanup", {
               runFriendlyId,
               traceId: run.traceId,
-              error: {
-                name: error.name,
-                message: error.message,
-                stack: error.stack,
-              },
             });
-          });
-      };
+
+            // Remove message listener
+            if (messageListener) {
+              eventEmitter.removeListener("message", messageListener);
+            }
+            eventEmitter.removeAllListeners();
+
+            // Unsubscribe from Redis pub/sub
+            unsubscribe()
+              .then(() => {
+                logger.info("RunStreamPresenter.cleanup.unsubscribe succeeded", {
+                  runFriendlyId,
+                  traceId: run.traceId,
+                });
+              })
+              .catch((error) => {
+                logger.error("RunStreamPresenter.cleanup.unsubscribe failed", {
+                  runFriendlyId,
+                  traceId: run.traceId,
+                  error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                  },
+                });
+              });
+          },
+        };
+      },
     });
   }
 }
+
+// Export a singleton loader for the route to use
+export const runStreamLoader = singleton("runStreamLoader", () => {
+  const presenter = new RunStreamPresenter();
+  return presenter.createLoader();
+});
diff --git a/apps/webapp/app/presenters/v3/ScheduleListPresenter.server.ts b/apps/webapp/app/presenters/v3/ScheduleListPresenter.server.ts
index 929e1e40ba9..053414dcfc7 100644
--- a/apps/webapp/app/presenters/v3/ScheduleListPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/ScheduleListPresenter.server.ts
@@ -96,7 +96,7 @@ export class ScheduleListPresenter extends BasePresenter {
 
     const schedulesCount = await CheckScheduleService.getUsedSchedulesCount({
       prisma: this._replica,
-      environments: project.environments,
+      projectId,
     });
 
     const limit = await getLimit(project.organizationId, "schedules", 100_000_000);
diff --git a/apps/webapp/app/presenters/v3/SpanPresenter.server.ts b/apps/webapp/app/presenters/v3/SpanPresenter.server.ts
index 4c0e3405cfd..0ea9b37ab7f 100644
--- a/apps/webapp/app/presenters/v3/SpanPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/SpanPresenter.server.ts
@@ -8,6 +8,10 @@ import {
   type V3TaskRunContext,
 } from "@trigger.dev/core/v3";
 import { AttemptId, getMaxDuration, parseTraceparent } from "@trigger.dev/core/v3/isomorphic";
+import {
+  extractIdempotencyKeyScope,
+  getUserProvidedIdempotencyKey,
+} from "@trigger.dev/core/v3/serverOnly";
 import { RUNNING_STATUSES } from "~/components/runs/v3/TaskRunStatus";
 import { logger } from "~/services/logger.server";
 import { rehydrateAttribute } from "~/v3/eventRepository/eventRepository.server";
@@ -20,6 +24,53 @@ import { engine } from "~/v3/runEngine.server";
 import { resolveEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { IEventRepository, SpanDetail } from "~/v3/eventRepository/eventRepository.types";
 import { safeJsonParse } from "~/utils/json";
+import {
+  extractAISpanData,
+  extractAISummarySpanData,
+  extractAIToolCallData,
+  extractAIEmbedData,
+} from "~/components/runs/v3/ai";
+
+export type PromptSpanData = {
+  slug: string;
+  version: number;
+  labels: string;
+  model?: string;
+  template?: string;
+  text?: string;
+  input?: string;
+  config?: string;
+};
+
+function extractPromptSpanData(
+  properties: Record<string, unknown>
+): PromptSpanData | undefined {
+  // Properties come as an unflattened nested object from ClickHouse,
+  // e.g. { prompt: { slug: "...", version: 3, ... } }
+  const prompt = properties.prompt;
+  if (!prompt || typeof prompt !== "object") {
+    return undefined;
+  }
+
+  const p = prompt as Record<string, unknown>;
+  const slug = p.slug;
+  const version = p.version;
+
+  if (typeof slug !== "string" || typeof version !== "number") {
+    return undefined;
+  }
+
+  return {
+    slug,
+    version,
+    labels: typeof p.labels === "string" ? p.labels : "",
+    model: typeof p.model === "string" ? p.model : undefined,
+    template: typeof p.template === "string" ? p.template : undefined,
+    text: typeof p.text === "string" ? p.text : undefined,
+    input: typeof p.input === "string" ? p.input : undefined,
+    config: typeof p.config === "string" ? p.config : undefined,
+  };
+}
 
 type Result = Awaited<ReturnType<SpanPresenter["call"]>>;
 export type Span = NonNullable<NonNullable<Result>["span"]>;
@@ -35,11 +86,13 @@ export class SpanPresenter extends BasePresenter {
     projectSlug,
     spanId,
     runFriendlyId,
+    linkedRunId,
   }: {
     userId: string;
     projectSlug: string;
     spanId: string;
     runFriendlyId: string;
+    linkedRunId?: string;
   }) {
     const project = await this._replica.project.findFirst({
       where: {
@@ -88,6 +141,7 @@ export class SpanPresenter extends BasePresenter {
       traceId,
       eventRepository,
       spanId,
+      linkedRunId,
       createdAt: parentRun.createdAt,
       completedAt: parentRun.completedAt,
       environmentId: parentRun.runtimeEnvironmentId,
@@ -126,6 +180,7 @@ export class SpanPresenter extends BasePresenter {
     traceId,
     eventRepository,
     spanId,
+    linkedRunId,
     createdAt,
     completedAt,
   }: {
@@ -134,19 +189,12 @@ export class SpanPresenter extends BasePresenter {
     traceId: string;
     eventRepository: IEventRepository;
     spanId: string;
+    linkedRunId?: string;
     createdAt: Date;
     completedAt: Date | null;
   }) {
-    const originalRunId = await eventRepository.getSpanOriginalRunId(
-      eventStore,
-      environmentId,
-      spanId,
-      traceId,
-      createdAt,
-      completedAt ?? undefined
-    );
-
-    const run = await this.findRun({ originalRunId, spanId, environmentId });
+    // Use linkedRunId if provided (for cached spans), otherwise look up by spanId
+    const run = await this.findRun({ originalRunId: linkedRunId, spanId, environmentId });
 
     if (!run) {
       return;
@@ -232,8 +280,10 @@ export class SpanPresenter extends BasePresenter {
       isTest: run.isTest,
       replayedFromTaskRunFriendlyId: run.replayedFromTaskRunFriendlyId,
       environmentId: run.runtimeEnvironment.id,
-      idempotencyKey: run.idempotencyKey,
+      idempotencyKey: getUserProvidedIdempotencyKey(run),
       idempotencyKeyExpiresAt: run.idempotencyKeyExpiresAt,
+      idempotencyKeyScope: extractIdempotencyKeyScope(run),
+      idempotencyKeyStatus: this.getIdempotencyKeyStatus(run),
       debounce: run.debounce as { key: string; delay: string; createdAt: Date } | null,
       schedule: await this.resolveSchedule(run.scheduleId ?? undefined),
       queue: {
@@ -272,13 +322,37 @@ export class SpanPresenter extends BasePresenter {
       workerQueue: run.workerQueue,
       traceId: run.traceId,
       spanId: run.spanId,
-      isCached: !!originalRunId,
+      isCached: !!linkedRunId,
       machinePreset: machine?.name,
       taskEventStore: run.taskEventStore,
       externalTraceId,
     };
   }
 
+  private getIdempotencyKeyStatus(run: {
+    idempotencyKey: string | null;
+    idempotencyKeyExpiresAt: Date | null;
+    idempotencyKeyOptions: unknown;
+  }): "active" | "inactive" | "expired" | undefined {
+    // No idempotency configured if no scope exists
+    const scope = extractIdempotencyKeyScope(run);
+    if (!scope) {
+      return undefined;
+    }
+
+    // Check if expired first (takes precedence)
+    if (run.idempotencyKeyExpiresAt && run.idempotencyKeyExpiresAt < new Date()) {
+      return "expired";
+    }
+
+    // Check if reset (hash is null but options exist)
+    if (run.idempotencyKey === null) {
+      return "inactive";
+    }
+
+    return "active";
+  }
+
   async resolveSchedule(scheduleId?: string) {
     if (!scheduleId) {
       return;
@@ -358,6 +432,7 @@ export class SpanPresenter extends BasePresenter {
         //idempotency
         idempotencyKey: true,
         idempotencyKeyExpiresAt: true,
+        idempotencyKeyOptions: true,
         //debounce
         debounce: true,
         //delayed
@@ -481,8 +556,7 @@ export class SpanPresenter extends BasePresenter {
         taskIdentifier: true,
         spanId: true,
         createdAt: true,
-        number: true,
-        taskVersion: true,
+        status: true,
       },
       where: {
         parentSpanId: spanId,
@@ -516,6 +590,13 @@ export class SpanPresenter extends BasePresenter {
       entity: span.entity,
       metadata: span.metadata,
       triggeredRuns,
+      aiData:
+        span.properties && typeof span.properties === "object"
+          ? extractAISpanData(
+              span.properties as Record<string, unknown>,
+              span.duration / 1_000_000
+            )
+          : undefined,
     };
 
     switch (span.entity.type) {
@@ -602,11 +683,182 @@ export class SpanPresenter extends BasePresenter {
           },
         };
       }
-      default:
+      case "input-stream": {
+        if (!span.entity.id) {
+          logger.error(`SpanPresenter: No input stream id`, {
+            spanId,
+            inputStreamId: span.entity.id,
+          });
+          return { ...data, entity: null };
+        }
+
+        const [runId, streamId] = span.entity.id.split(":");
+
+        if (!runId || !streamId) {
+          logger.error(`SpanPresenter: Invalid input stream id`, {
+            spanId,
+            inputStreamId: span.entity.id,
+          });
+          return { ...data, entity: null };
+        }
+
+        // Translate user-facing stream ID to internal S2 stream name
+        const s2StreamKey = `$trigger.input:${streamId}`;
+
+        return {
+          ...data,
+          entity: {
+            type: "realtime-stream" as const,
+            object: {
+              runId,
+              streamKey: s2StreamKey,
+              displayName: streamId,
+              metadata: undefined,
+            },
+          },
+        };
+      }
+      case "prompt": {
+        const promptData = extractPromptSpanData(span.properties as Record<string, unknown>);
+
+        if (promptData) {
+          return {
+            ...data,
+            entity: { type: "prompt" as const, object: promptData },
+          };
+        }
+
+        return { ...data, entity: null };
+      }
+      default: {
+        // Check for top-level AI SDK parent spans by message name
+        const AI_SUMMARY_MESSAGES = [
+          "ai.generateText",
+          "ai.streamText",
+          "ai.generateObject",
+          "ai.streamObject",
+        ];
+
+        if (
+          typeof span.message === "string" &&
+          AI_SUMMARY_MESSAGES.includes(span.message)
+        ) {
+          const aiSummaryData = extractAISummarySpanData(
+            span.properties as Record<string, unknown>,
+            span.duration / 1_000_000
+          );
+          if (aiSummaryData) {
+            const promptVersionData = await this.#lookupPromptVersion(
+              aiSummaryData.promptSlug,
+              aiSummaryData.promptVersion,
+              aiSummaryData.promptLabels,
+              aiSummaryData.promptInput,
+              projectId,
+              environmentId
+            );
+            return {
+              ...data,
+              entity: {
+                type: "ai-summary" as const,
+                object: aiSummaryData,
+                promptVersionData,
+              },
+            };
+          }
+        }
+
+        if (span.message === "ai.toolCall") {
+          const toolCallData = extractAIToolCallData(
+            span.properties as Record<string, unknown>,
+            span.duration / 1_000_000
+          );
+          if (toolCallData) {
+            return {
+              ...data,
+              entity: { type: "ai-tool-call" as const, object: toolCallData },
+            };
+          }
+        }
+
+        if (span.message === "ai.embed") {
+          const embedData = extractAIEmbedData(
+            span.properties as Record<string, unknown>,
+            span.duration / 1_000_000
+          );
+          if (embedData) {
+            return {
+              ...data,
+              entity: { type: "ai-embed" as const, object: embedData },
+            };
+          }
+        }
+
+        // Child generation spans (doGenerate/doStream) with gen_ai.* attributes
+        if (data.aiData) {
+          const promptVersionData = await this.#lookupPromptVersion(
+            data.aiData.promptSlug,
+            data.aiData.promptVersion,
+            data.aiData.promptLabels,
+            data.aiData.promptInput,
+            projectId,
+            environmentId
+          );
+          return {
+            ...data,
+            entity: {
+              type: "ai-generation" as const,
+              object: data.aiData,
+              promptVersionData,
+            },
+          };
+        }
         return { ...data, entity: null };
+      }
     }
   }
 
+  async #lookupPromptVersion(
+    promptSlug: string | undefined,
+    promptVersion: string | undefined,
+    promptLabels: string | undefined,
+    promptInput: string | undefined,
+    projectId: string,
+    environmentId: string
+  ): Promise<PromptSpanData | undefined> {
+    if (!promptSlug || !promptVersion) return undefined;
+
+    const prompt = await this._replica.prompt.findUnique({
+      where: {
+        projectId_runtimeEnvironmentId_slug: {
+          projectId,
+          runtimeEnvironmentId: environmentId,
+          slug: promptSlug,
+        },
+      },
+    });
+    if (!prompt) return undefined;
+
+    const version = await this._replica.promptVersion.findUnique({
+      where: {
+        promptId_version: {
+          promptId: prompt.id,
+          version: Number(promptVersion),
+        },
+      },
+    });
+    if (!version) return undefined;
+
+    return {
+      slug: promptSlug,
+      version: version.version,
+      labels: promptLabels ?? "",
+      model: version.model ?? undefined,
+      template: version.textContent ?? undefined,
+      text: undefined,
+      input: promptInput,
+    };
+  }
+
   async #getTaskRunContext({ run, machine }: { run: FindRunResult; machine?: MachinePreset }) {
     if (run.engine === "V1") {
       return this.#getV3TaskRunContext({ run, machine });
@@ -647,7 +899,7 @@ export class SpanPresenter extends BasePresenter {
         createdAt: run.createdAt,
         tags: run.runTags,
         isTest: run.isTest,
-        idempotencyKey: run.idempotencyKey ?? undefined,
+        idempotencyKey: getUserProvidedIdempotencyKey(run) ?? undefined,
         startedAt: run.startedAt ?? run.createdAt,
         durationMs: run.usageDurationMs,
         costInCents: run.costInCents,
diff --git a/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts b/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts
index 2817b7c8b8f..09abb22639e 100644
--- a/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts
+++ b/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts
@@ -6,6 +6,7 @@ import {
   type TaskRunTemplate,
   PrismaClientOrTransaction,
 } from "@trigger.dev/database";
+import { inferSchema } from "@jsonhero/schema-infer";
 import parse from "parse-duration";
 import { type PrismaClient } from "~/db.server";
 import { RunsRepository } from "~/services/runsRepository/runsRepository.server";
@@ -34,6 +35,8 @@ type Task = {
   taskIdentifier: string;
   filePath: string;
   friendlyId: string;
+  payloadSchema?: unknown;
+  inferredPayloadSchema?: unknown;
 };
 
 type Queue = {
@@ -244,11 +247,30 @@ export class TestTaskPresenter {
       },
     });
 
+    // Infer schema from existing run payloads when no explicit schema is defined
+    let inferredPayloadSchema: unknown | undefined;
+    if (!task.payloadSchema && latestRuns.length > 0 && task.triggerSource === "STANDARD") {
+      let inference: ReturnType<typeof inferSchema> | undefined;
+      for (const run of latestRuns) {
+        try {
+          const parsed = await parsePacket({ data: run.payload, dataType: run.payloadType });
+          inference = inferSchema(parsed, inference);
+        } catch {
+          // Skip malformed runs — inference is best-effort
+        }
+      }
+      if (inference) {
+        inferredPayloadSchema = inference.toJSONSchema();
+      }
+    }
+
     const taskWithEnvironment = {
       id: task.id,
       taskIdentifier: task.slug,
       filePath: task.filePath,
       friendlyId: task.friendlyId,
+      payloadSchema: task.payloadSchema ?? undefined,
+      inferredPayloadSchema,
     };
 
     switch (task.triggerSource) {
diff --git a/apps/webapp/app/presenters/v3/VercelSettingsPresenter.server.ts b/apps/webapp/app/presenters/v3/VercelSettingsPresenter.server.ts
new file mode 100644
index 00000000000..4a57e3ec0ef
--- /dev/null
+++ b/apps/webapp/app/presenters/v3/VercelSettingsPresenter.server.ts
@@ -0,0 +1,624 @@
+import { type PrismaClient } from "@trigger.dev/database";
+import { type Result, fromPromise, ok, okAsync, ResultAsync } from "neverthrow";
+import { env } from "~/env.server";
+import { logger } from "~/services/logger.server";
+import { OrgIntegrationRepository } from "~/models/orgIntegration.server";
+import {
+  VercelIntegrationRepository,
+  VercelCustomEnvironment,
+  VercelEnvironmentVariable,
+} from "~/models/vercelIntegration.server";
+import { type GitHubAppInstallation } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
+import { EnvironmentVariablesRepository } from "~/v3/environmentVariables/environmentVariablesRepository.server";
+import {
+  VercelProjectIntegrationDataSchema,
+  VercelProjectIntegrationData,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+import { BasePresenter } from "./basePresenter.server";
+
+type VercelSettingsOptions = {
+  projectId: string;
+  organizationId: string;
+};
+
+export type VercelSettingsResult = {
+  enabled: boolean;
+  hasOrgIntegration: boolean;
+  authInvalid?: boolean;
+  authError?: string;
+  connectedProject?: {
+    id: string;
+    vercelProjectId: string;
+    vercelProjectName: string;
+    vercelTeamId: string | null;
+    integrationData: VercelProjectIntegrationData;
+    createdAt: Date;
+  };
+  isGitHubConnected: boolean;
+  hasStagingEnvironment: boolean;
+  hasPreviewEnvironment: boolean;
+  customEnvironments: VercelCustomEnvironment[];
+  /** Whether autoAssignCustomDomains is enabled on the Vercel project. null if unknown. */
+  autoAssignCustomDomains?: boolean | null;
+  /** URL to manage Vercel integration access (project sharing) on vercel.com */
+  vercelManageAccessUrl?: string;
+};
+
+export type VercelAvailableProject = {
+  id: string;
+  name: string;
+};
+
+export type VercelOnboardingData = {
+  customEnvironments: VercelCustomEnvironment[];
+  environmentVariables: VercelEnvironmentVariable[];
+  availableProjects: VercelAvailableProject[];
+  hasProjectSelected: boolean;
+  authInvalid?: boolean;
+  authError?: string;
+  existingVariables: Record<string, { environments: string[] }>; // Environment slugs (non-archived only)
+  gitHubAppInstallations: GitHubAppInstallation[];
+  isGitHubConnected: boolean;
+  isOnboardingComplete: boolean;
+};
+
+export class VercelSettingsPresenter extends BasePresenter {
+  /**
+   * Get Vercel integration settings for the settings page
+   */
+  public async call({ projectId, organizationId }: VercelSettingsOptions): Promise<Result<VercelSettingsResult, unknown>> {
+    const vercelIntegrationEnabled = OrgIntegrationRepository.isVercelSupported;
+
+    if (!vercelIntegrationEnabled) {
+      return ok({
+        enabled: false,
+        hasOrgIntegration: false,
+        authInvalid: false,
+        connectedProject: undefined,
+        isGitHubConnected: false,
+        hasStagingEnvironment: false,
+        hasPreviewEnvironment: false,
+        customEnvironments: [],
+      } as VercelSettingsResult);
+    }
+
+    const orgIntegrationResult = await fromPromise(
+      (this._replica as PrismaClient).organizationIntegration.findFirst({
+        where: {
+          organizationId,
+          service: "VERCEL",
+          deletedAt: null,
+        },
+        include: {
+          tokenReference: true,
+        },
+      }),
+      (error) => error
+    );
+
+    if (orgIntegrationResult.isErr()) {
+      logger.error("Unexpected error in VercelSettingsPresenter.call", { error: orgIntegrationResult.error });
+      return ok({
+        enabled: true,
+        hasOrgIntegration: false,
+        authInvalid: true,
+        authError: orgIntegrationResult.error instanceof Error ? orgIntegrationResult.error.message : "Failed to fetch organization integration",
+        connectedProject: undefined,
+        isGitHubConnected: false,
+        hasStagingEnvironment: false,
+        hasPreviewEnvironment: false,
+        customEnvironments: [],
+      } as VercelSettingsResult);
+    }
+
+    const orgIntegration = orgIntegrationResult.value;
+    const hasOrgIntegration = orgIntegration !== null;
+
+    if (hasOrgIntegration) {
+      const tokenResult = await VercelIntegrationRepository.validateVercelToken(orgIntegration);
+      if (tokenResult.isErr() || !tokenResult.value.isValid) {
+        return ok({
+          enabled: true,
+          hasOrgIntegration: true,
+          authInvalid: true,
+          authError: tokenResult.isErr() ? tokenResult.error.message : "Vercel token is invalid",
+          connectedProject: undefined,
+          isGitHubConnected: false,
+          hasStagingEnvironment: false,
+          hasPreviewEnvironment: false,
+          customEnvironments: [],
+        } as VercelSettingsResult);
+      }
+    }
+
+    const checkOrgIntegration = () => fromPromise(
+      Promise.resolve(hasOrgIntegration),
+      (error) => ({
+        type: "other" as const,
+        cause: error,
+      })
+    );
+
+    const checkGitHubConnection = () =>
+      fromPromise(
+        (this._replica as PrismaClient).connectedGithubRepository.findFirst({
+          where: {
+            projectId,
+            repository: {
+              installation: {
+                deletedAt: null,
+                suspendedAt: null,
+              },
+            },
+          },
+          select: {
+            id: true,
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).map((repo) => repo !== null);
+
+    const checkStagingEnvironment = () =>
+      fromPromise(
+        (this._replica as PrismaClient).runtimeEnvironment.findFirst({
+          select: {
+            id: true,
+          },
+          where: {
+            projectId,
+            type: "STAGING",
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).map((env) => env !== null);
+
+    const checkPreviewEnvironment = () =>
+      fromPromise(
+        (this._replica as PrismaClient).runtimeEnvironment.findFirst({
+          select: {
+            id: true,
+          },
+          where: {
+            projectId,
+            type: "PREVIEW",
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).map((env) => env !== null);
+
+    const getVercelProjectIntegration = () =>
+      fromPromise(
+        (this._replica as PrismaClient).organizationProjectIntegration.findFirst({
+          where: {
+            projectId,
+            deletedAt: null,
+            organizationIntegration: {
+              service: "VERCEL",
+              deletedAt: null,
+            },
+          },
+          include: {
+            organizationIntegration: true,
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).map((integration) => {
+        if (!integration) {
+          return undefined;
+        }
+
+        const parsedData = VercelProjectIntegrationDataSchema.safeParse(
+          integration.integrationData
+        );
+
+        if (!parsedData.success) {
+          return undefined;
+        }
+
+        return {
+          id: integration.id,
+          vercelProjectId: integration.externalEntityId,
+          vercelProjectName: parsedData.data.vercelProjectName,
+          vercelTeamId: parsedData.data.vercelTeamId,
+          integrationData: parsedData.data,
+          createdAt: integration.createdAt,
+        };
+      });
+
+    return ResultAsync.combine([
+      checkOrgIntegration(),
+      checkGitHubConnection(),
+      checkStagingEnvironment(),
+      checkPreviewEnvironment(),
+      getVercelProjectIntegration(),
+    ]).andThen(([hasOrgIntegration, isGitHubConnected, hasStagingEnvironment, hasPreviewEnvironment, connectedProject]) => {
+        const fetchVercelData = async (): Promise<{
+          customEnvironments: VercelCustomEnvironment[];
+          autoAssignCustomDomains: boolean | null;
+          vercelManageAccessUrl?: string;
+        }> => {
+          if (!orgIntegration) {
+            return { customEnvironments: [], autoAssignCustomDomains: null };
+          }
+          const clientResult = await VercelIntegrationRepository.getVercelClient(orgIntegration);
+          if (clientResult.isErr()) {
+            return { customEnvironments: [], autoAssignCustomDomains: null };
+          }
+          const client = clientResult.value;
+          const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+          // Build manage access URL
+          let vercelManageAccessUrl: string | undefined;
+          const appSlug = env.VERCEL_INTEGRATION_APP_SLUG;
+          const integrationData = orgIntegration.integrationData as Record<string, unknown> | null;
+          const installationId =
+            typeof integrationData?.installationId === "string"
+              ? integrationData.installationId
+              : undefined;
+          if (appSlug && installationId && teamId) {
+            const teamSlugResult = await VercelIntegrationRepository.getTeamSlug(client, teamId);
+            if (teamSlugResult.isOk()) {
+              vercelManageAccessUrl = `https://vercel.com/${teamSlugResult.value}/~/integrations/${appSlug}/${installationId}`;
+            }
+          }
+
+          if (!connectedProject) {
+            return { customEnvironments: [], autoAssignCustomDomains: null, vercelManageAccessUrl };
+          }
+
+          const [customEnvsResult, autoAssignResult] = await Promise.all([
+            VercelIntegrationRepository.getVercelCustomEnvironments(
+              client,
+              connectedProject.vercelProjectId,
+              teamId
+            ),
+            VercelIntegrationRepository.getAutoAssignCustomDomains(
+              client,
+              connectedProject.vercelProjectId,
+              teamId
+            ),
+          ]);
+          return {
+            customEnvironments: customEnvsResult.isOk() ? customEnvsResult.value : [],
+            autoAssignCustomDomains: autoAssignResult.isOk() ? autoAssignResult.value : null,
+            vercelManageAccessUrl,
+          };
+        };
+
+        return fromPromise(
+          fetchVercelData(),
+          (error) => ({ type: "other" as const, cause: error })
+        ).map(({ customEnvironments, autoAssignCustomDomains, vercelManageAccessUrl }) => ({
+          enabled: true,
+          hasOrgIntegration,
+          authInvalid: false,
+          connectedProject,
+          isGitHubConnected,
+          hasStagingEnvironment,
+          hasPreviewEnvironment,
+          customEnvironments,
+          autoAssignCustomDomains,
+          vercelManageAccessUrl,
+        } as VercelSettingsResult));
+      }).mapErr((error) => {
+        // Log the error and return a safe fallback
+        logger.error("Error in VercelSettingsPresenter.call", { error });
+        return error;
+      });
+  }
+
+  /**
+   * Get data needed for the onboarding modal (custom environments and env vars)
+   */
+  public async getOnboardingData(
+    projectId: string,
+    organizationId: string,
+    vercelEnvironmentId?: string
+  ): Promise<VercelOnboardingData | null> {
+    const result = await ResultAsync.fromPromise(
+      (async (): Promise<VercelOnboardingData | null> => {
+        const [gitHubInstallations, connectedGitHubRepo] = await Promise.all([
+          (this._replica as PrismaClient).githubAppInstallation.findMany({
+            where: {
+              organizationId,
+              deletedAt: null,
+              suspendedAt: null,
+            },
+            select: {
+              id: true,
+              accountHandle: true,
+              targetType: true,
+              appInstallationId: true,
+              repositories: {
+                select: {
+                  id: true,
+                  name: true,
+                  fullName: true,
+                  htmlUrl: true,
+                  private: true,
+                },
+                take: 200,
+              },
+            },
+            take: 20,
+            orderBy: {
+              createdAt: "desc",
+            },
+          }),
+          (this._replica as PrismaClient).connectedGithubRepository.findFirst({
+            where: {
+              projectId,
+              repository: {
+                installation: {
+                  deletedAt: null,
+                  suspendedAt: null,
+                },
+              },
+            },
+            select: {
+              id: true,
+            },
+          }),
+        ]);
+
+        const isGitHubConnected = connectedGitHubRepo !== null;
+        const gitHubAppInstallations: GitHubAppInstallation[] = gitHubInstallations.map((installation) => ({
+          id: installation.id,
+          appInstallationId: installation.appInstallationId,
+          targetType: installation.targetType,
+          accountHandle: installation.accountHandle,
+          repositories: installation.repositories.map((repo) => ({
+            id: repo.id,
+            name: repo.name,
+            fullName: repo.fullName,
+            private: repo.private,
+            htmlUrl: repo.htmlUrl,
+          })),
+        }));
+
+        const orgIntegration = await (this._replica as PrismaClient).organizationIntegration.findFirst({
+          where: {
+            organizationId,
+            service: "VERCEL",
+            deletedAt: null,
+          },
+          include: {
+            tokenReference: true,
+          },
+        });
+
+        if (!orgIntegration) {
+          return null;
+        }
+
+        const tokenResult = await VercelIntegrationRepository.validateVercelToken(orgIntegration);
+        if (tokenResult.isErr() || !tokenResult.value.isValid) {
+          return {
+            customEnvironments: [],
+            environmentVariables: [],
+            availableProjects: [],
+            hasProjectSelected: false,
+            authInvalid: true,
+            authError: tokenResult.isErr() ? tokenResult.error.message : "Vercel token is invalid",
+            existingVariables: {},
+            gitHubAppInstallations,
+            isGitHubConnected,
+            isOnboardingComplete: false,
+          };
+        }
+
+        const clientResult = await VercelIntegrationRepository.getVercelClient(orgIntegration);
+        if (clientResult.isErr()) {
+          return {
+            customEnvironments: [],
+            environmentVariables: [],
+            availableProjects: [],
+            hasProjectSelected: false,
+            authInvalid: clientResult.error.authInvalid,
+            authError: clientResult.error.authInvalid ? clientResult.error.message : undefined,
+            existingVariables: {},
+            gitHubAppInstallations,
+            isGitHubConnected,
+            isOnboardingComplete: false,
+          };
+        }
+        const client = clientResult.value;
+        const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+        const projectIntegration = await (this._replica as PrismaClient).organizationProjectIntegration.findFirst({
+          where: {
+            projectId,
+            deletedAt: null,
+            organizationIntegration: {
+              service: "VERCEL",
+              deletedAt: null,
+            },
+          },
+        });
+
+        const availableProjectsResult = await VercelIntegrationRepository.getVercelProjects(client, teamId);
+
+        if (availableProjectsResult.isErr()) {
+          return {
+            customEnvironments: [],
+            environmentVariables: [],
+            availableProjects: [],
+            hasProjectSelected: false,
+            authInvalid: availableProjectsResult.error.authInvalid,
+            authError: availableProjectsResult.error.authInvalid ? availableProjectsResult.error.message : undefined,
+            existingVariables: {},
+            gitHubAppInstallations,
+            isGitHubConnected,
+            isOnboardingComplete: false,
+          };
+        }
+
+        if (!projectIntegration) {
+          return {
+            customEnvironments: [],
+            environmentVariables: [],
+            availableProjects: availableProjectsResult.value,
+            hasProjectSelected: false,
+            existingVariables: {},
+            gitHubAppInstallations,
+            isGitHubConnected,
+            isOnboardingComplete: false,
+          };
+        }
+
+        const [customEnvironmentsResult, projectEnvVarsResult, sharedEnvVarsResult] = await Promise.all([
+          VercelIntegrationRepository.getVercelCustomEnvironments(
+            client,
+            projectIntegration.externalEntityId,
+            teamId
+          ),
+          VercelIntegrationRepository.getVercelEnvironmentVariables(
+            client,
+            projectIntegration.externalEntityId,
+            teamId
+          ),
+        // Only fetch shared env vars if teamId is available
+          teamId
+            ? VercelIntegrationRepository.getVercelSharedEnvironmentVariables(
+                client,
+                teamId,
+                projectIntegration.externalEntityId
+              )
+            : okAsync([] as Array<{ id: string; key: string; type: string; isSecret: boolean; target: string[] }>),
+        ]);
+        const authInvalid =
+          (customEnvironmentsResult.isErr() && customEnvironmentsResult.error.authInvalid) ||
+          (projectEnvVarsResult.isErr() && projectEnvVarsResult.error.authInvalid) ||
+          (sharedEnvVarsResult.isErr() && sharedEnvVarsResult.error.authInvalid);
+
+        if (authInvalid) {
+          const authError =
+            (customEnvironmentsResult.isErr() && customEnvironmentsResult.error.authInvalid && customEnvironmentsResult.error.message) ||
+            (projectEnvVarsResult.isErr() && projectEnvVarsResult.error.authInvalid && projectEnvVarsResult.error.message) ||
+            (sharedEnvVarsResult.isErr() && sharedEnvVarsResult.error.authInvalid && sharedEnvVarsResult.error.message) ||
+            undefined;
+
+          return {
+            customEnvironments: [],
+            environmentVariables: [],
+            availableProjects: availableProjectsResult.value,
+            hasProjectSelected: true,
+            authInvalid: true,
+            authError: authError || undefined,
+            existingVariables: {},
+            gitHubAppInstallations,
+            isGitHubConnected,
+            isOnboardingComplete: false,
+          };
+        }
+
+        const customEnvironments = customEnvironmentsResult.isOk() ? customEnvironmentsResult.value : [];
+        const projectEnvVars = projectEnvVarsResult.isOk() ? projectEnvVarsResult.value : [];
+        const sharedEnvVars = sharedEnvVarsResult.isOk() ? sharedEnvVarsResult.value : [];
+
+        // Filter out TRIGGER_SECRET_KEY and TRIGGER_VERSION (managed by Trigger.dev) and merge project + shared env vars
+        const excludedKeys = new Set(["TRIGGER_SECRET_KEY", "TRIGGER_VERSION"]);
+        const projectEnvVarKeys = new Set(projectEnvVars.map((v) => v.key));
+        const mergedEnvVars: VercelEnvironmentVariable[] = [
+          ...projectEnvVars
+            .filter((v) => !excludedKeys.has(v.key))
+            .map((v) => {
+              const envVar = { ...v };
+              if (vercelEnvironmentId && (v as any).customEnvironmentIds?.includes(vercelEnvironmentId)) {
+                envVar.target = [...v.target, 'staging'];
+              }
+              return envVar;
+            }),
+          ...sharedEnvVars
+            .filter((v) => !projectEnvVarKeys.has(v.key) && !excludedKeys.has(v.key))
+            .map((v) => {
+              const envVar = {
+                id: v.id,
+                key: v.key,
+                type: v.type as VercelEnvironmentVariable["type"],
+                isSecret: v.isSecret,
+                target: v.target,
+                isShared: true,
+                customEnvironmentIds: [] as string[],
+              };
+              if (vercelEnvironmentId && (v as any).customEnvironmentIds?.includes(vercelEnvironmentId)) {
+                envVar.target = [...v.target, 'staging'];
+              }
+              return envVar;
+            }),
+        ];
+
+        const sortedEnvVars = [...mergedEnvVars].sort((a, b) =>
+          a.key.localeCompare(b.key)
+        );
+
+        const projectEnvs = await (this._replica as PrismaClient).runtimeEnvironment.findMany({
+          where: {
+            projectId,
+            archivedAt: null, // Filter out archived environments
+          },
+          select: {
+            id: true,
+            slug: true,
+            type: true,
+          },
+        });
+        const envIdToSlug = new Map(projectEnvs.map((e) => [e.id, e.slug]));
+        const activeEnvIds = new Set(projectEnvs.map((e) => e.id));
+
+        const envVarRepository = new EnvironmentVariablesRepository(this._replica as PrismaClient);
+        const existingVariables = await envVarRepository.getProject(projectId);
+        const existingVariablesRecord: Record<string, { environments: string[] }> = {};
+        for (const v of existingVariables) {
+          // Filter out archived environments and map to slugs
+          const activeEnvSlugs = v.values
+            .filter((val) => activeEnvIds.has(val.environment.id))
+            .map((val) => envIdToSlug.get(val.environment.id) || val.environment.type.toLowerCase());
+          if (activeEnvSlugs.length > 0) {
+            existingVariablesRecord[v.key] = {
+              environments: activeEnvSlugs,
+            };
+          }
+        }
+
+        const parsedIntegrationData = VercelProjectIntegrationDataSchema.safeParse(
+          projectIntegration.integrationData
+        );
+
+        return {
+          customEnvironments,
+          environmentVariables: sortedEnvVars,
+          availableProjects: availableProjectsResult.value,
+          hasProjectSelected: true,
+          existingVariables: existingVariablesRecord,
+          gitHubAppInstallations,
+          isGitHubConnected,
+          isOnboardingComplete: parsedIntegrationData.success
+            ? (parsedIntegrationData.data.onboardingCompleted ?? false)
+            : false,
+        };
+      })(),
+      (error) => error
+    );
+
+    if (result.isErr()) {
+      logger.error("Error in getOnboardingData", { error: result.error });
+      return null;
+    }
+
+    return result.value;
+  }
+
+}
\ No newline at end of file
diff --git a/apps/webapp/app/root.tsx b/apps/webapp/app/root.tsx
index fb5fef9c846..c6027b1a6d3 100644
--- a/apps/webapp/app/root.tsx
+++ b/apps/webapp/app/root.tsx
@@ -10,10 +10,12 @@ import { RouteErrorDisplay } from "./components/ErrorDisplay";
 import { AppContainer, MainCenteredContainer } from "./components/layout/AppLayout";
 import { ShortcutsProvider } from "./components/primitives/ShortcutsProvider";
 import { Toast } from "./components/primitives/Toast";
+import { TimezoneSetter } from "./components/TimezoneSetter";
 import { env } from "./env.server";
 import { featuresForRequest } from "./features.server";
 import { usePostHog } from "./hooks/usePostHog";
 import { getUser } from "./services/session.server";
+import { getTimezonePreference } from "./services/preferences/uiPreferences.server";
 import { appEnvTitleTag } from "./utils";
 
 export const links: LinksFunction = () => {
@@ -50,6 +52,7 @@ export const loader = async ({ request }: LoaderFunctionArgs) => {
   const toastMessage = session.get("toastMessage") as ToastMessage;
   const posthogProjectKey = env.POSTHOG_PROJECT_KEY;
   const features = featuresForRequest(request);
+  const timezone = await getTimezonePreference(request);
 
   const kapa = {
     websiteId: env.KAPA_AI_WEBSITE_ID,
@@ -65,6 +68,7 @@ export const loader = async ({ request }: LoaderFunctionArgs) => {
       appOrigin: env.APP_ORIGIN,
       triggerCliTag: env.TRIGGER_CLI_TAG,
       kapa,
+      timezone,
     },
     { headers: { "Set-Cookie": await commitSession(session) } }
   );
@@ -118,6 +122,7 @@ export default function App() {
         </head>
         <body className="h-full overflow-hidden bg-background-dimmed">
           <ShortcutsProvider>
+            <TimezoneSetter />
             <Outlet />
             <Toast />
           </ShortcutsProvider>
diff --git a/apps/webapp/app/routes/@.runs.$runParam.ts b/apps/webapp/app/routes/@.runs.$runParam.ts
new file mode 100644
index 00000000000..a52600628d8
--- /dev/null
+++ b/apps/webapp/app/routes/@.runs.$runParam.ts
@@ -0,0 +1,67 @@
+import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { requireUser } from "~/services/session.server";
+import { impersonate, rootPath, v3RunPath } from "~/utils/pathBuilder";
+
+const ParamsSchema = z.object({
+  runParam: z.string(),
+});
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const user = await requireUser(request);
+
+  const { runParam } = ParamsSchema.parse(params);
+
+  const isAdmin = user.admin || user.isImpersonating;
+
+  if (!isAdmin) {
+    return redirectWithErrorMessage(
+      rootPath(),
+      request,
+      "You're not an admin and cannot impersonate",
+      {
+        ephemeral: false,
+      }
+    );
+  }
+
+  const run = await prisma.taskRun.findFirst({
+    where: {
+      friendlyId: runParam,
+    },
+    select: {
+      runtimeEnvironment: {
+        select: {
+          slug: true,
+        },
+      },
+      project: {
+        select: {
+          slug: true,
+          organization: {
+            select: {
+              slug: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  if (!run) {
+    return redirectWithErrorMessage(rootPath(), request, "Run doesn't exist", {
+      ephemeral: false,
+    });
+  }
+
+  const path = v3RunPath(
+    { slug: run.project.organization.slug },
+    { slug: run.project.slug },
+    { slug: run.runtimeEnvironment.slug },
+    { friendlyId: runParam }
+  );
+
+  return redirect(impersonate(path));
+}
diff --git a/apps/webapp/app/routes/_app.@.orgs.$organizationSlug.$.ts b/apps/webapp/app/routes/_app.@.orgs.$organizationSlug.$.ts
index 9115c1b21af..b430b4a2195 100644
--- a/apps/webapp/app/routes/_app.@.orgs.$organizationSlug.$.ts
+++ b/apps/webapp/app/routes/_app.@.orgs.$organizationSlug.$.ts
@@ -7,6 +7,14 @@ import { requireUser } from "~/services/session.server";
 
 export async function loader({ request, params }: LoaderFunctionArgs) {
   const user = await requireUser(request);
+
+  // If already impersonating, we need to clear the impersonation
+  if (user.isImpersonating) {
+    const url = new URL(request.url);
+    return clearImpersonation(request, url.pathname);
+  }
+
+  // Only admins can impersonate
   if (!user.admin) {
     return redirect("/");
   }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.invite/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.invite/route.tsx
index 8f82153052d..44990abaa6e 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.invite/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.invite/route.tsx
@@ -1,6 +1,11 @@
 import { conform, list, requestIntent, useFieldList, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import { EnvelopeIcon, LockOpenIcon, UserPlusIcon } from "@heroicons/react/20/solid";
+import {
+  ArrowUpCircleIcon,
+  EnvelopeIcon,
+  LockOpenIcon,
+  UserPlusIcon,
+} from "@heroicons/react/20/solid";
 import type { ActionFunction, LoaderFunctionArgs } from "@remix-run/node";
 import { json } from "@remix-run/node";
 import { Form, useActionData } from "@remix-run/react";
@@ -29,6 +34,7 @@ import { TeamPresenter } from "~/presenters/TeamPresenter.server";
 import { scheduleEmail } from "~/services/email.server";
 import { requireUserId } from "~/services/session.server";
 import { acceptInvitePath, organizationTeamPath, v3BillingPath } from "~/utils/pathBuilder";
+import { PurchaseSeatsModal } from "../_app.orgs.$organizationSlug.settings.team/route";
 
 const Params = z.object({
   organizationSlug: z.string(),
@@ -122,7 +128,8 @@ export const action: ActionFunction = async ({ request, params }) => {
 };
 
 export default function Page() {
-  const { limits } = useTypedLoaderData<typeof loader>();
+  const { limits, canPurchaseSeats, seatPricing, extraSeats, maxSeatQuota, planSeatLimit } =
+    useTypedLoaderData<typeof loader>();
   const [total, setTotal] = useState(limits.used);
   const organization = useOrganization();
   const lastSubmission = useActionData();
@@ -150,25 +157,54 @@ export default function Page() {
           title="Invite team members"
           description={`Invite new team members to ${organization.title}.`}
         />
-        {total > limits.limit && (
-          <InfoPanel
-            variant="upgrade"
-            icon={LockOpenIcon}
-            iconClassName="text-indigo-500"
-            title="Unlock more team members"
-            accessory={
-              <LinkButton to={v3BillingPath(organization)} variant="secondary/small">
-                Upgrade
-              </LinkButton>
-            }
-            panelClassName="mb-4"
-          >
-            <Paragraph variant="small">
-              You've used all {limits.limit} of your available team members. Upgrade your plan to
-              add more.
-            </Paragraph>
-          </InfoPanel>
-        )}
+        {total > limits.limit &&
+          (canPurchaseSeats && seatPricing ? (
+            <InfoPanel
+              variant="upgrade"
+              icon={LockOpenIcon}
+              iconClassName="text-indigo-500"
+              title="Need more seats?"
+              accessory={
+                <PurchaseSeatsModal
+                  seatPricing={seatPricing}
+                  extraSeats={extraSeats}
+                  usedSeats={limits.used}
+                  maxQuota={maxSeatQuota}
+                  planSeatLimit={planSeatLimit}
+                  triggerButton={<Button variant="primary/small">Purchase more seats…</Button>}
+                />
+              }
+              panelClassName="mb-4"
+            >
+              <Paragraph variant="small">
+                You've used all {limits.limit} of your available team members. Purchase extra seats
+                to add more.
+              </Paragraph>
+            </InfoPanel>
+          ) : (
+            <InfoPanel
+              variant="upgrade"
+              icon={LockOpenIcon}
+              iconClassName="text-indigo-500"
+              title="Unlock more team members"
+              accessory={
+                <LinkButton
+                  to={v3BillingPath(organization)}
+                  variant="secondary/small"
+                  LeadingIcon={ArrowUpCircleIcon}
+                  leadingIconClassName="text-indigo-500"
+                >
+                  Upgrade
+                </LinkButton>
+              }
+              panelClassName="mb-4"
+            >
+              <Paragraph variant="small">
+                You've used all {limits.limit} of your available team members. Upgrade your plan to
+                add more.
+              </Paragraph>
+            </InfoPanel>
+          ))}
         <Form method="post" {...form.props}>
           <Fieldset>
             <InputGroup>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam._index/route.tsx
index 5d6a947a424..2cf8b844a9e 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam._index/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam._index/route.tsx
@@ -6,16 +6,18 @@ import {
   ExclamationTriangleIcon,
   LightBulbIcon,
   MagnifyingGlassIcon,
+  XMarkIcon,
   UserPlusIcon,
   VideoCameraIcon,
 } from "@heroicons/react/20/solid";
 import { json, type MetaFunction } from "@remix-run/node";
-import { Link, useRevalidator, useSubmit } from "@remix-run/react";
+import { Link, useFetcher, useRevalidator } from "@remix-run/react";
 import { type ActionFunctionArgs, type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { DiscordIcon } from "@trigger.dev/companyicons";
 import { formatDurationMilliseconds } from "@trigger.dev/core/v3";
 import type { TaskRunStatus } from "@trigger.dev/database";
-import { Fragment, Suspense, useEffect, useState } from "react";
+import { Fragment, Suspense, useCallback, useEffect, useRef, useState } from "react";
+import type { PanelHandle } from "react-window-splitter";
 import { Bar, BarChart, ResponsiveContainer, Tooltip, type TooltipProps } from "recharts";
 import { TypedAwait, typeddefer, useTypedLoaderData } from "remix-typedjson";
 import { ExitIcon } from "~/assets/icons/ExitIcon";
@@ -42,9 +44,11 @@ import { Paragraph } from "~/components/primitives/Paragraph";
 import { PopoverMenuItem } from "~/components/primitives/Popover";
 import * as Property from "~/components/primitives/PropertyTable";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import { Spinner } from "~/components/primitives/Spinner";
 import { StepNumber } from "~/components/primitives/StepNumber";
@@ -84,6 +88,7 @@ import {
   uiPreferencesStorage,
 } from "~/services/preferences/uiPreferences.server";
 import { requireUserId } from "~/services/session.server";
+import { motion } from "framer-motion";
 import { cn } from "~/utils/cn";
 import {
   docsPath,
@@ -192,14 +197,20 @@ export default function Page() {
   }, [streamedEvents]); // eslint-disable-line react-hooks/exhaustive-deps
 
   const [showUsefulLinks, setShowUsefulLinks] = useState(usefulLinksPreference ?? true);
+  const usefulLinksPanelRef = useRef<PanelHandle>(null);
+  const fetcher = useFetcher();
+  const fetcherRef = useRef(fetcher);
+  fetcherRef.current = fetcher;
 
-  // Create a submit handler to save the preference
-  const submit = useSubmit();
-
-  const handleUsefulLinksToggle = (show: boolean) => {
+  const toggleUsefulLinks = useCallback((show: boolean) => {
     setShowUsefulLinks(show);
-    submit({ showUsefulLinks: show.toString() }, { method: "post" });
-  };
+    if (show) {
+      usefulLinksPanelRef.current?.expand();
+    } else {
+      usefulLinksPanelRef.current?.collapse();
+    }
+    fetcherRef.current.submit({ showUsefulLinks: show.toString() }, { method: "post" });
+  }, []);
 
   return (
     <PageContainer>
@@ -226,27 +237,24 @@ export default function Page() {
       </NavBar>
       <PageBody scrollable={false}>
         <ResizablePanelGroup orientation="horizontal" className="max-h-full">
-          <ResizablePanel id="tasks-main" className="max-h-full">
+          <ResizablePanel id="tasks-main" min="100px" className="max-h-full">
             <div className={cn("grid h-full grid-rows-1")}>
               {hasTasks ? (
                 <div className="flex min-w-0 max-w-full flex-col">
                   {tasks.length === 0 ? <UserHasNoTasks /> : null}
                   <div className="max-h-full overflow-hidden">
-                    <div className="flex items-center gap-1 p-2">
-                      <Input
-                        placeholder="Search tasks"
-                        variant="tertiary"
-                        icon={MagnifyingGlassIcon}
-                        fullWidth={true}
+                    <div className="flex items-center justify-between gap-1 p-2">
+                      <AnimatedSearchField
                         value={filterText}
-                        onChange={(e) => setFilterText(e.target.value)}
+                        onChange={setFilterText}
+                        placeholder="Search tasks…"
                         autoFocus
                       />
-                      {!showUsefulLinks && (
+                        {!showUsefulLinks && (
                         <Button
-                          variant="minimal/small"
+                          variant="secondary/small"
                           TrailingIcon={LightBulbIcon}
-                          onClick={() => handleUsefulLinksToggle(true)}
+                          onClick={() => toggleUsefulLinks(true)}
                           className="px-2.5"
                         />
                       )}
@@ -417,20 +425,29 @@ export default function Page() {
               )}
             </div>
           </ResizablePanel>
-          {hasTasks && showUsefulLinks ? (
-            <>
-              <ResizableHandle id="tasks-handle" />
-              <ResizablePanel
-                id="tasks-inspector"
-                min="200px"
-                default="400px"
-                max="500px"
-                className="w-full"
-              >
-                <HelpfulInfoHasTasks onClose={() => handleUsefulLinksToggle(false)} />
-              </ResizablePanel>
-            </>
-          ) : null}
+          <ResizableHandle
+            id="tasks-handle"
+            className={collapsibleHandleClassName(hasTasks && showUsefulLinks)}
+          />
+          <ResizablePanel
+            id="tasks-inspector"
+            handle={usefulLinksPanelRef}
+            default="400px"
+            min="400px"
+            max="500px"
+            className="overflow-hidden"
+            collapsible
+            collapsed={!hasTasks || !showUsefulLinks}
+            onCollapseChange={() => {}}
+            collapsedSize="0px"
+            collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+          >
+            <div className="h-full" style={{ minWidth: 400 }}>
+              {hasTasks && (
+                <HelpfulInfoHasTasks onClose={() => toggleUsefulLinks(false)} />
+              )}
+            </div>
+          </ResizablePanel>
         </ResizablePanelGroup>
       </PageBody>
     </PageContainer>
@@ -850,3 +867,54 @@ function FailedToLoadStats() {
     />
   );
 }
+
+function AnimatedSearchField({
+  value,
+  onChange,
+  placeholder,
+  autoFocus,
+}: {
+  value: string;
+  onChange: (value: string) => void;
+  placeholder?: string;
+  autoFocus?: boolean;
+}) {
+  const [isFocused, setIsFocused] = useState(false);
+
+  return (
+    <motion.div
+      initial={{ width: "auto" }}
+      animate={{ width: isFocused && value.length > 0 ? "24rem" : "auto" }}
+      transition={{ type: "spring", stiffness: 300, damping: 30 }}
+      className="relative h-6 min-w-52"
+    >
+      <Input
+        type="text"
+        variant="secondary-small"
+        placeholder={placeholder}
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        fullWidth
+        autoFocus={autoFocus}
+        className={cn(isFocused && "placeholder:text-text-dimmed/70")}
+        onFocus={() => setIsFocused(true)}
+        onBlur={() => setIsFocused(false)}
+        onKeyDown={(e) => {
+          if (e.key === "Escape") e.currentTarget.blur();
+        }}
+        icon={<MagnifyingGlassIcon className="size-4" />}
+        accessory={
+          value.length > 0 ? (
+            <button
+              type="button"
+              onClick={() => onChange("")}
+              className="flex size-4.5 items-center justify-center rounded-[2px] border border-text-dimmed/40 text-text-dimmed transition hover:bg-charcoal-600 hover:text-text-bright"
+            >
+              <XMarkIcon className="size-3" />
+            </button>
+          ) : undefined
+        }
+      />
+    </motion.div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts.new.connect-to-slack.ts b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts.new.connect-to-slack.ts
index 6800ab2ed88..ddd1bf646b7 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts.new.connect-to-slack.ts
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts.new.connect-to-slack.ts
@@ -28,6 +28,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     where: {
       service: "SLACK",
       organizationId: project.organizationId,
+      deletedAt: null,
     },
   });
 
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts/route.tsx
index 1bedd30d0f9..9b888a43624 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.alerts/route.tsx
@@ -63,6 +63,7 @@ import {
   v3NewProjectAlertPath,
   v3ProjectAlertsPath,
 } from "~/utils/pathBuilder";
+import { alertsWorker } from "~/v3/alertsWorker.server";
 
 export const meta: MetaFunction = () => {
   return [
@@ -156,6 +157,17 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
         data: { enabled: true },
       });
 
+      if (alertChannel.alertTypes.includes("ERROR_GROUP")) {
+        await alertsWorker.enqueue({
+          id: `evaluateErrorAlerts:${project.id}`,
+          job: "v3.evaluateErrorAlerts",
+          payload: {
+            projectId: project.id,
+            scheduledAt: Date.now(),
+          },
+        });
+      }
+
       return redirectWithSuccessMessage(
         v3ProjectAlertsPath({ slug: organizationSlug }, { slug: projectParam }, { slug: envParam }),
         request,
@@ -555,8 +567,10 @@ export function alertTypeTitle(alertType: ProjectAlertType): string {
       return "Deployment failure";
     case "DEPLOYMENT_SUCCESS":
       return "Deployment success";
+    case "ERROR_GROUP":
+      return "Error group";
     default: {
-      assertNever(alertType);
+      throw new Error(`Unknown alertType: ${alertType}`);
     }
   }
 }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.apikeys/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.apikeys/route.tsx
index acbf29c4f3f..897687f4ec9 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.apikeys/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.apikeys/route.tsx
@@ -51,7 +51,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
   try {
     const presenter = new ApiKeysPresenter();
-    const { environment } = await presenter.call({
+    const { environment, hasVercelIntegration } = await presenter.call({
       userId,
       projectSlug: projectParam,
       environmentSlug: envParam,
@@ -59,6 +59,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
     return typedjson({
       environment,
+      hasVercelIntegration,
     });
   } catch (error) {
     console.error(error);
@@ -70,7 +71,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 };
 
 export default function Page() {
-  const { environment } = useTypedLoaderData<typeof loader>();
+  const { environment, hasVercelIntegration } = useTypedLoaderData<typeof loader>();
   const organization = useOrganization();
 
   if (!environment) {
@@ -132,6 +133,8 @@ export default function Page() {
                 <RegenerateApiKeyModal
                   id={environment.parentEnvironment?.id ?? environment.id}
                   title={environmentFullTitle(environment)}
+                  hasVercelIntegration={hasVercelIntegration}
+                  isDevelopment={environment.type === "DEVELOPMENT"}
                 />
               </div>
               <ClipboardField
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches.$batchParam/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches.$batchParam/route.tsx
index 91403f4597d..6f5fc89341f 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches.$batchParam/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches.$batchParam/route.tsx
@@ -1,4 +1,4 @@
-import { ArrowRightIcon, ExclamationTriangleIcon } from "@heroicons/react/20/solid";
+import { ExclamationTriangleIcon } from "@heroicons/react/20/solid";
 import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { tryCatch } from "@trigger.dev/core";
 import { motion } from "framer-motion";
@@ -12,17 +12,14 @@ import { DateTime } from "~/components/primitives/DateTime";
 import { Header2, Header3 } from "~/components/primitives/Headers";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import * as Property from "~/components/primitives/PropertyTable";
-import {
-  BatchStatusCombo,
-  descriptionForBatchStatus,
-} from "~/components/runs/v3/BatchStatus";
+import { BatchStatusCombo, descriptionForBatchStatus } from "~/components/runs/v3/BatchStatus";
 import { useAutoRevalidate } from "~/hooks/useAutoRevalidate";
 import { useEnvironment } from "~/hooks/useEnvironment";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { findProjectBySlug } from "~/models/project.server";
 import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
-import { BatchPresenter, type BatchPresenterData } from "~/presenters/v3/BatchPresenter.server";
+import { BatchPresenter } from "~/presenters/v3/BatchPresenter.server";
 import { requireUserId } from "~/services/session.server";
 import { cn } from "~/utils/cn";
 import { formatNumber } from "~/utils/numberFormatter";
@@ -35,8 +32,7 @@ const BatchParamSchema = EnvironmentParamSchema.extend({
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const userId = await requireUserId(request);
 
-  const { organizationSlug, projectParam, envParam, batchParam } =
-    BatchParamSchema.parse(params);
+  const { organizationSlug, projectParam, envParam, batchParam } = BatchParamSchema.parse(params);
 
   const project = await findProjectBySlug(organizationSlug, projectParam, userId);
   if (!project) {
@@ -85,7 +81,8 @@ export default function Page() {
     disabled: batch.hasFinished,
   });
 
-  const showProgressMeter = batch.isV2 && (batch.status === "PROCESSING" || batch.status === "PARTIAL_FAILED");
+  const showProgressMeter =
+    batch.isV2 && (batch.status === "PROCESSING" || batch.status === "PARTIAL_FAILED");
 
   return (
     <div className="grid h-full max-h-full grid-rows-[2.5rem_2.5rem_1fr_3.25rem] overflow-hidden bg-background-bright">
@@ -141,9 +138,7 @@ export default function Page() {
               </Property.Item>
               <Property.Item>
                 <Property.Label>Version</Property.Label>
-                <Property.Value>
-                  {batch.isV2 ? "v2 (Run Engine)" : "v1 (Legacy)"}
-                </Property.Value>
+                <Property.Value>{batch.isV2 ? "v2 (Run Engine)" : "v1 (Legacy)"}</Property.Value>
               </Property.Item>
               <Property.Item>
                 <Property.Label>Total runs</Property.Label>
@@ -243,11 +238,11 @@ export default function Page() {
       {/* Footer */}
       <div className="flex items-center justify-end gap-2 border-t border-grid-dimmed px-2">
         <LinkButton
-          variant="tertiary/medium"
+          variant="secondary/medium"
           to={v3BatchRunsPath(organization, project, environment, batch)}
-          LeadingIcon={RunsIcon}
-          leadingIconClassName="text-indigo-500"
-          TrailingIcon={ArrowRightIcon}
+          trailingIconClassName="text-runs"
+          TrailingIcon={RunsIcon}
+          className="text-text-bright"
         >
           View runs
         </LinkButton>
@@ -304,4 +299,3 @@ function BatchProgressMeter({ successCount, failureCount, totalCount }: BatchPro
     </div>
   );
 }
-
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches/route.tsx
index a66e85c0f86..eaa040c4081 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.batches/route.tsx
@@ -1,9 +1,10 @@
-import { ArrowRightIcon, ExclamationCircleIcon } from "@heroicons/react/20/solid";
+import { ExclamationCircleIcon } from "@heroicons/react/20/solid";
 import { BookOpenIcon } from "@heroicons/react/24/solid";
-import { type MetaFunction, Outlet, useNavigation, useParams, useLocation } from "@remix-run/react";
+import { type MetaFunction, Outlet, useLocation, useNavigation, useParams } from "@remix-run/react";
 import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { formatDuration } from "@trigger.dev/core/v3/utils/durations";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { RunsIcon } from "~/assets/icons/RunsIcon";
 import { BatchesNone } from "~/components/BlankStatePanels";
 import { ListPagination } from "~/components/ListPagination";
 import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
@@ -13,6 +14,8 @@ import { DateTime } from "~/components/primitives/DateTime";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  collapsibleHandleClassName,
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
@@ -143,14 +146,25 @@ export default function Page() {
                 />
               </div>
             </ResizablePanel>
-            {isShowingInspector && (
-              <>
-                <ResizableHandle id="batches-handle" />
-                <ResizablePanel id="batches-inspector" min="100px" default="500px">
-                  <Outlet />
-                </ResizablePanel>
-              </>
-            )}
+            <ResizableHandle
+              id="batches-handle"
+              className={collapsibleHandleClassName(isShowingInspector)}
+            />
+            <ResizablePanel
+              id="batches-inspector"
+              min="370px"
+              default="370px"
+              className="overflow-hidden"
+              collapsible
+              collapsed={!isShowingInspector}
+              onCollapseChange={() => {}}
+              collapsedSize="0px"
+              collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+            >
+              <div className="h-full" style={{ minWidth: 370 }}>
+                <Outlet />
+              </div>
+            </ResizablePanel>
           </ResizablePanelGroup>
         )}
       </PageBody>
@@ -287,8 +301,14 @@ function BatchActionsCell({ runsPath }: { runsPath: string }) {
     <TableCellMenu
       isSticky
       hiddenButtons={
-        <LinkButton to={runsPath} variant="minimal/small" LeadingIcon={ArrowRightIcon}>
-          View runs
+        <LinkButton
+          to={runsPath}
+          variant="minimal/small"
+          TrailingIcon={RunsIcon}
+          trailingIconClassName="text-runs"
+          className="text-text-bright"
+        >
+          <span>View runs</span>
         </LinkButton>
       }
     />
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route.tsx
index f356ee6c81a..c7d54d1842e 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route.tsx
@@ -1,23 +1,17 @@
 import { conform, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import {
-  ArrowRightIcon,
-  ArrowUpCircleIcon,
-  CheckIcon,
-  MagnifyingGlassIcon,
-  PlusIcon,
-} from "@heroicons/react/20/solid";
+import { ArrowUpCircleIcon, CheckIcon, EnvelopeIcon, PlusIcon } from "@heroicons/react/20/solid";
 import { BookOpenIcon } from "@heroicons/react/24/solid";
 import { DialogClose } from "@radix-ui/react-dialog";
-import { Form, useActionData, useLocation, useSearchParams } from "@remix-run/react";
+import { Form, useActionData, useFetcher, useLocation, useSearchParams } from "@remix-run/react";
 import { type ActionFunctionArgs, json, type LoaderFunctionArgs } from "@remix-run/server-runtime";
-import { GitMeta } from "@trigger.dev/core/v3";
+import { GitMeta, tryCatch } from "@trigger.dev/core/v3";
 import { useCallback, useEffect, useState } from "react";
+import { SearchInput } from "~/components/primitives/SearchInput";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { BranchEnvironmentIconSmall } from "~/assets/icons/EnvironmentIcons";
 import { BranchesNoBranchableEnvironment, BranchesNoBranches } from "~/components/BlankStatePanels";
-import { Feedback } from "~/components/Feedback";
 import { GitMetadata } from "~/components/GitMetadata";
 import { V4Title } from "~/components/V4Badge";
 import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
@@ -41,12 +35,14 @@ import { Header3 } from "~/components/primitives/Headers";
 import { Hint } from "~/components/primitives/Hint";
 import { Input } from "~/components/primitives/Input";
 import { InputGroup } from "~/components/primitives/InputGroup";
+import { InputNumberStepper } from "~/components/primitives/InputNumberStepper";
 import { Label } from "~/components/primitives/Label";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { PaginationControls } from "~/components/primitives/Pagination";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { PopoverMenuItem } from "~/components/primitives/Popover";
 import * as Property from "~/components/primitives/PropertyTable";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
 import { Switch } from "~/components/primitives/Switch";
 import {
   Table,
@@ -62,16 +58,26 @@ import { InfoIconTooltip, SimpleTooltip } from "~/components/primitives/Tooltip"
 import { useEnvironment } from "~/hooks/useEnvironment";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
-import { useThrottle } from "~/hooks/useThrottle";
+
+import { findProjectBySlug } from "~/models/project.server";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { BranchesPresenter } from "~/presenters/v3/BranchesPresenter.server";
 import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
 import { UpsertBranchService } from "~/services/upsertBranch.server";
 import { cn } from "~/utils/cn";
-import { branchesPath, docsPath, ProjectParamSchema, v3BillingPath } from "~/utils/pathBuilder";
+import {
+  branchesPath,
+  docsPath,
+  EnvironmentParamSchema,
+  ProjectParamSchema,
+  v3BillingPath,
+} from "~/utils/pathBuilder";
+import { formatCurrency, formatNumber } from "~/utils/numberFormatter";
+import { SetBranchesAddOnService } from "~/v3/services/setBranchesAddOn.server";
 import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
 import { ArchiveButton } from "../resources.branches.archive";
+import { IconArrowBearRight2 } from "@tabler/icons-react";
 
 export const BranchesOptions = z.object({
   search: z.string().optional(),
@@ -119,10 +125,68 @@ export const schema = CreateBranchOptions.and(
   })
 );
 
-export async function action({ request }: ActionFunctionArgs) {
+const PurchaseSchema = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("purchase"),
+    amount: z.coerce.number().int("Must be a whole number").min(0, "Amount must be 0 or more"),
+  }),
+  z.object({
+    action: z.literal("quota-increase"),
+    amount: z.coerce
+      .number()
+      .int("Must be a whole number")
+      .min(1, "Amount must be greater than 0"),
+  }),
+]);
+
+export async function action({ request, params }: ActionFunctionArgs) {
   const userId = await requireUserId(request);
 
   const formData = await request.formData();
+  const formType = formData.get("_formType");
+
+  if (formType === "purchase-branches") {
+    const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+    const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+    const redirectPath = branchesPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam }
+    );
+
+    if (!project) {
+      throw redirectWithErrorMessage(redirectPath, request, "Project not found");
+    }
+
+    const submission = parse(formData, { schema: PurchaseSchema });
+
+    if (!submission.value || submission.intent !== "submit") {
+      return json(submission);
+    }
+
+    const service = new SetBranchesAddOnService();
+    const [error, result] = await tryCatch(
+      service.call({
+        userId,
+        organizationId: project.organizationId,
+        action: submission.value.action,
+        amount: submission.value.amount,
+      })
+    );
+
+    if (error) {
+      submission.error.amount = [error instanceof Error ? error.message : "Unknown error"];
+      return json(submission);
+    }
+
+    if (!result.success) {
+      submission.error.amount = [result.error];
+      return json(submission);
+    }
+
+    return json({ ok: true } as const);
+  }
+
   const submission = parse(formData, { schema });
 
   if (!submission.value) {
@@ -165,6 +229,11 @@ export default function Page() {
     currentPage,
     totalPages,
     hasBranches,
+    canPurchaseBranches,
+    extraBranches,
+    branchPricing,
+    maxBranchQuota,
+    planBranchLimit,
   } = useTypedLoaderData<typeof loader>();
   const organization = useOrganization();
   const project = useProject();
@@ -177,6 +246,8 @@ export default function Page() {
     !plan.v3Subscription.plan.limits.branches.canExceed;
   const canUpgrade =
     plan?.v3Subscription?.plan && !plan.v3Subscription.plan.limits.branches.canExceed;
+  const atBranchLimit = limits.used >= limits.limit;
+  const usageRatio = limits.limit > 0 ? Math.min(limits.used / limits.limit, 1) : 0;
 
   if (!branchableEnvironment) {
     return (
@@ -218,7 +289,15 @@ export default function Page() {
           </LinkButton>
 
           {limits.isAtLimit ? (
-            <UpgradePanel limits={limits} canUpgrade={canUpgrade ?? false} />
+            <UpgradePanel
+              limits={limits}
+              canUpgrade={canUpgrade ?? false}
+              canPurchaseBranches={canPurchaseBranches}
+              branchPricing={branchPricing}
+              extraBranches={extraBranches}
+              maxBranchQuota={maxBranchQuota}
+              planBranchLimit={planBranchLimit}
+            />
           ) : (
             <NewBranchPanel
               button={
@@ -230,7 +309,7 @@ export default function Page() {
                   fullWidth
                   textAlignLeft
                 >
-                  New branch
+                  New branch…
                 </Button>
               }
               parentEnvironment={branchableEnvironment}
@@ -324,7 +403,15 @@ export default function Page() {
                               isSticky
                               hiddenButtons={
                                 isSelected ? null : (
-                                  <PopoverMenuItem to={path} title="Switch to branch" />
+                                  <LinkButton
+                                    to={path}
+                                    variant="secondary/small"
+                                    LeadingIcon={IconArrowBearRight2}
+                                    leadingIconClassName="text-blue-500 -mr-2"
+                                    className="pl-1.5"
+                                  >
+                                    Switch to branch
+                                  </LinkButton>
                                 )
                               }
                               popoverContent={
@@ -333,8 +420,8 @@ export default function Page() {
                                     {isSelected ? null : (
                                       <PopoverMenuItem
                                         to={path}
-                                        icon={ArrowRightIcon}
-                                        leadingIconClassName="text-blue-500"
+                                        icon={IconArrowBearRight2}
+                                        leadingIconClassName="text-blue-500 -mr-0.5 -ml-1"
                                         title="Switch to branch"
                                       />
                                     )}
@@ -376,20 +463,20 @@ export default function Page() {
                           />
                           <circle
                             className={`fill-none ${
-                              requiresUpgrade ? "stroke-error" : "stroke-success"
+                              atBranchLimit ? "stroke-error" : "stroke-success"
                             }`}
                             strokeWidth="4"
                             r="10"
                             cx="12"
                             cy="12"
-                            strokeDasharray={`${(limits.used / limits.limit) * 62.8} 62.8`}
+                            strokeDasharray={`${usageRatio * 62.8} 62.8`}
                             strokeDashoffset="0"
                             strokeLinecap="round"
                           />
                         </svg>
                       </div>
                     }
-                    content={`${Math.round((limits.used / limits.limit) * 100)}%`}
+                    content={`${Math.round(usageRatio * 100)}%`}
                   />
                   <div className="flex w-full items-center justify-between gap-6">
                     {requiresUpgrade ? (
@@ -399,28 +486,36 @@ export default function Page() {
                       </Header3>
                     ) : (
                       <div className="flex items-center gap-1">
-                        <Header3>
+                        <Header3 className={atBranchLimit ? "text-error" : undefined}>
                           You've used {limits.used}/{limits.limit} of your branches
                         </Header3>
                         <InfoIconTooltip content="Archived branches don't count towards your limit." />
                       </div>
                     )}
 
-                    {canUpgrade ? (
-                      <LinkButton
-                        to={v3BillingPath(organization)}
-                        variant="secondary/small"
-                        LeadingIcon={ArrowUpCircleIcon}
-                        leadingIconClassName="text-indigo-500"
-                      >
-                        Upgrade
-                      </LinkButton>
-                    ) : (
-                      <Feedback
-                        button={<Button variant="secondary/small">Request more</Button>}
-                        defaultValue="help"
+                    {canPurchaseBranches && branchPricing ? (
+                      <PurchaseBranchesModal
+                        branchPricing={branchPricing}
+                        extraBranches={extraBranches}
+                        activeBranches={limits.used}
+                        maxQuota={maxBranchQuota}
+                        planBranchLimit={planBranchLimit}
                       />
-                    )}
+                    ) : canUpgrade ? (
+                      <div className="flex items-center gap-3">
+                        <Paragraph variant="small" className="whitespace-nowrap text-text-dimmed">
+                          Upgrade plan for more Preview Branches
+                        </Paragraph>
+                        <LinkButton
+                          to={v3BillingPath(organization)}
+                          variant="secondary/small"
+                          LeadingIcon={ArrowUpCircleIcon}
+                          leadingIconClassName="text-indigo-500"
+                        >
+                          Upgrade
+                        </LinkButton>
+                      </div>
+                    ) : null}
                   </div>
                 </div>
               </div>
@@ -434,42 +529,23 @@ export default function Page() {
 
 export function BranchFilters() {
   const [searchParams, setSearchParams] = useSearchParams();
-  const { search, showArchived, page } = BranchesOptions.parse(
-    Object.fromEntries(searchParams.entries())
-  );
+  const { showArchived } = BranchesOptions.parse(Object.fromEntries(searchParams.entries()));
 
-  const handleFilterChange = useCallback((filterType: string, value: string | undefined) => {
+  const handleArchivedChange = useCallback((checked: boolean) => {
     setSearchParams((s) => {
-      if (value) {
-        searchParams.set(filterType, value);
+      if (checked) {
+        s.set("showArchived", "true");
       } else {
-        searchParams.delete(filterType);
+        s.delete("showArchived");
       }
-      searchParams.delete("page");
-      return searchParams;
+      s.delete("page");
+      return s;
     });
   }, []);
 
-  const handleArchivedChange = useCallback((checked: boolean) => {
-    handleFilterChange("showArchived", checked ? "true" : undefined);
-  }, []);
-
-  const handleSearchChange = useThrottle((value: string) => {
-    handleFilterChange("search", value.length === 0 ? undefined : value);
-  }, 300);
-
   return (
-    <div className="flex w-full gap-2">
-      <Input
-        name="search"
-        placeholder="Search branch name"
-        icon={MagnifyingGlassIcon}
-        variant="tertiary"
-        className="grow"
-        defaultValue={search}
-        onChange={(e) => handleSearchChange(e.target.value)}
-      />
-
+    <div className="flex w-full items-center justify-between gap-2">
+      <SearchInput placeholder="Search branch name" resetParams={["page"]} />
       <Switch
         checked={showArchived ?? false}
         onCheckedChange={handleArchivedChange}
@@ -483,15 +559,47 @@ export function BranchFilters() {
 function UpgradePanel({
   limits,
   canUpgrade,
+  canPurchaseBranches,
+  branchPricing,
+  extraBranches,
+  maxBranchQuota,
+  planBranchLimit,
 }: {
   limits: {
     used: number;
     limit: number;
   };
   canUpgrade: boolean;
+  canPurchaseBranches: boolean;
+  branchPricing: { stepSize: number; centsPerStep: number } | null;
+  extraBranches: number;
+  maxBranchQuota: number;
+  planBranchLimit: number;
 }) {
   const organization = useOrganization();
 
+  if (canPurchaseBranches && branchPricing) {
+    return (
+      <PurchaseBranchesModal
+        branchPricing={branchPricing}
+        extraBranches={extraBranches}
+        activeBranches={limits.used}
+        maxQuota={maxBranchQuota}
+        planBranchLimit={planBranchLimit}
+        triggerButton={
+          <Button
+            LeadingIcon={PlusIcon}
+            leadingIconClassName="text-white"
+            variant="primary/small"
+            shortcut={{ key: "n" }}
+          >
+            Purchase more…
+          </Button>
+        }
+      />
+    );
+  }
+
   return (
     <Dialog>
       <DialogTrigger asChild>
@@ -517,18 +625,270 @@ function UpgradePanel({
             <LinkButton variant="primary/small" to={v3BillingPath(organization)}>
               Upgrade
             </LinkButton>
-          ) : (
-            <Feedback
-              button={<Button variant="primary/small">Request more</Button>}
-              defaultValue="help"
-            />
-          )}
+          ) : null}
         </DialogFooter>
       </DialogContent>
     </Dialog>
   );
 }
 
+function PurchaseBranchesModal({
+  branchPricing,
+  extraBranches,
+  activeBranches,
+  maxQuota,
+  planBranchLimit,
+  triggerButton,
+}: {
+  branchPricing: {
+    stepSize: number;
+    centsPerStep: number;
+  };
+  extraBranches: number;
+  activeBranches: number;
+  maxQuota: number;
+  planBranchLimit: number;
+  triggerButton?: React.ReactNode;
+}) {
+  const fetcher = useFetcher();
+  const lastSubmission =
+    fetcher.data && typeof fetcher.data === "object" && "intent" in fetcher.data
+      ? fetcher.data
+      : undefined;
+  const [form, { amount }] = useForm({
+    id: "purchase-branches",
+    lastSubmission: lastSubmission as any,
+    onValidate({ formData }) {
+      return parse(formData, { schema: PurchaseSchema });
+    },
+    shouldRevalidate: "onSubmit",
+  });
+
+  const [amountValue, setAmountValue] = useState(extraBranches);
+  useEffect(() => {
+    setAmountValue(extraBranches);
+  }, [extraBranches]);
+  const isLoading = fetcher.state !== "idle";
+
+  const [open, setOpen] = useState(false);
+  useEffect(() => {
+    const data = fetcher.data;
+    if (fetcher.state === "idle" && data !== null && typeof data === "object" && "ok" in data && data.ok) {
+      setOpen(false);
+    }
+  }, [fetcher.state, fetcher.data]);
+
+  const state = updateBranchState({
+    value: amountValue,
+    existingValue: extraBranches,
+    quota: maxQuota,
+    activeBranches,
+    planBranchLimit,
+  });
+  const changeClassName =
+    state === "decrease" ? "text-error" : state === "increase" ? "text-success" : undefined;
+
+  const pricePerBranch = branchPricing.centsPerStep / branchPricing.stepSize / 100;
+  const title = extraBranches === 0 ? "Purchase extra branches…" : "Add/remove extra branches…";
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        {triggerButton ?? (
+          <Button variant="primary/small" onClick={() => setOpen(true)}>
+            {title}
+          </Button>
+        )}
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>{title}</DialogHeader>
+        <fetcher.Form method="post" {...form.props}>
+          <input type="hidden" name="_formType" value="purchase-branches" />
+          <div className="flex flex-col gap-4 pt-2">
+            <div className="flex flex-col gap-1">
+              <Paragraph variant="small/bright">
+                Purchase extra preview branches at {formatCurrency(pricePerBranch, false)}/month per
+                branch. Reducing the number of branches will take effect at the start of the next
+                billing cycle (1st of the month).
+              </Paragraph>
+            </div>
+            <Fieldset>
+              <InputGroup fullWidth>
+                <Label htmlFor="amount" className="text-text-dimmed">
+                  Total extra branches
+                </Label>
+                <InputNumberStepper
+                  {...conform.input(amount, { type: "number" })}
+                  step={branchPricing.stepSize}
+                  min={0}
+                  max={undefined}
+                  value={amountValue}
+                  onChange={(e) => setAmountValue(Number(e.target.value))}
+                  disabled={isLoading}
+                />
+                <FormError id={amount.errorId}>
+                  {amount.error ?? amount.initialError?.[""]?.[0]}
+                </FormError>
+                <FormError>{form.error}</FormError>
+              </InputGroup>
+            </Fieldset>
+            {state === "need_to_archive" ? (
+              <div className="flex flex-col pb-3">
+                <Paragraph variant="small" className="text-warning" spacing>
+                  You need to archive{" "}
+                  {formatNumber(activeBranches - (planBranchLimit + amountValue))} more{" "}
+                  {activeBranches - (planBranchLimit + amountValue) === 1 ? "branch" : "branches"}{" "}
+                  before you can reduce to this level.
+                </Paragraph>
+              </div>
+            ) : state === "above_quota" ? (
+              <div className="flex flex-col pb-3">
+                <Paragraph variant="small" className="text-warning" spacing>
+                  Currently you can only have up to {maxQuota} extra preview branches. Send a
+                  request below to lift your current limit. We'll get back to you soon.
+                </Paragraph>
+              </div>
+            ) : (
+              <div className="flex flex-col pb-3 tabular-nums">
+                <div className="grid grid-cols-2 border-b border-grid-dimmed pb-1">
+                  <Header3 className="font-normal text-text-dimmed">Summary</Header3>
+                  <Header3 className="justify-self-end font-normal text-text-dimmed">Total</Header3>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className="pb-0 font-normal text-text-dimmed">
+                    <span className="text-text-bright">{formatNumber(extraBranches)}</span> current
+                    extra
+                  </Header3>
+                  <Header3 className="justify-self-end font-normal text-text-bright">
+                    {formatCurrency(extraBranches * pricePerBranch, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({extraBranches} {extraBranches === 1 ? "branch" : "branches"})
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className={cn("pb-0 font-normal", changeClassName)}>
+                    {state === "increase" ? "+" : null}
+                    {formatNumber(amountValue - extraBranches)}
+                  </Header3>
+                  <Header3 className={cn("justify-self-end font-normal", changeClassName)}>
+                    {state === "increase" ? "+" : null}
+                    {formatCurrency((amountValue - extraBranches) * pricePerBranch, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({Math.abs(amountValue - extraBranches)}{" "}
+                    {Math.abs(amountValue - extraBranches) === 1 ? "branch" : "branches"} @{" "}
+                    {formatCurrency(pricePerBranch, true)}/mth)
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className="pb-0 font-normal text-text-dimmed">
+                    <span className="text-text-bright">{formatNumber(amountValue)}</span> new total
+                  </Header3>
+                  <Header3 className="justify-self-end font-normal text-text-bright">
+                    {formatCurrency(amountValue * pricePerBranch, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({amountValue} {amountValue === 1 ? "branch" : "branches"})
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+              </div>
+            )}
+          </div>
+          <FormButtons
+            confirmButton={
+              state === "above_quota" ? (
+                <>
+                  <input type="hidden" name="action" value="quota-increase" />
+                  <Button
+                    LeadingIcon={isLoading ? SpinnerWhite : EnvelopeIcon}
+                    variant="primary/medium"
+                    type="submit"
+                    disabled={isLoading}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Send request for ${formatNumber(
+                      amountValue
+                    )}`}</span>
+                  </Button>
+                </>
+              ) : state === "decrease" || state === "need_to_archive" ? (
+                <>
+                  <input type="hidden" name="action" value="purchase" />
+                  <Button
+                    variant="danger/medium"
+                    type="submit"
+                    disabled={isLoading || state === "need_to_archive"}
+                    LeadingIcon={isLoading ? SpinnerWhite : undefined}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Remove ${formatNumber(
+                      extraBranches - amountValue
+                    )} ${extraBranches - amountValue === 1 ? "branch" : "branches"}`}</span>
+                  </Button>
+                </>
+              ) : (
+                <>
+                  <input type="hidden" name="action" value="purchase" />
+                  <Button
+                    variant="primary/medium"
+                    type="submit"
+                    disabled={isLoading || state === "no_change"}
+                    LeadingIcon={isLoading ? SpinnerWhite : undefined}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Purchase ${formatNumber(
+                      amountValue - extraBranches
+                    )} ${amountValue - extraBranches === 1 ? "branch" : "branches"}`}</span>
+                  </Button>
+                </>
+              )
+            }
+            cancelButton={
+              <DialogClose asChild>
+                <Button variant="secondary/medium" disabled={isLoading}>
+                  Cancel
+                </Button>
+              </DialogClose>
+            }
+          />
+        </fetcher.Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function updateBranchState({
+  value,
+  existingValue,
+  quota,
+  activeBranches,
+  planBranchLimit,
+}: {
+  value: number;
+  existingValue: number;
+  quota: number;
+  activeBranches: number;
+  planBranchLimit: number;
+}): "no_change" | "increase" | "decrease" | "above_quota" | "need_to_archive" {
+  if (value === existingValue) return "no_change";
+  if (value < existingValue) {
+    const newTotalLimit = planBranchLimit + value;
+    if (activeBranches > newTotalLimit) {
+      return "need_to_archive";
+    }
+    return "decrease";
+  }
+  if (value > quota) return "above_quota";
+  return "increase";
+}
+
 export function NewBranchPanel({
   button,
   parentEnvironment,
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.bulk-actions/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.bulk-actions/route.tsx
index f44ce5904dc..a17f3e7d99e 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.bulk-actions/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.bulk-actions/route.tsx
@@ -13,9 +13,11 @@ import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/Page
 import { PaginationControls } from "~/components/primitives/Pagination";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import {
   Table,
@@ -170,14 +172,26 @@ export default function Page() {
                 )}
               </div>
             </ResizablePanel>
-            {isShowingInspector && (
-              <>
-                <ResizableHandle id="bulk-actions-handle" />
-                <ResizablePanel id="bulk-actions-inspector" min="100px" default="500px">
-                  <Outlet />
-                </ResizablePanel>
-              </>
-            )}
+            <ResizableHandle
+              id="bulk-actions-handle"
+              className={collapsibleHandleClassName(isShowingInspector)}
+            />
+            <ResizablePanel
+              id="bulk-actions-inspector"
+              default="500px"
+              min="500px"
+              max="800px"
+              className="overflow-hidden"
+              collapsible
+              collapsed={!isShowingInspector}
+              onCollapseChange={() => {}}
+              collapsedSize="0px"
+              collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+            >
+              <div className="h-full" style={{ minWidth: 500 }}>
+                <Outlet />
+              </div>
+            </ResizablePanel>
           </ResizablePanelGroup>
         )}
       </PageBody>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.concurrency/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.concurrency/route.tsx
index 54068153141..1c96b8c6422 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.concurrency/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.concurrency/route.tsx
@@ -1,6 +1,7 @@
 import { conform, useFieldList, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
 import {
+  ArrowDownIcon,
   EnvelopeIcon,
   ExclamationTriangleIcon,
   InformationCircleIcon,
@@ -18,6 +19,7 @@ import {
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { tryCatch } from "@trigger.dev/core";
 import { useEffect, useState } from "react";
+import simplur from "simplur";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
@@ -289,7 +291,7 @@ function Upgradable({
 }: ConcurrencyResult) {
   const lastSubmission = useActionData();
   const [form, { environments: formEnvironments }] = useForm({
-    id: "purchase-concurrency",
+    id: "allocate-concurrency",
     // TODO: type this
     lastSubmission: lastSubmission as any,
     onValidate({ formData }) {
@@ -331,7 +333,7 @@ function Upgradable({
               disabled={unallocated < 0 ? false : allocationModified}
             />
           </div>
-          <Table>
+          <Table variant="bright/no-hover">
             <TableBody>
               <TableRow>
                 <TableCell className="pl-0 text-text-bright">Extra concurrency purchased</TableCell>
@@ -379,8 +381,15 @@ function Upgradable({
                   )}
                 </TableCell>
               </TableRow>
-              <TableRow className={allocationModified ? undefined : "after:bg-transparent"}>
-                <TableCell colSpan={2} className="py-0">
+              <TableRow
+                className={
+                  allocationModified || unallocated > 0 ? undefined : "after:bg-transparent"
+                }
+              >
+                <TableCell
+                  colSpan={2}
+                  className={cn("py-0", (unallocated > 0 || allocationModified) && "pr-0")}
+                >
                   <div className="flex h-10 items-center">
                     {allocationModified ? (
                       unallocated < 0 ? (
@@ -419,6 +428,16 @@ function Upgradable({
                           </Button>
                         </div>
                       )
+                    ) : unallocated > 0 ? (
+                      <div className="flex h-full w-full items-center justify-between bg-success/10 px-2.5">
+                        <div className="flex items-center justify-start gap-1">
+                          <InformationCircleIcon className="size-4 text-success" />
+                          <span className="text-success">
+                            You have {unallocated} extra concurrency available to allocate below.
+                          </span>
+                        </div>
+                        <ArrowDownIcon className="size-4 animate-bounce text-success" />
+                      </div>
                     ) : (
                       <></>
                     )}
@@ -427,14 +446,16 @@ function Upgradable({
               </TableRow>
             </TableBody>
           </Table>
-          <FormError id={formEnvironments.id}>{formEnvironments.error}</FormError>
+          <FormError id={formEnvironments.id}>
+            {formEnvironments.error ?? formEnvironments.initialError?.[""]?.[0]}
+          </FormError>
         </div>
         <Form className="flex flex-col gap-2" method="post" {...form.props} id="allocate">
           <input type="hidden" name="action" value="allocate" />
           <div className="flex items-center pb-1">
             <Header3 className="grow">Concurrency allocation</Header3>
           </div>
-          <Table>
+          <Table variant="bright/no-hover">
             <TableHeader>
               <TableRow>
                 <TableHeaderCell className="pl-0">Environment</TableHeaderCell>
@@ -452,7 +473,12 @@ function Upgradable({
               {environments.map((environment, index) => (
                 <TableRow key={environment.id}>
                   <TableCell>
-                    <EnvironmentCombo environment={environment} />
+                    <EnvironmentCombo
+                      environment={environment}
+                      className="max-w-[18ch]"
+                      tooltipSideOffset={6}
+                      tooltipSide="top"
+                    />
                   </TableCell>
                   <TableCell alignment="right">{environment.planConcurrencyLimit}</TableCell>
                   <TableCell alignment="right">
@@ -523,7 +549,7 @@ function NotUpgradable({ environments }: { environments: EnvironmentWithConcurre
         </>
       ) : null}
       <div className="mt-3 flex flex-col gap-3">
-        <Table>
+        <Table variant="bright/no-hover">
           <TableHeader>
             <TableRow>
               <TableHeaderCell className="pl-0">Environment</TableHeaderCell>
@@ -640,7 +666,9 @@ function PurchaseConcurrencyModal({
                   onChange={(e) => setAmountValue(Number(e.target.value))}
                   disabled={isLoading}
                 />
-                <FormError id={amount.errorId}>{amount.error}</FormError>
+                <FormError id={amount.errorId}>
+                  {amount.error ?? amount.initialError?.[""]?.[0]}
+                </FormError>
                 <FormError>{form.error}</FormError>
               </InputGroup>
             </Fieldset>
@@ -682,7 +710,7 @@ function PurchaseConcurrencyModal({
                 </div>
                 <div className="grid grid-cols-2 text-xs">
                   <span className="text-text-dimmed">
-                    ({extraConcurrency / concurrencyPricing.stepSize} bundles)
+                    ({simplur`${extraConcurrency / concurrencyPricing.stepSize} bundle[|s]`})
                   </span>
                   <span className="justify-self-end text-text-dimmed">/mth</span>
                 </div>
@@ -703,8 +731,11 @@ function PurchaseConcurrencyModal({
                 </div>
                 <div className="grid grid-cols-2 text-xs">
                   <span className="text-text-dimmed">
-                    ({(amountValue - extraConcurrency) / concurrencyPricing.stepSize} bundles @{" "}
-                    {formatCurrency(concurrencyPricing.centsPerStep / 100, true)}/mth)
+                    (
+                    {simplur`${
+                      (amountValue - extraConcurrency) / concurrencyPricing.stepSize
+                    } bundle[|s]`}{" "}
+                    @ {formatCurrency(concurrencyPricing.centsPerStep / 100, true)}/mth)
                   </span>
                   <span className="justify-self-end text-text-dimmed">/mth</span>
                 </div>
@@ -723,7 +754,7 @@ function PurchaseConcurrencyModal({
                 </div>
                 <div className="grid grid-cols-2 text-xs">
                   <span className="text-text-dimmed">
-                    ({amountValue / concurrencyPricing.stepSize} bundles)
+                    ({simplur`${amountValue / concurrencyPricing.stepSize} bundle[|s]`})
                   </span>
                   <span className="justify-self-end text-text-dimmed">/mth</span>
                 </div>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardKey/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardKey/route.tsx
new file mode 100644
index 00000000000..57b6b71db6f
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardKey/route.tsx
@@ -0,0 +1,406 @@
+import { type LoaderFunctionArgs } from "@remix-run/node";
+import type { TaskTriggerSource } from "@trigger.dev/database";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import ReactGridLayout from "react-grid-layout";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { LogsTaskFilter } from "~/components/logs/LogsTaskFilter";
+import { ModelsFilter, type ModelOption } from "~/components/metrics/ModelsFilter";
+import { OperationsFilter } from "~/components/metrics/OperationsFilter";
+import { PromptsFilter } from "~/components/metrics/PromptsFilter";
+import { ProvidersFilter } from "~/components/metrics/ProvidersFilter";
+import { type WidgetData } from "~/components/metrics/QueryWidget";
+import { QueuesFilter } from "~/components/metrics/QueuesFilter";
+import { ScopeFilter } from "~/components/metrics/ScopeFilter";
+import { TitleWidget } from "~/components/metrics/TitleWidget";
+import { CreateDashboardPageButton } from "~/components/navigation/DashboardDialogs";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import { TimeFilter } from "~/components/runs/v3/SharedFilters";
+import { $replica } from "~/db.server";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { getAllTaskIdentifiers } from "~/models/task.server";
+import {
+  type BuiltInDashboardFilter,
+  type LayoutItem,
+  type Widget,
+  MetricDashboardPresenter,
+} from "~/presenters/v3/MetricDashboardPresenter.server";
+import { PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUser } from "~/services/session.server";
+import { cn } from "~/utils/cn";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { QueryScopeSchema } from "~/v3/querySchemas";
+import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
+import { MetricWidget } from "../resources.metric";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  dashboardKey: z.string(),
+});
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const { projectParam, organizationSlug, envParam, dashboardKey } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
+  if (!project) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Project not found",
+    });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Environment not found",
+    });
+  }
+
+  const presenter = new MetricDashboardPresenter();
+  const [dashboard, possibleTasks] = await Promise.all([
+    presenter.builtInDashboard({
+      organizationId: project.organizationId,
+      key: dashboardKey,
+    }),
+    getAllTaskIdentifiers($replica, environment.id),
+  ]);
+
+  const filters = dashboard.filters ?? ["tasks", "queues"];
+
+  // Load distinct models from ClickHouse if the dashboard has a models filter
+  let possibleModels: { model: string; system: string }[] = [];
+  if (filters.includes("models")) {
+    const queryFn = clickhouseClient.reader.query({
+      name: "getDistinctModels",
+      query: `SELECT response_model, any(gen_ai_system) AS gen_ai_system FROM trigger_dev.llm_metrics_v1 WHERE organization_id = {organizationId: String} AND project_id = {projectId: String} AND environment_id = {environmentId: String} AND response_model != '' GROUP BY response_model ORDER BY response_model`,
+      params: z.object({
+        organizationId: z.string(),
+        projectId: z.string(),
+        environmentId: z.string(),
+      }),
+      schema: z.object({ response_model: z.string(), gen_ai_system: z.string() }),
+    });
+    const [error, rows] = await queryFn({
+      organizationId: project.organizationId,
+      projectId: project.id,
+      environmentId: environment.id,
+    });
+    if (!error) {
+      possibleModels = rows.map((r) => ({ model: r.response_model, system: r.gen_ai_system }));
+    }
+  }
+
+  const promptPresenter = new PromptPresenter(clickhouseClient);
+  const [possiblePrompts, possibleOperations, possibleProviders] = await Promise.all([
+    filters.includes("prompts")
+      ? promptPresenter.getDistinctPromptSlugs(project.organizationId, project.id, environment.id)
+      : ([] as string[]),
+    filters.includes("operations")
+      ? promptPresenter.getDistinctOperations(project.organizationId, project.id, environment.id)
+      : ([] as string[]),
+    filters.includes("providers")
+      ? promptPresenter.getDistinctProviders(project.organizationId, project.id, environment.id)
+      : ([] as string[]),
+  ]);
+
+  return typedjson({
+    ...dashboard,
+    filters,
+    possibleTasks: possibleTasks
+      .map((task) => ({ slug: task.slug, triggerSource: task.triggerSource }))
+      .sort((a, b) => a.slug.localeCompare(b.slug)),
+    possibleModels,
+    possiblePrompts,
+    possibleOperations,
+    possibleProviders,
+  });
+};
+
+export default function Page() {
+  const {
+    key,
+    title,
+    layout: dashboardLayout,
+    defaultPeriod,
+    filters,
+    possibleTasks,
+    possibleModels,
+    possiblePrompts,
+    possibleOperations,
+    possibleProviders,
+  } = useTypedLoaderData<typeof loader>();
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title={title} />
+        <PageAccessories>
+          <CreateDashboardPageButton
+            organization={organization}
+            project={project}
+            environment={environment}
+          />
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable={false}>
+        <div className="h-full">
+          <MetricDashboard
+            key={key}
+            layout={dashboardLayout.layout}
+            widgets={dashboardLayout.widgets}
+            defaultPeriod={defaultPeriod}
+            editable={false}
+            filters={filters}
+            possibleTasks={possibleTasks}
+            possibleModels={possibleModels}
+            possiblePrompts={possiblePrompts}
+            possibleOperations={possibleOperations}
+            possibleProviders={possibleProviders}
+          />
+        </div>
+      </PageBody>
+    </PageContainer>
+  );
+}
+
+export function MetricDashboard({
+  layout,
+  widgets,
+  defaultPeriod,
+  editable,
+  filters: filterConfig,
+  possibleTasks,
+  possibleModels,
+  possiblePrompts,
+  possibleOperations,
+  possibleProviders,
+  onLayoutChange,
+  onEditWidget,
+  onRenameWidget,
+  onDeleteWidget,
+  onDuplicateWidget,
+}: {
+  /** The layout items (positions/sizes) - fully controlled from parent */
+  layout: LayoutItem[];
+  /** The widget configurations keyed by widget ID - fully controlled from parent */
+  widgets: Record<string, Widget>;
+  defaultPeriod: string;
+  editable: boolean;
+  /** Which filters to show. Defaults to ["tasks", "queues"]. */
+  filters?: BuiltInDashboardFilter[];
+  /** Possible tasks for filtering */
+  possibleTasks?: { slug: string; triggerSource: TaskTriggerSource }[];
+  /** Possible models for filtering */
+  possibleModels?: ModelOption[];
+  /** Possible prompt slugs for filtering */
+  possiblePrompts?: string[];
+  /** Possible operations for filtering */
+  possibleOperations?: string[];
+  /** Possible providers for filtering */
+  possibleProviders?: string[];
+  onLayoutChange?: (layout: LayoutItem[]) => void;
+  onEditWidget?: (widgetId: string, widget: WidgetData) => void;
+  onRenameWidget?: (widgetId: string, newTitle: string) => void;
+  onDeleteWidget?: (widgetId: string) => void;
+  onDuplicateWidget?: (widgetId: string, widget: WidgetData) => void;
+}) {
+  const { value, values } = useSearchParams();
+  const { width, containerRef, mounted } = useContainerWidth();
+  const [resizingItemId, setResizingItemId] = useState<string | null>(null);
+  const [isDragging, setIsDragging] = useState(false);
+  const isInteracting = resizingItemId !== null || isDragging;
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const plan = useCurrentPlan();
+  const maxPeriodDays = plan?.v3Subscription?.plan?.limits?.queryPeriodDays?.number;
+
+  const period = value("period");
+  const from = value("from");
+  const to = value("to");
+  const parsedScope = QueryScopeSchema.safeParse(value("scope") ?? "environment");
+  const scope = parsedScope.success ? parsedScope.data : "environment";
+  const tasks = values("tasks").filter((v) => v !== "");
+  const queues = values("queues").filter((v) => v !== "");
+  const models = values("models").filter((v) => v !== "");
+  const prompts = values("prompts").filter((v) => v !== "");
+  const operations = values("operations").filter((v) => v !== "");
+  const providers = values("providers").filter((v) => v !== "");
+
+  const activeFilters = filterConfig ?? ["tasks", "queues"];
+
+  const handleLayoutChange = useCallback(
+    (newLayout: readonly LayoutItem[]) => {
+      const mutableLayout = [...newLayout];
+      onLayoutChange?.(mutableLayout);
+    },
+    [onLayoutChange]
+  );
+
+  // Apply constraints for title widgets: fixed height of 2, allow horizontal resize only
+  const constrainedLayout = useMemo(
+    () =>
+      layout.map((item) => {
+        const widget = widgets[item.i];
+        if (widget?.display.type === "title") {
+          return { ...item, h: 2, minH: 2, maxH: 2 };
+        }
+        return item;
+      }),
+    [layout, widgets]
+  );
+
+  return (
+    <div className="grid max-h-full grid-rows-[auto_1fr] overflow-hidden">
+      <div className="flex items-center gap-1 border-b border-b-grid-bright py-2 pl-2 pr-3">
+        <ScopeFilter />
+        {activeFilters.includes("tasks") && (
+          <LogsTaskFilter possibleTasks={possibleTasks ?? []} />
+        )}
+        {activeFilters.includes("queues") && <QueuesFilter />}
+        {activeFilters.includes("models") && (
+          <ModelsFilter possibleModels={possibleModels ?? []} />
+        )}
+        {activeFilters.includes("prompts") && (
+          <PromptsFilter possiblePrompts={possiblePrompts ?? []} />
+        )}
+        {activeFilters.includes("operations") && (
+          <OperationsFilter possibleOperations={possibleOperations ?? []} />
+        )}
+        {activeFilters.includes("providers") && (
+          <ProvidersFilter possibleProviders={possibleProviders ?? []} />
+        )}
+        <TimeFilter
+          defaultPeriod={defaultPeriod}
+          labelName="Period"
+          hideLabel
+          maxPeriodDays={maxPeriodDays}
+          valueClassName="text-text-bright"
+        />
+      </div>
+      <div
+        ref={containerRef}
+        className={cn(
+          "overflow-y-auto scrollbar-thin scrollbar-track-charcoal-800 scrollbar-thumb-charcoal-700",
+          isInteracting && "select-none"
+        )}
+      >
+        {mounted && (
+          <ReactGridLayout
+            layout={constrainedLayout}
+            width={width}
+            gridConfig={{ cols: 12, rowHeight: 30 }}
+            resizeConfig={{
+              enabled: editable,
+              handles: ["se"],
+            }}
+            dragConfig={{ enabled: editable, handle: ".drag-handle" }}
+            onLayoutChange={handleLayoutChange}
+            onResizeStart={(_layout, oldItem) => setResizingItemId(oldItem?.i ?? null)}
+            onResizeStop={() => setResizingItemId(null)}
+            onDragStart={() => setIsDragging(true)}
+            onDragStop={() => setIsDragging(false)}
+          >
+            {Object.entries(widgets).map(([key, widget]) => (
+              <div key={key}>
+                {widget.display.type === "title" ? (
+                  <TitleWidget
+                    title={widget.title}
+                    isDraggable={editable}
+                    isResizing={resizingItemId === key}
+                    onRename={
+                      onRenameWidget ? (newTitle) => onRenameWidget(key, newTitle) : undefined
+                    }
+                    onDelete={onDeleteWidget ? () => onDeleteWidget(key) : undefined}
+                  />
+                ) : (
+                  <MetricWidget
+                    widgetKey={key}
+                    title={widget.title}
+                    query={widget.query}
+                    scope={scope}
+                    period={period ?? defaultPeriod}
+                    from={from ?? null}
+                    to={to ?? null}
+                    taskIdentifiers={tasks.length > 0 ? tasks : undefined}
+                    queues={queues.length > 0 ? queues : undefined}
+                    responseModels={models.length > 0 ? models : undefined}
+                    promptSlugs={prompts.length > 0 ? prompts : undefined}
+                    operations={operations.length > 0 ? operations : undefined}
+                    providers={providers.length > 0 ? providers : undefined}
+                    config={widget.display}
+                    organizationId={organization.id}
+                    projectId={project.id}
+                    environmentId={environment.id}
+                    refreshIntervalMs={60_000}
+                    isResizing={resizingItemId === key}
+                    isDraggable={editable}
+                    onEdit={
+                      onEditWidget
+                        ? (resultData) => onEditWidget(key, { ...widget, resultData })
+                        : undefined
+                    }
+                    onRename={
+                      onRenameWidget ? (newTitle) => onRenameWidget(key, newTitle) : undefined
+                    }
+                    onDelete={onDeleteWidget ? () => onDeleteWidget(key) : undefined}
+                    onDuplicate={
+                      onDuplicateWidget
+                        ? (resultData) => onDuplicateWidget(key, { ...widget, resultData })
+                        : undefined
+                    }
+                  />
+                )}
+              </div>
+            ))}
+          </ReactGridLayout>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function useContainerWidth(initialWidth = 1280) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [width, setWidth] = useState(initialWidth);
+  const [mounted, setMounted] = useState(false);
+
+  const measureWidth = useCallback(() => {
+    if (containerRef.current) {
+      setWidth(containerRef.current.offsetWidth);
+    }
+  }, []);
+
+  useEffect(() => {
+    measureWidth();
+    setMounted(true);
+
+    const element = containerRef.current;
+    if (!element) return;
+
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        setWidth(entry.contentRect.width);
+      }
+    });
+
+    resizeObserver.observe(element);
+    return () => resizeObserver.disconnect();
+  }, [measureWidth]);
+
+  return { width, containerRef, mounted };
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.custom.$dashboardId/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.custom.$dashboardId/route.tsx
new file mode 100644
index 00000000000..051ea7a8a28
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.custom.$dashboardId/route.tsx
@@ -0,0 +1,765 @@
+import { ArrowUpCircleIcon, PlusIcon, TrashIcon } from "@heroicons/react/20/solid";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { type ActionFunctionArgs, type LoaderFunctionArgs } from "@remix-run/node";
+import { Form, useNavigation } from "@remix-run/react";
+import { IconChartHistogram, IconEdit, IconTypography } from "@tabler/icons-react";
+import { useCallback, useEffect, useState } from "react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { defaultChartConfig } from "~/components/code/ChartConfigPanel";
+import { Feedback } from "~/components/Feedback";
+import { MainCenteredContainer, PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTrigger,
+} from "~/components/primitives/Dialog";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { Header3 } from "~/components/primitives/Headers";
+import { InfoPanel } from "~/components/primitives/InfoPanel";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Popover,
+  PopoverContent,
+  PopoverVerticalEllipseTrigger,
+} from "~/components/primitives/Popover";
+import { Sheet, SheetContent } from "~/components/primitives/SheetV3";
+import { useToast } from "~/components/primitives/Toast";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { QueryEditor, type QueryEditorSaveData } from "~/components/query/QueryEditor";
+import { $replica, prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { useDashboardEditor } from "~/hooks/useDashboardEditor";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization, useWidgetLimitPerDashboard } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { redirectWithSuccessMessage } from "~/models/message.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { getAllTaskIdentifiers } from "~/models/task.server";
+import { MetricDashboardPresenter } from "~/presenters/v3/MetricDashboardPresenter.server";
+import { QueryPresenter } from "~/presenters/v3/QueryPresenter.server";
+import { requireUser, requireUserId } from "~/services/session.server";
+import {
+  EnvironmentParamSchema,
+  queryPath,
+  v3BillingPath,
+  v3BuiltInDashboardPath,
+} from "~/utils/pathBuilder";
+import { MetricDashboard } from "../_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardKey/route";
+import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
+import { Type } from "lucide-react";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  dashboardId: z.string(),
+});
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const { projectParam, organizationSlug, envParam, dashboardId } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
+  if (!project) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Project not found",
+    });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Environment not found",
+    });
+  }
+
+  const dashboardPresenter = new MetricDashboardPresenter();
+  const queryPresenter = new QueryPresenter();
+
+  const [dashboard, { defaultQuery, history }, possibleTasks] = await Promise.all([
+    dashboardPresenter.customDashboard({
+      friendlyId: dashboardId,
+      organizationId: project.organizationId,
+    }),
+    queryPresenter.call({
+      organizationId: project.organizationId,
+    }),
+    getAllTaskIdentifiers($replica, environment.id),
+  ]);
+
+  // Admins and impersonating users can use EXPLAIN
+  const isAdmin = user.admin || user.isImpersonating;
+
+  // Compute widget count from dashboard layout
+  const widgetCount = Object.keys(dashboard.layout.widgets).length;
+
+  return typedjson({
+    ...dashboard,
+    // Query editor data
+    queryDefaultQuery: defaultQuery,
+    queryHistory: history,
+    isAdmin,
+    maxRows: env.QUERY_CLICKHOUSE_MAX_RETURNED_ROWS,
+    possibleTasks: possibleTasks
+      .map((task) => ({ slug: task.slug, triggerSource: task.triggerSource }))
+      .sort((a, b) => a.slug.localeCompare(b.slug)),
+    widgetCount,
+  });
+};
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { projectParam, organizationSlug, envParam, dashboardId } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  // Load the dashboard
+  const dashboard = await prisma.metricsDashboard.findFirst({
+    where: {
+      friendlyId: dashboardId,
+      organizationId: project.organizationId,
+    },
+  });
+
+  if (!dashboard) {
+    throw new Response("Dashboard not found", { status: 404 });
+  }
+
+  const formData = await request.formData();
+  const action = formData.get("action");
+
+  switch (action) {
+    case "delete": {
+      await prisma.metricsDashboard.delete({
+        where: { id: dashboard.id },
+      });
+
+      return redirectWithSuccessMessage(
+        v3BuiltInDashboardPath(
+          { slug: organizationSlug },
+          { slug: projectParam },
+          { slug: envParam },
+          "overview"
+        ),
+        request,
+        `Deleted "${dashboard.title}" dashboard`
+      );
+    }
+    case "rename": {
+      const newTitle = formData.get("title");
+      if (typeof newTitle !== "string" || newTitle.trim().length === 0) {
+        throw new Response("Title is required", { status: 400 });
+      }
+
+      await prisma.metricsDashboard.update({
+        where: { id: dashboard.id },
+        data: { title: newTitle.trim() },
+      });
+
+      return typedjson({ success: true });
+    }
+    default: {
+      throw new Response("Invalid action", { status: 400 });
+    }
+  }
+};
+
+export default function Page() {
+  const {
+    friendlyId,
+    title,
+    layout: dashboardLayout,
+    defaultPeriod,
+    queryDefaultQuery,
+    queryHistory,
+    isAdmin,
+    maxRows,
+    possibleTasks,
+    widgetCount: initialWidgetCount,
+  } = useTypedLoaderData<typeof loader>();
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const plan = useCurrentPlan();
+  const maxPeriodDays = plan?.v3Subscription?.plan?.limits?.queryPeriodDays?.number;
+
+  // Widget limits
+  const widgetLimitPerDashboard = useWidgetLimitPerDashboard();
+  const planLimits = (plan?.v3Subscription?.plan?.limits as any)?.metricWidgetsPerDashboard;
+  const canExceedWidgets = typeof planLimits === "object" && planLimits.canExceed === true;
+
+  // Build the action URLs - both use the resource route to avoid full page renders on POST
+  const widgetActionUrl = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/dashboards/${friendlyId}/widgets`;
+  const layoutActionUrl = widgetActionUrl;
+
+  const toast = useToast();
+
+  const handleSyncError = useCallback((error: Error, action: string) => {
+    const actionMessages: Record<string, string> = {
+      add: "Failed to add widget",
+      update: "Failed to update widget",
+      delete: "Failed to delete widget",
+      duplicate: "Failed to duplicate widget",
+      layout: "Failed to save layout",
+    };
+
+    const message = actionMessages[action] || "Failed to save changes";
+
+    toast.error(`${message}. Your changes may not be saved.`, { title: "Sync Error" });
+  }, [toast]);
+
+  // Add title dialog state
+  const [showAddTitleDialog, setShowAddTitleDialog] = useState(false);
+  const [newTitleValue, setNewTitleValue] = useState("");
+
+  // Widget limit dialog state (triggered when hook blocks add/duplicate)
+  const [showWidgetLimitDialog, setShowWidgetLimitDialog] = useState(false);
+
+  const handleWidgetLimitReached = useCallback(() => {
+    setShowWidgetLimitDialog(true);
+  }, []);
+
+  // Use the dashboard editor hook for all state management
+  const { state, actions } = useDashboardEditor({
+    initialData: dashboardLayout,
+    widgetActionUrl,
+    layoutActionUrl,
+    widgetLimit: canExceedWidgets ? undefined : widgetLimitPerDashboard,
+    onSyncError: handleSyncError,
+    onWidgetLimitReached: handleWidgetLimitReached,
+  });
+
+  // Reactive widget count from editor state (title widgets don't count against limits)
+  const currentWidgetCount = Object.values(state.widgets).filter(
+    (w) => w.display.type !== "title"
+  ).length;
+  const totalWidgetCount = Object.keys(state.widgets).length;
+  const widgetLimits = { used: currentWidgetCount, limit: widgetLimitPerDashboard };
+  const widgetIsAtLimit = currentWidgetCount >= widgetLimitPerDashboard;
+  const widgetLimitRatio =
+    widgetLimits.limit > 0 ? widgetLimits.used / widgetLimits.limit : widgetLimits.used > 0 ? 1 : 0;
+  const widgetLimitPercent = Math.min(100, Math.max(0, Math.round(widgetLimitRatio * 100)));
+  const widgetCanUpgrade = plan?.v3Subscription?.plan && !canExceedWidgets;
+
+  // Build the query action URL for the editor
+  const queryActionUrl = queryPath(
+    { slug: organization.slug },
+    { slug: project.slug },
+    { slug: environment.slug }
+  );
+
+  // Handle save from the QueryEditor
+  const handleSave = useCallback(
+    (data: QueryEditorSaveData) => {
+      if (state.editorMode?.type === "add") {
+        actions.addWidget(data.title, data.query, data.config);
+      } else if (state.editorMode?.type === "edit") {
+        actions.updateWidget(state.editorMode.widgetId, data.title, data.query, data.config);
+      }
+    },
+    [state.editorMode, actions]
+  );
+
+  // Render save button for the QueryEditor
+  const renderSaveForm = useCallback(
+    (data: QueryEditorSaveData) => {
+      const isAdd = state.editorMode?.type === "add";
+
+      return (
+        <Button
+          type="button"
+          variant="primary/small"
+          disabled={!data.query}
+          onClick={() => handleSave(data)}
+        >
+          {isAdd ? "Add to dashboard" : "Save changes"}
+        </Button>
+      );
+    },
+    [state.editorMode, handleSave]
+  );
+
+  // Prepare editor props when in editor mode
+  const editorProps = state.editorMode
+    ? (() => {
+        const mode =
+          state.editorMode.type === "add"
+            ? { type: "dashboard-add" as const, dashboardId: friendlyId, dashboardName: title }
+            : {
+                type: "dashboard-edit" as const,
+                dashboardId: friendlyId,
+                dashboardName: title,
+                widgetId: state.editorMode.widgetId,
+                widgetName: state.editorMode.widget.title,
+              };
+
+        // For edit mode, use the widget's existing values as defaults
+        const editorDefaultQuery =
+          state.editorMode.type === "edit" ? state.editorMode.widget.query : queryDefaultQuery;
+        const editorDefaultChartConfig =
+          state.editorMode.type === "edit" && state.editorMode.widget.display.type === "chart"
+            ? {
+                chartType: state.editorMode.widget.display.chartType,
+                xAxisColumn: state.editorMode.widget.display.xAxisColumn,
+                yAxisColumns: state.editorMode.widget.display.yAxisColumns,
+                groupByColumn: state.editorMode.widget.display.groupByColumn,
+                stacked: state.editorMode.widget.display.stacked,
+                sortByColumn: state.editorMode.widget.display.sortByColumn,
+                sortDirection: state.editorMode.widget.display.sortDirection,
+                aggregation: state.editorMode.widget.display.aggregation,
+                seriesColors: state.editorMode.widget.display.seriesColors,
+              }
+            : defaultChartConfig;
+        const editorDefaultBigNumberConfig =
+          state.editorMode.type === "edit" && state.editorMode.widget.display.type === "bignumber"
+            ? {
+                column: state.editorMode.widget.display.column,
+                aggregation: state.editorMode.widget.display.aggregation,
+                sortDirection: state.editorMode.widget.display.sortDirection,
+                abbreviate: state.editorMode.widget.display.abbreviate,
+                prefix: state.editorMode.widget.display.prefix,
+                suffix: state.editorMode.widget.display.suffix,
+              }
+            : undefined;
+        const editorDefaultResultsView =
+          state.editorMode.type === "edit" ? state.editorMode.widget.display.type : "table";
+        // Pass the existing result data when editing
+        const editorDefaultData =
+          state.editorMode.type === "edit" ? state.editorMode.widget.resultData : undefined;
+
+        return {
+          mode,
+          editorDefaultQuery,
+          editorDefaultChartConfig,
+          editorDefaultBigNumberConfig,
+          editorDefaultResultsView,
+          editorDefaultData,
+        };
+      })()
+    : null;
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title={title} />
+        <PageAccessories>
+          {totalWidgetCount > 0 &&
+            (widgetIsAtLimit ? (
+              <>
+                <Dialog>
+                  <DialogTrigger asChild>
+                    <Button variant="primary/small" LeadingIcon={PlusIcon}>
+                      Add chart
+                    </Button>
+                  </DialogTrigger>
+                  <DialogContent>
+                    <DialogHeader>You've exceeded your widget limit</DialogHeader>
+                    <DialogDescription>
+                      You've used {widgetLimits.used}/{widgetLimits.limit} widgets on this
+                      dashboard.
+                    </DialogDescription>
+                    <DialogFooter>
+                      {widgetCanUpgrade ? (
+                        <LinkButton variant="primary/small" to={v3BillingPath(organization)}>
+                          Upgrade
+                        </LinkButton>
+                      ) : (
+                        <Feedback
+                          button={<Button variant="primary/small">Request more</Button>}
+                          defaultValue="help"
+                        />
+                      )}
+                    </DialogFooter>
+                  </DialogContent>
+                </Dialog>
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={Type}
+                  className="pl-1.5"
+                  iconSpacing="gap-x-1"
+                  onClick={() => {
+                    setNewTitleValue("");
+                    setShowAddTitleDialog(true);
+                  }}
+                >
+                  Add title
+                </Button>
+              </>
+            ) : (
+              <>
+                <Button
+                  variant="primary/small"
+                  LeadingIcon={IconChartHistogram}
+                  className="pl-1.5"
+                  iconSpacing="gap-x-1.5"
+                  onClick={actions.openAddEditor}
+                >
+                  Add chart
+                </Button>
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={Type}
+                  className="pl-1.5"
+                  iconSpacing="gap-x-1"
+                  onClick={() => {
+                    setNewTitleValue("");
+                    setShowAddTitleDialog(true);
+                  }}
+                >
+                  Add title
+                </Button>
+              </>
+            ))}
+          <Popover>
+            <PopoverVerticalEllipseTrigger variant="secondary" />
+            <PopoverContent className="w-fit min-w-[10rem] p-1" align="end">
+              <div className="flex flex-col gap-1">
+                <RenameDashboardDialog title={title} />
+                <DeleteDashboardDialog title={title} />
+              </div>
+            </PopoverContent>
+          </Popover>
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable={false}>
+        <div className="flex h-full flex-col">
+          <div className="min-h-0 flex-1">
+            {totalWidgetCount === 0 ? (
+              <MainCenteredContainer className="max-w-md">
+                <InfoPanel
+                  icon={IconChartHistogram}
+                  iconClassName="text-metrics"
+                  panelClassName="max-full"
+                  title="Add your first chart"
+                  accessory={
+                    <Button
+                      variant="primary/small"
+                      LeadingIcon={PlusIcon}
+                      onClick={actions.openAddEditor}
+                    >
+                      Add chart
+                    </Button>
+                  }
+                >
+                  <Paragraph variant="small">
+                    Charts let you visualize your task metrics. Write a query to pull data from your
+                    runs, then choose how to display it on this dashboard.
+                  </Paragraph>
+                </InfoPanel>
+              </MainCenteredContainer>
+            ) : (
+              <MetricDashboard
+                key={friendlyId}
+                layout={state.layout}
+                widgets={state.widgets}
+                defaultPeriod={defaultPeriod}
+                editable={true}
+                possibleTasks={possibleTasks}
+                onLayoutChange={actions.updateLayout}
+                onEditWidget={actions.openEditEditor}
+                onRenameWidget={actions.renameWidget}
+                onDeleteWidget={actions.deleteWidget}
+                onDuplicateWidget={actions.duplicateWidget}
+              />
+            )}
+          </div>
+          <div className="flex w-full items-start justify-between">
+            <div className="flex h-fit w-full items-center gap-4 border-t border-grid-bright bg-background-bright p-[0.86rem] pl-4">
+              <SimpleTooltip
+                button={
+                  <div className="size-6">
+                    <svg className="h-full w-full -rotate-90 overflow-visible">
+                      <circle
+                        className="fill-none stroke-grid-bright"
+                        strokeWidth="4"
+                        r="10"
+                        cx="12"
+                        cy="12"
+                      />
+                      <circle
+                        className={`fill-none ${
+                          widgetIsAtLimit ? "stroke-error" : "stroke-success"
+                        }`}
+                        strokeWidth="4"
+                        r="10"
+                        cx="12"
+                        cy="12"
+                        strokeDasharray={`${widgetLimitRatio * 62.8} 62.8`}
+                        strokeDashoffset="0"
+                        strokeLinecap="round"
+                      />
+                    </svg>
+                  </div>
+                }
+                content={`${widgetLimitPercent}%`}
+              />
+              <div className="flex w-full items-center justify-between gap-6">
+                {widgetIsAtLimit ? (
+                  <Header3 className="text-error">
+                    You've used all {widgetLimits.limit} of your available widgets. Upgrade your
+                    plan to enable more.
+                  </Header3>
+                ) : (
+                  <Header3>
+                    You've used {widgetLimits.used}/{widgetLimits.limit} of your charts
+                  </Header3>
+                )}
+                {widgetCanUpgrade ? (
+                  <LinkButton
+                    to={v3BillingPath(organization)}
+                    variant="secondary/small"
+                    LeadingIcon={ArrowUpCircleIcon}
+                    leadingIconClassName="text-indigo-500"
+                  >
+                    Upgrade
+                  </LinkButton>
+                ) : (
+                  <Feedback
+                    button={<Button variant="secondary/small">Request more…</Button>}
+                    defaultValue="help"
+                  />
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      </PageBody>
+
+      {/* Query Editor Sheet - opens on top of the dashboard */}
+      <Sheet open={!!state.editorMode} onOpenChange={(open) => !open && actions.closeEditor()}>
+        <SheetContent
+          side="right"
+          className="w-[90vw] max-w-none rounded-l-lg border-l border-grid-dimmed p-0 sm:max-w-none"
+        >
+          {editorProps && (
+            <QueryEditor
+              defaultQuery={editorProps.editorDefaultQuery}
+              defaultScope="environment"
+              defaultPeriod={defaultPeriod}
+              defaultResultsView={
+                editorProps.editorDefaultResultsView === "chart"
+                  ? "graph"
+                  : editorProps.editorDefaultResultsView === "bignumber"
+                  ? "bignumber"
+                  : "table"
+              }
+              defaultChartConfig={editorProps.editorDefaultChartConfig}
+              defaultBigNumberConfig={editorProps.editorDefaultBigNumberConfig}
+              defaultData={editorProps.editorDefaultData}
+              history={queryHistory}
+              isAdmin={isAdmin}
+              maxRows={maxRows}
+              queryActionUrl={queryActionUrl}
+              mode={editorProps.mode}
+              maxPeriodDays={maxPeriodDays}
+              save={renderSaveForm}
+              onClose={actions.closeEditor}
+            />
+          )}
+        </SheetContent>
+      </Sheet>
+
+      {/* Add title dialog */}
+      <Dialog open={showAddTitleDialog} onOpenChange={setShowAddTitleDialog}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>Add title</DialogHeader>
+          <form
+            className="space-y-4 pt-3"
+            onSubmit={(e) => {
+              e.preventDefault();
+              if (newTitleValue.trim()) {
+                actions.addTitleWidget(newTitleValue.trim());
+                setShowAddTitleDialog(false);
+              }
+            }}
+          >
+            <InputGroup>
+              <Label>Title</Label>
+              <Input
+                value={newTitleValue}
+                onChange={(e) => setNewTitleValue(e.target.value)}
+                placeholder="Section title"
+                autoFocus
+              />
+            </InputGroup>
+            <DialogFooter>
+              <DialogClose asChild>
+                <Button variant="tertiary/medium">Cancel</Button>
+              </DialogClose>
+              <Button type="submit" variant="primary/medium" disabled={!newTitleValue.trim()}>
+                Add
+              </Button>
+            </DialogFooter>
+          </form>
+        </DialogContent>
+      </Dialog>
+
+      {/* Widget limit dialog - triggered by hook when add/duplicate is blocked */}
+      <Dialog open={showWidgetLimitDialog} onOpenChange={setShowWidgetLimitDialog}>
+        <DialogContent>
+          <DialogHeader>You've exceeded your widget limit</DialogHeader>
+          <DialogDescription>
+            You've used {widgetLimits.used}/{widgetLimits.limit} widgets on this dashboard.
+          </DialogDescription>
+          <DialogFooter>
+            {widgetCanUpgrade ? (
+              <LinkButton variant="primary/small" to={v3BillingPath(organization)}>
+                Upgrade
+              </LinkButton>
+            ) : (
+              <Feedback
+                button={<Button variant="primary/small">Request more</Button>}
+                defaultValue="help"
+              />
+            )}
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </PageContainer>
+  );
+}
+
+function RenameDashboardDialog({ title }: { title: string }) {
+  const navigation = useNavigation();
+  const [isOpen, setIsOpen] = useState(false);
+  const [newTitle, setNewTitle] = useState(title);
+
+  const isRenaming =
+    navigation.state !== "idle" &&
+    navigation.formMethod === "post" &&
+    navigation.formData?.get("action") === "rename";
+
+  // Close dialog when navigation completes
+  useEffect(() => {
+    if (navigation.state === "idle") {
+      setIsOpen(false);
+    }
+  }, [navigation.state]);
+
+  // Sync newTitle state when title changes (after successful rename)
+  useEffect(() => {
+    setNewTitle(title);
+  }, [title]);
+
+  return (
+    <Dialog open={isOpen} onOpenChange={setIsOpen}>
+      <DialogTrigger asChild>
+        <Button
+          variant="small-menu-item"
+          LeadingIcon={IconEdit}
+          fullWidth
+          textAlignLeft
+          className="pl-0.5 pr-3"
+          leadingIconClassName="gap-x-0"
+        >
+          Rename dashboard
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-sm">
+        <DialogHeader>Rename dashboard</DialogHeader>
+        <Form method="post" className="space-y-4">
+          <input type="hidden" name="action" value="rename" />
+          <InputGroup>
+            <Label>Title</Label>
+            <Input
+              name="title"
+              value={newTitle}
+              onChange={(e) => setNewTitle(e.target.value)}
+              placeholder="Dashboard title"
+              required
+              autoFocus
+            />
+          </InputGroup>
+          <FormButtons
+            confirmButton={
+              <Button
+                type="submit"
+                variant="primary/medium"
+                disabled={isRenaming || !newTitle.trim()}
+              >
+                {isRenaming ? "Saving…" : "Save"}
+              </Button>
+            }
+            cancelButton={
+              <DialogClose asChild>
+                <Button variant="tertiary/medium">Cancel</Button>
+              </DialogClose>
+            }
+          />
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function DeleteDashboardDialog({ title }: { title: string }) {
+  const navigation = useNavigation();
+  const [isOpen, setIsOpen] = useState(false);
+
+  const isDeleting =
+    navigation.state !== "idle" &&
+    navigation.formMethod === "post" &&
+    navigation.formData?.get("action") === "delete";
+
+  // Close dialog when navigation completes
+  useEffect(() => {
+    if (navigation.state === "idle") {
+      setIsOpen(false);
+    }
+  }, [navigation.state]);
+
+  return (
+    <Dialog open={isOpen} onOpenChange={setIsOpen}>
+      <DialogTrigger asChild>
+        <Button
+          variant="small-menu-item"
+          LeadingIcon={TrashIcon}
+          leadingIconClassName="text-rose-500"
+          fullWidth
+          textAlignLeft
+        >
+          Delete dashboard
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>Delete dashboard</DialogHeader>
+        <div className="mb-2 mt-4 flex flex-col gap-2">
+          <Paragraph>
+            Are you sure you want to delete <strong>"{title}"</strong>? This action cannot be undone
+            and all widgets on this dashboard will be permanently removed.
+          </Paragraph>
+        </div>
+        <DialogFooter>
+          <DialogClose asChild>
+            <Button variant="secondary/medium">Cancel</Button>
+          </DialogClose>
+          <Form method="post">
+            <Button
+              type="submit"
+              name="action"
+              value="delete"
+              variant="danger/medium"
+              LeadingIcon={TrashIcon}
+              disabled={isDeleting}
+            >
+              {isDeleting ? "Deleting…" : "Delete"}
+            </Button>
+          </Form>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments.$deploymentParam/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments.$deploymentParam/route.tsx
index aebc934ba38..36ca0f335e8 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments.$deploymentParam/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments.$deploymentParam/route.tsx
@@ -3,9 +3,19 @@ import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { useEffect, useState, useRef, useCallback } from "react";
 import { S2, S2Error } from "@s2-dev/streamstore";
-import { Clipboard, ClipboardCheck, ChevronDown, ChevronUp } from "lucide-react";
+import {
+  Clipboard,
+  ClipboardCheck,
+  ChevronDown,
+  ChevronUp,
+  TerminalSquareIcon,
+  LayoutDashboardIcon,
+  GitBranchIcon,
+  ServerIcon,
+} from "lucide-react";
 import { ExitIcon } from "~/assets/icons/ExitIcon";
 import { GitMetadata } from "~/components/GitMetadata";
+import { VercelLink } from "~/components/integrations/VercelLink";
 import { RuntimeIcon } from "~/components/RuntimeIcon";
 import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
 import { EnvironmentCombo } from "~/components/environments/EnvironmentLabel";
@@ -73,6 +83,90 @@ type LogEntry = {
   level: "info" | "error" | "warn" | "debug";
 };
 
+function getTriggeredViaDisplay(triggeredVia: string | null | undefined): {
+  icon: React.ReactNode;
+  label: string;
+} | null {
+  if (!triggeredVia) return null;
+
+  const iconClass = "size-4 text-text-dimmed";
+
+  switch (triggeredVia) {
+    case "cli:manual":
+      return {
+        icon: <TerminalSquareIcon className={iconClass} />,
+        label: "CLI (Manual)",
+      };
+    case "cli:github_actions":
+      return {
+        icon: <GitBranchIcon className={iconClass} />,
+        label: "CLI (GitHub Actions)",
+      };
+    case "cli:gitlab_ci":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (GitLab CI)",
+      };
+    case "cli:circleci":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (CircleCI)",
+      };
+    case "cli:jenkins":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (Jenkins)",
+      };
+    case "cli:azure_pipelines":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (Azure Pipelines)",
+      };
+    case "cli:bitbucket_pipelines":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (Bitbucket Pipelines)",
+      };
+    case "cli:travis_ci":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (Travis CI)",
+      };
+    case "cli:buildkite":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (Buildkite)",
+      };
+    case "cli:ci_other":
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: "CLI (CI)",
+      };
+    case "git_integration:github":
+      return {
+        icon: <GitBranchIcon className={iconClass} />,
+        label: "GitHub Integration",
+      };
+    case "dashboard":
+      return {
+        icon: <LayoutDashboardIcon className={iconClass} />,
+        label: "Dashboard",
+      };
+    default:
+      // Handle any unknown values gracefully
+      if (triggeredVia.startsWith("cli:")) {
+        return {
+          icon: <TerminalSquareIcon className={iconClass} />,
+          label: `CLI (${triggeredVia.replace("cli:", "")})`,
+        };
+      }
+      return {
+        icon: <ServerIcon className={iconClass} />,
+        label: triggeredVia,
+      };
+  }
+}
+
 export default function Page() {
   const { deployment, eventStream } = useTypedLoaderData<typeof loader>();
   const organization = useOrganization();
@@ -104,17 +198,14 @@ export default function Page() {
 
         const readSession = await stream.readSession(
           {
-            seq_num: 0,
-            wait: 60,
-            as: "bytes",
+            start: { from: { seqNum: 0 }, clamp: true },
+            stop: { waitSecs: 60 },
           },
           { signal: abortController.signal }
         );
 
-        const decoder = new TextDecoder();
-
         for await (const record of readSession) {
-          const decoded = decoder.decode(record.body);
+          const decoded = record.body;
           const result = DeploymentEventFromString.safeParse(decoded);
 
           if (!result.success) {
@@ -123,8 +214,8 @@ export default function Page() {
               const headers: Record<string, string> = {};
 
               if (record.headers) {
-                for (const [nameBytes, valueBytes] of record.headers) {
-                  headers[decoder.decode(nameBytes)] = decoder.decode(valueBytes);
+                for (const [name, value] of record.headers) {
+                  headers[name] = value;
                 }
               }
               const level = (headers["level"]?.toLowerCase() as LogEntry["level"]) ?? "info";
@@ -408,6 +499,31 @@ export default function Page() {
                   )}
                 </Property.Value>
               </Property.Item>
+              <Property.Item>
+                <Property.Label>Triggered via</Property.Label>
+                <Property.Value>
+                  {(() => {
+                    const display = getTriggeredViaDisplay(deployment.triggeredVia);
+                    if (!display) return "–";
+                    return (
+                      <span className="flex items-center gap-1.5">
+                        {display.icon}
+                        {display.label}
+                      </span>
+                    );
+                  })()}
+                </Property.Value>
+              </Property.Item>
+              {deployment.vercelDeploymentUrl && (
+                <Property.Item>
+                  <Property.Label>Linked</Property.Label>
+                  <Property.Value>
+                    <div className="-ml-1 mt-0.5 flex flex-col">
+                      <VercelLink vercelDeploymentUrl={deployment.vercelDeploymentUrl} />
+                    </div>
+                  </Property.Value>
+                </Property.Item>
+              )}
             </Property.Table>
           </div>
 
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments/route.tsx
index 9b2b78f98b9..9dbac88c51a 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.deployments/route.tsx
@@ -19,6 +19,7 @@ import { useEffect } from "react";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { PromoteIcon } from "~/assets/icons/PromoteIcon";
+import { VercelLink } from "~/components/integrations/VercelLink";
 import { DeploymentsNone, DeploymentsNoneDev } from "~/components/BlankStatePanels";
 import { OctoKitty } from "~/components/GitHubLoginButton";
 import { GitMetadata } from "~/components/GitMetadata";
@@ -41,9 +42,11 @@ import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/Page
 import { PaginationControls } from "~/components/primitives/Pagination";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import {
   Table,
@@ -74,7 +77,7 @@ import {
   EnvironmentParamSchema,
   docsPath,
   v3DeploymentPath,
-  v3ProjectSettingsPath,
+  v3ProjectSettingsIntegrationsPath,
 } from "~/utils/pathBuilder";
 import { createSearchParams } from "~/utils/searchParams";
 import { compareDeploymentVersions } from "~/v3/utils/deploymentVersions";
@@ -160,6 +163,7 @@ export default function Page() {
     connectedGithubRepository,
     environmentGitHubBranch,
     autoReloadPollIntervalMs,
+    hasVercelIntegration,
   } = useTypedLoaderData<typeof loader>();
   const hasDeployments = totalPages > 0;
 
@@ -234,6 +238,7 @@ export default function Page() {
                       <TableHeaderCell>Deployed at</TableHeaderCell>
                       <TableHeaderCell>Deployed by</TableHeaderCell>
                       <TableHeaderCell>Git</TableHeaderCell>
+                      {hasVercelIntegration && <TableHeaderCell>Linked</TableHeaderCell>}
                       <TableHeaderCell hiddenLabel>Go to page</TableHeaderCell>
                     </TableRow>
                   </TableHeader>
@@ -252,7 +257,7 @@ export default function Page() {
                           <TableRow key={deployment.id} className="group" isSelected={isSelected}>
                             <TableCell to={path} isTabbableCell isSelected={isSelected}>
                               <div className="flex items-center gap-2">
-                                <Paragraph variant="extra-small">{deployment.shortCode}</Paragraph>
+                                <Paragraph variant="extra-small" className="group-hover/table-row:text-text-bright">{deployment.shortCode}</Paragraph>
                                 {deployment.label && (
                                   <Badge variant="extra-small">{titleCase(deployment.label)}</Badge>
                                 )}
@@ -307,6 +312,22 @@ export default function Page() {
                                 <GitMetadata git={deployment.git} />
                               </div>
                             </TableCell>
+                            {hasVercelIntegration && (
+                              <TableCell isSelected={isSelected}>
+                                {deployment.vercelDeploymentUrl ? (
+                                  <div
+                                    className="-ml-1 flex items-center"
+                                    onClick={(e) => e.stopPropagation()}
+                                  >
+                                    <VercelLink
+                                      vercelDeploymentUrl={deployment.vercelDeploymentUrl}
+                                    />
+                                  </div>
+                                ) : (
+                                  "–"
+                                )}
+                              </TableCell>
+                            )}
                             <DeploymentActionsCell
                               deployment={deployment}
                               path={path}
@@ -317,7 +338,7 @@ export default function Page() {
                         );
                       })
                     ) : (
-                      <TableBlankRow colSpan={8}>
+                      <TableBlankRow colSpan={hasVercelIntegration ? 9 : 8}>
                         <Paragraph className="flex items-center justify-center">
                           No deploys match your filters
                         </Paragraph>
@@ -351,7 +372,7 @@ export default function Page() {
                       <LinkButton
                         variant="minimal/small"
                         LeadingIcon={CogIcon}
-                        to={v3ProjectSettingsPath(organization, project, environment)}
+                        to={v3ProjectSettingsIntegrationsPath(organization, project, environment)}
                       />
                     </div>
                   )}
@@ -369,14 +390,26 @@ export default function Page() {
             )}
           </ResizablePanel>
 
-          {deploymentParam && (
-            <>
-              <ResizableHandle id="deployments-handle" />
-              <ResizablePanel id="deployments-inspector" min="500px" max="800px">
-                <Outlet />
-              </ResizablePanel>
-            </>
-          )}
+          <ResizableHandle
+            id="deployments-handle"
+            className={collapsibleHandleClassName(!!deploymentParam)}
+          />
+          <ResizablePanel
+            id="deployments-inspector"
+            default="400px"
+            min="400px"
+            max="800px"
+            className="overflow-hidden"
+            collapsible
+            collapsed={!deploymentParam}
+            onCollapseChange={() => {}}
+            collapsedSize="0px"
+            collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+          >
+            <div className="h-full" style={{ minWidth: 400 }}>
+              <Outlet />
+            </div>
+          </ResizablePanel>
         </ResizablePanelGroup>
       </PageBody>
     </PageContainer>
@@ -386,8 +419,8 @@ export default function Page() {
 export function UserTag({ name, avatarUrl }: { name: string; avatarUrl?: string }) {
   return (
     <div className="flex items-center gap-1">
-      <UserAvatar avatarUrl={avatarUrl} name={name} className="h-4 w-4" />
-      <Paragraph variant="extra-small">{name}</Paragraph>
+      <UserAvatar avatarUrl={avatarUrl} name={name} className="h-4 w-4 group-hover/table-row:text-text-bright" />
+      <Paragraph variant="extra-small" className="group-hover/table-row:text-text-bright">{name}</Paragraph>
     </div>
   );
 }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables.new/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables.new/route.tsx
index c52942a8acb..86bd5bbc95d 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables.new/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables.new/route.tsx
@@ -151,7 +151,13 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   }
 
   const repository = new EnvironmentVariablesRepository(prisma);
-  const result = await repository.create(project.id, submission.value);
+  const result = await repository.create(project.id, {
+    ...submission.value,
+    lastUpdatedBy: {
+      type: "user",
+      userId,
+    },
+  });
 
   if (!result.success) {
     if (result.variableErrors) {
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables/route.tsx
index edef3d30603..f7f91f33274 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.environment-variables/route.tsx
@@ -9,21 +9,22 @@ import {
   PlusIcon,
   TrashIcon,
 } from "@heroicons/react/20/solid";
-import { Form, type MetaFunction, Outlet, useActionData, useNavigation } from "@remix-run/react";
+import { Form, type MetaFunction, Outlet, useActionData, useFetcher, useNavigation, useRevalidator } from "@remix-run/react";
 import {
   type ActionFunctionArgs,
   type LoaderFunctionArgs,
   json,
-  redirectDocument,
 } from "@remix-run/server-runtime";
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { EnvironmentCombo } from "~/components/environments/EnvironmentLabel";
+import { VercelLogo } from "~/components/integrations/VercelLogo";
 import { PageBody, PageContainer } from "~/components/layout/AppLayout";
 import { Button, LinkButton } from "~/components/primitives/Buttons";
 import { ClipboardField } from "~/components/primitives/ClipboardField";
 import { CopyableText } from "~/components/primitives/CopyableText";
+import { DateTime } from "~/components/primitives/DateTime";
 import { Dialog, DialogContent, DialogHeader, DialogTrigger } from "~/components/primitives/Dialog";
 import { Fieldset } from "~/components/primitives/Fieldset";
 import { FormButtons } from "~/components/primitives/FormButtons";
@@ -71,6 +72,11 @@ import {
   EditEnvironmentVariableValue,
   EnvironmentVariable,
 } from "~/v3/environmentVariables/repository";
+import { UserAvatar } from "~/components/UserProfilePhoto";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
+import { fromPromise } from "neverthrow";
+import { logger } from "~/services/logger.server";
+import { shouldSyncEnvVar, isPullEnvVarsEnabledForEnvironment, type TriggerEnvironmentType } from "~/v3/vercel/vercelProjectIntegrationSchema";
 
 export const meta: MetaFunction = () => {
   return [
@@ -86,7 +92,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
   try {
     const presenter = new EnvironmentVariablesPresenter();
-    const { environmentVariables, environments, hasStaging } = await presenter.call({
+    const { environmentVariables, environments, hasStaging, vercelIntegration } = await presenter.call({
       userId,
       projectSlug: projectParam,
     });
@@ -95,6 +101,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       environmentVariables,
       environments,
       hasStaging,
+      vercelIntegration,
     });
   } catch (error) {
     console.error(error);
@@ -112,6 +119,12 @@ const schema = z.discriminatedUnion("action", [
     key: z.string(),
     ...DeleteEnvironmentVariableValue.shape,
   }),
+  z.object({
+    action: z.literal("update-vercel-sync"),
+    key: z.string(),
+    environmentType: z.enum(["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"]),
+    syncEnabled: z.union([z.literal("true"), z.literal("false")]).transform((val) => val === "true"),
+  }),
 ]);
 
 export const action = async ({ request, params }: ActionFunctionArgs) => {
@@ -152,26 +165,20 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   switch (submission.value.action) {
     case "edit": {
       const repository = new EnvironmentVariablesRepository(prisma);
-      const result = await repository.editValue(project.id, submission.value);
+      const result = await repository.editValue(project.id, {
+        ...submission.value,
+        lastUpdatedBy: {
+          type: "user",
+          userId,
+        },
+      });
 
       if (!result.success) {
         submission.error.key = [result.error];
         return json(submission);
       }
 
-      //use redirectDocument because it reloads the page
-      return redirectDocument(
-        v3EnvironmentVariablesPath(
-          { slug: organizationSlug },
-          { slug: projectParam },
-          { slug: envParam }
-        ),
-        {
-          headers: {
-            refresh: "true",
-          },
-        }
-      );
+      return json({ ...submission, success: true });
     }
     case "delete": {
       const repository = new EnvironmentVariablesRepository(prisma);
@@ -182,6 +189,32 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
         return json(submission);
       }
 
+      // Clean up syncEnvVarsMapping if Vercel integration exists (best-effort)
+      const { environmentId, key } = submission.value;
+      const vercelService = new VercelIntegrationService();
+      await fromPromise(
+        (async () => {
+          const integration = await vercelService.getVercelProjectIntegration(project.id);
+          if (integration) {
+            const runtimeEnv = await prisma.runtimeEnvironment.findUnique({
+              where: { id: environmentId },
+              select: { type: true },
+            });
+            if (runtimeEnv) {
+              await vercelService.removeSyncEnvVarForEnvironment(
+                project.id,
+                key,
+                runtimeEnv.type as TriggerEnvironmentType
+              );
+            }
+          }
+        })(),
+        (error) => error
+      ).mapErr((error) => {
+        logger.error("Failed to remove Vercel sync mapping", { error });
+        return error;
+      });
+
       return redirectWithSuccessMessage(
         v3EnvironmentVariablesPath(
           { slug: organizationSlug },
@@ -192,19 +225,38 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
         `Deleted ${submission.value.key} environment variable`
       );
     }
+    case "update-vercel-sync": {
+      const vercelService = new VercelIntegrationService();
+      const integration = await vercelService.getVercelProjectIntegration(project.id);
+
+      if (!integration) {
+        submission.error.key = ["Vercel integration not found"];
+        return json(submission);
+      }
+
+      // Update the sync mapping for the specific env var and environment
+      await vercelService.updateSyncEnvVarForEnvironment(
+        project.id,
+        submission.value.key,
+        submission.value.environmentType,
+        submission.value.syncEnabled
+      );
+
+      return json({ success: true });
+    }
   }
 };
 
 export default function Page() {
   const [revealAll, setRevealAll] = useState(false);
-  const { environmentVariables, environments } = useTypedLoaderData<typeof loader>();
+  const { environmentVariables, environments, vercelIntegration } = useTypedLoaderData<typeof loader>();
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
   const { filterText, setFilterText, filteredItems } =
     useFuzzyFilter<EnvironmentVariableWithSetValues>({
       items: environmentVariables,
-      keys: ["key", "value"],
+      keys: ["key", "value", "environment.type", "environment.branchName"],
     });
 
   // Add isFirst and isLast to each environment variable
@@ -292,10 +344,32 @@ export default function Page() {
           <Table containerClassName={cn(filteredItems.length === 0 && "border-t-0")}>
             <TableHeader>
               <TableRow>
-                <TableHeaderCell className="w-[25%]">Key</TableHeaderCell>
-                <TableHeaderCell className="w-[55%]">Value</TableHeaderCell>
-                <TableHeaderCell className="w-[20%]">Environment</TableHeaderCell>
-                <TableHeaderCell hiddenLabel className="pl-24">
+                <TableHeaderCell className={vercelIntegration?.enabled ? "w-[22%]" : "w-[25%]"}>
+                  Key
+                </TableHeaderCell>
+                <TableHeaderCell className={vercelIntegration?.enabled ? "w-[32%]" : "w-[37%]"}>
+                  Value
+                </TableHeaderCell>
+                <TableHeaderCell className={vercelIntegration?.enabled ? "w-[13%]" : "w-[15%]"}>
+                  Environment
+                </TableHeaderCell>
+                {vercelIntegration?.enabled && (
+                  <TableHeaderCell className="w-[8%]">
+                    <SimpleTooltip
+                      button={
+                        <span className="flex items-center gap-1">
+                          Sync
+                          <InformationCircleIcon className="size-4 text-text-dimmed" />
+                        </span>
+                      }
+                      content="When enabled, this variable will be pulled from Vercel during builds. Requires 'Pull env vars before build' to be enabled in settings."
+                    />
+                  </TableHeaderCell>
+                )}
+                <TableHeaderCell className={vercelIntegration?.enabled ? "w-[24%]" : "w-[22%]"}>
+                  Updated
+                </TableHeaderCell>
+                <TableHeaderCell hiddenLabel className="w-0">
                   Actions
                 </TableHeaderCell>
               </TableRow>
@@ -354,9 +428,54 @@ export default function Page() {
                       <TableCell className={cn(cellClassName, borderedCellClassName)}>
                         <EnvironmentCombo environment={variable.environment} className="text-sm" />
                       </TableCell>
+                      {vercelIntegration?.enabled && (
+                        <TableCell className={cn(cellClassName, borderedCellClassName)}>
+                          {variable.environment.type !== "DEVELOPMENT" && (
+                            <VercelSyncCheckbox
+                              envVarKey={variable.key}
+                              environmentType={variable.environment.type as TriggerEnvironmentType}
+                              syncEnabled={shouldSyncEnvVar(
+                                vercelIntegration.syncEnvVarsMapping,
+                                variable.key,
+                                variable.environment.type as TriggerEnvironmentType
+                              )}
+                              pullEnvVarsEnabledForEnv={isPullEnvVarsEnabledForEnvironment(
+                                vercelIntegration.pullEnvVarsBeforeBuild,
+                                variable.environment.type as TriggerEnvironmentType
+                              )}
+                            />
+                          )}
+                        </TableCell>
+                      )}
+                      <TableCell className={cn(cellClassName, borderedCellClassName)}>
+                        <div className="flex items-center gap-3">
+                          {variable.updatedByUser ? (
+                            <div className="flex items-center gap-2">
+                              <UserAvatar
+                                avatarUrl={variable.updatedByUser.avatarUrl}
+                                name={variable.updatedByUser.name}
+                                className="size-5"
+                              />
+                              <span className="text-sm">{variable.updatedByUser.name}</span>
+                            </div>
+                          ) : (variable.lastUpdatedBy?.type === "integration" && variable.lastUpdatedBy?.integration === 'vercel' ) ? (
+                            <div className="flex items-center gap-2">
+                              <VercelLogo className="size-4 text-text-dimmed group-hover/table-row:text-text-bright transition-colors" />
+                              <span className="text-sm text-text-dimmed group-hover/table-row:text-text-bright capitalize transition-colors">
+                                {variable.lastUpdatedBy.integration}
+                              </span>
+                            </div>
+                          ) : null}
+                          {variable.updatedAt ? (
+                            <span className="text-sm text-text-dimmed">
+                              <DateTime date={variable.updatedAt} includeSeconds={false} />
+                            </span>
+                          ) : null}
+                        </div>
+                      </TableCell>
                       <TableCellMenu
-                        className={cn(cellClassName, borderedCellClassName)}
                         isSticky
+                        className="w-0 [&:has(.group-hover/table-row:block)]:w-auto"
                         hiddenButtons={
                           <>
                             <EditEnvironmentVariablePanel
@@ -372,7 +491,7 @@ export default function Page() {
                 })
               ) : (
                 <TableRow>
-                  <TableCell colSpan={4}>
+                  <TableCell colSpan={vercelIntegration?.enabled ? 6 : 5}>
                     {environmentVariables.length === 0 ? (
                       <div className="flex flex-col items-center justify-center gap-y-4 py-8">
                         <Header2>You haven't set any environment variables yet.</Header2>
@@ -417,16 +536,20 @@ function EditEnvironmentVariablePanel({
   revealAll: boolean;
 }) {
   const [isOpen, setIsOpen] = useState(false);
-  const lastSubmission = useActionData();
-  const navigation = useNavigation();
+  const fetcher = useFetcher<typeof action>();
+  const lastSubmission = fetcher.data as any;
 
-  const isLoading =
-    navigation.state !== "idle" &&
-    navigation.formMethod === "post" &&
-    navigation.formData?.get("action") === "edit";
+  const isLoading = fetcher.state !== "idle";
+
+  // Close dialog on successful submission
+  useEffect(() => {
+    if (lastSubmission?.success && fetcher.state === "idle") {
+      setIsOpen(false);
+    }
+  }, [lastSubmission?.success, fetcher.state]);
 
   const [form, { id, environmentId, value }] = useForm({
-    id: "edit-environment-variable",
+    id: `edit-environment-variable-${variable.id}-${variable.environment.id}`,
     // TODO: type this
     lastSubmission: lastSubmission as any,
     onValidate({ formData }) {
@@ -439,12 +562,12 @@ function EditEnvironmentVariablePanel({
     <Dialog open={isOpen} onOpenChange={setIsOpen}>
       <DialogTrigger asChild>
         <Button variant="small-menu-item" LeadingIcon={PencilSquareIcon} fullWidth textAlignLeft>
-          Edit
+          
         </Button>
       </DialogTrigger>
       <DialogContent>
         <DialogHeader>Edit environment variable</DialogHeader>
-        <Form method="post" {...form.props}>
+        <fetcher.Form method="post" {...form.props}>
           <input type="hidden" name="action" value="edit" />
           <input {...conform.input(id, { type: "hidden" })} value={variable.id} />
           <input
@@ -490,7 +613,7 @@ function EditEnvironmentVariablePanel({
               }
             />
           </Fieldset>
-        </Form>
+        </fetcher.Form>
       </DialogContent>
     </Dialog>
   );
@@ -535,8 +658,82 @@ function DeleteEnvironmentVariableButton({
         leadingIconClassName="text-rose-500 group-hover/button:text-text-bright transition-colors"
         className="ml-0.5 transition-colors group-hover/button:bg-error"
       >
-        {isLoading ? "Deleting" : "Delete"}
+        {isLoading ? "Deleting" : ""}
       </Button>
     </Form>
   );
 }
+
+/**
+ * Toggle component for controlling whether an environment variable is pulled from Vercel.
+ *
+ * When enabled, the variable will be pulled from Vercel during builds.
+ * By default, all variables are pulled unless explicitly disabled.
+ *
+ * Note: If the env slug is missing from syncEnvVarsMapping, all vars are pulled by default.
+ * Only when syncEnvVarsMapping[envSlug][envVarName] = false, the env var is skipped during builds.
+ */
+function VercelSyncCheckbox({
+  envVarKey,
+  environmentType,
+  syncEnabled,
+  pullEnvVarsEnabledForEnv,
+}: {
+  envVarKey: string;
+  environmentType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT";
+  syncEnabled: boolean;
+  pullEnvVarsEnabledForEnv: boolean;
+}) {
+  const fetcher = useFetcher();
+  const revalidator = useRevalidator();
+
+  const isLoading = fetcher.state !== "idle";
+
+  // Revalidate loader data after successful submission (without full page reload)
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data) {
+      const data = fetcher.data as { success?: boolean };
+      if (data.success) {
+        revalidator.revalidate();
+      }
+    }
+  }, [fetcher.state, fetcher.data, revalidator]);
+
+  const handleChange = (checked: boolean) => {
+    fetcher.submit(
+      {
+        action: "update-vercel-sync",
+        key: envVarKey,
+        environmentType,
+        syncEnabled: checked.toString(),
+      },
+      { method: "post" }
+    );
+  };
+
+  // If pull env vars is disabled for this environment, show disabled state
+  if (!pullEnvVarsEnabledForEnv) {
+    return (
+      <SimpleTooltip
+        button={
+          <Switch
+            variant="small"
+            checked={false}
+            disabled
+            onCheckedChange={() => {}}
+          />
+        }
+        content="Enable 'Pull env vars before build' for this environment in Vercel settings."
+      />
+    );
+  }
+
+  return (
+    <Switch
+      variant="small"
+      checked={syncEnabled}
+      disabled={isLoading}
+      onCheckedChange={handleChange}
+    />
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.$fingerprint/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.$fingerprint/route.tsx
new file mode 100644
index 00000000000..f42c73b5ea3
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.$fingerprint/route.tsx
@@ -0,0 +1,927 @@
+import { type LoaderFunctionArgs, type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { type MetaFunction, useFetcher, useRevalidator } from "@remix-run/react";
+import { BellAlertIcon } from "@heroicons/react/20/solid";
+import { IconAlarmSnooze as IconAlarmSnoozeBase, IconCircleDotted } from "@tabler/icons-react";
+import { parse } from "@conform-to/zod";
+import { z } from "zod";
+import { ErrorStatusBadge } from "~/components/errors/ErrorStatusBadge";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { TypedAwait, typeddefer, useTypedLoaderData } from "remix-typedjson";
+import { requireUser, requireUserId } from "~/services/session.server";
+import {
+  EnvironmentParamSchema,
+  v3CreateBulkActionPath,
+  v3ErrorsPath,
+  v3RunsPath,
+} from "~/utils/pathBuilder";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  ErrorGroupPresenter,
+  type ErrorGroupActivity,
+  type ErrorGroupActivityVersions,
+  type ErrorGroupOccurrences,
+  type ErrorGroupSummary,
+  type ErrorGroupState,
+} from "~/presenters/v3/ErrorGroupPresenter.server";
+import { type NextRunList } from "~/presenters/v3/NextRunListPresenter.server";
+import { $replica } from "~/db.server";
+import { logsClickhouseClient, clickhouseClient } from "~/services/clickhouseInstance.server";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import { PageBody } from "~/components/layout/AppLayout";
+import {
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+} from "~/components/primitives/Resizable";
+import { AnimatePresence, motion } from "framer-motion";
+import { Suspense, useEffect, useMemo, useRef, useState } from "react";
+import { Spinner } from "~/components/primitives/Spinner";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Callout } from "~/components/primitives/Callout";
+import { Header2, Header3 } from "~/components/primitives/Headers";
+
+import { formatDistanceToNow, isPast } from "date-fns";
+
+import * as Property from "~/components/primitives/PropertyTable";
+import { TaskRunsTable } from "~/components/runs/v3/TaskRunsTable";
+import { DateTime, RelativeDateTime } from "~/components/primitives/DateTime";
+import { ErrorId } from "@trigger.dev/core/v3/isomorphic";
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  ResponsiveContainer,
+  Tooltip,
+  type TooltipProps,
+  XAxis,
+  YAxis,
+} from "recharts";
+import TooltipPortal from "~/components/primitives/TooltipPortal";
+import { TimeFilter, timeFilterFromTo } from "~/components/runs/v3/SharedFilters";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { DirectionSchema, ListPagination } from "~/components/ListPagination";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { ListCheckedIcon } from "~/assets/icons/ListCheckedIcon";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { RunsIcon } from "~/assets/icons/RunsIcon";
+import type { TaskRunListSearchFilters } from "~/components/runs/v3/RunFilters";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { CopyableText } from "~/components/primitives/CopyableText";
+import { cn } from "~/utils/cn";
+import { LogsVersionFilter } from "~/components/logs/LogsVersionFilter";
+import { CodeBlock } from "~/components/code/CodeBlock";
+
+import { Popover, PopoverArrowTrigger, PopoverContent } from "~/components/primitives/Popover";
+import { ErrorGroupActions } from "~/v3/services/errorGroupActions.server";
+import {
+  ErrorStatusMenuItems,
+  CustomIgnoreDialog,
+  statusActionToastMessage,
+} from "~/components/errors/ErrorStatusMenu";
+import { useToast } from "~/components/primitives/Toast";
+
+export const meta: MetaFunction<typeof loader> = ({ data }) => {
+  return [
+    {
+      title: `Error Details | Trigger.dev`,
+    },
+  ];
+};
+
+const emptyStringToUndefined = z.preprocess(
+  (v) => (v === "" ? undefined : v),
+  z.coerce.number().positive().optional()
+);
+
+const actionSchema = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("resolve"),
+    taskIdentifier: z.string().min(1),
+    resolvedInVersion: z.string().optional(),
+  }),
+  z.object({
+    action: z.literal("ignore"),
+    taskIdentifier: z.string().min(1),
+    duration: emptyStringToUndefined,
+    occurrenceRate: emptyStringToUndefined,
+    totalOccurrences: emptyStringToUndefined,
+    reason: z.preprocess((v) => (v === "" ? undefined : v), z.string().optional()),
+  }),
+  z.object({
+    action: z.literal("unresolve"),
+    taskIdentifier: z.string().min(1),
+  }),
+]);
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+  const fingerprint = params.fingerprint;
+
+  if (!fingerprint) {
+    return json({ error: "Fingerprint parameter is required" }, { status: 400 });
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    return json({ error: "Project not found" }, { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    return json({ error: "Environment not found" }, { status: 404 });
+  }
+
+  const formData = await request.formData();
+  const submission = parse(formData, { schema: actionSchema });
+
+  if (!submission.value) {
+    return json(submission);
+  }
+
+  const actions = new ErrorGroupActions();
+  const identifier = {
+    organizationId: project.organizationId,
+    projectId: project.id,
+    environmentId: environment.id,
+    taskIdentifier: submission.value.taskIdentifier,
+    errorFingerprint: fingerprint,
+  };
+
+  switch (submission.value.action) {
+    case "resolve": {
+      await actions.resolveError(identifier, {
+        userId,
+        resolvedInVersion: submission.value.resolvedInVersion,
+      });
+      return json({ ok: true });
+    }
+    case "ignore": {
+      let occurrenceCountAtIgnoreTime: number | undefined;
+
+      if (submission.value.totalOccurrences) {
+        const qb = clickhouseClient.errors.listQueryBuilder();
+        qb.where("organization_id = {organizationId: String}", {
+          organizationId: project.organizationId,
+        });
+        qb.where("project_id = {projectId: String}", { projectId: project.id });
+        qb.where("environment_id = {environmentId: String}", {
+          environmentId: environment.id,
+        });
+        qb.where("error_fingerprint = {fingerprint: String}", { fingerprint });
+        qb.where("task_identifier = {taskIdentifier: String}", {
+          taskIdentifier: submission.value.taskIdentifier,
+        });
+        qb.groupBy("error_fingerprint, task_identifier");
+
+        const [err, results] = await qb.execute();
+        if (err || !results || results.length === 0) {
+          return json(
+            { error: "Failed to fetch current occurrence count. Please try again." },
+            { status: 500 }
+          );
+        }
+        occurrenceCountAtIgnoreTime = results[0].occurrence_count;
+      }
+
+      await actions.ignoreError(identifier, {
+        userId,
+        duration: submission.value.duration,
+        occurrenceRateThreshold: submission.value.occurrenceRate,
+        totalOccurrencesThreshold: submission.value.totalOccurrences,
+        occurrenceCountAtIgnoreTime,
+        reason: submission.value.reason,
+      });
+      return json({ ok: true });
+    }
+    case "unresolve": {
+      await actions.unresolveError(identifier);
+      return json({ ok: true });
+    }
+  }
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const userId = user.id;
+
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+  const fingerprint = params.fingerprint;
+
+  if (!fingerprint) {
+    throw new Response("Fingerprint parameter is required", { status: 400 });
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const period = url.searchParams.get("period") ?? undefined;
+  const fromStr = url.searchParams.get("from");
+  const toStr = url.searchParams.get("to");
+  const from = fromStr ? parseInt(fromStr, 10) : undefined;
+  const to = toStr ? parseInt(toStr, 10) : undefined;
+  const versions = url.searchParams.getAll("versions").filter((v) => v.length > 0);
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  const directionRaw = url.searchParams.get("direction") ?? undefined;
+  const direction = directionRaw ? DirectionSchema.parse(directionRaw) : undefined;
+
+  const presenter = new ErrorGroupPresenter($replica, logsClickhouseClient, clickhouseClient);
+
+  const detailPromise = presenter
+    .call(project.organizationId, environment.id, {
+      userId,
+      projectId: project.id,
+      fingerprint,
+      versions: versions.length > 0 ? versions : undefined,
+      period,
+      from,
+      to,
+      cursor,
+      direction,
+    })
+    .catch((error) => {
+      if (error instanceof ServiceValidationError) {
+        return { error: error.message };
+      }
+      throw error;
+    });
+
+  const time = timeFilterFromTo({ period, from, to, defaultPeriod: "7d" });
+
+  const activityPromise = presenter
+    .getOccurrences(
+      project.organizationId,
+      project.id,
+      environment.id,
+      fingerprint,
+      time.from,
+      time.to,
+      versions.length > 0 ? versions : undefined
+    )
+    .catch(() => ({ data: [] as ErrorGroupActivity, versions: [] as string[] }));
+
+  return typeddefer({
+    data: detailPromise,
+    activity: activityPromise,
+    organizationSlug,
+    projectParam,
+    envParam,
+    fingerprint,
+  });
+};
+
+export default function Page() {
+  const { data, activity, organizationSlug, projectParam, envParam, fingerprint } =
+    useTypedLoaderData<typeof loader>();
+
+  const location = useOptimisticLocation();
+  const searchParams = new URLSearchParams(location.search);
+
+  const errorsPath = useMemo(() => {
+    const base = v3ErrorsPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam }
+    );
+    const carry = new URLSearchParams();
+    const period = searchParams.get("period");
+    const from = searchParams.get("from");
+    const to = searchParams.get("to");
+    if (period) carry.set("period", period);
+    if (from) carry.set("from", from);
+    if (to) carry.set("to", to);
+    for (const v of searchParams.getAll("versions")) {
+      if (v) carry.append("versions", v);
+    }
+    const qs = carry.toString();
+    return qs ? `${base}?${qs}` : base;
+  }, [organizationSlug, projectParam, envParam, searchParams.toString()]);
+
+  const alertsHref = useMemo(() => {
+    const params = new URLSearchParams(location.search);
+    params.set("alerts", "true");
+    return `?${params.toString()}`;
+  }, [location.search]);
+
+  return (
+    <>
+      <NavBar>
+        <PageTitle
+          backButton={{
+            to: errorsPath,
+            text: "Errors",
+          }}
+          title={<span className="font-mono text-xs">{ErrorId.toFriendlyId(fingerprint)}</span>}
+        />
+      </NavBar>
+
+      <PageBody scrollable={false}>
+        <Suspense
+          fallback={
+            <div className="my-2 flex items-center justify-center">
+              <div className="mx-auto flex items-center gap-2">
+                <Spinner />
+                <Paragraph variant="small">Loading error details…</Paragraph>
+              </div>
+            </div>
+          }
+        >
+          <TypedAwait
+            resolve={data}
+            errorElement={
+              <div className="flex items-center justify-center px-3 py-12">
+                <Callout variant="error" className="max-w-fit">
+                  Unable to load error details. Please refresh the page or try again in a moment.
+                </Callout>
+              </div>
+            }
+          >
+            {(result) => {
+              if ("error" in result) {
+                return (
+                  <div className="flex items-center justify-center px-3 py-12">
+                    <Callout variant="error" className="max-w-fit">
+                      {result.error}
+                    </Callout>
+                  </div>
+                );
+              }
+              return (
+                <ErrorGroupDetail
+                  errorGroup={result.errorGroup}
+                  runList={result.runList}
+                  activity={activity}
+                  organizationSlug={organizationSlug}
+                  projectParam={projectParam}
+                  envParam={envParam}
+                  fingerprint={fingerprint}
+                  alertsHref={alertsHref}
+                />
+              );
+            }}
+          </TypedAwait>
+        </Suspense>
+      </PageBody>
+    </>
+  );
+}
+
+function ErrorGroupDetail({
+  errorGroup,
+  runList,
+  activity,
+  organizationSlug,
+  projectParam,
+  envParam,
+  fingerprint,
+  alertsHref,
+}: {
+  errorGroup: ErrorGroupSummary | undefined;
+  runList: NextRunList | undefined;
+  activity: Promise<ErrorGroupOccurrences>;
+  organizationSlug: string;
+  projectParam: string;
+  envParam: string;
+  fingerprint: string;
+  alertsHref: string;
+}) {
+  const { value, values } = useSearchParams();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  if (!errorGroup) {
+    return (
+      <div className="flex h-full items-center justify-center">
+        <div className="text-center">
+          <Header3 className="mb-2">Error not found</Header3>
+          <Paragraph variant="small">
+            This error group does not exist or has no instances.
+          </Paragraph>
+        </div>
+      </div>
+    );
+  }
+
+  const fromValue = value("from") ?? undefined;
+  const toValue = value("to") ?? undefined;
+  const selectedVersions = values("versions").filter((v) => v !== "");
+
+  const filters: TaskRunListSearchFilters = {
+    period: value("period") ?? undefined,
+    from: fromValue ? parseInt(fromValue, 10) : undefined,
+    to: toValue ? parseInt(toValue, 10) : undefined,
+    versions: selectedVersions.length > 0 ? selectedVersions : undefined,
+    rootOnly: false,
+    errorId: ErrorId.toFriendlyId(fingerprint),
+  };
+
+  return (
+    <ResizablePanelGroup orientation="horizontal" className="max-h-full">
+      {/* Main content: chart + runs */}
+      <ResizablePanel id="error-main" min="300px">
+        <div className="grid h-full grid-rows-[12rem_1fr] overflow-hidden">
+          {/* Activity chart */}
+          <div className="flex flex-col gap-3 overflow-hidden border-b border-grid-bright bg-background-bright py-2 pl-2 pr-4">
+            <div className="flex items-center gap-2">
+              <TimeFilter defaultPeriod="7d" labelName="Occurred" />
+              <LogsVersionFilter />
+            </div>
+
+            <Suspense fallback={<ActivityChartBlankState />}>
+              <TypedAwait resolve={activity} errorElement={<ActivityChartBlankState />}>
+                {(result) => {
+                  if (result.data.length > 0 && result.versions.length > 0) {
+                    return <ActivityChart activity={result.data} versions={result.versions} />;
+                  }
+                  return <ActivityChartBlankState />;
+                }}
+              </TypedAwait>
+            </Suspense>
+          </div>
+
+          {/* Runs Table */}
+          <div className="flex flex-col gap-1 overflow-y-hidden">
+            <div className="flex items-center justify-between pl-3 pr-2 pt-1">
+              <Header3 className="mb-1 mt-2">Runs</Header3>
+              {runList && (
+                <div className="flex items-center gap-2">
+                  <LinkButton
+                    variant="secondary/small"
+                    to={v3RunsPath(organization, project, environment, filters)}
+                    LeadingIcon={RunsIcon}
+                  >
+                    View all runs
+                  </LinkButton>
+                  <LinkButton
+                    variant="secondary/small"
+                    to={v3CreateBulkActionPath(
+                      organization,
+                      project,
+                      environment,
+                      filters,
+                      "filter",
+                      "replay"
+                    )}
+                    LeadingIcon={ListCheckedIcon}
+                  >
+                    Bulk replay…
+                  </LinkButton>
+                  <ListPagination list={runList} />
+                </div>
+              )}
+            </div>
+            {runList ? (
+              <TaskRunsTable
+                total={runList.runs.length}
+                hasFilters={selectedVersions.length > 0}
+                filters={{
+                  tasks: [],
+                  versions: selectedVersions,
+                  statuses: [],
+                  from: undefined,
+                  to: undefined,
+                }}
+                runs={runList.runs}
+                isLoading={false}
+                variant="dimmed"
+                additionalTableState={{ errorId: ErrorId.toFriendlyId(fingerprint) }}
+              />
+            ) : (
+              <Paragraph variant="small" className="p-4 text-text-dimmed">
+                No runs found for this error.
+              </Paragraph>
+            )}
+          </div>
+        </div>
+      </ResizablePanel>
+
+      {/* Right-hand detail sidebar */}
+      <ResizableHandle id="error-detail-handle" />
+      <ResizablePanel id="error-detail" min="280px" default="380px" max="500px" isStaticAtRest>
+        <ErrorDetailSidebar
+          errorGroup={errorGroup}
+          fingerprint={fingerprint}
+          alertsHref={alertsHref}
+        />
+      </ResizablePanel>
+    </ResizablePanelGroup>
+  );
+}
+
+function ErrorDetailSidebar({
+  errorGroup,
+  fingerprint,
+  alertsHref,
+}: {
+  errorGroup: ErrorGroupSummary;
+  fingerprint: string;
+  alertsHref: string;
+}) {
+  return (
+    <div className="grid h-full grid-rows-[auto_1fr] overflow-hidden bg-background-bright">
+      <div className="flex items-center justify-between border-b border-grid-dimmed py-2 pl-3 pr-2">
+        <Header2 className="truncate">Details</Header2>
+        <LinkButton
+          to={alertsHref}
+          variant="secondary/small"
+          LeadingIcon={BellAlertIcon}
+          leadingIconClassName="text-alerts"
+        >
+          Configure alerts
+        </LinkButton>
+      </div>
+      <div className="overflow-y-auto px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <div className="flex flex-col gap-4">
+          <Property.Table>
+            {/* Status */}
+            <Property.Item className="gap-1">
+              <Property.Label>Error status</Property.Label>
+              <Property.Value>
+                <div className="flex items-center justify-between">
+                  <ErrorStatusBadge status={errorGroup.state.status} className="w-fit" />
+                  <ErrorStatusDropdown
+                    state={errorGroup.state}
+                    taskIdentifier={errorGroup.taskIdentifier}
+                  />
+                </div>
+
+                <AnimatePresence>
+                  {errorGroup.state.status === "IGNORED" && (
+                    <motion.div
+                      initial={{ height: 0, opacity: 0 }}
+                      animate={{ height: "auto", opacity: 1 }}
+                      exit={{ height: 0, opacity: 0 }}
+                      transition={{ duration: 0.15, ease: "easeInOut" }}
+                      className="overflow-hidden"
+                    >
+                      <IgnoredDetails
+                        className="mt-2"
+                        state={errorGroup.state}
+                        totalOccurrences={errorGroup.count}
+                      />
+                    </motion.div>
+                  )}
+                </AnimatePresence>
+              </Property.Value>
+            </Property.Item>
+
+            {/* Error message */}
+            <Property.Item className="gap-1">
+              <Property.Label>Error</Property.Label>
+              <Property.Value>
+                <CodeBlock
+                  code={errorGroup.errorMessage}
+                  showCopyButton
+                  showLineNumbers={false}
+                  showOpenInModal={false}
+                  language="typescript"
+                  wrap
+                />
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>ID</Property.Label>
+              <Property.Value>
+                <CopyableText value={ErrorId.toFriendlyId(errorGroup.fingerprint)} />
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>Task</Property.Label>
+              <Property.Value>
+                <CopyableText value={errorGroup.taskIdentifier} />
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>Occurrences</Property.Label>
+              <Property.Value>
+                <span className="tabular-nums">{errorGroup.count.toLocaleString()}</span>
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>First seen</Property.Label>
+              <Property.Value>
+                <DateTime date={errorGroup.firstSeen} />
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>Last seen</Property.Label>
+              <Property.Value>
+                <RelativeDateTime date={errorGroup.lastSeen} />
+              </Property.Value>
+            </Property.Item>
+            {errorGroup.affectedVersions.length > 0 && (
+              <Property.Item>
+                <Property.Label>Versions</Property.Label>
+                <Property.Value>
+                  <span className="font-mono text-sm">
+                    {errorGroup.affectedVersions.join(", ")}
+                  </span>
+                </Property.Value>
+              </Property.Item>
+            )}
+          </Property.Table>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function IgnoredDetails({
+  state,
+  totalOccurrences,
+  className,
+}: {
+  state: ErrorGroupState;
+  totalOccurrences: number;
+  className?: string;
+}) {
+  if (state.status !== "IGNORED") {
+    return null;
+  }
+
+  const hasConditions =
+    state.ignoredUntil || state.ignoredUntilOccurrenceRate || state.ignoredUntilTotalOccurrences;
+
+  const ignoredForever = !hasConditions;
+
+  const occurrencesSinceIgnore =
+    state.ignoredUntilTotalOccurrences && state.ignoredAtOccurrenceCount !== null
+      ? totalOccurrences - state.ignoredAtOccurrenceCount
+      : null;
+
+  return (
+    <div
+      className={cn(
+        "flex flex-col gap-1.5 rounded border border-text-dimmed/20 bg-text-dimmed/5 px-3 py-2.5 text-sm",
+        className
+      )}
+    >
+      <div className="flex flex-col gap-2">
+        <div className="flex items-center gap-1">
+          <IconAlarmSnoozeBase className="size-5 text-blue-500" />
+          <Header3 className="text-text-bright">
+            {ignoredForever ? "Ignored permanently" : "Ignored with conditions"}
+          </Header3>
+        </div>
+        {(state.ignoredByUserDisplayName || state.ignoredAt) && (
+          <Paragraph variant="extra-small/dimmed">
+            {state.ignoredByUserDisplayName && <>Configured by {state.ignoredByUserDisplayName}</>}
+            {state.ignoredByUserDisplayName && state.ignoredAt && " "}
+            {state.ignoredAt && <RelativeDateTime date={state.ignoredAt} capitalize={false} />}
+          </Paragraph>
+        )}
+      </div>
+
+      {state.ignoredReason && (
+        <Paragraph variant="extra-small/dimmed">Reason: {state.ignoredReason}</Paragraph>
+      )}
+
+      {hasConditions && (
+        <div className="flex flex-col gap-1 text-xs text-text-dimmed">
+          {state.ignoredUntil && (
+            <span>
+              Will revert to "Unresolved" at:{" "}
+              <span className="text-text-bright">
+                <DateTime date={state.ignoredUntil} />
+              </span>
+              {isPast(state.ignoredUntil) && <span className="ml-1 text-warning">(expired)</span>}
+            </span>
+          )}
+          {state.ignoredUntilOccurrenceRate !== null && state.ignoredUntilOccurrenceRate > 0 && (
+            <span>
+              Will revert to "Unresolved" when: Occurrence rate exceeds{" "}
+              <span className="tabular-nums text-text-bright">
+                {state.ignoredUntilOccurrenceRate}/min
+              </span>
+            </span>
+          )}
+          {state.ignoredUntilTotalOccurrences !== null &&
+            state.ignoredUntilTotalOccurrences > 0 && (
+              <span>
+                Will revert to "Unresolved" when: Total occurrences exceed{" "}
+                <span className="tabular-nums text-text-bright">
+                  {state.ignoredUntilTotalOccurrences.toLocaleString()}
+                </span>
+                {occurrencesSinceIgnore !== null && (
+                  <span className="ml-1 tabular-nums text-text-dimmed">
+                    ({occurrencesSinceIgnore.toLocaleString()} since ignored)
+                  </span>
+                )}
+              </span>
+            )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ErrorStatusDropdown({
+  state,
+  taskIdentifier,
+}: {
+  state: ErrorGroupState;
+  taskIdentifier: string;
+}) {
+  const fetcher = useFetcher<{ ok?: boolean }>();
+  const revalidator = useRevalidator();
+  const [popoverOpen, setPopoverOpen] = useState(false);
+  const [customIgnoreOpen, setCustomIgnoreOpen] = useState(false);
+  const isSubmitting = fetcher.state !== "idle";
+  const toast = useToast();
+  const pendingToast = useRef<string | undefined>();
+
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data?.ok && pendingToast.current) {
+      toast.success(pendingToast.current);
+      pendingToast.current = undefined;
+      revalidator.revalidate();
+    }
+  }, [fetcher.state, fetcher.data, toast, revalidator]);
+
+  const act = (data: Record<string, string>) => {
+    setPopoverOpen(false);
+    pendingToast.current = statusActionToastMessage(data);
+    fetcher.submit(data, { method: "post" });
+  };
+
+  return (
+    <>
+      <Popover open={popoverOpen} onOpenChange={setPopoverOpen}>
+        <PopoverArrowTrigger variant="primary" disabled={isSubmitting} className="items-center">
+          <IconCircleDotted className="-ml-1 mr-1 size-3.5 text-text-bright" />
+          Mark error as…
+        </PopoverArrowTrigger>
+        <PopoverContent className="inline-flex !min-w-0 flex-col p-1" align="end">
+          <ErrorStatusMenuItems
+            status={state.status}
+            taskIdentifier={taskIdentifier}
+            onAction={act}
+            onCustomIgnore={() => {
+              setPopoverOpen(false);
+              setCustomIgnoreOpen(true);
+            }}
+          />
+        </PopoverContent>
+      </Popover>
+
+      <CustomIgnoreDialog
+        open={customIgnoreOpen}
+        onOpenChange={setCustomIgnoreOpen}
+        taskIdentifier={taskIdentifier}
+      />
+    </>
+  );
+}
+
+function ActivityChart({
+  activity,
+  versions,
+}: {
+  activity: ErrorGroupActivity;
+  versions: ErrorGroupActivityVersions;
+}) {
+  const ERROR_CHART_COLORS = ["#6c5ce7", "#ec4899"];
+  const colors = useMemo(
+    () => versions.map((_, i) => ERROR_CHART_COLORS[i % ERROR_CHART_COLORS.length]),
+    [versions]
+  );
+
+  const data = useMemo(
+    () =>
+      activity.map((d) => ({
+        ...d,
+        __timestamp: d.date instanceof Date ? d.date.getTime() : new Date(d.date).getTime(),
+      })),
+    [activity]
+  );
+
+  const midnightTicks = useMemo(() => {
+    const ticks: number[] = [];
+    for (const d of data) {
+      const date = new Date(d.__timestamp);
+      if (date.getHours() === 0 && date.getMinutes() === 0) {
+        ticks.push(d.__timestamp);
+      }
+    }
+    return ticks;
+  }, [data]);
+
+  const xAxisFormatter = useMemo(() => {
+    return (value: number) => {
+      const date = new Date(value);
+      return date.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+      });
+    };
+  }, []);
+
+  return (
+    <ResponsiveContainer width="100%" height="100%">
+      <BarChart data={data} margin={{ top: 4, right: 4, left: 0, bottom: 0 }}>
+        <CartesianGrid vertical={false} stroke="#272A2E" strokeDasharray="3 3" />
+        <XAxis
+          dataKey="__timestamp"
+          tickFormatter={xAxisFormatter}
+          ticks={midnightTicks}
+          height={24}
+          axisLine={false}
+          tickLine={false}
+          tick={{ fontSize: 11, fill: "#878C99" }}
+        />
+        <YAxis
+          width={30}
+          tickMargin={4}
+          axisLine={false}
+          tickLine={false}
+          tick={{ fontSize: 11, fill: "#878C99" }}
+          domain={["auto", (dataMax: number) => dataMax * 1.15]}
+        />
+        <Tooltip
+          cursor={{ fill: "rgba(255, 255, 255, 0.06)" }}
+          content={<ActivityTooltip versions={versions} colors={colors} />}
+          allowEscapeViewBox={{ x: true, y: true }}
+          wrapperStyle={{ zIndex: 1000 }}
+          animationDuration={0}
+        />
+        {versions.map((version, i) => (
+          <Bar
+            key={version}
+            dataKey={version}
+            stackId="versions"
+            fill={colors[i]}
+            strokeWidth={0}
+            isAnimationActive={false}
+          />
+        ))}
+      </BarChart>
+    </ResponsiveContainer>
+  );
+}
+
+const ActivityTooltip = ({
+  active,
+  payload,
+  versions,
+  colors,
+}: TooltipProps<number, string> & { versions: string[]; colors: string[] }) => {
+  if (!active || !payload?.length) return null;
+
+  const timestamp = payload[0]?.payload?.__timestamp as number | undefined;
+  if (!timestamp) return null;
+
+  const date = new Date(timestamp);
+  const formattedDate = date.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+
+  return (
+    <TooltipPortal active={active}>
+      <div className="rounded-sm border border-grid-bright bg-background-dimmed px-3 py-2">
+        <Header3 className="border-b border-b-charcoal-650 pb-2">{formattedDate}</Header3>
+        <div className="mt-2 flex flex-col gap-1">
+          {payload.map((entry, i) => {
+            const value = (entry.value as number) ?? 0;
+            return (
+              <div key={entry.dataKey} className="flex items-center gap-2 text-xs">
+                <div className="size-2 rounded-[2px]" style={{ backgroundColor: entry.color }} />
+                <span className="text-text-dimmed">{entry.dataKey}</span>
+                <span className="tabular-nums text-text-bright">{value}</span>
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    </TooltipPortal>
+  );
+};
+
+function ActivityChartBlankState() {
+  return (
+    <div className="flex min-h-0 flex-1 items-end gap-px rounded-sm">
+      {[...Array(42)].map((_, i) => (
+        <div key={i} className="h-full flex-1 bg-charcoal-850" />
+      ))}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors._index/route.tsx
new file mode 100644
index 00000000000..e92b5b34644
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors._index/route.tsx
@@ -0,0 +1,748 @@
+import * as Ariakit from "@ariakit/react";
+import { BellAlertIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { Form, useFetcher, useRevalidator, type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { IconBugFilled } from "@tabler/icons-react";
+import { ErrorId } from "@trigger.dev/core/v3/isomorphic";
+import { type ErrorGroupStatus } from "@trigger.dev/database";
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import {
+  Bar,
+  BarChart,
+  ReferenceLine,
+  ResponsiveContainer,
+  Tooltip,
+  YAxis,
+  type TooltipProps,
+} from "recharts";
+import { TypedAwait, typeddefer, useTypedLoaderData } from "remix-typedjson";
+import { ErrorStatusBadge } from "~/components/errors/ErrorStatusBadge";
+import { PageBody } from "~/components/layout/AppLayout";
+import { ListPagination } from "~/components/ListPagination";
+import { LogsTaskFilter } from "~/components/logs/LogsTaskFilter";
+import { LogsVersionFilter } from "~/components/logs/LogsVersionFilter";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { formatDateTime, RelativeDateTime } from "~/components/primitives/DateTime";
+import { Header3 } from "~/components/primitives/Headers";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { SearchInput } from "~/components/primitives/SearchInput";
+import {
+  ComboBox,
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { Spinner } from "~/components/primitives/Spinner";
+import {
+  CopyableTableCell,
+  Table,
+  TableBody,
+  TableCell,
+  TableCellMenu,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { PopoverSectionHeader } from "~/components/primitives/Popover";
+import {
+  ErrorStatusMenuItems,
+  CustomIgnoreDialog,
+  statusActionToastMessage,
+} from "~/components/errors/ErrorStatusMenu";
+import { useToast } from "~/components/primitives/Toast";
+import TooltipPortal from "~/components/primitives/TooltipPortal";
+import { appliedSummary, FilterMenuProvider, TimeFilter } from "~/components/runs/v3/SharedFilters";
+import { $replica } from "~/db.server";
+import { useInterval } from "~/hooks/useInterval";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  ErrorsListPresenter,
+  type ErrorGroup,
+  type ErrorOccurrenceActivity,
+  type ErrorOccurrences,
+  type ErrorsList as ErrorsListData,
+} from "~/presenters/v3/ErrorsListPresenter.server";
+import { logsClickhouseClient } from "~/services/clickhouseInstance.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+import { requireUser } from "~/services/session.server";
+import { formatNumberCompact } from "~/utils/numberFormatter";
+import { EnvironmentParamSchema, v3ErrorPath } from "~/utils/pathBuilder";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+
+export const meta: MetaFunction = () => {
+  return [
+    {
+      title: `Errors | Trigger.dev`,
+    },
+  ];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const userId = user.id;
+
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const tasks = url.searchParams.getAll("tasks").filter((t) => t.length > 0);
+  const versions = url.searchParams.getAll("versions").filter((v) => v.length > 0);
+  const statuses = url.searchParams
+    .getAll("status")
+    .filter(
+      (s): s is ErrorGroupStatus => s === "UNRESOLVED" || s === "RESOLVED" || s === "IGNORED"
+    );
+  const search = url.searchParams.get("search") ?? undefined;
+  const period = url.searchParams.get("period") ?? undefined;
+  const fromStr = url.searchParams.get("from");
+  const toStr = url.searchParams.get("to");
+  const from = fromStr ? parseInt(fromStr, 10) : undefined;
+  const to = toStr ? parseInt(toStr, 10) : undefined;
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  const directionRaw = url.searchParams.get("direction");
+  const direction =
+    directionRaw === "forward" || directionRaw === "backward" ? directionRaw : undefined;
+
+  const plan = await getCurrentPlan(project.organizationId);
+  const retentionLimitDays = plan?.v3Subscription?.plan?.limits.logRetentionDays.number ?? 30;
+
+  const presenter = new ErrorsListPresenter($replica, logsClickhouseClient);
+
+  const listPromise = presenter
+    .call(project.organizationId, environment.id, {
+      userId,
+      projectId: project.id,
+      tasks: tasks.length > 0 ? tasks : undefined,
+      versions: versions.length > 0 ? versions : undefined,
+      statuses: statuses.length > 0 ? statuses : undefined,
+      search,
+      period,
+      from,
+      to,
+      cursor,
+      direction,
+      defaultPeriod: "1d",
+      retentionLimitDays,
+    })
+    .catch((error) => {
+      if (error instanceof ServiceValidationError) {
+        return { error: error.message };
+      }
+      throw error;
+    });
+
+  const occurrencesPromise = listPromise.then((result) => {
+    if ("error" in result) return { data: {} };
+    const fingerprints = result.errorGroups.map((g) => g.fingerprint);
+    if (fingerprints.length === 0) return { data: {} };
+    return presenter.getOccurrences(
+      project.organizationId,
+      project.id,
+      environment.id,
+      fingerprints,
+      result.filters.from,
+      result.filters.to
+    );
+  });
+
+  return typeddefer({
+    data: listPromise,
+    occurrences: occurrencesPromise,
+    defaultPeriod: "1d",
+    retentionLimitDays,
+    organizationSlug,
+    projectParam,
+    envParam,
+  });
+};
+
+export default function Page() {
+  const {
+    data,
+    occurrences,
+    defaultPeriod,
+    retentionLimitDays,
+    organizationSlug,
+    projectParam,
+    envParam,
+  } = useTypedLoaderData<typeof loader>();
+
+  const revalidator = useRevalidator();
+  useInterval({
+    interval: 60_000,
+    onLoad: false,
+    callback: useCallback(() => {
+      if (revalidator.state === "idle") {
+        revalidator.revalidate();
+      }
+    }, [revalidator]),
+  });
+
+  const location = useOptimisticLocation();
+  const alertsHref = useMemo(() => {
+    const params = new URLSearchParams(location.search);
+    params.set("alerts", "true");
+    return `?${params.toString()}`;
+  }, [location.search]);
+
+  return (
+    <>
+      <NavBar>
+        <PageTitle title="Errors" />
+      </NavBar>
+
+      <PageBody scrollable={false}>
+        <Suspense
+          fallback={
+            <div className="grid h-full max-h-full grid-rows-[2.5rem_auto] overflow-hidden">
+              <div className="border-b border-grid-bright" />
+              <div className="my-2 flex items-center justify-center">
+                <div className="mx-auto flex items-center gap-2">
+                  <Spinner />
+                  <Paragraph variant="small">Loading errors…</Paragraph>
+                </div>
+              </div>
+            </div>
+          }
+        >
+          <TypedAwait
+            resolve={data}
+            errorElement={
+              <div className="grid h-full max-h-full grid-rows-[2.5rem_auto_1fr] overflow-hidden">
+                <FiltersBar
+                  defaultPeriod={defaultPeriod}
+                  retentionLimitDays={retentionLimitDays}
+                  alertsHref={alertsHref}
+                />
+                <div className="flex items-center justify-center px-3 py-12">
+                  <Callout variant="error" className="max-w-fit">
+                    Unable to load errors. Please refresh the page or try again in a moment.
+                  </Callout>
+                </div>
+              </div>
+            }
+          >
+            {(result) => {
+              if ("error" in result) {
+                return (
+                  <div className="grid h-full max-h-full grid-rows-[2.5rem_auto_1fr] overflow-hidden">
+                    <FiltersBar
+                      defaultPeriod={defaultPeriod}
+                      retentionLimitDays={retentionLimitDays}
+                      alertsHref={alertsHref}
+                    />
+                    <div className="flex items-center justify-center px-3 py-12">
+                      <Callout variant="error" className="max-w-fit">
+                        {result.error}
+                      </Callout>
+                    </div>
+                  </div>
+                );
+              }
+              return (
+                <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden">
+                  <FiltersBar
+                    list={result}
+                    defaultPeriod={defaultPeriod}
+                    retentionLimitDays={retentionLimitDays}
+                    alertsHref={alertsHref}
+                  />
+                  <ErrorsList
+                    errorGroups={result.errorGroups}
+                    occurrences={occurrences}
+                    organizationSlug={organizationSlug}
+                    projectParam={projectParam}
+                    envParam={envParam}
+                  />
+                </div>
+              );
+            }}
+          </TypedAwait>
+        </Suspense>
+      </PageBody>
+    </>
+  );
+}
+
+const errorStatusOptions = [
+  { value: "UNRESOLVED", label: "Unresolved" },
+  { value: "RESOLVED", label: "Resolved" },
+  { value: "IGNORED", label: "Ignored" },
+] as const;
+
+const statusIcon = <IconBugFilled className="size-4" />;
+const statusShortcut = { key: "s" };
+
+function StatusFilter() {
+  const { values, del } = useSearchParams();
+  const selectedStatuses = values("status");
+
+  if (selectedStatuses.length === 0 || selectedStatuses.every((v) => v === "")) {
+    return (
+      <FilterMenuProvider>
+        {(search, setSearch) => (
+          <ErrorStatusDropdown
+            trigger={
+              <SelectTrigger
+                icon={statusIcon}
+                variant="secondary/small"
+                shortcut={statusShortcut}
+                tooltipTitle="Filter by status"
+              >
+                <span className="ml-0.5">Status</span>
+              </SelectTrigger>
+            }
+            searchValue={search}
+            clearSearchValue={() => setSearch("")}
+          />
+        )}
+      </FilterMenuProvider>
+    );
+  }
+
+  return (
+    <FilterMenuProvider>
+      {(search, setSearch) => (
+        <ErrorStatusDropdown
+          trigger={
+            <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+              <AppliedFilter
+                label="Status"
+                icon={statusIcon}
+                value={appliedSummary(
+                  selectedStatuses.map((s) => {
+                    const opt = errorStatusOptions.find((o) => o.value === s);
+                    return opt ? opt.label : s;
+                  })
+                )}
+                onRemove={() => del(["status", "cursor", "direction"])}
+                variant="secondary/small"
+              />
+            </Ariakit.Select>
+          }
+          searchValue={search}
+          clearSearchValue={() => setSearch("")}
+        />
+      )}
+    </FilterMenuProvider>
+  );
+}
+
+function ErrorStatusDropdown({
+  trigger,
+  clearSearchValue,
+  onClose,
+}: {
+  trigger: ReactNode;
+  clearSearchValue: () => void;
+  searchValue: string;
+  onClose?: () => void;
+}) {
+  const { values, replace } = useSearchParams();
+
+  const handleChange = (values: string[]) => {
+    clearSearchValue();
+    replace({
+      status: values.length > 0 ? values : undefined,
+      cursor: undefined,
+      direction: undefined,
+    });
+  };
+
+  return (
+    <SelectProvider value={values("status")} setValue={handleChange} virtualFocus={true}>
+      {trigger}
+      <SelectPopover
+        className="min-w-0 max-w-[min(240px,var(--popover-available-width))]"
+        hideOnEscape={() => {
+          if (onClose) {
+            onClose();
+            return false;
+          }
+          return true;
+        }}
+      >
+        <SelectList>
+          {errorStatusOptions.map((item) => (
+            <SelectItem key={item.value} value={item.value}>
+              <ErrorStatusBadge status={item.value} />
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function FiltersBar({
+  list,
+  defaultPeriod,
+  retentionLimitDays,
+  alertsHref,
+}: {
+  list?: ErrorsListData;
+  defaultPeriod?: string;
+  retentionLimitDays: number;
+  alertsHref: string;
+}) {
+  const location = useOptimisticLocation();
+  const searchParams = new URLSearchParams(location.search);
+  const hasFilters =
+    searchParams.has("status") ||
+    searchParams.has("tasks") ||
+    searchParams.has("versions") ||
+    searchParams.has("search") ||
+    searchParams.has("period") ||
+    searchParams.has("from") ||
+    searchParams.has("to");
+
+  return (
+    <div className="flex items-start justify-between gap-x-2 border-b border-grid-bright p-2">
+      <div className="flex flex-row flex-wrap items-center gap-2">
+        {list ? (
+          <>
+            <StatusFilter />
+            <LogsTaskFilter possibleTasks={list.filters.possibleTasks} />
+            <LogsVersionFilter />
+            <TimeFilter
+              defaultPeriod={defaultPeriod}
+              maxPeriodDays={retentionLimitDays}
+              labelName="Occurred"
+            />
+            <SearchInput placeholder="Search errors…" />
+            {hasFilters && (
+              <Form className="h-6">
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={XMarkIcon}
+                  tooltip="Clear all filters"
+                />
+              </Form>
+            )}
+          </>
+        ) : (
+          <>
+            <StatusFilter />
+            <LogsTaskFilter possibleTasks={[]} />
+            <LogsVersionFilter />
+            <TimeFilter defaultPeriod={defaultPeriod} maxPeriodDays={retentionLimitDays} />
+            <SearchInput placeholder="Search errors…" />
+            {hasFilters && (
+              <Form className="h-6">
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={XMarkIcon}
+                  tooltip="Clear all filters"
+                />
+              </Form>
+            )}
+          </>
+        )}
+      </div>
+      <div className="flex shrink-0 items-center gap-2">
+        <LinkButton
+          to={alertsHref}
+          variant="secondary/small"
+          LeadingIcon={BellAlertIcon}
+          leadingIconClassName="text-alerts"
+        >
+          Configure alerts
+        </LinkButton>
+        {list && <ListPagination list={list} />}
+      </div>
+    </div>
+  );
+}
+
+function ErrorsList({
+  errorGroups,
+  occurrences,
+  organizationSlug,
+  projectParam,
+  envParam,
+}: {
+  errorGroups: ErrorGroup[];
+  occurrences: Promise<ErrorOccurrences>;
+  organizationSlug: string;
+  projectParam: string;
+  envParam: string;
+}) {
+  if (errorGroups.length === 0) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3">
+        <IconBugFilled className="size-16 text-charcoal-650" />
+        <Paragraph className="text-center text-text-dimmed">
+          No errors found for this time period.
+        </Paragraph>
+      </div>
+    );
+  }
+
+  return (
+    <Table containerClassName="max-h-full pb-[2.5rem]" showTopBorder={false}>
+      <TableHeader>
+        <TableRow>
+          <TableHeaderCell>ID</TableHeaderCell>
+          <TableHeaderCell>Status</TableHeaderCell>
+          <TableHeaderCell>Task</TableHeaderCell>
+          <TableHeaderCell>Error</TableHeaderCell>
+          <TableHeaderCell>Occurrences</TableHeaderCell>
+          <TableHeaderCell>Activity</TableHeaderCell>
+          <TableHeaderCell>First seen</TableHeaderCell>
+          <TableHeaderCell>Last seen</TableHeaderCell>
+        </TableRow>
+      </TableHeader>
+      <TableBody>
+        {errorGroups.map((errorGroup) => (
+          <ErrorGroupRow
+            key={`${errorGroup.taskIdentifier}::${errorGroup.fingerprint}`}
+            errorGroup={errorGroup}
+            occurrences={occurrences}
+            organizationSlug={organizationSlug}
+            projectParam={projectParam}
+            envParam={envParam}
+          />
+        ))}
+      </TableBody>
+    </Table>
+  );
+}
+
+function ErrorGroupRow({
+  errorGroup,
+  occurrences,
+  organizationSlug,
+  projectParam,
+  envParam,
+}: {
+  errorGroup: ErrorGroup;
+  occurrences: Promise<ErrorOccurrences>;
+  organizationSlug: string;
+  projectParam: string;
+  envParam: string;
+}) {
+  const location = useOptimisticLocation();
+  const searchParams = new URLSearchParams(location.search);
+
+  const errorPath = useMemo(() => {
+    const base = v3ErrorPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam },
+      { fingerprint: errorGroup.fingerprint }
+    );
+    const carry = new URLSearchParams();
+    const period = searchParams.get("period");
+    const from = searchParams.get("from");
+    const to = searchParams.get("to");
+    if (period) carry.set("period", period);
+    if (from) carry.set("from", from);
+    if (to) carry.set("to", to);
+    for (const v of searchParams.getAll("versions")) {
+      if (v) carry.append("versions", v);
+    }
+    const qs = carry.toString();
+    return qs ? `${base}?${qs}` : base;
+  }, [organizationSlug, projectParam, envParam, errorGroup.fingerprint, searchParams.toString()]);
+
+  const errorMessage = `${errorGroup.errorMessage}`;
+
+  return (
+    <TableRow>
+      <CopyableTableCell to={errorPath} value={ErrorId.toFriendlyId(errorGroup.fingerprint)}>
+        {errorGroup.fingerprint.slice(-8)}
+      </CopyableTableCell>
+      <TableCell to={errorPath}>
+        <ErrorStatusBadge status={errorGroup.status} />
+      </TableCell>
+      <TableCell to={errorPath}>{errorGroup.taskIdentifier}</TableCell>
+      <CopyableTableCell to={errorPath} className="font-mono" value={errorMessage}>
+        {errorMessage.length > 128 ? `${errorMessage.slice(0, 128)}…` : errorMessage}
+      </CopyableTableCell>
+      <TableCell to={errorPath}>
+        <span className="tabular-nums">{errorGroup.count.toLocaleString()}</span>
+      </TableCell>
+      <TableCell to={errorPath} actionClassName="py-1.5">
+        <Suspense fallback={<ErrorActivityBlankState />}>
+          <TypedAwait resolve={occurrences} errorElement={<ErrorActivityBlankState />}>
+            {(result) => {
+              const activity = result.data[errorGroup.fingerprint];
+              return activity ? (
+                <ErrorActivityGraph activity={activity} />
+              ) : (
+                <ErrorActivityBlankState />
+              );
+            }}
+          </TypedAwait>
+        </Suspense>
+      </TableCell>
+      <TableCell to={errorPath} className="tabular-nums">
+        <RelativeDateTime date={errorGroup.firstSeen} />
+      </TableCell>
+      <TableCell to={errorPath} className="tabular-nums">
+        <RelativeDateTime date={errorGroup.lastSeen} />
+      </TableCell>
+      <ErrorActionsCell
+        errorGroup={errorGroup}
+        organizationSlug={organizationSlug}
+        projectParam={projectParam}
+        envParam={envParam}
+      />
+    </TableRow>
+  );
+}
+
+function ErrorActionsCell({
+  errorGroup,
+  organizationSlug,
+  projectParam,
+  envParam,
+}: {
+  errorGroup: ErrorGroup;
+  organizationSlug: string;
+  projectParam: string;
+  envParam: string;
+}) {
+  const fetcher = useFetcher<{ ok?: boolean }>();
+  const revalidator = useRevalidator();
+  const [customIgnoreOpen, setCustomIgnoreOpen] = useState(false);
+  const toast = useToast();
+  const pendingToast = useRef<string | undefined>();
+
+  useEffect(() => {
+    if (fetcher.state === "idle" && fetcher.data?.ok && pendingToast.current) {
+      toast.success(pendingToast.current);
+      pendingToast.current = undefined;
+      revalidator.revalidate();
+    }
+  }, [fetcher.state, fetcher.data, toast, revalidator]);
+
+  const actionUrl = v3ErrorPath(
+    { slug: organizationSlug },
+    { slug: projectParam },
+    { slug: envParam },
+    { fingerprint: errorGroup.fingerprint }
+  );
+
+  return (
+    <>
+      <TableCellMenu
+        isSticky
+        popoverContent={(close) => (
+          <>
+            <PopoverSectionHeader title="Mark error as…" />
+            <div className="flex flex-col gap-1 p-1">
+              <ErrorStatusMenuItems
+                status={errorGroup.status}
+                taskIdentifier={errorGroup.taskIdentifier}
+                onAction={(data) => {
+                  close();
+                  pendingToast.current = statusActionToastMessage(data);
+                  fetcher.submit(data, { method: "post", action: actionUrl });
+                }}
+                onCustomIgnore={() => {
+                  close();
+                  setCustomIgnoreOpen(true);
+                }}
+              />
+            </div>
+          </>
+        )}
+      />
+      <CustomIgnoreDialog
+        open={customIgnoreOpen}
+        onOpenChange={setCustomIgnoreOpen}
+        taskIdentifier={errorGroup.taskIdentifier}
+        formAction={actionUrl}
+      />
+    </>
+  );
+}
+
+function ErrorActivityGraph({ activity }: { activity: ErrorOccurrenceActivity }) {
+  const maxCount = Math.max(...activity.map((d) => d.count));
+
+  return (
+    <div className="flex items-start gap-1.5">
+      <div className="h-6 w-[7rem] rounded-sm">
+        <ResponsiveContainer width="100%" height="100%">
+          <BarChart data={activity} margin={{ top: 0, right: 0, left: 0, bottom: 0 }}>
+            <YAxis domain={[0, maxCount || 1]} hide />
+            <Tooltip
+              cursor={{ fill: "rgba(255, 255, 255, 0.06)" }}
+              content={<ErrorActivityTooltip />}
+              allowEscapeViewBox={{ x: true, y: true }}
+              wrapperStyle={{ zIndex: 1000 }}
+              animationDuration={0}
+            />
+            <Bar
+              dataKey="count"
+              fill="#6366F1"
+              strokeWidth={0}
+              isAnimationActive={false}
+              minPointSize={1}
+            />
+            <ReferenceLine y={0} stroke="#2C3034" strokeWidth={1} />
+            {maxCount > 0 && (
+              <ReferenceLine y={maxCount} stroke="#4D525B" strokeDasharray="4 4" strokeWidth={1} />
+            )}
+          </BarChart>
+        </ResponsiveContainer>
+      </div>
+      <span className="-mt-1 text-xxs tabular-nums text-text-dimmed">
+        {formatNumberCompact(maxCount)}
+      </span>
+    </div>
+  );
+}
+
+const ErrorActivityTooltip = ({ active, payload }: TooltipProps<number, string>) => {
+  if (active && payload && payload.length > 0) {
+    const entry = payload[0].payload as { date: Date; count: number };
+    const date = entry.date instanceof Date ? entry.date : new Date(entry.date);
+    const formattedDate = formatDateTime(date, "UTC", [], false, true);
+
+    return (
+      <TooltipPortal active={active}>
+        <div className="rounded-sm border border-grid-bright bg-background-dimmed px-3 py-2">
+          <Header3 className="border-b border-b-charcoal-650 pb-2">{formattedDate}</Header3>
+          <div className="mt-2 text-xs text-text-bright">
+            <span className="tabular-nums">{entry.count}</span>{" "}
+            <span className="text-text-dimmed">
+              {entry.count === 1 ? "occurrence" : "occurrences"}
+            </span>
+          </div>
+        </div>
+      </TooltipPortal>
+    );
+  }
+
+  return null;
+};
+
+function ErrorActivityBlankState() {
+  return (
+    <div className="flex h-6 w-[7rem] items-end gap-px rounded-sm">
+      {[...Array(24)].map((_, i) => (
+        <div key={i} className="h-full flex-1 bg-[#212327]" />
+      ))}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.connect-to-slack.ts b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.connect-to-slack.ts
new file mode 100644
index 00000000000..b8bed6b631d
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors.connect-to-slack.ts
@@ -0,0 +1,48 @@
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { prisma } from "~/db.server";
+import { redirectWithSuccessMessage } from "~/models/message.server";
+import { OrgIntegrationRepository } from "~/models/orgIntegration.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { requireUserId } from "~/services/session.server";
+import {
+  EnvironmentParamSchema,
+  v3ErrorsPath,
+  v3ErrorsConnectToSlackPath,
+} from "~/utils/pathBuilder";
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const url = new URL(request.url);
+  const shouldReinstall = url.searchParams.get("reinstall") === "true";
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const integration = await prisma.organizationIntegration.findFirst({
+    where: {
+      service: "SLACK",
+      organizationId: project.organizationId,
+      deletedAt: null,
+    },
+  });
+
+  if (integration && !shouldReinstall) {
+    return redirectWithSuccessMessage(
+      `${v3ErrorsPath({ slug: organizationSlug }, project, { slug: envParam })}?alerts`,
+      request,
+      "Successfully connected your Slack workspace"
+    );
+  }
+
+  return await OrgIntegrationRepository.redirectToAuthService(
+    "SLACK",
+    project.organizationId,
+    request,
+    v3ErrorsConnectToSlackPath({ slug: organizationSlug }, project, { slug: envParam })
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors/route.tsx
new file mode 100644
index 00000000000..dd9a5f6d593
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.errors/route.tsx
@@ -0,0 +1,207 @@
+import { parse } from "@conform-to/zod";
+import { Outlet, useNavigate } from "@remix-run/react";
+import { type ActionFunctionArgs, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { useCallback } from "react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { PageContainer } from "~/components/layout/AppLayout";
+import {
+  ConfigureErrorAlerts,
+  ErrorAlertsFormSchema,
+} from "~/components/errors/ConfigureErrorAlerts";
+import { Sheet, SheetContent } from "~/components/primitives/SheetV3";
+import { prisma } from "~/db.server";
+import { ErrorAlertChannelPresenter } from "~/presenters/v3/ErrorAlertChannelPresenter.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { requireUserId } from "~/services/session.server";
+import { env } from "~/env.server";
+import {
+  EnvironmentParamSchema,
+  v3ErrorsConnectToSlackPath,
+  v3ErrorsPath,
+} from "~/utils/pathBuilder";
+import {
+  type CreateAlertChannelOptions,
+  CreateAlertChannelService,
+} from "~/v3/services/alerts/createAlertChannel.server";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { useSearchParams } from "~/hooks/useSearchParam";
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const presenter = new ErrorAlertChannelPresenter();
+  const alertData = await presenter.call(project.id, environment.type);
+
+  const connectToSlackHref = v3ErrorsConnectToSlackPath({ slug: organizationSlug }, project, {
+    slug: envParam,
+  });
+
+  const errorsPath = v3ErrorsPath({ slug: organizationSlug }, project, { slug: envParam });
+
+  return typedjson({
+    alertData,
+    projectRef: project.externalRef,
+    projectId: project.id,
+    environmentType: environment.type,
+    connectToSlackHref,
+    errorsPath,
+  });
+};
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  if (request.method.toUpperCase() !== "POST") {
+    return json({ status: 405, error: "Method Not Allowed" }, { status: 405 });
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    return json({ error: "Project not found" }, { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    return json({ error: "Environment not found" }, { status: 404 });
+  }
+
+  const formData = await request.formData();
+  const submission = parse(formData, { schema: ErrorAlertsFormSchema });
+
+  if (!submission.value) {
+    return json(submission);
+  }
+
+  const { emails, webhooks, slackChannel, slackIntegrationId } = submission.value;
+
+  const emailEnabled = env.ALERT_FROM_EMAIL !== undefined && env.ALERT_RESEND_API_KEY !== undefined;
+  const slackEnabled = !!slackIntegrationId;
+
+  const existingChannels = await prisma.projectAlertChannel.findMany({
+    where: {
+      projectId: project.id,
+      alertTypes: { has: "ERROR_GROUP" },
+      environmentTypes: { has: environment.type },
+    },
+  });
+
+  const service = new CreateAlertChannelService();
+  const environmentTypes = [environment.type];
+  const processedChannelIds = new Set<string>();
+
+  if (emailEnabled) {
+    for (const email of emails) {
+      const options: CreateAlertChannelOptions = {
+        name: `Error alert to ${email}`,
+        alertTypes: ["ERROR_GROUP"],
+        environmentTypes,
+        deduplicationKey: `error-email:${email}:${environment.type}`,
+        channel: { type: "EMAIL", email },
+      };
+      const channel = await service.call(project.externalRef, userId, options);
+      processedChannelIds.add(channel.id);
+    }
+  }
+
+  if (slackEnabled && slackChannel) {
+    const [channelId, channelName] = slackChannel.split("/");
+    if (channelId && channelName) {
+      const options: CreateAlertChannelOptions = {
+        name: `Error alert to #${channelName}`,
+        alertTypes: ["ERROR_GROUP"],
+        environmentTypes,
+        deduplicationKey: `error-slack:${environment.type}`,
+        channel: {
+          type: "SLACK",
+          channelId,
+          channelName,
+          integrationId: slackIntegrationId,
+        },
+      };
+      const channel = await service.call(project.externalRef, userId, options);
+      processedChannelIds.add(channel.id);
+    }
+  }
+
+  for (const url of webhooks) {
+    const options: CreateAlertChannelOptions = {
+      name: `Error alert to ${new URL(url).hostname}`,
+      alertTypes: ["ERROR_GROUP"],
+      environmentTypes,
+      deduplicationKey: `error-webhook:${url}:${environment.type}`,
+      channel: { type: "WEBHOOK", url },
+    };
+    const channel = await service.call(project.externalRef, userId, options);
+    processedChannelIds.add(channel.id);
+  }
+
+  const editableTypes = new Set<string>(["WEBHOOK"]);
+  if (emailEnabled) {
+    editableTypes.add("EMAIL");
+  }
+  if (slackEnabled) {
+    editableTypes.add("SLACK");
+  }
+
+  const channelsToDelete = existingChannels.filter(
+    (ch) =>
+      !processedChannelIds.has(ch.id) &&
+      editableTypes.has(ch.type) &&
+      ch.alertTypes.length === 1 &&
+      ch.alertTypes[0] === "ERROR_GROUP"
+  );
+
+  for (const ch of channelsToDelete) {
+    await prisma.projectAlertChannel.delete({ where: { id: ch.id } });
+  }
+
+  return json({ ok: true });
+};
+
+export default function Page() {
+  const { alertData, connectToSlackHref, errorsPath } = useTypedLoaderData<typeof loader>();
+  const { has } = useSearchParams();
+  const showAlerts = has("alerts") ?? false;
+  const navigate = useNavigate();
+  const location = useOptimisticLocation();
+
+  const closeAlerts = useCallback(() => {
+    const params = new URLSearchParams(location.search);
+    params.delete("alerts");
+    const qs = params.toString();
+    navigate(qs ? `?${qs}` : location.pathname, { replace: true });
+  }, [location.search, location.pathname, navigate]);
+
+  return (
+    <PageContainer>
+      <Outlet />
+
+      <Sheet open={showAlerts} onOpenChange={(open) => !open && closeAlerts()}>
+        <SheetContent
+          side="right"
+          className="w-[420px] min-w-[320px] max-w-[560px] p-0 sm:max-w-[560px]"
+          onOpenAutoFocus={(e) => e.preventDefault()}
+        >
+          <ConfigureErrorAlerts
+            {...alertData}
+            connectToSlackHref={connectToSlackHref}
+            formAction={errorsPath}
+          />
+        </SheetContent>
+      </Sheet>
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.limits/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.limits/route.tsx
new file mode 100644
index 00000000000..ce19dd3a8cb
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.limits/route.tsx
@@ -0,0 +1,856 @@
+import { CheckIcon, BookOpenIcon } from "@heroicons/react/20/solid";
+import { type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { IconCardsFilled, IconDiamondFilled, IconTallymark4 } from "@tabler/icons-react";
+import { tryCatch } from "@trigger.dev/core";
+import { Gauge } from "lucide-react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { ConcurrencyIcon } from "~/assets/icons/ConcurrencyIcon";
+import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
+import { Feedback } from "~/components/Feedback";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { EnvironmentSelector } from "~/components/navigation/EnvironmentSelector";
+import { AnimatedNumber } from "~/components/primitives/AnimatedNumber";
+import { Badge } from "~/components/primitives/Badge";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Header2 } from "~/components/primitives/Headers";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import * as Property from "~/components/primitives/PropertyTable";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { InfoIconTooltip } from "~/components/primitives/Tooltip";
+import { useAutoRevalidate } from "~/hooks/useAutoRevalidate";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  LimitsPresenter,
+  type FeatureInfo,
+  type LimitsResult,
+  type QuotaInfo,
+  type RateLimitInfo,
+} from "~/presenters/v3/LimitsPresenter.server";
+import { requireUserId } from "~/services/session.server";
+import { cn } from "~/utils/cn";
+import { formatNumber } from "~/utils/numberFormatter";
+import {
+  concurrencyPath,
+  docsPath,
+  EnvironmentParamSchema,
+  organizationBillingPath,
+} from "~/utils/pathBuilder";
+
+export const meta: MetaFunction = () => {
+  return [
+    {
+      title: `Limits | Trigger.dev`,
+    },
+  ];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Project not found",
+    });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Environment not found",
+    });
+  }
+
+  const presenter = new LimitsPresenter();
+  const [error, result] = await tryCatch(
+    presenter.call({
+      organizationId: project.organizationId,
+      projectId: project.id,
+      environmentId: environment.id,
+      environmentType: environment.type,
+      environmentApiKey: environment.apiKey,
+    })
+  );
+
+  if (error) {
+    throw new Response(error.message, {
+      status: 400,
+    });
+  }
+
+  // Match the queues page pattern: pass a poll interval from the loader
+  const autoReloadPollIntervalMs = 5000;
+
+  return typedjson({
+    ...result,
+    autoReloadPollIntervalMs,
+  });
+};
+
+export default function Page() {
+  const data = useTypedLoaderData<typeof loader>();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  // Auto-revalidate using the loader-provided interval and refresh on focus
+  useAutoRevalidate({ interval: data.autoReloadPollIntervalMs, onFocus: true });
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Limits" />
+        <PageAccessories>
+          <AdminDebugTooltip>
+            <Property.Table>
+              <Property.Item>
+                <Property.Label>Plan</Property.Label>
+                <Property.Value>{data.planName ?? "No plan"}</Property.Value>
+              </Property.Item>
+              <Property.Item>
+                <Property.Label>Organization ID</Property.Label>
+                <Property.Value>{data.organizationId}</Property.Value>
+              </Property.Item>
+            </Property.Table>
+          </AdminDebugTooltip>
+          <LinkButton variant={"docs/small"} LeadingIcon={BookOpenIcon} to={docsPath("/limits")}>
+            Limits docs
+          </LinkButton>
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable={true}>
+        <div className="mx-auto mt-10 max-w-2xl p-4">
+          <div className="flex flex-col gap-8">
+            {/* Current Plan Section */}
+            {data.planName && (
+              <CurrentPlanSection
+                planName={data.planName}
+                isOnTopPlan={data.isOnTopPlan}
+                billingPath={organizationBillingPath(organization)}
+              />
+            )}
+
+            {/* Concurrency Section */}
+            <ConcurrencySection
+              concurrencyPath={concurrencyPath(organization, project, environment)}
+            />
+
+            {/* Rate Limits Section */}
+            <RateLimitsSection
+              rateLimits={data.rateLimits}
+              isOnTopPlan={data.isOnTopPlan}
+              billingPath={organizationBillingPath(organization)}
+              organization={organization}
+              project={project}
+              environment={environment}
+            />
+
+            {/* Quotas Section */}
+            <QuotasSection
+              quotas={data.quotas}
+              isOnTopPlan={data.isOnTopPlan}
+              billingPath={organizationBillingPath(organization)}
+            />
+
+            {/* Features Section */}
+            <FeaturesSection
+              features={data.features}
+              isOnTopPlan={data.isOnTopPlan}
+              billingPath={organizationBillingPath(organization)}
+            />
+          </div>
+        </div>
+      </PageBody>
+    </PageContainer>
+  );
+}
+
+function CurrentPlanSection({
+  planName,
+  isOnTopPlan,
+  billingPath,
+}: {
+  planName: string;
+  isOnTopPlan: boolean;
+  billingPath: string;
+}) {
+  return (
+    <div className="flex flex-col gap-3">
+      <Header2 className="flex items-center gap-1">
+        <IconCardsFilled className="size-5 text-amber-400" />
+        Current plan
+      </Header2>
+      <Table variant="bright/no-hover">
+        <TableBody>
+          <TableRow>
+            <TableCell className="w-full text-sm">{planName}</TableCell>
+            <TableCell alignment="right">
+              {isOnTopPlan ? (
+                <Feedback
+                  button={<Button variant="secondary/small">Request Enterprise</Button>}
+                  defaultValue="help"
+                />
+              ) : (
+                <LinkButton to={billingPath} variant="secondary/small">
+                  View plans
+                </LinkButton>
+              )}
+            </TableCell>
+          </TableRow>
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function ConcurrencySection({ concurrencyPath }: { concurrencyPath: string }) {
+  return (
+    <div className="flex flex-col gap-3">
+      <Header2 className="flex items-center gap-1.5">
+        <ConcurrencyIcon className="size-5 text-orange-500" />
+        Concurrency limits
+        <InfoIconTooltip
+          content="Concurrency limits control how many runs execute at the same time."
+          disableHoverableContent
+        />
+      </Header2>
+      <Table variant="bright/no-hover">
+        <TableBody>
+          <TableRow>
+            <TableCell className="w-full text-sm">Concurrency</TableCell>
+            <TableCell alignment="right">
+              <LinkButton to={concurrencyPath} variant="secondary/small">
+                Manage concurrency
+              </LinkButton>
+            </TableCell>
+          </TableRow>
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function RateLimitsSection({
+  rateLimits,
+  isOnTopPlan,
+  billingPath,
+  organization,
+  project,
+  environment,
+}: {
+  rateLimits: LimitsResult["rateLimits"];
+  isOnTopPlan: boolean;
+  billingPath: string;
+  organization: ReturnType<typeof useOrganization>;
+  project: ReturnType<typeof useProject>;
+  environment: ReturnType<typeof useEnvironment>;
+}) {
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="flex items-center justify-between">
+        <Header2 className="flex items-center gap-1.5">
+          <Gauge className="size-5 text-indigo-500" />
+          Rate limits
+          <InfoIconTooltip
+            content="Rate limits control how many API requests can be made within a time window. They are tracked per API key."
+            disableHoverableContent
+          />
+        </Header2>
+        <EnvironmentSelector
+          organization={organization}
+          project={project}
+          environment={environment}
+          className="w-auto"
+        />
+      </div>
+      <Table variant="bright/no-hover">
+        <TableHeader>
+          <TableRow>
+            <TableHeaderCell>Rate limit</TableHeaderCell>
+            <TableHeaderCell alignment="right">
+              <span className="flex items-center justify-end gap-x-1">
+                Type
+                <InfoIconTooltip
+                  content={
+                    <div className="flex max-w-xs flex-col gap-3 py-1">
+                      <div className="flex flex-col items-start gap-1.5">
+                        <RateLimitTypeBadge type="tokenBucket" />
+                        <span className="pl-0.5 text-text-bright">
+                          Requests consume tokens from a bucket that refills over time. When empty,
+                          requests are rate limited.
+                        </span>
+                      </div>
+                      <div className="flex flex-col items-start gap-1.5">
+                        <RateLimitTypeBadge type="fixedWindow" />
+                        <span className="pl-0.5 text-text-bright">
+                          Allows a set number of requests per time window. The window resets at
+                          fixed intervals.
+                        </span>
+                      </div>
+                      <div className="flex flex-col items-start gap-1.5">
+                        <RateLimitTypeBadge type="slidingWindow" />
+                        <span className="pl-0.5 text-text-bright">
+                          Allows a set number of requests per rolling time window. The limit is
+                          continuously evaluated.
+                        </span>
+                      </div>
+                    </div>
+                  }
+                  disableHoverableContent
+                />
+              </span>
+            </TableHeaderCell>
+            <TableHeaderCell alignment="right">Configuration</TableHeaderCell>
+            <TableHeaderCell alignment="right">
+              <span className="flex items-center justify-end gap-x-1">
+                Available
+                <InfoIconTooltip
+                  content="Current available tokens for this environment's API key"
+                  disableHoverableContent
+                />
+              </span>
+            </TableHeaderCell>
+            <TableHeaderCell alignment="right">Upgrade</TableHeaderCell>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          <RateLimitRow info={rateLimits.api} isOnTopPlan={isOnTopPlan} billingPath={billingPath} />
+          <RateLimitRow
+            info={rateLimits.batch}
+            isOnTopPlan={isOnTopPlan}
+            billingPath={billingPath}
+          />
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function RateLimitRow({
+  info,
+  isOnTopPlan,
+  billingPath,
+}: {
+  info: RateLimitInfo;
+  isOnTopPlan: boolean;
+  billingPath: string;
+}) {
+  const maxTokens = info.config.type === "tokenBucket" ? info.config.maxTokens : info.config.tokens;
+  const percentage =
+    info.currentTokens !== null && maxTokens > 0 ? info.currentTokens / maxTokens : null;
+
+  return (
+    <TableRow>
+      <TableCell>
+        <span className="flex items-center gap-1 text-sm">
+          {info.name}
+          <InfoIconTooltip content={info.description} disableHoverableContent />
+        </span>
+      </TableCell>
+      <TableCell alignment="right">
+        <div className="flex justify-end">
+          <RateLimitTypeBadge config={info.config} />
+        </div>
+      </TableCell>
+      <TableCell alignment="right">
+        <RateLimitConfigDisplay config={info.config} />
+      </TableCell>
+      <TableCell alignment="right">
+        {info.currentTokens !== null ? (
+          <div className="flex flex-col items-end gap-0.5">
+            <span
+              className={cn(
+                "font-medium tabular-nums",
+                getUsageColorClass(percentage, "remaining")
+              )}
+            >
+              <AnimatedNumber value={info.currentTokens} />
+            </span>
+            <span className="text-xs tabular-nums text-text-dimmed">
+              of {formatNumber(maxTokens)}
+            </span>
+          </div>
+        ) : (
+          <span className="text-text-dimmed">–</span>
+        )}
+      </TableCell>
+      <TableCell alignment="right">
+        <div className="flex justify-end">
+          {info.name === "Batch rate limit" ? (
+            isOnTopPlan ? (
+              <Feedback
+                button={<Button variant="secondary/small">Contact us</Button>}
+                defaultValue="help"
+              />
+            ) : (
+              <LinkButton to={billingPath} variant="secondary/small">
+                View plans
+              </LinkButton>
+            )
+          ) : (
+            <Feedback
+              button={<Button variant="secondary/small">Contact us</Button>}
+              defaultValue="help"
+            />
+          )}
+        </div>
+      </TableCell>
+    </TableRow>
+  );
+}
+
+function RateLimitTypeBadge({
+  config,
+  type,
+}: {
+  config?: RateLimitInfo["config"];
+  type?: "tokenBucket" | "fixedWindow" | "slidingWindow";
+}) {
+  const rateLimitType = type ?? config?.type;
+  switch (rateLimitType) {
+    case "tokenBucket":
+      return (
+        <Badge variant="small" className="w-fit bg-blue-500/20 text-blue-400">
+          Token bucket
+        </Badge>
+      );
+    case "fixedWindow":
+      return (
+        <Badge variant="small" className="w-fit bg-purple-500/20 text-purple-400">
+          Fixed window
+        </Badge>
+      );
+    case "slidingWindow":
+      return (
+        <Badge variant="small" className="w-fit bg-green-500/20 text-green-400">
+          Sliding window
+        </Badge>
+      );
+    default:
+      return null;
+  }
+}
+
+function RateLimitConfigDisplay({ config }: { config: RateLimitInfo["config"] }) {
+  if (config.type === "tokenBucket") {
+    return (
+      <div className="flex flex-col items-end gap-0.5 text-xs">
+        <span className="tabular-nums">
+          <span className="text-text-dimmed">Max tokens:</span>{" "}
+          <span className="font-medium text-text-bright">{formatNumber(config.maxTokens)}</span>
+        </span>
+        <span className="tabular-nums">
+          <span className="text-text-dimmed">Refill:</span>{" "}
+          <span className="font-medium text-text-bright">
+            {formatNumber(config.refillRate)}/{config.interval}
+          </span>
+        </span>
+      </div>
+    );
+  }
+
+  if (config.type === "fixedWindow" || config.type === "slidingWindow") {
+    return (
+      <div className="flex flex-col items-end gap-0.5 text-xs">
+        <span className="tabular-nums">
+          <span className="text-text-dimmed">Tokens:</span>{" "}
+          <span className="font-medium text-text-bright">{formatNumber(config.tokens)}</span>
+        </span>
+        <span className="tabular-nums">
+          <span className="text-text-dimmed">Window:</span>{" "}
+          <span className="font-medium text-text-bright">{config.window}</span>
+        </span>
+      </div>
+    );
+  }
+
+  return <span className="text-text-dimmed">–</span>;
+}
+
+function QuotasSection({
+  quotas,
+  isOnTopPlan,
+  billingPath,
+}: {
+  quotas: LimitsResult["quotas"];
+  isOnTopPlan: boolean;
+  billingPath: string;
+}) {
+  // Collect all quotas that should be shown
+  const quotaRows: QuotaInfo[] = [];
+
+  // Always show projects
+  quotaRows.push(quotas.projects);
+
+  // Add plan-based quotas if they exist
+  if (quotas.teamMembers) quotaRows.push(quotas.teamMembers);
+  if (quotas.schedules) quotaRows.push(quotas.schedules);
+  if (quotas.alerts) quotaRows.push(quotas.alerts);
+  if (quotas.branches) quotaRows.push(quotas.branches);
+  if (quotas.realtimeConnections) quotaRows.push(quotas.realtimeConnections);
+  if (quotas.logRetentionDays) quotaRows.push(quotas.logRetentionDays);
+
+  // Include batch processing concurrency
+  quotaRows.push(quotas.batchProcessingConcurrency);
+
+  // Add queue size quota if set
+  if (quotas.queueSize.limit !== null) quotaRows.push(quotas.queueSize);
+
+  // Metric & query quotas
+  if (quotas.metricDashboards) quotaRows.push(quotas.metricDashboards);
+  if (quotas.metricWidgetsPerDashboard) quotaRows.push(quotas.metricWidgetsPerDashboard);
+  if (quotas.queryPeriodDays) quotaRows.push(quotas.queryPeriodDays);
+
+  return (
+    <div className="flex flex-col gap-3">
+      <Header2 className="flex items-center gap-1">
+        <IconTallymark4 className="size-6 text-blue-500" />
+        Quotas
+        <InfoIconTooltip
+          content="Quotas define the maximum resources available to your organization."
+          disableHoverableContent
+        />
+      </Header2>
+      <Table variant="bright/no-hover">
+        <TableHeader>
+          <TableRow>
+            <TableHeaderCell>Quota</TableHeaderCell>
+            <TableHeaderCell alignment="right">Limit</TableHeaderCell>
+            <TableHeaderCell alignment="right">Current</TableHeaderCell>
+            <TableHeaderCell alignment="right">Source</TableHeaderCell>
+            <TableHeaderCell alignment="right">Upgrade</TableHeaderCell>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {quotaRows.map((quota) => (
+            <QuotaRow
+              key={quota.name}
+              quota={quota}
+              isOnTopPlan={isOnTopPlan}
+              billingPath={billingPath}
+            />
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function QuotaRow({
+  quota,
+  isOnTopPlan,
+  billingPath,
+}: {
+  quota: QuotaInfo;
+  isOnTopPlan: boolean;
+  billingPath: string;
+}) {
+  // For log retention and query period, we don't show current usage as it's a duration, not a count
+  // For widgets per dashboard, the usage varies per dashboard so we don't show a single number
+  const isDurationQuota = quota.name === "Log retention" || quota.name === "Query period";
+  const isPerItemQuota = quota.name === "Charts per dashboard";
+  const isRetentionQuota = isDurationQuota || isPerItemQuota;
+  const isQueueSizeQuota = quota.name === "Max queued runs";
+  const hideCurrentUsage = isRetentionQuota || isQueueSizeQuota;
+  
+  const percentage =
+    !hideCurrentUsage && quota.limit && quota.limit > 0 ? quota.currentUsage / quota.limit : null;
+
+  // Special handling for duration-based quotas (Log retention, Query period)
+  if (isDurationQuota) {
+    const canUpgrade = !isOnTopPlan;
+    return (
+      <TableRow>
+        <TableCell className="flex w-full items-center gap-1">
+          <span className="text-sm">{quota.name}</span>
+          <InfoIconTooltip content={quota.description} disableHoverableContent />
+        </TableCell>
+        <TableCell alignment="right" className="font-medium tabular-nums">
+          {quota.limit !== null
+              ? `${formatNumber(quota.limit)} ${quota.limit === 1 ? "day" : "days"}`
+              : "Unlimited"}
+        </TableCell>
+        <TableCell alignment="right" className="tabular-nums text-text-dimmed">
+          –
+        </TableCell>
+        <TableCell alignment="right">
+          <SourceBadge source={quota.source} />
+        </TableCell>
+        <TableCell alignment="right">
+          <div className="flex justify-end">
+            {canUpgrade ? (
+              <LinkButton to={billingPath} variant="secondary/small">
+                View plans
+              </LinkButton>
+            ) : (
+              <Feedback
+                button={<Button variant="secondary/small">Contact us</Button>}
+                defaultValue="help"
+              />
+            )}
+          </div>
+        </TableCell>
+      </TableRow>
+    );
+  }
+
+  const renderUpgrade = () => {
+    // Projects always show Contact us (regardless of upgrade flags)
+    if (quota.name === "Projects") {
+      return (
+        <div className="flex justify-end">
+          <Feedback
+            button={<Button variant="secondary/small">Contact us</Button>}
+            defaultValue="help"
+          />
+        </div>
+      );
+    }
+
+    if (!quota.isUpgradable) {
+      return null;
+    }
+
+    // Not on top plan - show View plans
+    if (!isOnTopPlan) {
+      return (
+        <div className="flex justify-end">
+          <LinkButton to={billingPath} variant="secondary/small">
+            View plans
+          </LinkButton>
+        </div>
+      );
+    }
+
+    // On top plan - show Contact us if canExceed is true
+    if (quota.canExceed) {
+      return (
+        <div className="flex justify-end">
+          <Feedback
+            button={<Button variant="secondary/small">Contact us</Button>}
+            defaultValue="help"
+          />
+        </div>
+      );
+    }
+
+    // On top plan but cannot exceed - no upgrade option
+    return null;
+  };
+
+  return (
+    <TableRow>
+      <TableCell className="flex w-full items-center gap-1">
+        <span className="text-sm">{quota.name}</span>
+        <InfoIconTooltip content={quota.description} disableHoverableContent />
+      </TableCell>
+      <TableCell alignment="right" className="font-medium tabular-nums">
+        {quota.limit !== null
+          ? isDurationQuota
+            ? `${formatNumber(quota.limit)} ${quota.limit === 1 ? "day" : "days"}`
+            : formatNumber(quota.limit)
+          : "Unlimited"}
+      </TableCell>
+      <TableCell
+        alignment="right"
+        className={cn(
+          "tabular-nums",
+          hideCurrentUsage ? "text-text-dimmed" : getUsageColorClass(percentage, "usage")
+        )}
+      >
+        {hideCurrentUsage ? "–" : formatNumber(quota.currentUsage)}
+      </TableCell>
+      <TableCell alignment="right">
+        <SourceBadge source={quota.source} />
+      </TableCell>
+      <TableCell alignment="right">{renderUpgrade()}</TableCell>
+    </TableRow>
+  );
+}
+
+function FeaturesSection({
+  features,
+  isOnTopPlan,
+  billingPath,
+}: {
+  features: LimitsResult["features"];
+  isOnTopPlan: boolean;
+  billingPath: string;
+}) {
+  // For staging environment: show View plans if not enabled (i.e., on Free plan)
+  const stagingUpgradeType = features.hasStagingEnvironment.enabled ? "none" : "view-plans";
+
+  return (
+    <div className="flex flex-col gap-3">
+      <Header2 className="flex items-center gap-1.5">
+        <IconDiamondFilled className="size-5 text-green-600" />
+        Plan features
+      </Header2>
+      <Table variant="bright/no-hover">
+        <TableHeader>
+          <TableRow>
+            <TableHeaderCell>Feature</TableHeaderCell>
+            <TableHeaderCell alignment="right">Status</TableHeaderCell>
+            <TableHeaderCell alignment="right">Upgrade</TableHeaderCell>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          <FeatureRow
+            feature={features.hasStagingEnvironment}
+            upgradeType={stagingUpgradeType}
+            billingPath={billingPath}
+          />
+          <FeatureRow
+            feature={features.support}
+            upgradeType={isOnTopPlan ? "contact-us" : "view-plans"}
+            billingPath={billingPath}
+          />
+          <FeatureRow
+            feature={features.includedUsage}
+            upgradeType={isOnTopPlan ? "contact-us" : "view-plans"}
+            billingPath={billingPath}
+          />
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function FeatureRow({
+  feature,
+  upgradeType,
+  billingPath,
+}: {
+  feature: FeatureInfo;
+  upgradeType: "view-plans" | "contact-us" | "none";
+  billingPath: string;
+}) {
+  const displayValue = () => {
+    if (feature.name === "Included compute" && typeof feature.value === "number") {
+      if (!feature.enabled || feature.value === 0) {
+        return <span className="text-text-dimmed">None</span>;
+      }
+      return (
+        <span className="font-medium text-text-bright">${formatNumber(feature.value / 100)}</span>
+      );
+    }
+
+    if (feature.value !== undefined) {
+      return <span className="font-medium text-text-bright">{feature.value}</span>;
+    }
+
+    return feature.enabled ? (
+      <span className="inline-flex items-center gap-1 text-success">
+        <CheckIcon className="size-4" />
+        Enabled
+      </span>
+    ) : (
+      <span className="inline-flex items-center gap-1 text-text-dimmed">Not available</span>
+    );
+  };
+
+  const renderUpgrade = () => {
+    switch (upgradeType) {
+      case "view-plans":
+        return (
+          <div className="flex justify-end">
+            <LinkButton to={billingPath} variant="secondary/small">
+              View plans
+            </LinkButton>
+          </div>
+        );
+      case "contact-us":
+        return (
+          <div className="flex justify-end">
+            <Feedback
+              button={<Button variant="secondary/small">Contact us</Button>}
+              defaultValue="help"
+            />
+          </div>
+        );
+      case "none":
+        return null;
+    }
+  };
+
+  return (
+    <TableRow>
+      <TableCell className="flex w-full items-center gap-1">
+        <span className="text-sm">{feature.name}</span>
+        <InfoIconTooltip content={feature.description} disableHoverableContent />
+      </TableCell>
+      <TableCell alignment="right">{displayValue()}</TableCell>
+      <TableCell alignment="right">{renderUpgrade()}</TableCell>
+    </TableRow>
+  );
+}
+
+/**
+ * Returns the appropriate color class based on usage percentage.
+ * @param percentage - The usage percentage (0-1 scale)
+ * @param mode - "usage" means higher is worse (quotas), "remaining" means lower is worse (rate limits)
+ * @returns Tailwind color class
+ */
+function getUsageColorClass(
+  percentage: number | null,
+  mode: "usage" | "remaining" = "usage"
+): string {
+  if (percentage === null) return "text-text-dimmed";
+
+  if (mode === "remaining") {
+    // For remaining tokens: 0 = bad (red), <=10% = warning (orange)
+    if (percentage <= 0) return "text-error";
+    if (percentage <= 0.1) return "text-warning";
+    return "text-text-bright";
+  } else {
+    // For usage: 100% = bad (red), >=90% = warning (orange)
+    if (percentage >= 1) return "text-error";
+    if (percentage >= 0.9) return "text-warning";
+    return "text-text-bright";
+  }
+}
+
+function SourceBadge({ source }: { source: "default" | "plan" | "override" }) {
+  const variants: Record<typeof source, { label: string; className: string }> = {
+    default: {
+      label: "Default",
+      className: "bg-indigo-500/20 text-indigo-400",
+    },
+    plan: {
+      label: "Plan",
+      className: "bg-purple-500/20 text-purple-400",
+    },
+    override: {
+      label: "Override",
+      className: "bg-amber-500/20 text-amber-400",
+    },
+  };
+
+  const variant = variants[source];
+
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center rounded px-1.5 py-0.5 text-xs font-medium",
+        variant.className
+      )}
+    >
+      {variant.label}
+    </span>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs/route.tsx
new file mode 100644
index 00000000000..af3cc30a246
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs/route.tsx
@@ -0,0 +1,502 @@
+import { type LoaderFunctionArgs, redirect } from "@remix-run/server-runtime";
+import { type MetaFunction, useFetcher, useNavigation, useLocation, Form } from "@remix-run/react";
+import { XMarkIcon } from "@heroicons/react/20/solid";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import {
+  TypedAwait,
+  typeddefer,
+  type UseDataFunctionReturn,
+  useTypedLoaderData,
+} from "remix-typedjson";
+import { requireUser } from "~/services/session.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { LogsListPresenter, LogEntry } from "~/presenters/v3/LogsListPresenter.server";
+import type { LogLevel } from "~/utils/logUtils";
+import { $replica, prisma } from "~/db.server";
+import { logsClickhouseClient } from "~/services/clickhouseInstance.server";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState, useTransition } from "react";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { Spinner } from "~/components/primitives/Spinner";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Callout } from "~/components/primitives/Callout";
+import { LogsTable } from "~/components/logs/LogsTable";
+import { LogDetailView } from "~/components/logs/LogDetailView";
+import { SearchInput } from "~/components/primitives/SearchInput";
+import { LogsLevelFilter } from "~/components/logs/LogsLevelFilter";
+import { LogsTaskFilter } from "~/components/logs/LogsTaskFilter";
+import { LogsRunIdFilter } from "~/components/logs/LogsRunIdFilter";
+import { TimeFilter } from "~/components/runs/v3/SharedFilters";
+import {
+  RESIZABLE_PANEL_ANIMATION,
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  collapsibleHandleClassName,
+  useFrozenValue,
+} from "~/components/primitives/Resizable";
+import { Button } from "~/components/primitives/Buttons";
+import { FEATURE_FLAG, validateFeatureFlagValue } from "~/v3/featureFlags";
+
+// Valid log levels for filtering
+const validLevels: LogLevel[] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"];
+
+function parseLevelsFromUrl(url: URL): LogLevel[] | undefined {
+  const levelParams = url.searchParams.getAll("levels").filter((v) => v.length > 0);
+  if (levelParams.length === 0) return undefined;
+  return levelParams.filter((l): l is LogLevel => validLevels.includes(l as LogLevel));
+}
+
+export const meta: MetaFunction = () => {
+  return [
+    {
+      title: `Logs | Trigger.dev`,
+    },
+  ];
+};
+
+// TODO: Move this to a more appropriate shared location
+async function hasLogsPageAccess(
+  userId: string,
+  isAdmin: boolean,
+  isImpersonating: boolean,
+  organizationSlug: string
+): Promise<boolean> {
+  if (isAdmin || isImpersonating) {
+    return true;
+  }
+
+  // Check organization feature flags
+  const organization = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+    },
+    select: {
+      featureFlags: true,
+    },
+  });
+
+  if (!organization?.featureFlags) {
+    return false;
+  }
+
+  const flags = organization.featureFlags as Record<string, unknown>;
+  const hasLogsPageAccessResult = validateFeatureFlagValue(
+    FEATURE_FLAG.hasLogsPageAccess,
+    flags.hasLogsPageAccess
+  );
+
+  return hasLogsPageAccessResult.success && hasLogsPageAccessResult.data === true;
+}
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const userId = user.id;
+
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const canAccess = await hasLogsPageAccess(
+    userId,
+    user.admin,
+    user.isImpersonating,
+    organizationSlug
+  );
+
+  if (!canAccess) {
+    throw redirect("/");
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  // Get filters from query params
+  const url = new URL(request.url);
+  const tasks = url.searchParams.getAll("tasks").filter((t) => t.length > 0);
+  const runId = url.searchParams.get("runId") ?? undefined;
+  const search = url.searchParams.get("search") ?? undefined;
+  const levels = parseLevelsFromUrl(url);
+  const period = url.searchParams.get("period") ?? undefined;
+  const fromStr = url.searchParams.get("from");
+  const toStr = url.searchParams.get("to");
+  const from = fromStr ? parseInt(fromStr, 10) : undefined;
+  const to = toStr ? parseInt(toStr, 10) : undefined;
+
+  // Get the user's plan to determine log retention limit
+  const plan = await getCurrentPlan(project.organizationId);
+  const retentionLimitDays = plan?.v3Subscription?.plan?.limits.logRetentionDays.number ?? 30;
+
+  const presenter = new LogsListPresenter($replica, logsClickhouseClient);
+
+  const listPromise = presenter
+    .call(project.organizationId, environment.id, {
+      userId,
+      projectId: project.id,
+      tasks: tasks.length > 0 ? tasks : undefined,
+      runId,
+      search,
+      levels,
+      period,
+      from,
+      to,
+      defaultPeriod: "1h",
+      retentionLimitDays,
+    })
+    .catch((error) => {
+      if (error instanceof ServiceValidationError) {
+        return { error: error.message };
+      }
+      throw error;
+    });
+
+  return typeddefer({
+    data: listPromise,
+    defaultPeriod: "1h",
+    retentionLimitDays,
+  });
+};
+
+export default function Page() {
+  const { data, defaultPeriod, retentionLimitDays } = useTypedLoaderData<typeof loader>();
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Logs" />
+      </NavBar>
+
+      <PageBody scrollable={false}>
+        <Suspense
+          fallback={
+            <div className="grid h-full max-h-full grid-rows-[2.5rem_auto] overflow-hidden">
+              <div className="border-b border-grid-bright" />
+              <div className="my-2 flex items-center justify-center">
+                <div className="mx-auto flex items-center gap-2">
+                  <Spinner />
+                  <Paragraph variant="small">Loading logs…</Paragraph>
+                </div>
+              </div>
+            </div>
+          }
+        >
+          <TypedAwait
+            resolve={data}
+            errorElement={
+              <div className="grid h-full max-h-full grid-rows-[2.5rem_auto_1fr] overflow-hidden">
+                <FiltersBar defaultPeriod={defaultPeriod} retentionLimitDays={retentionLimitDays} />
+                <div className="flex items-center justify-center px-3 py-12">
+                  <Callout variant="error" className="max-w-fit">
+                    Unable to load your logs. Please refresh the page or try again in a moment.
+                  </Callout>
+                </div>
+              </div>
+            }
+          >
+            {(result) => {
+              // Check if result contains an error
+              if ("error" in result) {
+                return (
+                  <div className="grid h-full max-h-full grid-rows-[2.5rem_auto_1fr] overflow-hidden">
+                    <FiltersBar
+                      defaultPeriod={defaultPeriod}
+                      retentionLimitDays={retentionLimitDays}
+                    />
+                    <div className="flex items-center justify-center px-3 py-12">
+                      <Callout variant="error" className="max-w-fit">
+                        {result.error}
+                      </Callout>
+                    </div>
+                  </div>
+                );
+              }
+              return (
+                <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden">
+                  <FiltersBar
+                    list={result}
+                    defaultPeriod={defaultPeriod}
+                    retentionLimitDays={retentionLimitDays}
+                  />
+                  <LogsList list={result} defaultPeriod={defaultPeriod} />
+                </div>
+              );
+            }}
+          </TypedAwait>
+        </Suspense>
+      </PageBody>
+    </PageContainer>
+  );
+}
+
+function FiltersBar({
+  list,
+  defaultPeriod,
+  retentionLimitDays,
+}: {
+  list?: Exclude<Awaited<UseDataFunctionReturn<typeof loader>["data"]>, { error: string }>;
+  defaultPeriod?: string;
+  retentionLimitDays: number;
+}) {
+  const location = useOptimisticLocation();
+  const searchParams = new URLSearchParams(location.search);
+  const hasFilters =
+    searchParams.has("tasks") ||
+    searchParams.has("runId") ||
+    searchParams.has("search") ||
+    searchParams.has("levels") ||
+    searchParams.has("period") ||
+    searchParams.has("from") ||
+    searchParams.has("to");
+
+  return (
+    <div className="flex items-start justify-between gap-x-2 border-b border-grid-bright p-2">
+      <div className="flex flex-row flex-wrap items-center gap-1">
+        {list ? (
+          <>
+            <LogsTaskFilter possibleTasks={list.possibleTasks} />
+            <LogsRunIdFilter />
+            <TimeFilter defaultPeriod={defaultPeriod} maxPeriodDays={retentionLimitDays} />
+            <LogsLevelFilter />
+            <SearchInput />
+            {hasFilters && (
+              <Form className="h-6">
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={XMarkIcon}
+                  tooltip="Clear all filters"
+                />
+              </Form>
+            )}
+          </>
+        ) : (
+          <>
+            <LogsTaskFilter possibleTasks={[]} />
+            <LogsRunIdFilter />
+            <TimeFilter defaultPeriod={defaultPeriod} maxPeriodDays={retentionLimitDays} />
+            <LogsLevelFilter />
+            <SearchInput />
+            {hasFilters && (
+              <Form className="h-6">
+                <Button
+                  variant="secondary/small"
+                  LeadingIcon={XMarkIcon}
+                  tooltip="Clear all filters"
+                />
+              </Form>
+            )}
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function LogsList({
+  list,
+}: {
+  list: Exclude<Awaited<UseDataFunctionReturn<typeof loader>["data"]>, { error: string }>; //exclude error, it is handled
+  defaultPeriod?: string;
+}) {
+  const navigation = useNavigation();
+  const location = useLocation();
+  const fetcher = useFetcher<{ logs: LogEntry[]; pagination: { next?: string } }>();
+  const [, startTransition] = useTransition();
+  const isLoading = navigation.state !== "idle";
+
+  // Accumulated logs state
+  const [accumulatedLogs, setAccumulatedLogs] = useState<LogEntry[]>(list.logs);
+  const [nextCursor, setNextCursor] = useState<string | undefined>(list.pagination.next);
+
+  // Selected log state - managed locally to avoid triggering navigation
+  const [selectedLogId, setSelectedLogId] = useState<string | undefined>(() => {
+    const params = new URLSearchParams(location.search);
+    return params.get("log") ?? undefined;
+  });
+
+  // Track which filter state (search params) the current fetcher request corresponds to
+  const fetcherFilterStateRef = useRef<string>(location.search);
+  // Track whether the current fetch is a "check for new" request vs "load more"
+  const isCheckingForNewRef = useRef<boolean>(false);
+
+  // Clear accumulated logs immediately when filters change (for instant visual feedback)
+  useEffect(() => {
+    setAccumulatedLogs([]);
+    setNextCursor(undefined);
+    // Preserve log selection from URL param, clear if not present
+    const params = new URLSearchParams(location.search);
+    setSelectedLogId(params.get("log") ?? undefined);
+  }, [location.search]);
+
+  // Populate accumulated logs when new data arrives
+  useEffect(() => {
+    setAccumulatedLogs(list.logs);
+    setNextCursor(list.pagination.next);
+  }, [list.logs, list.pagination.next]);
+
+  // Clear log parameter from URL when selectedLogId is cleared
+  useEffect(() => {
+    if (!selectedLogId) {
+      const url = new URL(window.location.href);
+      if (url.searchParams.has("log")) {
+        url.searchParams.delete("log");
+        window.history.replaceState(null, "", url.toString());
+      }
+    }
+  }, [selectedLogId]);
+
+  // Append/prepend new logs when fetcher completes (with deduplication)
+  useEffect(() => {
+    if (fetcher.data && fetcher.state === "idle") {
+      // Ignore fetcher data if it was loaded for a different filter state
+      if (fetcherFilterStateRef.current !== location.search) {
+        return;
+      }
+
+      if (isCheckingForNewRef.current) {
+        // "Check for new" - prepend new logs, don't update cursor
+        setAccumulatedLogs((prev) => {
+          const existingIds = new Set(prev.map((log) => log.id));
+          const newLogs = fetcher.data!.logs.filter((log) => !existingIds.has(log.id));
+          return newLogs.length > 0 ? [...newLogs, ...prev] : prev;
+        });
+        isCheckingForNewRef.current = false;
+      } else {
+        // "Load more" - append logs and update cursor
+        setAccumulatedLogs((prev) => {
+          const existingIds = new Set(prev.map((log) => log.id));
+          const newLogs = fetcher.data!.logs.filter((log) => !existingIds.has(log.id));
+          return newLogs.length > 0 ? [...prev, ...newLogs] : prev;
+        });
+        setNextCursor(fetcher.data.pagination.next);
+      }
+    }
+  }, [fetcher.data, fetcher.state, location.search]);
+
+  // Build resource URL for loading more
+  const loadMoreUrl = useMemo(() => {
+    if (!nextCursor) return null;
+    const resourcePath = `/resources${location.pathname}`;
+    const params = new URLSearchParams(location.search);
+    params.set("cursor", nextCursor);
+    params.delete("log");
+    return `${resourcePath}?${params.toString()}`;
+  }, [location.pathname, location.search, nextCursor]);
+
+  const handleLoadMore = useCallback(() => {
+    if (loadMoreUrl && fetcher.state === "idle") {
+      // Store the current filter state before loading
+      fetcherFilterStateRef.current = location.search;
+      fetcher.load(loadMoreUrl);
+    }
+  }, [loadMoreUrl, fetcher, location.search]);
+
+  const selectedLog = useMemo(() => {
+    if (!selectedLogId) return undefined;
+    return accumulatedLogs.find((log) => log.id === selectedLogId);
+  }, [selectedLogId, accumulatedLogs]);
+
+  const frozenLogId = useFrozenValue(selectedLogId);
+  const frozenLog = useFrozenValue(selectedLog);
+  const displayLogId = selectedLogId ?? frozenLogId;
+  const displayLog = selectedLog ?? frozenLog ?? undefined;
+
+  const updateUrlWithLog = useCallback((logId: string | undefined) => {
+    const url = new URL(window.location.href);
+    if (logId) {
+      url.searchParams.set("log", logId);
+    } else {
+      url.searchParams.delete("log");
+    }
+    window.history.replaceState(null, "", url.toString());
+  }, []);
+
+  const handleLogSelect = useCallback(
+    (logId: string) => {
+      startTransition(() => {
+        setSelectedLogId(logId);
+      });
+      updateUrlWithLog(logId);
+    },
+    [updateUrlWithLog, startTransition]
+  );
+
+  const handleClosePanel = useCallback(() => {
+    startTransition(() => {
+      setSelectedLogId(undefined);
+    });
+    updateUrlWithLog(undefined);
+  }, [updateUrlWithLog, startTransition]);
+
+  const handleCheckForMore = useCallback(() => {
+    if (fetcher.state !== "idle") return;
+    // Fetch without cursor to check for new logs
+    const resourcePath = `/resources${location.pathname}`;
+    const params = new URLSearchParams(location.search);
+    params.delete("cursor");
+    params.delete("log");
+    fetcherFilterStateRef.current = location.search;
+    isCheckingForNewRef.current = true;
+    fetcher.load(`${resourcePath}?${params.toString()}`);
+  }, [fetcher, location.pathname, location.search]);
+
+  return (
+    <ResizablePanelGroup orientation="horizontal" className="max-h-full">
+      <ResizablePanel id="logs-main" min="200px">
+        <LogsTable
+          key={location.search}
+          logs={accumulatedLogs}
+          searchTerm={list.searchTerm}
+          isLoading={isLoading}
+          isLoadingMore={fetcher.state === "loading"}
+          hasMore={!!nextCursor}
+          onLoadMore={handleLoadMore}
+          onCheckForMore={handleCheckForMore}
+          selectedLogId={selectedLogId}
+          onLogSelect={handleLogSelect}
+        />
+      </ResizablePanel>
+      <ResizableHandle id="logs-handle" className={collapsibleHandleClassName(!!selectedLogId)} />
+      <ResizablePanel
+        id="log-detail"
+        default="430px"
+        min="430px"
+        max="600px"
+        className="overflow-hidden"
+        collapsible
+        collapsed={!selectedLogId}
+        onCollapseChange={() => {}}
+        collapsedSize="0px"
+        collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+      >
+        <div className="h-full" style={{ minWidth: 430 }}>
+          {displayLogId && (
+            <Suspense
+              fallback={
+                <div className="flex h-full items-center justify-center">
+                  <Spinner />
+                </div>
+              }
+            >
+              <LogDetailView
+                logId={displayLogId}
+                initialLog={displayLog}
+                onClose={handleClosePanel}
+                searchTerm={list.searchTerm}
+              />
+            </Suspense>
+          )}
+        </div>
+      </ResizablePanel>
+    </ResizablePanelGroup>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.$dashboardKey.ts b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.$dashboardKey.ts
new file mode 100644
index 00000000000..0cad1ca559f
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.$dashboardKey.ts
@@ -0,0 +1,20 @@
+import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { EnvironmentParamSchema, v3BuiltInDashboardPath } from "~/utils/pathBuilder";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  dashboardKey: z.string(),
+});
+
+export const loader = async ({ params }: LoaderFunctionArgs) => {
+  const { organizationSlug, projectParam, envParam, dashboardKey } = ParamSchema.parse(params);
+  return redirect(
+    v3BuiltInDashboardPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam },
+      dashboardKey
+    ),
+    301
+  );
+};
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.custom.$dashboardId.ts b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.custom.$dashboardId.ts
new file mode 100644
index 00000000000..d15f6b78b1c
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.metrics.custom.$dashboardId.ts
@@ -0,0 +1,20 @@
+import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { EnvironmentParamSchema, v3CustomDashboardPath } from "~/utils/pathBuilder";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  dashboardId: z.string(),
+});
+
+export const loader = async ({ params }: LoaderFunctionArgs) => {
+  const { organizationSlug, projectParam, envParam, dashboardId } = ParamSchema.parse(params);
+  return redirect(
+    v3CustomDashboardPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam },
+      { friendlyId: dashboardId }
+    ),
+    301
+  );
+};
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.$modelId/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.$modelId/route.tsx
new file mode 100644
index 00000000000..7a25f996d4d
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.$modelId/route.tsx
@@ -0,0 +1,575 @@
+import { ArrowsRightLeftIcon } from "@heroicons/react/20/solid";
+import { type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { useState } from "react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { Badge } from "~/components/primitives/Badge";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { Header2 } from "~/components/primitives/Headers";
+import { Input } from "~/components/primitives/Input";
+import { Label } from "~/components/primitives/Label";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import * as Property from "~/components/primitives/PropertyTable";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { TabButton, TabContainer } from "~/components/primitives/Tabs";
+import { InlineCode } from "~/components/code/InlineCode";
+import { MetricWidget } from "~/routes/resources.metric";
+import type { QueryWidgetConfig } from "~/components/metrics/QueryWidget";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { ModelRegistryPresenter } from "~/presenters/v3/ModelRegistryPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUserId } from "~/services/session.server";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import {
+  EnvironmentParamSchema,
+  v3ModelComparePath,
+  v3ModelsPath,
+} from "~/utils/pathBuilder";
+import {
+  formatModelPrice,
+  formatTokenCount,
+  formatModelCost,
+  formatFeature,
+  formatProviderName,
+} from "~/utils/modelFormatters";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  modelId: z.string(),
+});
+
+export const meta: MetaFunction = () => {
+  return [{ title: "Model Detail | Trigger.dev" }];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, modelId } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const presenter = new ModelRegistryPresenter(clickhouseClient);
+  const model = await presenter.getModelDetail(modelId);
+
+  if (!model) {
+    throw new Response("Model not found", { status: 404 });
+  }
+
+  const now = new Date();
+  const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+  const userMetrics = await presenter.getUserMetrics(
+    model.modelName,
+    project.id,
+    environment.id,
+    sevenDaysAgo,
+    now
+  );
+
+  return typedjson({
+    model,
+    userMetrics,
+    organizationId: project.organizationId,
+    projectId: project.id,
+    environmentId: environment.id,
+  });
+};
+
+/** Escape a value for safe interpolation into a TSQL single-quoted string. */
+function escapeTSQL(value: string): string {
+  return value.replace(/'/g, "''");
+}
+
+function bignumberConfig(column: string, opts?: { aggregation?: "sum" | "avg" | "first"; suffix?: string; abbreviate?: boolean }): QueryWidgetConfig {
+  return { type: "bignumber", column, aggregation: opts?.aggregation ?? "sum", abbreviate: opts?.abbreviate ?? false, suffix: opts?.suffix };
+}
+
+function chartConfig(opts: { chartType: "bar" | "line"; xAxisColumn: string; yAxisColumns: string[]; aggregation?: "sum" | "avg" }): QueryWidgetConfig {
+  return { type: "chart", chartType: opts.chartType, xAxisColumn: opts.xAxisColumn, yAxisColumns: opts.yAxisColumns, groupByColumn: null, stacked: false, sortByColumn: null, sortDirection: "asc", aggregation: opts.aggregation ?? "sum" };
+}
+
+type Tab = "overview" | "global" | "usage";
+
+const TAB_CONFIG: { id: Tab; label: string }[] = [
+  { id: "overview", label: "Overview" },
+  { id: "usage", label: "Metrics" },
+  { id: "global", label: "Global metrics" },
+];
+
+export default function ModelDetailPage() {
+  const { model, userMetrics, organizationId, projectId, environmentId } =
+    useTypedLoaderData<typeof loader>();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const [activeTab, setActiveTab] = useState<Tab>("overview");
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle
+          title={model.displayId}
+          backButton={{
+            to: v3ModelsPath(organization, project, environment),
+            text: "Models",
+          }}
+        />
+        <PageAccessories>
+          <LinkButton
+            variant="tertiary/small"
+            to={`${v3ModelComparePath(organization, project, environment)}?models=${model.modelName}`}
+            LeadingIcon={ArrowsRightLeftIcon}
+          >
+            Compare with...
+          </LinkButton>
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable>
+        <TabContainer>
+          {TAB_CONFIG.map((tab) => (
+            <TabButton
+              key={tab.id}
+              isActive={activeTab === tab.id}
+              layoutId="model-detail-tabs"
+              onClick={() => setActiveTab(tab.id)}
+            >
+              {tab.label}
+            </TabButton>
+          ))}
+        </TabContainer>
+
+        <div className="p-4">
+          {activeTab === "overview" && <OverviewTab model={model} userMetrics={userMetrics} />}
+          {activeTab === "global" && (
+            <GlobalMetricsTab
+              modelName={model.modelName}
+              organizationId={organizationId}
+              projectId={projectId}
+              environmentId={environmentId}
+            />
+          )}
+          {activeTab === "usage" && (
+            <YourUsageTab
+              modelName={model.modelName}
+              organizationId={organizationId}
+              projectId={projectId}
+              environmentId={environmentId}
+            />
+          )}
+        </div>
+      </PageBody>
+    </PageContainer>
+  );
+}
+
+// --- Cost Estimator ---
+
+function CostEstimator({
+  inputPrice,
+  outputPrice,
+  defaultInputTokens,
+  defaultOutputTokens,
+}: {
+  inputPrice: number | null;
+  outputPrice: number | null;
+  defaultInputTokens?: number;
+  defaultOutputTokens?: number;
+}) {
+  const [inputTokens, setInputTokens] = useState(defaultInputTokens ?? 1000);
+  const [outputTokens, setOutputTokens] = useState(defaultOutputTokens ?? 500);
+  const [numCalls, setNumCalls] = useState(1000);
+
+  if (inputPrice === null && outputPrice === null) return null;
+
+  const inputCost = inputTokens * (inputPrice ?? 0) * numCalls;
+  const outputCost = outputTokens * (outputPrice ?? 0) * numCalls;
+  const totalCost = inputCost + outputCost;
+
+  return (
+    <div className="rounded-md border border-grid-dimmed p-4">
+      <Header2 className="mb-3">Cost Estimator</Header2>
+      <div className="space-y-3">
+        <div className="grid grid-cols-3 gap-3">
+          <div className="space-y-1.5">
+            <Label htmlFor="input-tokens">Input tokens/call</Label>
+            <Input
+              id="input-tokens"
+              variant="medium"
+              fullWidth
+              type="number"
+              value={inputTokens}
+              onChange={(e) => setInputTokens(parseInt(e.target.value) || 0)}
+            />
+          </div>
+          <div className="space-y-1.5">
+            <Label htmlFor="output-tokens">Output tokens/call</Label>
+            <Input
+              id="output-tokens"
+              variant="medium"
+              fullWidth
+              type="number"
+              value={outputTokens}
+              onChange={(e) => setOutputTokens(parseInt(e.target.value) || 0)}
+            />
+          </div>
+          <div className="space-y-1.5">
+            <Label htmlFor="num-calls">Number of calls</Label>
+            <Input
+              id="num-calls"
+              variant="medium"
+              fullWidth
+              type="number"
+              value={numCalls}
+              onChange={(e) => setNumCalls(parseInt(e.target.value) || 0)}
+            />
+          </div>
+        </div>
+        <Callout variant="info">
+          <div className="text-lg font-semibold tabular-nums text-text-bright">
+            {formatModelCost(totalCost)}
+          </div>
+          <div className="mt-1 space-y-0.5 text-xs tabular-nums text-text-dimmed">
+            <div>
+              Input: {formatModelCost(inputCost)} ({formatTokenCount(inputTokens * numCalls)}{" "}
+              tokens x {formatModelPrice(inputPrice)}/1M)
+            </div>
+            <div>
+              Output: {formatModelCost(outputCost)} ({formatTokenCount(outputTokens * numCalls)}{" "}
+              tokens x {formatModelPrice(outputPrice)}/1M)
+            </div>
+          </div>
+        </Callout>
+      </div>
+    </div>
+  );
+}
+
+// --- Overview Tab ---
+
+function OverviewTab({
+  model,
+  userMetrics,
+}: {
+  model: ReturnType<typeof useTypedLoaderData<typeof loader>>["model"];
+  userMetrics: ReturnType<typeof useTypedLoaderData<typeof loader>>["userMetrics"];
+}) {
+  return (
+    <div className="space-y-4">
+      <div className="grid grid-cols-1 gap-4 lg:grid-cols-2">
+        {/* Model Info */}
+        <div className="rounded-md border border-grid-dimmed p-4">
+          <Header2 className="mb-3">Model Info</Header2>
+          <Property.Table>
+            <Property.Item>
+              <Property.Label>Provider</Property.Label>
+              <Property.Value>{formatProviderName(model.provider)}</Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>Model Name</Property.Label>
+              <Property.Value>
+                <InlineCode variant="small">{model.modelName}</InlineCode>
+              </Property.Value>
+            </Property.Item>
+            {model.description && (
+              <Property.Item>
+                <Property.Label>Description</Property.Label>
+                <Property.Value>{model.description}</Property.Value>
+              </Property.Item>
+            )}
+            {model.contextWindow && (
+              <Property.Item>
+                <Property.Label>Context Window</Property.Label>
+                <Property.Value>
+                  {formatTokenCount(model.contextWindow)} tokens
+                </Property.Value>
+              </Property.Item>
+            )}
+            {model.maxOutputTokens && (
+              <Property.Item>
+                <Property.Label>Max Output</Property.Label>
+                <Property.Value>
+                  {formatTokenCount(model.maxOutputTokens)} tokens
+                </Property.Value>
+              </Property.Item>
+            )}
+            {model.features.length > 0 && (
+              <Property.Item>
+                <Property.Label>Features</Property.Label>
+                <Property.Value>
+                  <div className="flex flex-wrap gap-1">
+                    {model.features.map((f) => (
+                      <Badge key={f} variant="outline-rounded">
+                        {formatFeature(f)}
+                      </Badge>
+                    ))}
+                  </div>
+                </Property.Value>
+              </Property.Item>
+            )}
+            <Property.Item>
+              <Property.Label>Match Pattern</Property.Label>
+              <Property.Value>
+                <InlineCode variant="small">{model.matchPattern}</InlineCode>
+              </Property.Value>
+            </Property.Item>
+          </Property.Table>
+        </div>
+
+        {/* Pricing */}
+        <div className="rounded-md border border-grid-dimmed p-4">
+          <Header2 className="mb-3">Pricing</Header2>
+          <Property.Table>
+            <Property.Item>
+              <Property.Label>Input</Property.Label>
+              <Property.Value>
+                {formatModelPrice(model.inputPrice)} / 1M tokens
+              </Property.Value>
+            </Property.Item>
+            <Property.Item>
+              <Property.Label>Output</Property.Label>
+              <Property.Value>
+                {formatModelPrice(model.outputPrice)} / 1M tokens
+              </Property.Value>
+            </Property.Item>
+          </Property.Table>
+          {model.pricingTiers.length > 1 && (
+            <div className="mt-4">
+              <p className="mb-2 text-xs font-medium text-text-dimmed">All pricing tiers</p>
+              {model.pricingTiers.map((tier) => (
+                <div
+                  key={tier.name}
+                  className="mb-2 rounded border border-grid-dimmed p-2 text-xs"
+                >
+                  <span className="font-medium text-text-bright">{tier.name}</span>
+                  {tier.isDefault && (
+                    <Badge variant="outline-rounded" className="ml-2">
+                      default
+                    </Badge>
+                  )}
+                  <div className="mt-1 space-y-0.5 text-text-dimmed">
+                    {Object.entries(tier.prices).map(([usage, price]) => (
+                      <div key={usage}>
+                        {usage}: ${(price * 1_000_000).toFixed(4)} / 1M
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Cost Estimator */}
+      <CostEstimator
+        inputPrice={model.inputPrice}
+        outputPrice={model.outputPrice}
+        defaultInputTokens={
+          userMetrics.totalCalls > 0
+            ? Math.round(userMetrics.totalInputTokens / userMetrics.totalCalls)
+            : undefined
+        }
+        defaultOutputTokens={
+          userMetrics.totalCalls > 0
+            ? Math.round(userMetrics.totalOutputTokens / userMetrics.totalCalls)
+            : undefined
+        }
+      />
+    </div>
+  );
+}
+
+// --- Global Metrics Tab ---
+
+function GlobalMetricsTab({
+  modelName,
+  organizationId,
+  projectId,
+  environmentId,
+}: {
+  modelName: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+}) {
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period: "7d",
+    from: null,
+    to: null,
+  };
+
+  return (
+    <div className="space-y-4">
+      {/* Big numbers */}
+      <div className="grid grid-cols-2 gap-3 sm:grid-cols-3">
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-ttfc-p50`}
+            title="p50 TTFC"
+            query={`SELECT round(quantilesMerge(0.5)(ttfc_quantiles)[1], 0) AS ttfc_p50 FROM llm_models WHERE response_model = '${escapeTSQL(modelName)}'`}
+            config={bignumberConfig("ttfc_p50", { aggregation: "avg", suffix: "ms" })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-ttfc-p90`}
+            title="p90 TTFC"
+            query={`SELECT round(quantilesMerge(0.9)(ttfc_quantiles)[1], 0) AS ttfc_p90 FROM llm_models WHERE response_model = '${escapeTSQL(modelName)}'`}
+            config={bignumberConfig("ttfc_p90", { aggregation: "avg", suffix: "ms" })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-tps`}
+            title="Tokens/sec (p50)"
+            query={`SELECT round(quantilesMerge(0.5)(tps_quantiles)[1], 0) AS tps_p50 FROM llm_models WHERE response_model = '${escapeTSQL(modelName)}'`}
+            config={bignumberConfig("tps_p50", { aggregation: "avg" })}
+            {...widgetProps}
+          />
+        </div>
+      </div>
+
+      {/* Charts */}
+      <div className="h-[300px]">
+        <MetricWidget
+          widgetKey={`${modelName}-ttfc-time`}
+          title="TTFC over time"
+          query={`SELECT timeBucket(), round(quantilesMerge(0.5)(ttfc_quantiles)[1], 0) AS ttfc_p50, round(quantilesMerge(0.9)(ttfc_quantiles)[1], 0) AS ttfc_p90 FROM llm_models WHERE response_model = '${escapeTSQL(modelName)}' GROUP BY timeBucket ORDER BY timeBucket`}
+          config={chartConfig({ chartType: "line", xAxisColumn: "timebucket", yAxisColumns: ["ttfc_p50", "ttfc_p90"], aggregation: "avg" })}
+          {...widgetProps}
+        />
+      </div>
+
+      <Callout variant="info">
+        Aggregated across all Trigger.dev users. No tenant-specific data is exposed.
+      </Callout>
+    </div>
+  );
+}
+
+// --- Your Usage Tab ---
+
+function YourUsageTab({
+  modelName,
+  organizationId,
+  projectId,
+  environmentId,
+}: {
+  modelName: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+}) {
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period: "7d",
+    from: null,
+    to: null,
+  };
+
+  return (
+    <div className="space-y-4">
+      {/* Big numbers */}
+      <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-user-calls`}
+            title="Total calls (7d)"
+            query={`SELECT count() AS total_calls FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}'`}
+            config={bignumberConfig("total_calls", { abbreviate: true })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-user-cost`}
+            title="Total cost (7d)"
+            query={`SELECT sum(total_cost) AS total_cost FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}'`}
+            config={bignumberConfig("total_cost", { aggregation: "sum" })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-user-ttfc`}
+            title="Avg TTFC"
+            query={`SELECT round(avg(ms_to_first_chunk), 0) AS avg_ttfc FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}' AND ms_to_first_chunk > 0`}
+            config={bignumberConfig("avg_ttfc", { aggregation: "avg", suffix: "ms" })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-24">
+          <MetricWidget
+            widgetKey={`${modelName}-user-tps`}
+            title="Avg Tokens/sec"
+            query={`SELECT round(avg(tokens_per_second), 0) AS avg_tps FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}' AND tokens_per_second > 0`}
+            config={bignumberConfig("avg_tps", { aggregation: "avg" })}
+            {...widgetProps}
+          />
+        </div>
+      </div>
+
+      {/* Charts */}
+      <div className="grid grid-cols-1 gap-3 lg:grid-cols-2">
+        <div className="h-[300px]">
+          <MetricWidget
+            widgetKey={`${modelName}-user-cost-time`}
+            title="Cost over time"
+            query={`SELECT timeBucket(), sum(total_cost) AS cost FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}' GROUP BY timeBucket ORDER BY timeBucket`}
+            config={chartConfig({ chartType: "bar", xAxisColumn: "timebucket", yAxisColumns: ["cost"] })}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-[300px]">
+          <MetricWidget
+            widgetKey={`${modelName}-user-tokens-time`}
+            title="Tokens over time"
+            query={`SELECT timeBucket(), sum(input_tokens) AS input_tokens, sum(output_tokens) AS output_tokens FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}' GROUP BY timeBucket ORDER BY timeBucket`}
+            config={chartConfig({ chartType: "bar", xAxisColumn: "timebucket", yAxisColumns: ["input_tokens", "output_tokens"] })}
+            {...widgetProps}
+          />
+        </div>
+      </div>
+
+      {/* Task breakdown */}
+      <div className="h-[300px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-tasks`}
+          title="Cost by task"
+          query={`SELECT task_identifier, count() AS calls, sum(total_cost) AS cost FROM llm_metrics WHERE response_model = '${escapeTSQL(modelName)}' GROUP BY task_identifier ORDER BY cost DESC LIMIT 20`}
+          config={{ type: "table", prettyFormatting: true, sorting: [] }}
+          {...widgetProps}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models._index/route.tsx
new file mode 100644
index 00000000000..7bf257f987b
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models._index/route.tsx
@@ -0,0 +1,1181 @@
+import {
+  AdjustmentsHorizontalIcon,
+  CheckIcon,
+  CubeIcon,
+  XMarkIcon,
+} from "@heroicons/react/20/solid";
+import * as Ariakit from "@ariakit/react";
+import { Form, type MetaFunction, useFetcher } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { AnimatePresence, motion } from "framer-motion";
+import { useEffect, useMemo, useState } from "react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import {
+  AnthropicIcon,
+  AzureIcon,
+  CerebrasIcon,
+  DeepseekIcon,
+  GeminiIcon,
+  LlamaIcon,
+  MistralIcon,
+  OpenAIIcon,
+  PerplexityIcon,
+  XAIIcon,
+} from "~/assets/icons/AiProviderIcons";
+import { ExitIcon } from "~/assets/icons/ExitIcon";
+import { InlineCode } from "~/components/code/InlineCode";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import { Badge } from "~/components/primitives/Badge";
+import { Button } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { Checkbox } from "~/components/primitives/Checkbox";
+import { DateTime } from "~/components/primitives/DateTime";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "~/components/primitives/Dialog";
+import { Header2 } from "~/components/primitives/Headers";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import * as Property from "~/components/primitives/PropertyTable";
+import {
+  RESIZABLE_PANEL_ANIMATION,
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  collapsibleHandleClassName,
+  useFrozenValue,
+} from "~/components/primitives/Resizable";
+import { SearchInput } from "~/components/primitives/SearchInput";
+import { Switch } from "~/components/primitives/Switch";
+import {
+  SelectProvider,
+  SelectPopover,
+  SelectList,
+  SelectItem,
+} from "~/components/primitives/Select";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { TabButton, TabContainer } from "~/components/primitives/Tabs";
+import { appliedSummary } from "~/components/runs/v3/SharedFilters";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { useOptimisticLocation } from "~/hooks/useOptimisticLocation";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  type ModelCatalogItem,
+  type ModelComparisonItem,
+  type PopularModel,
+  ModelRegistryPresenter,
+} from "~/presenters/v3/ModelRegistryPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUserId } from "~/services/session.server";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { EnvironmentParamSchema, v3ModelComparePath } from "~/utils/pathBuilder";
+import {
+  formatModelPrice,
+  formatTokenCount,
+  formatFeature,
+  formatProviderName,
+  formatModelCost,
+} from "~/utils/modelFormatters";
+import { formatNumberCompact } from "~/utils/numberFormatter";
+import { Spinner } from "~/components/primitives/Spinner";
+import { MetricWidget } from "~/routes/resources.metric";
+import type { QueryWidgetConfig } from "~/components/metrics/QueryWidget";
+
+import { type loader as compareLoader } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.compare/route";
+
+export const meta: MetaFunction = () => {
+  return [{ title: "Models | Trigger.dev" }];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const presenter = new ModelRegistryPresenter(clickhouseClient);
+  const catalog = await presenter.getModelCatalog();
+
+  const now = new Date();
+  const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+  const popularModels = await presenter.getPopularModels(sevenDaysAgo, now, 50);
+
+  const allProviders = catalog.map((g) => g.provider);
+  const allFeatures = Array.from(
+    new Set(catalog.flatMap((g) => g.models.flatMap((m) => m.features)))
+  ).sort();
+
+  return typedjson({
+    catalog,
+    popularModels,
+    allProviders,
+    allFeatures,
+    organizationId: project.organizationId,
+    projectId: project.id,
+    environmentId: environment.id,
+  });
+};
+
+const providerIcons: Record<string, (props: { className?: string }) => JSX.Element> = {
+  openai: OpenAIIcon,
+  anthropic: AnthropicIcon,
+  google: GeminiIcon,
+  meta: LlamaIcon,
+  mistral: MistralIcon,
+  deepseek: DeepseekIcon,
+  xai: XAIIcon,
+  perplexity: PerplexityIcon,
+  cerebras: CerebrasIcon,
+  azure: AzureIcon,
+};
+
+function providerIcon(slug: string) {
+  const Icon = providerIcons[slug] ?? CubeIcon;
+  return <Icon className="size-4" />;
+}
+
+// --- Filter Components ---
+
+function ProviderFilter({ providers }: { providers: string[] }) {
+  const { values, replace, del } = useSearchParams();
+  const selected = values("providers");
+  const hasFilter = selected.length > 0;
+
+  return (
+    <SelectProvider value={selected} setValue={(v) => replace({ providers: v })}>
+      <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+        <AppliedFilter
+          icon={<CubeIcon className="size-4" />}
+          label={hasFilter ? "Provider" : undefined}
+          value={hasFilter ? appliedSummary(selected.map(formatProviderName))! : "Provider"}
+          valueClassName={hasFilter ? undefined : "text-text-bright"}
+          removable={hasFilter}
+          onRemove={() => del("providers")}
+        />
+      </Ariakit.Select>
+      <SelectPopover>
+        <SelectList>
+          {providers.map((p) => (
+            <SelectItem key={p} value={p} icon={providerIcon(p)}>
+              {formatProviderName(p)}
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+function FeaturesFilter({ features }: { features: string[] }) {
+  const { values, replace, del } = useSearchParams();
+  const selected = values("features");
+  const hasFilter = selected.length > 0;
+
+  return (
+    <SelectProvider value={selected} setValue={(v) => replace({ features: v })}>
+      <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+        <AppliedFilter
+          icon={<AdjustmentsHorizontalIcon className="size-4" />}
+          label={hasFilter ? "Features" : undefined}
+          value={hasFilter ? appliedSummary(selected.map(formatFeature))! : "Features"}
+          valueClassName={hasFilter ? undefined : "text-text-bright"}
+          removable={hasFilter}
+          onRemove={() => del("features")}
+        />
+      </Ariakit.Select>
+      <SelectPopover>
+        <SelectList>
+          {features.map((f) => (
+            <SelectItem key={f} value={f}>
+              {formatFeature(f)}
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+// --- Filters Bar ---
+
+function FiltersBar({
+  allProviders,
+  allFeatures,
+  compareSet,
+  onCompare,
+  showAllDetails,
+  onToggleAllDetails,
+}: {
+  allProviders: string[];
+  allFeatures: string[];
+  compareSet: Set<string>;
+  onCompare: () => void;
+  showAllDetails: boolean;
+  onToggleAllDetails: (checked: boolean) => void;
+}) {
+  const location = useOptimisticLocation();
+  const searchParams = new URLSearchParams(location.search);
+  const hasFilters =
+    searchParams.has("providers") || searchParams.has("features") || searchParams.has("search");
+
+  const compareDisabled = compareSet.size < 2;
+
+  return (
+    <div className="flex items-start justify-between gap-x-2 border-b border-grid-bright p-2">
+      <div className="flex flex-row flex-wrap items-center gap-2">
+        <ProviderFilter providers={allProviders} />
+        <FeaturesFilter features={allFeatures} />
+        <SearchInput placeholder="Search models…" />
+        {hasFilters && (
+          <Form className="-ml-1 h-6">
+            <Button variant="minimal/small" LeadingIcon={XMarkIcon} tooltip="Clear all filters" />
+          </Form>
+        )}
+      </div>
+      <div className="flex shrink-0 items-center gap-2">
+        <Button
+          variant="secondary/small"
+          disabled={compareDisabled}
+          className="px-1.5"
+          tooltip={compareDisabled ? "Choose 2–4 models to compare" : "Compare selected models"}
+          onClick={compareDisabled ? undefined : onCompare}
+        >
+          <span className="flex items-center overflow-hidden">
+            <span className={!compareDisabled ? "text-text-bright" : undefined}>Compare</span>
+            <AnimatePresence initial={false}>
+              {compareSet.size >= 2 && (
+                <motion.span
+                  key="badge"
+                  initial={{ width: 0, marginLeft: 0, opacity: 0 }}
+                  animate={{ width: "auto", marginLeft: 4, opacity: 1 }}
+                  exit={{ width: 0, marginLeft: 0, opacity: 0 }}
+                  transition={{ duration: 0.15, ease: "easeInOut" }}
+                  className="inline-flex"
+                >
+                  <Badge variant="rounded">{compareSet.size}</Badge>
+                </motion.span>
+              )}
+            </AnimatePresence>
+          </span>
+        </Button>
+        <Switch
+          variant="secondary/small"
+          label="All details"
+          checked={showAllDetails}
+          onCheckedChange={onToggleAllDetails}
+        />
+      </div>
+    </div>
+  );
+}
+
+// --- Models Table ---
+
+function BooleanCell({ value, onClick }: { value: boolean; onClick: () => void }) {
+  return (
+    <TableCell onClick={onClick} alignment="center">
+      {value ? (
+        <CheckIcon className="size-4 text-text-dimmed group-hover/table-row:text-text-bright" />
+      ) : null}
+    </TableCell>
+  );
+}
+
+function ModelsList({
+  models,
+  popularMap,
+  compareSet,
+  onToggleCompare,
+  showAllDetails,
+  allFeatures,
+  selectedModelId,
+  onSelectModel,
+}: {
+  models: ModelCatalogItem[];
+  popularMap: Map<string, PopularModel>;
+  compareSet: Set<string>;
+  onToggleCompare: (modelName: string) => void;
+  showAllDetails: boolean;
+  allFeatures: string[];
+  selectedModelId: string | null;
+  onSelectModel: (model: ModelCatalogItem) => void;
+}) {
+  if (models.length === 0) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3">
+        <p className="text-center text-sm text-text-dimmed">No models match your filters.</p>
+      </div>
+    );
+  }
+
+  return (
+    <Table containerClassName="max-h-full" showTopBorder={false}>
+      <TableHeader>
+        <TableRow>
+          <TableHeaderCell className="w-8" />
+          <TableHeaderCell>Model</TableHeaderCell>
+          <TableHeaderCell>Provider</TableHeaderCell>
+          <TableHeaderCell alignment="right">Input $/1M</TableHeaderCell>
+          <TableHeaderCell alignment="right">Output $/1M</TableHeaderCell>
+          <TableHeaderCell alignment="right">Context</TableHeaderCell>
+          {showAllDetails && (
+            <>
+              <TableHeaderCell alignment="right">Max output</TableHeaderCell>
+              <TableHeaderCell>Release date</TableHeaderCell>
+              {allFeatures.map((f) => (
+                <TableHeaderCell key={f} alignment="center">
+                  {formatFeature(f)}
+                </TableHeaderCell>
+              ))}
+            </>
+          )}
+          <TableHeaderCell alignment="right">p50 TTFC</TableHeaderCell>
+        </TableRow>
+      </TableHeader>
+      <TableBody>
+        {models.map((model) => {
+          const popular = popularMap.get(model.modelName);
+          const select = () => onSelectModel(model);
+          return (
+            <TableRow key={model.friendlyId} isSelected={selectedModelId === model.friendlyId}>
+              <TableCell>
+                <Checkbox
+                  checked={compareSet.has(model.modelName)}
+                  onChange={() => onToggleCompare(model.modelName)}
+                  disabled={compareSet.size >= 4 && !compareSet.has(model.modelName)}
+                />
+              </TableCell>
+              <TableCell onClick={select} isTabbableCell>
+                {model.displayId}
+              </TableCell>
+              <TableCell onClick={select}>
+                <span className="flex items-center gap-1.5">
+                  {providerIcon(model.provider)}
+                  {formatProviderName(model.provider)}
+                </span>
+              </TableCell>
+              <TableCell onClick={select} alignment="right" className="tabular-nums">
+                {formatModelPrice(model.inputPrice)}
+              </TableCell>
+              <TableCell onClick={select} alignment="right" className="tabular-nums">
+                {formatModelPrice(model.outputPrice)}
+              </TableCell>
+              <TableCell onClick={select} alignment="right" className="tabular-nums">
+                {formatTokenCount(model.contextWindow)}
+              </TableCell>
+              {showAllDetails && (
+                <>
+                  <TableCell onClick={select} alignment="right" className="tabular-nums">
+                    {formatTokenCount(model.maxOutputTokens)}
+                  </TableCell>
+                  <TableCell onClick={select}>
+                    {model.releaseDate ? (
+                      <DateTime date={model.releaseDate} includeTime={false} />
+                    ) : (
+                      "—"
+                    )}
+                  </TableCell>
+                  {allFeatures.map((f) => (
+                    <BooleanCell key={f} value={model.features.includes(f)} onClick={select} />
+                  ))}
+                </>
+              )}
+              <TableCell onClick={select} alignment="right" className="tabular-nums">
+                {popular && popular.ttfcP50 > 0 ? `${popular.ttfcP50.toFixed(0)}ms` : "—"}
+              </TableCell>
+            </TableRow>
+          );
+        })}
+      </TableBody>
+    </Table>
+  );
+}
+
+// --- Compare Dialog ---
+
+type ComparisonRow = {
+  label: string;
+  values: React.ReactNode[];
+  bestIndex?: number;
+};
+
+function buildComparisonRows(
+  models: string[],
+  catalogModels: ModelCatalogItem[],
+  comparison: ModelComparisonItem[]
+): ComparisonRow[] {
+  const catalogMap = new Map<string, ModelCatalogItem>();
+  for (const item of catalogModels) {
+    catalogMap.set(item.modelName, item);
+  }
+
+  const dataMap = new Map<string, ModelComparisonItem>();
+  for (const item of comparison) {
+    dataMap.set(item.responseModel, item);
+  }
+
+  const allFeatures = Array.from(
+    new Set(models.flatMap((m) => catalogMap.get(m)?.features ?? []))
+  ).sort();
+
+  const getCatalog = (model: string) => catalogMap.get(model);
+  const getMetric = (model: string, key: keyof ModelComparisonItem) => {
+    const d = dataMap.get(model);
+    return d ? d[key] : 0;
+  };
+
+  const findBest = (values: number[], lowerIsBetter: boolean) => {
+    if (values.every((v) => v === 0)) return undefined;
+    const filtered = values.map((v, i) => ({ v, i })).filter(({ v }) => v > 0);
+    if (filtered.length === 0) return undefined;
+    const best = lowerIsBetter
+      ? filtered.reduce((a, b) => (a.v < b.v ? a : b))
+      : filtered.reduce((a, b) => (a.v > b.v ? a : b));
+    return best.i;
+  };
+
+  const inputPrices = models.map((m) => getCatalog(m)?.inputPrice ?? 0);
+  const outputPrices = models.map((m) => getCatalog(m)?.outputPrice ?? 0);
+  const contextWindows = models.map((m) => getCatalog(m)?.contextWindow ?? 0);
+  const maxOutputs = models.map((m) => getCatalog(m)?.maxOutputTokens ?? 0);
+  const callValues = models.map((m) => Number(getMetric(m, "callCount")));
+  const ttfcP50Values = models.map((m) => Number(getMetric(m, "ttfcP50")));
+  const ttfcP90Values = models.map((m) => Number(getMetric(m, "ttfcP90")));
+  const tpsP50Values = models.map((m) => Number(getMetric(m, "tpsP50")));
+  const tpsP90Values = models.map((m) => Number(getMetric(m, "tpsP90")));
+  const costValues = models.map((m) => Number(getMetric(m, "totalCost")));
+
+  return [
+    {
+      label: "Provider",
+      values: models.map((m) => {
+        const c = getCatalog(m);
+        const slug = c?.provider ?? dataMap.get(m)?.genAiSystem;
+        if (!slug) return "—";
+        return (
+          <span className="flex items-center gap-1.5">
+            {providerIcon(slug)}
+            {formatProviderName(slug)}
+          </span>
+        );
+      }),
+    },
+    {
+      label: "Input $/1M",
+      values: models.map((m) => formatModelPrice(getCatalog(m)?.inputPrice ?? null)),
+      bestIndex: findBest(inputPrices, true),
+    },
+    {
+      label: "Output $/1M",
+      values: models.map((m) => formatModelPrice(getCatalog(m)?.outputPrice ?? null)),
+      bestIndex: findBest(outputPrices, true),
+    },
+    {
+      label: "Context window",
+      values: models.map((m) => formatTokenCount(getCatalog(m)?.contextWindow ?? null)),
+      bestIndex: findBest(contextWindows, false),
+    },
+    {
+      label: "Max output",
+      values: models.map((m) => formatTokenCount(getCatalog(m)?.maxOutputTokens ?? null)),
+      bestIndex: findBest(maxOutputs, false),
+    },
+    {
+      label: "Release date",
+      values: models.map((m) => {
+        const c = getCatalog(m);
+        return c?.releaseDate
+          ? new Date(c.releaseDate).toLocaleDateString(undefined, {
+              year: "numeric",
+              month: "short",
+              day: "numeric",
+            })
+          : "—";
+      }),
+    },
+    ...allFeatures.map((feature) => ({
+      label: formatFeature(feature),
+      values: models.map((m) =>
+        getCatalog(m)?.features.includes(feature) ? (
+          <CheckIcon className="size-4 text-success/70 group-hover/table-row:text-success" />
+        ) : (
+          "—"
+        )
+      ),
+    })),
+    {
+      label: "Total calls (7d)",
+      values: callValues.map((v) => formatNumberCompact(v)),
+      bestIndex: findBest(callValues, false),
+    },
+    {
+      label: "p50 TTFC",
+      values: ttfcP50Values.map((v) => (v > 0 ? `${v.toFixed(0)}ms` : "—")),
+      bestIndex: findBest(ttfcP50Values, true),
+    },
+    {
+      label: "p90 TTFC",
+      values: ttfcP90Values.map((v) => (v > 0 ? `${v.toFixed(0)}ms` : "—")),
+      bestIndex: findBest(ttfcP90Values, true),
+    },
+    {
+      label: "Tokens/sec (p50)",
+      values: tpsP50Values.map((v) => (v > 0 ? v.toFixed(0) : "—")),
+      bestIndex: findBest(tpsP50Values, false),
+    },
+    {
+      label: "Tokens/sec (p90)",
+      values: tpsP90Values.map((v) => (v > 0 ? v.toFixed(0) : "—")),
+      bestIndex: findBest(tpsP90Values, false),
+    },
+    {
+      label: "Total cost (7d)",
+      values: costValues.map((v) => (v > 0 ? formatModelCost(v) : "—")),
+      bestIndex: findBest(costValues, true),
+    },
+  ];
+}
+
+function CompareDialog({
+  open,
+  onOpenChange,
+  models,
+  catalogModels,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  models: string[];
+  catalogModels: ModelCatalogItem[];
+}) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const fetcher = useFetcher<typeof compareLoader>();
+
+  const comparison = (fetcher.data as { comparison?: ModelComparisonItem[] } | undefined)
+    ?.comparison;
+  const rows = useMemo(
+    () => buildComparisonRows(models, catalogModels, comparison ?? []),
+    [comparison, models, catalogModels]
+  );
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps -- intentionally only fires on open; other deps are stable per dialog mount
+  useEffect(() => {
+    if (open && models.length >= 2) {
+      const params = models.join(",");
+      fetcher.load(`${v3ModelComparePath(organization, project, environment)}?models=${params}`);
+    }
+  }, [open]);
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="!w-fit !px-0 !pb-0 sm:!max-w-[90vw]">
+        <DialogHeader className="px-4">
+          <DialogTitle>Compare models</DialogTitle>
+        </DialogHeader>
+        {rows.length > 0 ? (
+          <div className="-mt-[0.375rem] max-h-[70vh] overflow-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600 [&_tbody_tr:last-child]:after:hidden">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHeaderCell>Metric</TableHeaderCell>
+                  {models.map((model) => (
+                    <TableHeaderCell key={model} alignment="right">
+                      {model}
+                    </TableHeaderCell>
+                  ))}
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {rows.map((row) => (
+                  <TableRow key={row.label}>
+                    <TableCell>
+                      <span className="text-xs font-medium text-text-dimmed group-hover/table-row:text-text-bright">
+                        {row.label}
+                      </span>
+                    </TableCell>
+                    {row.values.map((value, i) => (
+                      <TableCell key={i} alignment="right">
+                        <div
+                          className={`flex items-center justify-end tabular-nums ${
+                            row.bestIndex === i
+                              ? "font-medium text-success/70 group-hover/table-row:text-success"
+                              : "text-text-dimmed group-hover/table-row:text-text-bright"
+                          }`}
+                        >
+                          {value}
+                        </div>
+                      </TableCell>
+                    ))}
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        ) : (
+          <div className="flex items-center justify-center py-12 text-sm text-text-dimmed">
+            No comparison data available for these models.
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+// --- Model Detail Panel ---
+
+function escapeTSQL(value: string): string {
+  return value.replace(/'/g, "''");
+}
+
+function bignumberConfig(
+  column: string,
+  opts?: { aggregation?: "sum" | "avg" | "first"; suffix?: string; abbreviate?: boolean }
+): QueryWidgetConfig {
+  return {
+    type: "bignumber",
+    column,
+    aggregation: opts?.aggregation ?? "sum",
+    abbreviate: opts?.abbreviate ?? false,
+    suffix: opts?.suffix,
+  };
+}
+
+function chartConfig(opts: {
+  chartType: "bar" | "line";
+  xAxisColumn: string;
+  yAxisColumns: string[];
+  aggregation?: "sum" | "avg";
+}): QueryWidgetConfig {
+  return {
+    type: "chart",
+    chartType: opts.chartType,
+    xAxisColumn: opts.xAxisColumn,
+    yAxisColumns: opts.yAxisColumns,
+    groupByColumn: null,
+    stacked: false,
+    sortByColumn: null,
+    sortDirection: "asc",
+    aggregation: opts.aggregation ?? "sum",
+  };
+}
+
+type DetailTab = "overview" | "global" | "usage";
+
+function ModelDetailPanel({
+  model,
+  organizationId,
+  projectId,
+  environmentId,
+  onClose,
+}: {
+  model: ModelCatalogItem;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  onClose: () => void;
+}) {
+  const [tab, setTab] = useState<DetailTab>("overview");
+
+  return (
+    <div className="grid h-full max-h-full grid-rows-[2.5rem_2rem_1fr] overflow-hidden bg-background-bright">
+      <div className="flex items-center justify-between gap-2 overflow-x-hidden px-3 pr-2">
+        <Header2 className="truncate text-text-bright">{model.displayId}</Header2>
+        <Button
+          onClick={onClose}
+          variant="minimal/small"
+          TrailingIcon={ExitIcon}
+          shortcut={{ key: "esc" }}
+          shortcutPosition="before-trailing-icon"
+          className="pl-1"
+        />
+      </div>
+      <div className="h-fit overflow-x-auto whitespace-nowrap px-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <TabContainer>
+          <TabButton
+            isActive={tab === "overview"}
+            layoutId="model-detail"
+            onClick={() => setTab("overview")}
+            shortcut={{ key: "o" }}
+          >
+            Overview
+          </TabButton>
+          <TabButton
+            isActive={tab === "usage"}
+            layoutId="model-detail"
+            onClick={() => setTab("usage")}
+            shortcut={{ key: "u" }}
+          >
+            Metrics
+          </TabButton>
+          <TabButton
+            isActive={tab === "global"}
+            layoutId="model-detail"
+            onClick={() => setTab("global")}
+            shortcut={{ key: "g" }}
+          >
+            Global metrics
+          </TabButton>
+        </TabContainer>
+      </div>
+      <div className="overflow-y-auto px-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        {tab === "overview" && <DetailOverviewTab model={model} />}
+        {tab === "global" && (
+          <DetailGlobalMetricsTab
+            modelName={model.modelName}
+            organizationId={organizationId}
+            projectId={projectId}
+            environmentId={environmentId}
+          />
+        )}
+        {tab === "usage" && (
+          <DetailYourUsageTab
+            modelName={model.modelName}
+            organizationId={organizationId}
+            projectId={projectId}
+            environmentId={environmentId}
+          />
+        )}
+      </div>
+    </div>
+  );
+}
+
+function DetailOverviewTab({ model }: { model: ModelCatalogItem }) {
+  return (
+    <div className="flex flex-col gap-4 py-3">
+      <Property.Table>
+        <Property.Item>
+          <Property.Label>Provider</Property.Label>
+          <Property.Value>{formatProviderName(model.provider)}</Property.Value>
+        </Property.Item>
+        <Property.Item>
+          <Property.Label>Model name</Property.Label>
+          <Property.Value>
+            <InlineCode variant="small">{model.modelName}</InlineCode>
+          </Property.Value>
+        </Property.Item>
+        {model.description && (
+          <Property.Item>
+            <Property.Label>Description</Property.Label>
+            <Property.Value>{model.description}</Property.Value>
+          </Property.Item>
+        )}
+        <Property.Item>
+          <Property.Label>Input price</Property.Label>
+          <Property.Value className="tabular-nums">
+            {formatModelPrice(model.inputPrice)} / 1M tokens
+          </Property.Value>
+        </Property.Item>
+        <Property.Item>
+          <Property.Label>Output price</Property.Label>
+          <Property.Value className="tabular-nums">
+            {formatModelPrice(model.outputPrice)} / 1M tokens
+          </Property.Value>
+        </Property.Item>
+        {model.contextWindow && (
+          <Property.Item>
+            <Property.Label>Context window</Property.Label>
+            <Property.Value className="tabular-nums">
+              {formatTokenCount(model.contextWindow)} tokens
+            </Property.Value>
+          </Property.Item>
+        )}
+        {model.maxOutputTokens && (
+          <Property.Item>
+            <Property.Label>Max output tokens</Property.Label>
+            <Property.Value className="tabular-nums">
+              {formatTokenCount(model.maxOutputTokens)} tokens
+            </Property.Value>
+          </Property.Item>
+        )}
+        {model.releaseDate && (
+          <Property.Item>
+            <Property.Label>Release date</Property.Label>
+            <Property.Value>
+              <DateTime date={model.releaseDate} includeTime={false} />
+            </Property.Value>
+          </Property.Item>
+        )}
+      </Property.Table>
+
+      {model.features.length > 0 && (
+        <Property.Table>
+          <Property.Item>
+            <Property.Label>Features</Property.Label>
+            <Property.Value>
+              <div className="flex flex-col gap-0.5">
+                {model.features.map((f) => (
+                  <div key={f} className="mt-1 flex items-center gap-1">
+                    <CheckIcon className="size-4 text-text-dimmed" />
+                    <span className="text-text-dimmed">{formatFeature(f)}</span>
+                  </div>
+                ))}
+              </div>
+            </Property.Value>
+          </Property.Item>
+        </Property.Table>
+      )}
+
+      {model.variants.length > 0 && (
+        <>
+          <Header2>Variants</Header2>
+          <Property.Table>
+            {model.variants.map((v) => (
+              <Property.Item key={v.friendlyId}>
+                <Property.Label>{v.displayId}</Property.Label>
+                <Property.Value>
+                  {v.releaseDate ? <DateTime date={v.releaseDate} includeTime={false} /> : "—"}
+                </Property.Value>
+              </Property.Item>
+            ))}
+          </Property.Table>
+        </>
+      )}
+    </div>
+  );
+}
+
+function DetailGlobalMetricsTab({
+  modelName,
+  organizationId,
+  projectId,
+  environmentId,
+}: {
+  modelName: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+}) {
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period: "7d",
+    from: null,
+    to: null,
+  };
+
+  return (
+    <div className="flex flex-col gap-3 py-3">
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-ttfc-p50`}
+          title="p50 TTFC"
+          query={`SELECT round(quantilesMerge(0.5)(ttfc_quantiles)[1], 0) AS ttfc_p50 FROM llm_models WHERE response_model = '${escapeTSQL(
+            modelName
+          )}'`}
+          config={bignumberConfig("ttfc_p50", { aggregation: "avg", suffix: "ms" })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-ttfc-p90`}
+          title="p90 TTFC"
+          query={`SELECT round(quantilesMerge(0.9)(ttfc_quantiles)[1], 0) AS ttfc_p90 FROM llm_models WHERE response_model = '${escapeTSQL(
+            modelName
+          )}'`}
+          config={bignumberConfig("ttfc_p90", { aggregation: "avg", suffix: "ms" })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-tps`}
+          title="Tokens/sec (p50)"
+          query={`SELECT round(quantilesMerge(0.5)(tps_quantiles)[1], 0) AS tps_p50 FROM llm_models WHERE response_model = '${escapeTSQL(
+            modelName
+          )}'`}
+          config={bignumberConfig("tps_p50", { aggregation: "avg" })}
+          {...widgetProps}
+        />
+      </div>
+
+      <div className="h-[400px]">
+        <MetricWidget
+          widgetKey={`${modelName}-ttfc-time`}
+          title="TTFC over time"
+          query={`SELECT timeBucket(), round(quantilesMerge(0.5)(ttfc_quantiles)[1], 0) AS ttfc_p50, round(quantilesMerge(0.9)(ttfc_quantiles)[1], 0) AS ttfc_p90 FROM llm_models WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' GROUP BY timeBucket ORDER BY timeBucket`}
+          config={chartConfig({
+            chartType: "line",
+            xAxisColumn: "timebucket",
+            yAxisColumns: ["ttfc_p50", "ttfc_p90"],
+            aggregation: "avg",
+          })}
+          {...widgetProps}
+        />
+      </div>
+
+      <Callout variant="info">
+        Aggregated across all Trigger.dev users. No tenant-specific data is exposed.
+      </Callout>
+    </div>
+  );
+}
+
+function DetailYourUsageTab({
+  modelName,
+  organizationId,
+  projectId,
+  environmentId,
+}: {
+  modelName: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+}) {
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period: "7d",
+    from: null,
+    to: null,
+  };
+
+  return (
+    <div className="flex flex-col gap-3 py-3">
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-calls`}
+          title="Total calls (7d)"
+          query={`SELECT count() AS total_calls FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}'`}
+          config={bignumberConfig("total_calls", { abbreviate: true })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-cost`}
+          title="Total cost (7d)"
+          query={`SELECT sum(total_cost) AS total_cost FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}'`}
+          config={bignumberConfig("total_cost", { aggregation: "sum" })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-ttfc`}
+          title="Avg TTFC"
+          query={`SELECT round(avg(ms_to_first_chunk), 0) AS avg_ttfc FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' AND ms_to_first_chunk > 0`}
+          config={bignumberConfig("avg_ttfc", { aggregation: "avg", suffix: "ms" })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[120px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-tps`}
+          title="Avg tokens/sec"
+          query={`SELECT round(avg(tokens_per_second), 0) AS avg_tps FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' AND tokens_per_second > 0`}
+          config={bignumberConfig("avg_tps", { aggregation: "avg" })}
+          {...widgetProps}
+        />
+      </div>
+
+      <div className="h-[400px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-cost-time`}
+          title="Cost over time"
+          query={`SELECT timeBucket(), sum(total_cost) AS cost FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' GROUP BY timeBucket ORDER BY timeBucket`}
+          config={chartConfig({
+            chartType: "bar",
+            xAxisColumn: "timebucket",
+            yAxisColumns: ["cost"],
+          })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[400px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-tokens-time`}
+          title="Tokens over time"
+          query={`SELECT timeBucket(), sum(input_tokens) AS input_tokens, sum(output_tokens) AS output_tokens FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' GROUP BY timeBucket ORDER BY timeBucket`}
+          config={chartConfig({
+            chartType: "bar",
+            xAxisColumn: "timebucket",
+            yAxisColumns: ["input_tokens", "output_tokens"],
+          })}
+          {...widgetProps}
+        />
+      </div>
+      <div className="h-[400px]">
+        <MetricWidget
+          widgetKey={`${modelName}-user-tasks`}
+          title="Cost by task"
+          query={`SELECT task_identifier, count() AS calls, sum(total_cost) AS cost FROM llm_metrics WHERE response_model = '${escapeTSQL(
+            modelName
+          )}' GROUP BY task_identifier ORDER BY cost DESC LIMIT 20`}
+          config={{ type: "table", prettyFormatting: true, sorting: [] }}
+          {...widgetProps}
+        />
+      </div>
+    </div>
+  );
+}
+
+// --- Main Page ---
+
+export default function ModelsPage() {
+  const {
+    catalog,
+    popularModels,
+    allProviders,
+    allFeatures,
+    organizationId,
+    projectId,
+    environmentId,
+  } = useTypedLoaderData<typeof loader>();
+  const { values: searchValues, value: searchValue } = useSearchParams();
+
+  const search = searchValue("search") ?? "";
+  const selectedProviders = searchValues("providers");
+  const selectedFeatures = searchValues("features");
+  const [compareSet, setCompareSet] = useState<Set<string>>(new Set());
+  const [showAllDetails, setShowAllDetails] = useState(false);
+  const [compareOpen, setCompareOpen] = useState(false);
+  const [selectedModel, setSelectedModel] = useState<ModelCatalogItem | null>(null);
+  const frozenModel = useFrozenValue(selectedModel);
+  const displayModel = selectedModel ?? frozenModel;
+
+  const popularMap = useMemo(() => {
+    const map = new Map<string, PopularModel>();
+    for (const m of popularModels) {
+      map.set(m.responseModel, m);
+      if (m.responseModel.includes("/")) {
+        map.set(m.responseModel.split("/").slice(1).join("/"), m);
+      }
+    }
+    return map;
+  }, [popularModels]);
+
+  const filteredModels = useMemo(() => {
+    return catalog
+      .flatMap((group) => group.models)
+      .filter((m) => {
+        if (search && !m.displayId.toLowerCase().includes(search.toLowerCase())) return false;
+        if (selectedProviders.length > 0 && !selectedProviders.includes(m.provider)) return false;
+        if (selectedFeatures.length > 0 && !selectedFeatures.every((f) => m.features.includes(f)))
+          return false;
+        return true;
+      });
+  }, [catalog, search, selectedProviders, selectedFeatures]);
+
+  const toggleCompare = (modelName: string) => {
+    setCompareSet((prev) => {
+      const next = new Set(prev);
+      if (next.has(modelName)) {
+        next.delete(modelName);
+      } else if (next.size < 4) {
+        next.add(modelName);
+      }
+      return next;
+    });
+  };
+
+  const compareModels = useMemo(() => Array.from(compareSet), [compareSet]);
+  const allModels = useMemo(() => catalog.flatMap((g) => g.models), [catalog]);
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Models" />
+      </NavBar>
+      <PageBody scrollable={false}>
+        <ResizablePanelGroup orientation="horizontal" className="max-h-full">
+          <ResizablePanel id="models-main" min="100px">
+            <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden">
+              <FiltersBar
+                allProviders={allProviders}
+                allFeatures={allFeatures}
+                compareSet={compareSet}
+                onCompare={() => setCompareOpen(true)}
+                showAllDetails={showAllDetails}
+                onToggleAllDetails={(checked) => setShowAllDetails(checked)}
+              />
+              <ModelsList
+                models={filteredModels}
+                popularMap={popularMap}
+                compareSet={compareSet}
+                onToggleCompare={toggleCompare}
+                showAllDetails={showAllDetails}
+                allFeatures={allFeatures}
+                selectedModelId={selectedModel?.friendlyId ?? null}
+                onSelectModel={setSelectedModel}
+              />
+            </div>
+          </ResizablePanel>
+          <ResizableHandle
+            id="models-handle"
+            className={collapsibleHandleClassName(!!selectedModel)}
+          />
+          <ResizablePanel
+            id="model-detail"
+            default="420px"
+            min="420px"
+            max="700px"
+            className="overflow-hidden"
+            collapsible
+            collapsed={!selectedModel}
+            onCollapseChange={(isCollapsed) => {
+              if (isCollapsed) setSelectedModel(null);
+            }}
+            collapsedSize="0px"
+            collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+          >
+            <div className="h-full" style={{ minWidth: 420 }}>
+              {displayModel && (
+                <ModelDetailPanel
+                  key={displayModel.friendlyId}
+                  model={displayModel}
+                  organizationId={organizationId}
+                  projectId={projectId}
+                  environmentId={environmentId}
+                  onClose={() => setSelectedModel(null)}
+                />
+              )}
+            </div>
+          </ResizablePanel>
+        </ResizablePanelGroup>
+      </PageBody>
+      <CompareDialog
+        open={compareOpen}
+        onOpenChange={setCompareOpen}
+        models={compareModels}
+        catalogModels={allModels}
+      />
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.compare/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.compare/route.tsx
new file mode 100644
index 00000000000..661fb294268
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.models.compare/route.tsx
@@ -0,0 +1,221 @@
+import { ArrowsRightLeftIcon } from "@heroicons/react/20/solid";
+import { type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { MainCenteredContainer, PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { InfoPanel } from "~/components/primitives/InfoPanel";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  type ModelComparisonItem,
+  ModelRegistryPresenter,
+} from "~/presenters/v3/ModelRegistryPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUserId } from "~/services/session.server";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { EnvironmentParamSchema, v3ModelsPath } from "~/utils/pathBuilder";
+import { formatModelCost } from "~/utils/modelFormatters";
+import { formatNumberCompact } from "~/utils/numberFormatter";
+
+export const meta: MetaFunction = () => {
+  return [{ title: "Compare Models | Trigger.dev" }];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const modelsParam = url.searchParams.get("models") ?? "";
+  const responseModels = modelsParam.split(",").filter(Boolean).slice(0, 4);
+
+  if (responseModels.length < 2) {
+    return typedjson({ comparison: [] as ModelComparisonItem[], models: responseModels });
+  }
+
+  const presenter = new ModelRegistryPresenter(clickhouseClient);
+  const now = new Date();
+  const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+  const comparison = await presenter.getModelComparison(responseModels, sevenDaysAgo, now);
+
+  return typedjson({ comparison, models: responseModels });
+};
+
+type ComparisonRow = {
+  label: string;
+  values: string[];
+  bestIndex?: number;
+};
+
+function buildRows(models: string[], comparison: ModelComparisonItem[]): ComparisonRow[] {
+  const dataMap = new Map<string, ModelComparisonItem>();
+  for (const item of comparison) {
+    dataMap.set(item.responseModel, item);
+  }
+
+  const getValue = (model: string, key: keyof ModelComparisonItem) => {
+    const d = dataMap.get(model);
+    return d ? d[key] : 0;
+  };
+
+  const findBest = (values: number[], lowerIsBetter: boolean) => {
+    if (values.every((v) => v === 0)) return undefined;
+    const filtered = values.map((v, i) => ({ v, i })).filter(({ v }) => v > 0);
+    if (filtered.length === 0) return undefined;
+    const best = lowerIsBetter
+      ? filtered.reduce((a, b) => (a.v < b.v ? a : b))
+      : filtered.reduce((a, b) => (a.v > b.v ? a : b));
+    return best.i;
+  };
+
+  const callValues = models.map((m) => Number(getValue(m, "callCount")));
+  const ttfcP50Values = models.map((m) => Number(getValue(m, "ttfcP50")));
+  const ttfcP90Values = models.map((m) => Number(getValue(m, "ttfcP90")));
+  const tpsP50Values = models.map((m) => Number(getValue(m, "tpsP50")));
+  const tpsP90Values = models.map((m) => Number(getValue(m, "tpsP90")));
+  const costValues = models.map((m) => Number(getValue(m, "totalCost")));
+
+  return [
+    {
+      label: "Provider",
+      values: models.map((m) => dataMap.get(m)?.genAiSystem ?? "—"),
+    },
+    {
+      label: "Total Calls (7d)",
+      values: callValues.map((v) => formatNumberCompact(v)),
+      bestIndex: findBest(callValues, false),
+    },
+    {
+      label: "p50 TTFC",
+      values: ttfcP50Values.map((v) => (v > 0 ? `${v.toFixed(0)}ms` : "—")),
+      bestIndex: findBest(ttfcP50Values, true),
+    },
+    {
+      label: "p90 TTFC",
+      values: ttfcP90Values.map((v) => (v > 0 ? `${v.toFixed(0)}ms` : "—")),
+      bestIndex: findBest(ttfcP90Values, true),
+    },
+    {
+      label: "Tokens/sec (p50)",
+      values: tpsP50Values.map((v) => (v > 0 ? v.toFixed(0) : "—")),
+      bestIndex: findBest(tpsP50Values, false),
+    },
+    {
+      label: "Tokens/sec (p90)",
+      values: tpsP90Values.map((v) => (v > 0 ? v.toFixed(0) : "—")),
+      bestIndex: findBest(tpsP90Values, false),
+    },
+    {
+      label: "Total Cost (7d)",
+      values: costValues.map((v) => (v > 0 ? formatModelCost(v) : "—")),
+      bestIndex: findBest(costValues, true),
+    },
+  ];
+}
+
+export default function ModelComparePage() {
+  const { comparison, models } = useTypedLoaderData<typeof loader>();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const rows = buildRows(models, comparison);
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle
+          title="Compare Models"
+          backButton={{
+            to: v3ModelsPath(organization, project, environment),
+            text: "Models",
+          }}
+        />
+      </NavBar>
+      <PageBody scrollable>
+        {models.length < 2 ? (
+          <MainCenteredContainer className="max-w-md">
+            <InfoPanel
+              title="Compare models side by side"
+              icon={ArrowsRightLeftIcon}
+              iconClassName="text-indigo-500"
+              panelClassName="max-w-md"
+            >
+              <p className="text-sm text-text-dimmed">
+                Select 2-4 models from the catalog to compare their pricing, capabilities, and
+                performance metrics side by side.
+              </p>
+              <LinkButton
+                to={v3ModelsPath(organization, project, environment)}
+                variant="primary/small"
+                className="mt-3"
+              >
+                Browse models
+              </LinkButton>
+            </InfoPanel>
+          </MainCenteredContainer>
+        ) : (
+          <div className="p-4">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHeaderCell>Metric</TableHeaderCell>
+                  {models.map((model) => (
+                    <TableHeaderCell key={model} alignment="right">
+                      {model}
+                    </TableHeaderCell>
+                  ))}
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {rows.map((row) => (
+                  <TableRow key={row.label}>
+                    <TableCell>
+                      <span className="text-xs font-medium text-text-dimmed">{row.label}</span>
+                    </TableCell>
+                    {row.values.map((value, i) => (
+                      <TableCell key={i} alignment="right">
+                        <span
+                          className={`tabular-nums ${
+                            row.bestIndex === i
+                              ? "font-medium text-success"
+                              : "text-text-bright"
+                          }`}
+                        >
+                          {value}
+                        </span>
+                      </TableCell>
+                    ))}
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        )}
+      </PageBody>
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug/route.tsx
new file mode 100644
index 00000000000..5a953c0199b
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug/route.tsx
@@ -0,0 +1,2118 @@
+import * as Ariakit from "@ariakit/react";
+import { ArrowPathIcon, ChevronUpDownIcon } from "@heroicons/react/20/solid";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { type MetaFunction, useFetcher } from "@remix-run/react";
+import {
+  type ActionFunctionArgs,
+  json,
+  type LoaderFunctionArgs,
+  redirect,
+} from "@remix-run/server-runtime";
+
+import { AnimatePresence, motion } from "framer-motion";
+import { ClipboardCheckIcon, ClipboardIcon, GitBranchPlusIcon } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { TextEditor } from "~/components/code/TextEditor";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { ModelsFilter } from "~/components/metrics/ModelsFilter";
+import { OperationsFilter } from "~/components/metrics/OperationsFilter";
+import { ProvidersFilter } from "~/components/metrics/ProvidersFilter";
+import { AppliedFilter } from "~/components/primitives/AppliedFilter";
+import { Badge } from "~/components/primitives/Badge";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { DateTime } from "~/components/primitives/DateTime";
+import { Dialog, DialogContent, DialogHeader } from "~/components/primitives/Dialog";
+import { Header3 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Popover, PopoverContent, PopoverTrigger } from "~/components/primitives/Popover";
+import * as Property from "~/components/primitives/PropertyTable";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableCellMenu,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { RadioButtonCircle } from "~/components/primitives/RadioButton";
+import {
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  type ResizableSnapshot,
+} from "~/components/primitives/Resizable";
+import {
+  SelectItem,
+  SelectList,
+  SelectPopover,
+  SelectProvider,
+  SelectTrigger,
+} from "~/components/primitives/Select";
+import { Spinner } from "~/components/primitives/Spinner";
+import { TabButton, TabContainer } from "~/components/primitives/Tabs";
+import { TextArea } from "~/components/primitives/TextArea";
+import { TimeFilter } from "~/components/runs/v3/SharedFilters";
+import { prisma } from "~/db.server";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useInterval } from "~/hooks/useInterval";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useSearchParams } from "~/hooks/useSearchParam";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { type GenerationRow, PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { SpanView } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { getResizableSnapshot } from "~/services/resizablePanel.server";
+import { requireUserId } from "~/services/session.server";
+import { PromptService } from "~/v3/services/promptService.server";
+
+import { z } from "zod";
+import { AIPromptsIcon } from "~/assets/icons/AIPromptsIcon";
+import { RunsIcon } from "~/assets/icons/RunsIcon";
+import { InlineCode } from "~/components/code/InlineCode";
+import { InfoPanel } from "~/components/primitives/InfoPanel";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { MetricWidget } from "~/routes/resources.metric";
+import { cn } from "~/utils/cn";
+import { EnvironmentParamSchema, v3PromptsPath, v3RunSpanPath } from "~/utils/pathBuilder";
+import { parsePeriodToMs } from "~/utils/periods";
+
+const ParamSchema = EnvironmentParamSchema.extend({
+  promptSlug: z.string(),
+});
+
+export const meta: MetaFunction<typeof loader> = ({ data }) => {
+  return [{ title: `${(data as any)?.prompt.slug ?? "Prompt"} | Trigger.dev` }];
+};
+
+// ─── Action ──────────────────────────────────────────────
+
+const ActionSchema = z.discriminatedUnion("intent", [
+  z.object({
+    intent: z.literal("promote"),
+    versionId: z.string(),
+  }),
+  z.object({
+    intent: z.literal("saveVersion"),
+    textContent: z.string().optional(),
+    model: z.string().optional(),
+    commitMessage: z.string().optional(),
+  }),
+  z.object({
+    intent: z.literal("updateOverride"),
+    textContent: z.string().optional(),
+    model: z.string().optional(),
+    commitMessage: z.string().optional(),
+  }),
+  z.object({
+    intent: z.literal("removeOverride"),
+  }),
+  z.object({
+    intent: z.literal("reactivateOverride"),
+    versionId: z.string(),
+  }),
+]);
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, promptSlug } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) return json({ error: "Project not found" }, { status: 404 });
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) return json({ error: "Environment not found" }, { status: 404 });
+
+  const formData = Object.fromEntries(await request.formData());
+  const parsed = ActionSchema.safeParse(formData);
+  if (!parsed.success) return json({ error: "Invalid action" }, { status: 400 });
+
+  const prompt = await prisma.prompt.findUnique({
+    where: {
+      projectId_runtimeEnvironmentId_slug: {
+        projectId: project.id,
+        runtimeEnvironmentId: environment.id,
+        slug: promptSlug,
+      },
+    },
+  });
+
+  if (!prompt) return json({ error: "Prompt not found" }, { status: 404 });
+
+  const data = parsed.data;
+  const service = new PromptService();
+
+  if (data.intent === "promote") {
+    await service.promoteVersion(prompt.id, data.versionId);
+    return json({ ok: true });
+  }
+
+  const url = new URL(request.url);
+
+  if (data.intent === "saveVersion") {
+    const result = await service.createOverride(prompt.id, {
+      textContent: data.textContent ?? "",
+      model: data.model,
+      commitMessage: data.commitMessage,
+      source: "dashboard",
+      createdBy: userId,
+    });
+    url.searchParams.set("version", String(result.version));
+    return redirect(url.pathname + url.search);
+  }
+
+  if (data.intent === "updateOverride") {
+    await service.updateOverride(prompt.id, {
+      textContent: data.textContent,
+      model: data.model,
+      commitMessage: data.commitMessage,
+    });
+    return json({ ok: true });
+  }
+
+  if (data.intent === "removeOverride") {
+    await service.removeOverride(prompt.id);
+    // Navigate back to current version
+    const currentVersion = await prisma.promptVersion.findFirst({
+      where: { promptId: prompt.id, labels: { has: "current" } },
+      select: { version: true },
+    });
+    if (currentVersion) {
+      url.searchParams.set("version", String(currentVersion.version));
+    } else {
+      url.searchParams.delete("version");
+    }
+    return redirect(url.pathname + url.search);
+  }
+
+  if (data.intent === "reactivateOverride") {
+    await service.reactivateOverride(prompt.id, data.versionId);
+    return json({ ok: true });
+  }
+
+  return json({ error: "Unknown intent" }, { status: 400 });
+}
+
+// ─── Loader ──────────────────────────────────────────────
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, promptSlug } = ParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) throw new Response("Project not found", { status: 404 });
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) throw new Response("Environment not found", { status: 404 });
+
+  const prompt = await prisma.prompt.findUnique({
+    where: {
+      projectId_runtimeEnvironmentId_slug: {
+        projectId: project.id,
+        runtimeEnvironmentId: environment.id,
+        slug: promptSlug,
+      },
+    },
+    include: {
+      versions: { orderBy: { version: "desc" }, take: 50 },
+    },
+  });
+
+  if (!prompt) throw new Response("Prompt not found", { status: 404 });
+
+  const currentVersion = prompt.versions.find((v) => v.labels.includes("current"));
+  const overrideVersion = prompt.versions.find((v) => v.labels.includes("override"));
+
+  // Query ClickHouse for recent generations (for the Generations tab span list)
+  const url = new URL(request.url);
+  const period = url.searchParams.get("period") ?? "7d";
+  const periodMs = parsePeriodToMs(period);
+  const fromTime = url.searchParams.get("from");
+  const toTime = url.searchParams.get("to");
+
+  const startTime = fromTime ? new Date(fromTime) : new Date(Date.now() - periodMs);
+  const endTime = toTime ? new Date(toTime) : new Date();
+
+  const presenter = new PromptPresenter(clickhouseClient);
+  let generations: Awaited<ReturnType<typeof presenter.listGenerations>>["generations"] = [];
+  let generationsPagination: { next?: string } = {};
+  try {
+    const urlVersions = url.searchParams
+      .getAll("versions")
+      .filter(Boolean)
+      .map(Number)
+      .filter((n) => !isNaN(n));
+    const urlModels = url.searchParams.getAll("models").filter(Boolean);
+    const urlOperations = url.searchParams.getAll("operations").filter(Boolean);
+    const urlProviders = url.searchParams.getAll("providers").filter(Boolean);
+
+    const result = await presenter.listGenerations({
+      environmentId: environment.id,
+      promptSlug: prompt.slug,
+      promptVersions: urlVersions.length > 0 ? urlVersions : undefined,
+      startTime,
+      endTime,
+      responseModels: urlModels.length > 0 ? urlModels : undefined,
+      operations: urlOperations.length > 0 ? urlOperations : undefined,
+      providers: urlProviders.length > 0 ? urlProviders : undefined,
+    });
+    generations = result.generations;
+    generationsPagination = result.pagination;
+  } catch (e) {
+    console.error("Prompt generations query exception:", e);
+  }
+
+  // Load distinct filter values and resizable snapshots in parallel
+  const distinctQuery = (col: string, name: string) =>
+    clickhouseClient.reader.query({
+      name,
+      query: `SELECT DISTINCT ${col} AS val FROM trigger_dev.llm_metrics_v1 WHERE environment_id = {environmentId: String} AND prompt_slug = {promptSlug: String} AND ${col} != '' ORDER BY val`,
+      params: z.object({ environmentId: z.string(), promptSlug: z.string() }),
+      schema: z.object({ val: z.string() }),
+    })({ environmentId: environment.id, promptSlug: prompt.slug });
+
+  const [
+    resizableOuter,
+    resizableVertical,
+    resizableGenerations,
+    [modelsErr, modelsRows],
+    [opsErr, opsRows],
+    [provsErr, provsRows],
+  ] = await Promise.all([
+    getResizableSnapshot(request, "prompt-detail"),
+    getResizableSnapshot(request, "prompt-vertical"),
+    getResizableSnapshot(request, "prompt-generations"),
+    distinctQuery("response_model", "promptDistinctModels"),
+    distinctQuery("operation_id", "promptDistinctOperations"),
+    distinctQuery("gen_ai_system", "promptDistinctProviders"),
+  ]);
+
+  const possibleModels = modelsErr ? [] : modelsRows.map((r) => r.val);
+  const possibleOperations = opsErr ? [] : opsRows.map((r) => r.val);
+  const possibleProviders = provsErr ? [] : provsRows.map((r) => r.val);
+
+  return typedjson({
+    resizable: {
+      outer: resizableOuter,
+      vertical: resizableVertical,
+      generations: resizableGenerations,
+    },
+    prompt: {
+      id: prompt.id,
+      friendlyId: prompt.friendlyId,
+      slug: prompt.slug,
+      description: prompt.description,
+      tags: prompt.tags,
+      defaultModel: prompt.defaultModel,
+      defaultConfig: prompt.defaultConfig,
+      variableSchema: prompt.variableSchema,
+      filePath: prompt.filePath,
+      exportName: prompt.exportName,
+    },
+    currentVersion: currentVersion
+      ? {
+          id: currentVersion.id,
+          version: currentVersion.version,
+          textContent: currentVersion.textContent,
+          model: currentVersion.model,
+          source: currentVersion.source,
+          labels: currentVersion.labels,
+        }
+      : null,
+    versions: prompt.versions.map((v) => ({
+      id: v.id,
+      version: v.version,
+      labels: v.labels,
+      source: v.source,
+      commitMessage: v.commitMessage,
+      textContent: v.textContent,
+      model: v.model,
+      createdAt: v.createdAt,
+    })),
+    overrideVersion: overrideVersion
+      ? {
+          id: overrideVersion.id,
+          version: overrideVersion.version,
+        }
+      : null,
+    generations,
+    generationsPagination,
+    organizationId: project.organizationId,
+    projectId: project.id,
+    environmentId: environment.id,
+    possibleModels,
+    possibleOperations,
+    possibleProviders,
+  });
+};
+
+// ─── Helpers ─────────────────────────────────────────────
+
+type VersionData = {
+  id: string;
+  version: number;
+  labels: string[];
+  source: string;
+  commitMessage: string | null;
+  textContent: string | null;
+  model: string | null;
+  createdAt: Date;
+};
+
+type VariableField = {
+  name: string;
+  type: string;
+  required: boolean;
+  description?: string;
+  placeholder?: string;
+  enumValues?: string[];
+  isLongText: boolean;
+};
+
+function extractVariableFields(schema: unknown): VariableField[] {
+  const jsonSchema = schema as {
+    properties?: Record<string, { type?: string; description?: string; enum?: string[] }>;
+    required?: string[];
+  } | null;
+  if (!jsonSchema?.properties) return [];
+  const requiredSet = new Set(jsonSchema.required ?? []);
+  return Object.entries(jsonSchema.properties).map(([name, prop]) => ({
+    name,
+    type: prop.type ?? "string",
+    required: requiredSet.has(name),
+    description: prop.description,
+    placeholder: prop.description ?? name,
+    enumValues: prop.enum,
+    isLongText:
+      prop.type === "string" &&
+      !prop.enum &&
+      (name.toLowerCase().includes("text") ||
+        name.toLowerCase().includes("content") ||
+        name.toLowerCase().includes("message") ||
+        name.toLowerCase().includes("body")),
+  }));
+}
+
+function compileTemplatePreview(template: string, variables: Record<string, string>): string {
+  let result = template.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_match, key, content) => {
+    const value = variables[key];
+    return value
+      ? content.replace(/\{\{(\w+)\}\}/g, (_m: string, k: string) => variables[k] ?? "")
+      : "";
+  });
+  result = result.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
+    return variables[key] ?? `{{${key}}}`;
+  });
+  return result;
+}
+
+function getVersionContent(version: { textContent?: string | null }): string {
+  return version.textContent ?? "";
+}
+
+// ─── Component ───────────────────────────────────────────
+
+export default function PromptDetailPage() {
+  const {
+    prompt,
+    currentVersion,
+    versions,
+    overrideVersion,
+    generations,
+    generationsPagination,
+    organizationId,
+    projectId,
+    environmentId,
+    resizable,
+    possibleModels,
+    possibleOperations,
+    possibleProviders,
+  } = useTypedLoaderData<typeof loader>();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const fetcher = useFetcher();
+  const { value: searchValue, replace: replaceSearch } = useSearchParams();
+
+  const tab = searchValue("tab") ?? "details";
+  const contentTab = searchValue("contentTab") ?? "generations";
+  const period = searchValue("period") ?? "7d";
+  const from = searchValue("from") ?? null;
+  const to = searchValue("to") ?? null;
+
+  // Selected span for the generations inspector — auto-select first generation
+  const [selectedSpan, setSelectedSpan] = useState<{ runId: string; spanId: string } | null>(
+    generations[0] ? { runId: generations[0].run_id, spanId: generations[0].span_id } : null
+  );
+
+  // Selected version from URL or default to current
+  const versionParam = searchValue("version");
+  const selectedVersion = versionParam
+    ? versions.find((v) => v.version === Number(versionParam)) ?? versions[0]
+    : overrideVersion
+    ? versions.find((v) => v.id === overrideVersion.id) ?? versions[0]
+    : currentVersion
+    ? versions.find((v) => v.id === currentVersion.id) ?? versions[0]
+    : versions[0];
+
+  const content = selectedVersion ? getVersionContent(selectedVersion) : "";
+  const isCurrent = selectedVersion?.labels.includes("current") ?? false;
+
+  const [overrideDialogOpen, setOverrideDialogOpen] = useState(false);
+
+  const handlePromote = (versionId: string) => {
+    fetcher.submit({ intent: "promote", versionId }, { method: "POST" });
+  };
+
+  const switchVersion = (versionNumber: number) => {
+    replaceSearch({
+      version: String(versionNumber),
+      tab,
+    });
+  };
+
+  return (
+    <PageContainer className="grid-rows-[auto_auto_1fr]">
+      <NavBar>
+        <PageTitle
+          title={
+            <PromptCopyPopover
+              slug={prompt.slug}
+              friendlyId={prompt.friendlyId}
+              description={prompt.description}
+            />
+          }
+          backButton={{ to: v3PromptsPath(organization, project, environment), text: "Prompts" }}
+        />
+        <PageAccessories>
+          <div className="flex items-center gap-2">
+            {selectedVersion && (
+              <div className="flex items-center gap-1.5">
+                <div
+                  className={cn(
+                    "size-1.5 shrink-0 rounded-full",
+                    selectedVersion.labels.includes("override")
+                      ? "bg-amber-400"
+                      : isCurrent
+                      ? "bg-green-500"
+                      : "bg-charcoal-550"
+                  )}
+                />
+                <span className="text-xs text-text-dimmed">v{selectedVersion.version}</span>
+                {isCurrent && <Badge variant="extra-small">current</Badge>}
+                {selectedVersion.labels.includes("override") && (
+                  <Badge variant="extra-small" className="border-amber-500/30 text-amber-400">
+                    override
+                  </Badge>
+                )}
+              </div>
+            )}
+            {selectedVersion && !isCurrent && selectedVersion.source === "code" && (
+              <Button
+                variant="secondary/small"
+                onClick={() => handlePromote(selectedVersion.id)}
+                disabled={fetcher.state !== "idle"}
+              >
+                Promote to current
+              </Button>
+            )}
+            {selectedVersion &&
+              selectedVersion.source !== "code" &&
+              !selectedVersion.labels.includes("override") && (
+                <Button
+                  variant="secondary/small"
+                  onClick={() =>
+                    fetcher.submit(
+                      { intent: "reactivateOverride", versionId: selectedVersion.id },
+                      { method: "POST" }
+                    )
+                  }
+                  disabled={fetcher.state !== "idle"}
+                >
+                  Reactivate as override
+                </Button>
+              )}
+            {!overrideVersion && (
+              <Button variant="secondary/small" onClick={() => setOverrideDialogOpen(true)}>
+                Create override
+              </Button>
+            )}
+          </div>
+        </PageAccessories>
+      </NavBar>
+      <div>
+        <AnimatePresence initial={false}>
+          {overrideVersion && (
+            <motion.div
+              className="flex flex-wrap items-center justify-between gap-2 overflow-hidden border-b border-amber-500/10 bg-amber-500/10 pl-4 pr-2"
+              initial={{ opacity: 0, height: 0 }}
+              animate={{ opacity: 1, height: "auto" }}
+              exit={{ opacity: 0, height: 0 }}
+              transition={{ duration: 0.2, ease: "easeInOut" }}
+            >
+              <span className="py-1.5 text-xs text-amber-300">
+                Override v{overrideVersion.version} is active. API calls resolve to this version
+                instead of the deployed prompt.
+              </span>
+              <div className="flex items-center gap-2 py-1.5">
+                <Button
+                  variant="tertiary/small"
+                  className="border-amber-300/50 bg-amber-400/10 text-amber-300 group-hover/button:border-amber-400/60 group-hover/button:bg-amber-500/25 group-hover/button:text-amber-200"
+                  onClick={() => setOverrideDialogOpen(true)}
+                >
+                  Edit
+                </Button>
+                <Button
+                  variant="tertiary/small"
+                  className="border-amber-300/50 bg-amber-400/10 text-amber-300 group-hover/button:border-amber-400/60 group-hover/button:bg-amber-500/25 group-hover/button:text-amber-200"
+                  onClick={() => fetcher.submit({ intent: "removeOverride" }, { method: "POST" })}
+                  disabled={fetcher.state !== "idle"}
+                >
+                  Remove
+                </Button>
+              </div>
+            </motion.div>
+          )}
+        </AnimatePresence>
+      </div>
+      <PageBody scrollable={false}>
+        <ResizablePanelGroup
+          autosaveId="prompt-detail"
+          snapshot={resizable?.outer}
+          className="h-full max-h-full"
+        >
+          {/* Main content */}
+          <ResizablePanel id="prompt-main" min="400px">
+            <ResizablePanelGroup
+              autosaveId="prompt-vertical"
+              snapshot={resizable?.vertical}
+              orientation="vertical"
+              className="h-full max-h-full"
+            >
+              {/* Template panel */}
+              <ResizablePanel id="prompt-template" default="250px" min="80px">
+                {content ? (
+                  <CodeBlock
+                    code={content}
+                    language="markdown"
+                    showLineNumbers={false}
+                    showCopyButton={true}
+                    showTextWrapping={false}
+                    showOpenInModal={true}
+                    className="h-full rounded-none border-none [&_pre]:px-3 [&_pre]:py-2 [&_pre]:text-sm"
+                    maxLines={undefined}
+                  />
+                ) : (
+                  <div className="p-3">
+                    <Paragraph variant="small" className="text-text-dimmed">
+                      No content
+                    </Paragraph>
+                  </div>
+                )}
+              </ResizablePanel>
+
+              <ResizableHandle id="prompt-vertical-handle" />
+
+              {/* Tabs panel */}
+              <ResizablePanel id="prompt-tabs" min="100px">
+                <div className="grid h-full max-h-full grid-rows-[2.25rem_1fr] overflow-hidden">
+                  {/* Tab bar */}
+                  <div className="flex items-center justify-between border-b border-grid-dimmed bg-background-bright pl-3 pr-1.5">
+                    <TabContainer className="-mb-1">
+                      <TabButton
+                        isActive={contentTab === "generations"}
+                        layoutId="prompt-content"
+                        onClick={() =>
+                          replaceSearch({
+                            contentTab: "generations",
+                            tab,
+                            version: searchValue("version"),
+                            period: searchValue("period"),
+                            from: searchValue("from"),
+                            to: searchValue("to"),
+                          })
+                        }
+                      >
+                        Generations
+                      </TabButton>
+                      <TabButton
+                        isActive={contentTab === "metrics"}
+                        layoutId="prompt-content"
+                        onClick={() =>
+                          replaceSearch({
+                            contentTab: "metrics",
+                            tab,
+                            version: searchValue("version"),
+                            period: searchValue("period"),
+                            from: searchValue("from"),
+                            to: searchValue("to"),
+                          })
+                        }
+                      >
+                        Metrics
+                      </TabButton>
+                    </TabContainer>
+                    <div className="flex items-center gap-1.5">
+                      <PromptVersionsFilter versions={versions} />
+                      <ModelsFilter
+                        possibleModels={possibleModels.map((m) => ({ model: m, system: "" }))}
+                      />
+                      <OperationsFilter possibleOperations={possibleOperations} />
+                      <ProvidersFilter possibleProviders={possibleProviders} />
+                      <TimeFilter
+                        defaultPeriod="7d"
+                        labelName="Period"
+                        hideLabel
+                        valueClassName="text-text-bright"
+                        shortcut={{ key: "w" }}
+                      />
+                    </div>
+                  </div>
+
+                  {/* Tab content */}
+                  <div
+                    className={cn(
+                      "min-h-0 overflow-hidden",
+                      contentTab === "generations" && "bg-background-bright"
+                    )}
+                  >
+                    {contentTab === "generations" && (
+                      <GenerationsTab
+                        promptSlug={prompt.slug}
+                        initialGenerations={generations}
+                        initialPagination={generationsPagination}
+                        selectedSpan={selectedSpan}
+                        onSelectSpan={setSelectedSpan}
+                        generationsSnapshot={resizable?.generations}
+                      />
+                    )}
+
+                    {contentTab === "metrics" && (
+                      <div className="h-full overflow-y-auto p-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+                        <MetricsTab
+                          prompt={prompt}
+                          organizationId={organizationId}
+                          projectId={projectId}
+                          environmentId={environmentId}
+                          period={period}
+                          from={from}
+                          to={to}
+                        />
+                      </div>
+                    )}
+                  </div>
+                </div>
+              </ResizablePanel>
+            </ResizablePanelGroup>
+          </ResizablePanel>
+
+          <ResizableHandle id="prompt-sidebar-handle" />
+
+          {/* Sidebar */}
+          <ResizablePanel
+            id="prompt-sidebar"
+            default="380px"
+            min="280px"
+            max="500px"
+            isStaticAtRest
+          >
+            <div className="grid h-full max-h-full grid-rows-[2rem_1fr] overflow-hidden bg-background-bright">
+              {/* Tabs */}
+              <div className="overflow-x-auto px-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+                <TabContainer>
+                  <TabButton
+                    isActive={tab === "details"}
+                    layoutId="prompt-sidebar"
+                    onClick={() => replaceSearch({ tab: "details", version: versionParam })}
+                    shortcut={{ key: "d" }}
+                  >
+                    Details
+                  </TabButton>
+                  <TabButton
+                    isActive={tab === "preview"}
+                    layoutId="prompt-sidebar"
+                    onClick={() => replaceSearch({ tab: "preview", version: versionParam })}
+                    shortcut={{ key: "i" }}
+                  >
+                    Preview
+                  </TabButton>
+                  <TabButton
+                    isActive={tab === "versions"}
+                    layoutId="prompt-sidebar"
+                    onClick={() => replaceSearch({ tab: "versions", version: versionParam })}
+                    shortcut={{ key: "v" }}
+                  >
+                    Versions
+                  </TabButton>
+                </TabContainer>
+              </div>
+
+              {/* Tab content */}
+              <div
+                className={cn(
+                  "overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600",
+                  tab === "versions" ? "py-0" : "px-3 py-3"
+                )}
+              >
+                {tab === "details" && (
+                  <DetailsTab prompt={prompt} selectedVersion={selectedVersion} />
+                )}
+                {tab === "preview" && <PreviewTab prompt={prompt} content={content} />}
+                {tab === "versions" && (
+                  <VersionsTab
+                    versions={versions}
+                    selectedVersion={selectedVersion}
+                    onSelectVersion={switchVersion}
+                  />
+                )}
+              </div>
+            </div>
+          </ResizablePanel>
+        </ResizablePanelGroup>
+      </PageBody>
+      <OverrideDialog
+        open={overrideDialogOpen}
+        onOpenChange={setOverrideDialogOpen}
+        prompt={prompt}
+        content={
+          overrideVersion
+            ? getVersionContent(
+                versions.find((v) => v.id === overrideVersion.id) ?? { textContent: null }
+              )
+            : content
+        }
+        isEditingOverride={!!overrideVersion}
+        currentOverrideModel={
+          overrideVersion ? versions.find((v) => v.id === overrideVersion.id)?.model ?? null : null
+        }
+        onSave={(textContent, commitMessage, model) => {
+          const intent = overrideVersion ? "updateOverride" : "saveVersion";
+          fetcher.submit({ intent, textContent, commitMessage, model }, { method: "POST" });
+          setOverrideDialogOpen(false);
+        }}
+      />
+    </PageContainer>
+  );
+}
+
+// ─── Override Dialog ─────────────────────────────────────
+
+function OverrideDialog({
+  open,
+  onOpenChange,
+  prompt,
+  content,
+  isEditingOverride,
+  currentOverrideModel,
+  onSave,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  prompt: {
+    slug: string;
+    defaultModel: string | null;
+    defaultConfig: unknown;
+    variableSchema: unknown;
+  };
+  content: string;
+  isEditingOverride: boolean;
+  currentOverrideModel?: string | null;
+  onSave: (textContent: string, commitMessage: string, model: string) => void;
+}) {
+  const effectiveModel = currentOverrideModel ?? prompt.defaultModel ?? "";
+  const [editedContent, setEditedContent] = useState(content);
+  const [commitMessage, setCommitMessage] = useState("");
+  const [model, setModel] = useState(effectiveModel);
+
+  // Reset when dialog opens
+  useEffect(() => {
+    if (open) {
+      setEditedContent(content);
+      setCommitMessage("");
+      setModel(currentOverrideModel ?? prompt.defaultModel ?? "");
+    }
+  }, [open, content, currentOverrideModel, prompt.defaultModel]);
+
+  const variableFields = prompt.variableSchema ? extractVariableFields(prompt.variableSchema) : [];
+
+  // Extract variables used in the template
+  const templateVars = new Set<string>();
+  editedContent.replace(/\{\{\s*(\w+)\s*\}\}/g, (_m, key) => {
+    templateVars.add(key);
+    return "";
+  });
+  editedContent.replace(/\{\{#(\w+)\}\}/g, (_m, key) => {
+    templateVars.add(key);
+    return "";
+  });
+
+  // Check for schema mismatches
+  const schemaVarNames = new Set(variableFields.map((f) => f.name));
+  const undefinedVars = [...templateVars].filter((v) => !schemaVarNames.has(v));
+  const unusedVars = variableFields.filter((f) => f.required && !templateVars.has(f.name));
+
+  const hasChanges = editedContent !== content || model !== effectiveModel;
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="flex h-[85vh] max-h-[85vh] flex-col !gap-0 overflow-hidden pl-0 pr-3 pt-0 md:max-w-4xl lg:max-w-6xl">
+        <DialogHeader className="px-4 py-2.5">
+          {isEditingOverride ? "Edit override" : "Create override"}
+        </DialogHeader>
+
+        <ResizablePanelGroup
+          orientation="horizontal"
+          className="-mx-3 w-auto flex-1 border-b border-t border-grid-dimmed"
+        >
+          {/* Editor */}
+          <ResizablePanel id="override-editor" min="300px" className="bg-[#121317]">
+            <TextEditor
+              className="h-full"
+              autoFocus
+              defaultValue={editedContent}
+              onChange={setEditedContent}
+              showCopyButton
+            />
+          </ResizablePanel>
+
+          <ResizableHandle id="override-handle" />
+
+          {/* Right panel: properties */}
+          <ResizablePanel id="override-sidebar" min="220px" default="280px" max="360px">
+            <div className="h-full overflow-y-auto px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+              <div className="space-y-4">
+                <div className="space-y-2">
+                  <Header3>Override settings</Header3>
+                  <InputGroup>
+                    <Label variant="small">Commit message</Label>
+                    <Input
+                      variant="small"
+                      placeholder="What changed? (optional)"
+                      value={commitMessage}
+                      onChange={(e) => setCommitMessage(e.target.value)}
+                    />
+                  </InputGroup>
+                  <InputGroup>
+                    <Label variant="small">Model</Label>
+                    <Input
+                      variant="small"
+                      placeholder={prompt.defaultModel ?? "No default"}
+                      value={model}
+                      onChange={(e) => setModel(e.target.value)}
+                    />
+                    <Hint>Override the default model for this version</Hint>
+                  </InputGroup>
+                </div>
+
+                {/* Variable schema (read-only) */}
+                {variableFields.length > 0 && (
+                  <div className="space-y-1.5 border-t border-grid-dimmed pt-3">
+                    <Label variant="small">Variables (from code)</Label>
+                    <div className="space-y-1">
+                      {variableFields.map((f) => (
+                        <div key={f.name} className="flex items-center gap-1.5 text-xs">
+                          <code className="rounded bg-charcoal-750 px-1 py-0.5 text-text-bright">
+                            {f.name}
+                          </code>
+                          <span className="text-text-dimmed">{f.type}</span>
+                          {f.required && (
+                            <Badge
+                              variant="extra-small"
+                              className="border-amber-500/30 text-amber-400"
+                            >
+                              required
+                            </Badge>
+                          )}
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                )}
+
+                {/* Validation warnings */}
+                {(undefinedVars.length > 0 || unusedVars.length > 0) && (
+                  <div className="space-y-2 border-t border-grid-dimmed pt-3">
+                    {undefinedVars.length > 0 && (
+                      <div className="rounded border border-amber-500/30 bg-amber-500/5 px-2.5 py-2 text-xs text-amber-300">
+                        <span className="font-medium">Undefined variables:</span>{" "}
+                        {undefinedVars.map((v) => (
+                          <code
+                            key={v}
+                            className="mx-0.5 rounded bg-amber-500/10 px-1"
+                          >{`{{${v}}}`}</code>
+                        ))}
+                      </div>
+                    )}
+                    {unusedVars.length > 0 && (
+                      <div className="rounded border border-amber-500/30 bg-amber-500/5 px-2.5 py-2 text-xs text-amber-300">
+                        <span className="font-medium">Required but missing:</span>{" "}
+                        {unusedVars.map((v) => (
+                          <code key={v.name} className="mx-0.5 rounded bg-amber-500/10 px-1">
+                            {v.name}
+                          </code>
+                        ))}
+                      </div>
+                    )}
+                  </div>
+                )}
+              </div>
+            </div>
+          </ResizablePanel>
+        </ResizablePanelGroup>
+
+        {/* Footer */}
+        <div className="flex items-center justify-between gap-2 pl-4 pr-1 pt-3">
+          <DialogClose asChild>
+            <Button variant="secondary/medium">Cancel</Button>
+          </DialogClose>
+          <Button
+            variant="primary/medium"
+            disabled={!hasChanges}
+            onClick={() => onSave(editedContent, commitMessage, model)}
+          >
+            {isEditingOverride ? "Save override" : "Create override"}
+          </Button>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+// ─── Details Tab ─────────────────────────────────────────
+
+function DetailsTab({
+  prompt,
+  selectedVersion,
+}: {
+  prompt: ReturnType<typeof useTypedLoaderData<typeof loader>>["prompt"];
+  selectedVersion?: VersionData;
+}) {
+  const effectiveModel = selectedVersion?.model ?? prompt.defaultModel;
+  return (
+    <div className="space-y-4">
+      <Property.Table>
+        <Property.Item>
+          <Property.Label>Slug</Property.Label>
+          <Property.Value>
+            <code className="text-sm">{prompt.slug}</code>
+          </Property.Value>
+        </Property.Item>
+        {prompt.description && (
+          <Property.Item>
+            <Property.Label>Description</Property.Label>
+            <Property.Value>{prompt.description}</Property.Value>
+          </Property.Item>
+        )}
+        {effectiveModel && (
+          <Property.Item>
+            <Property.Label>Model</Property.Label>
+            <Property.Value>{effectiveModel}</Property.Value>
+          </Property.Item>
+        )}
+        {prompt.defaultConfig && (
+          <Property.Item>
+            <Property.Label className="mb-1.5">Config</Property.Label>
+            <Property.Value>
+              <CodeBlock
+                code={JSON.stringify(prompt.defaultConfig, null, 2)}
+                maxLines={10}
+                showLineNumbers={false}
+              />
+            </Property.Value>
+          </Property.Item>
+        )}
+        {prompt.filePath && (
+          <Property.Item>
+            <Property.Label>Source</Property.Label>
+            <Property.Value>
+              <code className="text-sm">
+                {prompt.filePath}
+                {prompt.exportName ? ` (${prompt.exportName})` : ""}
+              </code>
+            </Property.Value>
+          </Property.Item>
+        )}
+        {prompt.tags.length > 0 && (
+          <Property.Item>
+            <Property.Label>Tags</Property.Label>
+            <Property.Value>
+              <div className="flex flex-wrap gap-1">
+                {prompt.tags.map((tag) => (
+                  <Badge key={tag} variant="extra-small">
+                    {tag}
+                  </Badge>
+                ))}
+              </div>
+            </Property.Value>
+          </Property.Item>
+        )}
+      </Property.Table>
+
+      {prompt.variableSchema && (
+        <div className="space-y-2">
+          <Header3>Variable schema</Header3>
+          <CodeBlock
+            code={JSON.stringify(prompt.variableSchema, null, 2)}
+            maxLines={20}
+            showLineNumbers={false}
+            showCopyButton
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
+// ─── Preview Tab ─────────────────────────────────────────
+
+function PreviewTab({
+  prompt,
+  content,
+}: {
+  prompt: ReturnType<typeof useTypedLoaderData<typeof loader>>["prompt"];
+  content: string;
+}) {
+  const variableFields = prompt.variableSchema ? extractVariableFields(prompt.variableSchema) : [];
+  const [testVariables, setTestVariables] = useState<Record<string, string>>(() =>
+    Object.fromEntries(variableFields.map((f) => [f.name, ""]))
+  );
+  const hasTestValues = Object.values(testVariables).some((v) => v.length > 0);
+  const previewText = hasTestValues ? compileTemplatePreview(content, testVariables) : null;
+
+  return (
+    <div className="space-y-4">
+      {variableFields.length > 0 ? (
+        <>
+          <div className="space-y-3">
+            <div>
+              <Header3 className="mb-1">Variables</Header3>
+              <Paragraph variant="small">
+                Fill in values to preview your resolved prompt template.
+              </Paragraph>
+            </div>
+            {variableFields.map((field, index) => (
+              <InputGroup className="max-w-full" key={field.name}>
+                <Label variant="small" required={field.required}>
+                  {field.name}
+                </Label>
+                {field.enumValues ? (
+                  <select
+                    autoFocus={index === 0}
+                    className="h-6 w-full rounded border border-charcoal-650 bg-background-bright px-1 text-xs text-text-bright focus:border-indigo-500 focus:outline-none"
+                    value={testVariables[field.name] ?? ""}
+                    onChange={(e) =>
+                      setTestVariables((prev) => ({
+                        ...prev,
+                        [field.name]: e.target.value,
+                      }))
+                    }
+                  >
+                    <option value="">Select…</option>
+                    {field.enumValues.map((v) => (
+                      <option key={v} value={v}>
+                        {v}
+                      </option>
+                    ))}
+                  </select>
+                ) : field.isLongText ? (
+                  <TextArea
+                    autoFocus={index === 0}
+                    rows={3}
+                    className="w-full text-sm"
+                    placeholder={field.placeholder}
+                    value={testVariables[field.name] ?? ""}
+                    onChange={(e) =>
+                      setTestVariables((prev) => ({
+                        ...prev,
+                        [field.name]: e.target.value,
+                      }))
+                    }
+                  />
+                ) : (
+                  <Input
+                    autoFocus={index === 0}
+                    variant="small"
+                    placeholder={field.placeholder}
+                    value={testVariables[field.name] ?? ""}
+                    onChange={(e) =>
+                      setTestVariables((prev) => ({
+                        ...prev,
+                        [field.name]: e.target.value,
+                      }))
+                    }
+                  />
+                )}
+                {field.description && <Hint>{field.description}</Hint>}
+              </InputGroup>
+            ))}
+          </div>
+
+          {previewText && (
+            <div className="space-y-1.5">
+              <Header3>Resolved output</Header3>
+              <div className="overflow-auto rounded border border-grid-bright bg-background-dimmed p-3">
+                <pre className="whitespace-pre-wrap font-mono text-sm leading-relaxed text-text-bright">
+                  {previewText}
+                </pre>
+              </div>
+            </div>
+          )}
+        </>
+      ) : (
+        content && (
+          <>
+            <Header3>Resolved output</Header3>
+            <div className="overflow-auto rounded border border-grid-bright bg-background-dimmed p-3">
+              <pre className="whitespace-pre-wrap font-mono text-sm leading-relaxed text-text-bright">
+                {content}
+              </pre>
+            </div>
+          </>
+        )
+      )}
+    </div>
+  );
+}
+
+// ─── Generations Tab ─────────────────────────────────────
+
+function GenerationsTab({
+  promptSlug,
+  initialGenerations,
+  initialPagination,
+  selectedSpan,
+  onSelectSpan,
+  generationsSnapshot,
+}: {
+  promptSlug: string;
+  initialGenerations: GenerationRow[];
+  initialPagination: { next?: string };
+  selectedSpan: { runId: string; spanId: string } | null;
+  onSelectSpan: (span: { runId: string; spanId: string } | null) => void;
+  generationsSnapshot?: ResizableSnapshot;
+}) {
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const { value: searchValue } = useSearchParams();
+  const listRef = useRef<HTMLDivElement>(null);
+  const loadMoreRef = useRef<HTMLDivElement>(null);
+  const fetcher = useFetcher<{ generations: GenerationRow[]; pagination: { next?: string } }>();
+  const pollFetcher = useFetcher<{ generations: GenerationRow[]; pagination: { next?: string } }>();
+
+  // Accumulated generations state
+  const [generations, setGenerations] = useState<GenerationRow[]>(initialGenerations);
+  const [nextCursor, setNextCursor] = useState<string | undefined>(initialPagination.next);
+  const [newGenerationCount, setNewGenerationCount] = useState(0);
+
+  // Build the resource URL for fetches
+  const resourcePath = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${
+    environment.slug
+  }/prompts/${encodeURIComponent(promptSlug)}/generations`;
+
+  // Track filter state to reset on change
+  const { values: filterValues } = useSearchParams();
+  const models = filterValues("models").filter((v) => v !== "");
+  const operations = filterValues("operations").filter((v) => v !== "");
+  const providers = filterValues("providers").filter((v) => v !== "");
+
+  const versionFilters = filterValues("versions").filter((v) => v !== "");
+  const filterKey = `${versionFilters.join(",")}-${searchValue("period") ?? "7d"}-${
+    searchValue("from") ?? ""
+  }-${searchValue("to") ?? ""}-${models.join(",")}-${operations.join(",")}-${providers.join(",")}`;
+  const prevFilterKeyRef = useRef(filterKey);
+
+  // Reset when filters change (loader re-runs with new initial data)
+  useEffect(() => {
+    if (prevFilterKeyRef.current !== filterKey) {
+      prevFilterKeyRef.current = filterKey;
+      setGenerations(initialGenerations);
+      setNextCursor(initialPagination.next);
+      setNewGenerationCount(0);
+    }
+  }, [filterKey, initialGenerations, initialPagination.next]);
+
+  // Also reset if initialGenerations change identity (page navigation)
+  const initialGenRef = useRef(initialGenerations);
+  useEffect(() => {
+    if (initialGenRef.current !== initialGenerations) {
+      initialGenRef.current = initialGenerations;
+      setGenerations(initialGenerations);
+      setNextCursor(initialPagination.next);
+      setNewGenerationCount(0);
+    }
+  }, [initialGenerations, initialPagination.next]);
+
+  // Append fetched rows when fetcher completes
+  useEffect(() => {
+    if (fetcher.data && fetcher.state === "idle") {
+      setGenerations((prev) => {
+        const existingIds = new Set(prev.map((g) => g.span_id));
+        const newRows = fetcher.data!.generations.filter((g) => !existingIds.has(g.span_id));
+        return newRows.length > 0 ? [...prev, ...newRows] : prev;
+      });
+      setNextCursor(fetcher.data.pagination.next);
+    }
+  }, [fetcher.data, fetcher.state]);
+
+  // Poll for new generations periodically (also on focus/visibility)
+  useInterval({
+    interval: 10_000,
+    onLoad: false,
+    callback: () => {
+      if (pollFetcher.state !== "idle") return;
+      const params = new URLSearchParams();
+      for (const v of versionFilters) params.append("versions", v);
+      params.set("period", searchValue("period") ?? "7d");
+      const from = searchValue("from");
+      const to = searchValue("to");
+      if (from) params.set("from", from);
+      if (to) params.set("to", to);
+      for (const m of models) params.append("models", m);
+      for (const o of operations) params.append("operations", o);
+      for (const p of providers) params.append("providers", p);
+      pollFetcher.load(`${resourcePath}?${params.toString()}`);
+    },
+  });
+
+  // Check poll results for new generations — only react to new poll data, not generation list changes
+  const lastPollDataRef = useRef(pollFetcher.data);
+  useEffect(() => {
+    if (
+      pollFetcher.data &&
+      pollFetcher.state === "idle" &&
+      pollFetcher.data !== lastPollDataRef.current
+    ) {
+      lastPollDataRef.current = pollFetcher.data;
+      const existingIds = new Set(generations.map((g) => g.span_id));
+      const newCount = pollFetcher.data.generations.filter(
+        (g) => !existingIds.has(g.span_id)
+      ).length;
+      setNewGenerationCount(newCount);
+    }
+  }, [pollFetcher.data, pollFetcher.state, generations]);
+
+  const handleRefreshGenerations = useCallback(() => {
+    // Prepend new generations from the poll data
+    if (pollFetcher.data) {
+      setGenerations((prev) => {
+        const existingIds = new Set(prev.map((g) => g.span_id));
+        const newRows = pollFetcher.data!.generations.filter((g) => !existingIds.has(g.span_id));
+        return newRows.length > 0 ? [...newRows, ...prev] : prev;
+      });
+    }
+    setNewGenerationCount(0);
+    listRef.current?.scrollTo({ top: 0, behavior: "smooth" });
+  }, [pollFetcher.data]);
+
+  const handleLoadMore = useCallback(() => {
+    if (!nextCursor || fetcher.state !== "idle") return;
+
+    const params = new URLSearchParams();
+    for (const v of versionFilters) params.append("versions", v);
+    params.set("period", searchValue("period") ?? "7d");
+    const from = searchValue("from");
+    const to = searchValue("to");
+    if (from) params.set("from", from);
+    if (to) params.set("to", to);
+    for (const m of models) params.append("models", m);
+    for (const o of operations) params.append("operations", o);
+    for (const p of providers) params.append("providers", p);
+    params.set("cursor", nextCursor);
+    fetcher.load(`${resourcePath}?${params.toString()}`);
+  }, [
+    nextCursor,
+    fetcher,
+    searchValue,
+    resourcePath,
+    versionFilters,
+    models,
+    operations,
+    providers,
+  ]);
+
+  // Debounced loading spinner
+  const isLoadingMore = fetcher.state === "loading";
+  const [showSpinner, setShowSpinner] = useState(false);
+  useEffect(() => {
+    if (!isLoadingMore) {
+      setShowSpinner(false);
+      return;
+    }
+    const timer = setTimeout(() => setShowSpinner(true), 200);
+    return () => clearTimeout(timer);
+  }, [isLoadingMore]);
+
+  // IntersectionObserver for infinite scroll
+  useEffect(() => {
+    if (!nextCursor || isLoadingMore) return;
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting) {
+          handleLoadMore();
+        }
+      },
+      { threshold: 0.1 }
+    );
+
+    const currentRef = loadMoreRef.current;
+    if (currentRef) {
+      observer.observe(currentRef);
+    }
+
+    return () => {
+      if (currentRef) {
+        observer.unobserve(currentRef);
+      }
+    };
+  }, [nextCursor, isLoadingMore, handleLoadMore]);
+
+  // Keyboard navigation
+  const selectedIndex = selectedSpan
+    ? generations.findIndex((g) => g.span_id === selectedSpan.spanId)
+    : -1;
+
+  const selectByIndex = useCallback(
+    (index: number) => {
+      const gen = generations[index];
+      if (gen) {
+        onSelectSpan({ runId: gen.run_id, spanId: gen.span_id });
+        const items = listRef.current?.querySelectorAll("[data-generation-item]");
+        items?.[index]?.scrollIntoView({ block: "nearest" });
+      }
+    },
+    [generations, onSelectSpan]
+  );
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
+
+      if (e.key === "ArrowDown" || e.key === "j") {
+        e.preventDefault();
+        const next = selectedIndex < generations.length - 1 ? selectedIndex + 1 : 0;
+        selectByIndex(next);
+      } else if (e.key === "ArrowUp" || e.key === "k") {
+        e.preventDefault();
+        const prev = selectedIndex > 0 ? selectedIndex - 1 : generations.length - 1;
+        selectByIndex(prev);
+      }
+    };
+
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [selectedIndex, generations.length, selectByIndex]);
+
+  if (generations.length === 0) {
+    return (
+      <div className="flex h-full items-center justify-center">
+        <InfoPanel
+          title="No generations yet"
+          icon={AIPromptsIcon}
+          iconClassName="text-aiPrompts"
+          panelClassName="max-w-md"
+        >
+          <Paragraph variant="small">
+            Generations appear here when this prompt version is resolved inside a task using{" "}
+            <InlineCode variant="small">prompt.resolve()</InlineCode> with an AI SDK call.
+          </Paragraph>
+          <Paragraph variant="small">
+            Try adjusting the time period filter or switching to a different version.
+          </Paragraph>
+        </InfoPanel>
+      </div>
+    );
+  }
+
+  return (
+    <ResizablePanelGroup
+      autosaveId="prompt-generations"
+      snapshot={generationsSnapshot}
+      className="h-full"
+    >
+      {/* Span list */}
+      <ResizablePanel id="prompt-gen-list" min="200px">
+        <div
+          ref={listRef}
+          className="h-full overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        >
+          {newGenerationCount > 0 && (
+            <div className="sticky top-0 z-20 flex items-center justify-center gap-2 border-b border-grid-dimmed bg-background-bright px-3 py-1.5">
+              <span className="text-xs text-text-dimmed">
+                {newGenerationCount} new {newGenerationCount === 1 ? "generation" : "generations"}
+              </span>
+              <Button
+                variant="minimal/small"
+                onClick={handleRefreshGenerations}
+                LeadingIcon={ArrowPathIcon}
+              >
+                Refresh
+              </Button>
+            </div>
+          )}
+          <Table variant="bright" fullWidth showTopBorder={false}>
+            <TableHeader>
+              <TableRow>
+                <TableHeaderCell className="w-8" />
+                <TableHeaderCell>Operation</TableHeaderCell>
+                <TableHeaderCell>Version</TableHeaderCell>
+                <TableHeaderCell>Model</TableHeaderCell>
+                <TableHeaderCell>Tokens</TableHeaderCell>
+                <TableHeaderCell>Cost</TableHeaderCell>
+                <TableHeaderCell>Duration</TableHeaderCell>
+                <TableHeaderCell alignment="right">Time</TableHeaderCell>
+                <TableHeaderCell className="w-12" hiddenLabel>
+                  Actions
+                </TableHeaderCell>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {generations.map((gen, i) => {
+                const isSelected = selectedSpan?.spanId === gen.span_id;
+                const runPath = v3RunSpanPath(
+                  organization,
+                  project,
+                  environment,
+                  { friendlyId: gen.run_id },
+                  { spanId: gen.span_id }
+                );
+                return (
+                  <TableRow
+                    key={`${gen.run_id}-${gen.span_id}-${i}`}
+                    data-generation-item
+                    isSelected={isSelected}
+                    className="cursor-pointer [&_td]:cursor-pointer"
+                    onClick={() => onSelectSpan({ runId: gen.run_id, spanId: gen.span_id })}
+                  >
+                    <TableCell>
+                      <RadioButtonCircle checked={isSelected} />
+                    </TableCell>
+                    <TableCell className={cn("font-medium", isSelected && "text-text-bright")}>
+                      {gen.operation_id || gen.task_identifier}
+                    </TableCell>
+                    <TableCell
+                      className={cn("tabular-nums", isSelected ? "text-text-bright" : "text-charcoal-400")}
+                    >
+                      v{gen.prompt_version}
+                    </TableCell>
+                    <TableCell className={cn(isSelected && "text-text-bright")}>
+                      {gen.response_model}
+                    </TableCell>
+                    <TableCell className={cn("tabular-nums", isSelected && "text-text-bright")}>
+                      {gen.input_tokens + gen.output_tokens}
+                    </TableCell>
+                    <TableCell className={cn("tabular-nums", isSelected && "text-text-bright")}>
+                      {formatCost(gen.total_cost)}
+                    </TableCell>
+                    <TableCell className={cn("tabular-nums", isSelected && "text-text-bright")}>
+                      {Math.round(gen.duration_ms)}ms
+                    </TableCell>
+                    <TableCell
+                      alignment="right"
+                      className={cn("tabular-nums", isSelected && "text-text-bright")}
+                    >
+                      {gen.start_time}
+                    </TableCell>
+                    <TableCellMenu
+                      isSticky
+                      isSelected={isSelected}
+                      hiddenButtons={
+                        <LinkButton
+                          to={runPath}
+                          onClick={(e) => e.stopPropagation()}
+                          variant="minimal/small"
+                          TrailingIcon={RunsIcon}
+                          trailingIconClassName="text-text-bright"
+                          className="h-[1.375rem] pl-1.5 pr-2"
+                        >
+                          <span className="text-[0.6875rem] text-text-bright">View run</span>
+                        </LinkButton>
+                      }
+                    />
+                  </TableRow>
+                );
+              })}
+            </TableBody>
+          </Table>
+
+          {/* Infinite scroll sentinel */}
+          <div ref={loadMoreRef} className="h-px" />
+          {showSpinner && (
+            <div className="flex items-center justify-center py-3">
+              <Spinner className="size-4" />
+            </div>
+          )}
+        </div>
+      </ResizablePanel>
+
+      <ResizableHandle id="prompt-gen-handle" />
+
+      {/* Span inspector */}
+      <ResizablePanel id="prompt-gen-inspector" default="430px" min="320px" isStaticAtRest>
+        {selectedSpan ? (
+          <SpanView runParam={selectedSpan.runId} spanId={selectedSpan.spanId} />
+        ) : (
+          <div className="flex h-full items-center justify-center bg-background-bright">
+            <Paragraph variant="small" className="text-text-dimmed">
+              Select a generation to view details
+            </Paragraph>
+          </div>
+        )}
+      </ResizablePanel>
+    </ResizablePanelGroup>
+  );
+}
+
+function formatCost(cost: number): string {
+  if (cost >= 1) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.01) return `$${cost.toFixed(4)}`;
+  if (cost === 0) return "$0";
+  return `$${cost.toFixed(6)}`;
+}
+
+// ─── Metrics Tab ─────────────────────────────────────────
+
+function MetricsTab({
+  prompt,
+  organizationId,
+  projectId,
+  environmentId,
+  period,
+  from,
+  to,
+}: {
+  prompt: { slug: string };
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  period: string;
+  from: string | null;
+  to: string | null;
+}) {
+  const { values: filterValues } = useSearchParams();
+  const versionFilters = filterValues("versions")
+    .map(Number)
+    .filter((n) => Number.isInteger(n) && n > 0);
+  const models = filterValues("models").filter((v) => v !== "");
+  const operations = filterValues("operations").filter((v) => v !== "");
+  const providers = filterValues("providers").filter((v) => v !== "");
+
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period,
+    from,
+    to,
+    promptSlugs: [prompt.slug],
+    promptVersions: versionFilters.length > 0 ? versionFilters : undefined,
+    responseModels: models.length > 0 ? models : undefined,
+    operations: operations.length > 0 ? operations : undefined,
+    providers: providers.length > 0 ? providers : undefined,
+  };
+
+  return (
+    <div className="space-y-3">
+      {/* Summary big numbers */}
+      <div className="grid grid-cols-4 gap-3">
+        <div className="h-44">
+          <MetricWidget
+            widgetKey={`prompt-${prompt.slug}-generations`}
+            title="Total"
+            query={`SELECT count() AS generations FROM llm_metrics WHERE 1=1`}
+            config={{
+              type: "bignumber",
+              column: "generations",
+              aggregation: "sum",
+              abbreviate: true,
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-44">
+          <MetricWidget
+            widgetKey={`prompt-${prompt.slug}-tokens`}
+            title="Avg input tokens"
+            query={`SELECT round(avg(input_tokens)) AS avg_input FROM llm_metrics WHERE 1=1`}
+            config={{
+              type: "bignumber",
+              column: "avg_input",
+              aggregation: "avg",
+              abbreviate: true,
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-44">
+          <MetricWidget
+            widgetKey={`prompt-${prompt.slug}-cost`}
+            title="Avg input cost"
+            query={`SELECT avg(input_cost) AS avg_cost FROM llm_metrics WHERE 1=1`}
+            config={{
+              type: "bignumber",
+              column: "avg_cost",
+              aggregation: "avg",
+              abbreviate: false,
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-44">
+          <MetricWidget
+            widgetKey={`prompt-${prompt.slug}-latency`}
+            title="Avg latency"
+            query={`SELECT round(avg(duration) / 1000000, 1) AS avg_ms FROM llm_metrics WHERE 1=1`}
+            config={{
+              type: "bignumber",
+              column: "avg_ms",
+              aggregation: "avg",
+              abbreviate: false,
+              suffix: "ms",
+            }}
+            {...widgetProps}
+          />
+        </div>
+      </div>
+
+      {/* Version performance */}
+      <VersionPerformanceSection
+        promptSlug={prompt.slug}
+        organizationId={organizationId}
+        projectId={projectId}
+        environmentId={environmentId}
+        period={period}
+        from={from}
+        to={to}
+      />
+    </div>
+  );
+}
+
+// ─── Version Performance Section ─────────────────────────
+
+function VersionPerformanceSection({
+  promptSlug,
+  organizationId,
+  projectId,
+  environmentId,
+  period,
+  from,
+  to,
+}: {
+  promptSlug: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  period: string;
+  from: string | null;
+  to: string | null;
+}) {
+  const { values: filterValues } = useSearchParams();
+  const versionFilters = filterValues("versions")
+    .map(Number)
+    .filter((n) => Number.isInteger(n) && n > 0);
+  const models = filterValues("models").filter((v) => v !== "");
+  const operations = filterValues("operations").filter((v) => v !== "");
+  const providers = filterValues("providers").filter((v) => v !== "");
+
+  const widgetProps = {
+    organizationId,
+    projectId,
+    environmentId,
+    scope: "environment" as const,
+    period,
+    from,
+    to,
+    promptSlugs: [promptSlug],
+    promptVersions: versionFilters.length > 0 ? versionFilters : undefined,
+    responseModels: models.length > 0 ? models : undefined,
+    operations: operations.length > 0 ? operations : undefined,
+    providers: providers.length > 0 ? providers : undefined,
+  };
+
+  return (
+    <div className="space-y-3">
+      <div className="grid grid-cols-2 gap-3">
+        {/* Row 1: Latency + TTFC */}
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-latency`}
+            title="Latency p50 / p95"
+            query={`SELECT timeBucket(), round(quantile(0.5)(duration) / 1000000, 1) AS p50, round(quantile(0.95)(duration) / 1000000, 1) AS p95 FROM llm_metrics WHERE 1=1 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-ttfc`}
+            title="TTFC p50 / p95"
+            query={`SELECT timeBucket(), round(quantile(0.5)(ms_to_first_chunk), 1) AS p50, round(quantile(0.95)(ms_to_first_chunk), 1) AS p95 FROM llm_metrics WHERE ms_to_first_chunk > 0 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+        {/* Row 2: Input tokens + Input cost */}
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-input-tokens`}
+            title="Input tokens p50 / p95"
+            query={`SELECT timeBucket(), round(quantile(0.5)(input_tokens)) AS p50, round(quantile(0.95)(input_tokens)) AS p95 FROM llm_metrics WHERE 1=1 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-input-cost`}
+            title="Input cost per 1k tokens (p50 / p95)"
+            query={`SELECT timeBucket(), prettyFormat(quantile(0.5)(input_cost / input_tokens * 1000), 'costInDollars') AS p50, prettyFormat(quantile(0.95)(input_cost / input_tokens * 1000), 'costInDollars') AS p95 FROM llm_metrics WHERE input_tokens > 0 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+        {/* Row 3: Output tokens + Output cost */}
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-output-tokens`}
+            title="Output tokens p50 / p95"
+            query={`SELECT timeBucket(), round(quantile(0.5)(output_tokens)) AS p50, round(quantile(0.95)(output_tokens)) AS p95 FROM llm_metrics WHERE 1=1 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+        <div className="h-96">
+          <MetricWidget
+            widgetKey={`prompt-${promptSlug}-perf-output-cost`}
+            title="Output cost per 1k tokens (p50 / p95)"
+            query={`SELECT timeBucket(), prettyFormat(quantile(0.5)(output_cost / output_tokens * 1000), 'costInDollars') AS p50, prettyFormat(quantile(0.95)(output_cost / output_tokens * 1000), 'costInDollars') AS p95 FROM llm_metrics WHERE output_tokens > 0 GROUP BY timeBucket ORDER BY timeBucket`}
+            config={{
+              type: "chart",
+              chartType: "line",
+              xAxisColumn: "timebucket",
+              yAxisColumns: ["p50", "p95"],
+              groupByColumn: null,
+              stacked: false,
+              sortByColumn: null,
+              sortDirection: "asc",
+              aggregation: "avg",
+            }}
+            {...widgetProps}
+          />
+        </div>
+      </div>
+
+      <div className="h-48">
+        <MetricWidget
+          widgetKey={`prompt-${promptSlug}-perf-versions-table`}
+          title="Version summary"
+          query={`SELECT prompt_version, count() AS calls, round(avg(input_tokens)) AS avg_input_tokens, round(avg(output_tokens)) AS avg_output_tokens, prettyFormat(avg(total_cost), 'costInDollars') AS avg_total_cost, round(quantile(0.5)(duration) / 1000000, 1) AS p50_latency_ms, round(quantile(0.95)(duration) / 1000000, 1) AS p95_latency_ms FROM llm_metrics WHERE 1=1 GROUP BY prompt_version ORDER BY prompt_version DESC`}
+          config={{ type: "table", prettyFormatting: true, sorting: [] }}
+          {...widgetProps}
+        />
+      </div>
+    </div>
+  );
+}
+
+// ─── Prompt Versions Filter ──────────────────────────────
+
+function PromptVersionsFilter({ versions }: { versions: VersionData[] }) {
+  const { values, replace, del } = useSearchParams();
+  const selected = values("versions");
+
+  const handleChange = (newValues: string[]) => {
+    replace({ versions: newValues });
+  };
+
+  if (selected.length === 0 || selected.every((v) => v === "")) {
+    return (
+      <SelectProvider value={[]} setValue={handleChange} virtualFocus={true}>
+        <SelectTrigger
+          icon={<GitBranchPlusIcon className="size-4" />}
+          variant="secondary/small"
+          tooltipTitle="Filter by version"
+          shortcut={{ key: "e" }}
+        >
+          <span className="ml-0.5">Versions</span>
+        </SelectTrigger>
+        <SelectPopover className="min-w-0 max-w-[min(240px,var(--popover-available-width))]">
+          <SelectList>
+            {versions.map((v) => (
+              <SelectItem key={v.version} value={String(v.version)}>
+                v{v.version}
+                {v.labels.includes("current") ? " (current)" : ""}
+                {v.labels.includes("override") ? " (override)" : ""}
+              </SelectItem>
+            ))}
+          </SelectList>
+        </SelectPopover>
+      </SelectProvider>
+    );
+  }
+
+  const summary = selected.length === 1 ? `v${selected[0]}` : `${selected.length} versions`;
+
+  return (
+    <SelectProvider value={selected} setValue={handleChange} virtualFocus={true}>
+      <Ariakit.Select render={<div className="group cursor-pointer focus-custom" />}>
+        <AppliedFilter
+          label="Version"
+          icon={<GitBranchPlusIcon className="size-4" />}
+          value={summary}
+          onRemove={() => del(["versions"])}
+          variant="secondary/small"
+        />
+      </Ariakit.Select>
+      <SelectPopover className="min-w-0 max-w-[min(240px,var(--popover-available-width))]">
+        <SelectList>
+          {versions.map((v) => (
+            <SelectItem key={v.version} value={String(v.version)}>
+              v{v.version}
+              {v.labels.includes("current") ? " (current)" : ""}
+              {v.labels.includes("override") ? " (override)" : ""}
+            </SelectItem>
+          ))}
+        </SelectList>
+      </SelectPopover>
+    </SelectProvider>
+  );
+}
+
+// ─── Versions Tab ────────────────────────────────────────
+
+function VersionsTab({
+  versions,
+  selectedVersion,
+  onSelectVersion,
+}: {
+  versions: VersionData[];
+  selectedVersion: VersionData | undefined;
+  onSelectVersion: (version: number) => void;
+}) {
+  return (
+    <div className="divide-y divide-grid-dimmed border-b border-grid-dimmed">
+      {versions.map((v) => {
+        const isSelected = selectedVersion?.id === v.id;
+        const isCurrent = v.labels.includes("current");
+        const isLatest = v.labels.includes("latest");
+        const isOverride = v.labels.includes("override");
+
+        return (
+          <div
+            key={v.id}
+            onClick={() => onSelectVersion(v.version)}
+            className={cn(
+              "flex cursor-pointer items-center gap-3 px-3 py-3 text-sm transition",
+              isSelected ? "bg-indigo-500/10 hover:bg-indigo-500/[0.07]" : "hover:bg-charcoal-750"
+            )}
+          >
+            <RadioButtonCircle checked={isSelected} />
+            <div className="min-w-0 flex-1">
+              <div className="flex items-center gap-1.5">
+                <div
+                  className={cn(
+                    "size-2 shrink-0 rounded-full",
+                    isOverride ? "bg-amber-400" : isCurrent ? "bg-green-500" : "bg-charcoal-600"
+                  )}
+                />
+                <span className="font-medium text-text-bright">v{v.version}</span>
+                {isOverride && (
+                  <Badge variant="extra-small" className="border-amber-500/30 text-amber-400">
+                    override
+                  </Badge>
+                )}
+                {isCurrent && <Badge variant="extra-small">current</Badge>}
+                {isLatest && !isCurrent && <Badge variant="extra-small">latest</Badge>}
+                <span
+                  className={cn(
+                    "text-xs",
+                    v.source !== "code" ? "text-amber-400" : "text-text-dimmed"
+                  )}
+                >
+                  {v.source}
+                </span>
+              </div>
+              {(v.model || v.commitMessage) && (
+                <div className="flex items-center gap-1.5 truncate text-xs text-text-dimmed">
+                  {v.model && <span>{v.model}</span>}
+                  {v.model && v.commitMessage && <span className="text-charcoal-600">/</span>}
+                  {v.commitMessage && <span className="truncate">{v.commitMessage}</span>}
+                </div>
+              )}
+            </div>
+            <span className="shrink-0 text-xs text-text-dimmed">
+              <DateTime date={v.createdAt} />
+            </span>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+const MAX_DESCRIPTION_PREVIEW = 80;
+
+function PromptCopyPopover({
+  slug,
+  friendlyId,
+  description,
+}: {
+  slug: string;
+  friendlyId: string;
+  description: string | null;
+}) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger className="-ml-1.5 flex items-center gap-1 rounded py-1.5 pl-2 pr-1.5 font-mono text-xs text-text-dimmed transition focus-custom hover:bg-charcoal-750 hover:text-text-bright">
+        {slug}
+        <ChevronUpDownIcon className="size-4 text-charcoal-500" />
+      </PopoverTrigger>
+      <PopoverContent
+        align="start"
+        className="flex min-w-0 flex-col p-1"
+        onOpenAutoFocus={(e) => {
+          e.preventDefault();
+          const el = e.currentTarget as HTMLElement;
+          el.style.pointerEvents = "none";
+          requestAnimationFrame(() => {
+            el.style.pointerEvents = "";
+          });
+        }}
+      >
+        <CopyPopoverItem label="Copy slug" value={slug} onCopied={() => setOpen(false)} />
+        <CopyPopoverItem
+          label="Copy friendly ID"
+          value={friendlyId}
+          onCopied={() => setOpen(false)}
+        />
+        {description && (
+          <CopyPopoverItem
+            label="Copy description"
+            value={description}
+            preview={
+              description.length > MAX_DESCRIPTION_PREVIEW
+                ? description.slice(0, MAX_DESCRIPTION_PREVIEW) + "…"
+                : description
+            }
+            onCopied={() => setOpen(false)}
+          />
+        )}
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function CopyPopoverItem({
+  label,
+  value,
+  preview,
+  onCopied,
+}: {
+  label: string;
+  value: string;
+  preview?: string;
+  onCopied?: () => void;
+}) {
+  const [copied, setCopied] = useState(false);
+
+  const handleCopy = () => {
+    navigator.clipboard.writeText(value);
+    setCopied(true);
+    setTimeout(() => {
+      setCopied(false);
+      onCopied?.();
+    }, 600);
+  };
+
+  return (
+    <SimpleTooltip
+      button={
+        <button
+          type="button"
+          onClick={handleCopy}
+          className={cn(
+            "flex w-full items-center gap-2 rounded px-2 py-1.5 text-left text-xs transition",
+            copied
+              ? "text-green-500"
+              : "text-text-dimmed hover:bg-charcoal-700 hover:text-text-bright"
+          )}
+        >
+          {copied ? (
+            <ClipboardCheckIcon className="size-3.5 shrink-0" />
+          ) : (
+            <ClipboardIcon className="size-3.5 shrink-0" />
+          )}
+          {label}
+        </button>
+      }
+      content={<span className="max-w-64 break-all font-mono text-xs">{preview ?? value}</span>}
+      side="right"
+      disableHoverableContent
+      asChild
+    />
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts._index/route.tsx
new file mode 100644
index 00000000000..02c7cc444b7
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts._index/route.tsx
@@ -0,0 +1,186 @@
+import { type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { Bar, BarChart, ResponsiveContainer } from "recharts";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { PromptsNone } from "~/components/BlankStatePanels";
+import { MainCenteredContainer, PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { TruncatedCopyableValue } from "~/components/primitives/TruncatedCopyableValue";
+import { DateTime } from "~/components/primitives/DateTime";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import {
+  Table,
+  TableBlankRow,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUserId } from "~/services/session.server";
+import { docsPath, EnvironmentParamSchema, v3PromptsPath } from "~/utils/pathBuilder";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { BookOpenIcon } from "@heroicons/react/24/solid";
+
+export const meta: MetaFunction = () => {
+  return [{ title: "Prompts | Trigger.dev" }];
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const presenter = new PromptPresenter(clickhouseClient);
+  const prompts = await presenter.listPrompts(project.id, environment.id);
+
+  const sparklines = await presenter.getUsageSparklines(
+    environment.id,
+    prompts.map((p) => p.slug)
+  );
+
+  return typedjson({ prompts, sparklines });
+};
+
+export default function PromptsPage() {
+  const { prompts, sparklines } = useTypedLoaderData<typeof loader>();
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  if (prompts.length === 0) {
+    return (
+      <PageContainer>
+        <NavBar>
+          <PageTitle title="Prompts" />
+        </NavBar>
+        <PageBody>
+          <MainCenteredContainer className="max-w-lg">
+            <PromptsNone />
+          </MainCenteredContainer>
+        </PageBody>
+      </PageContainer>
+    );
+  }
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Prompts" />
+        <PageAccessories>
+          <LinkButton variant="docs/small" LeadingIcon={BookOpenIcon} to={docsPath("ai/prompts")}>
+            Prompts docs
+          </LinkButton>
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable={false}>
+        <Table containerClassName="border-t-0">
+          <TableHeader>
+            <TableRow>
+              <TableHeaderCell>ID</TableHeaderCell>
+              <TableHeaderCell>Slug</TableHeaderCell>
+              <TableHeaderCell>Description</TableHeaderCell>
+              <TableHeaderCell>Model</TableHeaderCell>
+              <TableHeaderCell>Version</TableHeaderCell>
+              <TableHeaderCell>Usage (24h)</TableHeaderCell>
+              <TableHeaderCell alignment="right">Last updated</TableHeaderCell>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {prompts.length === 0 ? (
+              <TableBlankRow colSpan={7}>No prompts found</TableBlankRow>
+            ) : (
+              prompts.map((prompt) => {
+                const path = `${v3PromptsPath(organization, project, environment)}/${prompt.slug}`;
+                const activeVersion = prompt.overrideVersion ?? prompt.currentVersion;
+                const isOverride = !!prompt.overrideVersion;
+
+                return (
+                  <TableRow key={prompt.id}>
+                    <TableCell to={path} isTabbableCell>
+                      <TruncatedCopyableValue value={prompt.friendlyId} />
+                    </TableCell>
+                    <TableCell to={path}>{prompt.slug}</TableCell>
+                    <TableCell to={path}>
+                      {prompt.description ? (
+                        <span
+                          title={prompt.description.length > 80 ? prompt.description : undefined}
+                        >
+                          {prompt.description.length > 80
+                            ? prompt.description.slice(0, 80) + "…"
+                            : prompt.description}
+                        </span>
+                      ) : (
+                        <span>-</span>
+                      )}
+                    </TableCell>
+                    <TableCell to={path}>
+                      <span>{prompt.defaultModel ?? <span>-</span>}</span>
+                    </TableCell>
+                    <TableCell to={path}>
+                      {activeVersion ? (
+                        <div className="flex items-center gap-1.5">
+                          <div
+                            className={`size-1.5 rounded-full ${
+                              isOverride ? "bg-warning" : "bg-success"
+                            }`}
+                          />
+                          <span>v{activeVersion.version}</span>
+                        </div>
+                      ) : (
+                        <span>-</span>
+                      )}
+                    </TableCell>
+                    <TableCell to={path}>
+                      <UsageSparkline data={sparklines[prompt.slug]} />
+                    </TableCell>
+                    <TableCell to={path} alignment="right">
+                      <DateTime date={prompt.updatedAt} />
+                    </TableCell>
+                  </TableRow>
+                );
+              })
+            )}
+          </TableBody>
+        </Table>
+      </PageBody>
+    </PageContainer>
+  );
+}
+
+function UsageSparkline({ data }: { data?: number[] }) {
+  if (!data || data.every((v) => v === 0)) {
+    return <span className="text-charcoal-500">-</span>;
+  }
+
+  const total = data.reduce((a, b) => a + b, 0);
+  const chartData = data.map((value) => ({ value }));
+
+  return (
+    <div className="flex items-center gap-2">
+      <div className="h-6 w-16">
+        <ResponsiveContainer width="100%" height="100%">
+          <BarChart data={chartData} margin={{ top: 1, right: 0, bottom: 1, left: 0 }}>
+            <Bar dataKey="value" fill="#3b82f6" radius={[1, 1, 0, 0]} isAnimationActive={false} />
+          </BarChart>
+        </ResponsiveContainer>
+      </div>
+      <span className="text-xs tabular-nums text-text-dimmed">{total.toLocaleString()}</span>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/AITabContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/AITabContent.tsx
new file mode 100644
index 00000000000..98e4002e718
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/AITabContent.tsx
@@ -0,0 +1,72 @@
+import { useState } from "react";
+import { SparkleListIcon } from "~/assets/icons/SparkleListIcon";
+import { AIQueryInput } from "~/components/code/AIQueryInput";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import type { AITimeFilter } from "./types";
+
+export function AITabContent({
+  onQueryGenerated,
+  onTimeFilterChange,
+  getCurrentQuery,
+  aiFixRequest,
+}: {
+  onQueryGenerated: (query: string) => void;
+  onTimeFilterChange?: (filter: AITimeFilter) => void;
+  getCurrentQuery: () => string;
+  aiFixRequest: { prompt: string; key: number } | null;
+}) {
+  const [examplePromptRequest, setExamplePromptRequest] = useState<{
+    prompt: string;
+    key: number;
+  } | null>(null);
+
+  // Use aiFixRequest if present, otherwise use example prompt request
+  const activeRequest = aiFixRequest ?? examplePromptRequest;
+
+  const examplePrompts = [
+    "Show me failed runs by hour for the past 7 days",
+    "Count of runs by status by hour for the past 48h",
+    "Top 50 most expensive runs this week",
+    "Average execution duration by task this week",
+    "Run counts by tag in the past 7 days",
+    "CPU utilization over time by task",
+    "Peak memory usage per run",
+  ];
+
+  return (
+    <div className="space-y-2">
+      <AIQueryInput
+        onQueryGenerated={onQueryGenerated}
+        onTimeFilterChange={onTimeFilterChange}
+        autoSubmitPrompt={activeRequest?.prompt}
+        autoSubmitKey={activeRequest?.key}
+        getCurrentQuery={getCurrentQuery}
+      />
+
+      <div className="pt-4">
+        <Header3 className="mb-3 text-text-bright">Example prompts</Header3>
+        <div className="flex flex-wrap gap-2">
+          {examplePrompts.map((example) => (
+            <button
+              key={example}
+              type="button"
+              onClick={() => {
+                setExamplePromptRequest((prev) => ({
+                  prompt: example,
+                  key: (prev?.key ?? 0) + 1,
+                }));
+              }}
+              className="group flex w-fit items-center gap-2 rounded-full border border-dashed border-charcoal-600 px-4 py-2 transition-colors hover:border-solid hover:border-indigo-500 focus-custom focus-visible:!rounded-full"
+            >
+              <SparkleListIcon className="size-4 shrink-0 text-text-dimmed transition group-hover:text-indigo-500" />
+              <Paragraph variant="small" className="text-left transition group-hover:text-text-bright">
+                {example}
+              </Paragraph>
+            </button>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/ExamplesContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/ExamplesContent.tsx
new file mode 100644
index 00000000000..f0c3c1d616f
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/ExamplesContent.tsx
@@ -0,0 +1,249 @@
+import { useState } from "react";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import SegmentedControl from "~/components/primitives/SegmentedControl";
+import type { QueryScope } from "~/services/queryService.server";
+import { querySchemas } from "~/v3/querySchemas";
+import { TryableCodeBlock } from "./TRQLGuideContent";
+
+// Example queries for the Examples tab
+export const exampleQueries: Array<{
+  title: string;
+  description: string;
+  query: string;
+  scope: QueryScope;
+  table: string;
+}> = [
+  {
+    title: "Failed runs by task (past 7 days)",
+    description: "Count of failed runs grouped by task identifier over the last 7 days.",
+    query: `SELECT
+  task_identifier,
+  count() AS failed_count
+FROM runs
+WHERE status = 'Failed'
+  AND triggered_at > now() - INTERVAL 7 DAY
+GROUP BY task_identifier
+ORDER BY failed_count DESC
+LIMIT 20`,
+    scope: "environment",
+    table: "runs",
+  },
+  {
+    title: "Execution duration p50 by task (past 7d)",
+    description: "Median (50th percentile) execution duration for each task.",
+    query: `SELECT
+  task_identifier,
+  quantile(0.5)(execution_duration) AS p50_duration_ms
+FROM runs
+WHERE triggered_at > now() - INTERVAL 7 DAY
+  AND execution_duration IS NOT NULL
+GROUP BY task_identifier
+ORDER BY p50_duration_ms DESC
+LIMIT 20`,
+    scope: "environment",
+    table: "runs",
+  },
+  {
+    title: "Runs over time",
+    description:
+      "Count of runs bucketed over time. The bucket size adjusts automatically to the time range.",
+    query: `SELECT
+  timeBucket(),
+  count() AS run_count
+FROM runs
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000`,
+    scope: "environment",
+    table: "runs",
+  },
+  {
+    title: "Most expensive 100 runs (past 7d)",
+    description: "Top 100 runs by cost over the last 7 days.",
+    query: `SELECT
+  run_id,
+  task_identifier,
+  status,
+  total_cost,
+  usage_duration,
+  machine,
+  triggered_at
+FROM runs
+WHERE triggered_at > now() - INTERVAL 7 DAY
+ORDER BY total_cost DESC
+LIMIT 100`,
+    scope: "environment",
+    table: "runs",
+  },
+  {
+    title: "CPU utilization over time",
+    description: "Track process CPU utilization bucketed over time.",
+    query: `SELECT
+  timeBucket(),
+  avg(metric_value) AS avg_cpu
+FROM metrics
+WHERE metric_name = 'process.cpu.utilization'
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000`,
+    scope: "environment",
+    table: "metrics",
+  },
+  {
+    title: "Memory usage by task (past 7d)",
+    description: "Average memory usage per task identifier over the last 7 days.",
+    query: `SELECT
+  task_identifier,
+  avg(metric_value) AS avg_memory
+FROM metrics
+WHERE metric_name = 'system.memory.usage'
+  AND bucket_start > now() - INTERVAL 7 DAY
+GROUP BY task_identifier
+ORDER BY avg_memory DESC
+LIMIT 20`,
+    scope: "environment",
+    table: "metrics",
+  },
+  {
+    title: "Available metric names",
+    description: "List all distinct metric names collected in your environment.",
+    query: `SELECT
+  metric_name,
+  count() AS sample_count
+FROM metrics
+GROUP BY metric_name
+ORDER BY sample_count DESC
+LIMIT 100`,
+    scope: "environment",
+    table: "metrics",
+  },
+  {
+    title: "LLM cost by model (past 7d)",
+    description: "Total cost, input tokens, and output tokens grouped by model over the last 7 days.",
+    query: `SELECT
+  response_model,
+  SUM(total_cost) AS total_cost,
+  SUM(input_tokens) AS input_tokens,
+  SUM(output_tokens) AS output_tokens
+FROM llm_metrics
+WHERE start_time > now() - INTERVAL 7 DAY
+GROUP BY response_model
+ORDER BY total_cost DESC`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+  {
+    title: "LLM cost over time",
+    description: "Total LLM cost bucketed over time. The bucket size adjusts automatically.",
+    query: `SELECT
+  timeBucket(),
+  SUM(total_cost) AS total_cost
+FROM llm_metrics
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+  {
+    title: "Most expensive runs by LLM cost (top 50)",
+    description: "Top 50 runs by total LLM cost with token breakdown.",
+    query: `SELECT
+  run_id,
+  task_identifier,
+  SUM(total_cost) AS llm_cost,
+  SUM(input_tokens) AS input_tokens,
+  SUM(output_tokens) AS output_tokens
+FROM llm_metrics
+GROUP BY run_id, task_identifier
+ORDER BY llm_cost DESC
+LIMIT 50`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+  {
+    title: "LLM calls by provider",
+    description: "Count and cost of LLM calls grouped by AI provider.",
+    query: `SELECT
+  gen_ai_system,
+  count() AS call_count,
+  SUM(total_cost) AS total_cost
+FROM llm_metrics
+GROUP BY gen_ai_system
+ORDER BY total_cost DESC`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+  {
+    title: "LLM cost by user",
+    description:
+      "Total LLM cost per user from run tags or AI SDK telemetry metadata. Uses metadata.userId which comes from experimental_telemetry metadata or run tags like user:123.",
+    query: `SELECT
+  metadata.userId AS user_id,
+  SUM(total_cost) AS total_cost,
+  SUM(total_tokens) AS total_tokens,
+  count() AS call_count
+FROM llm_metrics
+WHERE metadata.userId != ''
+GROUP BY metadata.userId
+ORDER BY total_cost DESC
+LIMIT 50`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+  {
+    title: "LLM cost by metadata key",
+    description:
+      "Browse all metadata keys and their LLM cost. Metadata comes from run tags (key:value) and AI SDK telemetry metadata.",
+    query: `SELECT
+  metadata,
+  response_model,
+  total_cost,
+  total_tokens,
+  run_id
+FROM llm_metrics
+ORDER BY start_time DESC
+LIMIT 20`,
+    scope: "environment",
+    table: "llm_metrics",
+  },
+];
+
+const tableOptions = querySchemas.map((s) => ({ label: s.name, value: s.name }));
+
+export function ExamplesContent({
+  onTryExample,
+}: {
+  onTryExample: (query: string, scope: QueryScope) => void;
+}) {
+  const [selectedTable, setSelectedTable] = useState(querySchemas[0].name);
+  const filtered = exampleQueries.filter((e) => e.table === selectedTable);
+
+  return (
+    <div className="space-y-6">
+      <div className="sticky top-0 z-10 bg-background-bright pb-3">
+        <SegmentedControl
+          name="examples-table-selector"
+          value={selectedTable}
+          options={tableOptions}
+          variant="secondary/small"
+          fullWidth
+          onChange={setSelectedTable}
+        />
+      </div>
+      {filtered.map((example) => (
+        <div key={example.title}>
+          <Header3 className="mb-1 text-text-bright">{example.title}</Header3>
+          <Paragraph variant="small" className="mb-2 text-text-dimmed">
+            {example.description}
+          </Paragraph>
+          <TryableCodeBlock
+            code={example.query}
+            onTry={() => onTryExample(example.query, example.scope)}
+          />
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHelpSidebar.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHelpSidebar.tsx
new file mode 100644
index 00000000000..daa7187acf2
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHelpSidebar.tsx
@@ -0,0 +1,117 @@
+import { AISparkleIcon } from "~/assets/icons/AISparkleIcon";
+import {
+  ClientTabs,
+  ClientTabsContent,
+  ClientTabsList,
+  ClientTabsTrigger,
+} from "~/components/primitives/ClientTabs";
+import type { QueryScope } from "~/services/queryService.server";
+import { AITabContent } from "./AITabContent";
+import { ExamplesContent } from "./ExamplesContent";
+import { TableSchemaContent } from "./TableSchemaContent";
+import { TRQLGuideContent } from "./TRQLGuideContent";
+import type { AITimeFilter } from "./types";
+
+export function QueryHelpSidebar({
+  onTryExample,
+  onQueryGenerated,
+  onTimeFilterChange,
+  getCurrentQuery,
+  activeTab,
+  onTabChange,
+  aiFixRequest,
+}: {
+  onTryExample: (query: string, scope: QueryScope) => void;
+  onQueryGenerated: (query: string) => void;
+  onTimeFilterChange?: (filter: AITimeFilter) => void;
+  getCurrentQuery: () => string;
+  activeTab: string;
+  onTabChange: (tab: string) => void;
+  aiFixRequest: { prompt: string; key: number } | null;
+}) {
+  return (
+    <div className="grid h-full max-h-full grid-rows-[auto_1fr] overflow-hidden bg-background-bright">
+      <ClientTabs
+        value={activeTab}
+        onValueChange={onTabChange}
+        className="flex min-h-0 flex-col overflow-hidden pt-1"
+      >
+        <div className="h-fit overflow-x-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <ClientTabsList variant="underline" className="mx-3 shrink-0">
+            <ClientTabsTrigger
+              value="ai"
+              variant="underline"
+              layoutId="query-help-tabs"
+              className="shrink-0"
+            >
+              <div className="flex items-center gap-0.5">
+                <AISparkleIcon className="size-4" /> AI
+              </div>
+            </ClientTabsTrigger>
+            <ClientTabsTrigger
+              value="guide"
+              variant="underline"
+              layoutId="query-help-tabs"
+              className="shrink-0"
+            >
+              Writing TRQL
+            </ClientTabsTrigger>
+            <ClientTabsTrigger
+              value="schema"
+              variant="underline"
+              layoutId="query-help-tabs"
+              className="shrink-0"
+            >
+              Table schema
+            </ClientTabsTrigger>
+            <ClientTabsTrigger
+              value="examples"
+              variant="underline"
+              layoutId="query-help-tabs"
+              className="shrink-0"
+            >
+              Examples
+            </ClientTabsTrigger>
+          </ClientTabsList>
+        </div>
+        <ClientTabsContent
+          value="ai"
+          className="min-h-0 flex-1 overflow-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        >
+          <div className="min-w-64 p-3">
+            <AITabContent
+              onQueryGenerated={onQueryGenerated}
+              onTimeFilterChange={onTimeFilterChange}
+              getCurrentQuery={getCurrentQuery}
+              aiFixRequest={aiFixRequest}
+            />
+          </div>
+        </ClientTabsContent>
+        <ClientTabsContent
+          value="guide"
+          className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        >
+          <div className="min-w-64 p-3">
+            <TRQLGuideContent onTryExample={onTryExample} />
+          </div>
+        </ClientTabsContent>
+        <ClientTabsContent
+          value="schema"
+          className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        >
+          <div className="min-w-64 p-3">
+            <TableSchemaContent />
+          </div>
+        </ClientTabsContent>
+        <ClientTabsContent
+          value="examples"
+          className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+        >
+          <div className="min-w-64 p-3">
+            <ExamplesContent onTryExample={onTryExample} />
+          </div>
+        </ClientTabsContent>
+      </ClientTabs>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHistoryPopover.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHistoryPopover.tsx
new file mode 100644
index 00000000000..65c10f3f9d4
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/QueryHistoryPopover.tsx
@@ -0,0 +1,163 @@
+import { useState } from "react";
+import { ClockRotateLeftIcon } from "~/assets/icons/ClockRotateLeftIcon";
+import { Button } from "~/components/primitives/Buttons";
+import { Popover, PopoverTrigger } from "~/components/primitives/Popover";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import type { QueryHistoryItem } from "~/presenters/v3/QueryPresenter.server";
+import { timeFilterRenderValues } from "~/components/runs/v3/SharedFilters";
+import { ChevronUpDownIcon } from "@heroicons/react/20/solid";
+import { cn } from "~/utils/cn";
+
+const SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "ORDER BY",
+  "LIMIT",
+  "GROUP BY",
+  "HAVING",
+  "JOIN",
+  "LEFT JOIN",
+  "RIGHT JOIN",
+  "INNER JOIN",
+  "OUTER JOIN",
+  "AND",
+  "OR",
+  "AS",
+  "ON",
+  "IN",
+  "NOT",
+  "NULL",
+  "DESC",
+  "ASC",
+  "DISTINCT",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+];
+
+function highlightSQL(query: string): React.ReactNode[] {
+  // Normalize: collapse multiple spaces/tabs to single space, but preserve newlines
+  // Then trim each line and limit total length
+  const normalized = query
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+/g, " ").trim())
+    .filter((line) => line.length > 0)
+    .join("\n")
+    .slice(0, 500);
+
+  // Create a regex pattern that matches keywords as whole words (case insensitive)
+  const keywordPattern = new RegExp(
+    `\\b(${SQL_KEYWORDS.map((k) => k.replace(/\s+/g, "\\s+")).join("|")})\\b`,
+    "gi"
+  );
+
+  const parts: React.ReactNode[] = [];
+  let lastIndex = 0;
+  let match;
+
+  while ((match = keywordPattern.exec(normalized)) !== null) {
+    // Add text before the match
+    if (match.index > lastIndex) {
+      parts.push(normalized.slice(lastIndex, match.index));
+    }
+    // Add the highlighted keyword
+    parts.push(
+      <span key={match.index} className="text-[#c678dd]">
+        {match[0]}
+      </span>
+    );
+    lastIndex = keywordPattern.lastIndex;
+  }
+
+  // Add remaining text
+  if (lastIndex < normalized.length) {
+    parts.push(normalized.slice(lastIndex));
+  }
+
+  return parts;
+}
+
+export function QueryHistoryPopover({
+  history,
+  onQuerySelected,
+}: {
+  history: QueryHistoryItem[];
+  onQuerySelected: (item: QueryHistoryItem) => void;
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+
+  return (
+    <Popover open={isOpen} onOpenChange={setIsOpen}>
+      <PopoverTrigger asChild>
+        <Button
+          type="button"
+          variant="secondary/small"
+          LeadingIcon={ClockRotateLeftIcon}
+          leadingIconClassName="-mr-1.5"
+          TrailingIcon={ChevronUpDownIcon}
+          disabled={history.length === 0}
+        >
+          History
+        </Button>
+      </PopoverTrigger>
+      <PopoverPrimitive.Content
+        className={cn(
+          "z-50 w-[400px] min-w-0 overflow-hidden rounded border border-charcoal-700 bg-background-bright p-0 shadow-md outline-none animate-in data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2"
+        )}
+        align="start"
+        sideOffset={6}
+        style={{ maxHeight: "var(--radix-popover-content-available-height)" }}
+      >
+        <div className="max-h-[40rem] overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <div className="p-1">
+            {history.map((item) => {
+              // Format time filter display
+              const { valueLabel } = timeFilterRenderValues({
+                period: item.filterPeriod ?? undefined,
+                from: item.filterFrom ?? undefined,
+                to: item.filterTo ?? undefined,
+              });
+
+              return (
+                <button
+                  key={item.id}
+                  type="button"
+                  onClick={() => {
+                    onQuerySelected(item);
+                    setIsOpen(false);
+                  }}
+                  className="flex w-full flex-col gap-1 rounded-sm px-2 py-2 outline-none transition-colors focus-custom hover:bg-charcoal-750"
+                >
+                  <div className="flex w-full flex-col items-start">
+                    {item.title ? (
+                      <p className="mb-1 truncate text-left text-sm font-medium text-text-bright">
+                        {item.title}
+                      </p>
+                    ) : (
+                      <p className="mb-1 truncate text-left font-mono text-xs text-text-bright">
+                        {item.query.split("\n")[0].slice(0, 60)}
+                      </p>
+                    )}
+                    <div className="flex items-center gap-1.5 text-xs text-text-dimmed">
+                      <span className="capitalize">{item.scope}</span>
+                      {valueLabel && <span>· {valueLabel}</span>}
+                      {item.userName && <span>· {item.userName}</span>}
+                    </div>
+                  </div>
+                  <div className="w-full border-l-2 border-charcoal-600 pl-2.5">
+                    <p className="line-clamp-4 w-full whitespace-pre-wrap text-left font-mono text-xs text-text-dimmed">
+                      {highlightSQL(item.query)}
+                    </p>
+                  </div>
+                </button>
+              );
+            })}
+          </div>
+        </div>
+      </PopoverPrimitive.Content>
+    </Popover>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TRQLGuideContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TRQLGuideContent.tsx
new file mode 100644
index 00000000000..35acfd266fc
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TRQLGuideContent.tsx
@@ -0,0 +1,1209 @@
+import { PlayIcon } from "@heroicons/react/20/solid";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { Button } from "~/components/primitives/Buttons";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import type { QueryScope } from "~/services/queryService.server";
+
+/** A code block with an integrated "Try it" button */
+export function TryableCodeBlock({
+  code,
+  onTry,
+  className,
+}: {
+  code: string;
+  onTry?: () => void;
+  className?: string;
+}) {
+  return (
+    <div className={className}>
+      <CodeBlock
+        code={code}
+        language="sql"
+        showLineNumbers={false}
+        showOpenInModal={false}
+        className={onTry ? "rounded-b-none border-b-0 text-xs" : "text-xs"}
+      />
+      {onTry && (
+        <div className="flex justify-end rounded-b-md border border-grid-bright p-1">
+          <Button variant="minimal/small" onClick={onTry} LeadingIcon={PlayIcon}>
+            Try it
+          </Button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+type FunctionDoc = { name: string; desc: string; example: string };
+
+function FunctionCategory({ title, functions }: { title: string; functions: FunctionDoc[] }) {
+  return (
+    <div>
+      <Paragraph variant="small/bright" className="mb-1">
+        {title}
+      </Paragraph>
+      <div className="flex flex-wrap gap-1">
+        {functions.map((fn) => (
+          <SimpleTooltip
+            key={fn.name}
+            button={
+              <code className="cursor-help rounded bg-charcoal-750 px-1.5 py-0.5 font-mono text-xxs text-indigo-400 transition-colors hover:bg-charcoal-700 hover:text-indigo-300">
+                {fn.name}
+              </code>
+            }
+            content={
+              <div className="max-w-xs space-y-1">
+                <div className="text-text-bright">{fn.desc}</div>
+                <code className="block rounded bg-charcoal-800 px-1.5 py-1 font-mono text-xxs text-indigo-300">
+                  {fn.example}
+                </code>
+              </div>
+            }
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+export function TRQLGuideContent({
+  onTryExample,
+}: {
+  onTryExample: (query: string, scope: QueryScope) => void;
+}) {
+  return (
+    <div className="space-y-6">
+      <Paragraph variant="small/bright">
+        TRQL is a query language for the Trigger platform. It is based on ClickHouse SQL and extends
+        it with additional features.
+      </Paragraph>
+      {/* Table of contents */}
+      <nav className="space-y-1 text-sm">
+        <a href="#basic" className="block text-text-link hover:underline">
+          Basic queries
+        </a>
+        <a href="#filtering" className="block text-text-link hover:underline">
+          Filtering with WHERE
+        </a>
+        <a href="#sorting" className="block text-text-link hover:underline">
+          Sorting &amp; limiting
+        </a>
+        <a href="#grouping" className="block text-text-link hover:underline">
+          Grouping &amp; aggregation
+        </a>
+        <a href="#functions" className="block text-text-link hover:underline">
+          Available functions
+        </a>
+      </nav>
+
+      {/* Basic queries */}
+      <section id="basic">
+        <Header3 className="mb-2 text-text-bright">Basic queries</Header3>
+        <Paragraph variant="small" className="mb-2 text-text-dimmed">
+          Select columns from a table. Use <code className="text-xs">*</code> to select all columns,
+          or list specific columns.
+        </Paragraph>
+        <TryableCodeBlock
+          code={`SELECT run_id, task_identifier, status
+FROM runs
+LIMIT 10`}
+          onTry={() =>
+            onTryExample(
+              `SELECT run_id, task_identifier, status
+FROM runs
+LIMIT 10`,
+              "environment"
+            )
+          }
+        />
+        <Paragraph variant="small" className="mt-3 text-text-dimmed">
+          Alias columns with <code className="text-xs">AS</code>:
+        </Paragraph>
+        <TryableCodeBlock
+          code={`SELECT task_identifier AS task, count() AS total
+FROM runs
+GROUP BY task`}
+          onTry={() =>
+            onTryExample(
+              `SELECT task_identifier AS task, count() AS total
+FROM runs
+GROUP BY task`,
+              "environment"
+            )
+          }
+          className="mt-1"
+        />
+      </section>
+
+      {/* Filtering */}
+      <section id="filtering">
+        <Header3 className="mb-2 text-text-bright">Filtering with WHERE</Header3>
+        <Paragraph variant="small" className="mb-2 text-text-dimmed">
+          Use comparison operators: <code className="text-xs">=</code>,{" "}
+          <code className="text-xs">!=</code>, <code className="text-xs">&lt;</code>,{" "}
+          <code className="text-xs">&gt;</code>, <code className="text-xs">&lt;=</code>,{" "}
+          <code className="text-xs">&gt;=</code>
+        </Paragraph>
+        <TryableCodeBlock
+          code={`SELECT * FROM runs
+WHERE status = 'Failed'
+  AND created_at > now() - INTERVAL 1 DAY`}
+          onTry={() =>
+            onTryExample(
+              `SELECT * FROM runs
+WHERE status = 'Failed'
+  AND created_at > now() - INTERVAL 1 DAY`,
+              "environment"
+            )
+          }
+        />
+        <Paragraph variant="small" className="mt-3 text-text-dimmed">
+          Other operators:
+        </Paragraph>
+        <TryableCodeBlock
+          code={`-- IN for multiple values
+WHERE status IN ('Failed', 'Crashed')
+
+-- LIKE for pattern matching (% = wildcard)
+WHERE task_identifier LIKE 'email%'
+
+-- ILIKE for case-insensitive matching
+WHERE task_identifier ILIKE '%send%'
+
+-- BETWEEN for ranges
+WHERE created_at BETWEEN '2024-01-01' AND '2024-01-31'
+
+-- NULL checks
+WHERE completed_at IS NOT NULL`}
+          className="mt-1"
+        />
+      </section>
+
+      {/* Sorting & limiting */}
+      <section id="sorting">
+        <Header3 className="mb-2 text-text-bright">Sorting &amp; limiting</Header3>
+        <Paragraph variant="small" className="mb-2 text-text-dimmed">
+          Sort results with <code className="text-xs">ORDER BY</code> (ASC/DESC). Limit results with{" "}
+          <code className="text-xs">LIMIT</code>.
+        </Paragraph>
+        <TryableCodeBlock
+          code={`SELECT run_id, compute_cost, created_at
+FROM runs
+ORDER BY compute_cost DESC, created_at ASC
+LIMIT 50`}
+          onTry={() =>
+            onTryExample(
+              `SELECT run_id, compute_cost, created_at
+FROM runs
+ORDER BY compute_cost DESC, created_at ASC
+LIMIT 50`,
+              "environment"
+            )
+          }
+        />
+      </section>
+
+      {/* Grouping */}
+      <section id="grouping">
+        <Header3 className="mb-2 text-text-bright">Grouping &amp; aggregation</Header3>
+        <Paragraph variant="small" className="mb-2 text-text-dimmed">
+          Use <code className="text-xs">GROUP BY</code> with aggregate functions. Filter groups with{" "}
+          <code className="text-xs">HAVING</code>.
+        </Paragraph>
+        <TryableCodeBlock
+          code={`SELECT
+  task_identifier,
+  status,
+  count() AS run_count,
+  avg(usage_duration) AS avg_duration
+FROM runs
+GROUP BY task_identifier, status
+HAVING run_count > 10
+ORDER BY run_count DESC`}
+          onTry={() =>
+            onTryExample(
+              `SELECT
+  task_identifier,
+  status,
+  count() AS run_count,
+  avg(usage_duration) AS avg_duration
+FROM runs
+GROUP BY task_identifier, status
+HAVING run_count > 10
+ORDER BY run_count DESC`,
+              "environment"
+            )
+          }
+        />
+      </section>
+
+      {/* Functions */}
+      <section id="functions">
+        <Header3 className="mb-2 text-text-bright">Available functions</Header3>
+        <Paragraph variant="extra-small" className="mb-3 text-text-dimmed">
+          Hover over any function to see its description and example usage.
+        </Paragraph>
+
+        <div className="space-y-4">
+          {/* Aggregate functions */}
+          <FunctionCategory
+            title="Aggregate functions"
+            functions={[
+              { name: "count()", desc: "Count rows", example: "count()" },
+              {
+                name: "countIf(col, cond)",
+                desc: "Count rows matching condition",
+                example: "countIf(status, status = 'Failed')",
+              },
+              {
+                name: "countDistinct(col)",
+                desc: "Count unique values",
+                example: "countDistinct(task_identifier)",
+              },
+              { name: "sum(col)", desc: "Sum of values", example: "sum(compute_cost)" },
+              {
+                name: "sumIf(col, cond)",
+                desc: "Sum values matching condition",
+                example: "sumIf(compute_cost, status = 'Completed')",
+              },
+              { name: "avg(col)", desc: "Average of values", example: "avg(usage_duration)" },
+              { name: "min(col)", desc: "Minimum value", example: "min(created_at)" },
+              { name: "max(col)", desc: "Maximum value", example: "max(compute_cost)" },
+              {
+                name: "uniq(col)",
+                desc: "Approximate unique count (fast)",
+                example: "uniq(task_identifier)",
+              },
+              { name: "uniqExact(col)", desc: "Exact unique count", example: "uniqExact(run_id)" },
+              {
+                name: "any(col)",
+                desc: "Any arbitrary value from group",
+                example: "any(task_identifier)",
+              },
+              {
+                name: "anyLast(col)",
+                desc: "Last value encountered in group",
+                example: "anyLast(status)",
+              },
+              {
+                name: "argMin(arg, val)",
+                desc: "Value of arg at minimum val",
+                example: "argMin(run_id, created_at)",
+              },
+              {
+                name: "argMax(arg, val)",
+                desc: "Value of arg at maximum val",
+                example: "argMax(run_id, compute_cost)",
+              },
+              {
+                name: "median(col)",
+                desc: "Median value (50th percentile)",
+                example: "median(usage_duration)",
+              },
+              {
+                name: "quantile(p)(col)",
+                desc: "Value at percentile p (0-1)",
+                example: "quantile(0.95)(usage_duration)",
+              },
+              {
+                name: "stddevPop(col)",
+                desc: "Population standard deviation",
+                example: "stddevPop(usage_duration)",
+              },
+              {
+                name: "stddevSamp(col)",
+                desc: "Sample standard deviation",
+                example: "stddevSamp(usage_duration)",
+              },
+              {
+                name: "groupArray(col)",
+                desc: "Collect values into array",
+                example: "groupArray(run_id)",
+              },
+              {
+                name: "groupUniqArray(col)",
+                desc: "Collect unique values into array",
+                example: "groupUniqArray(status)",
+              },
+              {
+                name: "topK(k)(col)",
+                desc: "Top k most frequent values",
+                example: "topK(5)(task_identifier)",
+              },
+            ]}
+          />
+
+          {/* String functions */}
+          <FunctionCategory
+            title="String functions"
+            functions={[
+              {
+                name: "length(s)",
+                desc: "Length of string in bytes",
+                example: "length(task_identifier)",
+              },
+              {
+                name: "lengthUTF8(s)",
+                desc: "Length in UTF-8 characters",
+                example: "lengthUTF8(task_identifier)",
+              },
+              { name: "empty(s)", desc: "Returns 1 if string is empty", example: "empty(error)" },
+              {
+                name: "notEmpty(s)",
+                desc: "Returns 1 if string is not empty",
+                example: "notEmpty(task_identifier)",
+              },
+              { name: "lower(s)", desc: "Convert to lowercase", example: "lower(status)" },
+              { name: "upper(s)", desc: "Convert to uppercase", example: "upper(status)" },
+              { name: "reverse(s)", desc: "Reverse string", example: "reverse(run_id)" },
+              {
+                name: "concat(s1, s2, ...)",
+                desc: "Concatenate strings",
+                example: "concat(task_identifier, '-', status)",
+              },
+              {
+                name: "substring(s, offset, len)",
+                desc: "Extract substring (1-indexed)",
+                example: "substring(run_id, 1, 10)",
+              },
+              { name: "left(s, n)", desc: "First n characters", example: "left(run_id, 10)" },
+              { name: "right(s, n)", desc: "Last n characters", example: "right(run_id, 8)" },
+              {
+                name: "trim(s)",
+                desc: "Remove leading/trailing whitespace",
+                example: "trim(task_identifier)",
+              },
+              {
+                name: "trimLeft(s)",
+                desc: "Remove leading whitespace",
+                example: "trimLeft(task_identifier)",
+              },
+              {
+                name: "trimRight(s)",
+                desc: "Remove trailing whitespace",
+                example: "trimRight(task_identifier)",
+              },
+              {
+                name: "leftPad(s, len, char)",
+                desc: "Pad string on left",
+                example: "leftPad(toString(attempt), 3, '0')",
+              },
+              {
+                name: "rightPad(s, len, char)",
+                desc: "Pad string on right",
+                example: "rightPad(status, 15, ' ')",
+              },
+              {
+                name: "startsWith(s, prefix)",
+                desc: "Check if starts with prefix",
+                example: "startsWith(task_identifier, 'email')",
+              },
+              {
+                name: "endsWith(s, suffix)",
+                desc: "Check if ends with suffix",
+                example: "endsWith(run_id, 'abc')",
+              },
+              {
+                name: "position(haystack, needle)",
+                desc: "Position of substring (0 if not found)",
+                example: "position(task_identifier, 'send')",
+              },
+              {
+                name: "replace(s, from, to)",
+                desc: "Replace all occurrences",
+                example: "replace(status, '_', '-')",
+              },
+              {
+                name: "replaceOne(s, from, to)",
+                desc: "Replace first occurrence",
+                example: "replaceOne(task_identifier, '-', '_')",
+              },
+              {
+                name: "replaceRegexpAll(s, pattern, repl)",
+                desc: "Replace using regex",
+                example: "replaceRegexpAll(run_id, '[0-9]', 'X')",
+              },
+              {
+                name: "match(s, pattern)",
+                desc: "Regex match (returns 0 or 1)",
+                example: "match(task_identifier, '^email.*')",
+              },
+              {
+                name: "extract(s, pattern)",
+                desc: "Extract first regex match",
+                example: "extract(task_identifier, '[a-z]+')",
+              },
+              {
+                name: "extractAll(s, pattern)",
+                desc: "Extract all regex matches as array",
+                example: "extractAll(task_identifier, '[a-z]+')",
+              },
+              {
+                name: "like(s, pattern)",
+                desc: "SQL LIKE pattern match",
+                example: "like(task_identifier, '%email%')",
+              },
+              {
+                name: "ilike(s, pattern)",
+                desc: "Case-insensitive LIKE",
+                example: "ilike(task_identifier, '%EMAIL%')",
+              },
+              {
+                name: "splitByChar(sep, s)",
+                desc: "Split by character",
+                example: "splitByChar('-', task_identifier)",
+              },
+              {
+                name: "splitByString(sep, s)",
+                desc: "Split by string",
+                example: "splitByString('::', task_identifier)",
+              },
+              {
+                name: "arrayStringConcat(arr, sep)",
+                desc: "Join array to string",
+                example: "arrayStringConcat(tags, ', ')",
+              },
+              {
+                name: "base64Encode(s)",
+                desc: "Encode to base64",
+                example: "base64Encode(run_id)",
+              },
+              {
+                name: "base64Decode(s)",
+                desc: "Decode from base64",
+                example: "base64Decode(encoded_value)",
+              },
+              { name: "repeat(s, n)", desc: "Repeat string n times", example: "repeat('-', 10)" },
+              {
+                name: "format(pattern, args...)",
+                desc: "Format string with placeholders",
+                example: "format('{} - {}', task_identifier, status)",
+              },
+            ]}
+          />
+
+          {/* Date/time functions */}
+          <FunctionCategory
+            title="Date/time functions"
+            functions={[
+              {
+                name: "timeBucket()",
+                desc: "Auto-bucket by time period. Uses the table's time column with an interval based on the query's time range.",
+                example: "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket",
+              },
+              { name: "now()", desc: "Current date and time", example: "now()" },
+              { name: "today()", desc: "Current date", example: "today()" },
+              { name: "yesterday()", desc: "Yesterday's date", example: "yesterday()" },
+              { name: "toYear(dt)", desc: "Extract year", example: "toYear(created_at)" },
+              {
+                name: "toQuarter(dt)",
+                desc: "Extract quarter (1-4)",
+                example: "toQuarter(created_at)",
+              },
+              { name: "toMonth(dt)", desc: "Extract month (1-12)", example: "toMonth(created_at)" },
+              {
+                name: "toDayOfMonth(dt)",
+                desc: "Extract day of month (1-31)",
+                example: "toDayOfMonth(created_at)",
+              },
+              {
+                name: "toDayOfWeek(dt)",
+                desc: "Day of week (1=Monday, 7=Sunday)",
+                example: "toDayOfWeek(created_at)",
+              },
+              { name: "toHour(dt)", desc: "Extract hour (0-23)", example: "toHour(created_at)" },
+              {
+                name: "toMinute(dt)",
+                desc: "Extract minute (0-59)",
+                example: "toMinute(created_at)",
+              },
+              {
+                name: "toSecond(dt)",
+                desc: "Extract second (0-59)",
+                example: "toSecond(created_at)",
+              },
+              {
+                name: "toDate(dt)",
+                desc: "Convert to date (strip time)",
+                example: "toDate(created_at)",
+              },
+              {
+                name: "toDateTime(x)",
+                desc: "Convert to datetime",
+                example: "toDateTime('2024-01-15 10:30:00')",
+              },
+              {
+                name: "toStartOfYear(dt)",
+                desc: "First day of year",
+                example: "toStartOfYear(created_at)",
+              },
+              {
+                name: "toStartOfQuarter(dt)",
+                desc: "First day of quarter",
+                example: "toStartOfQuarter(created_at)",
+              },
+              {
+                name: "toStartOfMonth(dt)",
+                desc: "First day of month",
+                example: "toStartOfMonth(created_at)",
+              },
+              {
+                name: "toStartOfWeek(dt)",
+                desc: "Start of week (Monday)",
+                example: "toStartOfWeek(created_at)",
+              },
+              { name: "toMonday(dt)", desc: "Monday of the week", example: "toMonday(created_at)" },
+              {
+                name: "toStartOfDay(dt)",
+                desc: "Start of day (midnight)",
+                example: "toStartOfDay(created_at)",
+              },
+              {
+                name: "toStartOfHour(dt)",
+                desc: "Start of hour",
+                example: "toStartOfHour(created_at)",
+              },
+              {
+                name: "toStartOfMinute(dt)",
+                desc: "Start of minute",
+                example: "toStartOfMinute(created_at)",
+              },
+              {
+                name: "toStartOfFiveMinutes(dt)",
+                desc: "Round to 5-minute interval",
+                example: "toStartOfFiveMinutes(created_at)",
+              },
+              {
+                name: "toStartOfFifteenMinutes(dt)",
+                desc: "Round to 15-minute interval",
+                example: "toStartOfFifteenMinutes(created_at)",
+              },
+              {
+                name: "toStartOfInterval(dt, INTERVAL n unit)",
+                desc: "Round to custom interval",
+                example: "toStartOfInterval(created_at, INTERVAL 30 MINUTE)",
+              },
+              {
+                name: "toUnixTimestamp(dt)",
+                desc: "Convert to Unix timestamp",
+                example: "toUnixTimestamp(created_at)",
+              },
+              {
+                name: "dateDiff(unit, start, end)",
+                desc: "Difference between dates",
+                example: "dateDiff('minute', started_at, completed_at)",
+              },
+              {
+                name: "dateAdd(unit, n, dt)",
+                desc: "Add time to date",
+                example: "dateAdd('day', 7, created_at)",
+              },
+              {
+                name: "dateSub(unit, n, dt)",
+                desc: "Subtract time from date",
+                example: "dateSub('hour', 1, created_at)",
+              },
+              {
+                name: "dateTrunc(unit, dt)",
+                desc: "Truncate to unit",
+                example: "dateTrunc('month', created_at)",
+              },
+              { name: "addDays(dt, n)", desc: "Add n days", example: "addDays(created_at, 7)" },
+              { name: "addHours(dt, n)", desc: "Add n hours", example: "addHours(created_at, 24)" },
+              {
+                name: "addMinutes(dt, n)",
+                desc: "Add n minutes",
+                example: "addMinutes(created_at, 30)",
+              },
+              {
+                name: "subtractDays(dt, n)",
+                desc: "Subtract n days",
+                example: "subtractDays(now(), 7)",
+              },
+              {
+                name: "subtractHours(dt, n)",
+                desc: "Subtract n hours",
+                example: "subtractHours(now(), 1)",
+              },
+              {
+                name: "formatDateTime(dt, format)",
+                desc: "Format datetime as string",
+                example: "formatDateTime(created_at, '%Y-%m-%d %H:%M')",
+              },
+              {
+                name: "parseDateTimeBestEffort(s)",
+                desc: "Parse string to datetime",
+                example: "parseDateTimeBestEffort('2024-01-15')",
+              },
+              {
+                name: "toTimeZone(dt, tz)",
+                desc: "Convert to timezone",
+                example: "toTimeZone(created_at, 'America/New_York')",
+              },
+            ]}
+          />
+
+          {/* Conditional & null functions */}
+          <FunctionCategory
+            title="Conditional & null functions"
+            functions={[
+              {
+                name: "if(cond, then, else)",
+                desc: "Conditional expression",
+                example: "if(status = 'Failed', 1, 0)",
+              },
+              {
+                name: "multiIf(c1, t1, c2, t2, ..., else)",
+                desc: "Multiple conditions (like CASE)",
+                example: "multiIf(status = 'Completed', 'ok', status = 'Failed', 'bad', 'other')",
+              },
+              {
+                name: "coalesce(a, b, ...)",
+                desc: "First non-null value",
+                example: "coalesce(completed_at, created_at)",
+              },
+              {
+                name: "ifNull(x, alt)",
+                desc: "Return alt if x is null",
+                example: "ifNull(completed_at, now())",
+              },
+              {
+                name: "nullIf(x, y)",
+                desc: "Return null if x equals y",
+                example: "nullIf(status, 'Pending')",
+              },
+              {
+                name: "isNull(x)",
+                desc: "Check if value is null",
+                example: "isNull(completed_at)",
+              },
+              {
+                name: "isNotNull(x)",
+                desc: "Check if value is not null",
+                example: "isNotNull(completed_at)",
+              },
+              {
+                name: "assumeNotNull(x)",
+                desc: "Treat nullable as non-null",
+                example: "assumeNotNull(completed_at)",
+              },
+            ]}
+          />
+
+          {/* Arithmetic & math */}
+          <FunctionCategory
+            title="Arithmetic & math functions"
+            functions={[
+              {
+                name: "plus(a, b)",
+                desc: "Addition (a + b)",
+                example: "plus(compute_cost, invocation_cost)",
+              },
+              {
+                name: "minus(a, b)",
+                desc: "Subtraction (a - b)",
+                example: "minus(completed_at, started_at)",
+              },
+              {
+                name: "multiply(a, b)",
+                desc: "Multiplication (a * b)",
+                example: "multiply(usage_duration, 2)",
+              },
+              {
+                name: "divide(a, b)",
+                desc: "Division (a / b)",
+                example: "divide(compute_cost, usage_duration)",
+              },
+              {
+                name: "intDiv(a, b)",
+                desc: "Integer division",
+                example: "intDiv(usage_duration, 1000)",
+              },
+              { name: "modulo(a, b)", desc: "Modulo (a % b)", example: "modulo(attempt, 2)" },
+              { name: "abs(x)", desc: "Absolute value", example: "abs(compute_cost)" },
+              { name: "sign(x)", desc: "Sign (-1, 0, or 1)", example: "sign(compute_cost)" },
+              { name: "sqrt(x)", desc: "Square root", example: "sqrt(usage_duration)" },
+              { name: "pow(x, y)", desc: "Power (x^y)", example: "pow(2, attempt)" },
+              {
+                name: "round(x, n)",
+                desc: "Round to n decimal places",
+                example: "round(compute_cost, 4)",
+              },
+              { name: "floor(x)", desc: "Round down", example: "floor(compute_cost * 100)" },
+              { name: "ceil(x)", desc: "Round up", example: "ceil(compute_cost * 100)" },
+              { name: "trunc(x)", desc: "Truncate towards zero", example: "trunc(compute_cost)" },
+              { name: "exp(x)", desc: "Exponential (e^x)", example: "exp(1)" },
+              { name: "log(x)", desc: "Natural logarithm", example: "log(usage_duration)" },
+              { name: "log10(x)", desc: "Base-10 logarithm", example: "log10(usage_duration)" },
+              {
+                name: "least(a, b)",
+                desc: "Minimum of two values",
+                example: "least(usage_duration, 10000)",
+              },
+              {
+                name: "greatest(a, b)",
+                desc: "Maximum of two values",
+                example: "greatest(usage_duration, 0)",
+              },
+            ]}
+          />
+
+          {/* Array functions */}
+          <FunctionCategory
+            title="Array functions"
+            functions={[
+              {
+                name: "array(a, b, ...)",
+                desc: "Create array from values",
+                example: "array('a', 'b', 'c')",
+              },
+              {
+                name: "range(start, end)",
+                desc: "Generate array of numbers",
+                example: "range(1, 10)",
+              },
+              { name: "length(arr)", desc: "Number of elements", example: "length(tags)" },
+              { name: "empty(arr)", desc: "Check if array is empty", example: "empty(tags)" },
+              {
+                name: "has(arr, elem)",
+                desc: "Check if array contains element",
+                example: "has(tags, 'important')",
+              },
+              {
+                name: "hasAll(arr1, arr2)",
+                desc: "Check if arr1 contains all of arr2",
+                example: "hasAll(tags, array('a', 'b'))",
+              },
+              {
+                name: "hasAny(arr1, arr2)",
+                desc: "Check if arr1 contains any of arr2",
+                example: "hasAny(tags, array('urgent', 'high'))",
+              },
+              {
+                name: "indexOf(arr, elem)",
+                desc: "Index of element (1-based, 0 if not found)",
+                example: "indexOf(tags, 'important')",
+              },
+              {
+                name: "arrayElement(arr, n)",
+                desc: "Get nth element (1-based)",
+                example: "arrayElement(tags, 1)",
+              },
+              { name: "arrayJoin(arr)", desc: "Expand array to rows", example: "arrayJoin(tags)" },
+              {
+                name: "arraySlice(arr, offset, length)",
+                desc: "Get slice of array",
+                example: "arraySlice(tags, 1, 3)",
+              },
+              {
+                name: "arrayPushBack(arr, elem)",
+                desc: "Append element to array",
+                example: "arrayPushBack(tags, 'new')",
+              },
+              {
+                name: "arrayPushFront(arr, elem)",
+                desc: "Prepend element to array",
+                example: "arrayPushFront(tags, 'first')",
+              },
+              { name: "arraySort(arr)", desc: "Sort array ascending", example: "arraySort(tags)" },
+              {
+                name: "arrayReverseSort(arr)",
+                desc: "Sort array descending",
+                example: "arrayReverseSort(tags)",
+              },
+              {
+                name: "arrayReverse(arr)",
+                desc: "Reverse array order",
+                example: "arrayReverse(tags)",
+              },
+              { name: "arrayUniq(arr)", desc: "Remove duplicates", example: "arrayUniq(tags)" },
+              {
+                name: "arrayDistinct(arr)",
+                desc: "Remove duplicates (preserves order)",
+                example: "arrayDistinct(tags)",
+              },
+              {
+                name: "arrayFlatten(arr)",
+                desc: "Flatten nested arrays",
+                example: "arrayFlatten([[1,2], [3,4]])",
+              },
+              {
+                name: "arrayFilter(func, arr)",
+                desc: "Filter array by condition",
+                example: "arrayFilter(x -> x > 0, arr)",
+              },
+              {
+                name: "arrayMap(func, arr)",
+                desc: "Transform each element",
+                example: "arrayMap(x -> x * 2, arr)",
+              },
+              {
+                name: "arrayMin(arr)",
+                desc: "Minimum element",
+                example: "arrayMin(array(1, 2, 3))",
+              },
+              {
+                name: "arrayMax(arr)",
+                desc: "Maximum element",
+                example: "arrayMax(array(1, 2, 3))",
+              },
+              {
+                name: "arraySum(arr)",
+                desc: "Sum of elements",
+                example: "arraySum(array(1, 2, 3))",
+              },
+              {
+                name: "arrayAvg(arr)",
+                desc: "Average of elements",
+                example: "arrayAvg(array(1, 2, 3))",
+              },
+            ]}
+          />
+
+          {/* JSON functions */}
+          <FunctionCategory
+            title="JSON functions"
+            functions={[
+              {
+                name: "JSONHas(json, key)",
+                desc: "Check if key exists",
+                example: "JSONHas(output, 'result')",
+              },
+              {
+                name: "JSONLength(json)",
+                desc: "Number of elements/keys",
+                example: "JSONLength(output)",
+              },
+              {
+                name: "JSONType(json, key)",
+                desc: "Type of JSON value",
+                example: "JSONType(output, 'data')",
+              },
+              {
+                name: "JSONExtractString(json, key)",
+                desc: "Extract as string",
+                example: "JSONExtractString(output, 'message')",
+              },
+              {
+                name: "JSONExtractInt(json, key)",
+                desc: "Extract as integer",
+                example: "JSONExtractInt(output, 'count')",
+              },
+              {
+                name: "JSONExtractFloat(json, key)",
+                desc: "Extract as float",
+                example: "JSONExtractFloat(output, 'score')",
+              },
+              {
+                name: "JSONExtractBool(json, key)",
+                desc: "Extract as boolean",
+                example: "JSONExtractBool(output, 'success')",
+              },
+              {
+                name: "JSONExtractRaw(json, key)",
+                desc: "Extract as raw JSON string",
+                example: "JSONExtractRaw(output, 'data')",
+              },
+              {
+                name: "JSONExtractArrayRaw(json, key)",
+                desc: "Extract array as strings",
+                example: "JSONExtractArrayRaw(output, 'items')",
+              },
+              {
+                name: "JSONExtractKeys(json)",
+                desc: "Get all keys as array",
+                example: "JSONExtractKeys(output)",
+              },
+              {
+                name: "toJSONString(value)",
+                desc: "Convert to JSON string",
+                example: "toJSONString(map('a', 1))",
+              },
+            ]}
+          />
+
+          {/* Type conversion */}
+          <FunctionCategory
+            title="Type conversion functions"
+            functions={[
+              { name: "toString(x)", desc: "Convert to string", example: "toString(attempt)" },
+              { name: "toInt32(x)", desc: "Convert to 32-bit integer", example: "toInt32('123')" },
+              {
+                name: "toInt64(x)",
+                desc: "Convert to 64-bit integer",
+                example: "toInt64(usage_duration)",
+              },
+              {
+                name: "toFloat64(x)",
+                desc: "Convert to 64-bit float",
+                example: "toFloat64('3.14')",
+              },
+              {
+                name: "toDecimal64(x, scale)",
+                desc: "Convert to decimal",
+                example: "toDecimal64(compute_cost, 6)",
+              },
+              { name: "toDate(x)", desc: "Convert to date", example: "toDate('2024-01-15')" },
+              {
+                name: "toDateOrNull(x)",
+                desc: "Convert to date (null on error)",
+                example: "toDateOrNull(some_string)",
+              },
+              {
+                name: "toDateTime(x)",
+                desc: "Convert to datetime",
+                example: "toDateTime('2024-01-15 10:30:00')",
+              },
+              {
+                name: "toDateTimeOrNull(x)",
+                desc: "Convert to datetime (null on error)",
+                example: "toDateTimeOrNull(some_string)",
+              },
+              { name: "toUUID(x)", desc: "Convert to UUID", example: "toUUID(uuid_string)" },
+              {
+                name: "toTypeName(x)",
+                desc: "Get type name as string",
+                example: "toTypeName(created_at)",
+              },
+            ]}
+          />
+
+          {/* Comparison & logical */}
+          <FunctionCategory
+            title="Comparison & logical functions"
+            functions={[
+              {
+                name: "equals(a, b)",
+                desc: "Equal (a = b)",
+                example: "equals(status, 'Completed')",
+              },
+              {
+                name: "notEquals(a, b)",
+                desc: "Not equal (a != b)",
+                example: "notEquals(status, 'Failed')",
+              },
+              { name: "less(a, b)", desc: "Less than (a < b)", example: "less(attempt, 3)" },
+              {
+                name: "greater(a, b)",
+                desc: "Greater than (a > b)",
+                example: "greater(usage_duration, 1000)",
+              },
+              {
+                name: "lessOrEquals(a, b)",
+                desc: "Less than or equal (a <= b)",
+                example: "lessOrEquals(attempt, 5)",
+              },
+              {
+                name: "greaterOrEquals(a, b)",
+                desc: "Greater than or equal (a >= b)",
+                example: "greaterOrEquals(usage_duration, 0)",
+              },
+              {
+                name: "and(a, b, ...)",
+                desc: "Logical AND",
+                example: "and(status = 'Failed', attempt > 1)",
+              },
+              {
+                name: "or(a, b, ...)",
+                desc: "Logical OR",
+                example: "or(status = 'Failed', status = 'Crashed')",
+              },
+              { name: "not(x)", desc: "Logical NOT", example: "not(is_test)" },
+              {
+                name: "in(x, set)",
+                desc: "Check if x is in set",
+                example: "in(status, ('Failed', 'Crashed'))",
+              },
+            ]}
+          />
+
+          {/* Hash functions */}
+          <FunctionCategory
+            title="Hash functions"
+            functions={[
+              { name: "MD5(s)", desc: "MD5 hash (16 bytes)", example: "hex(MD5(run_id))" },
+              {
+                name: "SHA256(s)",
+                desc: "SHA-256 hash (32 bytes)",
+                example: "hex(SHA256(run_id))",
+              },
+              {
+                name: "sipHash64(s)",
+                desc: "Fast 64-bit hash",
+                example: "sipHash64(task_identifier)",
+              },
+              { name: "cityHash64(s)", desc: "CityHash 64-bit", example: "cityHash64(run_id)" },
+              { name: "xxHash64(s)", desc: "xxHash 64-bit", example: "xxHash64(task_identifier)" },
+              { name: "hex(s)", desc: "Convert to hex string", example: "hex(MD5(run_id))" },
+              { name: "unhex(s)", desc: "Convert from hex string", example: "unhex('48656C6C6F')" },
+            ]}
+          />
+
+          {/* UUID & utility */}
+          <FunctionCategory
+            title="UUID & utility functions"
+            functions={[
+              {
+                name: "generateUUIDv4()",
+                desc: "Generate random UUID",
+                example: "generateUUIDv4()",
+              },
+              {
+                name: "isFinite(x)",
+                desc: "Check if number is finite",
+                example: "isFinite(compute_cost)",
+              },
+              { name: "isNaN(x)", desc: "Check if value is NaN", example: "isNaN(compute_cost)" },
+              {
+                name: "formatReadableSize(bytes)",
+                desc: "Format bytes as human-readable",
+                example: "formatReadableSize(1024)",
+              },
+              {
+                name: "formatReadableQuantity(n)",
+                desc: "Format number with suffixes (K, M, etc)",
+                example: "formatReadableQuantity(1500000)",
+              },
+              {
+                name: "formatReadableTimeDelta(seconds)",
+                desc: "Format seconds as duration",
+                example: "formatReadableTimeDelta(3661)",
+              },
+              {
+                name: "runningDifference(col)",
+                desc: "Difference from previous row",
+                example: "runningDifference(usage_duration)",
+              },
+              {
+                name: "neighbor(col, offset)",
+                desc: "Value from row at offset",
+                example: "neighbor(created_at, -1)",
+              },
+            ]}
+          />
+
+          {/* Tuple & map functions */}
+          <FunctionCategory
+            title="Tuple & map functions"
+            functions={[
+              {
+                name: "tuple(a, b, ...)",
+                desc: "Create tuple",
+                example: "tuple(task_identifier, status)",
+              },
+              {
+                name: "tupleElement(tuple, n)",
+                desc: "Get nth element (1-based)",
+                example: "tupleElement(t, 1)",
+              },
+              {
+                name: "map(k1, v1, k2, v2, ...)",
+                desc: "Create map from key-value pairs",
+                example: "map('a', 1, 'b', 2)",
+              },
+              {
+                name: "mapFromArrays(keys, values)",
+                desc: "Create map from two arrays",
+                example: "mapFromArrays(['a', 'b'], [1, 2])",
+              },
+              {
+                name: "mapContains(map, key)",
+                desc: "Check if map has key",
+                example: "mapContains(m, 'key')",
+              },
+              { name: "mapKeys(map)", desc: "Get all keys as array", example: "mapKeys(m)" },
+              { name: "mapValues(map)", desc: "Get all values as array", example: "mapValues(m)" },
+            ]}
+          />
+
+          {/* Window functions */}
+          <FunctionCategory
+            title="Window functions"
+            functions={[
+              {
+                name: "row_number()",
+                desc: "Row number within partition",
+                example: "row_number() OVER (ORDER BY created_at)",
+              },
+              {
+                name: "rank()",
+                desc: "Rank with gaps for ties",
+                example: "rank() OVER (ORDER BY compute_cost DESC)",
+              },
+              {
+                name: "dense_rank()",
+                desc: "Rank without gaps",
+                example: "dense_rank() OVER (ORDER BY compute_cost DESC)",
+              },
+              {
+                name: "first_value(col)",
+                desc: "First value in window",
+                example: "first_value(status) OVER (PARTITION BY task_identifier)",
+              },
+              {
+                name: "last_value(col)",
+                desc: "Last value in window",
+                example: "last_value(status) OVER (PARTITION BY task_identifier)",
+              },
+              {
+                name: "lag(col, offset, default)",
+                desc: "Value from previous row",
+                example: "lag(created_at, 1) OVER (ORDER BY created_at)",
+              },
+              {
+                name: "lead(col, offset, default)",
+                desc: "Value from next row",
+                example: "lead(created_at, 1) OVER (ORDER BY created_at)",
+              },
+            ]}
+          />
+
+          {/* Interval functions */}
+          <FunctionCategory
+            title="Interval functions"
+            functions={[
+              {
+                name: "toIntervalSecond(n)",
+                desc: "Create n-second interval",
+                example: "toIntervalSecond(30)",
+              },
+              {
+                name: "toIntervalMinute(n)",
+                desc: "Create n-minute interval",
+                example: "toIntervalMinute(5)",
+              },
+              {
+                name: "toIntervalHour(n)",
+                desc: "Create n-hour interval",
+                example: "toIntervalHour(1)",
+              },
+              {
+                name: "toIntervalDay(n)",
+                desc: "Create n-day interval",
+                example: "toIntervalDay(7)",
+              },
+              {
+                name: "toIntervalWeek(n)",
+                desc: "Create n-week interval",
+                example: "toIntervalWeek(2)",
+              },
+              {
+                name: "toIntervalMonth(n)",
+                desc: "Create n-month interval",
+                example: "toIntervalMonth(1)",
+              },
+              {
+                name: "toIntervalYear(n)",
+                desc: "Create n-year interval",
+                example: "toIntervalYear(1)",
+              },
+            ]}
+          />
+        </div>
+      </section>
+    </div>
+  );
+}
+
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TableSchemaContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TableSchemaContent.tsx
new file mode 100644
index 00000000000..41c17e6d3f7
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/TableSchemaContent.tsx
@@ -0,0 +1,80 @@
+import { useState } from "react";
+import type { ColumnSchema } from "@internal/tsql";
+import { Badge } from "~/components/primitives/Badge";
+import { CopyableText } from "~/components/primitives/CopyableText";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import SegmentedControl from "~/components/primitives/SegmentedControl";
+import { querySchemas } from "~/v3/querySchemas";
+
+function ColumnHelpItem({ col }: { col: ColumnSchema }) {
+  return (
+    <div className="pt-1">
+      <div className="flex items-center gap-2">
+        <CopyableText value={col.name} className="text-sm text-indigo-400" />
+        <Badge className="font-mono text-xxs">{col.type}</Badge>
+      </div>
+      {col.description && (
+        <Paragraph variant="extra-small" className="mt-1 text-text-dimmed">
+          {col.description}
+        </Paragraph>
+      )}
+      {col.example && (
+        <div className="mt-1 flex items-baseline gap-0.5">
+          <span className="text-xs text-text-dimmed">Example:</span>
+          <CopyableText
+            value={col.example}
+            className="rounded-sm bg-charcoal-750 px-1.5 py-0.5 font-mono text-xxs"
+          />
+        </div>
+      )}
+      {col.allowedValues && col.allowedValues.length > 0 && (
+        <div className="mt-0.5 flex flex-wrap gap-1">
+          <span className="text-xs text-text-dimmed">Available options:</span>
+          {col.allowedValues.map((value) => (
+            <CopyableText
+              key={value}
+              value={col.valueMap?.[value] ?? value}
+              className="rounded-sm bg-charcoal-750 px-1.5 py-0.5 font-mono text-xxs"
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+const tableOptions = querySchemas.map((s) => ({ label: s.name, value: s.name }));
+
+export function TableSchemaContent() {
+  const [selectedTable, setSelectedTable] = useState(querySchemas[0].name);
+  const table = querySchemas.find((s) => s.name === selectedTable) ?? querySchemas[0];
+
+  return (
+    <div>
+      <div className="sticky top-0 z-10 bg-background-bright pb-3">
+        <SegmentedControl
+          name="table-schema-selector"
+          value={selectedTable}
+          options={tableOptions}
+          variant="secondary/small"
+          fullWidth
+          onChange={setSelectedTable}
+        />
+      </div>
+      <div className="mb-2">
+        {table.description && (
+          <Paragraph variant="small" className="text-text-dimmed">
+            {table.description}
+          </Paragraph>
+        )}
+      </div>
+      <div className="flex flex-col gap-2 divide-y divide-grid-dimmed">
+        {Object.values(table.columns).map((col) => (
+          <ColumnHelpItem key={col.name} col={col} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/route.tsx
new file mode 100644
index 00000000000..848546a518f
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/route.tsx
@@ -0,0 +1,295 @@
+import {
+  redirect,
+  type ActionFunctionArgs,
+  type LoaderFunctionArgs,
+} from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { QueryEditor } from "~/components/query/QueryEditor";
+import { env } from "~/env.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { QueryPresenter } from "~/presenters/v3/QueryPresenter.server";
+import { executeQuery, getDefaultPeriod } from "~/services/queryService.server";
+import { requireUser } from "~/services/session.server";
+import { EnvironmentParamSchema, queryPath } from "~/utils/pathBuilder";
+import { canAccessQuery } from "~/v3/canAccessQuery.server";
+import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useEnvironment } from "~/hooks/useEnvironment";
+
+/** Convert a Date or ISO string to ISO string format */
+function toISOString(value: Date | string): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.toISOString();
+}
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const canAccess = await canAccessQuery({
+    userId: user.id,
+    isAdmin: user.admin,
+    isImpersonating: user.isImpersonating,
+    organizationSlug,
+  });
+  if (!canAccess) {
+    throw redirect("/");
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
+  if (!project) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Project not found",
+    });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Environment not found",
+    });
+  }
+
+  const presenter = new QueryPresenter();
+  const { defaultQuery, history } = await presenter.call({
+    organizationId: project.organizationId,
+  });
+
+  // Admins and impersonating users can use EXPLAIN
+  const isAdmin = user.admin || user.isImpersonating;
+
+  return typedjson({
+    defaultQuery,
+    defaultPeriod: await getDefaultPeriod(project.organizationId),
+    history,
+    isAdmin,
+    maxRows: env.QUERY_CLICKHOUSE_MAX_RETURNED_ROWS,
+  });
+};
+
+const ActionSchema = z.object({
+  query: z.string().min(1, "Query is required"),
+  scope: z.enum(["environment", "project", "organization"]),
+  explain: z.enum(["true", "false"]).nullable().optional(),
+  period: z.string().nullable().optional(),
+  from: z.string().nullable().optional(),
+  to: z.string().nullable().optional(),
+});
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const user = await requireUser(request);
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const canAccess = await canAccessQuery({
+    userId: user.id,
+    isAdmin: user.admin,
+    isImpersonating: user.isImpersonating,
+    organizationSlug,
+  });
+
+  if (!canAccess) {
+    return typedjson(
+      {
+        error: "Unauthorized",
+        rows: null,
+        columns: null,
+        stats: null,
+        hiddenColumns: null,
+        reachedMaxRows: null,
+        explainOutput: null,
+        generatedSql: null,
+        periodClipped: null,
+      },
+      { status: 403 }
+    );
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
+  if (!project) {
+    return typedjson(
+      {
+        error: "Project not found",
+        rows: null,
+        columns: null,
+        stats: null,
+        hiddenColumns: null,
+        reachedMaxRows: null,
+        explainOutput: null,
+        generatedSql: null,
+        periodClipped: null,
+      },
+      { status: 404 }
+    );
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    return typedjson(
+      {
+        error: "Environment not found",
+        rows: null,
+        columns: null,
+        stats: null,
+        hiddenColumns: null,
+        reachedMaxRows: null,
+        explainOutput: null,
+        generatedSql: null,
+        periodClipped: null,
+      },
+      { status: 404 }
+    );
+  }
+
+  const formData = await request.formData();
+  const parsed = ActionSchema.safeParse({
+    query: formData.get("query"),
+    scope: formData.get("scope"),
+    explain: formData.get("explain"),
+    period: formData.get("period"),
+    from: formData.get("from"),
+    to: formData.get("to"),
+  });
+
+  if (!parsed.success) {
+    return typedjson(
+      {
+        error: parsed.error.errors.map((e) => e.message).join(", "),
+        rows: null,
+        columns: null,
+        stats: null,
+        hiddenColumns: null,
+        reachedMaxRows: null,
+        explainOutput: null,
+        generatedSql: null,
+        periodClipped: null,
+      },
+      { status: 400 }
+    );
+  }
+
+  const { query, scope, explain: explainParam, period, from, to } = parsed.data;
+  // Only allow explain for admins/impersonating users
+  const isAdmin = user.admin || user.isImpersonating;
+  const explain = explainParam === "true" && isAdmin;
+
+  try {
+    const queryResult = await executeQuery({
+      name: "query-page",
+      query,
+      scope,
+      organizationId: project.organizationId,
+      projectId: project.id,
+      environmentId: environment.id,
+      explain,
+      period,
+      from,
+      to,
+      history: {
+        source: "DASHBOARD",
+        userId: user.id,
+        skip: user.isImpersonating,
+      },
+    });
+
+    if (!queryResult.success) {
+      return typedjson(
+        {
+          error: queryResult.error.message,
+          rows: null,
+          columns: null,
+          stats: null,
+          hiddenColumns: null,
+          reachedMaxRows: null,
+          explainOutput: null,
+          generatedSql: null,
+          queryId: null,
+          periodClipped: null,
+        },
+        { status: 400 }
+      );
+    }
+
+    return typedjson({
+      error: null,
+      rows: queryResult.result.rows,
+      columns: queryResult.result.columns,
+      stats: queryResult.result.stats,
+      hiddenColumns: queryResult.result.hiddenColumns ?? null,
+      reachedMaxRows: queryResult.result.reachedMaxRows,
+      explainOutput: queryResult.result.explainOutput ?? null,
+      generatedSql: queryResult.result.generatedSql ?? null,
+      queryId: queryResult.queryId,
+      periodClipped: queryResult.periodClipped,
+      maxQueryPeriod: queryResult.maxQueryPeriod,
+    });
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Unknown error executing query";
+    return typedjson(
+      {
+        error: errorMessage,
+        rows: null,
+        columns: null,
+        stats: null,
+        hiddenColumns: null,
+        reachedMaxRows: null,
+        explainOutput: null,
+        generatedSql: null,
+        queryId: null,
+        periodClipped: null,
+      },
+      { status: 500 }
+    );
+  }
+};
+
+export default function Page() {
+  const { defaultPeriod, defaultQuery, history, isAdmin, maxRows } =
+    useTypedLoaderData<typeof loader>();
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+  const plan = useCurrentPlan();
+  const maxPeriodDays = plan?.v3Subscription?.plan?.limits?.queryPeriodDays?.number;
+
+  // Use most recent history item if available, otherwise fall back to defaults
+  const initialQuery = history.length > 0 ? history[0].query : defaultQuery;
+  const initialScope = history.length > 0 ? history[0].scope : "environment";
+  const initialTimeFilter =
+    history.length > 0
+      ? {
+          period: history[0].filterPeriod ?? undefined,
+          from: history[0].filterFrom ? toISOString(history[0].filterFrom) : undefined,
+          to: history[0].filterTo ? toISOString(history[0].filterTo) : undefined,
+        }
+      : undefined;
+
+  // Build the query action URL for this page
+  const queryActionUrl = queryPath(
+    { slug: organization.slug },
+    { slug: project.slug },
+    { slug: environment.slug }
+  );
+
+  return (
+    <QueryEditor
+      defaultQuery={initialQuery}
+      defaultScope={initialScope}
+      defaultPeriod={defaultPeriod}
+      defaultTimeFilter={initialTimeFilter}
+      history={history}
+      isAdmin={isAdmin}
+      maxRows={maxRows}
+      queryActionUrl={queryActionUrl}
+      mode={{ type: "standalone" }}
+      maxPeriodDays={maxPeriodDays}
+    />
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types.ts b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types.ts
new file mode 100644
index 00000000000..2fe8a980d84
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types.ts
@@ -0,0 +1,9 @@
+/**
+ * Time filter configuration that can be set by the AI.
+ * Used across both server and client code for AI query generation.
+ */
+export type AITimeFilter = {
+  period?: string;
+  from?: string;
+  to?: string;
+};
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues/route.tsx
index 0c069f31e67..b33fc1e809b 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues/route.tsx
@@ -80,6 +80,7 @@ import { PauseEnvironmentService } from "~/v3/services/pauseEnvironment.server";
 import { PauseQueueService } from "~/v3/services/pauseQueue.server";
 import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
 import { ConcurrencyIcon } from "~/assets/icons/ConcurrencyIcon";
+import { QueueName } from "~/components/runs/v3/QueueName";
 
 const SearchParamsSchema = z.object({
   query: z.string().optional(),
@@ -344,7 +345,7 @@ export default function Page() {
             <BigNumber
               title="Queued"
               value={environment.queued}
-              suffix={env.paused && environment.queued > 0 ? "paused" : undefined}
+              suffix={env.paused ? <span className="text-warning">paused</span> : undefined}
               animate
               accessory={
                 <div className="flex items-start gap-1">
@@ -363,14 +364,14 @@ export default function Page() {
                   />
                 </div>
               }
-              valueClassName={env.paused ? "text-warning" : undefined}
+              valueClassName={env.paused ? "text-warning tabular-nums" : "tabular-nums"}
               compactThreshold={1000000}
             />
             <BigNumber
               title="Running"
               value={environment.running}
               animate
-              valueClassName={limitClassName}
+              valueClassName={cn(limitClassName, "tabular-nums")}
               suffix={
                 limitStatus === "burst" ? (
                   <span className={cn(limitClassName, "flex items-center gap-1")}>
@@ -392,7 +393,7 @@ export default function Page() {
                     period: "30d",
                     rootOnly: false,
                   })}
-                  tooltip="View runs"
+                  tooltip="View running runs"
                 />
               }
               compactThreshold={1000000}
@@ -499,7 +500,7 @@ export default function Page() {
                     >
                       Limited by
                     </TableHeaderCell>
-                    <TableHeaderCell className="w-[1%] pl-24">
+                    <TableHeaderCell className="w-[1%] pl-32">
                       <span className="sr-only">Pause/resume</span>
                     </TableHeaderCell>
                   </TableRow>
@@ -508,7 +509,10 @@ export default function Page() {
                   {queues.length > 0 ? (
                     queues.map((queue) => {
                       const limit = queue.concurrencyLimit ?? environment.concurrencyLimit;
-                      const isAtLimit = queue.running >= limit;
+                      const isAtConcurrencyLimit = queue.running >= limit;
+                      const isAtQueueLimit =
+                        environment.queueSizeLimit !== null &&
+                        queue.queued >= environment.queueSizeLimit;
                       const queueFilterableName = `${queue.type === "task" ? "task/" : ""}${
                         queue.name
                       }`;
@@ -516,34 +520,7 @@ export default function Page() {
                         <TableRow key={queue.name}>
                           <TableCell>
                             <span className="flex items-center gap-2">
-                              {queue.type === "task" ? (
-                                <SimpleTooltip
-                                  button={
-                                    <TaskIconSmall
-                                      className={cn(
-                                        "size-[1.125rem] text-blue-500",
-                                        queue.paused && "opacity-50"
-                                      )}
-                                    />
-                                  }
-                                  content={`This queue was automatically created from your "${queue.name}" task`}
-                                />
-                              ) : (
-                                <SimpleTooltip
-                                  button={
-                                    <RectangleStackIcon
-                                      className={cn(
-                                        "size-[1.125rem] text-purple-500",
-                                        queue.paused && "opacity-50"
-                                      )}
-                                    />
-                                  }
-                                  content={`This is a custom queue you added in your code.`}
-                                />
-                              )}
-                              <span className={queue.paused ? "opacity-50" : undefined}>
-                                {queue.name}
-                              </span>
+                              <QueueName {...queue} />
                               {queue.concurrency?.overriddenAt ? (
                                 <SimpleTooltip
                                   button={
@@ -561,7 +538,12 @@ export default function Page() {
                                   Paused
                                 </Badge>
                               ) : null}
-                              {isAtLimit ? (
+                              {isAtQueueLimit ? (
+                                <Badge variant="extra-small" className="text-error">
+                                  At queue limit
+                                </Badge>
+                              ) : null}
+                              {isAtConcurrencyLimit ? (
                                 <Badge variant="extra-small" className="text-warning">
                                   At concurrency limit
                                 </Badge>
@@ -571,8 +553,9 @@ export default function Page() {
                           <TableCell
                             alignment="right"
                             className={cn(
-                              "w-[1%] tabular-nums",
-                              queue.paused ? "opacity-50" : undefined
+                              "w-[1%] pl-16 tabular-nums",
+                              queue.paused ? "opacity-50" : undefined,
+                              isAtQueueLimit && "text-error"
                             )}
                           >
                             {queue.queued}
@@ -580,10 +563,10 @@ export default function Page() {
                           <TableCell
                             alignment="right"
                             className={cn(
-                              "w-[1%] tabular-nums",
+                              "w-[1%] pl-16 tabular-nums",
                               queue.paused ? "opacity-50" : undefined,
                               queue.running > 0 && "text-text-bright",
-                              isAtLimit && "text-warning"
+                              isAtConcurrencyLimit && "text-warning"
                             )}
                           >
                             {queue.running}
@@ -591,7 +574,7 @@ export default function Page() {
                           <TableCell
                             alignment="right"
                             className={cn(
-                              "w-[1%] tabular-nums",
+                              "w-[1%] pl-16 tabular-nums",
                               queue.paused ? "opacity-50" : undefined,
                               queue.concurrency?.overriddenAt && "font-medium text-text-bright"
                             )}
@@ -601,9 +584,9 @@ export default function Page() {
                           <TableCell
                             alignment="right"
                             className={cn(
-                              "w-[1%]",
+                              "w-[1%] pl-16",
                               queue.paused ? "opacity-50" : undefined,
-                              isAtLimit && "text-warning",
+                              isAtConcurrencyLimit && "text-warning",
                               queue.concurrency?.overriddenAt && "font-medium text-text-bright"
                             )}
                           >
@@ -1003,6 +986,11 @@ function QueueOverrideConcurrencyButton({
             </div>
 
             <FormButtons
+              defaultAction={{
+                name: "action",
+                value: "queue-override",
+                disabled: isLoading || !concurrencyLimit,
+              }}
               confirmButton={
                 <Button
                   type="submit"
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.regions/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.regions/route.tsx
index 3484e1378b4..26daa24df34 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.regions/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.regions/route.tsx
@@ -262,7 +262,7 @@ export default function Page() {
                               <TableCellMenu
                                 className="pl-32"
                                 isSticky
-                                visibleButtons={
+                                hiddenButtons={
                                   <SetDefaultDialog regions={regions} newDefaultRegion={region} />
                                 }
                               />
@@ -309,12 +309,9 @@ export default function Page() {
                       <TextLink to="https://security.trigger.dev">security portal</TextLink> or{" "}
                       <Feedback
                         button={
-                          <Paragraph
-                            variant="extra-small"
-                            className="cursor-pointer text-indigo-500 transition hover:text-indigo-400"
-                          >
+                          <span className="cursor-pointer text-xs text-indigo-500 transition hover:text-indigo-400">
                             get in touch
-                          </Paragraph>
+                          </span>
                         }
                         defaultValue="help"
                       />
@@ -345,20 +342,21 @@ function SetDefaultDialog({
     <Dialog open={isOpen} onOpenChange={setIsOpen}>
       <DialogTrigger asChild>
         <Button
-          variant="secondary/small"
+          variant="minimal/small"
           LeadingIcon={MapPinIcon}
           leadingIconClassName="text-blue-500"
           iconSpacing="gap-2"
           className="pl-2"
         >
-          Set as default…
+          <span className="text-text-bright">Set as default…</span>
         </Button>
       </DialogTrigger>
       <DialogContent>
         <DialogHeader>
           <DialogTitle>Set as default region</DialogTitle>
         </DialogHeader>
-        <DialogDescription>
+        <DialogDescription asChild>
+          <div>
           <Paragraph>
             Are you sure you want to set {newDefaultRegion.name} as your new default region?
           </Paragraph>
@@ -441,6 +439,7 @@ function SetDefaultDialog({
             Runs triggered from now on will execute in "{newDefaultRegion.name}", unless you{" "}
             <TextLink to={docsPath("triggering#region")}>override when triggering</TextLink>.
           </Paragraph>
+          </div>
         </DialogDescription>
         <DialogFooter>
           <Button variant="secondary/medium" onClick={() => setIsOpen(false)}>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.stream/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.stream/route.tsx
index 682337caed7..87f3be8a03d 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.stream/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.stream/route.tsx
@@ -1,13 +1,11 @@
 import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
-import { z } from "zod";
-import { RunStreamPresenter } from "~/presenters/v3/RunStreamPresenter.server";
+import { runStreamLoader } from "~/presenters/v3/RunStreamPresenter.server";
 import { requireUserId } from "~/services/session.server";
 
-export async function loader({ request, params }: LoaderFunctionArgs) {
-  await requireUserId(request);
+export async function loader(args: LoaderFunctionArgs) {
+  // Authenticate the user before starting the stream
+  await requireUserId(args.request);
 
-  const { runParam } = z.object({ runParam: z.string() }).parse(params);
-
-  const presenter = new RunStreamPresenter();
-  return presenter.call({ request, runFriendlyId: runParam });
+  // Delegate to the SSE loader
+  return runStreamLoader(args);
 }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/route.tsx
index 8ad68c00a9d..f35376a4275 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/route.tsx
@@ -2,7 +2,6 @@ import {
   ArrowUturnLeftIcon,
   BoltSlashIcon,
   BookOpenIcon,
-  ChevronUpIcon,
   ChevronDownIcon,
   ChevronRightIcon,
   InformationCircleIcon,
@@ -12,6 +11,7 @@ import {
   MagnifyingGlassPlusIcon,
   StopCircleIcon,
 } from "@heroicons/react/20/solid";
+
 import { useLoaderData, useRevalidator } from "@remix-run/react";
 import { type LoaderFunctionArgs, type SerializeFrom, json } from "@remix-run/server-runtime";
 import { type Virtualizer } from "@tanstack/react-virtual";
@@ -26,6 +26,8 @@ import { motion } from "framer-motion";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useHotkeys } from "react-hotkeys-hook";
 import { redirect } from "remix-typedjson";
+import { ChevronExtraSmallDown } from "~/assets/icons/ChevronExtraSmallDown";
+import { ChevronExtraSmallUp } from "~/assets/icons/ChevronExtraSmallUp";
 import { MoveToTopIcon } from "~/assets/icons/MoveToTopIcon";
 import { MoveUpIcon } from "~/assets/icons/MoveUpIcon";
 import tileBgPath from "~/assets/images/error-banner-tile@2x.png";
@@ -35,6 +37,7 @@ import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
 import { PageBody } from "~/components/layout/AppLayout";
 import { Badge } from "~/components/primitives/Badge";
 import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { CopyableText } from "~/components/primitives/CopyableText";
 import { DateTimeShort } from "~/components/primitives/DateTime";
 import { Dialog, DialogTrigger } from "~/components/primitives/Dialog";
 import { Header3 } from "~/components/primitives/Headers";
@@ -45,9 +48,13 @@ import { Paragraph } from "~/components/primitives/Paragraph";
 import { Popover, PopoverArrowTrigger, PopoverContent } from "~/components/primitives/Popover";
 import * as Property from "~/components/primitives/PropertyTable";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  type ResizableSnapshot,
+  collapsibleHandleClassName,
+  useFrozenValue,
 } from "~/components/primitives/Resizable";
 import { ShortcutKey, variants } from "~/components/primitives/ShortcutKey";
 import { Slider } from "~/components/primitives/Slider";
@@ -62,6 +69,7 @@ import {
 import { type NodesState } from "~/components/primitives/TreeView/reducer";
 import { CancelRunDialog } from "~/components/runs/v3/CancelRunDialog";
 import { ReplayRunDialog } from "~/components/runs/v3/ReplayRunDialog";
+import { getRunFiltersFromSearchParams } from "~/components/runs/v3/RunFilters";
 import { RunIcon } from "~/components/runs/v3/RunIcon";
 import {
   SpanTitle,
@@ -69,6 +77,7 @@ import {
   eventBorderClassName,
 } from "~/components/runs/v3/SpanTitle";
 import { TaskRunStatusIcon, runStatusClassNameColor } from "~/components/runs/v3/TaskRunStatus";
+import { $replica } from "~/db.server";
 import { useDebounce } from "~/hooks/useDebounce";
 import { useEnvironment } from "~/hooks/useEnvironment";
 import { useEventSource } from "~/hooks/useEventSource";
@@ -76,10 +85,16 @@ import { useInitialDimensions } from "~/hooks/useInitialDimensions";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { useReplaceSearchParams } from "~/hooks/useReplaceSearchParams";
+import { useSearchParams } from "~/hooks/useSearchParam";
 import { type Shortcut, useShortcutKeys } from "~/hooks/useShortcutKeys";
 import { useHasAdminAccess } from "~/hooks/useUser";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { NextRunListPresenter } from "~/presenters/v3/NextRunListPresenter.server";
 import { RunEnvironmentMismatchError, RunPresenter } from "~/presenters/v3/RunPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
 import { getImpersonationId } from "~/services/impersonation.server";
+import { logger } from "~/services/logger.server";
 import { getResizableSnapshot } from "~/services/resizablePanel.server";
 import { requireUserId } from "~/services/session.server";
 import { cn } from "~/utils/cn";
@@ -94,22 +109,13 @@ import {
   v3RunStreamingPath,
   v3RunsPath,
 } from "~/utils/pathBuilder";
+import type { SpanOverride } from "~/v3/eventRepository/eventRepository.types";
 import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
 import { SpanView } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route";
-import { useSearchParams } from "~/hooks/useSearchParam";
-import { CopyableText } from "~/components/primitives/CopyableText";
-import type { SpanOverride } from "~/v3/eventRepository/eventRepository.types";
-import { getRunFiltersFromSearchParams } from "~/components/runs/v3/RunFilters";
-import { NextRunListPresenter } from "~/presenters/v3/NextRunListPresenter.server";
-import { $replica } from "~/db.server";
-import { clickhouseClient } from "~/services/clickhouseInstance.server";
-import { findProjectBySlug } from "~/models/project.server";
-import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
-import { logger } from "~/services/logger.server";
 
 const resizableSettings = {
   parent: {
-    autosaveId: "panel-run-parent",
+    autosaveId: "panel-run-parent-v2",
     handleId: "parent-handle",
     main: {
       id: "run",
@@ -117,7 +123,7 @@ const resizableSettings = {
     },
     inspector: {
       id: "inspector",
-      default: "430px" as const,
+      default: "500px" as const,
       min: "50px" as const,
     },
   },
@@ -210,7 +216,10 @@ async function getRunsListFromTableState({
       }
     }
 
-    if (currentRunIndex === currentPageResult.runs.length - 1 && currentPageResult.pagination.next) {
+    if (
+      currentRunIndex === currentPageResult.runs.length - 1 &&
+      currentPageResult.pagination.next
+    ) {
       const nextPageResult = await runsListPresenter.call(project.organizationId, environment.id, {
         userId,
         projectId: project.id,
@@ -298,7 +307,8 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 type LoaderData = SerializeFrom<typeof loader>;
 
 export default function Page() {
-  const { run, trace, maximumLiveReloadingSetting, runsList } = useLoaderData<typeof loader>();
+  const { run, trace, maximumLiveReloadingSetting, runsList, resizable } =
+    useLoaderData<typeof loader>();
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
@@ -313,7 +323,16 @@ export default function Page() {
   const tabParam = value("tab") ?? undefined;
   const spanParam = value("span") ?? undefined;
 
-  const [previousRunPath, nextRunPath] = useAdjacentRunPaths({organization, project, environment, tableState, run, runsList, tabParam, useSpan: !!spanParam});
+  const [previousRunPath, nextRunPath] = useAdjacentRunPaths({
+    organization,
+    project,
+    environment,
+    tableState,
+    run,
+    runsList,
+    tabParam,
+    useSpan: !!spanParam,
+  });
 
   return (
     <>
@@ -323,13 +342,21 @@ export default function Page() {
             to: v3RunsPath(organization, project, environment, filters),
             text: "Runs",
           }}
-          title={<>
-          <CopyableText value={run.friendlyId} variant="text-below" className="font-mono px-0 py-0 pb-[2px]"/>
-          {tableState && (<div className="flex">
-              <PreviousRunButton to={previousRunPath} />
-              <NextRunButton to={nextRunPath} />
-            </div>)}
-          </>}
+          title={
+            <div className="flex items-center gap-x-0">
+              <CopyableText
+                value={run.friendlyId}
+                variant="text-below"
+                className="-ml-[0.4375rem] h-6 px-1.5 font-mono text-xs hover:text-text-bright"
+              />
+              {tableState && (
+                <div className="flex">
+                  <PreviousRunButton to={previousRunPath} />
+                  <NextRunButton to={nextRunPath} />
+                </div>
+              )}
+            </div>
+          }
         />
         {environment.type === "DEVELOPMENT" && <DevDisconnectedBanner isConnected={isConnected} />}
         <PageAccessories>
@@ -405,23 +432,47 @@ export default function Page() {
             run={run}
             trace={trace}
             maximumLiveReloadingSetting={maximumLiveReloadingSetting}
+            resizable={resizable}
           />
         ) : (
-          <NoLogsView
-            run={run}
-          />
+          <NoLogsView run={run} resizable={resizable} />
         )}
       </PageBody>
     </>
   );
 }
 
-function TraceView({ run, trace, maximumLiveReloadingSetting }: Pick<LoaderData, "run" | "trace" | "maximumLiveReloadingSetting">) {
+function shouldLiveReload({
+  events,
+  maximumLiveReloadingSetting,
+  run,
+}: {
+  events: TraceEvent[];
+  maximumLiveReloadingSetting: number;
+  run: { completedAt: string | null };
+}): boolean {
+  // We don't live reload if there are a ton of spans/logs
+  if (events.length > maximumLiveReloadingSetting) return false;
+
+  // If the run was completed a while ago, we don't need to live reload anymore
+  if (run.completedAt && new Date(run.completedAt).getTime() < Date.now() - 30_000) return false;
+
+  return true;
+}
+
+function TraceView({
+  run,
+  trace,
+  maximumLiveReloadingSetting,
+  resizable,
+}: Pick<LoaderData, "run" | "trace" | "maximumLiveReloadingSetting" | "resizable">) {
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
   const { searchParams, replaceSearchParam } = useReplaceSearchParams();
   const selectedSpanId = searchParams.get("span") ?? undefined;
+  const frozenSpanId = useFrozenValue(selectedSpanId);
+  const displaySpanId = selectedSpanId ?? frozenSpanId;
 
   if (!trace) {
     return <></>;
@@ -429,18 +480,19 @@ function TraceView({ run, trace, maximumLiveReloadingSetting }: Pick<LoaderData,
 
   const { events, duration, rootSpanStatus, rootStartedAt, queuedDuration, overridesBySpanId } =
     trace;
-  const shouldLiveReload = events.length <= maximumLiveReloadingSetting;
 
   const changeToSpan = useDebounce((selectedSpan: string) => {
     replaceSearchParam("span", selectedSpan, { replace: true });
   }, 250);
 
+  const isLiveReloading = shouldLiveReload({ events, maximumLiveReloadingSetting, run });
+
   const revalidator = useRevalidator();
   const streamedEvents = useEventSource(
     v3RunStreamingPath(organization, project, environment, run),
     {
       event: "message",
-      disabled: !shouldLiveReload,
+      disabled: !isLiveReloading,
     }
   );
   useEffect(() => {
@@ -451,12 +503,22 @@ function TraceView({ run, trace, maximumLiveReloadingSetting }: Pick<LoaderData,
   }, [streamedEvents]); // eslint-disable-line react-hooks/exhaustive-deps
 
   const spanOverrides = selectedSpanId ? overridesBySpanId?.[selectedSpanId] : undefined;
+  const frozenSpanOverrides = useFrozenValue(spanOverrides);
+  const displaySpanOverrides = selectedSpanId ? spanOverrides : frozenSpanOverrides;
+
+  // Get the linked run ID for cached spans (map built during RunPresenter walk)
+  const { linkedRunIdBySpanId } = trace;
+  const selectedSpanLinkedRunId = selectedSpanId
+    ? linkedRunIdBySpanId?.[selectedSpanId]
+    : undefined;
+  const frozenLinkedRunId = useFrozenValue(selectedSpanLinkedRunId);
+  const displayLinkedRunId = (selectedSpanId ? selectedSpanLinkedRunId : frozenLinkedRunId) ?? undefined;
 
   return (
     <div className={cn("grid h-full max-h-full grid-cols-1 overflow-hidden")}>
       <ResizablePanelGroup
         autosaveId={resizableSettings.parent.autosaveId}
-        // snapshot={resizable.parent}
+        snapshot={resizable.parent as ResizableSnapshot}
         className="h-full max-h-full"
       >
         <ResizablePanel
@@ -481,36 +543,50 @@ function TraceView({ run, trace, maximumLiveReloadingSetting }: Pick<LoaderData,
             rootStartedAt={rootStartedAt ? new Date(rootStartedAt) : undefined}
             queuedDuration={queuedDuration}
             environmentType={run.environment.type}
-            shouldLiveReload={shouldLiveReload}
+            shouldLiveReload={isLiveReloading}
             maximumLiveReloadingSetting={maximumLiveReloadingSetting}
             rootRun={run.rootTaskRun}
             parentRun={run.parentTaskRun}
             isCompleted={run.completedAt !== null}
+            treeSnapshot={resizable.tree as ResizableSnapshot}
           />
         </ResizablePanel>
-        <ResizableHandle id={resizableSettings.parent.handleId} />
-        {selectedSpanId && (
-          <ResizablePanel
-            id={resizableSettings.parent.inspector.id}
-            default={resizableSettings.parent.inspector.default}
-            min={resizableSettings.parent.inspector.min}
-            isStaticAtRest
+        <ResizableHandle
+          id={resizableSettings.parent.handleId}
+          className={collapsibleHandleClassName(!!selectedSpanId)}
+        />
+        <ResizablePanel
+          id={resizableSettings.parent.inspector.id}
+          default={resizableSettings.parent.inspector.default}
+          min={resizableSettings.parent.inspector.min}
+          className="overflow-hidden"
+          collapsible
+          collapsed={!selectedSpanId}
+          onCollapseChange={() => {}}
+          collapsedSize="0px"
+          collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+        >
+          <div
+            className="h-full"
+            style={{ minWidth: parseInt(resizableSettings.parent.inspector.min) }}
           >
-            {" "}
-            <SpanView
-              runParam={run.friendlyId}
-              spanId={selectedSpanId}
-              spanOverrides={spanOverrides as SpanOverride | undefined}
-              closePanel={() => replaceSearchParam("span")}
-            />
-          </ResizablePanel>
-        )}
+            {displaySpanId && (
+              <SpanView
+                runParam={run.friendlyId}
+                spanId={displaySpanId}
+                spanOverrides={displaySpanOverrides as SpanOverride | undefined}
+                closePanel={() => replaceSearchParam("span")}
+                linkedRunId={displayLinkedRunId}
+              />
+            )}
+          </div>
+        </ResizablePanel>
       </ResizablePanelGroup>
     </div>
   );
 }
 
-function NoLogsView({ run }: Pick<LoaderData, "run">) {
+function NoLogsView({ run, resizable }: Pick<LoaderData, "run" | "resizable">) {
   const plan = useCurrentPlan();
   const organization = useOrganization();
 
@@ -530,7 +606,7 @@ function NoLogsView({ run }: Pick<LoaderData, "run">) {
     <div className={cn("grid h-full max-h-full grid-cols-1 overflow-hidden")}>
       <ResizablePanelGroup
         autosaveId={resizableSettings.parent.autosaveId}
-        // snapshot={resizable.parent}
+        snapshot={resizable.parent as ResizableSnapshot}
         className="h-full max-h-full"
       >
         <ResizablePanel
@@ -621,6 +697,7 @@ type TasksTreeViewProps = {
     spanId: string;
   } | null;
   isCompleted: boolean;
+  treeSnapshot?: ResizableSnapshot;
 };
 
 function TasksTreeView({
@@ -637,6 +714,7 @@ function TasksTreeView({
   rootRun,
   parentRun,
   isCompleted,
+  treeSnapshot,
 }: TasksTreeViewProps) {
   const isAdmin = useHasAdminAccess();
   const [filterText, setFilterText] = useState("");
@@ -720,7 +798,7 @@ function TasksTreeView({
           onCheckedChange={(e) => setErrorsOnly(e.valueOf())}
         />
       </div>
-      <ResizablePanelGroup autosaveId={resizableSettings.tree.autosaveId}>
+      <ResizablePanelGroup autosaveId={resizableSettings.tree.autosaveId} snapshot={treeSnapshot}>
         {/* Tree list */}
         <ResizablePanel
           id={resizableSettings.tree.tree.id}
@@ -875,7 +953,7 @@ function TasksTreeView({
       </ResizablePanelGroup>
       <div className="flex items-center justify-between gap-2 border-t border-grid-dimmed px-4">
         <div className="grow @container">
-          <div className="hidden items-center gap-4 @[42rem]:flex">
+          <div className="hidden items-center gap-4 @[48rem]:flex">
             <KeyboardShortcuts
               expandAllBelowDepth={expandAllBelowDepth}
               collapseAllBelowDepth={collapseAllBelowDepth}
@@ -883,7 +961,7 @@ function TasksTreeView({
               setShowDurations={setShowDurations}
             />
           </div>
-          <div className="@[42rem]:hidden">
+          <div className="@[48rem]:hidden">
             <Popover>
               <PopoverArrowTrigger>Shortcuts</PopoverArrowTrigger>
               <PopoverContent
@@ -1131,7 +1209,9 @@ function TimelineView({
                                     "-ml-[0.5px] h-[0.5625rem] w-px rounded-none",
                                     eventBackgroundClassName(node.data)
                                   )}
-                                  layoutId={disableSpansAnimations ? undefined : `${node.id}-${event.name}`}
+                                  layoutId={
+                                    disableSpansAnimations ? undefined : `${node.id}-${event.name}`
+                                  }
                                   animate={disableSpansAnimations ? false : undefined}
                                 />
                               )}
@@ -1150,7 +1230,9 @@ function TimelineView({
                                     "-ml-[0.1562rem] size-[0.3125rem] rounded-full border bg-background-bright",
                                     eventBorderClassName(node.data)
                                   )}
-                                  layoutId={disableSpansAnimations ? undefined : `${node.id}-${event.name}`}
+                                  layoutId={
+                                    disableSpansAnimations ? undefined : `${node.id}-${event.name}`
+                                  }
                                   animate={disableSpansAnimations ? false : undefined}
                                 />
                               )}
@@ -1444,7 +1526,12 @@ function SpanWithDuration({
   fadeLeft,
   disableAnimations,
   ...props
-}: Timeline.SpanProps & { node: TraceEvent; showDuration: boolean; fadeLeft: boolean; disableAnimations?: boolean }) {
+}: Timeline.SpanProps & {
+  node: TraceEvent;
+  showDuration: boolean;
+  fadeLeft: boolean;
+  disableAnimations?: boolean;
+}) {
   return (
     <Timeline.Span {...props}>
       <motion.div
@@ -1583,13 +1670,15 @@ function KeyboardShortcuts({
 }
 
 function AdjacentRunsShortcuts() {
-  return (<div className="flex items-center gap-0.5">
+  return (
+    <div className="flex items-center gap-0.5">
       <ShortcutKey shortcut={{ key: "[" }} variant="medium" className="ml-0 mr-0 px-1" />
       <ShortcutKey shortcut={{ key: "]" }} variant="medium" className="ml-0 mr-0 px-1" />
       <Paragraph variant="extra-small" className="ml-1.5 whitespace-nowrap">
-        Adjacent runs
+        Next/previous run
       </Paragraph>
-    </div>);
+    </div>
+  );
 }
 
 function ArrowKeyShortcuts() {
@@ -1679,13 +1768,13 @@ function useAdjacentRunPaths({
   run,
   runsList,
   tabParam,
-  useSpan
+  useSpan,
 }: {
   organization: { slug: string };
   project: { slug: string };
   environment: { slug: string };
   tableState: string;
-  run: { friendlyId: string, spanId: string };
+  run: { friendlyId: string; spanId: string };
   runsList: RunsListNavigation | null;
   tabParam?: string;
   useSpan?: boolean;
@@ -1695,7 +1784,7 @@ function useAdjacentRunPaths({
   }
 
   const currentIndex = runsList.runs.findIndex((r) => r.friendlyId === run.friendlyId);
-  
+
   if (currentIndex === -1) {
     return [null, null];
   }
@@ -1751,20 +1840,17 @@ function useAdjacentRunPaths({
   return [previousRunPath, nextRunPath];
 }
 
-
 function PreviousRunButton({ to }: { to: string | null }) {
   return (
     <div className={cn("peer/prev order-1", !to && "pointer-events-none")}>
       <LinkButton
-        to={to ? to : '#'}
+        to={to ? to : "#"}
         variant={"minimal/small"}
-        LeadingIcon={ChevronUpIcon}
-        className={cn(
-          "flex items-center rounded-r-none border-r-0 pl-2 pr-[0.5625rem]",
-          !to && "cursor-not-allowed opacity-50"
-        )}
+        LeadingIcon={ChevronExtraSmallUp}
+        leadingIconClassName="size-3 group-hover/button:text-text-bright transition-colors"
+        className={cn("flex size-6 max-w-6 items-center", !to && "cursor-not-allowed opacity-50")}
         onClick={(e) => !to && e.preventDefault()}
-        shortcut={{ key: "[" }}
+        shortcut={{ key: "j" }}
         tooltip="Previous Run"
         disabled={!to}
         replace
@@ -1777,15 +1863,13 @@ function NextRunButton({ to }: { to: string | null }) {
   return (
     <div className={cn("peer/next order-3", !to && "pointer-events-none")}>
       <LinkButton
-        to={to ? to : '#'}
+        to={to ? to : "#"}
         variant={"minimal/small"}
-        TrailingIcon={ChevronDownIcon}
-        className={cn(
-          "flex items-center rounded-l-none border-l-0 pl-[0.5625rem] pr-2",
-          !to && "cursor-not-allowed opacity-50"
-        )}
+        LeadingIcon={ChevronExtraSmallDown}
+        leadingIconClassName="size-3 group-hover/button:text-text-bright transition-colors"
+        className={cn("flex size-6 max-w-6 items-center", !to && "cursor-not-allowed opacity-50")}
         onClick={(e) => !to && e.preventDefault()}
-        shortcut={{ key: "]" }}
+        shortcut={{ key: "k" }}
         tooltip="Next Run"
         disabled={!to}
         replace
@@ -1793,4 +1877,3 @@ function NextRunButton({ to }: { to: string | null }) {
     </div>
   );
 }
-
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs._index/route.tsx
index 9f8cf278bef..ca7e8b7b0c1 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs._index/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs._index/route.tsx
@@ -20,9 +20,11 @@ import { InfoPanel } from "~/components/primitives/InfoPanel";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import { SelectedItemsProvider } from "~/components/primitives/SelectedItemsProvider";
 import { ShortcutKey } from "~/components/primitives/ShortcutKey";
@@ -305,18 +307,32 @@ function RunsList({
           </>
         </div>
       </ResizablePanel>
-      {isShowingBulkActionInspector && (
-        <>
-          <ResizableHandle id="runs-handle" />
-          <ResizablePanel id="bulk-action-inspector" min="300px" default="400px" max="600px">
+      <ResizableHandle
+        id="runs-handle"
+        className={collapsibleHandleClassName(isShowingBulkActionInspector)}
+      />
+      <ResizablePanel
+        id="bulk-action-inspector"
+        default="400px"
+        min="400px"
+        max="600px"
+        className="overflow-hidden"
+        collapsible
+        collapsed={!isShowingBulkActionInspector}
+        onCollapseChange={() => {}}
+        collapsedSize="0px"
+        collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+      >
+        <div className="h-full" style={{ minWidth: 400 }}>
+          {isShowingBulkActionInspector && (
             <CreateBulkActionInspector
               filters={filters}
               selectedItems={selectedItems}
               hasBulkActions={list.bulkActions.length > 0}
             />
-          </ResizablePanel>
-        </>
-      )}
+          )}
+        </div>
+      </ResizablePanel>
     </ResizablePanelGroup>
   );
 }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.schedules/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.schedules/route.tsx
index d32f9ecb5b4..769aa10cd75 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.schedules/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.schedules/route.tsx
@@ -25,9 +25,11 @@ import { PaginationControls } from "~/components/primitives/Pagination";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import * as Property from "~/components/primitives/PropertyTable";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import {
   Table,
@@ -304,14 +306,25 @@ export default function Page() {
               )}
             </div>
           </ResizablePanel>
-          {(isShowingNewPane || isShowingSchedule) && (
-            <>
-              <ResizableHandle id="schedules-handle" />
-              <ResizablePanel id="schedules-inspector" min="100px" default="500px">
-                <Outlet />
-              </ResizablePanel>
-            </>
-          )}
+          <ResizableHandle
+            id="schedules-handle"
+            className={collapsibleHandleClassName(isShowingNewPane || isShowingSchedule)}
+          />
+          <ResizablePanel
+            id="schedules-inspector"
+            min="400px"
+            default="500px"
+            className="overflow-hidden"
+            collapsible
+            collapsed={!isShowingNewPane && !isShowingSchedule}
+            onCollapseChange={() => {}}
+            collapsedSize="0px"
+            collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+          >
+            <div className="h-full" style={{ minWidth: 400 }}>
+              <Outlet />
+            </div>
+          </ResizablePanel>
         </ResizablePanelGroup>
       </PageBody>
     </PageContainer>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.general/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.general/route.tsx
new file mode 100644
index 00000000000..d66bdb0e0da
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.general/route.tsx
@@ -0,0 +1,293 @@
+import { conform, useForm } from "@conform-to/react";
+import { parse } from "@conform-to/zod";
+import { ExclamationTriangleIcon, FolderIcon, TrashIcon } from "@heroicons/react/20/solid";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { type ActionFunction, json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { InlineCode } from "~/components/code/InlineCode";
+import { MainHorizontallyCenteredContainer } from "~/components/layout/AppLayout";
+import { Button } from "~/components/primitives/Buttons";
+import { ClipboardField } from "~/components/primitives/ClipboardField";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
+import { Header2 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
+import { useProject } from "~/hooks/useProject";
+import {
+  redirectWithErrorMessage,
+  redirectWithSuccessMessage,
+} from "~/models/message.server";
+import { ProjectSettingsService } from "~/services/projectSettings.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { organizationPath, v3ProjectPath } from "~/utils/pathBuilder";
+import { useState } from "react";
+
+function createSchema(
+  constraints: {
+    getSlugMatch?: (slug: string) => { isMatch: boolean; projectSlug: string };
+  } = {}
+) {
+  return z.discriminatedUnion("action", [
+    z.object({
+      action: z.literal("rename"),
+      projectName: z.string().min(3, "Project name must have at least 3 characters").max(50),
+    }),
+    z.object({
+      action: z.literal("delete"),
+      projectSlug: z.string().superRefine((slug, ctx) => {
+        if (constraints.getSlugMatch === undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: conform.VALIDATION_UNDEFINED,
+          });
+        } else {
+          const { isMatch, projectSlug } = constraints.getSlugMatch(slug);
+          if (isMatch) {
+            return;
+          }
+
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The slug must match ${projectSlug}`,
+          });
+        }
+      }),
+    }),
+  ]);
+}
+
+export const action: ActionFunction = async ({ request, params }) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam } = params;
+  if (!organizationSlug || !projectParam) {
+    return json({ errors: { body: "organizationSlug and projectParam are required" } }, { status: 400 });
+  }
+
+  const formData = await request.formData();
+
+  const schema = createSchema({
+    getSlugMatch: (slug) => {
+      return { isMatch: slug === projectParam, projectSlug: projectParam };
+    },
+  });
+  const submission = parse(formData, { schema });
+
+  if (!submission.value || submission.intent !== "submit") {
+    return json(submission);
+  }
+
+  const projectSettingsService = new ProjectSettingsService();
+  const membershipResultOrFail = await projectSettingsService.verifyProjectMembership(
+    organizationSlug,
+    projectParam,
+    userId
+  );
+
+  if (membershipResultOrFail.isErr()) {
+    return json({ errors: { body: membershipResultOrFail.error.type } }, { status: 404 });
+  }
+
+  const { projectId } = membershipResultOrFail.value;
+
+  switch (submission.value.action) {
+    case "rename": {
+      const resultOrFail = await projectSettingsService.renameProject(
+        projectId,
+        submission.value.projectName
+      );
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to rename project", {
+              error: resultOrFail.error,
+            });
+            return json({ errors: { body: "Failed to rename project" } }, { status: 400 });
+          }
+        }
+      }
+
+      return redirectWithSuccessMessage(
+        v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
+        request,
+        `Project renamed to ${submission.value.projectName}`
+      );
+    }
+    case "delete": {
+      const resultOrFail = await projectSettingsService.deleteProject(projectId, userId);
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to delete project", {
+              error: resultOrFail.error,
+            });
+            return redirectWithErrorMessage(
+              v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
+              request,
+              `Project ${projectParam} could not be deleted`
+            );
+          }
+        }
+      }
+
+      return redirectWithSuccessMessage(
+        organizationPath({ slug: organizationSlug }),
+        request,
+        "Project deleted"
+      );
+    }
+  }
+};
+
+export default function GeneralSettingsPage() {
+  const project = useProject();
+  const lastSubmission = useActionData();
+  const navigation = useNavigation();
+
+  const [hasRenameFormChanges, setHasRenameFormChanges] = useState(false);
+
+  const [renameForm, { projectName }] = useForm({
+    id: "rename-project",
+    // TODO: type this
+    lastSubmission: lastSubmission as any,
+    shouldRevalidate: "onSubmit",
+    onValidate({ formData }) {
+      return parse(formData, {
+        schema: createSchema(),
+      });
+    },
+  });
+
+  const isRenameLoading =
+    navigation.formData?.get("action") === "rename" &&
+    (navigation.state === "submitting" || navigation.state === "loading");
+
+  const [deleteForm, { projectSlug }] = useForm({
+    id: "delete-project",
+    // TODO: type this
+    lastSubmission: lastSubmission as any,
+    shouldValidate: "onInput",
+    shouldRevalidate: "onSubmit",
+    onValidate({ formData }) {
+      return parse(formData, {
+        schema: createSchema({
+          getSlugMatch: (slug) => ({ isMatch: slug === project.slug, projectSlug: project.slug }),
+        }),
+      });
+    },
+  });
+
+  const isDeleteLoading =
+    navigation.formData?.get("action") === "delete" &&
+    (navigation.state === "submitting" || navigation.state === "loading");
+
+  const [deleteInputValue, setDeleteInputValue] = useState("");
+
+  return (
+    <MainHorizontallyCenteredContainer className="md:mt-6">
+      <div className="flex flex-col gap-6">
+        <div>
+          <Header2 spacing>General</Header2>
+          <div className="w-full rounded-sm border border-grid-dimmed p-4">
+            <Fieldset className="mb-5">
+              <InputGroup fullWidth>
+                <Label>Project ref</Label>
+                <ClipboardField value={project.externalRef} variant={"secondary/medium"} />
+                <Hint>
+                  This goes in your{" "}
+                  <InlineCode variant="extra-extra-small">trigger.config</InlineCode> file.
+                </Hint>
+              </InputGroup>
+            </Fieldset>
+            <Form method="post" {...renameForm.props}>
+              <Fieldset>
+                <InputGroup fullWidth>
+                  <Label htmlFor={projectName.id}>Project name</Label>
+                  <Input
+                    {...conform.input(projectName, { type: "text" })}
+                    defaultValue={project.name}
+                    placeholder="Project name"
+                    icon={FolderIcon}
+                    autoFocus
+                    onChange={(e) => {
+                      setHasRenameFormChanges(e.target.value !== project.name);
+                    }}
+                  />
+                  <FormError id={projectName.errorId}>{projectName.error}</FormError>
+                </InputGroup>
+                <FormButtons
+                  confirmButton={
+                    <Button
+                      type="submit"
+                      name="action"
+                      value="rename"
+                      variant={"secondary/small"}
+                      disabled={isRenameLoading || !hasRenameFormChanges}
+                      LeadingIcon={isRenameLoading ? SpinnerWhite : undefined}
+                    >
+                      Save
+                    </Button>
+                  }
+                />
+              </Fieldset>
+            </Form>
+          </div>
+        </div>
+
+        <div>
+          <Header2 spacing>Danger zone</Header2>
+          <div className="w-full rounded-sm border border-rose-500/40 p-4">
+            <Form method="post" {...deleteForm.props}>
+              <Fieldset>
+                <InputGroup fullWidth>
+                  <Label htmlFor={projectSlug.id}>Delete project</Label>
+                  <Input
+                    {...conform.input(projectSlug, { type: "text" })}
+                    placeholder="Your project slug"
+                    icon={ExclamationTriangleIcon}
+                    onChange={(e) => setDeleteInputValue(e.target.value)}
+                  />
+                  <FormError id={projectSlug.errorId}>{projectSlug.error}</FormError>
+                  <FormError>{deleteForm.error}</FormError>
+                  <Hint>
+                    This change is irreversible, so please be certain. Type in the Project slug
+                    <InlineCode variant="extra-small">{project.slug}</InlineCode> and then press
+                    Delete.
+                  </Hint>
+                </InputGroup>
+                <FormButtons
+                  confirmButton={
+                    <Button
+                      type="submit"
+                      name="action"
+                      value="delete"
+                      variant={"danger/small"}
+                      LeadingIcon={isDeleteLoading ? SpinnerWhite : TrashIcon}
+                      leadingIconClassName="text-white"
+                      disabled={isDeleteLoading || deleteInputValue !== project.slug}
+                    >
+                      Delete
+                    </Button>
+                  }
+                />
+              </Fieldset>
+            </Form>
+          </div>
+        </div>
+      </div>
+    </MainHorizontallyCenteredContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.integrations/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.integrations/route.tsx
new file mode 100644
index 00000000000..2178d19f99b
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings.integrations/route.tsx
@@ -0,0 +1,500 @@
+import { conform, useForm } from "@conform-to/react";
+import { parse } from "@conform-to/zod";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { type ActionFunction, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData, useTypedFetcher } from "remix-typedjson";
+import { z } from "zod";
+import { MainHorizontallyCenteredContainer } from "~/components/layout/AppLayout";
+import { Button } from "~/components/primitives/Buttons";
+import { CheckboxWithLabel } from "~/components/primitives/Checkbox";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
+import { Header2 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import {
+  redirectBackWithErrorMessage,
+  redirectBackWithSuccessMessage,
+} from "~/models/message.server";
+import { ProjectSettingsService } from "~/services/projectSettings.server";
+import { ProjectSettingsPresenter } from "~/services/projectSettingsPresenter.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema, v3BillingPath, vercelResourcePath } from "~/utils/pathBuilder";
+import React, { useEffect, useState, useCallback, useRef } from "react";
+import { useSearchParams } from "@remix-run/react";
+import { type BuildSettings } from "~/v3/buildSettings";
+import { GitHubSettingsPanel } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
+import {
+  VercelSettingsPanel,
+  VercelOnboardingModal,
+} from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel";
+import type { loader as vercelLoader } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel";
+import { OrgIntegrationRepository } from "~/models/orgIntegration.server";
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { projectParam, organizationSlug } = EnvironmentParamSchema.parse(params);
+
+  const projectSettingsPresenter = new ProjectSettingsPresenter();
+  const resultOrFail = await projectSettingsPresenter.getProjectSettings(
+    organizationSlug,
+    projectParam,
+    userId
+  );
+
+  if (resultOrFail.isErr()) {
+    switch (resultOrFail.error.type) {
+      case "project_not_found": {
+        throw new Response(undefined, {
+          status: 404,
+          statusText: "Project not found",
+        });
+      }
+      case "other":
+      default: {
+        resultOrFail.error.type satisfies "other";
+
+        logger.error("Failed loading project settings", {
+          error: resultOrFail.error,
+        });
+        throw new Response(undefined, {
+          status: 400,
+          statusText: "Something went wrong, please try again!",
+        });
+      }
+    }
+  }
+
+  const { gitHubApp, buildSettings } = resultOrFail.value;
+
+  return typedjson({
+    githubAppEnabled: gitHubApp.enabled,
+    buildSettings,
+    vercelIntegrationEnabled: OrgIntegrationRepository.isVercelSupported,
+  });
+};
+
+const UpdateBuildSettingsFormSchema = z.object({
+  action: z.literal("update-build-settings"),
+  triggerConfigFilePath: z
+    .string()
+    .trim()
+    .optional()
+    .transform((val) => (val ? val.replace(/^\/+/, "") : val))
+    .refine((val) => !val || val.length <= 255, {
+      message: "Config file path must not exceed 255 characters",
+    }),
+  installCommand: z
+    .string()
+    .trim()
+    .optional()
+    .refine((val) => !val || !val.includes("\n"), {
+      message: "Install command must be a single line",
+    })
+    .refine((val) => !val || val.length <= 500, {
+      message: "Install command must not exceed 500 characters",
+    }),
+  preBuildCommand: z
+    .string()
+    .trim()
+    .optional()
+    .refine((val) => !val || !val.includes("\n"), {
+      message: "Pre-build command must be a single line",
+    })
+    .refine((val) => !val || val.length <= 500, {
+      message: "Pre-build command must not exceed 500 characters",
+    }),
+  useNativeBuildServer: z
+    .string()
+    .optional()
+    .transform((val) => val === "on"),
+});
+
+export const action: ActionFunction = async ({ request, params }) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam } = params;
+  if (!organizationSlug || !projectParam) {
+    return json({ errors: { body: "organizationSlug and projectParam are required" } }, { status: 400 });
+  }
+
+  const formData = await request.formData();
+  const submission = parse(formData, { schema: UpdateBuildSettingsFormSchema });
+
+  if (!submission.value || submission.intent !== "submit") {
+    return json(submission);
+  }
+
+  const projectSettingsService = new ProjectSettingsService();
+  const membershipResultOrFail = await projectSettingsService.verifyProjectMembership(
+    organizationSlug,
+    projectParam,
+    userId
+  );
+
+  if (membershipResultOrFail.isErr()) {
+    return json({ errors: { body: membershipResultOrFail.error.type } }, { status: 404 });
+  }
+
+  const { projectId } = membershipResultOrFail.value;
+
+  const { installCommand, preBuildCommand, triggerConfigFilePath, useNativeBuildServer } =
+    submission.value;
+
+  const resultOrFail = await projectSettingsService.updateBuildSettings(projectId, {
+    installCommand: installCommand || undefined,
+    preBuildCommand: preBuildCommand || undefined,
+    triggerConfigFilePath: triggerConfigFilePath || undefined,
+    useNativeBuildServer: useNativeBuildServer,
+  });
+
+  if (resultOrFail.isErr()) {
+    switch (resultOrFail.error.type) {
+      case "other":
+      default: {
+        resultOrFail.error.type satisfies "other";
+
+        logger.error("Failed to update build settings", {
+          error: resultOrFail.error,
+        });
+        return redirectBackWithErrorMessage(request, "Failed to update build settings");
+      }
+    }
+  }
+
+  return redirectBackWithSuccessMessage(request, "Build settings updated successfully");
+};
+
+export default function IntegrationsSettingsPage() {
+  const { githubAppEnabled, buildSettings, vercelIntegrationEnabled } =
+    useTypedLoaderData<typeof loader>();
+  const project = useProject();
+  const organization = useOrganization();
+  const environment = useEnvironment();
+  const [searchParams, setSearchParams] = useSearchParams();
+
+  // Vercel onboarding modal state
+  const hasQueryParam = searchParams.get("vercelOnboarding") === "true";
+  const nextUrl = searchParams.get("next");
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const vercelFetcher = useTypedFetcher<typeof vercelLoader>();
+
+  // Helper to open modal and ensure query param is present
+  const openVercelOnboarding = useCallback(() => {
+    setIsModalOpen(true);
+    // Ensure query param is present to maintain state during form submissions
+    if (!hasQueryParam) {
+      setSearchParams((prev) => {
+        prev.set("vercelOnboarding", "true");
+        return prev;
+      });
+    }
+  }, [hasQueryParam, setSearchParams]);
+
+  const closeVercelOnboarding = useCallback(() => {
+    // Remove query param if present
+    if (hasQueryParam) {
+      setSearchParams((prev) => {
+        prev.delete("vercelOnboarding");
+        return prev;
+      });
+    }
+    // Close modal
+    setIsModalOpen(false);
+  }, [hasQueryParam, setSearchParams]);
+
+  // When query param is present, handle modal opening
+  // Note: We don't close the modal based on data state during onboarding - only when explicitly closed
+  useEffect(() => {
+    if (hasQueryParam && vercelIntegrationEnabled) {
+      // Ensure query param is present and modal is open
+      if (vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+        // Data is loaded, ensure modal is open (query param takes precedence)
+        if (!isModalOpen) {
+          openVercelOnboarding();
+        }
+      } else if (vercelFetcher.state === "idle" && vercelFetcher.data === undefined) {
+        // Load onboarding data
+        vercelFetcher.load(
+          `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true`
+        );
+      }
+    } else if (!hasQueryParam && isModalOpen) {
+      // Query param removed but modal is open, close modal
+      setIsModalOpen(false);
+    }
+  }, [hasQueryParam, vercelIntegrationEnabled, organization.slug, project.slug, environment.slug, vercelFetcher.data, vercelFetcher.state, isModalOpen, openVercelOnboarding]);
+
+  // Ensure modal stays open when query param is present (even after data reloads)
+  // This is a safeguard to prevent the modal from closing during form submissions
+  useEffect(() => {
+    if (hasQueryParam && !isModalOpen) {
+      // Query param is present but modal is closed, open it
+      // This ensures the modal stays open during the onboarding flow
+      openVercelOnboarding();
+    }
+  }, [hasQueryParam, isModalOpen, openVercelOnboarding]);
+
+  // When data finishes loading (from query param), ensure modal is open
+  useEffect(() => {
+    if (hasQueryParam && vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+      // Data loaded and query param is present, ensure modal is open
+      if (!isModalOpen) {
+        openVercelOnboarding();
+      }
+    }
+  }, [hasQueryParam, vercelFetcher.data, vercelFetcher.state, isModalOpen, openVercelOnboarding]);
+
+  // Track if we're waiting for data from button click (not query param)
+  const waitingForButtonClickRef = useRef(false);
+
+  // Handle opening modal from button click (without query param)
+  const handleOpenVercelModal = useCallback(() => {
+    // Add query param to maintain state during form submissions
+    if (!hasQueryParam) {
+      setSearchParams((prev) => {
+        prev.set("vercelOnboarding", "true");
+        return prev;
+      });
+    }
+
+    if (vercelFetcher.data && vercelFetcher.data.onboardingData) {
+      // Data already loaded, open modal immediately
+      openVercelOnboarding();
+    } else {
+      // Need to load data first, mark that we're waiting for button click
+      waitingForButtonClickRef.current = true;
+      vercelFetcher.load(
+        `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true`
+      );
+    }
+  }, [organization.slug, project.slug, environment.slug, vercelFetcher, setSearchParams, hasQueryParam, openVercelOnboarding]);
+
+  // When data loads from button click, open modal
+  useEffect(() => {
+    if (waitingForButtonClickRef.current && vercelFetcher.data?.onboardingData && vercelFetcher.state === "idle") {
+      // Data loaded from button click, open modal and ensure query param is present
+      waitingForButtonClickRef.current = false;
+      openVercelOnboarding();
+    }
+  }, [vercelFetcher.data, vercelFetcher.state, openVercelOnboarding]);
+
+  return (
+    <>
+      <MainHorizontallyCenteredContainer className="md:mt-6">
+        <div className="flex flex-col gap-6">
+          {githubAppEnabled && (
+            <React.Fragment>
+              <div>
+                <Header2 spacing>Git settings</Header2>
+                <div className="w-full rounded-sm border border-grid-dimmed p-4">
+                  <GitHubSettingsPanel
+                    organizationSlug={organization.slug}
+                    projectSlug={project.slug}
+                    environmentSlug={environment.slug}
+                    billingPath={v3BillingPath({ slug: organization.slug })}
+                  />
+                </div>
+              </div>
+
+              {vercelIntegrationEnabled && (
+                <div>
+                  <Header2 spacing>Vercel integration</Header2>
+                  <div className="w-full rounded-sm border border-grid-dimmed p-4">
+                    <VercelSettingsPanel
+                      organizationSlug={organization.slug}
+                      projectSlug={project.slug}
+                      environmentSlug={environment.slug}
+                      onOpenVercelModal={handleOpenVercelModal}
+                      isLoadingVercelData={vercelFetcher.state === "loading" || vercelFetcher.state === "submitting"}
+                    />
+                  </div>
+                </div>
+              )}
+
+              <div>
+                <Header2 spacing>Build settings</Header2>
+                <div className="w-full rounded-sm border border-grid-dimmed p-4">
+                  <BuildSettingsForm buildSettings={buildSettings ?? {}} />
+                </div>
+              </div>
+            </React.Fragment>
+          )}
+        </div>
+      </MainHorizontallyCenteredContainer>
+
+      {/* Vercel Onboarding Modal */}
+      {vercelIntegrationEnabled && (
+        <VercelOnboardingModal
+          isOpen={isModalOpen}
+          onClose={closeVercelOnboarding}
+          onboardingData={vercelFetcher.data?.onboardingData ?? null}
+          organizationSlug={organization.slug}
+          projectSlug={project.slug}
+          environmentSlug={environment.slug}
+          hasStagingEnvironment={vercelFetcher.data?.hasStagingEnvironment ?? false}
+          hasPreviewEnvironment={vercelFetcher.data?.hasPreviewEnvironment ?? false}
+          hasOrgIntegration={vercelFetcher.data?.hasOrgIntegration ?? false}
+          nextUrl={nextUrl ?? undefined}
+          vercelManageAccessUrl={vercelFetcher.data?.vercelManageAccessUrl}
+          onDataReload={(vercelEnvironmentId) => {
+            vercelFetcher.load(
+              `${vercelResourcePath(organization.slug, project.slug, environment.slug)}?vercelOnboarding=true${
+                vercelEnvironmentId ? `&vercelEnvironmentId=${encodeURIComponent(vercelEnvironmentId)}` : ""
+              }`
+            );
+          }}
+        />
+      )}
+    </>
+  );
+}
+
+function BuildSettingsForm({ buildSettings }: { buildSettings: BuildSettings }) {
+  const lastSubmission = useActionData() as any;
+  const navigation = useNavigation();
+
+  const [hasBuildSettingsChanges, setHasBuildSettingsChanges] = useState(false);
+  const [buildSettingsValues, setBuildSettingsValues] = useState({
+    preBuildCommand: buildSettings?.preBuildCommand || "",
+    installCommand: buildSettings?.installCommand || "",
+    triggerConfigFilePath: buildSettings?.triggerConfigFilePath || "",
+    useNativeBuildServer: buildSettings?.useNativeBuildServer || false,
+  });
+
+  useEffect(() => {
+    const hasChanges =
+      buildSettingsValues.preBuildCommand !== (buildSettings?.preBuildCommand || "") ||
+      buildSettingsValues.installCommand !== (buildSettings?.installCommand || "") ||
+      buildSettingsValues.triggerConfigFilePath !== (buildSettings?.triggerConfigFilePath || "") ||
+      buildSettingsValues.useNativeBuildServer !== (buildSettings?.useNativeBuildServer || false);
+    setHasBuildSettingsChanges(hasChanges);
+  }, [buildSettingsValues, buildSettings]);
+
+  const [buildSettingsForm, fields] = useForm({
+    id: "update-build-settings",
+    lastSubmission: lastSubmission,
+    shouldRevalidate: "onSubmit",
+    onValidate({ formData }) {
+      return parse(formData, {
+        schema: UpdateBuildSettingsFormSchema,
+      });
+    },
+  });
+
+  const isBuildSettingsLoading =
+    navigation.formData?.get("action") === "update-build-settings" &&
+    (navigation.state === "submitting" || navigation.state === "loading");
+
+  return (
+    <Form method="post" {...buildSettingsForm.props}>
+      <Fieldset>
+        <InputGroup fullWidth>
+          <Label htmlFor={fields.triggerConfigFilePath.id}>Trigger config file</Label>
+          <Input
+            {...conform.input(fields.triggerConfigFilePath, { type: "text" })}
+            defaultValue={buildSettings?.triggerConfigFilePath || ""}
+            placeholder="trigger.config.ts"
+            onChange={(e) => {
+              setBuildSettingsValues((prev) => ({
+                ...prev,
+                triggerConfigFilePath: e.target.value,
+              }));
+            }}
+          />
+          <Hint>
+            Path to your Trigger configuration file, relative to the root directory of your repo.
+          </Hint>
+          <FormError id={fields.triggerConfigFilePath.errorId}>
+            {fields.triggerConfigFilePath.error}
+          </FormError>
+        </InputGroup>
+
+        <InputGroup fullWidth>
+          <Label htmlFor={fields.installCommand.id}>Install command</Label>
+          <Input
+            {...conform.input(fields.installCommand, { type: "text" })}
+            defaultValue={buildSettings?.installCommand || ""}
+            placeholder="e.g., `npm install`, `pnpm install`, or `bun install`"
+            onChange={(e) => {
+              setBuildSettingsValues((prev) => ({
+                ...prev,
+                installCommand: e.target.value,
+              }));
+            }}
+          />
+          <Hint>
+            Command to install your project dependencies. This will be run from the root directory
+            of your repo. Auto-detected by default.
+          </Hint>
+          <FormError id={fields.installCommand.errorId}>{fields.installCommand.error}</FormError>
+        </InputGroup>
+        <InputGroup fullWidth>
+          <Label htmlFor={fields.preBuildCommand.id}>Pre-build command</Label>
+          <Input
+            {...conform.input(fields.preBuildCommand, { type: "text" })}
+            defaultValue={buildSettings?.preBuildCommand || ""}
+            placeholder="e.g., `npm run prisma:generate`"
+            onChange={(e) => {
+              setBuildSettingsValues((prev) => ({
+                ...prev,
+                preBuildCommand: e.target.value,
+              }));
+            }}
+          />
+          <Hint>
+            Any command that needs to run before we build and deploy your project. This will be run
+            from the root directory of your repo.
+          </Hint>
+          <FormError id={fields.preBuildCommand.errorId}>{fields.preBuildCommand.error}</FormError>
+        </InputGroup>
+        <div className="border-t border-grid-dimmed pt-4">
+          <InputGroup>
+            <CheckboxWithLabel
+              id={fields.useNativeBuildServer.id}
+              {...conform.input(fields.useNativeBuildServer, { type: "checkbox" })}
+              label="Use native build server"
+              variant="simple/small"
+              defaultChecked={buildSettings?.useNativeBuildServer || false}
+              onChange={(isChecked) => {
+                setBuildSettingsValues((prev) => ({
+                  ...prev,
+                  useNativeBuildServer: isChecked,
+                }));
+              }}
+            />
+            <Hint>
+              Native build server builds do not rely on external build providers and will become the
+              default in the future. Version 4.2.0 or newer is required.
+            </Hint>
+            <FormError id={fields.useNativeBuildServer.errorId}>
+              {fields.useNativeBuildServer.error}
+            </FormError>
+          </InputGroup>
+        </div>
+        <FormError>{buildSettingsForm.error}</FormError>
+        <FormButtons
+          confirmButton={
+            <Button
+              type="submit"
+              name="action"
+              value="update-build-settings"
+              variant="secondary/small"
+              disabled={isBuildSettingsLoading || !hasBuildSettingsChanges}
+              LeadingIcon={isBuildSettingsLoading ? SpinnerWhite : undefined}
+            >
+              Save
+            </Button>
+          }
+        />
+      </Fieldset>
+    </Form>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx
index 66ea64cb36f..cc85dbb4acc 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx
@@ -1,49 +1,13 @@
-import { conform, useForm } from "@conform-to/react";
-import { parse } from "@conform-to/zod";
-import { ExclamationTriangleIcon, FolderIcon, TrashIcon } from "@heroicons/react/20/solid";
-import { Form, type MetaFunction, useActionData, useNavigation } from "@remix-run/react";
-import { type ActionFunction, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
-import { typedjson, useTypedLoaderData } from "remix-typedjson";
-import { z } from "zod";
-import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
-import { InlineCode } from "~/components/code/InlineCode";
-import {
-  MainHorizontallyCenteredContainer,
-  PageBody,
-  PageContainer,
-} from "~/components/layout/AppLayout";
-import { Button } from "~/components/primitives/Buttons";
-import { CheckboxWithLabel } from "~/components/primitives/Checkbox";
-import { ClipboardField } from "~/components/primitives/ClipboardField";
-import { Fieldset } from "~/components/primitives/Fieldset";
-import { FormButtons } from "~/components/primitives/FormButtons";
-import { FormError } from "~/components/primitives/FormError";
-import { Header2 } from "~/components/primitives/Headers";
-import { Hint } from "~/components/primitives/Hint";
-import { Input } from "~/components/primitives/Input";
-import { InputGroup } from "~/components/primitives/InputGroup";
-import { Label } from "~/components/primitives/Label";
+import { Outlet, type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs, redirect } from "@remix-run/server-runtime";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import * as Property from "~/components/primitives/PropertyTable";
-import { SpinnerWhite } from "~/components/primitives/Spinner";
-import { useOrganization } from "~/hooks/useOrganizations";
+import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
 import { useProject } from "~/hooks/useProject";
-import {
-  redirectBackWithErrorMessage,
-  redirectBackWithSuccessMessage,
-  redirectWithErrorMessage,
-  redirectWithSuccessMessage,
-} from "~/models/message.server";
-import { ProjectSettingsService } from "~/services/projectSettings.server";
-import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
-import { organizationPath, v3ProjectPath, EnvironmentParamSchema, v3BillingPath } from "~/utils/pathBuilder";
-import React, { useEffect, useState } from "react";
-import { useEnvironment } from "~/hooks/useEnvironment";
-import { ProjectSettingsPresenter } from "~/services/projectSettingsPresenter.server";
-import { type BuildSettings } from "~/v3/buildSettings";
-import { GitHubSettingsPanel } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github";
+import { EnvironmentParamSchema, v3ProjectSettingsGeneralPath, v3ProjectSettingsIntegrationsPath } from "~/utils/pathBuilder";
 
 export const meta: MetaFunction = () => {
   return [
@@ -54,287 +18,28 @@ export const meta: MetaFunction = () => {
 };
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
-  const userId = await requireUserId(request);
-  const { projectParam, organizationSlug } = EnvironmentParamSchema.parse(params);
+  await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
 
-  const projectSettingsPresenter = new ProjectSettingsPresenter();
-  const resultOrFail = await projectSettingsPresenter.getProjectSettings(
-    organizationSlug,
-    projectParam,
-    userId
-  );
+  // Redirect /settings to /settings/general (or /settings/integrations for Vercel onboarding)
+  const url = new URL(request.url);
+  if (url.pathname.endsWith("/settings") || url.pathname.endsWith("/settings/")) {
+    const org = { slug: organizationSlug };
+    const project = { slug: projectParam };
+    const env = { slug: envParam };
 
-  if (resultOrFail.isErr()) {
-    switch (resultOrFail.error.type) {
-      case "project_not_found": {
-        throw new Response(undefined, {
-          status: 404,
-          statusText: "Project not found",
-        });
-      }
-      case "other":
-      default: {
-        resultOrFail.error.type satisfies "other";
+    const basePath = url.searchParams.has("vercelOnboarding")
+      ? v3ProjectSettingsIntegrationsPath(org, project, env)
+      : v3ProjectSettingsGeneralPath(org, project, env);
 
-        logger.error("Failed loading project settings", {
-          error: resultOrFail.error,
-        });
-        throw new Response(undefined, {
-          status: 400,
-          statusText: "Something went wrong, please try again!",
-        });
-      }
-    }
+    return redirect(`${basePath}${url.search}`);
   }
 
-  const { gitHubApp, buildSettings } = resultOrFail.value;
-
-  return typedjson({
-    githubAppEnabled: gitHubApp.enabled,
-    buildSettings,
-  });
-};
-
-const UpdateBuildSettingsFormSchema = z.object({
-  action: z.literal("update-build-settings"),
-  triggerConfigFilePath: z
-    .string()
-    .trim()
-    .optional()
-    .transform((val) => (val ? val.replace(/^\/+/, "") : val))
-    .refine((val) => !val || val.length <= 255, {
-      message: "Config file path must not exceed 255 characters",
-    }),
-  installCommand: z
-    .string()
-    .trim()
-    .optional()
-    .refine((val) => !val || !val.includes("\n"), {
-      message: "Install command must be a single line",
-    })
-    .refine((val) => !val || val.length <= 500, {
-      message: "Install command must not exceed 500 characters",
-    }),
-  preBuildCommand: z
-    .string()
-    .trim()
-    .optional()
-    .refine((val) => !val || !val.includes("\n"), {
-      message: "Pre-build command must be a single line",
-    })
-    .refine((val) => !val || val.length <= 500, {
-      message: "Pre-build command must not exceed 500 characters",
-    }),
-  useNativeBuildServer: z
-    .string()
-    .optional()
-    .transform((val) => val === "on"),
-});
-
-type UpdateBuildSettingsFormSchema = z.infer<typeof UpdateBuildSettingsFormSchema>;
-
-export function createSchema(
-  constraints: {
-    getSlugMatch?: (slug: string) => { isMatch: boolean; projectSlug: string };
-  } = {}
-) {
-  return z.discriminatedUnion("action", [
-    z.object({
-      action: z.literal("rename"),
-      projectName: z.string().min(3, "Project name must have at least 3 characters").max(50),
-    }),
-    z.object({
-      action: z.literal("delete"),
-      projectSlug: z.string().superRefine((slug, ctx) => {
-        if (constraints.getSlugMatch === undefined) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: conform.VALIDATION_UNDEFINED,
-          });
-        } else {
-          const { isMatch, projectSlug } = constraints.getSlugMatch(slug);
-          if (isMatch) {
-            return;
-          }
-
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The slug must match ${projectSlug}`,
-          });
-        }
-      }),
-    }),
-    UpdateBuildSettingsFormSchema,
-  ]);
-}
-
-export const action: ActionFunction = async ({ request, params }) => {
-  const userId = await requireUserId(request);
-  const { organizationSlug, projectParam } = params;
-  if (!organizationSlug || !projectParam) {
-    return json({ errors: { body: "organizationSlug is required" } }, { status: 400 });
-  }
-
-  const formData = await request.formData();
-
-  const schema = createSchema({
-    getSlugMatch: (slug) => {
-      return { isMatch: slug === projectParam, projectSlug: projectParam };
-    },
-  });
-  const submission = parse(formData, { schema });
-
-  if (!submission.value || submission.intent !== "submit") {
-    return json(submission);
-  }
-
-  const projectSettingsService = new ProjectSettingsService();
-  const membershipResultOrFail = await projectSettingsService.verifyProjectMembership(
-    organizationSlug,
-    projectParam,
-    userId
-  );
-
-  if (membershipResultOrFail.isErr()) {
-    return json({ errors: { body: membershipResultOrFail.error.type } }, { status: 404 });
-  }
-
-  const { projectId } = membershipResultOrFail.value;
-
-  switch (submission.value.action) {
-    case "rename": {
-      const resultOrFail = await projectSettingsService.renameProject(
-        projectId,
-        submission.value.projectName
-      );
-
-      if (resultOrFail.isErr()) {
-        switch (resultOrFail.error.type) {
-          case "other":
-          default: {
-            resultOrFail.error.type satisfies "other";
-
-            logger.error("Failed to rename project", {
-              error: resultOrFail.error,
-            });
-            return json({ errors: { body: "Failed to rename project" } }, { status: 400 });
-          }
-        }
-      }
-
-      return redirectWithSuccessMessage(
-        v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
-        request,
-        `Project renamed to ${submission.value.projectName}`
-      );
-    }
-    case "delete": {
-      const resultOrFail = await projectSettingsService.deleteProject(projectParam, userId);
-
-      if (resultOrFail.isErr()) {
-        switch (resultOrFail.error.type) {
-          case "other":
-          default: {
-            resultOrFail.error.type satisfies "other";
-
-            logger.error("Failed to delete project", {
-              error: resultOrFail.error,
-            });
-            return redirectWithErrorMessage(
-              v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
-              request,
-              `Project ${projectParam} could not be deleted`
-            );
-          }
-        }
-      }
-
-      return redirectWithSuccessMessage(
-        organizationPath({ slug: organizationSlug }),
-        request,
-        "Project deleted"
-      );
-    }
-    case "update-build-settings": {
-      const { installCommand, preBuildCommand, triggerConfigFilePath, useNativeBuildServer } =
-        submission.value;
-
-      const resultOrFail = await projectSettingsService.updateBuildSettings(projectId, {
-        installCommand: installCommand || undefined,
-        preBuildCommand: preBuildCommand || undefined,
-        triggerConfigFilePath: triggerConfigFilePath || undefined,
-        useNativeBuildServer: useNativeBuildServer,
-      });
-
-      if (resultOrFail.isErr()) {
-        switch (resultOrFail.error.type) {
-          case "other":
-          default: {
-            resultOrFail.error.type satisfies "other";
-
-            logger.error("Failed to update build settings", {
-              error: resultOrFail.error,
-            });
-            return redirectBackWithErrorMessage(request, "Failed to update build settings");
-          }
-        }
-      }
-
-      return redirectBackWithSuccessMessage(request, "Build settings updated successfully");
-    }
-    default: {
-      submission.value satisfies never;
-      return redirectBackWithErrorMessage(request, "Failed to process request");
-    }
-  }
+  return null;
 };
 
-export default function Page() {
-  const { githubAppEnabled, buildSettings } = useTypedLoaderData<typeof loader>();
+export default function SettingsLayout() {
   const project = useProject();
-  const organization = useOrganization();
-  const environment = useEnvironment();
-  const lastSubmission = useActionData();
-  const navigation = useNavigation();
-
-  const [hasRenameFormChanges, setHasRenameFormChanges] = useState(false);
-
-  const [renameForm, { projectName }] = useForm({
-    id: "rename-project",
-    // TODO: type this
-    lastSubmission: lastSubmission as any,
-    shouldRevalidate: "onSubmit",
-    onValidate({ formData }) {
-      return parse(formData, {
-        schema: createSchema(),
-      });
-    },
-  });
-
-  const isRenameLoading =
-    navigation.formData?.get("action") === "rename" &&
-    (navigation.state === "submitting" || navigation.state === "loading");
-
-  const [deleteForm, { projectSlug }] = useForm({
-    id: "delete-project",
-    // TODO: type this
-    lastSubmission: lastSubmission as any,
-    shouldValidate: "onInput",
-    shouldRevalidate: "onSubmit",
-    onValidate({ formData }) {
-      return parse(formData, {
-        schema: createSchema({
-          getSlugMatch: (slug) => ({ isMatch: slug === project.slug, projectSlug: project.slug }),
-        }),
-      });
-    },
-  });
-
-  const isDeleteLoading =
-    navigation.formData?.get("action") === "delete" &&
-    (navigation.state === "submitting" || navigation.state === "loading");
-
-  const [deleteInputValue, setDeleteInputValue] = useState("");
 
   return (
     <PageContainer>
@@ -361,264 +66,8 @@ export default function Page() {
       </NavBar>
 
       <PageBody>
-        <MainHorizontallyCenteredContainer className="md:mt-6">
-          <div className="flex flex-col gap-6">
-            <div>
-              <Header2 spacing>General</Header2>
-              <div className="w-full rounded-sm border border-grid-dimmed p-4">
-                <Fieldset className="mb-5">
-                  <InputGroup fullWidth>
-                    <Label>Project ref</Label>
-                    <ClipboardField value={project.externalRef} variant={"secondary/medium"} />
-                    <Hint>
-                      This goes in your{" "}
-                      <InlineCode variant="extra-extra-small">trigger.config</InlineCode> file.
-                    </Hint>
-                  </InputGroup>
-                </Fieldset>
-                <Form method="post" {...renameForm.props}>
-                  <Fieldset>
-                    <InputGroup fullWidth>
-                      <Label htmlFor={projectName.id}>Project name</Label>
-                      <Input
-                        {...conform.input(projectName, { type: "text" })}
-                        defaultValue={project.name}
-                        placeholder="Project name"
-                        icon={FolderIcon}
-                        autoFocus
-                        onChange={(e) => {
-                          setHasRenameFormChanges(e.target.value !== project.name);
-                        }}
-                      />
-                      <FormError id={projectName.errorId}>{projectName.error}</FormError>
-                    </InputGroup>
-                    <FormButtons
-                      confirmButton={
-                        <Button
-                          type="submit"
-                          name="action"
-                          value="rename"
-                          variant={"secondary/small"}
-                          disabled={isRenameLoading || !hasRenameFormChanges}
-                          LeadingIcon={isRenameLoading ? SpinnerWhite : undefined}
-                        >
-                          Save
-                        </Button>
-                      }
-                    />
-                  </Fieldset>
-                </Form>
-              </div>
-            </div>
-
-            {githubAppEnabled && (
-              <React.Fragment>
-                <div>
-                  <Header2 spacing>Git settings</Header2>
-                  <div className="w-full rounded-sm border border-grid-dimmed p-4">
-                    <GitHubSettingsPanel
-                      organizationSlug={organization.slug}
-                      projectSlug={project.slug}
-                      environmentSlug={environment.slug}
-                      billingPath={v3BillingPath({ slug: organization.slug })}
-                    />
-                  </div>
-                </div>
-
-                <div>
-                  <Header2 spacing>Build settings</Header2>
-                  <div className="w-full rounded-sm border border-grid-dimmed p-4">
-                    <BuildSettingsForm buildSettings={buildSettings ?? {}} />
-                  </div>
-                </div>
-              </React.Fragment>
-            )}
-
-            <div>
-              <Header2 spacing>Danger zone</Header2>
-              <div className="w-full rounded-sm border border-rose-500/40 p-4">
-                <Form method="post" {...deleteForm.props}>
-                  <Fieldset>
-                    <InputGroup fullWidth>
-                      <Label htmlFor={projectSlug.id}>Delete project</Label>
-                      <Input
-                        {...conform.input(projectSlug, { type: "text" })}
-                        placeholder="Your project slug"
-                        icon={ExclamationTriangleIcon}
-                        onChange={(e) => setDeleteInputValue(e.target.value)}
-                      />
-                      <FormError id={projectSlug.errorId}>{projectSlug.error}</FormError>
-                      <FormError>{deleteForm.error}</FormError>
-                      <Hint>
-                        This change is irreversible, so please be certain. Type in the Project slug
-                        <InlineCode variant="extra-small">{project.slug}</InlineCode> and then press
-                        Delete.
-                      </Hint>
-                    </InputGroup>
-                    <FormButtons
-                      confirmButton={
-                        <Button
-                          type="submit"
-                          name="action"
-                          value="delete"
-                          variant={"danger/small"}
-                          LeadingIcon={isDeleteLoading ? SpinnerWhite : TrashIcon}
-                          leadingIconClassName="text-white"
-                          disabled={isDeleteLoading || deleteInputValue !== project.slug}
-                        >
-                          Delete
-                        </Button>
-                      }
-                    />
-                  </Fieldset>
-                </Form>
-              </div>
-            </div>
-          </div>
-        </MainHorizontallyCenteredContainer>
+        <Outlet />
       </PageBody>
     </PageContainer>
   );
 }
-
-function BuildSettingsForm({ buildSettings }: { buildSettings: BuildSettings }) {
-  const lastSubmission = useActionData() as any;
-  const navigation = useNavigation();
-
-  const [hasBuildSettingsChanges, setHasBuildSettingsChanges] = useState(false);
-  const [buildSettingsValues, setBuildSettingsValues] = useState({
-    preBuildCommand: buildSettings?.preBuildCommand || "",
-    installCommand: buildSettings?.installCommand || "",
-    triggerConfigFilePath: buildSettings?.triggerConfigFilePath || "",
-    useNativeBuildServer: buildSettings?.useNativeBuildServer || false,
-  });
-
-  useEffect(() => {
-    const hasChanges =
-      buildSettingsValues.preBuildCommand !== (buildSettings?.preBuildCommand || "") ||
-      buildSettingsValues.installCommand !== (buildSettings?.installCommand || "") ||
-      buildSettingsValues.triggerConfigFilePath !== (buildSettings?.triggerConfigFilePath || "") ||
-      buildSettingsValues.useNativeBuildServer !== (buildSettings?.useNativeBuildServer || false);
-    setHasBuildSettingsChanges(hasChanges);
-  }, [buildSettingsValues, buildSettings]);
-
-  const [buildSettingsForm, fields] = useForm({
-    id: "update-build-settings",
-    lastSubmission: lastSubmission,
-    shouldRevalidate: "onSubmit",
-    onValidate({ formData }) {
-      return parse(formData, {
-        schema: UpdateBuildSettingsFormSchema,
-      });
-    },
-  });
-
-  const isBuildSettingsLoading =
-    navigation.formData?.get("action") === "update-build-settings" &&
-    (navigation.state === "submitting" || navigation.state === "loading");
-
-  return (
-    <Form method="post" {...buildSettingsForm.props}>
-      <Fieldset>
-        <InputGroup fullWidth>
-          <Label htmlFor={fields.triggerConfigFilePath.id}>Trigger config file</Label>
-          <Input
-            {...conform.input(fields.triggerConfigFilePath, { type: "text" })}
-            defaultValue={buildSettings?.triggerConfigFilePath || ""}
-            placeholder="trigger.config.ts"
-            onChange={(e) => {
-              setBuildSettingsValues((prev) => ({
-                ...prev,
-                triggerConfigFilePath: e.target.value,
-              }));
-            }}
-          />
-          <Hint>
-            Path to your Trigger configuration file, relative to the root directory of your repo.
-          </Hint>
-          <FormError id={fields.triggerConfigFilePath.errorId}>
-            {fields.triggerConfigFilePath.error}
-          </FormError>
-        </InputGroup>
-
-        <InputGroup fullWidth>
-          <Label htmlFor={fields.installCommand.id}>Install command</Label>
-          <Input
-            {...conform.input(fields.installCommand, { type: "text" })}
-            defaultValue={buildSettings?.installCommand || ""}
-            placeholder="e.g., `npm install`, `pnpm install`, or `bun install`"
-            onChange={(e) => {
-              setBuildSettingsValues((prev) => ({
-                ...prev,
-                installCommand: e.target.value,
-              }));
-            }}
-          />
-          <Hint>
-            Command to install your project dependencies. This will be run from the root directory
-            of your repo. Auto-detected by default.
-          </Hint>
-          <FormError id={fields.installCommand.errorId}>{fields.installCommand.error}</FormError>
-        </InputGroup>
-        <InputGroup fullWidth>
-          <Label htmlFor={fields.preBuildCommand.id}>Pre-build command</Label>
-          <Input
-            {...conform.input(fields.preBuildCommand, { type: "text" })}
-            defaultValue={buildSettings?.preBuildCommand || ""}
-            placeholder="e.g., `npm run prisma:generate`"
-            onChange={(e) => {
-              setBuildSettingsValues((prev) => ({
-                ...prev,
-                preBuildCommand: e.target.value,
-              }));
-            }}
-          />
-          <Hint>
-            Any command that needs to run before we build and deploy your project. This will be run
-            from the root directory of your repo.
-          </Hint>
-          <FormError id={fields.preBuildCommand.errorId}>{fields.preBuildCommand.error}</FormError>
-        </InputGroup>
-        <div className="border-t border-grid-dimmed pt-4">
-          <InputGroup>
-            <CheckboxWithLabel
-              id={fields.useNativeBuildServer.id}
-              {...conform.input(fields.useNativeBuildServer, { type: "checkbox" })}
-              label="Use native build server"
-              variant="simple/small"
-              defaultChecked={buildSettings?.useNativeBuildServer || false}
-              onChange={(isChecked) => {
-                setBuildSettingsValues((prev) => ({
-                  ...prev,
-                  useNativeBuildServer: isChecked,
-                }));
-              }}
-            />
-            <Hint>
-              Native build server builds do not rely on external build providers and will become the
-              default in the future. Version 4.2.0 or newer is required.
-            </Hint>
-            <FormError id={fields.useNativeBuildServer.errorId}>
-              {fields.useNativeBuildServer.error}
-            </FormError>
-          </InputGroup>
-        </div>
-        <FormError>{buildSettingsForm.error}</FormError>
-        <FormButtons
-          confirmButton={
-            <Button
-              type="submit"
-              name="action"
-              value="update-build-settings"
-              variant="secondary/small"
-              disabled={isBuildSettingsLoading || !hasBuildSettingsChanges}
-              LeadingIcon={isBuildSettingsLoading ? SpinnerWhite : undefined}
-            >
-              Save
-            </Button>
-          }
-        />
-      </Fieldset>
-    </Form>
-  );
-}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/AIPayloadTabContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/AIPayloadTabContent.tsx
new file mode 100644
index 00000000000..3d9302356cc
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/AIPayloadTabContent.tsx
@@ -0,0 +1,377 @@
+import { CheckIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { AnimatePresence, motion } from "framer-motion";
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+import { SparkleListIcon } from "~/assets/icons/SparkleListIcon";
+import { Button } from "~/components/primitives/Buttons";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Spinner } from "~/components/primitives/Spinner";
+import { useEnvironment } from "~/hooks/useEnvironment";
+import { useOrganization } from "~/hooks/useOrganizations";
+import { useProject } from "~/hooks/useProject";
+import { cn } from "~/utils/cn";
+
+const StreamdownRenderer = lazy(() =>
+  import("streamdown").then((mod) => ({
+    default: ({ children, isAnimating }: { children: string; isAnimating: boolean }) => (
+      <mod.ShikiThemeContext.Provider value={["one-dark-pro", "one-dark-pro"]}>
+        <mod.Streamdown isAnimating={isAnimating}>{children}</mod.Streamdown>
+      </mod.ShikiThemeContext.Provider>
+    ),
+  }))
+);
+
+type StreamEventType =
+  | { type: "thinking"; content: string }
+  | { type: "result"; success: true; payload: string }
+  | { type: "result"; success: false; error: string };
+
+export function AIPayloadTabContent({
+  onPayloadGenerated,
+  payloadSchema,
+  taskIdentifier,
+  getCurrentPayload,
+}: {
+  onPayloadGenerated: (payload: string) => void;
+  payloadSchema?: unknown;
+  taskIdentifier: string;
+  getCurrentPayload?: () => string;
+}) {
+  const [prompt, setPrompt] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const isLoadingRef = useRef(false);
+  const [thinking, setThinking] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [showThinking, setShowThinking] = useState(false);
+  const [lastResult, setLastResult] = useState<"success" | "error" | null>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const organization = useOrganization();
+  const project = useProject();
+  const environment = useEnvironment();
+
+  const resourcePath = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/test/ai-generate-payload`;
+
+  const submitGeneration = useCallback(
+    async (queryPrompt: string) => {
+      if (!queryPrompt.trim() || isLoadingRef.current) return;
+
+      isLoadingRef.current = true;
+      setIsLoading(true);
+      setThinking("");
+      setError(null);
+      setShowThinking(true);
+      setLastResult(null);
+
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      abortControllerRef.current = new AbortController();
+
+      try {
+        const formData = new FormData();
+        formData.append("prompt", queryPrompt);
+        formData.append("taskIdentifier", taskIdentifier);
+        if (payloadSchema) {
+          formData.append("payloadSchema", JSON.stringify(payloadSchema));
+        }
+        const currentPayload = getCurrentPayload?.();
+        if (currentPayload) {
+          formData.append("currentPayload", currentPayload);
+        }
+
+        const response = await fetch(resourcePath, {
+          method: "POST",
+          body: formData,
+          signal: abortControllerRef.current.signal,
+        });
+
+        if (!response.ok) {
+          const errorData = (await response.json()) as { error?: string };
+          setError(errorData.error || "Failed to generate payload");
+          setIsLoading(false);
+          setLastResult("error");
+          return;
+        }
+
+        const reader = response.body?.getReader();
+        if (!reader) {
+          setError("No response stream");
+          setIsLoading(false);
+          setLastResult("error");
+          return;
+        }
+
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+
+          const lines = buffer.split("\n\n");
+          buffer = lines.pop() || "";
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const event = JSON.parse(line.slice(6)) as StreamEventType;
+                processStreamEvent(event);
+              } catch {
+                // Ignore parse errors
+              }
+            }
+          }
+        }
+
+        if (buffer.startsWith("data: ")) {
+          try {
+            const event = JSON.parse(buffer.slice(6)) as StreamEventType;
+            processStreamEvent(event);
+          } catch {
+            // Ignore parse errors
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") return;
+        setError(err instanceof Error ? err.message : "An error occurred");
+        setLastResult("error");
+      } finally {
+        isLoadingRef.current = false;
+        setIsLoading(false);
+      }
+    },
+    [resourcePath, taskIdentifier, payloadSchema, getCurrentPayload]
+  );
+
+  const processStreamEvent = useCallback(
+    (event: StreamEventType) => {
+      switch (event.type) {
+        case "thinking":
+          setThinking((prev) => prev + event.content);
+          break;
+        case "result":
+          if (event.success) {
+            onPayloadGenerated(event.payload);
+            setPrompt("");
+            setLastResult("success");
+          } else {
+            setError(event.error);
+            setLastResult("error");
+          }
+          break;
+      }
+    },
+    [onPayloadGenerated]
+  );
+
+  const handleSubmit = useCallback(
+    (e?: React.FormEvent) => {
+      e?.preventDefault();
+      submitGeneration(prompt);
+    },
+    [prompt, submitGeneration]
+  );
+
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+
+  useEffect(() => {
+    if (error) {
+      const timer = setTimeout(() => setError(null), 15000);
+      return () => clearTimeout(timer);
+    }
+  }, [error]);
+
+  const examplePrompts = payloadSchema
+    ? [
+        "Generate a valid payload",
+        "Generate a payload with edge cases",
+        "Generate a minimal payload with only required fields",
+      ]
+    : [
+        "Generate a simple JSON payload",
+        "Generate a payload with nested objects",
+        "Generate a payload with an array of items",
+      ];
+
+  return (
+    <div className="space-y-2">
+      <div
+        className="overflow-hidden rounded-md p-px"
+        style={{ background: "linear-gradient(to bottom right, #E543FF, #286399)" }}
+      >
+        <div className="overflow-hidden rounded-md bg-background-bright">
+          <div>
+            <textarea
+              ref={textareaRef}
+              name="prompt"
+              placeholder={
+                payloadSchema
+                  ? "e.g. generate a payload for a new user signup"
+                  : "e.g. generate a JSON payload with name, email, and age fields"
+              }
+              value={prompt}
+              onChange={(e) => setPrompt(e.target.value)}
+              disabled={isLoading}
+              rows={5}
+              className="m-0 min-h-10 w-full resize-none border-0 bg-background-bright px-3 py-2.5 text-sm text-text-bright scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600 placeholder:text-text-dimmed focus:border-0 focus:outline-none focus:ring-0 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0 disabled:cursor-not-allowed disabled:opacity-50"
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && !e.shiftKey && prompt.trim() && !isLoading) {
+                  e.preventDefault();
+                  handleSubmit();
+                }
+              }}
+            />
+            <div className="flex justify-end gap-2 px-2 pb-2">
+              {isLoading ? (
+                <Button
+                  type="button"
+                  variant="tertiary/small"
+                  disabled={true}
+                  LeadingIcon={Spinner}
+                  className="pl-2"
+                  iconSpacing="gap-1.5"
+                >
+                  Generating…
+                </Button>
+              ) : (
+                <Button
+                  type="button"
+                  variant="tertiary/small"
+                  disabled={!prompt.trim()}
+                  className={cn(!prompt.trim() && "opacity-50")}
+                  onClick={() => handleSubmit()}
+                >
+                  Generate payload
+                </Button>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Error message */}
+      <AnimatePresence>
+        {error && (
+          <motion.div
+            initial={{ opacity: 0, height: 0 }}
+            animate={{ opacity: 1, height: "auto" }}
+            exit={{ opacity: 0, height: 0 }}
+            transition={{ duration: 0.2 }}
+            className="overflow-hidden"
+          >
+            <div className="rounded-md border border-error/30 bg-error/10 px-3 py-2 text-sm text-error">
+              {error}
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+
+      {/* Thinking panel */}
+      <AnimatePresence>
+        {showThinking && thinking && (
+          <motion.div
+            initial={{ opacity: 0, height: 0 }}
+            animate={{ opacity: 1, height: "auto" }}
+            exit={{ opacity: 0, height: 0 }}
+            transition={{ duration: 0.2 }}
+            className="overflow-hidden"
+          >
+            <div className="px-1">
+              <div className="rounded-b-lg border-x border-b border-grid-dimmed bg-charcoal-850 p-3 pb-1">
+                <div className="mb-1 flex items-center justify-between">
+                  <div className="flex items-center gap-1">
+                    {isLoading ? (
+                      <Spinner className="size-4" />
+                    ) : lastResult === "success" ? (
+                      <CheckIcon className="size-4 text-success" />
+                    ) : lastResult === "error" ? (
+                      <XMarkIcon className="size-4 text-error" />
+                    ) : null}
+                    <span className="text-xs font-medium text-text-dimmed">
+                      {isLoading
+                        ? "AI is thinking…"
+                        : lastResult === "success"
+                          ? "Payload generated"
+                          : lastResult === "error"
+                            ? "Generation failed"
+                            : "AI response"}
+                    </span>
+                  </div>
+                  {isLoading ? (
+                    <Button
+                      variant="minimal/small"
+                      onClick={() => {
+                        if (abortControllerRef.current) {
+                          abortControllerRef.current.abort();
+                        }
+                        setIsLoading(false);
+                        setShowThinking(false);
+                        setThinking("");
+                      }}
+                      className="text-xs"
+                    >
+                      Cancel
+                    </Button>
+                  ) : (
+                    <Button
+                      variant="minimal/small"
+                      onClick={() => {
+                        setShowThinking(false);
+                        setThinking("");
+                      }}
+                      className="text-xs"
+                    >
+                      Dismiss
+                    </Button>
+                  )}
+                </div>
+                <div className="streamdown-container max-h-96 overflow-y-auto text-xs text-text-dimmed scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+                  <Suspense fallback={<p className="whitespace-pre-wrap">{thinking}</p>}>
+                    <StreamdownRenderer isAnimating={isLoading}>{thinking}</StreamdownRenderer>
+                  </Suspense>
+                </div>
+              </div>
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+
+      {/* Example prompts */}
+      <div className="pt-4">
+        <Header3 className="mb-3 text-text-bright">Example prompts</Header3>
+        <div className="flex flex-wrap gap-2">
+          {examplePrompts.map((example) => (
+            <button
+              key={example}
+              type="button"
+              disabled={isLoading}
+              onClick={() => {
+                setPrompt(example);
+                submitGeneration(example);
+              }}
+              className="group flex w-fit items-center gap-2 rounded-full border border-dashed border-charcoal-600 px-4 py-2 transition-colors hover:border-solid hover:border-indigo-500 focus-custom focus-visible:!rounded-full disabled:cursor-not-allowed disabled:opacity-50"
+            >
+              <SparkleListIcon className="size-4 shrink-0 text-text-dimmed transition group-hover:text-indigo-500" />
+              <Paragraph
+                variant="small"
+                className="text-left transition group-hover:text-text-bright"
+              >
+                {example}
+              </Paragraph>
+            </button>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/SchemaTabContent.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/SchemaTabContent.tsx
new file mode 100644
index 00000000000..b7a43a75028
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/SchemaTabContent.tsx
@@ -0,0 +1,93 @@
+import { BookOpenIcon } from "@heroicons/react/20/solid";
+import { CodeBlock } from "~/components/code/CodeBlock";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { Header3 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { TextLink } from "~/components/primitives/TextLink";
+import { docsPath } from "~/utils/pathBuilder";
+
+export function SchemaTabContent({
+  schema,
+  inferredSchema,
+}: {
+  schema?: unknown;
+  inferredSchema?: unknown;
+}) {
+  if (schema) {
+    return (
+      <div className="space-y-2">
+        <Header3 className="text-text-bright">Payload schema</Header3>
+        <Paragraph variant="extra-small" className="text-text-dimmed">
+          JSON Schema defined by this task via{" "}
+          <TextLink to={docsPath("tasks/schemaTask")}>schemaTask</TextLink>.
+        </Paragraph>
+        <CodeBlock
+          code={JSON.stringify(schema, null, 2)}
+          language="json"
+          showLineNumbers={false}
+          showOpenInModal={false}
+        />
+      </div>
+    );
+  }
+
+  if (inferredSchema) {
+    return (
+      <div className="space-y-3">
+        <Header3 className="text-text-bright">Inferred schema</Header3>
+        <Paragraph variant="extra-small" className="text-text-dimmed">
+          Schema inferred from recent run payloads. For an exact schema, use schemaTask.
+        </Paragraph>
+        <LinkButton
+          variant="docs/small"
+          LeadingIcon={BookOpenIcon}
+          to={docsPath("tasks/schemaTask")}
+        >
+          schemaTask docs
+        </LinkButton>
+        <CodeBlock
+          code={JSON.stringify(inferredSchema, null, 2)}
+          language="json"
+          showLineNumbers={false}
+          showOpenInModal={false}
+        />
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-3">
+      <Header3 className="text-text-bright">No schema defined</Header3>
+      <Paragraph variant="small" className="text-text-dimmed">
+        Use <code className="text-text-bright">schemaTask</code> to define a payload schema for this
+        task. The schema will appear here and can be used by AI to generate example payloads.
+      </Paragraph>
+      <LinkButton variant="docs/small" LeadingIcon={BookOpenIcon} to={docsPath("tasks/schemaTask")}>
+        schemaTask docs
+      </LinkButton>
+      <CodeBlock
+        code={exampleCode}
+        language="typescript"
+        showLineNumbers={false}
+        showCopyButton={false}
+        showOpenInModal={false}
+      />
+    </div>
+  );
+}
+
+const exampleCode = `import { schemaTask } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const myTask = schemaTask({
+  id: "my-task",
+  schema: z.object({
+    name: z.string(),
+    email: z.string().email(),
+    count: z.number().int().positive(),
+  }),
+  run: async (payload) => {
+    // payload is fully typed
+    console.log(payload.name);
+  },
+});`;
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/TestSidebarTabs.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/TestSidebarTabs.tsx
new file mode 100644
index 00000000000..9ea8289ab9a
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/TestSidebarTabs.tsx
@@ -0,0 +1,78 @@
+import { AISparkleIcon } from "~/assets/icons/AISparkleIcon";
+import {
+  ClientTabs,
+  ClientTabsContent,
+  ClientTabsList,
+  ClientTabsTrigger,
+} from "~/components/primitives/ClientTabs";
+
+export function TestSidebarTabs({
+  activeTab,
+  onTabChange,
+  optionsContent,
+  aiContent,
+  schemaContent,
+}: {
+  activeTab: string;
+  onTabChange: (tab: string) => void;
+  optionsContent: React.ReactNode;
+  aiContent: React.ReactNode;
+  schemaContent: React.ReactNode;
+}) {
+  return (
+    <ClientTabs
+      value={activeTab}
+      onValueChange={onTabChange}
+      className="flex h-full min-h-0 flex-col overflow-hidden pt-1"
+    >
+      <div className="h-fit overflow-x-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <ClientTabsList variant="underline" className="mx-3 shrink-0">
+          <ClientTabsTrigger
+            value="options"
+            variant="underline"
+            layoutId="test-sidebar-tabs"
+            className="shrink-0"
+          >
+            Options
+          </ClientTabsTrigger>
+          <ClientTabsTrigger
+            value="ai"
+            variant="underline"
+            layoutId="test-sidebar-tabs"
+            className="shrink-0"
+          >
+            <span className="flex items-center gap-0.5">
+              <AISparkleIcon className="size-4" /> AI
+            </span>
+          </ClientTabsTrigger>
+          <ClientTabsTrigger
+            value="schema"
+            variant="underline"
+            layoutId="test-sidebar-tabs"
+            className="shrink-0"
+          >
+            Schema
+          </ClientTabsTrigger>
+        </ClientTabsList>
+      </div>
+      <ClientTabsContent
+        value="options"
+        className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+      >
+        {optionsContent}
+      </ClientTabsContent>
+      <ClientTabsContent
+        value="ai"
+        className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+      >
+        <div className="min-w-64 p-3">{aiContent}</div>
+      </ClientTabsContent>
+      <ClientTabsContent
+        value="schema"
+        className="min-h-0 flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600"
+      >
+        <div className="min-w-64 p-3">{schemaContent}</div>
+      </ClientTabsContent>
+    </ClientTabs>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/route.tsx
index 5d6fdb80ff5..ee69419e1b7 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/route.tsx
@@ -54,7 +54,7 @@ import {
   TestTaskPresenter,
 } from "~/presenters/v3/TestTaskPresenter.server";
 import { logger } from "~/services/logger.server";
-import { requireUserId } from "~/services/session.server";
+import { requireUser } from "~/services/session.server";
 import { cn } from "~/utils/cn";
 import { docsPath, v3RunSpanPath, v3TaskParamsSchema, v3TestPath } from "~/utils/pathBuilder";
 import { TestTaskService } from "~/v3/services/testTask.server";
@@ -75,14 +75,18 @@ import { DialogClose, DialogDescription } from "@radix-ui/react-dialog";
 import { FormButtons } from "~/components/primitives/FormButtons";
 import { $replica } from "~/db.server";
 import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { RegionsPresenter, type Region } from "~/presenters/v3/RegionsPresenter.server";
+import { TestSidebarTabs } from "./TestSidebarTabs";
+import { AIPayloadTabContent } from "./AIPayloadTabContent";
+import { SchemaTabContent } from "./SchemaTabContent";
 
 type FormAction = "create-template" | "delete-template" | "run-scheduled" | "run-standard";
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
-  const userId = await requireUserId(request);
+  const user = await requireUser(request);
   const { projectParam, organizationSlug, envParam, taskParam } = v3TaskParamsSchema.parse(params);
 
-  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
   if (!project) {
     throw new Response(undefined, {
       status: 404,
@@ -90,7 +94,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     });
   }
 
-  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
   if (!environment) {
     throw new Response(undefined, {
       status: 404,
@@ -100,15 +104,28 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
   const presenter = new TestTaskPresenter($replica, clickhouseClient);
   try {
-    const result = await presenter.call({
-      userId,
-      projectId: project.id,
-      taskIdentifier: taskParam,
-      environment: environment,
+    const [result, regionsResult] = await Promise.all([
+      presenter.call({
+        userId: user.id,
+        projectId: project.id,
+        taskIdentifier: taskParam,
+        environment: environment,
+      }),
+      new RegionsPresenter().call({
+        userId: user.id,
+        projectSlug: projectParam,
+        isAdmin: user.admin || user.isImpersonating,
+      }),
+    ]);
+
+    return typedjson({ ...result, regions: regionsResult.regions });
+  } catch (error) {
+    logger.error("Failed to load test page", {
+      taskParam,
+      error: error instanceof Error ? error.message : error,
+      stack: error instanceof Error ? error.stack : undefined,
     });
 
-    return typedjson(result);
-  } catch (error) {
     return redirectWithErrorMessage(
       v3TestPath({ slug: organizationSlug }, { slug: projectParam }, environment),
       request,
@@ -118,15 +135,15 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 };
 
 export const action: ActionFunction = async ({ request, params }) => {
-  const userId = await requireUserId(request);
+  const user = await requireUser(request);
   const { organizationSlug, projectParam, envParam } = v3TaskParamsSchema.parse(params);
 
-  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
   if (!project) {
     return redirectBackWithErrorMessage(request, "Project not found");
   }
 
-  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
 
   if (!environment) {
     return redirectBackWithErrorMessage(request, "Environment not found");
@@ -290,6 +307,7 @@ export default function Page() {
           templates={result.taskRunTemplates}
           disableVersionSelection={result.disableVersionSelection}
           allowArbitraryQueues={result.allowArbitraryQueues}
+          regions={result.regions}
         />
       );
     }
@@ -304,6 +322,7 @@ export default function Page() {
           possibleTimezones={result.possibleTimezones}
           disableVersionSelection={result.disableVersionSelection}
           allowArbitraryQueues={result.allowArbitraryQueues}
+          regions={result.regions}
         />
       );
     }
@@ -324,6 +343,7 @@ function StandardTaskForm({
   templates,
   disableVersionSelection,
   allowArbitraryQueues,
+  regions,
 }: {
   task: StandardTaskResult["task"];
   queues: Required<StandardTaskResult>["queue"][];
@@ -332,6 +352,7 @@ function StandardTaskForm({
   templates: RunTemplate[];
   disableVersionSelection: boolean;
   allowArbitraryQueues: boolean;
+  regions: Region[];
 }) {
   const environment = useEnvironment();
   const { value, replace } = useSearchParams();
@@ -373,6 +394,12 @@ function StandardTaskForm({
   );
   const [queueValue, setQueueValue] = useState<string | undefined>(lastRun?.queue);
   const [machineValue, setMachineValue] = useState<string | undefined>(lastRun?.machinePreset);
+  const isDev = environment.type === "DEVELOPMENT";
+  const defaultRegion = regions.find((r) => r.isDefault);
+  const [regionValue, setRegionValue] = useState<string | undefined>(
+    isDev ? undefined : defaultRegion?.name
+  );
+
   const [maxAttemptsValue, setMaxAttemptsValue] = useState<number | undefined>(
     lastRun?.maxAttempts
   );
@@ -380,6 +407,13 @@ function StandardTaskForm({
     lastRun?.maxDurationInSeconds
   );
   const [tagsValue, setTagsValue] = useState<string[]>(lastRun?.runTags ?? []);
+  const [sidebarTab, setSidebarTab] = useState("options");
+
+  const regionItems = regions.map((r) => ({
+    value: r.name,
+    label: r.description ? `${r.name} — ${r.description}` : r.name,
+    isDefault: r.isDefault,
+  }));
 
   const queueItems = queues.map((q) => ({
     value: q.type === "task" ? `task/${q.name}` : q.name,
@@ -409,6 +443,8 @@ function StandardTaskForm({
       tags,
       version,
       machine,
+      region,
+      prioritySeconds,
     },
   ] = useForm({
     id: "test-task",
@@ -521,229 +557,298 @@ function StandardTaskForm({
           </div>
         </ResizablePanel>
         <ResizableHandle id="test-task-handle" />
-        <ResizablePanel id="test-task-options" min="300px" default="300px" max="360px">
-          <div className="h-full overflow-y-scroll scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
-            <Fieldset className="px-3 py-3">
-              <Hint>
-                Options enable you to control the execution behavior of your task.{" "}
-                <TextLink to={docsPath("triggering#options")}>Read the docs.</TextLink>
-              </Hint>
-              <InputGroup>
-                <Label htmlFor={machine.id} variant="small">
-                  Machine
-                </Label>
-                <Select
-                  {...conform.select(machine)}
-                  variant="tertiary/small"
-                  placeholder="Select machine type"
-                  dropdownIcon
-                  items={machinePresets}
-                  defaultValue={undefined}
-                  value={machineValue}
-                  setValue={(e) => {
-                    if (Array.isArray(e)) return;
-                    setMachineValue(e);
-                  }}
-                >
-                  {machinePresets.map((machine) => (
-                    <SelectItem key={machine} value={machine}>
-                      {machine}
-                    </SelectItem>
-                  ))}
-                </Select>
-                <Hint>Overrides the machine preset.</Hint>
-                <FormError id={machine.errorId}>{machine.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={version.id} variant="small">
-                  Version
-                </Label>
-                <Select
-                  {...conform.select(version)}
-                  defaultValue="latest"
-                  variant="tertiary/small"
-                  placeholder="Select version"
-                  dropdownIcon
-                  disabled={disableVersionSelection}
-                >
-                  {versions.map((version, i) => (
-                    <SelectItem key={version} value={i === 0 ? "latest" : version}>
-                      {version} {i === 0 && "(latest)"}
-                    </SelectItem>
-                  ))}
-                </Select>
-                {disableVersionSelection ? (
-                  <Hint>Only the latest version is available in the development environment.</Hint>
-                ) : (
-                  <Hint>Runs task on a specific version.</Hint>
-                )}
-                <FormError id={version.errorId}>{version.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={queue.id} variant="small">
-                  Queue
-                </Label>
-                {allowArbitraryQueues ? (
-                  <Input
-                    {...conform.input(queue, { type: "text" })}
-                    variant="small"
-                    value={queueValue ?? ""}
-                    onChange={(e) => setQueueValue(e.target.value)}
-                  />
-                ) : (
+        <ResizablePanel id="test-task-options" min="300px" default="380px" max="600px">
+          <TestSidebarTabs
+            activeTab={sidebarTab}
+            onTabChange={setSidebarTab}
+            optionsContent={
+              <Fieldset className="px-3 py-3">
+                <Hint>
+                  Options enable you to control the execution behavior of your task.{" "}
+                  <TextLink to={docsPath("triggering#options")}>Read the docs.</TextLink>
+                </Hint>
+                <InputGroup>
+                  <Label htmlFor={machine.id} variant="small">
+                    Machine
+                  </Label>
                   <Select
-                    name={queue.name}
-                    id={queue.id}
-                    placeholder="Select queue"
-                    heading="Filter queues"
+                    {...conform.select(machine)}
                     variant="tertiary/small"
+                    placeholder="Select machine type"
                     dropdownIcon
-                    items={queueItems}
-                    filter={{ keys: ["label"] }}
-                    value={queueValue}
-                    setValue={setQueueValue}
+                    items={machinePresets}
+                    defaultValue={undefined}
+                    value={machineValue}
+                    setValue={(e) => {
+                      if (Array.isArray(e)) return;
+                      setMachineValue(e);
+                    }}
                   >
-                    {(matches) =>
-                      matches.map((queueItem) => (
-                        <SelectItem
-                          key={queueItem.value}
-                          value={queueItem.value}
-                          className="max-w-[var(--popover-anchor-width)]"
-                          icon={
-                            queueItem.type === "task" ? (
-                              <TaskIcon className="size-4 shrink-0 text-blue-500" />
-                            ) : (
-                              <RectangleStackIcon className="size-4 shrink-0 text-purple-500" />
-                            )
-                          }
-                        >
-                          <div className="flex w-full min-w-0 items-center justify-between">
-                            <span className="truncate">{queueItem.label}</span>
-                            {queueItem.paused && (
-                              <Badge variant="extra-small" className="ml-1 text-warning">
-                                Paused
-                              </Badge>
-                            )}
-                          </div>
-                        </SelectItem>
-                      ))
-                    }
+                    {machinePresets.map((machine) => (
+                      <SelectItem key={machine} value={machine}>
+                        {machine}
+                      </SelectItem>
+                    ))}
                   </Select>
+                  <Hint>Overrides the machine preset.</Hint>
+                  <FormError id={machine.errorId}>{machine.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label htmlFor={version.id} variant="small">
+                    Version
+                  </Label>
+                  <Select
+                    {...conform.select(version)}
+                    defaultValue="latest"
+                    variant="tertiary/small"
+                    placeholder="Select version"
+                    dropdownIcon
+                    disabled={disableVersionSelection}
+                  >
+                    {versions.map((version, i) => (
+                      <SelectItem key={version} value={i === 0 ? "latest" : version}>
+                        {version} {i === 0 && "(latest)"}
+                      </SelectItem>
+                    ))}
+                  </Select>
+                  {disableVersionSelection ? (
+                    <Hint>
+                      Only the latest version is available in the development environment.
+                    </Hint>
+                  ) : (
+                    <Hint>Runs task on a specific version.</Hint>
+                  )}
+                  <FormError id={version.errorId}>{version.error}</FormError>
+                </InputGroup>
+                {regionItems.length > 1 && (
+                  <InputGroup>
+                    <Label htmlFor={region.id} variant="small">
+                      Region
+                    </Label>
+                    {/* Our Select primitive uses Ariakit under the hood, which treats
+                        value={undefined} as uncontrolled, keeping stale internal state when
+                        switching environments. The key forces a remount so it reinitializes
+                        with the correct defaultValue. */}
+                    <Select
+                      key={`region-${environment.id}`}
+                      {...conform.select(region)}
+                      variant="tertiary/small"
+                      placeholder={isDev ? "–" : undefined}
+                      dropdownIcon
+                      items={regionItems}
+                      defaultValue={isDev ? undefined : defaultRegion?.name}
+                      value={isDev ? undefined : regionValue}
+                      setValue={
+                        isDev
+                          ? undefined
+                          : (e) => {
+                              if (Array.isArray(e)) return;
+                              setRegionValue(e);
+                            }
+                      }
+                      disabled={isDev}
+                    >
+                      {regionItems.map((r) => (
+                        <SelectItem key={r.value} value={r.value}>
+                          {r.label}
+                          {r.isDefault ? " (default)" : ""}
+                        </SelectItem>
+                      ))}
+                    </Select>
+                    {isDev ? (
+                      <Hint>Region is not available in the development environment.</Hint>
+                    ) : (
+                      <Hint>Overrides the region for this run.</Hint>
+                    )}
+                    <FormError id={region.errorId}>{region.error}</FormError>
+                  </InputGroup>
                 )}
-                <Hint>Assign run to a specific queue.</Hint>
-                <FormError id={queue.errorId}>{queue.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={tags.id} variant="small">
-                  Tags
-                </Label>
-                <RunTagInput
-                  name={tags.name}
-                  id={tags.id}
-                  variant="small"
-                  tags={tagsValue}
-                  onTagsChange={setTagsValue}
-                />
-                <Hint>Add tags to easily filter runs.</Hint>
-                <FormError id={tags.errorId}>{tags.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={maxAttempts.id} variant="small">
-                  Max attempts
-                </Label>
-                <Input
-                  {...conform.input(maxAttempts, { type: "number" })}
-                  className="[&::-webkit-inner-spin-button]:appearance-none"
-                  variant="small"
-                  min={1}
-                  value={maxAttemptsValue}
-                  onChange={(e) =>
-                    setMaxAttemptsValue(e.target.value ? parseInt(e.target.value) : undefined)
-                  }
-                  onKeyDown={(e) => {
-                    // only allow entering integers > 1
-                    if (["-", "+", ".", "e", "E"].includes(e.key)) {
-                      e.preventDefault();
-                    }
-                  }}
-                  onBlur={(e) => {
-                    const value = parseInt(e.target.value);
-                    if (value < 1 && e.target.value !== "") {
-                      e.target.value = "1";
+                <InputGroup>
+                  <Label htmlFor={queue.id} variant="small">
+                    Queue
+                  </Label>
+                  {allowArbitraryQueues ? (
+                    <Input
+                      {...conform.input(queue, { type: "text" })}
+                      variant="small"
+                      value={queueValue ?? ""}
+                      onChange={(e) => setQueueValue(e.target.value)}
+                    />
+                  ) : (
+                    <Select
+                      name={queue.name}
+                      id={queue.id}
+                      placeholder="Select queue"
+                      heading="Filter queues"
+                      variant="tertiary/small"
+                      dropdownIcon
+                      items={queueItems}
+                      filter={{ keys: ["label"] }}
+                      value={queueValue}
+                      setValue={setQueueValue}
+                    >
+                      {(matches) =>
+                        matches.map((queueItem) => (
+                          <SelectItem
+                            key={queueItem.value}
+                            value={queueItem.value}
+                            className="max-w-[var(--popover-anchor-width)]"
+                            icon={
+                              queueItem.type === "task" ? (
+                                <TaskIcon className="size-4 shrink-0 text-blue-500" />
+                              ) : (
+                                <RectangleStackIcon className="size-4 shrink-0 text-purple-500" />
+                              )
+                            }
+                          >
+                            <div className="flex w-full min-w-0 items-center justify-between">
+                              <span className="truncate">{queueItem.label}</span>
+                              {queueItem.paused && (
+                                <Badge variant="extra-small" className="ml-1 text-warning">
+                                  Paused
+                                </Badge>
+                              )}
+                            </div>
+                          </SelectItem>
+                        ))
+                      }
+                    </Select>
+                  )}
+                  <Hint>Assign run to a specific queue.</Hint>
+                  <FormError id={queue.errorId}>{queue.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label htmlFor={tags.id} variant="small">
+                    Tags
+                  </Label>
+                  <RunTagInput
+                    name={tags.name}
+                    id={tags.id}
+                    variant="small"
+                    tags={tagsValue}
+                    onTagsChange={setTagsValue}
+                  />
+                  <Hint>Add tags to easily filter runs.</Hint>
+                  <FormError id={tags.errorId}>{tags.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label htmlFor={maxAttempts.id} variant="small">
+                    Max attempts
+                  </Label>
+                  <Input
+                    {...conform.input(maxAttempts, { type: "number" })}
+                    className="[&::-webkit-inner-spin-button]:appearance-none"
+                    variant="small"
+                    min={1}
+                    value={maxAttemptsValue}
+                    onChange={(e) =>
+                      setMaxAttemptsValue(e.target.value ? parseInt(e.target.value) : undefined)
                     }
-                  }}
-                />
-                <Hint>Retries failed runs up to the specified number of attempts.</Hint>
-                <FormError id={maxAttempts.errorId}>{maxAttempts.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label variant="small">Max duration</Label>
-                <DurationPicker
-                  name={maxDurationSeconds.name}
-                  id={maxDurationSeconds.id}
-                  value={maxDurationValue}
-                  onChange={setMaxDurationValue}
-                />
-                <Hint>Overrides the maximum compute time limit for the run.</Hint>
-                <FormError id={maxDurationSeconds.errorId}>{maxDurationSeconds.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={idempotencyKey.id} variant="small">
-                  Idempotency key
-                </Label>
-                <Input {...conform.input(idempotencyKey, { type: "text" })} variant="small" />
-                <FormError id={idempotencyKey.errorId}>{idempotencyKey.error}</FormError>
-                <Hint>
-                  Specify an idempotency key to ensure that a task is only triggered once with the
-                  same key.
-                </Hint>
-              </InputGroup>
-              <InputGroup>
-                <Label variant="small">Idempotency key TTL</Label>
-                <DurationPicker
-                  name={idempotencyKeyTTLSeconds.name}
-                  id={idempotencyKeyTTLSeconds.id}
-                />
-                <Hint>Keys expire after 30 days by default.</Hint>
-                <FormError id={idempotencyKeyTTLSeconds.errorId}>
-                  {idempotencyKeyTTLSeconds.error}
-                </FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label htmlFor={concurrencyKey.id} variant="small">
-                  Concurrency key
-                </Label>
-                <Input
-                  {...conform.input(concurrencyKey, { type: "text" })}
-                  variant="small"
-                  value={concurrencyKeyValue ?? ""}
-                  onChange={(e) => setConcurrencyKeyValue(e.target.value)}
-                />
-                <Hint>
-                  Limits concurrency by creating a separate queue for each value of the key.
-                </Hint>
-                <FormError id={concurrencyKey.errorId}>{concurrencyKey.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label variant="small">Delay</Label>
-                <DurationPicker name={delaySeconds.name} id={delaySeconds.id} />
-                <Hint>Delays run by a specific duration.</Hint>
-                <FormError id={delaySeconds.errorId}>{delaySeconds.error}</FormError>
-              </InputGroup>
-              <InputGroup>
-                <Label variant="small">TTL</Label>
-                <DurationPicker
-                  name={ttlSeconds.name}
-                  id={ttlSeconds.id}
-                  value={ttlValue}
-                  onChange={setTtlValue}
-                />
-                <Hint>Expires the run if it hasn't started within the TTL.</Hint>
-                <FormError id={ttlSeconds.errorId}>{ttlSeconds.error}</FormError>
-              </InputGroup>
-              <FormError>{form.error}</FormError>
-            </Fieldset>
-          </div>
+                    onKeyDown={(e) => {
+                      // only allow entering integers > 1
+                      if (["-", "+", ".", "e", "E"].includes(e.key)) {
+                        e.preventDefault();
+                      }
+                    }}
+                    onBlur={(e) => {
+                      const value = parseInt(e.target.value);
+                      if (value < 1 && e.target.value !== "") {
+                        e.target.value = "1";
+                      }
+                    }}
+                  />
+                  <Hint>Retries failed runs up to the specified number of attempts.</Hint>
+                  <FormError id={maxAttempts.errorId}>{maxAttempts.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label variant="small">Max duration</Label>
+                  <DurationPicker
+                    name={maxDurationSeconds.name}
+                    id={maxDurationSeconds.id}
+                    value={maxDurationValue}
+                    onChange={setMaxDurationValue}
+                  />
+                  <Hint>Overrides the maximum compute time limit for the run.</Hint>
+                  <FormError id={maxDurationSeconds.errorId}>{maxDurationSeconds.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label htmlFor={idempotencyKey.id} variant="small">
+                    Idempotency key
+                  </Label>
+                  <Input {...conform.input(idempotencyKey, { type: "text" })} variant="small" />
+                  <FormError id={idempotencyKey.errorId}>{idempotencyKey.error}</FormError>
+                  <Hint>
+                    Specify an idempotency key to ensure that a task is only triggered once with the
+                    same key.
+                  </Hint>
+                </InputGroup>
+                <InputGroup>
+                  <Label variant="small">Idempotency key TTL</Label>
+                  <DurationPicker
+                    name={idempotencyKeyTTLSeconds.name}
+                    id={idempotencyKeyTTLSeconds.id}
+                  />
+                  <Hint>Keys expire after 30 days by default.</Hint>
+                  <FormError id={idempotencyKeyTTLSeconds.errorId}>
+                    {idempotencyKeyTTLSeconds.error}
+                  </FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label htmlFor={concurrencyKey.id} variant="small">
+                    Concurrency key
+                  </Label>
+                  <Input
+                    {...conform.input(concurrencyKey, { type: "text" })}
+                    variant="small"
+                    value={concurrencyKeyValue ?? ""}
+                    onChange={(e) => setConcurrencyKeyValue(e.target.value)}
+                  />
+                  <Hint>
+                    Limits concurrency by creating a separate queue for each value of the key.
+                  </Hint>
+                  <FormError id={concurrencyKey.errorId}>{concurrencyKey.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label variant="small">Delay</Label>
+                  <DurationPicker name={delaySeconds.name} id={delaySeconds.id} />
+                  <Hint>Delays run by a specific duration.</Hint>
+                  <FormError id={delaySeconds.errorId}>{delaySeconds.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label variant="small">Priority</Label>
+                  <DurationPicker name={prioritySeconds.name} id={prioritySeconds.id} />
+                  <Hint>Sets the priority of the run. Higher values mean higher priority.</Hint>
+                  <FormError id={prioritySeconds.errorId}>{prioritySeconds.error}</FormError>
+                </InputGroup>
+                <InputGroup>
+                  <Label variant="small">TTL</Label>
+                  <DurationPicker
+                    name={ttlSeconds.name}
+                    id={ttlSeconds.id}
+                    value={ttlValue}
+                    onChange={setTtlValue}
+                  />
+                  <Hint>Expires the run if it hasn't started within the TTL.</Hint>
+                  <FormError id={ttlSeconds.errorId}>{ttlSeconds.error}</FormError>
+                </InputGroup>
+                <FormError>{form.error}</FormError>
+              </Fieldset>
+            }
+            aiContent={
+              <AIPayloadTabContent
+                onPayloadGenerated={setPayload}
+                payloadSchema={task.payloadSchema ?? task.inferredPayloadSchema}
+                taskIdentifier={task.taskIdentifier}
+                getCurrentPayload={() => currentPayloadJson.current}
+              />
+            }
+            schemaContent={
+              <SchemaTabContent
+                schema={task.payloadSchema}
+                inferredSchema={task.inferredPayloadSchema}
+              />
+            }
+          />
         </ResizablePanel>
       </ResizablePanelGroup>
       <div className="flex items-center justify-end gap-3 border-t border-grid-bright bg-background-dimmed p-2">
@@ -796,6 +901,7 @@ function ScheduledTaskForm({
   templates,
   disableVersionSelection,
   allowArbitraryQueues,
+  regions,
 }: {
   task: ScheduledTaskResult["task"];
   runs: ScheduledRun[];
@@ -805,6 +911,7 @@ function ScheduledTaskForm({
   templates: RunTemplate[];
   disableVersionSelection: boolean;
   allowArbitraryQueues: boolean;
+  regions: Region[];
 }) {
   const environment = useEnvironment();
 
@@ -826,6 +933,12 @@ function ScheduledTaskForm({
   );
   const [queueValue, setQueueValue] = useState<string | undefined>(lastRun?.queue);
   const [machineValue, setMachineValue] = useState<string | undefined>(lastRun?.machinePreset);
+  const isDev = environment.type === "DEVELOPMENT";
+  const defaultRegion = regions.find((r) => r.isDefault);
+  const [regionValue, setRegionValue] = useState<string | undefined>(
+    isDev ? undefined : defaultRegion?.name
+  );
+
   const [maxAttemptsValue, setMaxAttemptsValue] = useState<number | undefined>(
     lastRun?.maxAttempts
   );
@@ -836,6 +949,12 @@ function ScheduledTaskForm({
 
   const [showTemplateCreatedSuccessMessage, setShowTemplateCreatedSuccessMessage] = useState(false);
 
+  const regionItems = regions.map((r) => ({
+    value: r.name,
+    label: r.description ? `${r.name} — ${r.description}` : r.name,
+    isDefault: r.isDefault,
+  }));
+
   const queueItems = queues.map((q) => ({
     value: q.type === "task" ? `task/${q.name}` : q.name,
     label: q.name,
@@ -872,6 +991,8 @@ function ScheduledTaskForm({
       tags,
       version,
       machine,
+      region,
+      prioritySeconds,
     },
   ] = useForm({
     id: "test-task-scheduled",
@@ -1093,6 +1214,49 @@ function ScheduledTaskForm({
             )}
             <FormError id={version.errorId}>{version.error}</FormError>
           </InputGroup>
+          {regionItems.length > 1 && (
+            <InputGroup>
+              <Label htmlFor={region.id} variant="small">
+                Region
+              </Label>
+              {/* Our Select primitive uses Ariakit under the hood, which treats
+                  value={undefined} as uncontrolled, keeping stale internal state when
+                  switching environments. The key forces a remount so it reinitializes
+                  with the correct defaultValue. */}
+              <Select
+                key={`region-${environment.id}`}
+                {...conform.select(region)}
+                variant="tertiary/small"
+                placeholder={isDev ? "–" : undefined}
+                dropdownIcon
+                items={regionItems}
+                defaultValue={isDev ? undefined : defaultRegion?.name}
+                value={isDev ? undefined : regionValue}
+                setValue={
+                  isDev
+                    ? undefined
+                    : (e) => {
+                        if (Array.isArray(e)) return;
+                        setRegionValue(e);
+                      }
+                }
+                disabled={isDev}
+              >
+                {regionItems.map((r) => (
+                  <SelectItem key={r.value} value={r.value}>
+                    {r.label}
+                    {r.isDefault ? " (default)" : ""}
+                  </SelectItem>
+                ))}
+              </Select>
+              {isDev ? (
+                <Hint>Region is not available in the development environment.</Hint>
+              ) : (
+                <Hint>Overrides the region for this run.</Hint>
+              )}
+              <FormError id={region.errorId}>{region.error}</FormError>
+            </InputGroup>
+          )}
           <InputGroup>
             <Label htmlFor={queue.id} variant="small">
               Queue
@@ -1237,6 +1401,14 @@ function ScheduledTaskForm({
             <Hint>Limits concurrency by creating a separate queue for each value of the key.</Hint>
             <FormError id={concurrencyKey.errorId}>{concurrencyKey.error}</FormError>
           </InputGroup>
+          <InputGroup>
+            <Label htmlFor={prioritySeconds.id} variant="small">
+              Priority
+            </Label>
+            <DurationPicker name={prioritySeconds.name} id={prioritySeconds.id} />
+            <Hint>Sets the priority of the run. Higher values mean higher priority.</Hint>
+            <FormError id={prioritySeconds.errorId}>{prioritySeconds.error}</FormError>
+          </InputGroup>
           <InputGroup>
             <Label htmlFor={ttlSeconds.id} variant="small">
               TTL
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.tokens/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.tokens/route.tsx
index b3233abb858..782f3b132ff 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.tokens/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.tokens/route.tsx
@@ -13,9 +13,11 @@ import { DateTime } from "~/components/primitives/DateTime";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  RESIZABLE_PANEL_ANIMATION,
   ResizableHandle,
   ResizablePanel,
   ResizablePanelGroup,
+  collapsibleHandleClassName,
 } from "~/components/primitives/Resizable";
 import {
   Table,
@@ -240,14 +242,25 @@ export default function Page() {
                 </div>
               </div>
             </ResizablePanel>
-            {isShowingWaitpoint && (
-              <>
-                <ResizableHandle id="waitpoint-tokens-handle" />
-                <ResizablePanel id="waitpoint-tokens-inspector" min="100px" default="500px">
-                  <Outlet />
-                </ResizablePanel>
-              </>
-            )}
+            <ResizableHandle
+              id="waitpoint-tokens-handle"
+              className={collapsibleHandleClassName(isShowingWaitpoint)}
+            />
+            <ResizablePanel
+              id="waitpoint-tokens-inspector"
+              min="450px"
+              default="500px"
+              className="overflow-hidden"
+              collapsible
+              collapsed={!isShowingWaitpoint}
+              onCollapseChange={() => {}}
+              collapsedSize="0px"
+              collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+            >
+              <div className="h-full" style={{ minWidth: 450 }}>
+                <Outlet />
+              </div>
+            </ResizablePanel>
           </ResizablePanelGroup>
         )}
       </PageBody>
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam/route.tsx
index aea6b345ee7..3f4be602aa7 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam/route.tsx
@@ -19,7 +19,7 @@ export default function Project() {
 
   return (
     <>
-      <div className="grid grid-cols-[14rem_1fr] overflow-hidden">
+      <div className="grid grid-cols-[auto_1fr] overflow-hidden">
         <DevPresenceProvider enabled={environment.type === "DEVELOPMENT"}>
           <SideMenu
             user={{ ...user, isImpersonating }}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings._index/route.tsx
index e4c3967a36a..0eb496880a4 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings._index/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings._index/route.tsx
@@ -5,10 +5,12 @@ import {
   CheckIcon,
   ExclamationTriangleIcon,
   FolderIcon,
+  GlobeAltIcon,
   TrashIcon,
 } from "@heroicons/react/20/solid";
-import { Form, type MetaFunction, useActionData, useNavigation } from "@remix-run/react";
+import { Form, type MetaFunction, useActionData, useNavigation, useSubmit } from "@remix-run/react";
 import { type ActionFunction, json, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { useEffect, useRef, useState } from "react";
 import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { InlineCode } from "~/components/code/InlineCode";
@@ -26,35 +28,31 @@ import {
   parseAvatar,
   defaultAvatarHex,
   defaultAvatarColors,
+  type Avatar as AvatarT,
 } from "~/components/primitives/Avatar";
 import { Button } from "~/components/primitives/Buttons";
 import { Fieldset } from "~/components/primitives/Fieldset";
 import { FormButtons } from "~/components/primitives/FormButtons";
 import { FormError } from "~/components/primitives/FormError";
-import { Header2, Header3 } from "~/components/primitives/Headers";
+import { Header2 } from "~/components/primitives/Headers";
 import { Hint } from "~/components/primitives/Hint";
 import { Input } from "~/components/primitives/Input";
 import { InputGroup } from "~/components/primitives/InputGroup";
 import { Label } from "~/components/primitives/Label";
 import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
-import {
-  Popover,
-  PopoverContent,
-  PopoverCustomTrigger,
-  PopoverTrigger,
-} from "~/components/primitives/Popover";
-import { Spinner, SpinnerWhite } from "~/components/primitives/Spinner";
+import { Popover, PopoverContent, PopoverTrigger } from "~/components/primitives/Popover";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
 import { prisma } from "~/db.server";
-import { useOrganization } from "~/hooks/useOrganizations";
+import { useFaviconUrl } from "~/hooks/useFaviconUrl";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { clearCurrentProject } from "~/services/dashboardPreferences.server";
 import { DeleteOrganizationService } from "~/services/deleteOrganization.server";
 import { logger } from "~/services/logger.server";
 import { requireUser, requireUserId } from "~/services/session.server";
 import { cn } from "~/utils/cn";
+import { extractDomain, faviconUrl as buildFaviconUrl } from "~/utils/favicon";
 import {
   OrganizationParamsSchema,
-  organizationPath,
   organizationSettingsPath,
   rootPath,
 } from "~/utils/pathBuilder";
@@ -79,6 +77,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       slug: true,
       title: true,
       avatar: true,
+      onboardingData: true,
     },
   });
 
@@ -86,8 +85,21 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     throw new Response("Not found", { status: 404 });
   }
 
+  const onboardingData = toRecord(organization.onboardingData);
+
+  const parsedAvatar = parseAvatar(organization.avatar, defaultAvatar);
+  const lastIconHex =
+    parsedAvatar.type === "image" && parsedAvatar.lastIconHex
+      ? parsedAvatar.lastIconHex
+      : defaultAvatarHex;
+
   return typedjson({
-    organization: { ...organization, avatar: parseAvatar(organization.avatar, defaultAvatar) },
+    organization: {
+      ...organization,
+      avatar: parsedAvatar,
+      companyUrl: typeof onboardingData.companyUrl === "string" ? onboardingData.companyUrl : "",
+      lastIconHex,
+    },
   });
 };
 
@@ -102,6 +114,7 @@ export function createSchema(
       type: AvatarType,
       name: z.string().optional(),
       hex: z.string().optional(),
+      url: z.string().optional(),
     }),
     z.object({
       action: z.literal("rename"),
@@ -199,6 +212,43 @@ export const action: ActionFunction = async ({ request, params }) => {
         }
       }
       case "avatar": {
+        const orgWhere = {
+          slug: organizationSlug,
+          members: { some: { userId: user.id } },
+        };
+
+        if (submission.value.type === "image") {
+          const url = submission.value.url ?? "";
+          const domain = url ? extractDomain(url) : null;
+
+          const existing = await prisma.organization.findFirst({
+            where: orgWhere,
+            select: { avatar: true, onboardingData: true },
+          });
+
+          const existingData = toRecord(existing?.onboardingData);
+          const existingAvatar = parseAvatar(existing?.avatar ?? null, defaultAvatar);
+          const lastIconHex = extractLastIconHex(existingAvatar);
+
+          await prisma.organization.update({
+            where: orgWhere,
+            data: {
+              avatar: {
+                type: "image",
+                url: domain ? buildFaviconUrl(domain) : "",
+                ...(lastIconHex ? { lastIconHex } : {}),
+              },
+              onboardingData: { ...existingData, companyUrl: url },
+            },
+          });
+
+          return redirectWithSuccessMessage(
+            organizationSettingsPath({ slug: organizationSlug }),
+            request,
+            `Updated logo`
+          );
+        }
+
         const avatar = AvatarData.safeParse(submission.value);
 
         if (!avatar.success) {
@@ -210,14 +260,7 @@ export const action: ActionFunction = async ({ request, params }) => {
         }
 
         await prisma.organization.update({
-          where: {
-            slug: organizationSlug,
-            members: {
-              some: {
-                userId: user.id,
-              },
-            },
-          },
+          where: orgWhere,
           data: {
             avatar: avatar.data,
           },
@@ -226,12 +269,13 @@ export const action: ActionFunction = async ({ request, params }) => {
         return redirectWithSuccessMessage(
           organizationSettingsPath({ slug: organizationSlug }),
           request,
-          `Updated icon`
+          `Updated logo`
         );
       }
     }
-  } catch (error: any) {
-    return json({ errors: { body: error.message } }, { status: 400 });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : "An unexpected error occurred";
+    return json({ errors: { body: message } }, { status: 400 });
   }
 };
 
@@ -374,89 +418,164 @@ export default function Page() {
   );
 }
 
-function LogoForm({ organization }: { organization: { avatar: Avatar; title: string } }) {
+function LogoForm({
+  organization,
+}: {
+  organization: { avatar: AvatarT; title: string; companyUrl: string; lastIconHex: string };
+}) {
   const navigation = useNavigation();
 
-  const isSubmitting =
-    navigation.state != "idle" && navigation.formData?.get("action") === "avatar";
-
   const avatar = navigation.formData
     ? avatarFromFormData(navigation.formData) ?? organization.avatar
     : organization.avatar;
 
-  const hex = "hex" in avatar ? avatar.hex : defaultAvatarHex;
+  const hex =
+    "hex" in avatar
+      ? avatar.hex
+      : avatar.type === "image" && avatar.lastIconHex
+        ? avatar.lastIconHex
+        : organization.lastIconHex;
+  const mode: "logo" | "icon" = avatar.type === "image" ? "logo" : "icon";
+
+  const [companyUrl, setCompanyUrl] = useState(organization.companyUrl);
+  const faviconPreview = useFaviconUrl(companyUrl);
+  const [faviconError, setFaviconError] = useState(false);
+  const logoFormRef = useRef<HTMLFormElement>(null);
+  const submit = useSubmit();
+  const prevFaviconRef = useRef(faviconPreview);
+
+  useEffect(() => {
+    if (faviconPreview === prevFaviconRef.current) return;
+    prevFaviconRef.current = faviconPreview;
+    if (mode === "logo" && logoFormRef.current) {
+      submit(logoFormRef.current);
+    }
+  }, [faviconPreview, mode, submit]);
+
+  const showFavicon = faviconPreview && !faviconError;
 
   return (
     <Fieldset>
       <InputGroup fullWidth>
-        <Label>Icon</Label>
-        <div className="flex w-full items-end justify-between gap-2">
-          <div className="grid place-items-center overflow-hidden rounded-sm border border-charcoal-750 bg-background-bright">
-            <Avatar avatar={avatar} size={5} includePadding orgName={organization.title} />
-          </div>
-          {/* Letters */}
-          <Form method="post">
+        <Label>Logo</Label>
+        <div className="flex flex-col gap-3">
+          {/* Row 1: Logo from URL */}
+          <Form ref={logoFormRef} method="post" className="flex items-center gap-3">
             <input type="hidden" name="action" value="avatar" />
-            <input type="hidden" name="type" value="letters" />
-            <input type="hidden" name="hex" value={hex} />
-            <button
-              type="submit"
-              className={cn(
-                "box-content grid size-10 place-items-center rounded-sm border-2 bg-charcoal-775",
-                avatar.type === "letters"
-                  ? undefined
-                  : "border-charcoal-775 hover:border-charcoal-600"
-              )}
-              style={{
-                borderColor: avatar.type === "letters" ? hex : undefined,
-              }}
-            >
-              <Avatar
-                avatar={{
-                  type: "letters",
-                  hex,
-                }}
-                size={2.5}
-                includePadding
-                orgName={organization.title}
-              />
+            <input type="hidden" name="type" value="image" />
+            <input type="hidden" name="url" value={companyUrl} />
+            <button type="submit" className="flex shrink-0 items-center gap-3">
+              <RadioDot active={mode === "logo"} />
             </button>
-          </Form>
-          {/* Icons */}
-          {Object.entries(avatarIcons).map(([name]) => (
-            <Form key={name} method="post">
-              <input type="hidden" name="action" value="avatar" />
-              <input type="hidden" name="type" value="icon" />
-              <input type="hidden" name="name" value={name} />
-              <input type="hidden" name="hex" value={hex} />
+            <div className="flex flex-1 items-center gap-1.5">
               <button
                 type="submit"
                 className={cn(
-                  "box-content grid size-10 place-items-center rounded-sm border-2 bg-charcoal-775",
-                  avatar.type === "icon" && avatar.name === name
-                    ? undefined
+                  iconTileClass,
+                  mode === "logo"
+                    ? "border-indigo-500"
                     : "border-charcoal-775 hover:border-charcoal-600"
                 )}
-                style={{
-                  borderColor: avatar.type === "icon" && avatar.name === name ? hex : undefined,
-                }}
               >
-                <Avatar
-                  key={name}
-                  avatar={{
-                    type: "icon",
-                    name,
-                    hex,
-                  }}
-                  size={2.5}
-                  includePadding
-                  orgName={organization.title}
-                />
+                {showFavicon ? (
+                  <img
+                    src={faviconPreview}
+                    alt=""
+                    width={28}
+                    height={28}
+                    className="rounded-sm"
+                    onError={() => setFaviconError(true)}
+                    onLoad={() => setFaviconError(false)}
+                  />
+                ) : (
+                  <GlobeAltIcon className="size-6 text-text-dimmed" />
+                )}
+              </button>
+              <Input
+                type="text"
+                value={companyUrl}
+                onChange={(e) => {
+                  setCompanyUrl(e.target.value);
+                  setFaviconError(false);
+                }}
+                onFocus={() => {
+                  if (mode !== "logo" && logoFormRef.current) {
+                    submit(logoFormRef.current);
+                  }
+                }}
+                placeholder="Enter your company URL to generate a logo"
+                variant="medium"
+                containerClassName="flex-1"
+              />
+            </div>
+          </Form>
+
+          {/* Row 2: Icon picker */}
+          <div className="flex items-center gap-3">
+            <Form method="post" className="shrink-0">
+              <input type="hidden" name="action" value="avatar" />
+              <input type="hidden" name="type" value="letters" />
+              <input type="hidden" name="hex" value={hex} />
+              <button type="submit">
+                <RadioDot active={mode === "icon"} />
               </button>
             </Form>
-          ))}
-          {/* Hex */}
-          <HexPopover avatar={avatar} hex={hex} />
+            <div className="flex flex-wrap items-center gap-1.5">
+              {/* Letters */}
+              <Form method="post">
+                <input type="hidden" name="action" value="avatar" />
+                <input type="hidden" name="type" value="letters" />
+                <input type="hidden" name="hex" value={hex} />
+                <button
+                  type="submit"
+                  className={cn(
+                    iconTileClass,
+                    avatar.type !== "letters" && "border-charcoal-775 hover:border-charcoal-600"
+                  )}
+                  style={{
+                    borderColor: avatar.type === "letters" ? hex : undefined,
+                  }}
+                >
+                  <Avatar
+                    avatar={{ type: "letters", hex }}
+                    size={2.5}
+                    includePadding
+                    orgName={organization.title}
+                  />
+                </button>
+              </Form>
+              {/* Icons */}
+              {Object.entries(avatarIcons).map(([name]) => (
+                <Form key={name} method="post">
+                  <input type="hidden" name="action" value="avatar" />
+                  <input type="hidden" name="type" value="icon" />
+                  <input type="hidden" name="name" value={name} />
+                  <input type="hidden" name="hex" value={hex} />
+                  <button
+                    type="submit"
+                    className={cn(
+                      iconTileClass,
+                      !(avatar.type === "icon" && avatar.name === name) &&
+                        "border-charcoal-775 hover:border-charcoal-600"
+                    )}
+                    style={{
+                      borderColor:
+                        avatar.type === "icon" && avatar.name === name ? hex : undefined,
+                    }}
+                  >
+                    <Avatar
+                      avatar={{ type: "icon", name, hex }}
+                      size={2.5}
+                      includePadding
+                      orgName={organization.title}
+                    />
+                  </button>
+                </Form>
+              ))}
+              {/* Color picker */}
+              <HexPopover avatar={avatar} hex={hex} />
+            </div>
+          </div>
         </div>
       </InputGroup>
     </Fieldset>
@@ -466,7 +585,7 @@ function LogoForm({ organization }: { organization: { avatar: Avatar; title: str
 function HexPopover({ avatar, hex }: { avatar: Avatar; hex: string }) {
   return (
     <Popover>
-      <PopoverTrigger className="box-content grid size-10 place-items-center rounded-sm border-2 border-charcoal-775 bg-charcoal-775 hover:border-charcoal-600">
+      <PopoverTrigger className={cn(iconTileClass, "border-charcoal-775 hover:border-charcoal-600")}>
         <img src={colorWheelIcon} className="m-0 block size-[30px] p-0" />
       </PopoverTrigger>
       <PopoverContent
@@ -474,10 +593,10 @@ function HexPopover({ avatar, hex }: { avatar: Avatar; hex: string }) {
         align="start"
         style={{ maxHeight: `calc(var(--radix-popover-content-available-height) - 10vh)` }}
       >
-        <Form method="post" className="flex w-fit min-w-40 flex-col gap-1 ">
+        <Form method="post" className="flex w-fit min-w-40 flex-col gap-1">
           <input type="hidden" name="action" value="avatar" />
-          <input type="hidden" name="type" value={avatar.type} />
-          {"name" in avatar && <input type="hidden" name="name" value={avatar.name} />}
+          <input type="hidden" name="type" value={avatar.type === "image" ? "letters" : avatar.type} />
+          {avatar.type === "icon" && <input type="hidden" name="name" value={avatar.name} />}
           {defaultAvatarColors.map((color) => (
             <Button
               key={color.hex}
@@ -511,29 +630,52 @@ function HexPopover({ avatar, hex }: { avatar: Avatar; hex: string }) {
   );
 }
 
-function avatarFromFormData(formData: FormData): Avatar | undefined {
-  const action = formData.get("action");
-  if (!action || action !== "avatar") {
-    return undefined;
-  }
-
-  const type = formData.get("type");
-  const hex = formData.get("hex");
+function RadioDot({ active }: { active: boolean }) {
+  return (
+    <div
+      className={cn(
+        "flex shrink-0 items-center justify-center rounded-full border-2 p-0.5 transition",
+        active ? "border-indigo-500" : "border-charcoal-700 hover:border-charcoal-600"
+      )}
+    >
+      <div
+        className="size-2 rounded-full"
+        style={{ backgroundColor: active ? "#6366f1" : "transparent" }}
+      />
+    </div>
+  );
+}
 
-  if (type === "letters") {
-    return {
-      type: "letters",
-      hex: hex as string,
-    };
-  }
+const iconTileClass = "box-content grid size-10 shrink-0 place-items-center rounded-sm border-2 bg-charcoal-775";
 
-  if (type === "icon") {
-    return {
-      type: "icon",
-      name: formData.get("name") as string,
-      hex: hex as string,
-    };
-  }
+function toRecord(json: unknown): Record<string, unknown> {
+  return json && typeof json === "object" ? (json as Record<string, unknown>) : {};
+}
 
+function extractLastIconHex(avatar: AvatarT): string | undefined {
+  if ("hex" in avatar) return avatar.hex;
+  if (avatar.type === "image") return avatar.lastIconHex;
   return undefined;
 }
+
+function avatarFromFormData(formData: FormData): AvatarT | undefined {
+  const action = formData.get("action");
+  if (action !== "avatar") return undefined;
+
+  const type = formData.get("type");
+  const hex = formData.get("hex") as string;
+
+  switch (type) {
+    case "letters":
+      return { type: "letters", hex };
+    case "icon":
+      return { type: "icon", name: formData.get("name") as string, hex };
+    case "image": {
+      const url = formData.get("url") as string;
+      const domain = url ? extractDomain(url) : null;
+      return { type: "image", url: domain ? buildFaviconUrl(domain) : "" };
+    }
+    default:
+      return undefined;
+  }
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.billing-alerts/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.billing-alerts/route.tsx
index eb0a8138b08..c4f8762639b 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.billing-alerts/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.billing-alerts/route.tsx
@@ -24,12 +24,13 @@ import { Label } from "~/components/primitives/Label";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { TextLink } from "~/components/primitives/TextLink";
+import { InfoIconTooltip } from "~/components/primitives/Tooltip";
 import { prisma } from "~/db.server";
 import { featuresForRequest } from "~/features.server";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { getBillingAlerts, setBillingAlert } from "~/services/platform.v3.server";
 import { requireUserId } from "~/services/session.server";
-import { formatCurrency } from "~/utils/numberFormatter";
+import { formatCurrency, formatNumber } from "~/utils/numberFormatter";
 import {
   docsPath,
   OrganizationParamsSchema,
@@ -183,6 +184,8 @@ export default function Page() {
 
   const checkboxLevels = [0.75, 0.9, 1.0, 2.0, 5.0];
 
+  const spikeAlertLevels = [10.0, 20.0, 50.0, 100.0];
+
   useEffect(() => {
     if (alerts.emails.length > 0) {
       requestIntent(form.ref.current ?? undefined, list.append(emails.name));
@@ -272,6 +275,39 @@ export default function Page() {
                   ))}
                   <FormError id={alertLevels.errorId}>{alertLevels.error}</FormError>
                 </InputGroup>
+                <InputGroup fullWidth>
+                  <div className="flex items-center gap-1">
+                    <Label>Spike alerts</Label>
+                    <InfoIconTooltip
+                      content={
+                        "Catch runaway usage from bugs or errors. We recommend keeping these enabled as a safety net."
+                      }
+                      disableHoverableContent
+                    />
+                  </div>
+                  {spikeAlertLevels.map((level) => (
+                    <CheckboxWithLabel
+                      name={alertLevels.name}
+                      id={`level_${level}`}
+                      key={level}
+                      value={level.toString()}
+                      variant="simple/small"
+                      label={
+                        <span>
+                          {formatNumber(level * 100)}%{" "}
+                          <span className="text-text-dimmed">
+                            ({formatCurrency(Number(dollarAmount) * level, false)})
+                          </span>
+                        </span>
+                      }
+                      defaultChecked={
+                        alerts.alertLevels.includes(level) ||
+                        !spikeAlertLevels.some((l) => alerts.alertLevels.includes(l))
+                      }
+                      className="pr-0"
+                    />
+                  ))}
+                </InputGroup>
                 <InputGroup fullWidth>
                   <Label htmlFor={emails.id}>Email addresses</Label>
                   {emailFields.map((email, index) => (
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.slack.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.slack.tsx
new file mode 100644
index 00000000000..ba11cf8f8a1
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.slack.tsx
@@ -0,0 +1,343 @@
+import { type ActionFunctionArgs, type LoaderFunctionArgs, json, redirect } from "@remix-run/node";
+import { fromPromise } from "neverthrow";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { TrashIcon } from "@heroicons/react/20/solid";
+import { IconBugFilled } from "@tabler/icons-react";
+import { SlackMonoIcon } from "~/assets/icons/SlackMonoIcon";
+import { Button } from "~/components/primitives/Buttons";
+import { DateTime } from "~/components/primitives/DateTime";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "~/components/primitives/Dialog";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { Header2, Header3 } from "~/components/primitives/Headers";
+import { Hint } from "~/components/primitives/Hint";
+import {
+  MainHorizontallyCenteredContainer,
+  PageBody,
+  PageContainer,
+} from "~/components/layout/AppLayout";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { EnabledStatus } from "~/components/runs/v3/EnabledStatus";
+import { $transaction, prisma } from "~/db.server";
+import { requireOrganization } from "~/services/org.server";
+import { OrganizationParamsSchema, organizationSlackIntegrationPath } from "~/utils/pathBuilder";
+import { logger } from "~/services/logger.server";
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const { organization } = await requireOrganization(request, organizationSlug);
+
+  const slackIntegration = await prisma.organizationIntegration.findFirst({
+    where: {
+      organizationId: organization.id,
+      service: "SLACK",
+      deletedAt: null,
+    },
+  });
+
+  if (!slackIntegration) {
+    return typedjson({
+      organization,
+      slackIntegration: null,
+      alertChannels: [],
+      teamName: null,
+    });
+  }
+
+  const integrationData = slackIntegration.integrationData as any;
+  const teamName = integrationData?.team?.name ?? null;
+
+  const alertChannels = await prisma.projectAlertChannel.findMany({
+    where: {
+      type: "SLACK",
+      project: { organizationId: organization.id },
+      OR: [
+        { integrationId: slackIntegration.id },
+        {
+          properties: {
+            path: ["integrationId"],
+            equals: slackIntegration.id,
+          },
+        },
+      ],
+    },
+    include: {
+      project: {
+        select: {
+          id: true,
+          slug: true,
+          name: true,
+        },
+      },
+    },
+    orderBy: {
+      createdAt: "desc",
+    },
+  });
+
+  return typedjson({
+    organization,
+    slackIntegration,
+    alertChannels,
+    teamName,
+  });
+};
+
+const ActionSchema = z.object({
+  intent: z.literal("uninstall"),
+});
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const { organization, userId } = await requireOrganization(request, organizationSlug);
+
+  const formData = await request.formData();
+  const result = ActionSchema.safeParse({ intent: formData.get("intent") });
+  if (!result.success) {
+    return json({ error: "Invalid action" }, { status: 400 });
+  }
+
+  const slackIntegration = await prisma.organizationIntegration.findFirst({
+    where: {
+      organizationId: organization.id,
+      service: "SLACK",
+      deletedAt: null,
+    },
+  });
+
+  if (!slackIntegration) {
+    return json({ error: "Slack integration not found" }, { status: 404 });
+  }
+
+  const txResult = await fromPromise(
+    $transaction(prisma, async (tx) => {
+      await tx.projectAlertChannel.updateMany({
+        where: {
+          type: "SLACK",
+          OR: [
+            { integrationId: slackIntegration.id },
+            {
+              properties: {
+                path: ["integrationId"],
+                equals: slackIntegration.id,
+              },
+            },
+          ],
+        },
+        data: {
+          enabled: false,
+          integrationId: null,
+        },
+      });
+
+      await tx.organizationIntegration.update({
+        where: { id: slackIntegration.id },
+        data: { deletedAt: new Date() },
+      });
+    }),
+    (error) => error
+  );
+
+  if (txResult.isErr()) {
+    logger.error("Failed to remove Slack integration", {
+      organizationId: organization.id,
+      organizationSlug,
+      userId,
+      integrationId: slackIntegration.id,
+      error: txResult.error instanceof Error ? txResult.error.message : String(txResult.error),
+    });
+
+    return json(
+      { error: "Failed to remove Slack integration. Please try again." },
+      { status: 500 }
+    );
+  }
+
+  logger.info("Slack integration removed successfully", {
+    organizationId: organization.id,
+    organizationSlug,
+    userId,
+    integrationId: slackIntegration.id,
+  });
+
+  return redirect(organizationSlackIntegrationPath({ slug: organizationSlug }));
+};
+
+export default function SlackIntegrationPage() {
+  const { slackIntegration, alertChannels, teamName } = useTypedLoaderData<typeof loader>();
+  const actionData = useActionData<typeof action>();
+  const navigation = useNavigation();
+  const isUninstalling =
+    navigation.state === "submitting" && navigation.formData?.get("intent") === "uninstall";
+
+  if (!slackIntegration) {
+    return (
+      <PageContainer>
+        <NavBar>
+          <PageTitle title="Slack integration" />
+        </NavBar>
+        <PageBody>
+          <div className="flex h-full flex-col items-center justify-center gap-3">
+            <SlackMonoIcon className="mb-2 size-16 text-charcoal-650" />
+            <Header2>No Slack integration found</Header2>
+            <Paragraph className="max-w-md text-center text-text-dimmed">
+              Your organization doesn't have a Slack integration configured. You can connect Slack
+              when setting up alerts from the{" "}
+              <IconBugFilled className="-ml-0.5 mb-0.5 inline size-5 text-errors" />
+              <span className="text-text-bright">Errors</span> page.
+            </Paragraph>
+          </div>
+        </PageBody>
+      </PageContainer>
+    );
+  }
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Slack integration" />
+      </NavBar>
+      <PageBody>
+        <MainHorizontallyCenteredContainer>
+          <div className="flex flex-col gap-6">
+            <div>
+              <div className="mb-3 border-b border-grid-dimmed pb-3">
+                <Header2>Integration details</Header2>
+              </div>
+              <div className="flex flex-col gap-1">
+                {teamName && (
+                  <Paragraph variant="small">
+                    <span className="text-text-dimmed">Workspace:</span>{" "}
+                    <span className="text-text-bright">{teamName}</span>
+                  </Paragraph>
+                )}
+                <Paragraph variant="small">
+                  <span className="text-text-dimmed">Installed:</span>{" "}
+                  <span className="text-text-bright">
+                    <DateTime date={slackIntegration.createdAt} />
+                  </span>
+                </Paragraph>
+              </div>
+            </div>
+
+            <div>
+              <Header3 spacing>
+                Connected alert channels
+                <span className="ml-1 text-text-dimmed">({alertChannels.length})</span>
+              </Header3>
+              {alertChannels.length === 0 ? (
+                <Paragraph variant="small" className="text-text-dimmed">
+                  No alert channels are currently connected to this Slack integration.
+                </Paragraph>
+              ) : (
+                <Table>
+                  <TableHeader>
+                    <TableRow>
+                      <TableHeaderCell>Channel</TableHeaderCell>
+                      <TableHeaderCell>Project</TableHeaderCell>
+                      <TableHeaderCell>Status</TableHeaderCell>
+                      <TableHeaderCell>Created</TableHeaderCell>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    {alertChannels.map((channel) => (
+                      <TableRow key={channel.id}>
+                        <TableCell>{channel.name}</TableCell>
+                        <TableCell>{channel.project.name}</TableCell>
+                        <TableCell>
+                          <EnabledStatus enabled={channel.enabled} />
+                        </TableCell>
+                        <TableCell>
+                          <DateTime date={channel.createdAt} />
+                        </TableCell>
+                      </TableRow>
+                    ))}
+                  </TableBody>
+                </Table>
+              )}
+            </div>
+
+            <div>
+              <Header2 spacing>Danger zone</Header2>
+              <div className="w-full rounded-sm border border-rose-500/40 p-4">
+                <Header3 spacing>Remove integration</Header3>
+                <Hint>
+                  This will remove the Slack integration and disable all connected alert channels.
+                  This action cannot be undone.
+                </Hint>
+                {actionData?.error && (
+                  <Paragraph variant="small" className="mt-2 text-error">
+                    {actionData.error}
+                  </Paragraph>
+                )}
+                <FormButtons
+                  className="mt-2"
+                  confirmButton={
+                    <Dialog>
+                      <DialogTrigger asChild>
+                        <Button
+                          variant="danger/small"
+                          LeadingIcon={TrashIcon}
+                          disabled={isUninstalling}
+                        >
+                          Remove integration
+                        </Button>
+                      </DialogTrigger>
+                      <DialogContent>
+                        <DialogHeader>
+                          <DialogTitle>Remove Slack integration</DialogTitle>
+                        </DialogHeader>
+                        <DialogDescription className="mb-2">
+                          This will remove the Slack integration and disable all connected alert
+                          channels. This action cannot be undone.
+                        </DialogDescription>
+                        <FormButtons
+                          confirmButton={
+                            <Form method="post">
+                              <input type="hidden" name="intent" value="uninstall" />
+                              <Button
+                                variant="danger/medium"
+                                LeadingIcon={TrashIcon}
+                                type="submit"
+                                disabled={isUninstalling}
+                              >
+                                {isUninstalling ? "Removing…" : "Remove integration"}
+                              </Button>
+                            </Form>
+                          }
+                          cancelButton={
+                            <DialogClose asChild>
+                              <Button variant="tertiary/medium">Cancel</Button>
+                            </DialogClose>
+                          }
+                        />
+                      </DialogContent>
+                    </Dialog>
+                  }
+                />
+              </div>
+            </div>
+          </div>
+        </MainHorizontallyCenteredContainer>
+      </PageBody>
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx
new file mode 100644
index 00000000000..df6f5b9859a
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx
@@ -0,0 +1,375 @@
+import type {
+  ActionFunctionArgs,
+  LoaderFunctionArgs,
+} from "@remix-run/node";
+import { json, redirect } from "@remix-run/node";
+import { fromPromise } from "neverthrow";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { Button } from "~/components/primitives/Buttons";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "~/components/primitives/Dialog";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { Header1 } from "~/components/primitives/Headers";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Table, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow } from "~/components/primitives/Table";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
+import { $transaction, prisma } from "~/db.server";
+import { requireOrganization } from "~/services/org.server";
+import { OrganizationParamsSchema } from "~/utils/pathBuilder";
+import { logger } from "~/services/logger.server";
+import { TrashIcon } from "@heroicons/react/20/solid";
+import { v3ProjectSettingsIntegrationsPath } from "~/utils/pathBuilder";
+import { LinkButton } from "~/components/primitives/Buttons";
+
+function formatDate(date: Date): string {
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true,
+  }).format(date);
+}
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const url = new URL(request.url);
+  const configurationId = url.searchParams.get("configurationId") ?? undefined;
+  const { organization } = await requireOrganization(request, organizationSlug);
+  
+  // Find Vercel integration for this organization
+  let vercelIntegration = await prisma.organizationIntegration.findFirst({
+    where: {
+      organizationId: organization.id,
+      service: "VERCEL",
+      deletedAt: null,
+      // If configurationId is provided, filter by it in integrationData
+      ...(configurationId && {
+        integrationData: {
+          path: ["installationId"],
+          equals: configurationId,
+        },
+      }),
+    },
+    include: {
+      tokenReference: true,
+    },
+  });
+
+  if (!vercelIntegration) {
+    return typedjson({
+      organization,
+      vercelIntegration: null,
+      connectedProjects: [],
+      teamId: null,
+      installationId: null,
+    });
+  }
+
+  // Get team ID from integrationData
+  const integrationData = vercelIntegration.integrationData as any;
+  const teamId = integrationData?.teamId ?? null;
+  const installationId = integrationData?.installationId ?? null;
+
+  // Get all connected projects for this integration
+  const connectedProjects = await prisma.organizationProjectIntegration.findMany({
+    where: {
+      organizationIntegrationId: vercelIntegration.id,
+      deletedAt: null,
+    },
+    include: {
+      project: {
+        select: {
+          id: true,
+          slug: true,
+          name: true,
+        },
+      },
+    },
+    orderBy: {
+      createdAt: "desc",
+    },
+  });
+
+  return typedjson({
+    organization,
+    vercelIntegration,
+    connectedProjects,
+    teamId,
+    installationId,
+  });
+};
+
+const ActionSchema = z.object({
+  intent: z.literal("uninstall"),
+});
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const { organization, userId } = await requireOrganization(request, organizationSlug);
+
+  const formData = await request.formData();
+  const result = ActionSchema.safeParse({ intent: formData.get("intent") });
+  if (!result.success) {
+    return json({ error: "Invalid action" }, { status: 400 });
+  }
+
+  // Find Vercel integration
+  const vercelIntegration = await prisma.organizationIntegration.findFirst({
+    where: {
+      organizationId: organization.id,
+      service: "VERCEL",
+      deletedAt: null,
+    },
+    include: {
+      tokenReference: true,
+    },
+  });
+
+  if (!vercelIntegration) {
+    return json({ error: "Vercel integration not found" }, { status: 404 });
+  }
+
+  // Uninstall from Vercel side
+  const uninstallResult = await VercelIntegrationRepository.uninstallVercelIntegration(vercelIntegration);
+
+  if (uninstallResult.isErr()) {
+    logger.error("Failed to uninstall Vercel integration", {
+      organizationId: organization.id,
+      organizationSlug,
+      userId,
+      integrationId: vercelIntegration.id,
+      error: uninstallResult.error.message,
+    });
+
+    return json(
+      { error: "Failed to uninstall Vercel integration. Please try again." },
+      { status: 500 }
+    );
+  }
+
+  // Soft-delete the integration and all connected projects in a transaction
+  const txResult = await fromPromise(
+    $transaction(prisma, async (tx) => {
+      await tx.organizationProjectIntegration.updateMany({
+        where: {
+          organizationIntegrationId: vercelIntegration.id,
+          deletedAt: null,
+        },
+        data: { deletedAt: new Date() },
+      });
+
+      await tx.organizationIntegration.update({
+        where: { id: vercelIntegration.id },
+        data: { deletedAt: new Date() },
+      });
+    }),
+    (error) => error
+  );
+
+  if (txResult.isErr()) {
+    logger.error("Failed to soft-delete Vercel integration records", {
+      organizationId: organization.id,
+      organizationSlug,
+      userId,
+      integrationId: vercelIntegration.id,
+      error: txResult.error instanceof Error ? txResult.error.message : String(txResult.error),
+    });
+
+    return json(
+      { error: "Failed to uninstall Vercel integration. Please try again." },
+      { status: 500 }
+    );
+  }
+
+  if (uninstallResult.value.authInvalid) {
+    logger.warn("Vercel integration uninstalled with auth error - token invalid", {
+      organizationId: organization.id,
+      organizationSlug,
+      userId,
+      integrationId: vercelIntegration.id,
+    });
+  } else {
+    logger.info("Vercel integration uninstalled successfully", {
+      organizationId: organization.id,
+      organizationSlug,
+      userId,
+      integrationId: vercelIntegration.id,
+    });
+  }
+
+  // Redirect back to organization settings
+  return redirect(`/orgs/${organizationSlug}/settings`);
+};
+
+export default function VercelIntegrationPage() {
+  const { organization, vercelIntegration, connectedProjects, teamId, installationId } = 
+    useTypedLoaderData<typeof loader>();
+  const actionData = useActionData<typeof action>();
+  const navigation = useNavigation();
+  const isUninstalling = navigation.state === "submitting" && 
+    navigation.formData?.get("intent") === "uninstall";
+
+  if (!vercelIntegration) {
+    return (
+      <PageContainer>
+        <PageBody>
+          <div className="flex flex-col items-center justify-center py-8">
+            <Header1>No Vercel Integration Found</Header1>
+            <Paragraph className="mt-2 text-center text-text-dimmed">
+              This organization doesn't have a Vercel integration configured.
+            </Paragraph>
+          </div>
+        </PageBody>
+      </PageContainer>
+    );
+  }
+
+  return (
+    <PageContainer>
+      <PageBody>
+        <div className="mb-8">
+          <Header1>Vercel Integration</Header1>
+          <Paragraph className="mt-2 text-text-dimmed">
+            Manage your organization's Vercel integration and connected projects.
+          </Paragraph>
+        </div>
+
+        {/* Integration Info Section */}
+        <div className="mb-8 rounded-lg border border-grid-bright bg-background-bright p-6">
+          <div className="flex items-center justify-between">
+            <div>
+              <h2 className="text-lg font-medium text-text-bright">Integration Details</h2>
+              <div className="mt-2 space-y-1 text-sm text-text-dimmed">
+                {teamId && (
+                  <div>
+                    <span className="font-medium">Vercel Team ID:</span> {teamId}
+                  </div>
+                )}
+                {installationId && (
+                  <div>
+                    <span className="font-medium">Installation ID:</span> {installationId}
+                  </div>
+                )}
+                <div>
+                  <span className="font-medium">Installed:</span>{" "}
+                  {formatDate(new Date(vercelIntegration.createdAt))}
+                </div>
+              </div>
+            </div>
+            <div className="flex flex-col items-end gap-2">
+              <Dialog>
+                <DialogTrigger asChild>
+                  <Button
+                    variant="danger/medium"
+                    LeadingIcon={TrashIcon}
+                    disabled={isUninstalling}
+                  >
+                    Remove Integration
+                  </Button>
+                </DialogTrigger>
+                <DialogContent>
+                  <DialogHeader>
+                    <DialogTitle>Remove Vercel Integration</DialogTitle>
+                  </DialogHeader>
+                  <DialogDescription>
+                    This will permanently remove the Vercel integration and disconnect all projects. 
+                    This action cannot be undone.
+                  </DialogDescription>
+                  <FormButtons
+                    confirmButton={
+                      <Form method="post">
+                        <input type="hidden" name="intent" value="uninstall" />
+                        <Button
+                          variant="danger/medium"
+                          LeadingIcon={TrashIcon}
+                          type="submit"
+                          disabled={isUninstalling}
+                        >
+                          {isUninstalling ? "Removing..." : "Remove Integration"}
+                        </Button>
+                      </Form>
+                    }
+                    cancelButton={
+                      <DialogClose asChild>
+                        <Button variant="tertiary/medium">Cancel</Button>
+                      </DialogClose>
+                    }
+                  />
+                </DialogContent>
+              </Dialog>
+              {actionData?.error && (
+                <Paragraph variant="small" className="text-error">
+                  {actionData.error}
+                </Paragraph>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Connected Projects Section */}
+        <div>
+          <h2 className="mb-4 text-lg font-medium text-text-bright">
+            Connected Projects ({connectedProjects.length})
+          </h2>
+          
+          {connectedProjects.length === 0 ? (
+            <div className="rounded-lg border border-grid-bright bg-background-bright p-6 text-center">
+              <Paragraph className="text-text-dimmed">
+                No projects are currently connected to this Vercel integration.
+              </Paragraph>
+            </div>
+          ) : (
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHeaderCell>Project Name</TableHeaderCell>
+                  <TableHeaderCell>Vercel Project ID</TableHeaderCell>
+                  <TableHeaderCell>Connected</TableHeaderCell>
+                  <TableHeaderCell hiddenLabel>Actions</TableHeaderCell>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {connectedProjects.map((projectIntegration) => (
+                  <TableRow key={projectIntegration.id}>
+                    <TableCell>{projectIntegration.project.name}</TableCell>
+                    <TableCell className="font-mono text-xs">
+                      {projectIntegration.externalEntityId}
+                    </TableCell>
+                    <TableCell>
+                      {formatDate(new Date(projectIntegration.createdAt))}
+                    </TableCell>
+                    <TableCell>
+                      <LinkButton
+                        variant="minimal/small"
+                        to={v3ProjectSettingsIntegrationsPath(
+                          organization,
+                          projectIntegration.project,
+                          { slug: "prod" } // Default to production environment
+                        )}
+                      >
+                        Configure
+                      </LinkButton>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          )}
+        </div>
+      </PageBody>
+    </PageContainer>
+  );
+}
\ No newline at end of file
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections._index/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections._index/route.tsx
new file mode 100644
index 00000000000..7c82333ccc0
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections._index/route.tsx
@@ -0,0 +1,307 @@
+import { LinkButton } from "~/components/primitives/Buttons";
+import { Form, useFetcher, useRevalidator, type MetaFunction } from "@remix-run/react";
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
+import {
+  MainHorizontallyCenteredContainer,
+  PageBody,
+  PageContainer,
+} from "~/components/layout/AppLayout";
+import { Badge } from "~/components/primitives/Badge";
+import { Header2 } from "~/components/primitives/Headers";
+import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { prisma } from "~/db.server";
+import { canAccessPrivateConnections } from "~/v3/canAccessPrivateConnections.server";
+import { logger } from "~/services/logger.server";
+import { getPrivateLinks } from "~/services/platform.v3.server";
+import { requireUserId } from "~/services/session.server";
+import {
+  OrganizationParamsSchema,
+  organizationPath,
+  v3PrivateConnectionsPath,
+} from "~/utils/pathBuilder";
+import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
+import type { PrivateLinkConnectionStatus } from "@trigger.dev/platform";
+import { Button } from "~/components/primitives/Buttons";
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { deletePrivateLink } from "~/services/platform.v3.server";
+import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
+import {
+  ClipboardDocumentIcon,
+  PlusIcon,
+  TrashIcon,
+} from "@heroicons/react/20/solid";
+import { useMemo, useState } from "react";
+import { useInterval } from "~/hooks/useInterval";
+
+export const meta: MetaFunction = () => {
+  return [{ title: `Private Connections | Trigger.dev` }];
+};
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+
+  const canAccess = await canAccessPrivateConnections({ organizationSlug, userId });
+  if (!canAccess) {
+    return redirect(organizationPath({ slug: organizationSlug }));
+  }
+
+  const organization = await prisma.organization.findFirst({
+    where: { slug: organizationSlug, members: { some: { userId } } },
+  });
+
+  if (!organization) {
+    throw new Response(null, { status: 404, statusText: "Organization not found" });
+  }
+
+  const [error, connections] = await tryCatch(getPrivateLinks(organization.id));
+  if (error) {
+    logger.error("Error loading private link connections", { error, organizationId: organization.id });
+  }
+
+  return typedjson({
+    connections: connections?.connections ?? [],
+    organizationId: organization.id,
+  });
+}
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+
+  if (request.method !== "DELETE" && request.method !== "POST") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  const formData = await request.formData();
+  const connectionId = formData.get("connectionId");
+  const intent = formData.get("intent");
+
+  if (intent !== "delete" || typeof connectionId !== "string") {
+    return json({ error: "Invalid request" }, { status: 400 });
+  }
+
+  const organization = await prisma.organization.findFirst({
+    where: { slug: organizationSlug, members: { some: { userId } } },
+  });
+
+  if (!organization) {
+    return redirectWithErrorMessage(
+      v3PrivateConnectionsPath({ slug: organizationSlug }),
+      request,
+      "Organization not found"
+    );
+  }
+
+  const [error] = await tryCatch(deletePrivateLink(organization.id, connectionId));
+  if (error) {
+    return redirectWithErrorMessage(
+      v3PrivateConnectionsPath({ slug: organizationSlug }),
+      request,
+      `Failed to delete connection: ${error.message}`
+    );
+  }
+
+  return redirectWithSuccessMessage(
+    v3PrivateConnectionsPath({ slug: organizationSlug }),
+    request,
+    "Connection deletion initiated"
+  );
+};
+
+const STATUS_COLORS: Record<PrivateLinkConnectionStatus, string> = {
+  PENDING: "bg-amber-500/20 text-amber-400",
+  PROVISIONING: "bg-blue-500/20 text-blue-400",
+  ACTIVE: "bg-emerald-500/20 text-emerald-400",
+  ERROR: "bg-rose-500/20 text-rose-400",
+  DELETING: "bg-charcoal-500/20 text-charcoal-400",
+};
+
+function StatusBadge({ status }: { status: PrivateLinkConnectionStatus }) {
+  return (
+    <span
+      className={`inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[status]}`}
+    >
+      {status}
+    </span>
+  );
+}
+
+function CopyButton({ value }: { value: string }) {
+  const [copied, setCopied] = useState(false);
+
+  return (
+    <button
+      type="button"
+      onClick={() => {
+        navigator.clipboard.writeText(value);
+        setCopied(true);
+        setTimeout(() => setCopied(false), 2000);
+      }}
+      className="ml-1 inline-flex items-center text-text-dimmed transition hover:text-text-bright"
+      title="Copy to clipboard"
+    >
+      <ClipboardDocumentIcon className="h-3.5 w-3.5" />
+      {copied && <span className="ml-1 text-xs text-emerald-400">Copied</span>}
+    </button>
+  );
+}
+
+const TERMINAL_STATUSES: PrivateLinkConnectionStatus[] = ["ACTIVE", "ERROR"];
+
+export default function Page() {
+  const { connections } = useTypedLoaderData<typeof loader>();
+  const plan = useCurrentPlan();
+  const revalidator = useRevalidator();
+
+  const hasInProgressConnections = useMemo(
+    () => connections.some((c) => !TERMINAL_STATUSES.includes(c.status)),
+    [connections]
+  );
+
+  useInterval({
+    interval: 3_000,
+    onLoad: false,
+    callback: () => {
+      if (revalidator.state === "idle") {
+        revalidator.revalidate();
+      }
+    },
+    disabled: !hasInProgressConnections,
+  });
+
+  const hasPrivateNetworking = plan?.v3Subscription?.plan?.limits?.hasPrivateNetworking ?? false;
+  const limit = plan?.v3Subscription?.plan?.limits?.privateLinkConnectionLimit ?? 2;
+  const canAdd = connections.filter((c) => c.status !== "DELETING").length < limit;
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Private Connections" />
+        <PageAccessories>
+          {hasPrivateNetworking && canAdd && (
+            <LinkButton variant="primary/small" LeadingIcon={PlusIcon} to="new">
+              Add Connection
+            </LinkButton>
+          )}
+        </PageAccessories>
+      </NavBar>
+      <PageBody scrollable={true}>
+        <MainHorizontallyCenteredContainer className="max-w-3xl">
+          <div>
+            <div className="mb-4 border-b border-grid-dimmed pb-3">
+              <Header2 spacing>Private Connections</Header2>
+              <Paragraph variant="small">
+                Connect your AWS resources (databases, caches, APIs) to your Trigger.dev tasks via
+                AWS PrivateLink. Connections are organization-wide and work across all projects and
+                environments.
+              </Paragraph>
+            </div>
+
+            {!hasPrivateNetworking ? (
+              <div className="rounded-lg border border-grid-dimmed p-6 text-center">
+                <Paragraph variant="small" className="text-text-dimmed">
+                  Private Connections require upgrading to Pro or an Enterprise plan.
+                </Paragraph>
+              </div>
+            ) : connections.length === 0 ? (
+              <div className="rounded-lg border border-grid-dimmed p-6 text-center">
+                <Paragraph variant="small" className="mb-4 text-text-dimmed">
+                  No private connections yet. Add your first connection to securely reach your AWS
+                  resources from task pods.
+                </Paragraph>
+                <LinkButton variant="primary/small" LeadingIcon={PlusIcon} to="new">
+                  Add Connection
+                </LinkButton>
+              </div>
+            ) : (
+              <div className="flex flex-col gap-3">
+                {connections.map((connection) => (
+                  <div
+                    key={connection.id}
+                    className="rounded-lg border border-grid-dimmed p-4"
+                  >
+                    <div>
+                      <div className="mb-1 flex items-center gap-2">
+                        <span className="font-medium text-text-bright">
+                          {connection.name}
+                        </span>
+                        <StatusBadge status={connection.status} />
+                        {connection.status !== "DELETING" && (
+                          <Form method="POST" className="ml-auto">
+                            <input type="hidden" name="connectionId" value={connection.id} />
+                            <input type="hidden" name="intent" value="delete" />
+                            <button
+                              type="submit"
+                              className="text-text-dimmed transition hover:text-rose-400"
+                              title="Delete connection"
+                              onClick={(e) => {
+                                if (
+                                  !confirm(
+                                    `Delete connection "${connection.name}"? This will remove the VPC Endpoint and network access.`
+                                  )
+                                ) {
+                                  e.preventDefault();
+                                }
+                              }}
+                            >
+                              <TrashIcon className="h-4 w-4" />
+                            </button>
+                          </Form>
+                        )}
+                      </div>
+                      <div className="space-y-1">
+                        <div className="flex items-center text-xs text-text-dimmed">
+                          <span className="w-24 shrink-0">Service:</span>
+                          <code className="truncate font-mono text-text-dimmed">
+                            {connection.endpointServiceName}
+                          </code>
+                          <CopyButton value={connection.endpointServiceName} />
+                        </div>
+                        <div className="flex items-center text-xs text-text-dimmed">
+                          <span className="w-24 shrink-0">Region:</span>
+                          <span>{connection.targetRegion}</span>
+                        </div>
+                        {connection.endpointIps && connection.endpointIps.length > 0 && (
+                          <div className="flex items-center text-xs text-text-dimmed">
+                            <span className="w-24 shrink-0">IPs:</span>
+                            <code className="truncate font-mono text-emerald-400">
+                              {connection.endpointIps.join(", ")}
+                            </code>
+                            <CopyButton value={connection.endpointIps.join(", ")} />
+                          </div>
+                        )}
+                        {connection.statusMessage && (
+                          <div className="flex items-center text-xs text-rose-400">
+                            <span className="w-24 shrink-0">Error:</span>
+                            <span>{connection.statusMessage}</span>
+                          </div>
+                        )}
+                        <div className="flex items-center text-xs text-text-dimmed">
+                          <span className="w-24 shrink-0">Created:</span>
+                          <span>
+                            {new Date(connection.createdAt).toLocaleDateString()}
+                          </span>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                ))}
+
+                {!canAdd && (
+                  <Paragraph variant="extra-small" className="text-text-dimmed">
+                    Connection limit reached ({limit}). Delete an existing connection to add a new
+                    one.
+                  </Paragraph>
+                )}
+              </div>
+            )}
+          </div>
+        </MainHorizontallyCenteredContainer>
+      </PageBody>
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections.new/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections.new/route.tsx
new file mode 100644
index 00000000000..649419b9c65
--- /dev/null
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.private-connections.new/route.tsx
@@ -0,0 +1,769 @@
+import { conform, useForm } from "@conform-to/react";
+import { parse } from "@conform-to/zod";
+import { Form, useActionData, useParams, type MetaFunction } from "@remix-run/react";
+import { json, type ActionFunction, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { useState } from "react";
+import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import {
+  MainHorizontallyCenteredContainer,
+  PageBody,
+  PageContainer,
+} from "~/components/layout/AppLayout";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
+import { Header2, Header3 } from "~/components/primitives/Headers";
+import { Input } from "~/components/primitives/Input";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { canAccessPrivateConnections } from "~/v3/canAccessPrivateConnections.server";
+import {
+  redirectWithErrorMessage,
+  redirectWithSuccessMessage,
+} from "~/models/message.server";
+import type { CreatePrivateLinkConnectionBody } from "@trigger.dev/platform";
+import {
+  createPrivateLink,
+  getPrivateLinkRegions,
+} from "~/services/platform.v3.server";
+import { requireUserId } from "~/services/session.server";
+import {
+  OrganizationParamsSchema,
+  organizationPath,
+  v3PrivateConnectionsPath,
+} from "~/utils/pathBuilder";
+import {
+  CommandLineIcon,
+  DocumentTextIcon,
+  PencilSquareIcon,
+  SparklesIcon,
+  TrashIcon,
+} from "@heroicons/react/20/solid";
+
+export const meta: MetaFunction = () => {
+  return [{ title: `Add Private Connection | Trigger.dev` }];
+};
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+
+  const canAccess = await canAccessPrivateConnections({ organizationSlug, userId });
+  if (!canAccess) {
+    return redirect(organizationPath({ slug: organizationSlug }));
+  }
+
+  const organization = await prisma.organization.findFirst({
+    where: { slug: organizationSlug, members: { some: { userId } } },
+  });
+
+  if (!organization) {
+    throw new Response(null, { status: 404, statusText: "Organization not found" });
+  }
+
+  const [error, regions] = await tryCatch(getPrivateLinkRegions(organization.id));
+
+  const awsAccountIds = env.PRIVATE_CONNECTIONS_AWS_ACCOUNT_IDS?.split(",").filter(Boolean) ?? [];
+
+  return typedjson({
+    availableRegions: regions?.availableRegions ?? ["us-east-1", "eu-central-1"],
+    activeRegions: regions?.activeRegions ?? [],
+    awsAccountIds,
+  });
+}
+
+const schema = z.object({
+  name: z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less"),
+  endpointServiceName: z
+    .string()
+    .min(1, "VPC Endpoint Service name is required")
+    .regex(
+      /^com\.amazonaws\.vpce\..+\.vpce-svc-.+$/,
+      "Must be a valid VPC Endpoint Service name (com.amazonaws.vpce.<region>.vpce-svc-*)"
+    ),
+  targetRegion: z.string().min(1, "Region is required"),
+});
+
+export const action: ActionFunction = async ({ request, params }) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+
+  const formData = await request.formData();
+  const submission = parse(formData, { schema });
+
+  if (!submission.value || submission.intent !== "submit") {
+    return json(submission);
+  }
+
+  const organization = await prisma.organization.findFirst({
+    where: { slug: organizationSlug, members: { some: { userId } } },
+  });
+
+  if (!organization) {
+    return redirectWithErrorMessage(
+      v3PrivateConnectionsPath({ slug: organizationSlug }),
+      request,
+      "Organization not found"
+    );
+  }
+
+  // Fetch available regions dynamically (same call the loader makes)
+  const [, fetchedRegions] = await tryCatch(getPrivateLinkRegions(organization.id));
+  const availableRegions = fetchedRegions?.availableRegions ?? ["us-east-1", "eu-central-1"];
+
+  const { targetRegion: selectedRegion, ...rest } = submission.value;
+
+  if (!availableRegions.includes(selectedRegion)) {
+    return redirectWithErrorMessage(
+      v3PrivateConnectionsPath({ slug: organizationSlug }),
+      request,
+      `Invalid region: ${selectedRegion}`
+    );
+  }
+
+  const [error] = await tryCatch(
+    createPrivateLink(organization.id, {
+      ...rest,
+      targetRegion: selectedRegion as CreatePrivateLinkConnectionBody["targetRegion"],
+    })
+  );
+
+  if (error) {
+    return redirectWithErrorMessage(
+      v3PrivateConnectionsPath({ slug: organizationSlug }),
+      request,
+      error.message
+    );
+  }
+
+  const message = "Connection created! Provisioning will begin shortly.";
+
+  return redirectWithSuccessMessage(
+    v3PrivateConnectionsPath({ slug: organizationSlug }),
+    request,
+    message
+  );
+};
+
+
+type SetupMethod = "manual" | "ai" | "terraform" | "docs";
+
+type PortEntry = { port: string; protocol: "TCP" | "UDP" };
+
+const AWS_REGIONS = [
+  { value: "us-east-1", label: "US East (N. Virginia)" },
+  { value: "us-east-2", label: "US East (Ohio)" },
+  { value: "us-west-1", label: "US West (N. California)" },
+  { value: "us-west-2", label: "US West (Oregon)" },
+  { value: "af-south-1", label: "Africa (Cape Town)" },
+  { value: "ap-east-1", label: "Asia Pacific (Hong Kong)" },
+  { value: "ap-south-1", label: "Asia Pacific (Mumbai)" },
+  { value: "ap-south-2", label: "Asia Pacific (Hyderabad)" },
+  { value: "ap-southeast-1", label: "Asia Pacific (Singapore)" },
+  { value: "ap-southeast-2", label: "Asia Pacific (Sydney)" },
+  { value: "ap-southeast-3", label: "Asia Pacific (Jakarta)" },
+  { value: "ap-southeast-4", label: "Asia Pacific (Melbourne)" },
+  { value: "ap-northeast-1", label: "Asia Pacific (Tokyo)" },
+  { value: "ap-northeast-2", label: "Asia Pacific (Seoul)" },
+  { value: "ap-northeast-3", label: "Asia Pacific (Osaka)" },
+  { value: "ca-central-1", label: "Canada (Central)" },
+  { value: "ca-west-1", label: "Canada West (Calgary)" },
+  { value: "eu-central-1", label: "Europe (Frankfurt)" },
+  { value: "eu-central-2", label: "Europe (Zurich)" },
+  { value: "eu-west-1", label: "Europe (Ireland)" },
+  { value: "eu-west-2", label: "Europe (London)" },
+  { value: "eu-west-3", label: "Europe (Paris)" },
+  { value: "eu-south-1", label: "Europe (Milan)" },
+  { value: "eu-south-2", label: "Europe (Spain)" },
+  { value: "eu-north-1", label: "Europe (Stockholm)" },
+  { value: "il-central-1", label: "Israel (Tel Aviv)" },
+  { value: "me-south-1", label: "Middle East (Bahrain)" },
+  { value: "me-central-1", label: "Middle East (UAE)" },
+  { value: "sa-east-1", label: "South America (São Paulo)" },
+];
+
+function TerraformWizard({ awsAccountIds }: { awsAccountIds: string[] }) {
+  const [hostname, setHostname] = useState("");
+  const [ports, setPorts] = useState<PortEntry[]>([{ port: "5432", protocol: "TCP" }]);
+  const [region, setRegion] = useState("us-east-1");
+
+  const addPort = () => setPorts([...ports, { port: "", protocol: "TCP" }]);
+  const removePort = (index: number) => setPorts(ports.filter((_, i) => i !== index));
+  const updatePort = (index: number, field: keyof PortEntry, value: string) =>
+    setPorts(ports.map((p, i) => (i === index ? { ...p, [field]: value } : p)));
+
+  const validPorts = ports.filter((p) => p.port !== "");
+
+  const terraformScript = `# Trigger.dev Private Networking - Terraform Configuration
+# Creates an NLB and VPC Endpoint Service for your resource
+
+variable "vpc_id" {
+  description = "Your VPC ID"
+  type        = string
+}
+
+variable "subnet_ids" {
+  description = "Private subnet IDs in your VPC"
+  type        = list(string)
+}
+
+variable "target_ip" {
+  description = "IP address of the target resource"
+  type        = string${hostname ? `\n  default     = "${hostname}"` : ""}
+}
+
+# Network Load Balancer
+resource "aws_lb" "trigger_privatelink" {
+  name               = "trigger-privatelink"
+  internal           = true
+  load_balancer_type = "network"
+  subnets            = var.subnet_ids
+}
+${validPorts
+  .map(
+    (p, i) => `
+resource "aws_lb_target_group" "port_${p.port}" {
+  name        = "trigger-pl-${p.port}"
+  port        = ${p.port}
+  protocol    = "${p.protocol}"
+  vpc_id      = var.vpc_id
+  target_type = "ip"
+
+  health_check {
+    protocol = "TCP"
+    port     = ${p.port}
+  }
+}
+
+resource "aws_lb_target_group_attachment" "port_${p.port}" {
+  target_group_arn = aws_lb_target_group.port_${p.port}.arn
+  target_id        = var.target_ip
+  port             = ${p.port}
+}
+
+resource "aws_lb_listener" "port_${p.port}" {
+  load_balancer_arn = aws_lb.trigger_privatelink.arn
+  port              = ${p.port}
+  protocol          = "${p.protocol}"
+
+  default_action {
+    type             = "forward"
+    target_group_arn = aws_lb_target_group.port_${p.port}.arn
+  }
+}`
+  )
+  .join("\n")}
+
+# VPC Endpoint Service
+resource "aws_vpc_endpoint_service" "trigger_privatelink" {
+  acceptance_required        = false
+  network_load_balancer_arns = [aws_lb.trigger_privatelink.arn]
+  supported_regions          = ["us-east-1", "eu-central-1"]
+
+  allowed_principals = [
+${awsAccountIds.map((id) => `    "arn:aws:iam::${id}:root",`).join("\n")}
+  ]
+}
+
+output "endpoint_service_name" {
+  description = "Paste this into the Trigger.dev dashboard"
+  value       = aws_vpc_endpoint_service.trigger_privatelink.service_name
+}
+`;
+
+  return (
+    <div className="space-y-4">
+      <InputGroup>
+        <Label>Resource hostname or IP</Label>
+        <Input
+          value={hostname}
+          onChange={(e) => setHostname(e.target.value)}
+          placeholder="my-database.abc123.us-east-1.rds.amazonaws.com"
+          fullWidth
+        />
+      </InputGroup>
+
+      <div>
+        <Label>Ports</Label>
+        <div className="mt-1 space-y-2">
+          {ports.map((entry, index) => (
+            <div key={index} className="flex items-center gap-2">
+              <Input
+                type="number"
+                min={1}
+                max={65535}
+                value={entry.port}
+                onChange={(e) => updatePort(index, "port", e.target.value)}
+                placeholder="Port"
+                className="w-24"
+              />
+              <select
+                value={entry.protocol}
+                onChange={(e) => updatePort(index, "protocol", e.target.value)}
+                className="rounded-md border border-charcoal-700 bg-charcoal-800 px-3 py-2 text-sm text-text-bright"
+              >
+                <option value="TCP">TCP</option>
+                <option value="UDP">UDP</option>
+              </select>
+              {ports.length > 1 && (
+                <button
+                  type="button"
+                  onClick={() => removePort(index)}
+                  className="text-text-dimmed transition hover:text-rose-400"
+                  title="Remove port"
+                >
+                  <TrashIcon className="h-4 w-4" />
+                </button>
+              )}
+            </div>
+          ))}
+          <button
+            type="button"
+            onClick={addPort}
+            className="text-xs text-indigo-400 transition hover:text-indigo-300"
+          >
+            + Add port
+          </button>
+        </div>
+      </div>
+
+      <InputGroup>
+        <Label>Resource AWS Region</Label>
+        <Select
+          variant="tertiary/medium"
+          value={region}
+          setValue={(v) => setRegion(v)}
+          items={AWS_REGIONS}
+          filter={(item, search) => {
+            const s = search.toLowerCase();
+            return item.value.toLowerCase().includes(s) || item.label.toLowerCase().includes(s);
+          }}
+          text={(value) => {
+            const r = AWS_REGIONS.find((r) => r.value === value);
+            return r ? `${r.value} — ${r.label}` : value;
+          }}
+          placeholder="Select a region"
+        >
+          {(items) =>
+            items.map((item) => (
+              <SelectItem key={item.value} value={item.value}>
+                <span className="text-text-bright">{item.value}</span>
+                <span className="ml-2 text-text-dimmed">{item.label}</span>
+              </SelectItem>
+            ))
+          }
+        </Select>
+      </InputGroup>
+
+      <div className="rounded-md border border-charcoal-700 bg-charcoal-900">
+        <div className="flex items-center justify-between border-b border-charcoal-700 px-3 py-2">
+          <span className="text-xs font-medium text-text-dimmed">main.tf</span>
+          <button
+            type="button"
+            onClick={() => navigator.clipboard.writeText(terraformScript)}
+            className="text-xs text-text-dimmed transition hover:text-text-bright"
+          >
+            Copy
+          </button>
+        </div>
+        <pre className="max-h-64 overflow-auto p-3 text-xs text-text-dimmed">
+          <code>{terraformScript}</code>
+        </pre>
+      </div>
+    </div>
+  );
+}
+
+function AIPromptWizard({ awsAccountIds }: { awsAccountIds: string[] }) {
+  const [hostname, setHostname] = useState("");
+  const [ports, setPorts] = useState<PortEntry[]>([{ port: "5432", protocol: "TCP" }]);
+  const [region, setRegion] = useState("us-east-1");
+
+  const addPort = () => setPorts([...ports, { port: "", protocol: "TCP" }]);
+  const removePort = (index: number) => setPorts(ports.filter((_, i) => i !== index));
+  const updatePort = (index: number, field: keyof PortEntry, value: string) =>
+    setPorts(ports.map((p, i) => (i === index ? { ...p, [field]: value } : p)));
+
+  const validPorts = ports.filter((p) => p.port !== "");
+  const regionLabel = AWS_REGIONS.find((r) => r.value === region)?.label ?? region;
+
+  const portsDescription = validPorts.length > 0
+    ? validPorts.map((p) => `${p.port} (${p.protocol})`).join(", ")
+    : "5432 (TCP)";
+
+  const prompt = `I need to set up AWS PrivateLink so that Trigger.dev can connect to my resource. Please create the following in my AWS account in the ${region} (${regionLabel}) region:
+
+1. A Network Load Balancer (NLB):
+   - Name: trigger-privatelink
+   - Internal: yes
+   - Type: network
+   - Place it in my private subnets
+
+2. For each of the following ports, create a target group, target group attachment, and listener:
+${validPorts.length > 0 ? validPorts.map((p) => `   - Port ${p.port} (${p.protocol})`).join("\n") : "   - Port 5432 (TCP)"}
+
+   Each target group should:
+   - Target type: ip
+   - Target IP: ${hostname || "<my-resource-ip>"}
+   - Have a TCP health check on the same port
+
+3. A VPC Endpoint Service:
+   - Acceptance required: no
+   - Attach the NLB created above
+   - Supported regions: us-east-1, eu-central-1
+   - Allowed principals:
+${awsAccountIds.map((id) => `     - arn:aws:iam::${id}:root`).join("\n") || "     - <Trigger.dev AWS account ARN>"}
+
+After creating everything, give me the VPC Endpoint Service name (it looks like com.amazonaws.vpce.<region>.vpce-svc-*) so I can paste it into the Trigger.dev dashboard.`;
+
+  return (
+    <div className="space-y-4">
+      <InputGroup>
+        <Label>Resource hostname or IP</Label>
+        <Input
+          value={hostname}
+          onChange={(e) => setHostname(e.target.value)}
+          placeholder="my-database.abc123.us-east-1.rds.amazonaws.com"
+          fullWidth
+        />
+      </InputGroup>
+
+      <div>
+        <Label>Ports</Label>
+        <div className="mt-1 space-y-2">
+          {ports.map((entry, index) => (
+            <div key={index} className="flex items-center gap-2">
+              <Input
+                type="number"
+                min={1}
+                max={65535}
+                value={entry.port}
+                onChange={(e) => updatePort(index, "port", e.target.value)}
+                placeholder="Port"
+                className="w-24"
+              />
+              <select
+                value={entry.protocol}
+                onChange={(e) => updatePort(index, "protocol", e.target.value)}
+                className="rounded-md border border-charcoal-700 bg-charcoal-800 px-3 py-2 text-sm text-text-bright"
+              >
+                <option value="TCP">TCP</option>
+                <option value="UDP">UDP</option>
+              </select>
+              {ports.length > 1 && (
+                <button
+                  type="button"
+                  onClick={() => removePort(index)}
+                  className="text-text-dimmed transition hover:text-rose-400"
+                  title="Remove port"
+                >
+                  <TrashIcon className="h-4 w-4" />
+                </button>
+              )}
+            </div>
+          ))}
+          <button
+            type="button"
+            onClick={addPort}
+            className="text-xs text-indigo-400 transition hover:text-indigo-300"
+          >
+            + Add port
+          </button>
+        </div>
+      </div>
+
+      <InputGroup>
+        <Label>Resource AWS Region</Label>
+        <Select
+          variant="tertiary/medium"
+          value={region}
+          setValue={(v) => setRegion(v)}
+          items={AWS_REGIONS}
+          filter={(item, search) => {
+            const s = search.toLowerCase();
+            return item.value.toLowerCase().includes(s) || item.label.toLowerCase().includes(s);
+          }}
+          text={(value) => {
+            const r = AWS_REGIONS.find((r) => r.value === value);
+            return r ? `${r.value} — ${r.label}` : value;
+          }}
+          placeholder="Select a region"
+        >
+          {(items) =>
+            items.map((item) => (
+              <SelectItem key={item.value} value={item.value}>
+                <span className="text-text-bright">{item.value}</span>
+                <span className="ml-2 text-text-dimmed">{item.label}</span>
+              </SelectItem>
+            ))
+          }
+        </Select>
+      </InputGroup>
+
+      <div className="rounded-md border border-charcoal-700 bg-charcoal-900">
+        <div className="flex items-center justify-between border-b border-charcoal-700 px-3 py-2">
+          <span className="text-xs font-medium text-text-dimmed">AI Prompt</span>
+          <button
+            type="button"
+            onClick={() => navigator.clipboard.writeText(prompt)}
+            className="text-xs text-text-dimmed transition hover:text-text-bright"
+          >
+            Copy
+          </button>
+        </div>
+        <pre className="max-h-80 overflow-auto whitespace-pre-wrap p-3 text-xs text-text-dimmed">
+          {prompt}
+        </pre>
+      </div>
+    </div>
+  );
+}
+
+export default function Page() {
+  const { availableRegions, activeRegions, awsAccountIds } = useTypedLoaderData<typeof loader>();
+  const { organizationSlug } = useParams();
+  const lastSubmission = useActionData();
+  const [setupMethod, setSetupMethod] = useState<SetupMethod | null>(null);
+
+  const defaultRegion = "us-east-1";
+
+  const [form, { name, endpointServiceName, targetRegion }] = useForm({
+    id: "create-private-connection",
+    lastSubmission: lastSubmission as any,
+    onValidate({ formData }) {
+      return parse(formData, { schema });
+    },
+  });
+
+  return (
+    <PageContainer>
+      <NavBar>
+        <PageTitle title="Add Private Connection" backButton={{ to: v3PrivateConnectionsPath({ slug: organizationSlug! }), text: "Private Connections" }} />
+      </NavBar>
+      <PageBody scrollable={true}>
+        <MainHorizontallyCenteredContainer className="max-w-3xl">
+          <div>
+            <div className="mb-4 border-b border-grid-dimmed pb-3">
+              <Header2 spacing>Add Private Connection</Header2>
+              <Paragraph variant="small">
+                Connect your AWS resources to Trigger.dev task pods via AWS PrivateLink. You'll need
+                to create a VPC Endpoint Service on your AWS account first.
+              </Paragraph>
+            </div>
+
+            {/* Setup method cards */}
+            <div className="mb-6 grid grid-cols-2 gap-3 sm:grid-cols-4">
+              <button
+                type="button"
+                onClick={() => setSetupMethod("manual")}
+                className={`rounded-lg border p-4 text-left transition ${
+                  setupMethod === "manual"
+                    ? "border-indigo-500 bg-indigo-500/10"
+                    : "border-grid-dimmed hover:border-charcoal-600"
+                }`}
+              >
+                <PencilSquareIcon className="mb-2 h-5 w-5 text-indigo-400" />
+                <div className="text-sm font-medium text-text-bright">I have my details</div>
+                <div className="mt-1 text-xs text-text-dimmed">
+                  Already have your VPC Endpoint Service name
+                </div>
+              </button>
+              <button
+                type="button"
+                onClick={() => setSetupMethod("ai")}
+                className={`rounded-lg border p-4 text-left transition ${
+                  setupMethod === "ai"
+                    ? "border-indigo-500 bg-indigo-500/10"
+                    : "border-grid-dimmed hover:border-charcoal-600"
+                }`}
+              >
+                <SparklesIcon className="mb-2 h-5 w-5 text-purple-400" />
+                <div className="text-sm font-medium text-text-bright">Set up with AI</div>
+                <div className="mt-1 text-xs text-text-dimmed">
+                  Generate a prompt for your AI assistant
+                </div>
+              </button>
+              <button
+                type="button"
+                onClick={() => setSetupMethod("terraform")}
+                className={`rounded-lg border p-4 text-left transition ${
+                  setupMethod === "terraform"
+                    ? "border-indigo-500 bg-indigo-500/10"
+                    : "border-grid-dimmed hover:border-charcoal-600"
+                }`}
+              >
+                <CommandLineIcon className="mb-2 h-5 w-5 text-emerald-400" />
+                <div className="text-sm font-medium text-text-bright">Set up with Terraform</div>
+                <div className="mt-1 text-xs text-text-dimmed">
+                  Generate a customized Terraform script
+                </div>
+              </button>
+              <button
+                type="button"
+                onClick={() => setSetupMethod("docs")}
+                className={`rounded-lg border p-4 text-left transition ${
+                  setupMethod === "docs"
+                    ? "border-indigo-500 bg-indigo-500/10"
+                    : "border-grid-dimmed hover:border-charcoal-600"
+                }`}
+              >
+                <DocumentTextIcon className="mb-2 h-5 w-5 text-amber-400" />
+                <div className="text-sm font-medium text-text-bright">Step-by-step guide</div>
+                <div className="mt-1 text-xs text-text-dimmed">
+                  Visual instructions for the AWS Console
+                </div>
+              </button>
+            </div>
+
+            {/* AI prompt wizard */}
+            {setupMethod === "ai" && (
+              <div className="mb-6 rounded-lg border border-grid-dimmed p-4">
+                <Header3 spacing>AI-Assisted Setup</Header3>
+                <Paragraph variant="small" className="mb-4">
+                  Fill in your resource details below and we'll generate a prompt you can paste into
+                  Claude, ChatGPT, or any AI assistant with AWS access. After it creates the
+                  resources, paste the VPC Endpoint Service name below.
+                </Paragraph>
+                <AIPromptWizard awsAccountIds={awsAccountIds} />
+              </div>
+            )}
+
+            {/* Terraform wizard (expandable) */}
+            {setupMethod === "terraform" && (
+              <div className="mb-6 rounded-lg border border-grid-dimmed p-4">
+                <Header3 spacing>Terraform Configuration</Header3>
+                <Paragraph variant="small" className="mb-4">
+                  Fill in your resource details below and we'll generate a Terraform script. Run{" "}
+                  <code className="rounded bg-charcoal-800 px-1 py-0.5 text-xs">
+                    terraform apply
+                  </code>{" "}
+                  to create the VPC Endpoint Service, then paste the output service name below.
+                </Paragraph>
+                <TerraformWizard awsAccountIds={awsAccountIds} />
+              </div>
+            )}
+
+            {/* Docs iframe */}
+            {setupMethod === "docs" && (
+              <div className="mb-6 rounded-lg border border-grid-dimmed p-4">
+                <Header3 spacing>Setup Guide</Header3>
+                {awsAccountIds.length > 0 && (
+                  <>
+                    <Paragraph variant="small" className="mb-3">
+                      When adding allowed principals to your VPC Endpoint Service, use the following
+                      AWS account ID(s):
+                    </Paragraph>
+                    <div className="mb-4 rounded-md border border-charcoal-700 bg-charcoal-900 p-3">
+                      {awsAccountIds.map((id) => (
+                        <code key={id} className="text-sm text-emerald-400">
+                          {id}
+                        </code>
+                      ))}
+                    </div>
+                  </>
+                )}
+                <iframe
+                  src="https://trigger.dev/docs/network/private-link-setup-guide"
+                  title="Private Link Setup Guide"
+                  className="h-[600px] w-full rounded-md border border-charcoal-700"
+                />
+              </div>
+            )}
+
+            {/* AWS account IDs reference */}
+            {setupMethod === "manual" && (
+              <div className="mb-6 rounded-lg border border-grid-dimmed p-4">
+                <Paragraph variant="small" className="mb-2">
+                  Add the following AWS account ID(s) to your VPC Endpoint Service's allowed
+                  principals:
+                </Paragraph>
+                <div className="rounded-md border border-charcoal-700 bg-charcoal-900 p-3">
+                  {awsAccountIds.map((id) => (
+                    <code key={id} className="text-sm text-emerald-400">
+                      {id}
+                    </code>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* Connection form (always visible) */}
+            <div className="rounded-lg border border-grid-dimmed p-4">
+              <Header3 spacing>Connection Details</Header3>
+              <Form method="post" {...form.props}>
+                <Fieldset>
+                  <InputGroup fullWidth>
+                    <Label htmlFor={name.id} required>
+                      Friendly name
+                    </Label>
+                    <Input
+                      {...conform.input(name, { type: "text" })}
+                      placeholder="e.g., Production Database, Redis Cache"
+                      fullWidth
+                    />
+                    <FormError id={name.errorId}>{name.error}</FormError>
+                  </InputGroup>
+                  <InputGroup fullWidth>
+                    <Label htmlFor={endpointServiceName.id} required>
+                      VPC Endpoint Service name
+                    </Label>
+                    <Input
+                      {...conform.input(endpointServiceName, { type: "text" })}
+                      placeholder="com.amazonaws.vpce.us-east-1.vpce-svc-0123456789abcdef0"
+                      fullWidth
+                    />
+                    <FormError id={endpointServiceName.errorId}>
+                      {endpointServiceName.error}
+                    </FormError>
+                  </InputGroup>
+                  <InputGroup fullWidth>
+                    <Label htmlFor={targetRegion.id} required>
+                      Target region
+                    </Label>
+                    <select
+                      {...conform.input(targetRegion)}
+                      defaultValue={defaultRegion}
+                      className="w-full rounded-md border border-charcoal-700 bg-charcoal-800 px-3 py-2 text-sm text-text-bright"
+                    >
+                      {availableRegions.map((region: string) => (
+                        <option key={region} value={region}>
+                          {region}
+                        </option>
+                      ))}
+                    </select>
+                    <FormError id={targetRegion.errorId}>{targetRegion.error}</FormError>
+                    {activeRegions.length > 0 && (
+                      <Paragraph variant="extra-small" className="text-text-dimmed">
+                        Your tasks have recently run in: {activeRegions.join(", ")}
+                      </Paragraph>
+                    )}
+                  </InputGroup>
+                  <FormButtons
+                    cancelButton={
+                      <LinkButton variant="tertiary/small" to="..">
+                        Cancel
+                      </LinkButton>
+                    }
+                    confirmButton={
+                      <Button type="submit" variant="primary/small">
+                        Create Connection
+                      </Button>
+                    }
+                  />
+                </Fieldset>
+              </Form>
+            </div>
+          </div>
+        </MainHorizontallyCenteredContainer>
+      </PageBody>
+    </PageContainer>
+  );
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.team/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.team/route.tsx
index c83e10ced0f..dc71bc5585f 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.team/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.team/route.tsx
@@ -1,19 +1,23 @@
-import { useForm } from "@conform-to/react";
+import { conform, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import { EnvelopeIcon, LockOpenIcon, TrashIcon, UserPlusIcon } from "@heroicons/react/20/solid";
-import { Form, type MetaFunction, useActionData } from "@remix-run/react";
-import { type ActionFunction, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
-import { useState } from "react";
+import { EnvelopeIcon, NoSymbolIcon, UserPlusIcon } from "@heroicons/react/20/solid";
+import { DialogClose } from "@radix-ui/react-dialog";
+import {
+  Form,
+  type MetaFunction,
+  useActionData,
+  useFetcher,
+  useNavigation,
+} from "@remix-run/react";
+import { type ActionFunctionArgs, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { useEffect, useRef, useState } from "react";
 import { type UseDataFunctionReturn, typedjson, useTypedLoaderData } from "remix-typedjson";
 import invariant from "tiny-invariant";
 import { z } from "zod";
 import { UserAvatar } from "~/components/UserProfilePhoto";
 import { AdminDebugTooltip } from "~/components/admin/debugTooltip";
-import {
-  MainHorizontallyCenteredContainer,
-  PageBody,
-  PageContainer,
-} from "~/components/layout/AppLayout";
+import { PageBody, PageContainer } from "~/components/layout/AppLayout";
 import {
   Alert,
   AlertCancel,
@@ -26,12 +30,20 @@ import {
 } from "~/components/primitives/Alert";
 import { Button, ButtonContent, LinkButton } from "~/components/primitives/Buttons";
 import { DateTime } from "~/components/primitives/DateTime";
+import { Dialog, DialogContent, DialogHeader, DialogTrigger } from "~/components/primitives/Dialog";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
 import { Header2, Header3 } from "~/components/primitives/Headers";
-import { InfoPanel } from "~/components/primitives/InfoPanel";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { InputNumberStepper } from "~/components/primitives/InputNumberStepper";
+import { Label } from "~/components/primitives/Label";
 import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/PageHeader";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import * as Property from "~/components/primitives/PropertyTable";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
 import { SimpleTooltip } from "~/components/primitives/Tooltip";
+import { cn } from "~/utils/cn";
 import { $replica } from "~/db.server";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useUser } from "~/hooks/useUser";
@@ -46,6 +58,9 @@ import {
   revokeInvitePath,
   v3BillingPath,
 } from "~/utils/pathBuilder";
+import { formatCurrency, formatNumber } from "~/utils/numberFormatter";
+import { SetSeatsAddOnService } from "~/v3/services/setSeatsAddOn.server";
+import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
 
 export const meta: MetaFunction = () => {
   return [
@@ -89,12 +104,67 @@ const schema = z.object({
   memberId: z.string(),
 });
 
-export const action: ActionFunction = async ({ request, params }) => {
+const PurchaseSchema = z.discriminatedUnion("action", [
+  z.object({
+    action: z.literal("purchase"),
+    amount: z.coerce.number().int("Must be a whole number").min(0, "Amount must be 0 or more"),
+  }),
+  z.object({
+    action: z.literal("quota-increase"),
+    amount: z.coerce
+      .number()
+      .int("Must be a whole number")
+      .min(1, "Amount must be greater than 0"),
+  }),
+]);
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
   const userId = await requireUserId(request);
   const { organizationSlug } = params;
   invariant(organizationSlug, "organizationSlug not found");
 
   const formData = await request.formData();
+  const formType = formData.get("_formType");
+
+  if (formType === "purchase-seats") {
+    const org = await $replica.organization.findFirst({
+      where: { slug: organizationSlug },
+      select: { id: true },
+    });
+
+    if (!org) {
+      return json({ ok: false, error: "Organization not found" } as const);
+    }
+
+    const submission = parse(formData, { schema: PurchaseSchema });
+
+    if (!submission.value || submission.intent !== "submit") {
+      return json(submission);
+    }
+
+    const service = new SetSeatsAddOnService();
+    const [error, result] = await tryCatch(
+      service.call({
+        userId,
+        organizationId: org.id,
+        action: submission.value.action,
+        amount: submission.value.amount,
+      })
+    );
+
+    if (error) {
+      submission.error.amount = [error instanceof Error ? error.message : "Unknown error"];
+      return json(submission);
+    }
+
+    if (!result.success) {
+      submission.error.amount = [result.error];
+      return json(submission);
+    }
+
+    return json({ ok: true } as const);
+  }
+
   const submission = parse(formData, { schema });
 
   if (!submission.value || submission.intent !== "submit") {
@@ -126,11 +196,24 @@ type Member = UseDataFunctionReturn<typeof loader>["members"][number];
 type Invite = UseDataFunctionReturn<typeof loader>["invites"][number];
 
 export default function Page() {
-  const { members, invites, limits } = useTypedLoaderData<typeof loader>();
+  const {
+    members,
+    invites,
+    limits,
+    canPurchaseSeats,
+    extraSeats,
+    seatPricing,
+    maxSeatQuota,
+    planSeatLimit,
+  } = useTypedLoaderData<typeof loader>();
   const user = useUser();
   const organization = useOrganization();
 
+  const plan = useCurrentPlan();
   const requiresUpgrade = limits.used >= limits.limit;
+  const usageRatio = limits.limit > 0 ? Math.min(limits.used / limits.limit, 1) : 0;
+  const canUpgrade =
+    plan?.v3Subscription?.plan && !plan.v3Subscription.plan.limits.teamMembers.canExceed;
 
   return (
     <PageContainer>
@@ -159,97 +242,142 @@ export default function Page() {
               ))}
             </Property.Table>
           </AdminDebugTooltip>
+          {requiresUpgrade ? (
+            <SimpleTooltip
+              button={
+                <ButtonContent variant="primary/small" LeadingIcon={UserPlusIcon} className="cursor-not-allowed opacity-50">
+                  Invite a team member
+                </ButtonContent>
+              }
+              content="Purchase more seats to invite more team members"
+              disableHoverableContent
+            />
+          ) : (
+            <LinkButton
+              to={inviteTeamMemberPath(organization)}
+              variant="primary/small"
+              LeadingIcon={UserPlusIcon}
+            >
+              Invite a team member
+            </LinkButton>
+          )}
         </PageAccessories>
       </NavBar>
-      <PageBody>
-        <MainHorizontallyCenteredContainer>
-          <Header2>
-            Members{" "}
-            <span className="font-normal text-text-dimmed">
-              ({limits.used}/{limits.limit})
-            </span>
-          </Header2>
-          <ul className="divide-ui-border mt-3 flex w-full flex-col divide-y border-y border-grid-bright">
-            {members.map((member) => (
-              <li key={member.user.id} className="flex items-center gap-x-4 py-4">
-                <UserAvatar
-                  avatarUrl={member.user.avatarUrl}
-                  name={member.user.name}
-                  className="size-10"
-                />
-                <div className="flex flex-col gap-0.5">
-                  <Header3>
-                    {member.user.name}{" "}
-                    {member.user.id === user.id && <span className="text-text-dimmed">(You)</span>}
-                  </Header3>
-                  <Paragraph variant="small">{member.user.email}</Paragraph>
-                </div>
-                <div className="flex grow items-center justify-end gap-4">
-                  <LeaveRemoveButton
-                    userId={user.id}
-                    member={member}
-                    memberCount={members.length}
-                  />
-                </div>
-              </li>
-            ))}
-          </ul>
-
-          {invites.length > 0 && (
-            <>
-              <Header2 className="mb-3 mt-4">Pending invites</Header2>
-              <ul className="flex w-full flex-col divide-y divide-charcoal-800 border-b border-grid-bright">
-                {invites.map((invite) => (
-                  <li key={invite.id} className="flex items-center gap-4 py-4">
-                    <div className="rounded-md border border-charcoal-750 bg-charcoal-800 p-1.5">
-                      <EnvelopeIcon className="size-7 text-cyan-500" />
-                    </div>
+      <PageBody scrollable={false}>
+        <div className="grid max-h-full min-h-full grid-rows-[1fr_auto]">
+          <div className="overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+            <div className="mx-auto max-w-3xl px-4 pb-4 pt-20">
+              {invites.length > 0 && (
+                <>
+                  <Header2 className="mb-3 mt-4">Pending invites</Header2>
+                  <ul className="divide-ui-border mb-6 flex w-full flex-col divide-y border-y">
+                    {invites.map((invite) => (
+                      <li key={invite.id} className="flex items-center gap-4 py-4">
+                        <div className="rounded-md border border-charcoal-750 bg-charcoal-800 p-1.5">
+                          <EnvelopeIcon className="size-7 text-text-dimmed" />
+                        </div>
+                        <div className="flex flex-col gap-0.5">
+                          <Header3>{invite.email}</Header3>
+                          <Paragraph variant="small">
+                            Invite sent {<DateTime date={invite.updatedAt} />}
+                          </Paragraph>
+                        </div>
+                        <div className="flex grow items-center justify-end gap-x-2">
+                          <ResendButton invite={invite} />
+                          <RevokeButton invite={invite} />
+                        </div>
+                      </li>
+                    ))}
+                  </ul>
+                </>
+              )}
+              <Header2>Active team members</Header2>
+              <ul className="divide-ui-border mb-8 mt-3 flex w-full flex-col divide-y border-y border-grid-bright">
+                {members.map((member) => (
+                  <li key={member.user.id} className="flex items-center gap-x-4 py-4">
+                    <UserAvatar
+                      avatarUrl={member.user.avatarUrl}
+                      name={member.user.name}
+                      className="size-10"
+                    />
                     <div className="flex flex-col gap-0.5">
-                      <Header3>{invite.email}</Header3>
-                      <Paragraph variant="small">
-                        Invite sent {<DateTime date={invite.updatedAt} />}
-                      </Paragraph>
+                      <Header3>
+                        {member.user.name}{" "}
+                        {member.user.id === user.id && (
+                          <span className="text-text-dimmed">(You)</span>
+                        )}
+                      </Header3>
+                      <Paragraph variant="small">{member.user.email}</Paragraph>
                     </div>
-                    <div className="flex grow items-center justify-end gap-x-2">
-                      <ResendButton invite={invite} />
-                      <RevokeButton invite={invite} />
+                    <div className="flex grow items-center justify-end gap-4">
+                      <LeaveRemoveButton
+                        userId={user.id}
+                        member={member}
+                        memberCount={members.length}
+                      />
                     </div>
                   </li>
                 ))}
               </ul>
-            </>
-          )}
-
-          {requiresUpgrade ? (
-            <InfoPanel
-              variant="upgrade"
-              icon={LockOpenIcon}
-              iconClassName="text-indigo-500"
-              title="Unlock more team members"
-              accessory={
-                <LinkButton to={v3BillingPath(organization)} variant="secondary/small">
+            </div>
+          </div>
+
+          <div className="flex h-fit w-full items-center gap-3 border-t border-grid-bright bg-background-bright p-[0.86rem] pl-4">
+            <SimpleTooltip
+              button={
+                <div className="size-6">
+                  <svg className="h-full w-full -rotate-90 overflow-visible">
+                    <circle
+                      className="fill-none stroke-grid-bright"
+                      strokeWidth="4"
+                      r="10"
+                      cx="12"
+                      cy="12"
+                    />
+                    <circle
+                      className={`fill-none ${requiresUpgrade ? "stroke-error" : "stroke-success"}`}
+                      strokeWidth="4"
+                      r="10"
+                      cx="12"
+                      cy="12"
+                      strokeDasharray={`${usageRatio * 62.8} 62.8`}
+                      strokeDashoffset="0"
+                      strokeLinecap="round"
+                    />
+                  </svg>
+                </div>
+              }
+              content={`${Math.round(usageRatio * 100)}%`}
+            />
+            <div className="flex w-full items-center justify-between gap-6">
+              {requiresUpgrade ? (
+                <Header3 className="text-error">
+                  You've used all {limits.limit} of your seats.{" "}
+                  {canPurchaseSeats
+                    ? "Purchase more seats to invite more team members."
+                    : "Upgrade your plan to invite more team members."}
+                </Header3>
+              ) : (
+                <Header3>
+                  You've used {limits.used}/{limits.limit} of your seats
+                </Header3>
+              )}
+              {canPurchaseSeats && seatPricing ? (
+                <PurchaseSeatsModal
+                  seatPricing={seatPricing}
+                  extraSeats={extraSeats}
+                  usedSeats={limits.used}
+                  maxQuota={maxSeatQuota}
+                  planSeatLimit={planSeatLimit}
+                />
+              ) : canUpgrade ? (
+                <LinkButton to={v3BillingPath(organization)} variant="primary/small">
                   Upgrade
                 </LinkButton>
-              }
-              panelClassName="mt-4"
-            >
-              <Paragraph variant="small">
-                You've used all {limits.limit} of your available team members. Upgrade your plan to
-                enable more.
-              </Paragraph>
-            </InfoPanel>
-          ) : (
-            <div className="mt-4 flex justify-end">
-              <LinkButton
-                to={inviteTeamMemberPath(organization)}
-                variant={"secondary/small"}
-                LeadingIcon={UserPlusIcon}
-              >
-                Invite a team member
-              </LinkButton>
+              ) : null}
             </div>
-          )}
-        </MainHorizontallyCenteredContainer>
+          </div>
+        </div>
       </PageBody>
     </PageContainer>
   );
@@ -275,6 +403,7 @@ function LeaveRemoveButton({
               Leave team
             </ButtonContent>
           }
+          disableHoverableContent
           content="An organization requires at least 1 team member"
         />
       );
@@ -332,7 +461,7 @@ function LeaveTeamModal({
   return (
     <Alert open={open} onOpenChange={(o) => setOpen(o)}>
       <AlertTrigger asChild>
-        <Button variant="tertiary/small">{buttonText}</Button>
+        <Button variant="secondary/small">{buttonText}</Button>
       </AlertTrigger>
       <AlertContent>
         <AlertHeader>
@@ -341,7 +470,7 @@ function LeaveTeamModal({
         </AlertHeader>
         <AlertFooter>
           <AlertCancel asChild>
-            <Button variant="tertiary/small">Cancel</Button>
+            <Button variant="secondary/small">Cancel</Button>
           </AlertCancel>
           <Form method="post" {...form.props} onSubmit={() => setOpen(false)}>
             <input type="hidden" value={member.id} name="memberId" />
@@ -355,12 +484,61 @@ function LeaveTeamModal({
   );
 }
 
+const RESEND_COOLDOWN_SECONDS = 30;
+
+function initialCooldown(updatedAt: Date | string): number {
+  const elapsed = Math.floor((Date.now() - new Date(updatedAt).getTime()) / 1000);
+  const remaining = RESEND_COOLDOWN_SECONDS - elapsed;
+  return remaining > 0 ? remaining : 0;
+}
+
 function ResendButton({ invite }: { invite: Invite }) {
+  const navigation = useNavigation();
+  const isSubmitting =
+    navigation.state === "submitting" &&
+    navigation.formAction === resendInvitePath() &&
+    navigation.formData?.get("inviteId") === invite.id;
+  const prevSubmitting = useRef(false);
+  const [cooldown, setCooldown] = useState(() => initialCooldown(invite.updatedAt));
+  const intervalRef = useRef<ReturnType<typeof setInterval>>();
+
+  useEffect(() => {
+    if (prevSubmitting.current && !isSubmitting) {
+      setCooldown(RESEND_COOLDOWN_SECONDS);
+    }
+    prevSubmitting.current = isSubmitting;
+  }, [isSubmitting]);
+
+  const cooldownActive = cooldown > 0;
+  useEffect(() => {
+    if (!cooldownActive) return;
+
+    intervalRef.current = setInterval(() => {
+      setCooldown((c) => {
+        if (c <= 1) {
+          clearInterval(intervalRef.current);
+          return 0;
+        }
+        return c - 1;
+      });
+    }, 1000);
+
+    return () => clearInterval(intervalRef.current);
+  }, [cooldownActive]);
+
+  const isDisabled = isSubmitting || cooldown > 0;
+
   return (
     <Form method="post" action={resendInvitePath()} className="flex">
       <input type="hidden" value={invite.id} name="inviteId" />
-      <Button type="submit" variant="tertiary/small">
-        Resend invite
+      <Button type="submit" variant="secondary/small" disabled={isDisabled}>
+        {isSubmitting ? (
+          "Sending…"
+        ) : cooldown > 0 ? (
+          <span className="tabular-nums">{`Sent – resend in ${cooldown}s`}</span>
+        ) : (
+          "Resend invite"
+        )}
       </Button>
     </Form>
   );
@@ -373,12 +551,285 @@ function RevokeButton({ invite }: { invite: Invite }) {
     <Form method="post" action={revokeInvitePath()} className="flex">
       <input type="hidden" value={invite.id} name="inviteId" />
       <input type="hidden" value={organization.slug} name="slug" />
-      <Button
-        type="submit"
-        variant="danger/small"
-        LeadingIcon={TrashIcon}
-        leadingIconClassName="text-white"
+      <SimpleTooltip
+        button={
+          <Button
+            type="submit"
+            variant="danger/small"
+            LeadingIcon={NoSymbolIcon}
+            leadingIconClassName="text-white"
+            aria-label="Revoke invite"
+          />
+        }
+        content="Revoke invite"
+        disableHoverableContent
+        asChild
       />
     </Form>
   );
 }
+
+export function PurchaseSeatsModal({
+  seatPricing,
+  extraSeats,
+  usedSeats,
+  maxQuota,
+  planSeatLimit,
+  triggerButton,
+}: {
+  seatPricing: {
+    stepSize: number;
+    centsPerStep: number;
+  };
+  extraSeats: number;
+  usedSeats: number;
+  maxQuota: number;
+  planSeatLimit: number;
+  triggerButton?: React.ReactElement;
+}) {
+  const fetcher = useFetcher();
+  const organization = useOrganization();
+  const lastSubmission =
+    fetcher.data && typeof fetcher.data === "object" && "intent" in fetcher.data
+      ? fetcher.data
+      : undefined;
+  const [form, { amount }] = useForm({
+    id: "purchase-seats",
+    lastSubmission: lastSubmission as any,
+    onValidate({ formData }) {
+      return parse(formData, { schema: PurchaseSchema });
+    },
+    shouldRevalidate: "onSubmit",
+  });
+
+  const [amountValue, setAmountValue] = useState(extraSeats);
+  useEffect(() => {
+    setAmountValue(extraSeats);
+  }, [extraSeats]);
+  const isLoading = fetcher.state !== "idle";
+
+  const [open, setOpen] = useState(false);
+  useEffect(() => {
+    const data = fetcher.data;
+    if (
+      fetcher.state === "idle" &&
+      data !== null &&
+      typeof data === "object" &&
+      "ok" in data &&
+      data.ok
+    ) {
+      setOpen(false);
+    }
+  }, [fetcher.state, fetcher.data]);
+
+  const state = updateSeatState({
+    value: amountValue,
+    existingValue: extraSeats,
+    quota: maxQuota,
+    usedSeats,
+    planSeatLimit,
+  });
+  const changeClassName =
+    state === "decrease" ? "text-error" : state === "increase" ? "text-success" : undefined;
+
+  const pricePerSeat = seatPricing.centsPerStep / seatPricing.stepSize / 100;
+  const title = extraSeats === 0 ? "Purchase extra seats…" : "Add/remove extra seats…";
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        {triggerButton ?? (
+          <Button variant="primary/small" onClick={() => setOpen(true)}>
+            {title}
+          </Button>
+        )}
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>{title}</DialogHeader>
+        <fetcher.Form method="post" action={organizationTeamPath(organization)} {...form.props}>
+          <input type="hidden" name="_formType" value="purchase-seats" />
+          <div className="flex flex-col gap-4 pt-2">
+            <div className="flex flex-col gap-1">
+              <Paragraph variant="small/bright">
+                Purchase extra seats at {formatCurrency(pricePerSeat, true)}/month per seat.
+                Reducing seats will take effect at the start of your next billing cycle (on the 1st
+                of the month).
+              </Paragraph>
+            </div>
+            <Fieldset>
+              <InputGroup fullWidth>
+                <Label htmlFor="amount" className="text-text-dimmed">
+                  Total extra seats
+                </Label>
+                <InputNumberStepper
+                  {...conform.input(amount, { type: "number" })}
+                  step={seatPricing.stepSize}
+                  min={0}
+                  max={undefined}
+                  value={amountValue}
+                  onChange={(e) => setAmountValue(Number(e.target.value))}
+                  disabled={isLoading}
+                />
+                <FormError id={amount.errorId}>
+                  {amount.error ?? amount.initialError?.[""]?.[0]}
+                </FormError>
+                <FormError>{form.error}</FormError>
+              </InputGroup>
+            </Fieldset>
+            {state === "need_to_remove_members" ? (
+              <div className="flex flex-col pb-3">
+                <Paragraph variant="small" className="text-warning" spacing>
+                  You need to remove {formatNumber(usedSeats - (planSeatLimit + amountValue))}{" "}
+                  {usedSeats - (planSeatLimit + amountValue) === 1
+                    ? "team member or pending invite"
+                    : "team members or pending invites"}{" "}
+                  before you can reduce to this level.
+                </Paragraph>
+              </div>
+            ) : state === "above_quota" ? (
+              <div className="flex flex-col pb-3">
+                <Paragraph variant="small" className="text-warning" spacing>
+                  Currently you can only have up to {maxQuota} extra seats. Send a request below to
+                  lift your current limit. We'll get back to you soon.
+                </Paragraph>
+              </div>
+            ) : (
+              <div className="flex flex-col pb-3 tabular-nums">
+                <div className="grid grid-cols-2 border-b border-grid-dimmed pb-1">
+                  <Header3 className="font-normal text-text-dimmed">Summary</Header3>
+                  <Header3 className="justify-self-end font-normal text-text-dimmed">Total</Header3>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className="pb-0 font-normal text-text-dimmed">
+                    <span className="text-text-bright">{formatNumber(extraSeats)}</span> current
+                    extra
+                  </Header3>
+                  <Header3 className="justify-self-end font-normal text-text-bright">
+                    {formatCurrency(extraSeats * pricePerSeat, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({extraSeats} {extraSeats === 1 ? "seat" : "seats"})
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className={cn("pb-0 font-normal", changeClassName)}>
+                    {state === "increase" ? "+" : null}
+                    {formatNumber(amountValue - extraSeats)}
+                  </Header3>
+                  <Header3 className={cn("justify-self-end font-normal", changeClassName)}>
+                    {state === "increase" ? "+" : null}
+                    {formatCurrency((amountValue - extraSeats) * pricePerSeat, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({Math.abs(amountValue - extraSeats)}{" "}
+                    {Math.abs(amountValue - extraSeats) === 1 ? "seat" : "seats"} @{" "}
+                    {formatCurrency(pricePerSeat, true)}/mth)
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+                <div className="grid grid-cols-2 pt-2">
+                  <Header3 className="pb-0 font-normal text-text-dimmed">
+                    <span className="text-text-bright">{formatNumber(amountValue)}</span> new total
+                  </Header3>
+                  <Header3 className="justify-self-end font-normal text-text-bright">
+                    {formatCurrency(amountValue * pricePerSeat, true)}
+                  </Header3>
+                </div>
+                <div className="grid grid-cols-2 text-xs">
+                  <span className="text-text-dimmed">
+                    ({amountValue} {amountValue === 1 ? "seat" : "seats"})
+                  </span>
+                  <span className="justify-self-end text-text-dimmed">/mth</span>
+                </div>
+              </div>
+            )}
+          </div>
+          <FormButtons
+            confirmButton={
+              state === "above_quota" ? (
+                <>
+                  <input type="hidden" name="action" value="quota-increase" />
+                  <Button
+                    LeadingIcon={isLoading ? SpinnerWhite : EnvelopeIcon}
+                    variant="primary/medium"
+                    type="submit"
+                    disabled={isLoading}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Send request for ${formatNumber(
+                      amountValue
+                    )}`}</span>
+                  </Button>
+                </>
+              ) : state === "decrease" || state === "need_to_remove_members" ? (
+                <>
+                  <input type="hidden" name="action" value="purchase" />
+                  <Button
+                    variant="danger/medium"
+                    type="submit"
+                    disabled={isLoading || state === "need_to_remove_members"}
+                    LeadingIcon={isLoading ? SpinnerWhite : undefined}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Remove ${formatNumber(
+                      extraSeats - amountValue
+                    )} ${extraSeats - amountValue === 1 ? "seat" : "seats"}`}</span>
+                  </Button>
+                </>
+              ) : (
+                <>
+                  <input type="hidden" name="action" value="purchase" />
+                  <Button
+                    variant="primary/medium"
+                    type="submit"
+                    disabled={isLoading || state === "no_change"}
+                    LeadingIcon={isLoading ? SpinnerWhite : undefined}
+                  >
+                    <span className="tabular-nums text-text-bright">{`Purchase ${formatNumber(
+                      amountValue - extraSeats
+                    )} ${amountValue - extraSeats === 1 ? "seat" : "seats"}`}</span>
+                  </Button>
+                </>
+              )
+            }
+            cancelButton={
+              <DialogClose asChild>
+                <Button variant="secondary/medium" disabled={isLoading}>
+                  Cancel
+                </Button>
+              </DialogClose>
+            }
+          />
+        </fetcher.Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function updateSeatState({
+  value,
+  existingValue,
+  quota,
+  usedSeats,
+  planSeatLimit,
+}: {
+  value: number;
+  existingValue: number;
+  quota: number;
+  usedSeats: number;
+  planSeatLimit: number;
+}): "no_change" | "increase" | "decrease" | "above_quota" | "need_to_remove_members" {
+  if (value === existingValue) return "no_change";
+  if (value < existingValue) {
+    const newTotalLimit = planSeatLimit + value;
+    if (usedSeats > newTotalLimit) {
+      return "need_to_remove_members";
+    }
+    return "decrease";
+  }
+  if (value > quota) return "above_quota";
+  return "increase";
+}
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.usage/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.usage/route.tsx
index cfefb3938c0..0957c06d044 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.usage/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.usage/route.tsx
@@ -2,18 +2,14 @@ import { InformationCircleIcon } from "@heroicons/react/20/solid";
 import { Await, type MetaFunction } from "@remix-run/react";
 import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { formatDurationMilliseconds } from "@trigger.dev/core/v3";
-import { Suspense } from "react";
-import { Bar, BarChart, CartesianGrid, XAxis, YAxis } from "recharts";
+import { Suspense, useMemo } from "react";
 import { redirect, typeddefer, useTypedLoaderData } from "remix-typedjson";
 import { URL } from "url";
 import { UsageBar } from "~/components/billing/UsageBar";
 import { PageBody, PageContainer } from "~/components/layout/AppLayout";
-import {
-  type ChartConfig,
-  ChartContainer,
-  ChartTooltip,
-  ChartTooltipContent,
-} from "~/components/primitives/Chart";
+import { Card } from "~/components/primitives/charts/Card";
+import type { ChartConfig } from "~/components/primitives/charts/Chart";
+import { Chart } from "~/components/primitives/charts/ChartCompound";
 import { Header2 } from "~/components/primitives/Headers";
 import { InfoPanel } from "~/components/primitives/InfoPanel";
 import { NavBar, PageTitle } from "~/components/primitives/PageHeader";
@@ -171,30 +167,30 @@ export default function Page() {
               </Suspense>
             </div>
           </div>
-          <div>
-            <Header2 spacing className="pl-3">
-              Usage by day
-            </Header2>
-            <div className="p-3">
-              <Suspense
-                fallback={
-                  <div className="flex min-h-40 items-center justify-center">
-                    <Spinner />
-                  </div>
-                }
-              >
-                <Await
-                  resolve={usage}
-                  errorElement={
+          <div className="px-3">
+            <Card>
+              <Card.Header>Usage by day</Card.Header>
+              <Card.Content>
+                <Suspense
+                  fallback={
                     <div className="flex min-h-40 items-center justify-center">
-                      <Paragraph variant="small">Failed to load graph.</Paragraph>
+                      <Spinner />
                     </div>
                   }
                 >
-                  {(u) => <UsageChart data={u.timeSeries} />}
-                </Await>
-              </Suspense>
-            </div>
+                  <Await
+                    resolve={usage}
+                    errorElement={
+                      <div className="flex min-h-40 items-center justify-center">
+                        <Paragraph variant="small">Failed to load graph.</Paragraph>
+                      </div>
+                    }
+                  >
+                    {(u) => <UsageChart data={u.timeSeries} />}
+                  </Await>
+                </Suspense>
+              </Card.Content>
+            </Card>
           </div>
           <div>
             <Header2 spacing className="pl-3">
@@ -284,7 +280,7 @@ export default function Page() {
 
 const chartConfig = {
   dollars: {
-    label: "Usage ($)",
+    label: "Usage $",
     color: "#7655fd",
   },
 } satisfies ChartConfig;
@@ -294,48 +290,40 @@ const tooltipDateFormatter = new Intl.DateTimeFormat("en-US", {
   day: "numeric",
 });
 
+const xAxisTickFormatter = (value: string) => {
+  if (!value) return "";
+  const date = new Date(value);
+  return `${date.getDate()}`;
+};
+
+const tooltipLabelFormatter = (label: string) => {
+  if (!label) return "";
+  return tooltipDateFormatter.format(new Date(label));
+};
+
 function UsageChart({ data }: { data: UsageSeriesData }) {
   const maxDollar = Math.max(...data.map((d) => d.dollars));
   const decimalPlaces = maxDollar < 1 ? 4 : 2;
 
-  return (
-    <ChartContainer config={chartConfig} className="max-h-96 min-h-40 w-full">
-      <BarChart accessibilityLayer data={data}>
-        <CartesianGrid vertical={false} />
-        <XAxis
-          fontSize={12}
-          tickLine={false}
-          tickMargin={10}
-          axisLine={false}
-          dataKey="date"
-          tickFormatter={(value) => {
-            if (!value) return "";
-            const date = new Date(value);
-            return `${date.getDate()}`;
-          }}
-          className="text-xs"
-        />
-        <YAxis
-          fontSize={12}
-          tickLine={false}
-          tickMargin={10}
-          axisLine={false}
-          allowDecimals={true}
-          tickFormatter={(value) => `$${value.toFixed(decimalPlaces)}`}
-        />
-        <ChartTooltip
-          content={<ChartTooltipContent />}
-          labelFormatter={(value, data) => {
-            const dateString = data.at(0)?.payload.date;
-            if (!dateString) {
-              return "";
-            }
+  const yAxisTickFormatter = useMemo(
+    () => (value: number) => `$${value.toFixed(decimalPlaces)}`,
+    [decimalPlaces]
+  );
 
-            return tooltipDateFormatter.format(new Date(dateString));
-          }}
-        />
-        <Bar dataKey="dollars" fill="var(--color-dollars)" radius={[4, 4, 0, 0]} />
-      </BarChart>
-    </ChartContainer>
+  return (
+    <Chart.Root
+      config={chartConfig}
+      data={data}
+      dataKey="date"
+      showLegend={false}
+      enableZoom={false}
+      minHeight="160px"
+    >
+      <Chart.Bar
+        xAxisProps={{ tickFormatter: xAxisTickFormatter }}
+        yAxisProps={{ tickFormatter: yAxisTickFormatter, allowDecimals: true }}
+        tooltipLabelFormatter={tooltipLabelFormatter}
+      />
+    </Chart.Root>
   );
 }
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug/route.tsx
index 8a22bdefc98..6fea018af54 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug/route.tsx
@@ -3,6 +3,7 @@ import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { typedjson } from "remix-typedjson";
 import { z } from "zod";
 import { RouteErrorDisplay } from "~/components/ErrorDisplay";
+import { prisma } from "~/db.server";
 import { useOptionalOrganization } from "~/hooks/useOrganizations";
 import { useTypedMatchesData } from "~/hooks/useTypedMatchData";
 import { OrganizationsPresenter } from "~/presenters/OrganizationsPresenter.server";
@@ -87,9 +88,18 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   firstDayOfNextMonth.setUTCDate(1);
   firstDayOfNextMonth.setUTCHours(0, 0, 0, 0);
 
-  const [plan, usage] = await Promise.all([
+  const [plan, usage, customDashboards] = await Promise.all([
     getCurrentPlan(organization.id),
     getCachedUsage(organization.id, { from: firstDayOfMonth, to: firstDayOfNextMonth }),
+    prisma.metricsDashboard.findMany({
+      where: { organizationId: organization.id },
+      select: {
+        friendlyId: true,
+        title: true,
+        layout: true,
+      },
+      orderBy: { createdAt: "desc" },
+    }),
   ]);
 
   let hasExceededFreeTier = false;
@@ -99,6 +109,39 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     usagePercentage = usage.cents / plan.v3Subscription.plan.limits.includedUsage;
   }
 
+  // Derive metric dashboard limit from plan, fallback to 3
+  const metricDashboardsLimitValue = plan?.v3Subscription?.plan?.limits?.metricDashboards;
+  const dashboardLimit =
+    typeof metricDashboardsLimitValue === "number"
+      ? metricDashboardsLimitValue
+      : metricDashboardsLimitValue?.number ?? 3;
+
+  // Derive widget-per-dashboard limit from plan, fallback to 16
+  const metricWidgetsLimitValue = plan?.v3Subscription?.plan?.limits?.metricWidgetsPerDashboard;
+  const widgetLimitPerDashboard =
+    typeof metricWidgetsLimitValue === "number"
+      ? metricWidgetsLimitValue
+      : metricWidgetsLimitValue?.number ?? 16;
+
+  // Compute widget counts per dashboard from layout JSON
+  const customDashboardsWithWidgetCount = customDashboards.map((d) => {
+    let widgetCount = 0;
+    try {
+      const layout = JSON.parse(String(d.layout)) as Record<string, unknown>;
+      const widgets = layout.widgets;
+      if (widgets && typeof widgets === "object") {
+        widgetCount = Object.keys(widgets as Record<string, unknown>).length;
+      }
+    } catch {
+      // ignore parse errors
+    }
+    return {
+      friendlyId: d.friendlyId,
+      title: d.title,
+      widgetCount,
+    };
+  });
+
   return typedjson({
     organizations,
     organization,
@@ -106,6 +149,12 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     environment,
     isImpersonating: !!impersonationId,
     currentPlan: { ...plan, v3Usage: { ...usage, hasExceededFreeTier, usagePercentage } },
+    customDashboards: customDashboardsWithWidgetCount,
+    dashboardLimits: {
+      used: customDashboards.length,
+      limit: dashboardLimit,
+    },
+    widgetLimitPerDashboard,
   });
 };
 
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
index 68c3306e284..39cde0cf2d0 100644
--- a/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.$organizationSlug_.projects.new/route.tsx
@@ -1,15 +1,17 @@
 import { conform, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import { FolderIcon } from "@heroicons/react/20/solid";
-import type { ActionFunction, LoaderFunctionArgs } from "@remix-run/node";
-import { json } from "@remix-run/node";
+import { CommandLineIcon, FolderIcon } from "@heroicons/react/20/solid";
+import { json, type ActionFunction, type LoaderFunctionArgs } from "@remix-run/node";
 import { Form, useActionData, useNavigation } from "@remix-run/react";
+import type { Prisma } from "@trigger.dev/database";
+import React, { useEffect, useState } from "react";
 import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
 import invariant from "tiny-invariant";
 import { z } from "zod";
 import { BackgroundWrapper } from "~/components/BackgroundWrapper";
 import { Feedback } from "~/components/Feedback";
 import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
+import { TechnologyPicker } from "~/components/onboarding/TechnologyPicker";
 import { Button, LinkButton } from "~/components/primitives/Buttons";
 import { Callout } from "~/components/primitives/Callout";
 import { Fieldset } from "~/components/primitives/Fieldset";
@@ -19,7 +21,8 @@ import { FormTitle } from "~/components/primitives/FormTitle";
 import { Input } from "~/components/primitives/Input";
 import { InputGroup } from "~/components/primitives/InputGroup";
 import { Label } from "~/components/primitives/Label";
-import { ButtonSpinner } from "~/components/primitives/Spinner";
+import { Select, SelectItem } from "~/components/primitives/Select";
+
 import { prisma } from "~/db.server";
 import { featuresForRequest } from "~/features.server";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
@@ -32,6 +35,79 @@ import {
   selectPlanPath,
   v3ProjectPath,
 } from "~/utils/pathBuilder";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+
+const WORKING_ON_OTHER = "Other/not sure yet";
+const GOALS_OTHER = "Other/not sure yet";
+
+const workingOnOptions = [
+  "AI agent",
+  "Media processing pipeline",
+  "Media generation with AI",
+  "Event-driven workflow",
+  "Realtime streaming",
+  "Internal tool or background job",
+  WORKING_ON_OTHER,
+] as const;
+
+const goalOptions = [
+  "Ship a production workflow",
+  "Prototype or explore",
+  "Migrate an existing system",
+  "Learn how Trigger works",
+  "Evaluate against alternatives",
+  GOALS_OTHER,
+] as const;
+
+function shuffleArray<T>(arr: T[]): T[] {
+  const shuffled = [...arr];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
+
+function MultiSelectField({
+  value,
+  setValue,
+  items,
+  icon,
+}: {
+  value: string[];
+  setValue: (value: string[]) => void;
+  items: string[];
+  icon: React.ReactNode;
+}) {
+  return (
+    <Select<string[], string>
+      value={value}
+      setValue={setValue}
+      placeholder="Select some options"
+      variant="secondary/small"
+      dropdownIcon
+      icon={icon}
+      items={items}
+      className="h-8 min-w-0 border-0 bg-charcoal-750 pl-2 text-sm text-text-dimmed ring-charcoal-600 transition hover:bg-charcoal-650 hover:text-text-dimmed hover:ring-1"
+      text={(v) =>
+        v.length === 0 ? undefined : (
+          <span className="flex min-w-0 items-center text-text-bright">
+            <span className="truncate">{v.slice(0, 2).join(", ")}</span>
+            {v.length > 2 && <span className="ml-1 flex-none">+{v.length - 2} more</span>}
+          </span>
+        )
+      }
+    >
+      {(items) =>
+        items.map((item) => (
+          <SelectItem key={item} value={item} checkPosition="left">
+            <span className="text-text-bright">{item}</span>
+          </SelectItem>
+        ))
+      }
+    </Select>
+  );
+}
 
 export async function loader({ params, request }: LoaderFunctionArgs) {
   const userId = await requireUserId(request);
@@ -61,14 +137,12 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
     throw new Response(null, { status: 404, statusText: "Organization not found" });
   }
 
-  //if you don't have v3 access, you must select a plan
   const { isManagedCloud } = featuresForRequest(request);
   if (isManagedCloud && !organization.v3Enabled) {
     return redirect(selectPlanPath({ slug: organizationSlug }));
   }
 
   const url = new URL(request.url);
-
   const message = url.searchParams.get("message");
 
   return typedjson({
@@ -89,6 +163,14 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
 const schema = z.object({
   projectName: z.string().min(3, "Project name must have at least 3 characters").max(50),
   projectVersion: z.enum(["v2", "v3"]),
+  workingOn: z.string().optional(),
+  workingOnOther: z.string().optional(),
+  technologies: z.string().optional(),
+  technologiesOther: z.string().optional(),
+  goals: z.string().optional(),
+  goalsOther: z.string().optional(),
+  workingOnPositions: z.string().optional(),
+  goalsPositions: z.string().optional(),
 });
 
 export const action: ActionFunction = async ({ request, params }) => {
@@ -103,14 +185,110 @@ export const action: ActionFunction = async ({ request, params }) => {
     return json(submission);
   }
 
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const configurationId = url.searchParams.get("configurationId");
+  const next = url.searchParams.get("next");
+
+  const stringArraySchema = z.array(z.string());
+
+  function safeParseStringArray(value: string | undefined): string[] | undefined {
+    if (!value) return undefined;
+    try {
+      const result = stringArraySchema.safeParse(JSON.parse(value));
+      return result.success && result.data.length > 0 ? result.data : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  const numberArraySchema = z.array(z.number());
+  function safeParseNumberArray(value: string | undefined): number[] | undefined {
+    if (!value) return undefined;
+    try {
+      const result = numberArraySchema.safeParse(JSON.parse(value));
+      return result.success && result.data.length > 0 ? result.data : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  const onboardingData: Record<string, Prisma.InputJsonValue> = {};
+
+  const workingOn = safeParseStringArray(submission.value.workingOn);
+  if (workingOn) {
+    onboardingData.workingOn = workingOn;
+    const workingOnPositions = safeParseNumberArray(submission.value.workingOnPositions);
+    if (workingOnPositions) onboardingData.workingOnPositions = workingOnPositions;
+  }
+
+  if (submission.value.workingOnOther) {
+    onboardingData.workingOnOther = submission.value.workingOnOther;
+  }
+
+  const technologies = safeParseStringArray(submission.value.technologies);
+  if (technologies) onboardingData.technologies = technologies;
+
+  const technologiesOther = safeParseStringArray(submission.value.technologiesOther);
+  if (technologiesOther) onboardingData.technologiesOther = technologiesOther;
+
+  const goals = safeParseStringArray(submission.value.goals);
+  if (goals) {
+    onboardingData.goals = goals;
+    const goalsPositions = safeParseNumberArray(submission.value.goalsPositions);
+    if (goalsPositions) onboardingData.goalsPositions = goalsPositions;
+  }
+
+  if (submission.value.goalsOther) {
+    onboardingData.goalsOther = submission.value.goalsOther;
+  }
+
   try {
     const project = await createProject({
       organizationSlug: organizationSlug,
       name: submission.value.projectName,
       userId,
       version: submission.value.projectVersion,
+      onboardingData: Object.keys(onboardingData).length > 0 ? onboardingData : undefined,
     });
 
+    if (code && configurationId) {
+      const environment = await prisma.runtimeEnvironment.findFirst({
+        where: {
+          projectId: project.id,
+          slug: "prod",
+          archivedAt: null,
+        },
+      });
+
+      if (!environment) {
+        return redirectWithErrorMessage(
+          newProjectPath({ slug: organizationSlug }),
+          request,
+          "Failed to find project environment."
+        );
+      }
+
+      const state = await generateVercelOAuthState({
+        organizationId: project.organization.id,
+        projectId: project.id,
+        environmentSlug: environment.slug,
+        organizationSlug: project.organization.slug,
+        projectSlug: project.slug,
+      });
+
+      const params = new URLSearchParams({
+        state,
+        code,
+        configurationId,
+        origin: "marketplace",
+      });
+      if (next) {
+        params.set("next", next);
+      }
+      return redirect(`/vercel/connect?${params.toString()}`);
+    }
+
     return redirectWithSuccessMessage(
       v3ProjectPath(project.organization, project),
       request,
@@ -150,7 +328,6 @@ export default function Page() {
 
   const [form, { projectName, projectVersion }] = useForm({
     id: "create-project",
-    // TODO: type this
     lastSubmission: lastSubmission as any,
     onValidate({ formData }) {
       return parse(formData, { schema });
@@ -160,10 +337,31 @@ export default function Page() {
   const navigation = useNavigation();
   const isLoading = navigation.state === "submitting" || navigation.state === "loading";
 
+  const [selectedWorkingOn, setSelectedWorkingOn] = useState<string[]>([]);
+  const [workingOnOther, setWorkingOnOther] = useState("");
+  const [selectedTechnologies, setSelectedTechnologies] = useState<string[]>([]);
+  const [customTechnologies, setCustomTechnologies] = useState<string[]>([]);
+  const [selectedGoals, setSelectedGoals] = useState<string[]>([]);
+  const [goalsOther, setGoalsOther] = useState("");
+
+  const [shuffledWorkingOn, setShuffledWorkingOn] = useState<string[]>([...workingOnOptions]);
+  const [shuffledGoals, setShuffledGoals] = useState<string[]>([...goalOptions]);
+
+  useEffect(() => {
+    const nonOther = workingOnOptions.filter((o) => o !== WORKING_ON_OTHER);
+    setShuffledWorkingOn([...shuffleArray(nonOther), WORKING_ON_OTHER]);
+
+    const nonOtherGoals = goalOptions.filter((o) => o !== GOALS_OTHER);
+    setShuffledGoals([...shuffleArray(nonOtherGoals), GOALS_OTHER]);
+  }, []);
+
+  const showWorkingOnOther = selectedWorkingOn.includes(WORKING_ON_OTHER);
+  const showGoalsOther = selectedGoals.includes(GOALS_OTHER);
+
   return (
     <AppContainer className="bg-charcoal-900">
       <BackgroundWrapper>
-        <MainCenteredContainer className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+        <MainCenteredContainer variant="onboarding" className="max-w-[29rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
           <div>
             <FormTitle
               LeadingIcon={<FolderIcon className="size-7 text-indigo-500" />}
@@ -178,7 +376,9 @@ export default function Page() {
               )}
               <Fieldset>
                 <InputGroup>
-                  <Label htmlFor={projectName.id}>Project name</Label>
+                  <Label htmlFor={projectName.id}>
+                    Project name <span className="text-text-bright">*</span>
+                  </Label>
                   <Input
                     {...conform.input(projectName, { type: "text" })}
                     placeholder="Your project name"
@@ -192,15 +392,96 @@ export default function Page() {
                 ) : (
                   <input {...conform.input(projectVersion, { type: "hidden" })} value={"v2"} />
                 )}
+
+                <div className="border-t border-charcoal-700" />
+                <InputGroup>
+                  <Label>What are you working on?</Label>
+                  <input type="hidden" name="workingOn" value={JSON.stringify(selectedWorkingOn)} />
+                  <input
+                    type="hidden"
+                    name="workingOnPositions"
+                    value={JSON.stringify(
+                      selectedWorkingOn.map((v) => shuffledWorkingOn.indexOf(v) + 1)
+                    )}
+                  />
+                  <MultiSelectField
+                    value={selectedWorkingOn}
+                    setValue={setSelectedWorkingOn}
+                    items={shuffledWorkingOn}
+                    icon={<CommandLineIcon className="mr-1 size-4 text-text-dimmed" />}
+                  />
+                  {showWorkingOnOther && (
+                    <>
+                      <input type="hidden" name="workingOnOther" value={workingOnOther} />
+                      <Input
+                        type="text"
+                        variant="small"
+                        value={workingOnOther}
+                        onChange={(e) => setWorkingOnOther(e.target.value)}
+                        placeholder="Tell us what you're working on"
+                        spellCheck={false}
+                        containerClassName="h-8"
+                      />
+                    </>
+                  )}
+                </InputGroup>
+
+                <InputGroup>
+                  <Label>What technologies are you using?</Label>
+                  <input
+                    type="hidden"
+                    name="technologies"
+                    value={JSON.stringify(selectedTechnologies)}
+                  />
+                  <input
+                    type="hidden"
+                    name="technologiesOther"
+                    value={JSON.stringify(customTechnologies)}
+                  />
+                  <TechnologyPicker
+                    value={selectedTechnologies}
+                    onChange={setSelectedTechnologies}
+                    customValues={customTechnologies}
+                    onCustomValuesChange={setCustomTechnologies}
+                  />
+                </InputGroup>
+
+                <InputGroup>
+                  <Label>What are you trying to do with Trigger.dev?</Label>
+                  <input type="hidden" name="goals" value={JSON.stringify(selectedGoals)} />
+                  <input
+                    type="hidden"
+                    name="goalsPositions"
+                    value={JSON.stringify(
+                      selectedGoals.map((v) => shuffledGoals.indexOf(v) + 1)
+                    )}
+                  />
+                  <MultiSelectField
+                    value={selectedGoals}
+                    setValue={setSelectedGoals}
+                    items={shuffledGoals}
+                    icon={<CommandLineIcon className="mr-1 size-4 text-text-dimmed" />}
+                  />
+                  {showGoalsOther && (
+                    <>
+                      <input type="hidden" name="goalsOther" value={goalsOther} />
+                      <Input
+                        type="text"
+                        variant="small"
+                        value={goalsOther}
+                        onChange={(e) => setGoalsOther(e.target.value)}
+                        placeholder="Tell us what you're trying to do with Trigger.dev"
+                        spellCheck={false}
+                        containerClassName="h-8"
+                      />
+                    </>
+                  )}
+                </InputGroup>
+
                 <FormButtons
                   confirmButton={
-                    <Button
-                      type="submit"
-                      variant={"primary/small"}
-                      disabled={isLoading}
-                      TrailingIcon={isLoading ? ButtonSpinner : undefined}
-                    >
-                      {isLoading ? "Creating…" : "Create"}
+                    <Button type="submit" variant={"primary/small"} isLoading={isLoading}>
+                      Create
                     </Button>
                   }
                   cancelButton={
diff --git a/apps/webapp/app/routes/_app.orgs.new/route.tsx b/apps/webapp/app/routes/_app.orgs.new/route.tsx
index a677782eaec..f4f7f995bf9 100644
--- a/apps/webapp/app/routes/_app.orgs.new/route.tsx
+++ b/apps/webapp/app/routes/_app.orgs.new/route.tsx
@@ -1,10 +1,10 @@
 import { conform, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import { BuildingOffice2Icon } from "@heroicons/react/20/solid";
+import { BuildingOffice2Icon, GlobeAltIcon } from "@heroicons/react/20/solid";
 import { RadioGroup } from "@radix-ui/react-radio-group";
-import type { ActionFunction, LoaderFunctionArgs } from "@remix-run/node";
-import { json, redirect } from "@remix-run/node";
+import { json, redirect, type ActionFunction, type LoaderFunctionArgs } from "@remix-run/node";
 import { Form, useActionData, useNavigation } from "@remix-run/react";
+import { useState } from "react";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
 import { z } from "zod";
 import { BackgroundWrapper } from "~/components/BackgroundWrapper";
@@ -19,18 +19,18 @@ import { Input } from "~/components/primitives/Input";
 import { InputGroup } from "~/components/primitives/InputGroup";
 import { Label } from "~/components/primitives/Label";
 import { RadioGroupItem } from "~/components/primitives/RadioButton";
-import { TextArea } from "~/components/primitives/TextArea";
+import { useFaviconUrl } from "~/hooks/useFaviconUrl";
 import { useFeatures } from "~/hooks/useFeatures";
 import { createOrganization } from "~/models/organization.server";
 import { NewOrganizationPresenter } from "~/presenters/NewOrganizationPresenter.server";
 import { requireUser, requireUserId } from "~/services/session.server";
-import { sendNewOrgMessage } from "~/services/slack.server";
+import { extractDomain, faviconUrl } from "~/utils/favicon";
 import { organizationPath, rootPath } from "~/utils/pathBuilder";
 
 const schema = z.object({
   orgName: z.string().min(3).max(50),
   companySize: z.string().optional(),
-  whyUseUs: z.string().optional(),
+  companyUrl: z.string().optional(),
 });
 
 export const loader = async ({ request }: LoaderFunctionArgs) => {
@@ -53,20 +53,49 @@ export const action: ActionFunction = async ({ request }) => {
   }
 
   try {
+    const companySize = submission.value.companySize ?? null;
+
+    const onboardingData: Record<string, string> = {};
+    if (submission.value.companyUrl) {
+      onboardingData.companyUrl = submission.value.companyUrl;
+    }
+    if (submission.value.companySize) {
+      onboardingData.companySize = submission.value.companySize;
+    }
+
+    let avatar: { type: "image"; url: string } | undefined;
+    if (submission.value.companyUrl) {
+      const domain = extractDomain(submission.value.companyUrl);
+      if (domain) {
+        avatar = { type: "image", url: faviconUrl(domain) };
+      }
+    }
+
     const organization = await createOrganization({
       title: submission.value.orgName,
       userId: user.id,
-      companySize: submission.value.companySize ?? null,
+      companySize,
+      onboardingData: Object.keys(onboardingData).length > 0 ? onboardingData : undefined,
+      avatar,
     });
 
-    const whyUseUs = formData.get("whyUseUs");
+    const url = new URL(request.url);
+    const code = url.searchParams.get("code");
+    const configurationId = url.searchParams.get("configurationId");
+    const integration = url.searchParams.get("integration");
+    const next = url.searchParams.get("next");
 
-    if (whyUseUs) {
-      await sendNewOrgMessage({
-        orgName: submission.value.orgName,
-        whyUseUs: whyUseUs.toString(),
-        userEmail: user.email,
+    if (code && configurationId && integration === "vercel") {
+      const params = new URLSearchParams({
+        code,
+        configurationId,
+        integration,
       });
+      if (next) {
+        params.set("next", next);
+      }
+      const redirectUrl = `${organizationPath(organization)}/projects/new?${params.toString()}`;
+      return redirect(redirectUrl);
     }
 
     return redirect(organizationPath(organization));
@@ -80,10 +109,12 @@ export default function NewOrganizationPage() {
   const lastSubmission = useActionData();
   const { isManagedCloud } = useFeatures();
   const navigation = useNavigation();
+  const [companyUrl, setCompanyUrl] = useState("");
+  const faviconUrl = useFaviconUrl(companyUrl);
+  const [faviconError, setFaviconError] = useState(false);
 
   const [form, { orgName }] = useForm({
     id: "create-organization",
-    // TODO: type this
     lastSubmission: lastSubmission as any,
     onValidate({ formData }) {
       return parse(formData, { schema });
@@ -94,10 +125,25 @@ export default function NewOrganizationPage() {
 
   const isLoading = navigation.state === "submitting" || navigation.state === "loading";
 
+  const urlIcon =
+    faviconUrl && !faviconError ? (
+      <img
+        src={faviconUrl}
+        alt=""
+        width={16}
+        height={16}
+        className="ml-0.5 shrink-0 rounded-sm"
+        onError={() => setFaviconError(true)}
+        onLoad={() => setFaviconError(false)}
+      />
+    ) : (
+      GlobeAltIcon
+    );
+
   return (
     <AppContainer className="bg-charcoal-900">
       <BackgroundWrapper>
-        <MainCenteredContainer className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+        <MainCenteredContainer variant="onboarding" className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
           <FormTitle
             LeadingIcon={<BuildingOffice2Icon className="size-6 text-fuchsia-600" />}
             title="Create an Organization"
@@ -105,20 +151,36 @@ export default function NewOrganizationPage() {
           <Form method="post" {...form.props}>
             <Fieldset>
               <InputGroup>
-                <Label htmlFor={orgName.id}>Organization name</Label>
+                <Label htmlFor={orgName.id}>Organization name *</Label>
                 <Input
                   {...conform.input(orgName, { type: "text" })}
                   placeholder="Your Organization name"
                   icon={BuildingOffice2Icon}
                   autoFocus
                 />
-                <Hint>E.g. your company name or your workspace name.</Hint>
+                <Hint>Normally your company name.</Hint>
                 <FormError id={orgName.errorId}>{orgName.error}</FormError>
               </InputGroup>
               {isManagedCloud && (
                 <>
                   <InputGroup>
-                    <Label htmlFor={"companySize"}>Number of employees</Label>
+                    <Label htmlFor="companyUrl">URL</Label>
+                    <Input
+                      id="companyUrl"
+                      name="companyUrl"
+                      type="url"
+                      placeholder="Your Organization URL"
+                      icon={urlIcon}
+                      value={companyUrl}
+                      onChange={(e) => {
+                        setCompanyUrl(e.target.value);
+                        setFaviconError(false);
+                      }}
+                    />
+                    <Hint>Add your company URL and we'll use it as your organization's logo.</Hint>
+                  </InputGroup>
+                  <InputGroup>
+                    <Label htmlFor="companySize">Number of employees</Label>
                     <RadioGroup
                       name="companySize"
                       className="flex items-center justify-between gap-2"
@@ -153,25 +215,18 @@ export default function NewOrganizationPage() {
                       />
                     </RadioGroup>
                   </InputGroup>
-                  <InputGroup>
-                    <Label htmlFor={"whyUseUs"}>What problem are you trying to solve?</Label>
-                    <TextArea name="whyUseUs" rows={4} spellCheck={false} />
-                    <Hint>
-                      Your answer will help us understand your use case and provide better support.
-                    </Hint>
-                  </InputGroup>
                 </>
               )}
 
               <FormButtons
                 confirmButton={
-                  <Button type="submit" variant={"primary/small"} disabled={isLoading}>
+                  <Button type="submit" variant={"primary/small"} isLoading={isLoading}>
                     Create
                   </Button>
                 }
                 cancelButton={
                   hasOrganizations ? (
-                    <LinkButton to={rootPath()} variant={"tertiary/small"}>
+                    <LinkButton to={rootPath()} variant={"secondary/small"}>
                       Cancel
                     </LinkButton>
                   ) : null
diff --git a/apps/webapp/app/routes/admin.api.v1.feature-flags.ts b/apps/webapp/app/routes/admin.api.v1.feature-flags.ts
index d0e1dd6b274..b10c983b14d 100644
--- a/apps/webapp/app/routes/admin.api.v1.feature-flags.ts
+++ b/apps/webapp/app/routes/admin.api.v1.feature-flags.ts
@@ -1,7 +1,8 @@
 import { ActionFunctionArgs, json } from "@remix-run/server-runtime";
 import { prisma } from "~/db.server";
 import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
-import { makeSetMultipleFlags, validatePartialFeatureFlags } from "~/v3/featureFlags.server";
+import { makeSetMultipleFlags } from "~/v3/featureFlags.server";
+import { validatePartialFeatureFlags } from "~/v3/featureFlags";
 
 export async function action({ request }: ActionFunctionArgs) {
   // Next authenticate the request
@@ -11,7 +12,7 @@ export async function action({ request }: ActionFunctionArgs) {
     return json({ error: "Invalid or Missing API key" }, { status: 401 });
   }
 
-  const user = await prisma.user.findUnique({
+  const user = await prisma.user.findFirst({
     where: {
       id: authenticationResult.userId,
     },
diff --git a/apps/webapp/app/routes/admin.api.v1.llm-models.$modelId.ts b/apps/webapp/app/routes/admin.api.v1.llm-models.$modelId.ts
new file mode 100644
index 00000000000..2556dc8267f
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.llm-models.$modelId.ts
@@ -0,0 +1,164 @@
+import { type ActionFunctionArgs, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+
+async function requireAdmin(request: Request) {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    throw json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: authResult.userId } });
+  if (!user?.admin) {
+    throw json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  return user;
+}
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  await requireAdmin(request);
+
+  const model = await prisma.llmModel.findUnique({
+    where: { id: params.modelId },
+    include: {
+      pricingTiers: {
+        include: { prices: true },
+        orderBy: { priority: "asc" },
+      },
+    },
+  });
+
+  if (!model) {
+    return json({ error: "Model not found" }, { status: 404 });
+  }
+
+  return json({ model });
+}
+
+const UpdateModelSchema = z.object({
+  modelName: z.string().min(1).optional(),
+  matchPattern: z.string().min(1).optional(),
+  startDate: z.string().nullable().optional(),
+  provider: z.string().nullable().optional(),
+  description: z.string().nullable().optional(),
+  contextWindow: z.number().int().nullable().optional(),
+  maxOutputTokens: z.number().int().nullable().optional(),
+  capabilities: z.array(z.string()).optional(),
+  isHidden: z.boolean().optional(),
+  pricingTiers: z
+    .array(
+      z.object({
+        name: z.string().min(1),
+        isDefault: z.boolean().default(true),
+        priority: z.number().int().default(0),
+        conditions: z
+          .array(
+            z.object({
+              usageDetailPattern: z.string(),
+              operator: z.enum(["gt", "gte", "lt", "lte", "eq", "neq"]),
+              value: z.number(),
+            })
+          )
+          .default([]),
+        prices: z.record(z.string(), z.number()),
+      })
+    )
+    .optional(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  await requireAdmin(request);
+
+  const modelId = params.modelId!;
+
+  if (request.method === "DELETE") {
+    const existing = await prisma.llmModel.findUnique({ where: { id: modelId } });
+    if (!existing) {
+      return json({ error: "Model not found" }, { status: 404 });
+    }
+
+    await prisma.llmModel.delete({ where: { id: modelId } });
+    return json({ success: true });
+  }
+
+  if (request.method !== "PUT") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const parsed = UpdateModelSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return json({ error: "Invalid request body", details: parsed.error.issues }, { status: 400 });
+  }
+
+  const { modelName, matchPattern, startDate, pricingTiers, provider, description, contextWindow, maxOutputTokens, capabilities, isHidden } = parsed.data;
+
+  // Validate regex if provided — strip (?i) POSIX flag since our registry handles it
+  if (matchPattern) {
+    try {
+      const testPattern = matchPattern.startsWith("(?i)") ? matchPattern.slice(4) : matchPattern;
+      new RegExp(testPattern);
+    } catch {
+      return json({ error: "Invalid regex in matchPattern" }, { status: 400 });
+    }
+  }
+
+  // Update model + tiers atomically
+  const updated = await prisma.$transaction(async (tx) => {
+    await tx.llmModel.update({
+      where: { id: modelId },
+      data: {
+        ...(modelName !== undefined && { modelName }),
+        ...(matchPattern !== undefined && { matchPattern }),
+        ...(startDate !== undefined && { startDate: startDate ? new Date(startDate) : null }),
+        ...(provider !== undefined && { provider }),
+        ...(description !== undefined && { description }),
+        ...(contextWindow !== undefined && { contextWindow }),
+        ...(maxOutputTokens !== undefined && { maxOutputTokens }),
+        ...(capabilities !== undefined && { capabilities }),
+        ...(isHidden !== undefined && { isHidden }),
+      },
+    });
+
+    if (pricingTiers) {
+      await tx.llmPricingTier.deleteMany({ where: { modelId } });
+
+      for (const tier of pricingTiers) {
+        await tx.llmPricingTier.create({
+          data: {
+            modelId,
+            name: tier.name,
+            isDefault: tier.isDefault,
+            priority: tier.priority,
+            conditions: tier.conditions,
+            prices: {
+              create: Object.entries(tier.prices).map(([usageType, price]) => ({
+                modelId,
+                usageType,
+                price,
+              })),
+            },
+          },
+        });
+      }
+    }
+
+    return tx.llmModel.findUnique({
+      where: { id: modelId },
+      include: {
+        pricingTiers: { include: { prices: true }, orderBy: { priority: "asc" } },
+      },
+    });
+  });
+
+  return json({ model: updated });
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.llm-models.missing.ts b/apps/webapp/app/routes/admin.api.v1.llm-models.missing.ts
new file mode 100644
index 00000000000..5ca7077e1cc
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.llm-models.missing.ts
@@ -0,0 +1,33 @@
+import { type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { getMissingLlmModels } from "~/services/admin/missingLlmModels.server";
+
+async function requireAdmin(request: Request) {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    throw json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: authResult.userId } });
+  if (!user?.admin) {
+    throw json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  return user;
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  await requireAdmin(request);
+
+  const url = new URL(request.url);
+  const lookbackHours = parseInt(url.searchParams.get("lookbackHours") ?? "24", 10);
+
+  if (isNaN(lookbackHours) || lookbackHours < 1 || lookbackHours > 720) {
+    return json({ error: "lookbackHours must be between 1 and 720" }, { status: 400 });
+  }
+
+  const models = await getMissingLlmModels({ lookbackHours });
+
+  return json({ models, lookbackHours });
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.llm-models.reload.ts b/apps/webapp/app/routes/admin.api.v1.llm-models.reload.ts
new file mode 100644
index 00000000000..747722b352a
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.llm-models.reload.ts
@@ -0,0 +1,24 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+export async function action({ request }: ActionFunctionArgs) {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: authResult.userId } });
+  if (!user?.admin) {
+    return json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  if (!llmPricingRegistry) {
+    return json({ error: "LLM cost tracking is disabled" }, { status: 400 });
+  }
+
+  await llmPricingRegistry.reload();
+
+  return json({ success: true, message: "LLM pricing registry reloaded" });
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.llm-models.seed.ts b/apps/webapp/app/routes/admin.api.v1.llm-models.seed.ts
new file mode 100644
index 00000000000..32e780d9fb9
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.llm-models.seed.ts
@@ -0,0 +1,47 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { seedLlmPricing, syncLlmCatalog } from "@internal/llm-model-catalog";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+export async function action({ request }: ActionFunctionArgs) {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: authResult.userId } });
+  if (!user?.admin) {
+    return json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  const url = new URL(request.url);
+  const action = url.searchParams.get("action") ?? "seed";
+
+  if (action === "sync") {
+    const result = await syncLlmCatalog(prisma);
+
+    if (llmPricingRegistry) {
+      await llmPricingRegistry.reload();
+    }
+
+    return json({
+      success: true,
+      ...result,
+      message: `Synced ${result.modelsUpdated} models, skipped ${result.modelsSkipped}`,
+    });
+  }
+
+  // Default: seed (creates new + syncs existing)
+  const result = await seedLlmPricing(prisma);
+
+  if (llmPricingRegistry) {
+    await llmPricingRegistry.reload();
+  }
+
+  return json({
+    success: true,
+    ...result,
+    message: `Seeded ${result.modelsCreated} created, ${result.modelsSkipped} skipped, ${result.modelsUpdated} updated`,
+  });
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.llm-models.ts b/apps/webapp/app/routes/admin.api.v1.llm-models.ts
new file mode 100644
index 00000000000..4e3cc39f47a
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.llm-models.ts
@@ -0,0 +1,153 @@
+import { type ActionFunctionArgs, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
+
+async function requireAdmin(request: Request) {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    throw json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({ where: { id: authResult.userId } });
+  if (!user?.admin) {
+    throw json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  return user;
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  await requireAdmin(request);
+
+  const url = new URL(request.url);
+  const page = parseInt(url.searchParams.get("page") ?? "1");
+  const pageSize = parseInt(url.searchParams.get("pageSize") ?? "50");
+
+  const [models, total] = await Promise.all([
+    prisma.llmModel.findMany({
+      where: { projectId: null },
+      include: {
+        pricingTiers: {
+          include: { prices: true },
+          orderBy: { priority: "asc" },
+        },
+      },
+      orderBy: { modelName: "asc" },
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+    }),
+    prisma.llmModel.count({ where: { projectId: null } }),
+  ]);
+
+  return json({ models, total, page, pageSize });
+}
+
+const CreateModelSchema = z.object({
+  modelName: z.string().min(1),
+  matchPattern: z.string().min(1),
+  startDate: z.string().optional(),
+  source: z.enum(["default", "admin"]).optional().default("admin"),
+  provider: z.string().optional(),
+  description: z.string().optional(),
+  contextWindow: z.number().int().optional(),
+  maxOutputTokens: z.number().int().optional(),
+  capabilities: z.array(z.string()).optional(),
+  isHidden: z.boolean().optional(),
+  pricingTiers: z.array(
+    z.object({
+      name: z.string().min(1),
+      isDefault: z.boolean().default(true),
+      priority: z.number().int().default(0),
+      conditions: z
+        .array(
+          z.object({
+            usageDetailPattern: z.string(),
+            operator: z.enum(["gt", "gte", "lt", "lte", "eq", "neq"]),
+            value: z.number(),
+          })
+        )
+        .default([]),
+      prices: z.record(z.string(), z.number()),
+    })
+  ),
+});
+
+export async function action({ request }: ActionFunctionArgs) {
+  await requireAdmin(request);
+
+  if (request.method !== "POST") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const parsed = CreateModelSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return json({ error: "Invalid request body", details: parsed.error.issues }, { status: 400 });
+  }
+
+  const { modelName, matchPattern, startDate, source, pricingTiers, provider, description, contextWindow, maxOutputTokens, capabilities, isHidden } = parsed.data;
+
+  // Validate regex pattern — strip (?i) POSIX flag since our registry handles it
+  try {
+    const testPattern = matchPattern.startsWith("(?i)") ? matchPattern.slice(4) : matchPattern;
+    new RegExp(testPattern);
+  } catch {
+    return json({ error: "Invalid regex in matchPattern" }, { status: 400 });
+  }
+
+  // Create model + tiers atomically
+  const created = await prisma.$transaction(async (tx) => {
+    const model = await tx.llmModel.create({
+      data: {
+        friendlyId: generateFriendlyId("llm_model"),
+        modelName,
+        matchPattern,
+        startDate: startDate ? new Date(startDate) : null,
+        source,
+        provider: provider ?? null,
+        description: description ?? null,
+        contextWindow: contextWindow ?? null,
+        maxOutputTokens: maxOutputTokens ?? null,
+        capabilities: capabilities ?? [],
+        isHidden: isHidden ?? false,
+      },
+    });
+
+    for (const tier of pricingTiers) {
+      await tx.llmPricingTier.create({
+        data: {
+          modelId: model.id,
+          name: tier.name,
+          isDefault: tier.isDefault,
+          priority: tier.priority,
+          conditions: tier.conditions,
+          prices: {
+            create: Object.entries(tier.prices).map(([usageType, price]) => ({
+              modelId: model.id,
+              usageType,
+              price,
+            })),
+          },
+        },
+      });
+    }
+
+    return tx.llmModel.findUnique({
+      where: { id: model.id },
+      include: {
+        pricingTiers: { include: { prices: true } },
+      },
+    });
+  });
+
+  return json({ model: created }, { status: 201 });
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.orgs.$organizationId.feature-flags.ts b/apps/webapp/app/routes/admin.api.v1.orgs.$organizationId.feature-flags.ts
new file mode 100644
index 00000000000..bb0671355bd
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.orgs.$organizationId.feature-flags.ts
@@ -0,0 +1,153 @@
+import { ActionFunctionArgs, LoaderFunctionArgs, json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { validatePartialFeatureFlags } from "~/v3/featureFlags";
+
+const ParamsSchema = z.object({
+  organizationId: z.string(),
+});
+
+async function authenticateAdmin(request: Request) {
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return { error: json({ error: "Invalid or Missing API key" }, { status: 401 }) };
+  }
+
+  const user = await prisma.user.findFirst({
+    where: {
+      id: authenticationResult.userId,
+    },
+  });
+
+  if (!user) {
+    return { error: json({ error: "Invalid or Missing API key" }, { status: 401 }) };
+  }
+
+  if (!user.admin) {
+    return { error: json({ error: "You must be an admin to perform this action" }, { status: 403 }) };
+  }
+
+  return { user };
+}
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const authResult = await authenticateAdmin(request);
+
+  if ("error" in authResult) {
+    return authResult.error;
+  }
+
+  const { organizationId } = ParamsSchema.parse(params);
+
+  const organization = await prisma.organization.findFirst({
+    where: {
+      id: organizationId,
+    },
+    select: {
+      id: true,
+      slug: true,
+      featureFlags: true,
+    },
+  });
+
+  if (!organization) {
+    return json({ error: "Organization not found" }, { status: 404 });
+  }
+
+  const flagsResult = organization.featureFlags
+    ? validatePartialFeatureFlags(organization.featureFlags as Record<string, unknown>)
+    : { success: false as const };
+
+  const featureFlags = flagsResult.success ? flagsResult.data : {};
+
+  return json({
+    organizationId: organization.id,
+    organizationSlug: organization.slug,
+    featureFlags,
+  });
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const authResult = await authenticateAdmin(request);
+
+  if ("error" in authResult) {
+    return authResult.error;
+  }
+
+  const { organizationId } = ParamsSchema.parse(params);
+
+  const organization = await prisma.organization.findFirst({
+    where: {
+      id: organizationId,
+    },
+    select: {
+      id: true,
+      featureFlags: true,
+    },
+  });
+
+  if (!organization) {
+    return json({ error: "Organization not found" }, { status: 404 });
+  }
+
+  try {
+    const body = await request.json();
+
+    // Validate the input using the partial schema
+    const validationResult = validatePartialFeatureFlags(body as Record<string, unknown>);
+    if (!validationResult.success) {
+      return json(
+        {
+          error: "Invalid feature flags data",
+          details: validationResult.error.issues,
+        },
+        { status: 400 }
+      );
+    }
+
+    // Merge new flags with existing flags
+    const existingFlags = organization.featureFlags
+      ? validatePartialFeatureFlags(organization.featureFlags as Record<string, unknown>)
+      : { success: false as const };
+
+    const mergedFlags = {
+      ...(existingFlags.success ? existingFlags.data : {}),
+      ...validationResult.data,
+    };
+
+    // Update the organization's feature flags
+    const updatedOrganization = await prisma.organization.update({
+      where: {
+        id: organizationId,
+      },
+      data: {
+        featureFlags: mergedFlags,
+      },
+      select: {
+        id: true,
+        slug: true,
+        featureFlags: true,
+      },
+    });
+
+    const updatedFlagsResult = updatedOrganization.featureFlags
+      ? validatePartialFeatureFlags(updatedOrganization.featureFlags as Record<string, unknown>)
+      : { success: false as const };
+
+    return json({
+      success: true,
+      organizationId: updatedOrganization.id,
+      organizationSlug: updatedOrganization.slug,
+      featureFlags: updatedFlagsResult.success ? updatedFlagsResult.data : {},
+    });
+  } catch (error) {
+    return json(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      { status: 400 }
+    );
+  }
+}
diff --git a/apps/webapp/app/routes/admin.api.v1.platform-notifications.ts b/apps/webapp/app/routes/admin.api.v1.platform-notifications.ts
new file mode 100644
index 00000000000..093104bcb05
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v1.platform-notifications.ts
@@ -0,0 +1,64 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { err, ok, type Result } from "neverthrow";
+import { prisma } from "~/db.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import {
+  createPlatformNotification,
+  type CreatePlatformNotificationInput,
+} from "~/services/platformNotifications.server";
+
+type AdminUser = { id: string; admin: boolean };
+type AuthError = { status: number; message: string };
+
+async function authenticateAdmin(request: Request): Promise<Result<AdminUser, AuthError>> {
+  const authResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authResult) {
+    return err({ status: 401, message: "Invalid or Missing API key" });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { id: authResult.userId },
+    select: { id: true, admin: true },
+  });
+
+  if (!user?.admin) {
+    return err({
+      status: user ? 403 : 401,
+      message: user ? "You must be an admin to perform this action" : "Invalid or Missing API key",
+    });
+  }
+
+  return ok(user);
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  if (request.method !== "POST") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  const authResult = await authenticateAdmin(request);
+  if (authResult.isErr()) {
+    const { status, message } = authResult.error;
+    return json({ error: message }, { status });
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  const result = await createPlatformNotification(body as CreatePlatformNotificationInput);
+
+  if (result.isErr()) {
+    const error = result.error;
+
+    if (error.type === "validation") {
+      return json({ error: "Validation failed", details: error.issues }, { status: 400 });
+    }
+
+    return json({ error: error.message }, { status: 500 });
+  }
+
+  return json(result.value, { status: 201 });
+}
diff --git a/apps/webapp/app/routes/admin.api.v2.orgs.$organizationId.feature-flags.ts b/apps/webapp/app/routes/admin.api.v2.orgs.$organizationId.feature-flags.ts
new file mode 100644
index 00000000000..6081febb526
--- /dev/null
+++ b/apps/webapp/app/routes/admin.api.v2.orgs.$organizationId.feature-flags.ts
@@ -0,0 +1,132 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { Prisma } from "@trigger.dev/database";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { requireUser } from "~/services/session.server";
+import { flags as getGlobalFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG, validatePartialFeatureFlags, getAllFlagControlTypes } from "~/v3/featureFlags";
+import { featuresForRequest } from "~/features.server";
+
+// Session-auth route for the admin feature flags dialog.
+// Uses replace semantics: the action writes the full flag set (or null to clear).
+// Compare with v1 (admin.api.v1.orgs.$organizationId.feature-flags.ts) which
+// uses PAT auth and merge semantics for programmatic use.
+
+const ParamsSchema = z.object({
+  organizationId: z.string(),
+});
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const user = await requireUser(request);
+  if (!user.admin) {
+    throw new Response("Unauthorized", { status: 403 });
+  }
+
+  const { organizationId } = ParamsSchema.parse(params);
+
+  const [organization, globalFlags, workerGroups] = await Promise.all([
+    prisma.organization.findFirst({
+      where: { id: organizationId },
+      select: {
+        id: true,
+        title: true,
+        slug: true,
+        featureFlags: true,
+      },
+    }),
+    getGlobalFlags(),
+    prisma.workerInstanceGroup.findMany({
+      select: { id: true, name: true },
+      orderBy: { name: "asc" },
+    }),
+  ]);
+
+  if (!organization) {
+    throw new Response("Organization not found", { status: 404 });
+  }
+
+  const orgFlagsResult = organization.featureFlags
+    ? validatePartialFeatureFlags(organization.featureFlags as Record<string, unknown>)
+    : ({ success: false } as const);
+
+  const orgFlags = orgFlagsResult.success ? orgFlagsResult.data : {};
+  const controlTypes = getAllFlagControlTypes();
+
+  // Resolve worker group name for display
+  const workerGroupId = (globalFlags as Record<string, unknown>)?.[
+    FEATURE_FLAG.defaultWorkerInstanceGroupId
+  ];
+  let workerGroupName: string | undefined;
+  if (typeof workerGroupId === "string") {
+    const wg = await prisma.workerInstanceGroup.findFirst({
+      where: { id: workerGroupId },
+      select: { name: true },
+    });
+    workerGroupName = wg?.name;
+  }
+
+  const { isManagedCloud } = featuresForRequest(request);
+
+  return json({
+    org: {
+      id: organization.id,
+      title: organization.title,
+      slug: organization.slug,
+    },
+    orgFlags,
+    globalFlags,
+    controlTypes,
+    workerGroupName,
+    workerGroups,
+    isManagedCloud,
+  });
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const user = await requireUser(request);
+  if (!user.admin) {
+    throw new Response("Unauthorized", { status: 403 });
+  }
+
+  const { organizationId } = ParamsSchema.parse(params);
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  let featureFlags: typeof Prisma.JsonNull | Record<string, unknown>;
+
+  if (
+    body === null ||
+    (typeof body === "object" && !Array.isArray(body) && Object.keys(body).length === 0)
+  ) {
+    featureFlags = Prisma.JsonNull;
+  } else {
+    const validationResult = validatePartialFeatureFlags(body as Record<string, unknown>);
+    if (!validationResult.success) {
+      return json(
+        { error: "Invalid feature flags", details: validationResult.error.issues },
+        { status: 400 }
+      );
+    }
+    featureFlags = validationResult.data;
+  }
+
+  try {
+    await prisma.organization.update({
+      where: { id: organizationId },
+      data: { featureFlags: featureFlags as Prisma.InputJsonValue },
+    });
+  } catch (e) {
+    if (e instanceof Prisma.PrismaClientKnownRequestError && e.code === "P2025") {
+      throw new Response("Organization not found", { status: 404 });
+    }
+    throw e;
+  }
+
+  return json({ success: true });
+}
diff --git a/apps/webapp/app/routes/admin.feature-flags.tsx b/apps/webapp/app/routes/admin.feature-flags.tsx
new file mode 100644
index 00000000000..8e91bdb0731
--- /dev/null
+++ b/apps/webapp/app/routes/admin.feature-flags.tsx
@@ -0,0 +1,564 @@
+import { useFetcher } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { useEffect, useState } from "react";
+import stableStringify from "json-stable-stringify";
+import { json } from "@remix-run/server-runtime";
+import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { LockClosedIcon } from "@heroicons/react/20/solid";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { requireUser } from "~/services/session.server";
+import {
+  FEATURE_FLAG,
+  GLOBAL_LOCKED_FLAGS,
+  type FlagControlType,
+  getAllFlagControlTypes,
+  validatePartialFeatureFlags,
+} from "~/v3/featureFlags";
+import { flags as getGlobalFlags } from "~/v3/featureFlags.server";
+import { featuresForRequest } from "~/features.server";
+import { Button } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { CheckboxWithLabel } from "~/components/primitives/Checkbox";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogDescription,
+  DialogFooter,
+} from "~/components/primitives/Dialog";
+import { cn } from "~/utils/cn";
+import {
+  UNSET_VALUE,
+  BooleanControl,
+  EnumControl,
+  StringControl,
+  WorkerGroupControl,
+  type WorkerGroup,
+} from "~/components/admin/FlagControls";
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  if (!user.admin) {
+    return redirect("/");
+  }
+
+  const [globalFlags, workerGroups] = await Promise.all([
+    getGlobalFlags(),
+    prisma.workerInstanceGroup.findMany({
+      select: { id: true, name: true },
+      orderBy: { name: "asc" },
+    }),
+  ]);
+  const controlTypes = getAllFlagControlTypes();
+
+  // Resolve env-based defaults for locked flags
+  const resolvedDefaults: Record<string, string> = {
+    [FEATURE_FLAG.taskEventRepository]: env.EVENT_REPOSITORY_DEFAULT_STORE,
+  };
+
+  // Look up worker group name if the flag is set
+  const workerGroupId = (globalFlags as Record<string, unknown>)?.[
+    FEATURE_FLAG.defaultWorkerInstanceGroupId
+  ];
+  const workerGroupName =
+    typeof workerGroupId === "string"
+      ? workerGroups.find((wg) => wg.id === workerGroupId)?.name
+      : undefined;
+
+  const { isManagedCloud } = featuresForRequest(request);
+
+  return typedjson({
+    globalFlags,
+    controlTypes,
+    resolvedDefaults,
+    workerGroupName,
+    workerGroups,
+    isManagedCloud,
+  });
+};
+
+export const action = async ({ request }: ActionFunctionArgs) => {
+  const user = await requireUser(request);
+  if (!user.admin) {
+    throw new Response("Unauthorized", { status: 403 });
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const payloadSchema = z.object({ flags: z.record(z.unknown()) });
+  const parsed = payloadSchema.safeParse(body);
+  if (!parsed.success) {
+    return json({ error: "Invalid payload" }, { status: 400 });
+  }
+
+  const { isManagedCloud } = featuresForRequest(request);
+
+  // On managed cloud, reject if payload includes locked flags
+  if (isManagedCloud) {
+    const lockedInPayload = Object.keys(parsed.data.flags).filter((key) =>
+      GLOBAL_LOCKED_FLAGS.includes(key)
+    );
+    if (lockedInPayload.length > 0) {
+      return json(
+        { error: `Cannot modify locked flags: ${lockedInPayload.join(", ")}` },
+        { status: 400 }
+      );
+    }
+  }
+
+  const validationResult = validatePartialFeatureFlags(parsed.data.flags);
+  if (!validationResult.success) {
+    return json(
+      { error: "Invalid feature flags", details: validationResult.error.issues },
+      { status: 400 }
+    );
+  }
+
+  const validatedFlags = validationResult.data as Record<string, unknown>;
+  const controlTypes = getAllFlagControlTypes();
+  const catalogKeys = Object.keys(controlTypes);
+
+  const keysToDelete: string[] = [];
+  const upsertOps: ReturnType<typeof prisma.featureFlag.upsert>[] = [];
+
+  for (const key of catalogKeys) {
+    if (key in validatedFlags) {
+      upsertOps.push(
+        prisma.featureFlag.upsert({
+          where: { key },
+          create: { key, value: validatedFlags[key] as any },
+          update: { value: validatedFlags[key] as any },
+        })
+      );
+    } else {
+      // On cloud, never delete locked flags (they're not in the payload
+      // because the UI doesn't include them). Locally, delete everything
+      // the user didn't include - full control.
+      const isProtected = isManagedCloud && GLOBAL_LOCKED_FLAGS.includes(key);
+      if (!isProtected) {
+        keysToDelete.push(key);
+      }
+    }
+  }
+
+  await prisma.$transaction([
+    ...upsertOps,
+    ...(keysToDelete.length > 0
+      ? [prisma.featureFlag.deleteMany({ where: { key: { in: keysToDelete } } })]
+      : []),
+  ]);
+
+  return json({ success: true });
+};
+
+export default function AdminFeatureFlagsRoute() {
+  const {
+    globalFlags,
+    controlTypes,
+    resolvedDefaults,
+    workerGroupName,
+    workerGroups,
+    isManagedCloud,
+  } = useTypedLoaderData<typeof loader>();
+  const saveFetcher = useFetcher<{ success?: boolean; error?: string }>();
+
+  const [values, setValues] = useState<Record<string, unknown>>({});
+  const [initialValues, setInitialValues] = useState<Record<string, unknown>>({});
+  const [saveError, setSaveError] = useState<string | null>(null);
+  const [confirmOpen, setConfirmOpen] = useState(false);
+  const [unlocked, setUnlocked] = useState(false);
+
+  const isLocked = (key: string) => !unlocked && GLOBAL_LOCKED_FLAGS.includes(key);
+
+  useEffect(() => {
+    const loaded = (globalFlags ?? {}) as Record<string, unknown>;
+    // Only track editable flags in state
+    const editable: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(loaded)) {
+      if (!isLocked(key)) {
+        editable[key] = value;
+      }
+    }
+    setValues({ ...editable });
+    setInitialValues({ ...editable });
+  }, [globalFlags, unlocked]);
+
+  useEffect(() => {
+    if (saveFetcher.data?.success) {
+      setSaveError(null);
+      setConfirmOpen(false);
+    } else if (saveFetcher.data?.error) {
+      setSaveError(saveFetcher.data.error);
+    }
+  }, [saveFetcher.data]);
+
+  const isDirty = stableStringify(values) !== stableStringify(initialValues);
+  const isSaving = saveFetcher.state === "submitting";
+
+  const setFlagValue = (key: string, value: unknown) => {
+    setValues((prev) => ({ ...prev, [key]: value }));
+  };
+
+  const unsetFlag = (key: string) => {
+    setValues((prev) => {
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  };
+
+  const handleSave = () => {
+    saveFetcher.submit(JSON.stringify({ flags: values }), {
+      method: "POST",
+      encType: "application/json",
+    });
+  };
+
+  const typedControlTypes = controlTypes as Record<string, FlagControlType>;
+  const typedResolvedDefaults = resolvedDefaults as Record<string, string>;
+  const allFlags = (globalFlags ?? {}) as Record<string, unknown>;
+  const sortedFlagKeys = Object.keys(typedControlTypes).sort();
+  const workerGroupMap = new Map((workerGroups as WorkerGroup[]).map((wg) => [wg.id, wg.name]));
+
+  const resolveWorkerGroupDisplay = (id: string) => {
+    const name = workerGroupMap.get(id);
+    return name ? `${name} (${id.slice(0, 8)}...)` : id;
+  };
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4 lg:order-last">
+      <div className="max-w-2xl space-y-4">
+        <p className="text-sm text-text-dimmed">
+          Global defaults for all organizations. Org-level overrides take precedence. When not set,
+          each consumer uses its own default.
+        </p>
+
+        <div className={isManagedCloud ? "cursor-not-allowed" : undefined}>
+          <CheckboxWithLabel
+            variant="simple/small"
+            label={
+              isManagedCloud
+                ? "Unlock read-only flags (only in unmanaged cloud)"
+                : "Unlock read-only flags"
+            }
+            defaultChecked={unlocked}
+            onChange={setUnlocked}
+            disabled={isManagedCloud}
+            className={isManagedCloud ? "pointer-events-none" : undefined}
+          />
+        </div>
+
+        <div className="flex flex-col gap-1.5">
+          {sortedFlagKeys.map((key) => {
+            const control = typedControlTypes[key];
+            const locked = isLocked(key);
+
+            if (locked) {
+              return (
+                <LockedFlagRow
+                  key={key}
+                  flagKey={key}
+                  value={allFlags[key]}
+                  resolvedDefault={typedResolvedDefaults[key]}
+                  workerGroupName={workerGroupName as string | undefined}
+                />
+              );
+            }
+
+            const isSet = key in values;
+            const isWorkerGroup = key === FEATURE_FLAG.defaultWorkerInstanceGroupId;
+
+            return (
+              <div
+                key={key}
+                className={cn(
+                  "flex items-center justify-between rounded-md border px-3 py-2.5",
+                  isSet
+                    ? "border-indigo-500/20 bg-indigo-500/5"
+                    : "border-transparent bg-charcoal-750"
+                )}
+              >
+                <div className="min-w-0 flex-1">
+                  <div
+                    className={cn(
+                      "truncate text-sm",
+                      isSet ? "text-text-bright" : "text-text-dimmed"
+                    )}
+                  >
+                    {isWorkerGroup ? "defaultWorkerInstanceGroup" : key}
+                  </div>
+                  <div className="text-xs text-charcoal-400">
+                    {isSet
+                      ? isWorkerGroup
+                        ? resolveWorkerGroupDisplay(values[key] as string)
+                        : `value: ${String(values[key])}`
+                      : typedResolvedDefaults[key]
+                        ? `${typedResolvedDefaults[key]} (from env)`
+                        : "not set"}
+                  </div>
+                </div>
+
+                <div className="flex items-center gap-2">
+                  <Button
+                    variant="minimal/small"
+                    onClick={() => unsetFlag(key)}
+                    className={cn(!isSet && "invisible")}
+                  >
+                    unset
+                  </Button>
+
+                  {isWorkerGroup ? (
+                    <WorkerGroupControl
+                      value={isSet ? (values[key] as string) : undefined}
+                      workerGroups={workerGroups as WorkerGroup[]}
+                      onChange={(val) => {
+                        if (val === UNSET_VALUE) {
+                          unsetFlag(key);
+                        } else {
+                          setFlagValue(key, val);
+                        }
+                      }}
+                      dimmed={!isSet}
+                    />
+                  ) : (
+                    <>
+                      {control.type === "boolean" && (
+                        <BooleanControl
+                          value={isSet ? (values[key] as boolean) : undefined}
+                          onChange={(val) => setFlagValue(key, val)}
+                          dimmed={!isSet}
+                        />
+                      )}
+
+                      {control.type === "enum" && (
+                        <EnumControl
+                          value={isSet ? (values[key] as string) : undefined}
+                          options={control.options}
+                          onChange={(val) => {
+                            if (val === UNSET_VALUE) {
+                              unsetFlag(key);
+                            } else {
+                              setFlagValue(key, val);
+                            }
+                          }}
+                          dimmed={!isSet}
+                        />
+                      )}
+
+                      {control.type === "string" && (
+                        <StringControl
+                          value={isSet ? (values[key] as string) : ""}
+                          onChange={(val) => {
+                            if (val === "") {
+                              unsetFlag(key);
+                            } else {
+                              setFlagValue(key, val);
+                            }
+                          }}
+                          dimmed={!isSet}
+                        />
+                      )}
+                    </>
+                  )}
+                </div>
+              </div>
+            );
+          })}
+        </div>
+
+        {saveError && <Callout variant="error">{saveError}</Callout>}
+
+        <div className="flex justify-end gap-2">
+          {isDirty && (
+            <Button variant="tertiary/small" onClick={() => setValues({ ...initialValues })}>
+              Discard
+            </Button>
+          )}
+          <Button
+            variant="primary/small"
+            onClick={() => setConfirmOpen(true)}
+            disabled={!isDirty || isSaving}
+          >
+            Review changes
+          </Button>
+        </div>
+      </div>
+
+      <ConfirmDialog
+        open={confirmOpen}
+        onOpenChange={setConfirmOpen}
+        initialValues={initialValues}
+        newValues={values}
+        controlTypes={typedControlTypes}
+        lockedKeys={unlocked ? [] : GLOBAL_LOCKED_FLAGS}
+        onConfirm={handleSave}
+        isSaving={isSaving}
+      />
+    </main>
+  );
+}
+
+// --- Locked Flag Row ---
+
+function LockedFlagRow({
+  flagKey,
+  value,
+  resolvedDefault,
+  workerGroupName,
+}: {
+  flagKey: string;
+  value: unknown;
+  resolvedDefault: string | undefined;
+  workerGroupName: string | undefined;
+}) {
+  const isSet = value !== undefined;
+  const isWorkerGroup = flagKey === FEATURE_FLAG.defaultWorkerInstanceGroupId;
+
+  let displayValue: string;
+  if (isSet) {
+    if (isWorkerGroup && workerGroupName) {
+      displayValue = `${workerGroupName} (${String(value).slice(0, 8)}...)`;
+    } else {
+      displayValue = String(value);
+    }
+  } else if (resolvedDefault) {
+    displayValue = `${resolvedDefault} (from env)`;
+  } else {
+    displayValue = "not set (required)";
+  }
+
+  return (
+    <div
+      className={cn(
+        "flex items-center justify-between rounded-md border px-3 py-2.5",
+        isSet ? "border-indigo-500/20 bg-indigo-500/5" : "border-transparent bg-charcoal-750"
+      )}
+      title="Managed via database - not editable from this UI"
+    >
+      <div className="min-w-0 flex-1">
+        <div
+          className={cn("truncate text-sm", isSet ? "text-text-bright" : "text-text-dimmed")}
+        >
+          {isWorkerGroup ? "defaultWorkerInstanceGroup" : flagKey}
+        </div>
+        <div className="text-xs text-charcoal-400">{displayValue}</div>
+      </div>
+
+      <LockClosedIcon className="size-4 text-charcoal-500" />
+    </div>
+  );
+}
+
+// --- Confirmation Dialog with Diff ---
+
+function ConfirmDialog({
+  open,
+  onOpenChange,
+  initialValues,
+  newValues,
+  controlTypes,
+  lockedKeys,
+  onConfirm,
+  isSaving,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  initialValues: Record<string, unknown>;
+  newValues: Record<string, unknown>;
+  controlTypes: Record<string, FlagControlType>;
+  lockedKeys: readonly string[];
+  onConfirm: () => void;
+  isSaving: boolean;
+}) {
+  const editableKeys = Object.keys(controlTypes)
+    .filter((key) => !lockedKeys.includes(key))
+    .sort();
+
+  type Change =
+    | { key: string; type: "added"; newVal: string }
+    | { key: string; type: "removed"; oldVal: string }
+    | { key: string; type: "changed"; oldVal: string; newVal: string };
+
+  const changes = editableKeys.flatMap<Change>((key) => {
+    const wasSet = key in initialValues;
+    const isSet = key in newValues;
+    const oldVal = initialValues[key];
+    const newVal = newValues[key];
+
+    if (!wasSet && !isSet) return [];
+    if (wasSet && isSet && stableStringify(oldVal) === stableStringify(newVal)) return [];
+
+    if (!wasSet && isSet) {
+      return [{ key, type: "added" as const, newVal: String(newVal) }];
+    }
+    if (wasSet && !isSet) {
+      return [{ key, type: "removed" as const, oldVal: String(oldVal) }];
+    }
+    return [
+      {
+        key,
+        type: "changed" as const,
+        oldVal: String(oldVal),
+        newVal: String(newVal),
+      },
+    ];
+  });
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>Confirm feature flag changes</DialogHeader>
+        <DialogDescription>
+          These changes affect all organizations globally. Please review carefully.
+        </DialogDescription>
+
+        <div className="flex flex-col gap-2 pb-2">
+          {changes.length === 0 ? (
+            <p className="text-sm text-text-dimmed">No changes to apply.</p>
+          ) : (
+            changes.map((change) => (
+              <div
+                key={change.key}
+                className="rounded-md border border-charcoal-600 bg-charcoal-800 px-3 py-2 font-mono text-xs"
+              >
+                <div className="font-sans text-sm text-text-bright">{change.key}</div>
+                {change.type === "added" && (
+                  <div className="mt-1 text-green-400">+ {change.newVal}</div>
+                )}
+                {change.type === "removed" && (
+                  <div className="mt-1 text-red-400">- {change.oldVal} (unset)</div>
+                )}
+                {change.type === "changed" && (
+                  <>
+                    <div className="mt-1 text-red-400">- {change.oldVal}</div>
+                    <div className="text-green-400">+ {change.newVal}</div>
+                  </>
+                )}
+              </div>
+            ))
+          )}
+        </div>
+
+        <DialogFooter>
+          <Button variant="tertiary/small" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button
+            variant="danger/small"
+            onClick={onConfirm}
+            disabled={isSaving || changes.length === 0}
+          >
+            {isSaving ? "Saving..." : "Apply changes"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/webapp/app/routes/admin.llm-models.$modelId.tsx b/apps/webapp/app/routes/admin.llm-models.$modelId.tsx
new file mode 100644
index 00000000000..7b51067dd0c
--- /dev/null
+++ b/apps/webapp/app/routes/admin.llm-models.$modelId.tsx
@@ -0,0 +1,560 @@
+import { Form, useActionData, useNavigate } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { useState } from "react";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Input } from "~/components/primitives/Input";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const model = await prisma.llmModel.findUnique({
+    where: { friendlyId: params.modelId },
+    include: {
+      pricingTiers: { include: { prices: true }, orderBy: { priority: "asc" } },
+    },
+  });
+
+  if (!model) throw new Response("Model not found", { status: 404 });
+
+  // Convert Prisma Decimal to plain numbers for serialization
+  const serialized = {
+    ...model,
+    pricingTiers: model.pricingTiers.map((t) => ({
+      ...t,
+      prices: t.prices.map((p) => ({ ...p, price: Number(p.price) })),
+    })),
+  };
+
+  return typedjson({ model: serialized });
+};
+
+const SaveSchema = z.object({
+  modelName: z.string().min(1),
+  matchPattern: z.string().min(1),
+  pricingTiersJson: z.string(),
+  provider: z.string().optional(),
+  description: z.string().optional(),
+  contextWindow: z.string().optional(),
+  maxOutputTokens: z.string().optional(),
+  capabilities: z.string().optional(),
+  isHidden: z.string().optional(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const friendlyId = params.modelId!;
+  const existing = await prisma.llmModel.findUnique({ where: { friendlyId } });
+  if (!existing) throw new Response("Model not found", { status: 404 });
+  const modelId = existing.id;
+
+  const formData = await request.formData();
+  const _action = formData.get("_action");
+
+  if (_action === "delete") {
+    await prisma.llmModel.delete({ where: { id: modelId } });
+    await llmPricingRegistry?.reload();
+    return redirect("/admin/llm-models");
+  }
+
+  if (_action === "save") {
+    const raw = Object.fromEntries(formData);
+    const parsed = SaveSchema.safeParse(raw);
+
+    if (!parsed.success) {
+      return typedjson({ error: "Invalid form data", details: parsed.error.issues }, { status: 400 });
+    }
+
+    const { modelName, matchPattern, pricingTiersJson } = parsed.data;
+
+    // Validate regex — strip (?i) POSIX flag since our registry handles it
+    try {
+      const testPattern = matchPattern.startsWith("(?i)") ? matchPattern.slice(4) : matchPattern;
+      new RegExp(testPattern);
+    } catch {
+      return typedjson({ error: "Invalid regex in matchPattern" }, { status: 400 });
+    }
+
+    // Parse tiers
+    let pricingTiers: Array<{
+      name: string;
+      isDefault: boolean;
+      priority: number;
+      conditions: Array<{ usageDetailPattern: string; operator: string; value: number }>;
+      prices: Record<string, number>;
+    }>;
+    try {
+      pricingTiers = JSON.parse(pricingTiersJson) as typeof pricingTiers;
+    } catch {
+      return typedjson({ error: "Invalid pricing tiers JSON" }, { status: 400 });
+    }
+
+    // Update model
+    const { provider, description, contextWindow, maxOutputTokens, capabilities, isHidden } = parsed.data;
+    await prisma.llmModel.update({
+      where: { id: modelId },
+      data: {
+        modelName,
+        matchPattern,
+        provider: provider || null,
+        description: description || null,
+        contextWindow: contextWindow ? parseInt(contextWindow) || null : null,
+        maxOutputTokens: maxOutputTokens ? parseInt(maxOutputTokens) || null : null,
+        capabilities: capabilities ? capabilities.split(",").map((s) => s.trim()).filter(Boolean) : [],
+        isHidden: isHidden === "on",
+      },
+    });
+
+    // Replace tiers
+    await prisma.llmPricingTier.deleteMany({ where: { modelId } });
+    for (const tier of pricingTiers) {
+      await prisma.llmPricingTier.create({
+        data: {
+          modelId,
+          name: tier.name,
+          isDefault: tier.isDefault,
+          priority: tier.priority,
+          conditions: tier.conditions,
+          prices: {
+            create: Object.entries(tier.prices).map(([usageType, price]) => ({
+              modelId,
+              usageType,
+              price,
+            })),
+          },
+        },
+      });
+    }
+
+    await llmPricingRegistry?.reload();
+    return typedjson({ success: true });
+  }
+
+  return typedjson({ error: "Unknown action" }, { status: 400 });
+}
+
+export default function AdminLlmModelDetailRoute() {
+  const { model } = useTypedLoaderData<typeof loader>();
+  const actionData = useActionData<{ success?: boolean; error?: string; details?: unknown[] }>();
+  const navigate = useNavigate();
+
+  const [modelName, setModelName] = useState(model.modelName);
+  const [matchPattern, setMatchPattern] = useState(model.matchPattern);
+  const [provider, setProvider] = useState(model.provider ?? "");
+  const [description, setDescription] = useState(model.description ?? "");
+  const [contextWindow, setContextWindow] = useState(model.contextWindow?.toString() ?? "");
+  const [maxOutputTokens, setMaxOutputTokens] = useState(model.maxOutputTokens?.toString() ?? "");
+  const [capabilities, setCapabilities] = useState(model.capabilities?.join(", ") ?? "");
+  const [isHidden, setIsHidden] = useState(model.isHidden ?? false);
+  const [testInput, setTestInput] = useState("");
+  const [tiers, setTiers] = useState(() =>
+    model.pricingTiers.map((t) => ({
+      name: t.name,
+      isDefault: t.isDefault,
+      priority: t.priority,
+      conditions: (t.conditions ?? []) as Array<{
+        usageDetailPattern: string;
+        operator: string;
+        value: number;
+      }>,
+      prices: Object.fromEntries(t.prices.map((p) => [p.usageType, p.price])),
+    }))
+  );
+
+  // Test regex match
+  let testResult: boolean | null = null;
+  if (testInput) {
+    try {
+      const pattern = matchPattern.startsWith("(?i)")
+        ? matchPattern.slice(4)
+        : matchPattern;
+      testResult = new RegExp(pattern, "i").test(testInput);
+    } catch {
+      testResult = null;
+    }
+  }
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="max-w-3xl space-y-6">
+        <div className="flex items-center justify-between">
+          <h2 className="text-lg font-medium text-text-bright">{model.modelName}</h2>
+          <div className="flex items-center gap-2">
+            <span
+              className={`inline-flex rounded-sm px-1.5 py-0.5 text-[11px] font-medium ${
+                model.source === "admin"
+                  ? "bg-amber-500/20 text-amber-400"
+                  : "bg-charcoal-700 text-text-dimmed"
+              }`}
+            >
+              {model.source ?? "default"}
+            </span>
+            <LinkButton to="/admin/llm-models" variant="tertiary/small">
+              Back to list
+            </LinkButton>
+          </div>
+        </div>
+
+        <Form method="post">
+          <input type="hidden" name="_action" value="save" />
+          <input type="hidden" name="pricingTiersJson" value={JSON.stringify(tiers)} />
+
+          <div className="space-y-4">
+            {/* Model fields */}
+            <div className="space-y-2">
+              <label className="text-xs font-medium text-text-dimmed">Model Name</label>
+              <Input
+                name="modelName"
+                value={modelName}
+                onChange={(e) => setModelName(e.target.value)}
+                variant="medium"
+                fullWidth
+              />
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-xs font-medium text-text-dimmed">Match Pattern (regex)</label>
+              <Input
+                name="matchPattern"
+                value={matchPattern}
+                onChange={(e) => setMatchPattern(e.target.value)}
+                variant="medium"
+                fullWidth
+                className="font-mono text-xs"
+              />
+            </div>
+
+            {/* Test pattern */}
+            <div className="space-y-2">
+              <label className="text-xs font-medium text-text-dimmed">Test pattern match</label>
+              <div className="flex items-center gap-2">
+                <Input
+                  value={testInput}
+                  onChange={(e) => setTestInput(e.target.value)}
+                  placeholder="Type a model name to test..."
+                  variant="medium"
+                  fullWidth
+                />
+                {testInput && (
+                  <span
+                    className={`text-xs font-medium ${
+                      testResult ? "text-green-400" : "text-red-400"
+                    }`}
+                  >
+                    {testResult ? "Match" : "No match"}
+                  </span>
+                )}
+              </div>
+            </div>
+
+            {/* Catalog metadata */}
+            <div className="space-y-2 border-t border-grid-dimmed pt-4">
+              <label className="text-sm font-medium text-text-bright">Catalog Metadata</label>
+
+              <div className="grid grid-cols-2 gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Provider</label>
+                  <Input
+                    name="provider"
+                    value={provider}
+                    onChange={(e) => setProvider(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="openai, anthropic, google"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Context Window</label>
+                  <Input
+                    name="contextWindow"
+                    value={contextWindow}
+                    onChange={(e) => setContextWindow(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="128000"
+                  />
+                </div>
+              </div>
+
+              <div className="space-y-1">
+                <label className="text-xs font-medium text-text-dimmed">Description</label>
+                <Input
+                  name="description"
+                  value={description}
+                  onChange={(e) => setDescription(e.target.value)}
+                  variant="medium"
+                  fullWidth
+                  placeholder="Brief model description"
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Max Output Tokens</label>
+                  <Input
+                    name="maxOutputTokens"
+                    value={maxOutputTokens}
+                    onChange={(e) => setMaxOutputTokens(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="16384"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Features (comma-separated)</label>
+                  <Input
+                    name="capabilities"
+                    value={capabilities}
+                    onChange={(e) => setCapabilities(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="vision, tool_use, streaming, json_mode"
+                  />
+                </div>
+              </div>
+
+              <label className="flex items-center gap-2 text-xs text-text-dimmed">
+                <input
+                  type="checkbox"
+                  name="isHidden"
+                  checked={isHidden}
+                  onChange={(e) => setIsHidden(e.target.checked)}
+                />
+                Hidden (exclude from model registry)
+              </label>
+            </div>
+
+            {/* Pricing tiers */}
+            <div className="space-y-3">
+              <div className="flex items-center justify-between">
+                <label className="text-sm font-medium text-text-bright">Pricing Tiers</label>
+                <Button
+                  type="button"
+                  variant="tertiary/small"
+                  onClick={() =>
+                    setTiers([
+                      ...tiers,
+                      {
+                        name: `Tier ${tiers.length + 1}`,
+                        isDefault: tiers.length === 0,
+                        priority: tiers.length,
+                        conditions: [],
+                        prices: {},
+                      },
+                    ])
+                  }
+                >
+                  Add tier
+                </Button>
+              </div>
+
+              {tiers.map((tier, tierIdx) => (
+                <TierEditor
+                  key={tierIdx}
+                  tier={tier}
+                  onChange={(updated) => {
+                    const next = [...tiers];
+                    next[tierIdx] = updated;
+                    setTiers(next);
+                  }}
+                  onRemove={() => setTiers(tiers.filter((_, i) => i !== tierIdx))}
+                />
+              ))}
+            </div>
+
+            {actionData?.error && (
+              <div className="rounded-md bg-red-500/10 border border-red-500/30 p-3 text-sm text-red-400">
+                {actionData.error}
+                {actionData.details && (
+                  <pre className="mt-1 text-xs text-red-300/70 overflow-auto">
+                    {JSON.stringify(actionData.details, null, 2)}
+                  </pre>
+                )}
+              </div>
+            )}
+
+            {/* Actions */}
+            <div className="flex items-center gap-2 border-t border-grid-dimmed pt-4">
+              <Button type="submit" variant="primary/medium">
+                Save
+              </Button>
+              <LinkButton to="/admin/llm-models" variant="tertiary/medium">
+                Cancel
+              </LinkButton>
+            </div>
+          </div>
+        </Form>
+
+        {/* Delete section */}
+        <div className="border-t border-grid-dimmed pt-4">
+          <Form method="post" onSubmit={(e) => {
+            if (!confirm(`Delete model "${model.modelName}"?`)) e.preventDefault();
+          }}>
+            <input type="hidden" name="_action" value="delete" />
+            <Button type="submit" variant="danger/small">
+              Delete model
+            </Button>
+          </Form>
+        </div>
+      </div>
+    </main>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tier editor sub-component
+// ---------------------------------------------------------------------------
+
+type TierData = {
+  name: string;
+  isDefault: boolean;
+  priority: number;
+  conditions: Array<{ usageDetailPattern: string; operator: string; value: number }>;
+  prices: Record<string, number>;
+};
+
+const COMMON_USAGE_TYPES = [
+  "input",
+  "output",
+  "input_cached_tokens",
+  "cache_creation_input_tokens",
+  "reasoning_tokens",
+];
+
+function TierEditor({
+  tier,
+  onChange,
+  onRemove,
+}: {
+  tier: TierData;
+  onChange: (t: TierData) => void;
+  onRemove: () => void;
+}) {
+  const [newUsageType, setNewUsageType] = useState("");
+
+  return (
+    <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-3 space-y-3">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <input
+            className="bg-charcoal-750 text-text-bright rounded px-2 py-1 text-sm border border-grid-dimmed"
+            value={tier.name}
+            onChange={(e) => onChange({ ...tier, name: e.target.value })}
+            placeholder="Tier name"
+          />
+          <label className="flex items-center gap-1 text-xs text-text-dimmed">
+            <input
+              type="checkbox"
+              checked={tier.isDefault}
+              onChange={(e) => onChange({ ...tier, isDefault: e.target.checked })}
+            />
+            Default
+          </label>
+          <label className="flex items-center gap-1 text-xs text-text-dimmed">
+            Priority:
+            <input
+              type="number"
+              className="w-12 bg-charcoal-750 text-text-bright rounded px-1 py-0.5 text-xs border border-grid-dimmed"
+              value={tier.priority}
+              onChange={(e) => onChange({ ...tier, priority: parseInt(e.target.value) || 0 })}
+            />
+          </label>
+        </div>
+        <button
+          type="button"
+          onClick={onRemove}
+          className="text-xs text-red-400 hover:text-red-300"
+        >
+          Remove tier
+        </button>
+      </div>
+
+      {/* Prices */}
+      <div className="space-y-1">
+        <span className="text-xs font-medium text-text-dimmed">
+          Prices (per token)
+        </span>
+        <div className="space-y-1">
+          {Object.entries(tier.prices).map(([usageType, price]) => (
+            <div key={usageType} className="flex items-center gap-2">
+              <span className="w-48 text-xs font-mono text-text-dimmed">{usageType}</span>
+              <input
+                type="text"
+                className="w-32 bg-charcoal-750 text-text-bright rounded px-2 py-0.5 text-xs font-mono border border-grid-dimmed"
+                value={price}
+                onChange={(e) => {
+                  const val = parseFloat(e.target.value);
+                  if (!isNaN(val)) {
+                    onChange({
+                      ...tier,
+                      prices: { ...tier.prices, [usageType]: val },
+                    });
+                  }
+                }}
+              />
+              <button
+                type="button"
+                onClick={() => {
+                  const { [usageType]: _, ...rest } = tier.prices;
+                  onChange({ ...tier, prices: rest });
+                }}
+                className="text-xs text-red-400 hover:text-red-300"
+              >
+                x
+              </button>
+            </div>
+          ))}
+        </div>
+
+        {/* Add price */}
+        <div className="flex items-center gap-2 pt-1">
+          <select
+            className="bg-charcoal-750 text-text-dimmed rounded px-2 py-0.5 text-xs border border-grid-dimmed"
+            value={newUsageType}
+            onChange={(e) => setNewUsageType(e.target.value)}
+          >
+            <option value="">Add price...</option>
+            {COMMON_USAGE_TYPES.filter((t) => !(t in tier.prices)).map((t) => (
+              <option key={t} value={t}>
+                {t}
+              </option>
+            ))}
+            <option value="__custom">Custom...</option>
+          </select>
+          {newUsageType && (
+            <Button
+              type="button"
+              variant="tertiary/small"
+              onClick={() => {
+                const key =
+                  newUsageType === "__custom"
+                    ? prompt("Usage type name:") ?? ""
+                    : newUsageType;
+                if (key) {
+                  onChange({
+                    ...tier,
+                    prices: { ...tier.prices, [key]: 0 },
+                  });
+                  setNewUsageType("");
+                }
+              }}
+            >
+              Add
+            </Button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/admin.llm-models._index.tsx b/apps/webapp/app/routes/admin.llm-models._index.tsx
new file mode 100644
index 00000000000..ea2eff72541
--- /dev/null
+++ b/apps/webapp/app/routes/admin.llm-models._index.tsx
@@ -0,0 +1,370 @@
+import { MagnifyingGlassIcon } from "@heroicons/react/20/solid";
+import { Form, useFetcher, Link } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Input } from "~/components/primitives/Input";
+import { PaginationControls } from "~/components/primitives/Pagination";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Table,
+  TableBlankRow,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import { createSearchParams } from "~/utils/searchParams";
+import { seedLlmPricing, syncLlmCatalog } from "@internal/llm-model-catalog";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+const PAGE_SIZE = 50;
+
+const SearchParams = z.object({
+  page: z.coerce.number().optional(),
+  search: z.string().optional(),
+});
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const searchParams = createSearchParams(request.url, SearchParams);
+  if (!searchParams.success) throw new Error(searchParams.error);
+  const { page: rawPage, search } = searchParams.params.getAll();
+  const page = rawPage ?? 1;
+
+  const where = {
+    projectId: null as string | null,
+    ...(search ? { modelName: { contains: search, mode: "insensitive" as const } } : {}),
+  };
+
+  const [rawModels, total] = await Promise.all([
+    prisma.llmModel.findMany({
+      where,
+      include: {
+        pricingTiers: { include: { prices: true }, orderBy: { priority: "asc" } },
+      },
+      orderBy: { modelName: "asc" },
+      skip: (page - 1) * PAGE_SIZE,
+      take: PAGE_SIZE,
+    }),
+    prisma.llmModel.count({ where }),
+  ]);
+
+  // Convert Prisma Decimal to plain numbers for serialization
+  const models = rawModels.map((m) => ({
+    ...m,
+    pricingTiers: m.pricingTiers.map((t) => ({
+      ...t,
+      prices: t.prices.map((p) => ({ ...p, price: Number(p.price) })),
+    })),
+  }));
+
+  return typedjson({
+    models,
+    total,
+    page,
+    pageCount: Math.ceil(total / PAGE_SIZE),
+    filters: { search },
+  });
+};
+
+export async function action({ request }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const formData = await request.formData();
+  const _action = formData.get("_action");
+
+  if (_action === "seed") {
+    console.log("[admin] seed action started");
+    const result = await seedLlmPricing(prisma);
+    console.log(`[admin] seed complete: ${result.modelsCreated} created, ${result.modelsSkipped} skipped, ${result.modelsUpdated} updated`);
+    await llmPricingRegistry?.reload();
+    console.log("[admin] registry reloaded after seed");
+    return typedjson({
+      success: true,
+      message: `Seeded: ${result.modelsCreated} created, ${result.modelsSkipped} skipped, ${result.modelsUpdated} updated`,
+    });
+  }
+
+  if (_action === "sync") {
+    console.log("[admin] sync catalog action started");
+    const result = await syncLlmCatalog(prisma);
+    console.log(`[admin] sync complete: ${result.modelsUpdated} updated, ${result.modelsSkipped} skipped`);
+    await llmPricingRegistry?.reload();
+    console.log("[admin] registry reloaded after sync");
+    return typedjson({
+      success: true,
+      message: `Synced: ${result.modelsUpdated} updated, ${result.modelsSkipped} skipped`,
+    });
+  }
+
+  if (_action === "reload") {
+    console.log("[admin] reload action started");
+    await llmPricingRegistry?.reload();
+    console.log("[admin] registry reloaded");
+    return typedjson({ success: true, message: "Registry reloaded" });
+  }
+
+  if (_action === "test") {
+    const modelString = formData.get("modelString");
+    if (typeof modelString !== "string" || !modelString) {
+      return typedjson({ testResult: null });
+    }
+
+    // Use the registry's match() which handles prefix stripping automatically
+    const matched = llmPricingRegistry?.match(modelString) ?? null;
+
+    return typedjson({
+      testResult: {
+        modelString,
+        match: matched
+          ? { friendlyId: matched.friendlyId, modelName: matched.modelName }
+          : null,
+      },
+    });
+  }
+
+  if (_action === "delete") {
+    const modelId = formData.get("modelId");
+    if (typeof modelId === "string") {
+      await prisma.llmModel.delete({ where: { id: modelId } });
+      await llmPricingRegistry?.reload();
+    }
+    return typedjson({ success: true });
+  }
+
+  return typedjson({ error: "Unknown action" }, { status: 400 });
+}
+
+export default function AdminLlmModelsRoute() {
+  const { models, filters, page, pageCount, total } =
+    useTypedLoaderData<typeof loader>();
+  const seedFetcher = useFetcher();
+  const syncFetcher = useFetcher();
+  const reloadFetcher = useFetcher();
+  const testFetcher = useFetcher<{
+    testResult?: {
+      modelString: string;
+      match: { friendlyId: string; modelName: string } | null;
+    } | null;
+  }>();
+
+  const testResult = testFetcher.data?.testResult;
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="space-y-4">
+        <div className="flex items-center justify-between">
+          <Form className="flex items-center gap-2">
+            <Input
+              placeholder="Search models..."
+              variant="medium"
+              icon={MagnifyingGlassIcon}
+              fullWidth={true}
+              name="search"
+              defaultValue={filters.search}
+              autoFocus
+            />
+            <Button type="submit" variant="secondary/medium">
+              Search
+            </Button>
+          </Form>
+
+          <div className="flex items-center gap-2">
+            <seedFetcher.Form method="post">
+              <input type="hidden" name="_action" value="seed" />
+              <Button
+                type="submit"
+                variant="tertiary/small"
+                disabled={seedFetcher.state !== "idle"}
+              >
+                {seedFetcher.state !== "idle" ? "Seeding..." : "Seed defaults"}
+              </Button>
+            </seedFetcher.Form>
+
+            <syncFetcher.Form method="post">
+              <input type="hidden" name="_action" value="sync" />
+              <Button
+                type="submit"
+                variant="tertiary/small"
+                disabled={syncFetcher.state !== "idle"}
+              >
+                {syncFetcher.state !== "idle" ? "Syncing..." : "Sync catalog"}
+              </Button>
+            </syncFetcher.Form>
+
+            <reloadFetcher.Form method="post">
+              <input type="hidden" name="_action" value="reload" />
+              <Button
+                type="submit"
+                variant="tertiary/small"
+                disabled={reloadFetcher.state !== "idle"}
+              >
+                {reloadFetcher.state !== "idle" ? "Reloading..." : "Reload registry"}
+              </Button>
+            </reloadFetcher.Form>
+
+            <LinkButton to="/admin/llm-models/missing" variant="tertiary/small">
+              Missing models
+            </LinkButton>
+
+            <LinkButton to="/admin/llm-models/new" variant="primary/small">
+              Add model
+            </LinkButton>
+          </div>
+        </div>
+
+        {/* Model tester */}
+        <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-3 space-y-2">
+          <label className="text-xs font-medium text-text-dimmed">
+            Test model string — paste a model name to see which pricing model matches
+          </label>
+          <testFetcher.Form method="post" className="flex items-center gap-2">
+            <input type="hidden" name="_action" value="test" />
+            <Input
+              name="modelString"
+              placeholder="e.g. anthropic/claude-haiku-4-5-20251001, gpt-4o-mini, mistral/mistral-large-3"
+              variant="medium"
+              fullWidth
+              className="font-mono text-xs"
+            />
+            <Button
+              type="submit"
+              variant="secondary/small"
+              disabled={testFetcher.state !== "idle"}
+            >
+              Test
+            </Button>
+          </testFetcher.Form>
+          {testResult !== undefined && testResult !== null && (
+            <div className="text-xs space-y-1">
+              <span className="text-text-dimmed">
+                Testing: <span className="font-mono text-text-bright">{testResult.modelString}</span>
+              </span>
+              {testResult.match ? (
+                <div className="text-green-400">
+                  Match:{" "}
+                  <Link
+                    to={`/admin/llm-models/${testResult.match.friendlyId}`}
+                    className="underline font-medium"
+                  >
+                    {testResult.match.modelName}
+                  </Link>
+                </div>
+              ) : (
+                <div className="text-red-400">
+                  No match found — this model has no pricing data
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+
+        <div className="flex items-center justify-between">
+          <Paragraph className="text-text-dimmed">
+            {total} global models (page {page} of {pageCount})
+          </Paragraph>
+          <PaginationControls currentPage={page} totalPages={pageCount} />
+        </div>
+
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHeaderCell>Model Name</TableHeaderCell>
+              <TableHeaderCell>Source</TableHeaderCell>
+              <TableHeaderCell>Input $/tok</TableHeaderCell>
+              <TableHeaderCell>Output $/tok</TableHeaderCell>
+              <TableHeaderCell>Other prices</TableHeaderCell>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {models.length === 0 ? (
+              <TableBlankRow colSpan={5}>
+                <Paragraph>No models found</Paragraph>
+              </TableBlankRow>
+            ) : (
+              models.map((model) => {
+                // Get default tier prices
+                const defaultTier =
+                  model.pricingTiers.find((t) => t.isDefault) ?? model.pricingTiers[0];
+                const priceMap = defaultTier
+                  ? Object.fromEntries(defaultTier.prices.map((p) => [p.usageType, p.price]))
+                  : {};
+                const inputPrice = priceMap["input"];
+                const outputPrice = priceMap["output"];
+                const otherPrices = defaultTier
+                  ? defaultTier.prices.filter(
+                      (p) => p.usageType !== "input" && p.usageType !== "output"
+                    )
+                  : [];
+
+                return (
+                  <TableRow key={model.id}>
+                    <TableCell>
+                      <Link
+                        to={`/admin/llm-models/${model.friendlyId}`}
+                        className="font-medium text-indigo-500 underline"
+                      >
+                        {model.modelName}
+                      </Link>
+                    </TableCell>
+                    <TableCell>
+                      <span
+                        className={`inline-flex rounded-sm px-1.5 py-0.5 text-[11px] font-medium ${
+                          model.source === "admin"
+                            ? "bg-amber-500/20 text-amber-400"
+                            : "bg-charcoal-700 text-text-dimmed"
+                        }`}
+                      >
+                        {model.source ?? "default"}
+                      </span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs font-mono text-text-bright">
+                        {inputPrice != null ? formatPrice(inputPrice) : "-"}
+                      </span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs font-mono text-text-bright">
+                        {outputPrice != null ? formatPrice(outputPrice) : "-"}
+                      </span>
+                    </TableCell>
+                    <TableCell>
+                      {otherPrices.length > 0 ? (
+                        <span className="text-xs text-text-dimmed" title={otherPrices.map((p) => p.usageType).join(", ")}>
+                          +{otherPrices.length} more
+                        </span>
+                      ) : (
+                        <span className="text-xs text-text-dimmed">-</span>
+                      )}
+                    </TableCell>
+                  </TableRow>
+                );
+              })
+            )}
+          </TableBody>
+        </Table>
+
+        <PaginationControls currentPage={page} totalPages={pageCount} />
+      </div>
+    </main>
+  );
+}
+
+/** Format a per-token price as $/M tokens for readability */
+function formatPrice(perToken: number): string {
+  const perMillion = perToken * 1_000_000;
+  if (perMillion >= 1) return `$${perMillion.toFixed(2)}/M`;
+  if (perMillion >= 0.01) return `$${perMillion.toFixed(4)}/M`;
+  return `$${perMillion.toFixed(6)}/M`;
+}
diff --git a/apps/webapp/app/routes/admin.llm-models.missing.$model.tsx b/apps/webapp/app/routes/admin.llm-models.missing.$model.tsx
new file mode 100644
index 00000000000..78cb1c4fc91
--- /dev/null
+++ b/apps/webapp/app/routes/admin.llm-models.missing.$model.tsx
@@ -0,0 +1,469 @@
+import { useState } from "react";
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import {
+  getMissingModelSamples,
+  type MissingModelSample,
+} from "~/services/admin/missingLlmModels.server";
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  // Model name is URL-encoded in the URL param
+  const modelName = decodeURIComponent(params.model ?? "");
+  if (!modelName) throw new Response("Missing model param", { status: 400 });
+
+  const url = new URL(request.url);
+  const lookbackHours = parseInt(url.searchParams.get("lookbackHours") ?? "24", 10);
+
+  let samples: MissingModelSample[] = [];
+  let error: string | undefined;
+
+  try {
+    samples = await getMissingModelSamples({ model: modelName, lookbackHours, limit: 10 });
+  } catch (e) {
+    error = e instanceof Error ? e.message : "Failed to query ClickHouse";
+  }
+
+  return typedjson({ modelName, samples, lookbackHours, error });
+};
+
+export default function AdminMissingModelDetailRoute() {
+  const { modelName, samples, lookbackHours, error } = useTypedLoaderData<typeof loader>();
+  const [copied, setCopied] = useState(false);
+  const [expandedSpans, setExpandedSpans] = useState<Set<string>>(new Set());
+
+  const providerCosts = extractProviderCosts(samples);
+  const prompt = buildPrompt(modelName, samples, providerCosts);
+
+  function handleCopy() {
+    navigator.clipboard.writeText(prompt).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2000);
+    });
+  }
+
+  function toggleSpan(spanId: string) {
+    setExpandedSpans((prev) => {
+      const next = new Set(prev);
+      if (next.has(spanId)) next.delete(spanId);
+      else next.add(spanId);
+      return next;
+    });
+  }
+
+  // Extract key token fields from the first sample for quick summary
+  const tokenSummary = samples.length > 0 ? extractTokenTypes(samples) : [];
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="max-w-5xl space-y-6">
+        {/* Header */}
+        <div className="flex items-center justify-between">
+          <div>
+            <h2 className="text-lg font-medium text-text-bright font-mono">{modelName}</h2>
+            <Paragraph className="text-text-dimmed">
+              Missing pricing — {samples.length} sample span{samples.length !== 1 ? "s" : ""} from
+              last {lookbackHours}h
+            </Paragraph>
+          </div>
+          <div className="flex items-center gap-2">
+            <LinkButton
+              to={`/admin/llm-models/new?modelName=${encodeURIComponent(modelName)}`}
+              variant="primary/small"
+            >
+              Add pricing
+            </LinkButton>
+            <LinkButton to="/admin/llm-models/missing" variant="tertiary/small">
+              Back to missing
+            </LinkButton>
+          </div>
+        </div>
+
+        {error && (
+          <div className="rounded-md border border-red-500/30 bg-red-500/10 p-3 text-sm text-red-400">
+            {error}
+          </div>
+        )}
+
+        {/* Token types summary */}
+        {tokenSummary.length > 0 && (
+          <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-3 space-y-2">
+            <span className="text-xs font-medium text-text-dimmed">
+              Token types seen across samples
+            </span>
+            <div className="flex flex-wrap gap-2">
+              {tokenSummary.map((t) => (
+                <span
+                  key={t.key}
+                  className="inline-flex items-center gap-1.5 rounded-sm bg-charcoal-700 px-2 py-1 text-xs font-mono"
+                >
+                  <span className="text-text-bright">{t.key}</span>
+                  <span className="text-text-dimmed">
+                    {t.min === t.max ? t.min.toLocaleString() : `${t.min.toLocaleString()}-${t.max.toLocaleString()}`}
+                  </span>
+                </span>
+              ))}
+            </div>
+            <Paragraph className="text-text-dimmed text-xs">
+              These are the token usage types that need pricing entries (at minimum: input, output).
+            </Paragraph>
+          </div>
+        )}
+
+        {/* Provider-reported costs */}
+        {providerCosts.length > 0 && (
+          <div className="rounded-md border border-green-500/30 bg-green-500/5 p-3 space-y-2">
+            <span className="text-xs font-medium text-green-400">
+              Provider-reported cost data found in {providerCosts.length} span{providerCosts.length !== 1 ? "s" : ""}
+            </span>
+            <div className="space-y-1">
+              {providerCosts.map((c, i) => (
+                <div key={i} className="flex items-center gap-3 text-xs">
+                  <span className="text-text-dimmed">{c.source}</span>
+                  <span className="font-mono text-text-bright">${c.cost.toFixed(6)}</span>
+                  <span className="text-text-dimmed">
+                    ({c.inputTokens.toLocaleString()} in + {c.outputTokens.toLocaleString()} out)
+                  </span>
+                </div>
+              ))}
+            </div>
+            {providerCosts[0]?.estimatedInputPrice != null && (
+              <div className="border-t border-green-500/20 pt-2 text-xs">
+                <span className="text-green-300">
+                  Estimated per-token rates (assuming ~3x output/input ratio):
+                </span>
+                <div className="flex gap-4 mt-1 font-mono text-text-bright">
+                  <span>input: {providerCosts[0].estimatedInputPrice.toExponential(4)}</span>
+                  <span>output: {(providerCosts[0].estimatedOutputPrice ?? 0).toExponential(4)}</span>
+                </div>
+                <span className="text-text-dimmed mt-1 block">
+                  Cross-reference with the provider's pricing page before using these estimates.
+                </span>
+              </div>
+            )}
+          </div>
+        )}
+
+        {/* Prompt section */}
+        <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-3 space-y-2">
+          <div className="flex items-center justify-between">
+            <span className="text-xs font-medium text-text-dimmed">
+              Claude Code prompt — paste this to have it add pricing for this model
+            </span>
+            <Button variant="tertiary/small" onClick={handleCopy}>
+              {copied ? "Copied!" : "Copy prompt"}
+            </Button>
+          </div>
+          <pre className="max-h-64 overflow-auto rounded bg-charcoal-900 p-3 text-xs text-text-dimmed font-mono whitespace-pre-wrap">
+            {prompt}
+          </pre>
+        </div>
+
+        {/* Sample spans */}
+        <div className="space-y-2">
+          <span className="text-sm font-medium text-text-bright">
+            Sample spans ({samples.length})
+          </span>
+          {samples.map((s) => {
+            const expanded = expandedSpans.has(s.span_id);
+            let parsedAttrs: Record<string, unknown> | null = null;
+            try {
+              parsedAttrs = JSON.parse(s.attributes_text) as Record<string, unknown>;
+            } catch {
+              // ignore
+            }
+
+            return (
+              <div
+                key={s.span_id}
+                className="rounded-md border border-grid-dimmed bg-charcoal-800"
+              >
+                <button
+                  type="button"
+                  onClick={() => toggleSpan(s.span_id)}
+                  className="w-full flex items-center justify-between p-3 text-left hover:bg-charcoal-750"
+                >
+                  <div className="flex items-center gap-3 text-xs">
+                    <span className="font-mono text-text-dimmed">{s.span_id.slice(0, 8)}</span>
+                    <span className="text-text-bright">{s.message}</span>
+                    <span className="text-text-dimmed">{s.run_id}</span>
+                  </div>
+                  <span className="text-xs text-text-dimmed">{expanded ? "▼" : "▶"}</span>
+                </button>
+                {expanded && parsedAttrs && (
+                  <div className="border-t border-grid-dimmed p-3">
+                    <pre className="max-h-96 overflow-auto text-xs text-text-dimmed font-mono whitespace-pre-wrap">
+                      {JSON.stringify(parsedAttrs, null, 2)}
+                    </pre>
+                  </div>
+                )}
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    </main>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Extract unique token usage types across all samples
+// ---------------------------------------------------------------------------
+
+type TokenTypeSummary = { key: string; min: number; max: number };
+
+function extractTokenTypes(samples: MissingModelSample[]): TokenTypeSummary[] {
+  const stats = new Map<string, { min: number; max: number }>();
+
+  for (const s of samples) {
+    let attrs: Record<string, unknown>;
+    try {
+      attrs = JSON.parse(s.attributes_text) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    // Collect from gen_ai.usage.*
+    const genAiUsage = getNestedObj(attrs, ["gen_ai", "usage"]);
+    if (genAiUsage) {
+      for (const [k, v] of Object.entries(genAiUsage)) {
+        if (typeof v === "number" && v > 0) {
+          const existing = stats.get(`gen_ai.usage.${k}`);
+          if (existing) {
+            existing.min = Math.min(existing.min, v);
+            existing.max = Math.max(existing.max, v);
+          } else {
+            stats.set(`gen_ai.usage.${k}`, { min: v, max: v });
+          }
+        }
+      }
+    }
+
+    // Collect from ai.usage.*
+    const aiUsage = getNestedObj(attrs, ["ai", "usage"]);
+    if (aiUsage) {
+      for (const [k, v] of Object.entries(aiUsage)) {
+        if (typeof v === "number" && v > 0) {
+          const existing = stats.get(`ai.usage.${k}`);
+          if (existing) {
+            existing.min = Math.min(existing.min, v);
+            existing.max = Math.max(existing.max, v);
+          } else {
+            stats.set(`ai.usage.${k}`, { min: v, max: v });
+          }
+        }
+      }
+    }
+  }
+
+  return Array.from(stats.entries())
+    .map(([key, { min, max }]) => ({ key, min, max }))
+    .sort((a, b) => a.key.localeCompare(b.key));
+}
+
+function getNestedObj(
+  obj: Record<string, unknown>,
+  path: string[]
+): Record<string, unknown> | null {
+  let current: unknown = obj;
+  for (const key of path) {
+    if (!current || typeof current !== "object") return null;
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current && typeof current === "object" ? (current as Record<string, unknown>) : null;
+}
+
+// ---------------------------------------------------------------------------
+// Extract provider-reported costs from providerMetadata
+// ---------------------------------------------------------------------------
+
+type ProviderCostInfo = {
+  source: string; // "gateway" or "openrouter"
+  cost: number;
+  inputTokens: number;
+  outputTokens: number;
+  estimatedInputPrice?: number;  // per-token estimate
+  estimatedOutputPrice?: number; // per-token estimate
+};
+
+function extractProviderCosts(samples: MissingModelSample[]): ProviderCostInfo[] {
+  const costs: ProviderCostInfo[] = [];
+
+  for (const s of samples) {
+    let attrs: Record<string, unknown>;
+    try {
+      attrs = JSON.parse(s.attributes_text) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    // Parse providerMetadata — could be nested or stringified
+    let providerMeta: Record<string, unknown> | null = null;
+    const aiResponse = getNestedObj(attrs, ["ai", "response"]);
+    const rawMeta = aiResponse?.providerMetadata;
+    if (typeof rawMeta === "string") {
+      try { providerMeta = JSON.parse(rawMeta) as Record<string, unknown>; } catch {}
+    } else if (rawMeta && typeof rawMeta === "object") {
+      providerMeta = rawMeta as Record<string, unknown>;
+    }
+    if (!providerMeta) continue;
+
+    // Get token counts
+    const genAiUsage = getNestedObj(attrs, ["gen_ai", "usage"]);
+    const inputTokens = Number(genAiUsage?.input_tokens ?? 0);
+    const outputTokens = Number(genAiUsage?.output_tokens ?? 0);
+    if (inputTokens === 0 && outputTokens === 0) continue;
+
+    // Gateway: { gateway: { cost: "0.0006615" } }
+    const gw = getNestedObj(providerMeta, ["gateway"]);
+    if (gw) {
+      const cost = parseFloat(String(gw.cost ?? "0"));
+      if (cost > 0) {
+        costs.push({ source: "gateway", cost, inputTokens, outputTokens });
+        continue;
+      }
+    }
+
+    // OpenRouter: { openrouter: { usage: { cost: 0.000135 } } }
+    const or = getNestedObj(providerMeta, ["openrouter"]);
+    const orUsage = or ? getNestedObj(or, ["usage"]) : null;
+    if (orUsage) {
+      const cost = Number(orUsage.cost ?? 0);
+      if (cost > 0) {
+        costs.push({ source: "openrouter", cost, inputTokens, outputTokens });
+        continue;
+      }
+    }
+  }
+
+  // Estimate per-token prices from aggregate costs if we have enough data
+  if (costs.length > 0) {
+    // Use least-squares to estimate input/output price from cost = input*pi + output*po
+    // With 2+ samples we can solve; with 1 we can only estimate a blended rate
+    const totalInput = costs.reduce((s, c) => s + c.inputTokens, 0);
+    const totalOutput = costs.reduce((s, c) => s + c.outputTokens, 0);
+    const totalCost = costs.reduce((s, c) => s + c.cost, 0);
+
+    if (totalInput > 0 && totalOutput > 0) {
+      // Simple approach: assume output is 2-5x input price (common ratio)
+      // Use ratio r where output_price = r * input_price
+      // totalCost = input_price * (totalInput + r * totalOutput)
+      // Try r=3 (common for many models)
+      const r = 3;
+      const estimatedInputPrice = totalCost / (totalInput + r * totalOutput);
+      const estimatedOutputPrice = estimatedInputPrice * r;
+
+      for (const c of costs) {
+        c.estimatedInputPrice = estimatedInputPrice;
+        c.estimatedOutputPrice = estimatedOutputPrice;
+      }
+    }
+  }
+
+  return costs;
+}
+
+// ---------------------------------------------------------------------------
+// Prompt builder — focused on figuring out pricing, not API mechanics
+// ---------------------------------------------------------------------------
+
+function buildPrompt(modelName: string, samples: MissingModelSample[], providerCosts: ProviderCostInfo[]): string {
+  const hasPrefix = modelName.includes("/");
+  const prefix = hasPrefix ? modelName.split("/")[0] : null;
+  const baseName = hasPrefix ? modelName.split("/").slice(1).join("/") : modelName;
+
+  // Extract token types from samples
+  const tokenTypes = extractTokenTypes(samples);
+  const tokenTypeList = tokenTypes.length > 0
+    ? tokenTypes.map((t) => `  - ${t.key}: ${t.min === t.max ? t.min : `${t.min}-${t.max}`}`).join("\n")
+    : "  (no token data found in samples)";
+
+  // Get a compact sample of attributes for context
+  let sampleAttrs = "";
+  if (samples.length > 0) {
+    try {
+      const attrs = JSON.parse(samples[0].attributes_text) as Record<string, unknown>;
+      const ai = attrs.ai as Record<string, unknown> | undefined;
+      const aiResponse = (ai?.response ?? {}) as Record<string, unknown>;
+      // Extract just the relevant fields
+      const compact: Record<string, unknown> = {};
+      if (attrs.gen_ai) compact.gen_ai = attrs.gen_ai;
+      if (ai?.usage) compact["ai.usage"] = ai.usage;
+      if (aiResponse.providerMetadata) {
+        compact["ai.response.providerMetadata"] = aiResponse.providerMetadata;
+      }
+      sampleAttrs = JSON.stringify(compact, null, 2);
+    } catch {
+      // ignore
+    }
+  }
+
+  // Build suggested regex
+  const escapedBase = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const suggestedPattern = prefix
+    ? `(?i)^(${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/)?(${escapedBase})$`
+    : `(?i)^(${escapedBase})$`;
+
+  return `I need to add LLM pricing for the model "${modelName}".
+
+## Model info
+- Full model string from spans: \`${modelName}\`
+- Base model name: \`${baseName}\`${prefix ? `\n- Provider prefix: \`${prefix}\`` : ""}
+- This model appears in production spans but has no pricing data.
+
+## Token types seen in spans
+${tokenTypeList}
+
+## What I need you to do
+
+1. **Look up pricing**: Find the current per-token pricing for \`${baseName}\` from the provider's official pricing page. Search the web if needed.
+
+2. **Present the pricing to me** in the following format so I can review before adding:
+
+\`\`\`
+Model name: ${baseName}
+Match pattern: ${suggestedPattern}
+Pricing tier: Standard
+
+Prices (per token):
+  input: <cost per input token>
+  output: <cost per output token>
+  (add any additional token types if applicable)
+\`\`\`
+
+**IMPORTANT: Do NOT call the admin API or create the model yourself.** Just research the pricing and present it to me. I will add it via the admin dashboard or ask you to proceed once I've reviewed.
+
+## Pricing research notes
+
+- All prices should be in **cost per token** (NOT per million). To convert: divide $/M by 1,000,000.
+  - Example: $3.00/M tokens = 0.000003 per token
+- The \`matchPattern\` regex should match the model name both with and without the provider prefix.
+  - Suggested: \`${suggestedPattern}\`
+  - This matches both \`${baseName}\` and \`${modelName}\`
+- Based on the token types seen in spans, check if the provider charges differently for:
+  - \`input\` and \`output\` — always required
+  - \`input_cached_tokens\` — if the provider offers prompt caching discounts
+  - \`cache_creation_input_tokens\` — if there's a cache write cost
+  - \`reasoning_tokens\` — if the model has chain-of-thought/reasoning tokens${providerCosts.length > 0 ? `
+
+## Provider-reported costs (from ${providerCosts[0].source})
+The gateway/router is reporting costs for this model. Use these to cross-reference your pricing:
+${providerCosts.map((c) => `- $${c.cost.toFixed(6)} for ${c.inputTokens.toLocaleString()} input + ${c.outputTokens.toLocaleString()} output tokens`).join("\n")}${providerCosts[0].estimatedInputPrice != null ? `
+- Estimated per-token rates (rough, assuming ~3x output/input ratio):
+  - input: ${providerCosts[0].estimatedInputPrice.toExponential(4)} (${(providerCosts[0].estimatedInputPrice * 1_000_000).toFixed(4)} $/M)
+  - output: ${(providerCosts[0].estimatedOutputPrice ?? 0).toExponential(4)} (${((providerCosts[0].estimatedOutputPrice ?? 0) * 1_000_000).toFixed(4)} $/M)
+- Verify these against the official pricing page before using.` : ""}` : ""}${sampleAttrs ? `
+
+## Sample span attributes (first span)
+\`\`\`json
+${sampleAttrs}
+\`\`\`` : ""}`;
+}
diff --git a/apps/webapp/app/routes/admin.llm-models.missing._index.tsx b/apps/webapp/app/routes/admin.llm-models.missing._index.tsx
new file mode 100644
index 00000000000..fd933cd22e9
--- /dev/null
+++ b/apps/webapp/app/routes/admin.llm-models.missing._index.tsx
@@ -0,0 +1,158 @@
+import { useSearchParams } from "@remix-run/react";
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { LinkButton } from "~/components/primitives/Buttons";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Table,
+  TableBlankRow,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import { getMissingLlmModels } from "~/services/admin/missingLlmModels.server";
+
+const LOOKBACK_OPTIONS = [
+  { label: "1 hour", value: 1 },
+  { label: "6 hours", value: 6 },
+  { label: "24 hours", value: 24 },
+  { label: "7 days", value: 168 },
+  { label: "30 days", value: 720 },
+];
+
+const SearchParams = z.object({
+  lookbackHours: z.coerce.number().optional(),
+});
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const url = new URL(request.url);
+  const lookbackHours = parseInt(url.searchParams.get("lookbackHours") ?? "24", 10);
+
+  let models: Awaited<ReturnType<typeof getMissingLlmModels>> = [];
+  let error: string | undefined;
+
+  try {
+    models = await getMissingLlmModels({ lookbackHours });
+  } catch (e) {
+    error = e instanceof Error ? e.message : "Failed to query ClickHouse";
+  }
+
+  return typedjson({ models, lookbackHours, error });
+};
+
+export default function AdminLlmModelsMissingRoute() {
+  const { models, lookbackHours, error } = useTypedLoaderData<typeof loader>();
+  const [searchParams, setSearchParams] = useSearchParams();
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="space-y-4">
+        <div className="flex items-center justify-between">
+          <h2 className="text-lg font-medium text-text-bright">Missing LLM Models</h2>
+          <LinkButton to="/admin/llm-models" variant="tertiary/small">
+            Back to models
+          </LinkButton>
+        </div>
+
+        <Paragraph className="text-text-dimmed">
+          Models appearing in spans without cost enrichment. These models need pricing data added.
+        </Paragraph>
+
+        {/* Lookback selector */}
+        <div className="flex items-center gap-2">
+          <span className="text-xs text-text-dimmed">Lookback:</span>
+          {LOOKBACK_OPTIONS.map((opt) => (
+            <LinkButton
+              key={opt.value}
+              to={`/admin/llm-models/missing?lookbackHours=${opt.value}`}
+              variant={lookbackHours === opt.value ? "primary/small" : "tertiary/small"}
+            >
+              {opt.label}
+            </LinkButton>
+          ))}
+        </div>
+
+        {error && (
+          <div className="rounded-md border border-red-500/30 bg-red-500/10 p-3 text-sm text-red-400">
+            {error}
+          </div>
+        )}
+
+        <Paragraph className="text-text-dimmed">
+          {models.length} unpriced model{models.length !== 1 ? "s" : ""} found in the last{" "}
+          {lookbackHours < 24
+            ? `${lookbackHours}h`
+            : lookbackHours < 168
+              ? `${lookbackHours / 24}d`
+              : `${Math.round(lookbackHours / 24)}d`}
+        </Paragraph>
+
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHeaderCell>Model Name</TableHeaderCell>
+              <TableHeaderCell>Provider</TableHeaderCell>
+              <TableHeaderCell>Span Count</TableHeaderCell>
+              <TableHeaderCell>Actions</TableHeaderCell>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {models.length === 0 ? (
+              <TableBlankRow colSpan={4}>
+                <Paragraph>All models have pricing data</Paragraph>
+              </TableBlankRow>
+            ) : (
+              models.map((m) => (
+                <MissingModelRow key={`${m.system}/${m.model}`} model={m} />
+              ))
+            )}
+          </TableBody>
+        </Table>
+      </div>
+    </main>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Row component with link to detail page
+// ---------------------------------------------------------------------------
+
+function MissingModelRow({ model: m }: { model: { model: string; system: string; count: number } }) {
+  return (
+    <TableRow>
+      <TableCell>
+        <LinkButton
+          to={`/admin/llm-models/missing/${encodeURIComponent(m.model)}`}
+          variant="minimal/small"
+          className="font-mono text-sm text-indigo-500 underline"
+        >
+          {m.model}
+        </LinkButton>
+      </TableCell>
+      <TableCell>
+        <span className="text-xs text-text-dimmed">{m.system || "-"}</span>
+      </TableCell>
+      <TableCell>
+        <span className="text-sm text-text-bright">{m.count.toLocaleString()}</span>
+      </TableCell>
+      <TableCell>
+        <LinkButton
+          to={`/admin/llm-models/missing/${encodeURIComponent(m.model)}`}
+          variant="tertiary/small"
+        >
+          Details
+        </LinkButton>
+      </TableCell>
+    </TableRow>
+  );
+}
diff --git a/apps/webapp/app/routes/admin.llm-models.new.tsx b/apps/webapp/app/routes/admin.llm-models.new.tsx
new file mode 100644
index 00000000000..7f18bf5826a
--- /dev/null
+++ b/apps/webapp/app/routes/admin.llm-models.new.tsx
@@ -0,0 +1,494 @@
+import { Form, useActionData, useSearchParams } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { typedjson } from "remix-typedjson";
+import { z } from "zod";
+import { useState } from "react";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Input } from "~/components/primitives/Input";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+  return typedjson({});
+};
+
+const CreateSchema = z.object({
+  modelName: z.string().min(1),
+  matchPattern: z.string().min(1),
+  pricingTiersJson: z.string(),
+  provider: z.string().optional(),
+  description: z.string().optional(),
+  contextWindow: z.string().optional(),
+  maxOutputTokens: z.string().optional(),
+  capabilities: z.string().optional(),
+  isHidden: z.string().optional(),
+});
+
+export async function action({ request }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const formData = await request.formData();
+  const raw = Object.fromEntries(formData);
+  console.log("[admin] create model form data:", JSON.stringify(raw).slice(0, 500));
+  const parsed = CreateSchema.safeParse(raw);
+
+  if (!parsed.success) {
+    console.log("[admin] create model validation error:", JSON.stringify(parsed.error.issues));
+    return typedjson({ error: "Invalid form data", details: parsed.error.issues }, { status: 400 });
+  }
+
+  const { modelName, matchPattern, pricingTiersJson } = parsed.data;
+
+  // Validate regex — strip (?i) POSIX flag since our registry handles it
+  try {
+    const testPattern = matchPattern.startsWith("(?i)") ? matchPattern.slice(4) : matchPattern;
+    new RegExp(testPattern);
+  } catch {
+    return typedjson({ error: "Invalid regex in matchPattern" }, { status: 400 });
+  }
+
+  let pricingTiers: Array<{
+    name: string;
+    isDefault: boolean;
+    priority: number;
+    conditions: Array<{ usageDetailPattern: string; operator: string; value: number }>;
+    prices: Record<string, number>;
+  }>;
+  try {
+    pricingTiers = JSON.parse(pricingTiersJson) as typeof pricingTiers;
+  } catch {
+    return typedjson({ error: "Invalid pricing tiers JSON" }, { status: 400 });
+  }
+
+  const { provider, description, contextWindow, maxOutputTokens, capabilities, isHidden } = parsed.data;
+
+  const model = await prisma.llmModel.create({
+    data: {
+      friendlyId: generateFriendlyId("llm_model"),
+      modelName,
+      matchPattern,
+      source: "admin",
+      provider: provider || null,
+      description: description || null,
+      contextWindow: contextWindow ? parseInt(contextWindow) || null : null,
+      maxOutputTokens: maxOutputTokens ? parseInt(maxOutputTokens) || null : null,
+      capabilities: capabilities ? capabilities.split(",").map((s) => s.trim()).filter(Boolean) : [],
+      isHidden: isHidden === "on",
+    },
+  });
+
+  for (const tier of pricingTiers) {
+    await prisma.llmPricingTier.create({
+      data: {
+        modelId: model.id,
+        name: tier.name,
+        isDefault: tier.isDefault,
+        priority: tier.priority,
+        conditions: tier.conditions,
+        prices: {
+          create: Object.entries(tier.prices).map(([usageType, price]) => ({
+            modelId: model.id,
+            usageType,
+            price,
+          })),
+        },
+      },
+    });
+  }
+
+  await llmPricingRegistry?.reload();
+  return redirect(`/admin/llm-models/${model.friendlyId}`);
+}
+
+export default function AdminLlmModelNewRoute() {
+  const actionData = useActionData<{ error?: string; details?: unknown[] }>();
+  const [params] = useSearchParams();
+  const initialModelName = params.get("modelName") ?? "";
+  const [modelName, setModelName] = useState(initialModelName);
+  const [matchPattern, setMatchPattern] = useState("");
+  const [provider, setProvider] = useState("");
+  const [description, setDescription] = useState("");
+  const [contextWindow, setContextWindow] = useState("");
+  const [maxOutputTokens, setMaxOutputTokens] = useState("");
+  const [capabilities, setCapabilities] = useState("");
+  const [isHidden, setIsHidden] = useState(false);
+  const [testInput, setTestInput] = useState("");
+  const [tiers, setTiers] = useState<TierData[]>([
+    { name: "Standard", isDefault: true, priority: 0, conditions: [], prices: { input: 0, output: 0 } },
+  ]);
+
+  let testResult: boolean | null = null;
+  if (testInput && matchPattern) {
+    try {
+      const pattern = matchPattern.startsWith("(?i)")
+        ? matchPattern.slice(4)
+        : matchPattern;
+      testResult = new RegExp(pattern, "i").test(testInput);
+    } catch {
+      testResult = null;
+    }
+  }
+
+  // Auto-generate match pattern from model name
+  function autoPattern() {
+    if (modelName) {
+      const escaped = modelName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      setMatchPattern(`(?i)^(${escaped})$`);
+    }
+  }
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="max-w-3xl space-y-6">
+        <div className="flex items-center justify-between">
+          <h2 className="text-lg font-medium text-text-bright">New LLM Model</h2>
+          <LinkButton to="/admin/llm-models" variant="tertiary/small">
+            Back to list
+          </LinkButton>
+        </div>
+
+        <Form method="post">
+          <input type="hidden" name="pricingTiersJson" value={JSON.stringify(tiers)} />
+
+          <div className="space-y-4">
+            <div className="space-y-2">
+              <label className="text-xs font-medium text-text-dimmed">Model Name</label>
+              <Input
+                name="modelName"
+                value={modelName}
+                onChange={(e) => setModelName(e.target.value)}
+                variant="medium"
+                fullWidth
+                placeholder="e.g. gemini-3-flash"
+              />
+            </div>
+
+            <div className="space-y-2">
+              <div className="flex items-center justify-between">
+                <label className="text-xs font-medium text-text-dimmed">Match Pattern (regex)</label>
+                <button
+                  type="button"
+                  onClick={autoPattern}
+                  className="text-xs text-indigo-400 hover:text-indigo-300"
+                >
+                  Auto-generate from name
+                </button>
+              </div>
+              <Input
+                name="matchPattern"
+                value={matchPattern}
+                onChange={(e) => setMatchPattern(e.target.value)}
+                variant="medium"
+                fullWidth
+                className="font-mono text-xs"
+                placeholder="(?i)^(google/)?(gemini-3-flash)$"
+              />
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-xs font-medium text-text-dimmed">Test pattern match</label>
+              <div className="flex items-center gap-2">
+                <Input
+                  value={testInput}
+                  onChange={(e) => setTestInput(e.target.value)}
+                  placeholder="Type a model name to test..."
+                  variant="medium"
+                  fullWidth
+                />
+                {testInput && (
+                  <span
+                    className={`text-xs font-medium ${
+                      testResult ? "text-green-400" : "text-red-400"
+                    }`}
+                  >
+                    {testResult ? "Match" : "No match"}
+                  </span>
+                )}
+              </div>
+            </div>
+
+            {/* Catalog metadata */}
+            <div className="space-y-2 border-t border-grid-dimmed pt-4">
+              <label className="text-sm font-medium text-text-bright">Catalog Metadata</label>
+
+              <div className="grid grid-cols-2 gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Provider</label>
+                  <Input
+                    name="provider"
+                    value={provider}
+                    onChange={(e) => setProvider(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="openai, anthropic, google"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Context Window</label>
+                  <Input
+                    name="contextWindow"
+                    value={contextWindow}
+                    onChange={(e) => setContextWindow(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="128000"
+                  />
+                </div>
+              </div>
+
+              <div className="space-y-1">
+                <label className="text-xs font-medium text-text-dimmed">Description</label>
+                <Input
+                  name="description"
+                  value={description}
+                  onChange={(e) => setDescription(e.target.value)}
+                  variant="medium"
+                  fullWidth
+                  placeholder="Brief model description"
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-3">
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Max Output Tokens</label>
+                  <Input
+                    name="maxOutputTokens"
+                    value={maxOutputTokens}
+                    onChange={(e) => setMaxOutputTokens(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="16384"
+                  />
+                </div>
+                <div className="space-y-1">
+                  <label className="text-xs font-medium text-text-dimmed">Features (comma-separated)</label>
+                  <Input
+                    name="capabilities"
+                    value={capabilities}
+                    onChange={(e) => setCapabilities(e.target.value)}
+                    variant="medium"
+                    fullWidth
+                    placeholder="vision, tool_use, streaming, json_mode"
+                  />
+                </div>
+              </div>
+
+              <label className="flex items-center gap-2 text-xs text-text-dimmed">
+                <input
+                  type="checkbox"
+                  name="isHidden"
+                  checked={isHidden}
+                  onChange={(e) => setIsHidden(e.target.checked)}
+                />
+                Hidden (exclude from model registry)
+              </label>
+            </div>
+
+            {/* Pricing tiers */}
+            <div className="space-y-3">
+              <div className="flex items-center justify-between">
+                <label className="text-sm font-medium text-text-bright">Pricing Tiers</label>
+                <Button
+                  type="button"
+                  variant="tertiary/small"
+                  onClick={() =>
+                    setTiers([
+                      ...tiers,
+                      {
+                        name: `Tier ${tiers.length + 1}`,
+                        isDefault: tiers.length === 0,
+                        priority: tiers.length,
+                        conditions: [],
+                        prices: {},
+                      },
+                    ])
+                  }
+                >
+                  Add tier
+                </Button>
+              </div>
+
+              {tiers.map((tier, tierIdx) => (
+                <TierEditor
+                  key={tierIdx}
+                  tier={tier}
+                  onChange={(updated) => {
+                    const next = [...tiers];
+                    next[tierIdx] = updated;
+                    setTiers(next);
+                  }}
+                  onRemove={() => setTiers(tiers.filter((_, i) => i !== tierIdx))}
+                />
+              ))}
+            </div>
+
+            {actionData?.error && (
+              <div className="rounded-md bg-red-500/10 border border-red-500/30 p-3 text-sm text-red-400">
+                {actionData.error}
+                {actionData.details && (
+                  <pre className="mt-1 text-xs text-red-300/70 overflow-auto">
+                    {JSON.stringify(actionData.details, null, 2)}
+                  </pre>
+                )}
+              </div>
+            )}
+
+            <div className="flex items-center gap-2 border-t border-grid-dimmed pt-4">
+              <Button type="submit" variant="primary/medium">
+                Create model
+              </Button>
+              <LinkButton to="/admin/llm-models" variant="tertiary/medium">
+                Cancel
+              </LinkButton>
+            </div>
+          </div>
+        </Form>
+      </div>
+    </main>
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Shared tier editor (duplicated from detail page — could be extracted later)
+// ---------------------------------------------------------------------------
+
+type TierData = {
+  name: string;
+  isDefault: boolean;
+  priority: number;
+  conditions: Array<{ usageDetailPattern: string; operator: string; value: number }>;
+  prices: Record<string, number>;
+};
+
+const COMMON_USAGE_TYPES = [
+  "input",
+  "output",
+  "input_cached_tokens",
+  "cache_creation_input_tokens",
+  "reasoning_tokens",
+];
+
+function TierEditor({
+  tier,
+  onChange,
+  onRemove,
+}: {
+  tier: TierData;
+  onChange: (t: TierData) => void;
+  onRemove: () => void;
+}) {
+  const [newUsageType, setNewUsageType] = useState("");
+
+  return (
+    <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-3 space-y-3">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <input
+            className="bg-charcoal-750 text-text-bright rounded px-2 py-1 text-sm border border-grid-dimmed"
+            value={tier.name}
+            onChange={(e) => onChange({ ...tier, name: e.target.value })}
+            placeholder="Tier name"
+          />
+          <label className="flex items-center gap-1 text-xs text-text-dimmed">
+            <input
+              type="checkbox"
+              checked={tier.isDefault}
+              onChange={(e) => onChange({ ...tier, isDefault: e.target.checked })}
+            />
+            Default
+          </label>
+          <label className="flex items-center gap-1 text-xs text-text-dimmed">
+            Priority:
+            <input
+              type="number"
+              className="w-12 bg-charcoal-750 text-text-bright rounded px-1 py-0.5 text-xs border border-grid-dimmed"
+              value={tier.priority}
+              onChange={(e) => onChange({ ...tier, priority: parseInt(e.target.value) || 0 })}
+            />
+          </label>
+        </div>
+        <button
+          type="button"
+          onClick={onRemove}
+          className="text-xs text-red-400 hover:text-red-300"
+        >
+          Remove tier
+        </button>
+      </div>
+
+      <div className="space-y-1">
+        <span className="text-xs font-medium text-text-dimmed">Prices (per token)</span>
+        <div className="space-y-1">
+          {Object.entries(tier.prices).map(([usageType, price]) => (
+            <div key={usageType} className="flex items-center gap-2">
+              <span className="w-48 text-xs font-mono text-text-dimmed">{usageType}</span>
+              <input
+                type="text"
+                className="w-32 bg-charcoal-750 text-text-bright rounded px-2 py-0.5 text-xs font-mono border border-grid-dimmed"
+                value={price}
+                onChange={(e) => {
+                  const val = parseFloat(e.target.value);
+                  if (!isNaN(val)) {
+                    onChange({ ...tier, prices: { ...tier.prices, [usageType]: val } });
+                  }
+                }}
+              />
+              <button
+                type="button"
+                onClick={() => {
+                  const { [usageType]: _, ...rest } = tier.prices;
+                  onChange({ ...tier, prices: rest });
+                }}
+                className="text-xs text-red-400 hover:text-red-300"
+              >
+                x
+              </button>
+            </div>
+          ))}
+        </div>
+
+        <div className="flex items-center gap-2 pt-1">
+          <select
+            className="bg-charcoal-750 text-text-dimmed rounded px-2 py-0.5 text-xs border border-grid-dimmed"
+            value={newUsageType}
+            onChange={(e) => setNewUsageType(e.target.value)}
+          >
+            <option value="">Add price...</option>
+            {COMMON_USAGE_TYPES.filter((t) => !(t in tier.prices)).map((t) => (
+              <option key={t} value={t}>
+                {t}
+              </option>
+            ))}
+            <option value="__custom">Custom...</option>
+          </select>
+          {newUsageType && (
+            <Button
+              type="button"
+              variant="tertiary/small"
+              onClick={() => {
+                const key =
+                  newUsageType === "__custom"
+                    ? prompt("Usage type name:") ?? ""
+                    : newUsageType;
+                if (key) {
+                  onChange({ ...tier, prices: { ...tier.prices, [key]: 0 } });
+                  setNewUsageType("");
+                }
+              }}
+            >
+              Add
+            </Button>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/admin.notifications.tsx b/apps/webapp/app/routes/admin.notifications.tsx
new file mode 100644
index 00000000000..d9b06816953
--- /dev/null
+++ b/apps/webapp/app/routes/admin.notifications.tsx
@@ -0,0 +1,1078 @@
+import { ChevronRightIcon, XMarkIcon } from "@heroicons/react/20/solid";
+import { useFetcher, useSearchParams } from "@remix-run/react";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { useRef, useState, useLayoutEffect } from "react";
+import ReactMarkdown from "react-markdown";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { Button } from "~/components/primitives/Buttons";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from "~/components/primitives/Dialog";
+import { Header3 } from "~/components/primitives/Headers";
+import { Input } from "~/components/primitives/Input";
+import { PaginationControls } from "~/components/primitives/Pagination";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Table,
+  TableBlankRow,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import {
+  createPlatformNotification,
+  getAdminNotificationsList,
+} from "~/services/platformNotifications.server";
+import { createSearchParams } from "~/utils/searchParams";
+import { cn } from "~/utils/cn";
+
+const PAGE_SIZE = 20;
+
+const WEBAPP_TYPES = ["card", "changelog"] as const;
+const CLI_TYPES = ["info", "warn", "error", "success"] as const;
+
+const SearchParams = z.object({
+  page: z.coerce.number().optional(),
+  hideArchived: z.coerce.boolean().optional(),
+});
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const searchParams = createSearchParams(request.url, SearchParams);
+  if (!searchParams.success) throw new Error(searchParams.error);
+  const { page: rawPage, hideArchived } = searchParams.params.getAll();
+  const page = rawPage ?? 1;
+
+  const data = await getAdminNotificationsList({ page, pageSize: PAGE_SIZE, hideArchived: hideArchived ?? false });
+
+  return typedjson({ ...data, userId });
+};
+
+export async function action({ request }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user?.admin) throw redirect("/");
+
+  const formData = await request.formData();
+  const _action = formData.get("_action");
+
+  if (_action === "create" || _action === "create-preview") {
+    return handleCreateAction(formData, userId, _action === "create-preview");
+  }
+
+  if (_action === "archive") {
+    return handleArchiveAction(formData);
+  }
+
+  return typedjson({ error: "Unknown action" }, { status: 400 });
+}
+
+async function handleCreateAction(formData: FormData, userId: string, isPreview: boolean) {
+  const surface = formData.get("surface") as string;
+  const payloadType = formData.get("payloadType") as string;
+  const adminLabel = formData.get("adminLabel") as string;
+  const title = formData.get("title") as string;
+  const description = formData.get("description") as string;
+  const actionUrl = (formData.get("actionUrl") as string) || undefined;
+  const image = (formData.get("image") as string) || undefined;
+  const dismissOnAction = formData.get("dismissOnAction") === "true";
+  const startsAt = formData.get("startsAt") as string;
+  const endsAt = formData.get("endsAt") as string;
+  const priority = Number(formData.get("priority") || "0");
+
+  if (!adminLabel || !title || !description || !endsAt || !surface || !payloadType) {
+    return typedjson({ error: "Missing required fields" }, { status: 400 });
+  }
+
+  const cliMaxShowCount = formData.get("cliMaxShowCount")
+    ? Number(formData.get("cliMaxShowCount"))
+    : undefined;
+  const cliMaxDaysAfterFirstSeen = formData.get("cliMaxDaysAfterFirstSeen")
+    ? Number(formData.get("cliMaxDaysAfterFirstSeen"))
+    : undefined;
+  const cliShowEvery = formData.get("cliShowEvery")
+    ? Number(formData.get("cliShowEvery"))
+    : undefined;
+
+  const discoveryFilePatterns = (formData.get("discoveryFilePatterns") as string) || "";
+  const discoveryContentPattern =
+    (formData.get("discoveryContentPattern") as string) || undefined;
+  const discoveryMatchBehavior = (formData.get("discoveryMatchBehavior") as string) || "";
+
+  const discovery =
+    discoveryFilePatterns && discoveryMatchBehavior
+      ? {
+          filePatterns: discoveryFilePatterns
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+          ...(discoveryContentPattern ? { contentPattern: discoveryContentPattern } : {}),
+          matchBehavior: discoveryMatchBehavior as "show-if-found" | "show-if-not-found",
+        }
+      : undefined;
+
+  const result = await createPlatformNotification({
+    title: isPreview ? `[Preview] ${adminLabel}` : adminLabel,
+    payload: {
+      version: "1" as const,
+      data: {
+        type: payloadType as "info" | "warn" | "error" | "success" | "card" | "changelog",
+        title,
+        description,
+        ...(actionUrl ? { actionUrl } : {}),
+        ...(image ? { image } : {}),
+        ...(dismissOnAction ? { dismissOnAction: true } : {}),
+        ...(discovery ? { discovery } : {}),
+      },
+    },
+    surface: surface as "CLI" | "WEBAPP",
+    scope: isPreview ? "USER" : "GLOBAL",
+    ...(isPreview ? { userId } : {}),
+    startsAt: isPreview
+      ? new Date().toISOString()
+      : startsAt
+        ? new Date(startsAt + "Z").toISOString()
+        : new Date().toISOString(),
+    endsAt: isPreview
+      ? new Date(Date.now() + 60 * 60 * 1000).toISOString()
+      : new Date(endsAt + "Z").toISOString(),
+    priority,
+    ...(surface === "CLI"
+      ? isPreview
+        ? { cliMaxShowCount: 1 }
+        : {
+            cliMaxShowCount,
+            cliMaxDaysAfterFirstSeen,
+            cliShowEvery,
+          }
+      : {}),
+  });
+
+  if (result.isErr()) {
+    const err = result.error;
+    if (err.type === "validation") {
+      return typedjson(
+        { error: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ") },
+        { status: 400 }
+      );
+    }
+    return typedjson({ error: err.message }, { status: 500 });
+  }
+
+  if (isPreview) {
+    return typedjson({ success: true, previewId: result.value.id });
+  }
+  return typedjson({ success: true, id: result.value.id });
+}
+
+async function handleArchiveAction(formData: FormData) {
+  const notificationId = formData.get("notificationId") as string;
+  if (!notificationId) {
+    return typedjson({ error: "Missing notificationId" }, { status: 400 });
+  }
+
+  await prisma.platformNotification.update({
+    where: { id: notificationId },
+    data: { archivedAt: new Date() },
+  });
+
+  return typedjson({ success: true });
+}
+
+export default function AdminNotificationsRoute() {
+  const { notifications, total, page, pageCount } = useTypedLoaderData<typeof loader>();
+  const [showCreate, setShowCreate] = useState(false);
+  const createFetcher = useFetcher<{
+    success?: boolean;
+    error?: string;
+    id?: string;
+    previewId?: string;
+  }>();
+  const archiveFetcher = useFetcher<{ success?: boolean; error?: string }>();
+  const [surface, setSurface] = useState<"CLI" | "WEBAPP">("WEBAPP");
+  const [title, setTitle] = useState("");
+  const [description, setDescription] = useState("");
+  const [actionUrl, setActionUrl] = useState("");
+  const [image, setImage] = useState("");
+  const [payloadType, setPayloadType] = useState<string>("card");
+  const [detailNotification, setDetailNotification] = useState<(typeof notifications)[number] | null>(null);
+
+  const typeOptions = surface === "WEBAPP" ? WEBAPP_TYPES : CLI_TYPES;
+
+  // Reset type when surface changes if current type isn't valid for new surface
+  const handleSurfaceChange = (newSurface: "CLI" | "WEBAPP") => {
+    setSurface(newSurface);
+    const newTypes = newSurface === "WEBAPP" ? WEBAPP_TYPES : CLI_TYPES;
+    if (!newTypes.includes(payloadType as any)) {
+      setPayloadType(newTypes[0]);
+    }
+  };
+
+  const [urlSearchParams, setUrlSearchParams] = useSearchParams();
+  const hideArchived = urlSearchParams.get("hideArchived") === "true";
+
+  const toggleHideArchived = () => {
+    setUrlSearchParams((prev) => {
+      const next = new URLSearchParams(prev);
+      if (hideArchived) {
+        next.delete("hideArchived");
+      } else {
+        next.set("hideArchived", "true");
+      }
+      next.delete("page");
+      return next;
+    });
+  };
+
+  return (
+    <main className="flex h-full min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
+      <div className="space-y-4">
+        <div className="flex items-center justify-end">
+          <Button variant="primary/small" onClick={() => setShowCreate((v) => !v)}>
+            {showCreate ? "Hide form" : "Create Notification"}
+          </Button>
+        </div>
+
+        {showCreate && (
+          <div className="rounded-md border border-grid-dimmed bg-charcoal-800 p-4 space-y-3">
+            <createFetcher.Form method="post" className="space-y-3">
+
+              <div className="flex gap-3">
+                <div className="flex-1">
+                  <label className="text-xs font-medium text-text-dimmed">Admin Label</label>
+                  <Input
+                    name="adminLabel"
+                    variant="medium"
+                    fullWidth
+                    placeholder="Internal name for this notification"
+                    className="mt-1"
+                  />
+                </div>
+
+                <div className="w-28">
+                  <label className="text-xs font-medium text-text-dimmed">Surface</label>
+                  <select
+                    name="surface"
+                    value={surface}
+                    onChange={(e) => handleSurfaceChange(e.target.value as "CLI" | "WEBAPP")}
+                    className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright"
+                  >
+                    <option value="WEBAPP">WEBAPP</option>
+                    <option value="CLI">CLI</option>
+                  </select>
+                </div>
+
+                <div className="w-28">
+                  <label className="text-xs font-medium text-text-dimmed">Type</label>
+                  <select
+                    name="payloadType"
+                    value={payloadType}
+                    onChange={(e) => setPayloadType(e.target.value)}
+                    className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright"
+                  >
+                    {typeOptions.map((t) => (
+                      <option key={t} value={t}>
+                        {t}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+
+                <div className="w-16">
+                  <label className="text-xs font-medium text-text-dimmed">Priority</label>
+                  <Input
+                    name="priority"
+                    variant="medium"
+                    fullWidth
+                    defaultValue="0"
+                    type="number"
+                    className="mt-1"
+                  />
+                </div>
+              </div>
+
+              {/* CLI live preview */}
+              {surface === "CLI" && (title || description) && (
+                <div>
+                  <p className="text-[10px] font-medium text-text-dimmed/60 uppercase tracking-wider mb-1">
+                    CLI Preview
+                  </p>
+                  <div className="rounded border border-grid-dimmed bg-charcoal-900 p-3 font-mono text-xs leading-relaxed">
+                    {title && (
+                      <p className="font-bold text-text-bright">
+                        <CliColorMarkup text={title} fallbackClass="text-text-bright" />
+                      </p>
+                    )}
+                    {description && (
+                      <p className="text-text-dimmed">
+                        <CliColorMarkup text={description} fallbackClass="text-text-dimmed" />
+                      </p>
+                    )}
+                    {actionUrl && (
+                      <p className="text-text-dimmed underline">{actionUrl}</p>
+                    )}
+                  </div>
+                </div>
+              )}
+
+              <div>
+                <label className="text-xs font-medium text-text-dimmed">Title</label>
+                <Input
+                  name="title"
+                  variant="medium"
+                  fullWidth
+                  placeholder="Notification title"
+                  className="mt-1"
+                  value={title}
+                  onChange={(e) => setTitle(e.target.value)}
+                />
+              </div>
+
+              {/* Description + live preview (webapp only) */}
+              <div>
+                <label className="text-xs font-medium text-text-dimmed">
+                  Description{surface === "WEBAPP" ? " (markdown)" : ""}
+                </label>
+                {surface === "WEBAPP" ? (
+                  <div className="mt-1 flex gap-3">
+                    <textarea
+                      name="description"
+                      value={description}
+                      onChange={(e) => setDescription(e.target.value)}
+                      rows={6}
+                      placeholder="Supports **bold**, *italic*, `code`, [links](url)..."
+                      className="block min-w-0 flex-1 rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright placeholder:text-text-dimmed/50 font-mono resize-y"
+                    />
+                    <div className="shrink-0">
+                      <div className="text-[10px] font-medium text-text-dimmed/60 uppercase tracking-wider mb-1">
+                        Preview
+                      </div>
+                      <div className="w-56">
+                        <NotificationPreviewCard
+                          title={title || "Notification title"}
+                          description={description || "Description preview will appear here..."}
+                          actionUrl={actionUrl || undefined}
+                          image={image || undefined}
+                        />
+                      </div>
+                    </div>
+                  </div>
+                ) : (
+                  <textarea
+                    name="description"
+                    value={description}
+                    onChange={(e) => setDescription(e.target.value)}
+                    rows={6}
+                    placeholder="Plain text description..."
+                    className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright placeholder:text-text-dimmed/50 font-mono resize-y"
+                  />
+                )}
+              </div>
+
+              {/* Action URL + dismiss on action (webapp gets both in one row) */}
+              {surface === "WEBAPP" ? (
+                <div className="flex items-end gap-3">
+                  <div className="flex-1">
+                    <label className="text-xs font-medium text-text-dimmed">Action URL (optional)</label>
+                    <Input
+                      name="actionUrl"
+                      variant="medium"
+                      fullWidth
+                      placeholder="https://..."
+                      className="mt-1"
+                      value={actionUrl}
+                      onChange={(e) => setActionUrl(e.target.value)}
+                    />
+                  </div>
+                  <label className="flex items-center gap-2 pb-1.5 text-xs text-text-dimmed whitespace-nowrap">
+                    <input
+                      type="checkbox"
+                      name="dismissOnAction"
+                      value="true"
+                      className="rounded border-grid-dimmed bg-charcoal-900"
+                    />
+                    Dismiss on action click
+                  </label>
+                </div>
+              ) : (
+                <div>
+                  <label className="text-xs font-medium text-text-dimmed">Action URL (optional)</label>
+                  <Input
+                    name="actionUrl"
+                    variant="medium"
+                    fullWidth
+                    placeholder="https://..."
+                    className="mt-1"
+                    value={actionUrl}
+                    onChange={(e) => setActionUrl(e.target.value)}
+                  />
+                </div>
+              )}
+
+              {surface === "WEBAPP" && (
+                <div>
+                  <label className="text-xs font-medium text-text-dimmed">Image URL (optional)</label>
+                  <Input
+                    name="image"
+                    variant="medium"
+                    fullWidth
+                    placeholder="https://example.com/image.png"
+                    className="mt-1"
+                    value={image}
+                    onChange={(e) => setImage(e.target.value)}
+                  />
+                </div>
+              )}
+
+              <div className="grid grid-cols-2 gap-3">
+                <div>
+                  <label className="text-xs font-medium text-text-dimmed">Starts At (UTC)</label>
+                  <input
+                    name="startsAt"
+                    type="datetime-local"
+                    defaultValue={defaultStartsAt()}
+                    className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright"
+                  />
+                </div>
+                <div>
+                  <label className="text-xs font-medium text-text-dimmed">Ends At (UTC)</label>
+                  <input
+                    name="endsAt"
+                    type="datetime-local"
+                    defaultValue={defaultEndsAt()}
+                    className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright"
+                    required
+                  />
+                </div>
+              </div>
+
+              {surface === "CLI" && (
+                <>
+                <div className="grid grid-cols-3 gap-3 rounded border border-grid-dimmed bg-charcoal-900 p-3">
+                  <div>
+                    <label className="text-xs font-medium text-text-dimmed">Max Show Count</label>
+                    <Input
+                      name="cliMaxShowCount"
+                      variant="medium"
+                      fullWidth
+                      type="number"
+                      placeholder="e.g. 5"
+                      className="mt-1"
+                    />
+                  </div>
+                  <div>
+                    <label className="text-xs font-medium text-text-dimmed">
+                      Max Days After First Seen
+                    </label>
+                    <Input
+                      name="cliMaxDaysAfterFirstSeen"
+                      variant="medium"
+                      fullWidth
+                      type="number"
+                      placeholder="e.g. 7"
+                      className="mt-1"
+                    />
+                  </div>
+                  <div>
+                    <label className="text-xs font-medium text-text-dimmed">Show Every (Nth)</label>
+                    <Input
+                      name="cliShowEvery"
+                      variant="medium"
+                      fullWidth
+                      type="number"
+                      placeholder="e.g. 3"
+                      className="mt-1"
+                    />
+                  </div>
+                </div>
+
+                <div className="rounded border border-grid-dimmed bg-charcoal-900 p-3 space-y-3">
+                  <div className="text-xs font-medium text-text-dimmed">
+                    Discovery (optional) — only show notification if file pattern matches
+                  </div>
+                  <div className="grid grid-cols-3 gap-3">
+                    <div>
+                      <label className="text-xs font-medium text-text-dimmed">File Patterns</label>
+                      <Input
+                        name="discoveryFilePatterns"
+                        variant="medium"
+                        fullWidth
+                        placeholder="trigger.config.ts, trigger.config.js"
+                        className="mt-1"
+                      />
+                      <span className="text-[10px] text-text-dimmed/60">Comma-separated</span>
+                    </div>
+                    <div>
+                      <label className="text-xs font-medium text-text-dimmed">Content Pattern</label>
+                      <Input
+                        name="discoveryContentPattern"
+                        variant="medium"
+                        fullWidth
+                        placeholder="e.g. syncVercelEnvVars"
+                        className="mt-1"
+                      />
+                      <span className="text-[10px] text-text-dimmed/60">Regex (optional)</span>
+                    </div>
+                    <div>
+                      <label className="text-xs font-medium text-text-dimmed">Match Behavior</label>
+                      <select
+                        name="discoveryMatchBehavior"
+                        className="mt-1 block w-full rounded-sm border border-grid-dimmed bg-charcoal-900 px-2 py-1.5 text-sm text-text-bright"
+                      >
+                        <option value="">— none —</option>
+                        <option value="show-if-found">show-if-found</option>
+                        <option value="show-if-not-found">show-if-not-found</option>
+                      </select>
+                    </div>
+                  </div>
+                </div>
+                </>
+              )}
+
+              <div className="flex items-center gap-2">
+                <Button
+                  type="submit"
+                  name="_action"
+                  value="create"
+                  variant="primary/small"
+                  disabled={createFetcher.state !== "idle"}
+                >
+                  {createFetcher.state !== "idle" ? "Creating..." : "Create"}
+                </Button>
+                <Button
+                  type="submit"
+                  name="_action"
+                  value="create-preview"
+                  variant="tertiary/small"
+                  disabled={createFetcher.state !== "idle"}
+                >
+                  Send Preview to Me
+                </Button>
+                {createFetcher.data?.error && (
+                  <span className="text-xs text-red-400">{createFetcher.data.error}</span>
+                )}
+                {createFetcher.data?.success && !createFetcher.data.previewId && (
+                  <span className="text-xs text-green-400">Created successfully</span>
+                )}
+                {createFetcher.data?.previewId && (
+                  <span className="text-xs text-green-400">
+                    Preview sent (ID: {createFetcher.data.previewId})
+                  </span>
+                )}
+              </div>
+            </createFetcher.Form>
+          </div>
+        )}
+
+        <div className="flex items-center justify-between">
+          <Paragraph className="text-text-dimmed">
+            {total} notifications (page {page} of {pageCount || 1})
+          </Paragraph>
+          <label className="flex items-center gap-2 text-xs text-text-dimmed">
+            <input
+              type="checkbox"
+              checked={hideArchived}
+              onChange={toggleHideArchived}
+              className="rounded border-grid-dimmed bg-charcoal-900"
+            />
+            Hide archived
+          </label>
+        </div>
+
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHeaderCell>Title</TableHeaderCell>
+              <TableHeaderCell>Surface</TableHeaderCell>
+              <TableHeaderCell>Scope</TableHeaderCell>
+              <TableHeaderCell>Type</TableHeaderCell>
+              <TableHeaderCell>Starts (UTC)</TableHeaderCell>
+              <TableHeaderCell>Ends (UTC)</TableHeaderCell>
+              <TableHeaderCell>Seen</TableHeaderCell>
+              <TableHeaderCell>Clicked</TableHeaderCell>
+              <TableHeaderCell>Dismissed</TableHeaderCell>
+              <TableHeaderCell>Actions</TableHeaderCell>
+              <TableHeaderCell>Status</TableHeaderCell>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {notifications.length === 0 ? (
+              <TableBlankRow colSpan={10}>
+                <Paragraph>No notifications found</Paragraph>
+              </TableBlankRow>
+            ) : (
+              notifications.map((n) => {
+                const status = getNotificationStatus(n);
+                const isActive = status === "active";
+                return (
+                  <TableRow key={n.id}>
+                    <TableCell>
+                      <button
+                        type="button"
+                        onClick={() => setDetailNotification(n)}
+                        className="text-sm font-medium text-text-bright hover:text-indigo-400 transition-colors text-left"
+                      >
+                        {n.title}
+                      </button>
+                    </TableCell>
+                    <TableCell>
+                      <Badge color={n.surface === "CLI" ? "amber" : "blue"}>{n.surface}</Badge>
+                    </TableCell>
+                    <TableCell>
+                      <Badge color={n.scope === "GLOBAL" ? "green" : "gray"}>{n.scope}</Badge>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs text-text-dimmed">{n.payloadType ?? "—"}</span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs text-text-dimmed">{formatDate(n.startsAt)}</span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs text-text-dimmed">{formatDate(n.endsAt)}</span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs font-mono">{n.stats.seen}</span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs font-mono">{n.stats.clicked}</span>
+                    </TableCell>
+                    <TableCell>
+                      <span className="text-xs font-mono">{n.stats.dismissed}</span>
+                    </TableCell>
+                    <TableCell>
+                      {isActive && (
+                        <archiveFetcher.Form method="post" className="inline">
+                          <input type="hidden" name="_action" value="archive" />
+                          <input type="hidden" name="notificationId" value={n.id} />
+                          <Button
+                            type="submit"
+                            variant="danger/small"
+                            disabled={archiveFetcher.state !== "idle"}
+                          >
+                            Archive
+                          </Button>
+                        </archiveFetcher.Form>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <StatusBadge status={status} />
+                    </TableCell>
+                  </TableRow>
+                );
+              })
+            )}
+          </TableBody>
+        </Table>
+
+        <PaginationControls currentPage={page} totalPages={pageCount} />
+      </div>
+
+      <Dialog
+        open={detailNotification !== null}
+        onOpenChange={(open) => {
+          if (!open) setDetailNotification(null);
+        }}
+      >
+        <DialogContent className="max-w-lg">
+          {detailNotification && (
+            <>
+              <DialogHeader>
+                <DialogTitle>{detailNotification.title}</DialogTitle>
+              </DialogHeader>
+              <NotificationDetailContent notification={detailNotification} />
+            </>
+          )}
+        </DialogContent>
+      </Dialog>
+    </main>
+  );
+}
+
+function NotificationDetailContent({
+  notification: n,
+}: {
+  notification: {
+    id: string;
+    friendlyId: string;
+    surface: string;
+    scope: string;
+    priority: number;
+    startsAt: Date;
+    endsAt: Date;
+    archivedAt: Date | null;
+    createdAt: Date;
+    payloadTitle: string | null;
+    payloadType: string | null;
+    payloadDescription: string | null;
+    payloadActionUrl: string | null | undefined;
+    payloadImage: string | null | undefined;
+    cliMaxShowCount: number | null;
+    cliMaxDaysAfterFirstSeen: number | null;
+    cliShowEvery: number | null;
+    stats: { seen: number; clicked: number; dismissed: number };
+  };
+}) {
+  return (
+    <div className="space-y-4">
+      {/* Preview */}
+      {n.payloadTitle && n.payloadDescription && (
+        <div>
+          <p className="mb-1 text-xs font-medium text-text-dimmed">Preview</p>
+          {n.surface === "WEBAPP" ? (
+            <NotificationPreviewCard
+              title={n.payloadTitle}
+              description={n.payloadDescription}
+              actionUrl={n.payloadActionUrl ?? undefined}
+              image={n.payloadImage ?? undefined}
+            />
+          ) : (
+            <div className="rounded border border-grid-dimmed bg-charcoal-900 p-3 font-mono text-xs leading-relaxed">
+              <p className="font-bold text-text-bright">
+                <CliColorMarkup text={n.payloadTitle} fallbackClass="text-text-bright" />
+              </p>
+              <p className="text-text-dimmed">
+                <CliColorMarkup text={n.payloadDescription} fallbackClass="text-text-dimmed" />
+              </p>
+              {n.payloadActionUrl && (
+                <p className="text-text-dimmed underline">{n.payloadActionUrl}</p>
+              )}
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Details grid */}
+      <div className="grid grid-cols-2 gap-x-4 gap-y-2 text-xs">
+        <DetailRow label="ID" value={n.friendlyId} />
+        <DetailRow label="Surface" value={n.surface} />
+        <DetailRow label="Scope" value={n.scope} />
+        <DetailRow label="Type" value={n.payloadType ?? "—"} />
+        <DetailRow label="Priority" value={String(n.priority)} />
+        <DetailRow label="Created" value={formatDate(n.createdAt)} />
+        <DetailRow label="Starts" value={formatDate(n.startsAt)} />
+        <DetailRow label="Ends" value={formatDate(n.endsAt)} />
+        {n.archivedAt && <DetailRow label="Archived" value={formatDate(n.archivedAt)} />}
+        {n.payloadActionUrl && <DetailRow label="Action URL" value={n.payloadActionUrl} />}
+      </div>
+
+      {/* CLI settings */}
+      {n.surface === "CLI" && (n.cliMaxShowCount || n.cliMaxDaysAfterFirstSeen || n.cliShowEvery) && (
+        <div>
+          <p className="mb-1 text-xs font-medium text-text-dimmed">CLI Settings</p>
+          <div className="grid grid-cols-2 gap-x-4 gap-y-2 text-xs">
+            {n.cliMaxShowCount != null && (
+              <DetailRow label="Max show count" value={String(n.cliMaxShowCount)} />
+            )}
+            {n.cliMaxDaysAfterFirstSeen != null && (
+              <DetailRow label="Max days after first seen" value={String(n.cliMaxDaysAfterFirstSeen)} />
+            )}
+            {n.cliShowEvery != null && (
+              <DetailRow label="Show every N-th" value={String(n.cliShowEvery)} />
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* Stats */}
+      <div>
+        <p className="mb-1 text-xs font-medium text-text-dimmed">Stats</p>
+        <div className="grid grid-cols-3 gap-2">
+          <StatCard label="Seen" value={n.stats.seen} />
+          <StatCard label="Clicked" value={n.stats.clicked} />
+          <StatCard label="Dismissed" value={n.stats.dismissed} />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function DetailRow({ label, value }: { label: string; value: string }) {
+  return (
+    <>
+      <span className="text-text-dimmed">{label}</span>
+      <span className="text-text-bright break-all">{value}</span>
+    </>
+  );
+}
+
+function StatCard({ label, value }: { label: string; value: number }) {
+  return (
+    <div className="rounded border border-grid-dimmed bg-charcoal-900 p-2 text-center">
+      <p className="text-lg font-mono font-medium text-text-bright">{value}</p>
+      <p className="text-xs text-text-dimmed">{label}</p>
+    </div>
+  );
+}
+
+// Mirrors NotificationCard from NotificationPanel.tsx — static preview, no interactions
+function NotificationPreviewCard({
+  title,
+  description,
+  actionUrl,
+  image,
+}: {
+  title: string;
+  description: string;
+  actionUrl?: string;
+  image?: string;
+}) {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const [isOverflowing, setIsOverflowing] = useState(false);
+  const descriptionRef = useRef<HTMLDivElement>(null);
+
+  useLayoutEffect(() => {
+    const el = descriptionRef.current;
+    if (el) {
+      setIsOverflowing(el.scrollHeight > el.clientHeight);
+    }
+  }, [description]);
+
+  const Wrapper = actionUrl ? "a" : "div";
+  const wrapperProps = actionUrl
+    ? { href: actionUrl, target: "_blank" as const, rel: "noopener noreferrer" as const }
+    : {};
+
+  return (
+    <Wrapper
+      {...wrapperProps}
+      className="group/card group relative block overflow-hidden rounded border transition-colors border-grid-bright bg-charcoal-750/50 no-underline"
+    >
+      <div className="relative flex items-start gap-1 px-2 pt-1.5">
+        <Header3 className="flex-1 !text-xs">{title}</Header3>
+        <button
+          type="button"
+          className="shrink-0 rounded p-0.5 text-text-dimmed transition-colors hover:bg-charcoal-700 hover:text-text-bright"
+          tabIndex={-1}
+        >
+          <XMarkIcon className="size-3.5" />
+        </button>
+      </div>
+
+      <div className="relative px-2 pb-2">
+        <div className="flex gap-1">
+          <div className="min-w-0 flex-1">
+            <div ref={descriptionRef} className={cn(!isExpanded && "line-clamp-3")}>
+              <ReactMarkdown components={markdownComponents}>{description}</ReactMarkdown>
+            </div>
+            {(isOverflowing || isExpanded) && (
+              <button
+                type="button"
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                  setIsExpanded((v) => !v);
+                }}
+                className="mt-0.5 text-xs text-indigo-400 hover:text-indigo-300"
+              >
+                {isExpanded ? "Show less" : "Show more"}
+              </button>
+            )}
+          </div>
+          {actionUrl && (
+            <div className="mt-1 flex shrink-0 items-center pb-1 text-text-dimmed group-hover/card:text-text-bright transition-colors">
+              <ChevronRightIcon className="size-4" />
+            </div>
+          )}
+        </div>
+
+        {image && (
+          <img src={sanitizeImageUrl(image)} alt="" className="mt-1.5 rounded px-2 pb-2" />
+        )}
+      </div>
+    </Wrapper>
+  );
+}
+
+const markdownComponents = {
+  p: ({ children }: { children?: React.ReactNode }) => (
+    <p className="my-0.5 text-xs leading-relaxed text-text-dimmed">{children}</p>
+  ),
+  a: ({ href, children }: { href?: string; children?: React.ReactNode }) => (
+    <a
+      href={href}
+      target="_blank"
+      rel="noopener noreferrer"
+      className="text-indigo-400 underline hover:text-indigo-300 transition-colors"
+      onClick={(e) => e.stopPropagation()}
+    >
+      {children}
+    </a>
+  ),
+  strong: ({ children }: { children?: React.ReactNode }) => (
+    <strong className="font-semibold text-text-bright">{children}</strong>
+  ),
+  em: ({ children }: { children?: React.ReactNode }) => <em>{children}</em>,
+  code: ({ children }: { children?: React.ReactNode }) => (
+    <code className="rounded bg-charcoal-700 px-1 py-0.5 text-[11px]">{children}</code>
+  ),
+};
+
+const CLI_COLOR_MAP: Record<string, string> = {
+  red: "text-red-500",
+  green: "text-green-500",
+  yellow: "text-yellow-500",
+  blue: "text-blue-500",
+  magenta: "text-fuchsia-500",
+  cyan: "text-cyan-500",
+  white: "text-white",
+  gray: "text-gray-400",
+  redBright: "text-red-400",
+  greenBright: "text-green-400",
+  yellowBright: "text-yellow-400",
+  blueBright: "text-blue-400",
+  magentaBright: "text-fuchsia-400",
+  cyanBright: "text-cyan-400",
+  whiteBright: "text-white",
+  bold: "font-bold",
+};
+
+function CliColorMarkup({ text, fallbackClass }: { text: string; fallbackClass?: string }) {
+  const parts: React.ReactNode[] = [];
+  let pos = 0;
+  let key = 0;
+
+  while (pos < text.length) {
+    const braceIdx = text.indexOf("{", pos);
+    if (braceIdx === -1) {
+      parts.push(text.slice(pos));
+      break;
+    }
+
+    const closeIdx = text.indexOf("}", braceIdx);
+    if (closeIdx === -1) {
+      parts.push(text.slice(pos));
+      break;
+    }
+
+    const tagName = text.slice(braceIdx + 1, closeIdx);
+    if (CLI_COLOR_MAP[tagName]) {
+      // Found opening tag — look for matching close tag
+      const closeTag = `{/${tagName}}`;
+      const endIdx = text.indexOf(closeTag, closeIdx + 1);
+      if (endIdx !== -1) {
+        // Push text before the tag
+        if (braceIdx > pos) {
+          parts.push(<span key={key++} className={fallbackClass}>{text.slice(pos, braceIdx)}</span>);
+        }
+        // Push styled content
+        parts.push(
+          <span key={key++} className={CLI_COLOR_MAP[tagName]}>
+            {text.slice(closeIdx + 1, endIdx)}
+          </span>
+        );
+        pos = endIdx + closeTag.length;
+        continue;
+      }
+    }
+
+    // Not a recognized tag — treat as literal
+    parts.push(text.slice(pos, closeIdx + 1));
+    pos = closeIdx + 1;
+  }
+
+  return <>{parts}</>;
+}
+
+function Badge({
+  children,
+  color,
+}: {
+  children: React.ReactNode;
+  color: "amber" | "blue" | "green" | "gray";
+}) {
+  const colors = {
+    amber: "bg-amber-500/20 text-amber-400",
+    blue: "bg-blue-500/20 text-blue-400",
+    green: "bg-green-500/20 text-green-400",
+    gray: "bg-charcoal-700 text-text-dimmed",
+  };
+
+  return (
+    <span
+      className={`inline-flex rounded-sm px-1.5 py-0.5 text-[11px] font-medium ${colors[color]}`}
+    >
+      {children}
+    </span>
+  );
+}
+
+function formatDate(date: string | Date): string {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: "UTC",
+  });
+}
+
+function toDatetimeLocalUTC(date: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}`;
+}
+
+function defaultStartsAt(): string {
+  return toDatetimeLocalUTC(new Date(Date.now() + 24 * 60 * 60 * 1000));
+}
+
+function defaultEndsAt(): string {
+  return toDatetimeLocalUTC(new Date(Date.now() + 30 * 24 * 60 * 60 * 1000));
+}
+
+/** Sanitize image URL to prevent XSS via javascript: or data: URIs. */
+function sanitizeImageUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:" || parsed.protocol === "http:") {
+      return parsed.href;
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+type NotificationStatus = "active" | "pending" | "expired" | "archived";
+
+function getNotificationStatus(n: {
+  archivedAt: string | Date | null;
+  startsAt: string | Date;
+  endsAt: string | Date;
+}): NotificationStatus {
+  if (n.archivedAt) return "archived";
+  const now = new Date();
+  const starts = typeof n.startsAt === "string" ? new Date(n.startsAt) : n.startsAt;
+  const ends = typeof n.endsAt === "string" ? new Date(n.endsAt) : n.endsAt;
+  if (now < starts) return "pending";
+  if (now >= ends) return "expired";
+  return "active";
+}
+
+function StatusBadge({ status }: { status: NotificationStatus }) {
+  const styles: Record<NotificationStatus, string> = {
+    active: "bg-green-500/20 text-green-400",
+    pending: "bg-blue-500/20 text-blue-400",
+    expired: "bg-charcoal-700 text-text-dimmed",
+    archived: "bg-red-500/20 text-red-400",
+  };
+
+  return (
+    <span className={`inline-flex rounded-sm px-1.5 py-0.5 text-[11px] font-medium ${styles[status]}`}>
+      {status}
+    </span>
+  );
+}
diff --git a/apps/webapp/app/routes/admin.orgs.tsx b/apps/webapp/app/routes/admin.orgs.tsx
index afdcf5e97c9..6f496362947 100644
--- a/apps/webapp/app/routes/admin.orgs.tsx
+++ b/apps/webapp/app/routes/admin.orgs.tsx
@@ -2,7 +2,9 @@ import { MagnifyingGlassIcon } from "@heroicons/react/20/solid";
 import { Form } from "@remix-run/react";
 import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
+import { useState } from "react";
 import { z } from "zod";
+import { FeatureFlagsDialog } from "~/components/admin/FeatureFlagsDialog";
 import { Button, LinkButton } from "~/components/primitives/Buttons";
 import { CopyableText } from "~/components/primitives/CopyableText";
 import { Input } from "~/components/primitives/Input";
@@ -46,6 +48,15 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 export default function AdminDashboardRoute() {
   const { organizations, filters, page, pageCount } = useTypedLoaderData<typeof loader>();
 
+  const [flagsOrgId, setFlagsOrgId] = useState<string | null>(null);
+  const [flagsOpen, setFlagsOpen] = useState(false);
+  const flagsOrgTitle = organizations.find((o) => o.id === flagsOrgId)?.title ?? "";
+
+  const openFlagsDialog = (orgId: string) => {
+    setFlagsOrgId(orgId);
+    setFlagsOpen(true);
+  };
+
   return (
     <main
       aria-labelledby="primary-heading"
@@ -113,18 +124,25 @@ export default function AdminDashboardRoute() {
                     <TableCell>{org.v3Enabled ? "✅" : ""}</TableCell>
                     <TableCell>{org.deletedAt ? "☠️" : ""}</TableCell>
                     <TableCell isSticky={true}>
-                      <LinkButton
-                        to={`/@/orgs/${org.slug}`}
-                        className="mr-2"
-                        variant="tertiary/small"
-                        shortcut={
-                          organizations.length === 1
-                            ? { modifiers: ["mod"], key: "enter", enabledOnInputElements: true }
-                            : undefined
-                        }
-                      >
-                        Impersonate
-                      </LinkButton>
+                      <div className="flex items-center gap-2">
+                        <Button
+                          variant="tertiary/small"
+                          onClick={() => openFlagsDialog(org.id)}
+                        >
+                          Flags
+                        </Button>
+                        <LinkButton
+                          to={`/@/orgs/${org.slug}`}
+                          variant="tertiary/small"
+                          shortcut={
+                            organizations.length === 1
+                              ? { modifiers: ["mod"], key: "enter", enabledOnInputElements: true }
+                              : undefined
+                          }
+                        >
+                          Impersonate
+                        </LinkButton>
+                      </div>
                     </TableCell>
                   </TableRow>
                 );
@@ -135,6 +153,12 @@ export default function AdminDashboardRoute() {
 
         <PaginationControls currentPage={page} totalPages={pageCount} />
       </div>
+      <FeatureFlagsDialog
+        orgId={flagsOrgId}
+        orgTitle={flagsOrgTitle}
+        open={flagsOpen}
+        onOpenChange={setFlagsOpen}
+      />
     </main>
   );
 }
diff --git a/apps/webapp/app/routes/admin.tsx b/apps/webapp/app/routes/admin.tsx
index ac8e56c855e..4cd2deca533 100644
--- a/apps/webapp/app/routes/admin.tsx
+++ b/apps/webapp/app/routes/admin.tsx
@@ -32,6 +32,18 @@ export default function Page() {
               label: "Concurrency",
               to: "/admin/concurrency",
             },
+            {
+              label: "LLM Models",
+              to: "/admin/llm-models",
+            },
+            {
+              label: "Feature Flags",
+              to: "/admin/feature-flags",
+            },
+            {
+              label: "Notifications",
+              to: "/admin/notifications",
+            },
           ]}
           layoutId={"admin"}
         />
diff --git a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.progress.ts b/apps/webapp/app/routes/api.v1.deployments.$deploymentId.progress.ts
index 64f20f4f64d..2c78c59f552 100644
--- a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.progress.ts
+++ b/apps/webapp/app/routes/api.v1.deployments.$deploymentId.progress.ts
@@ -48,6 +48,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
       contentHash: body.data.contentHash,
       git: body.data.gitMeta,
       runtime: body.data.runtime,
+      buildServerMetadata: body.data.buildServerMetadata,
     })
     .match(
       () => {
diff --git a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts b/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts
index ca3417b75bb..d0593e564fd 100644
--- a/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts
+++ b/apps/webapp/app/routes/api.v1.deployments.$deploymentId.ts
@@ -39,6 +39,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
           tasks: true,
         },
       },
+      integrationDeployments: true,
     },
   });
 
@@ -54,6 +55,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     version: deployment.version,
     imageReference: deployment.imageReference,
     imagePlatform: deployment.imagePlatform,
+    commitSHA: deployment.commitSHA,
     externalBuildData:
       deployment.externalBuildData as GetDeploymentResponseBody["externalBuildData"],
     errorData: deployment.errorData as GetDeploymentResponseBody["errorData"],
@@ -69,5 +71,15 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
           })),
         }
       : undefined,
+    integrationDeployments:
+      deployment.integrationDeployments.length > 0
+        ? deployment.integrationDeployments.map((id) => ({
+            id: id.id,
+            integrationName: id.integrationName,
+            integrationDeploymentId: id.integrationDeploymentId,
+            commitSHA: id.commitSHA,
+            createdAt: id.createdAt,
+          }))
+        : undefined,
   } satisfies GetDeploymentResponseBody);
 }
diff --git a/apps/webapp/app/routes/api.v1.deployments.$deploymentVersion.promote.ts b/apps/webapp/app/routes/api.v1.deployments.$deploymentVersion.promote.ts
index 24f8e74a5ed..893b260dc82 100644
--- a/apps/webapp/app/routes/api.v1.deployments.$deploymentVersion.promote.ts
+++ b/apps/webapp/app/routes/api.v1.deployments.$deploymentVersion.promote.ts
@@ -32,6 +32,9 @@ export async function action({ request, params }: ActionFunctionArgs) {
 
   const authenticatedEnv = authenticationResult.environment;
 
+  const url = new URL(request.url);
+  const allowRollbacks = url.searchParams.get("allowRollbacks") === "true";
+
   const { deploymentVersion } = parsedParams.data;
 
   const deployment = await prisma.workerDeployment.findFirst({
@@ -47,7 +50,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
 
   try {
     const service = new ChangeCurrentDeploymentService();
-    await service.call(deployment, "promote");
+    await service.call(deployment, "promote", allowRollbacks);
 
     return json(
       {
diff --git a/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts b/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts
new file mode 100644
index 00000000000..aaf54685888
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.orgs.$organizationSlug.projects.$projectParam.vercel.projects.ts
@@ -0,0 +1,147 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { apiCors } from "~/utils/apiCors";
+import { logger } from "~/services/logger.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
+
+const ParamsSchema = z.object({
+  organizationSlug: z.string(),
+  projectParam: z.string(),
+});
+
+/**
+ * API endpoint to retrieve connected Vercel projects for a Trigger.dev project.
+ *
+ * GET /api/v1/orgs/:organizationSlug/projects/:projectParam/vercel/projects
+ *
+ * Returns:
+ * - vercelProject: The connected Vercel project details (if any)
+ * - config: The Vercel integration configuration
+ * - syncEnvVarsMapping: The environment variable sync mapping
+ */
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  // Handle CORS
+  if (request.method === "OPTIONS") {
+    return apiCors(request, json({}));
+  }
+
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return apiCors(
+      request,
+      json({ error: "Invalid or Missing Access Token" }, { status: 401 })
+    );
+  }
+
+  const parsedParams = ParamsSchema.safeParse(params);
+  if (!parsedParams.success) {
+    return apiCors(
+      request,
+      json({ error: "Invalid parameters" }, { status: 400 })
+    );
+  }
+
+  const { organizationSlug, projectParam } = parsedParams.data;
+
+  const result = await fromPromise(
+    (async () => {
+      // Find the project, verifying org membership
+      const project = await prisma.project.findFirst({
+        where: {
+          slug: projectParam,
+          organization: {
+            slug: organizationSlug,
+            members: {
+              some: {
+                userId: authenticationResult.userId,
+              },
+            },
+          },
+          deletedAt: null,
+        },
+        select: {
+          id: true,
+          name: true,
+          slug: true,
+          organizationId: true,
+        },
+      });
+
+      if (!project) {
+        return { type: "not_found" as const };
+      }
+
+      // Get Vercel integration for the project
+      const vercelService = new VercelIntegrationService();
+      const integration = await vercelService.getVercelProjectIntegration(project.id);
+
+      return { type: "success" as const, project, integration };
+    })(),
+    (error) => error
+  );
+
+  if (result.isErr()) {
+    logger.error("Failed to fetch Vercel projects", {
+      error: result.error,
+      organizationSlug,
+      projectParam,
+    });
+
+    return apiCors(
+      request,
+      json({ error: "Internal server error" }, { status: 500 })
+    );
+  }
+
+  if (result.value.type === "not_found") {
+    return apiCors(
+      request,
+      json({ error: "Project not found" }, { status: 404 })
+    );
+  }
+
+  const { project, integration } = result.value;
+
+  if (!integration) {
+    return apiCors(
+      request,
+      json({
+        connected: false,
+        vercelProject: null,
+        config: null,
+        syncEnvVarsMapping: null,
+      })
+    );
+  }
+
+  const { parsedIntegrationData } = integration;
+
+  return apiCors(
+    request,
+    json({
+      connected: true,
+      vercelProject: {
+        id: parsedIntegrationData.vercelProjectId,
+        name: parsedIntegrationData.vercelProjectName,
+        teamId: parsedIntegrationData.vercelTeamId,
+      },
+      config: {
+        atomicBuilds: parsedIntegrationData.config.atomicBuilds,
+        pullEnvVarsBeforeBuild: parsedIntegrationData.config.pullEnvVarsBeforeBuild,
+        vercelStagingEnvironment: parsedIntegrationData.config.vercelStagingEnvironment,
+      },
+      syncEnvVarsMapping: parsedIntegrationData.syncEnvVarsMapping,
+      triggerProject: {
+        id: project.id,
+        name: project.name,
+        slug: project.slug,
+      },
+    })
+  );
+}
+
diff --git a/apps/webapp/app/routes/api.v1.packets.$.ts b/apps/webapp/app/routes/api.v1.packets.$.ts
index 4632df09186..031f2854bbb 100644
--- a/apps/webapp/app/routes/api.v1.packets.$.ts
+++ b/apps/webapp/app/routes/api.v1.packets.$.ts
@@ -3,7 +3,7 @@ import { json } from "@remix-run/server-runtime";
 import { z } from "zod";
 import { authenticateApiRequest } from "~/services/apiAuth.server";
 import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
-import { generatePresignedUrl } from "~/v3/r2.server";
+import { generatePresignedUrl } from "~/v3/objectStore.server";
 
 const ParamsSchema = z.object({
   "*": z.string(),
@@ -29,7 +29,8 @@ export async function action({ request, params }: ActionFunctionArgs) {
     authenticationResult.environment.project.externalRef,
     authenticationResult.environment.slug,
     filename,
-    "PUT"
+    "PUT",
+    { forceNoPrefix: true }
   );
 
   if (!signed.success) {
diff --git a/apps/webapp/app/routes/api.v1.platform-notifications.ts b/apps/webapp/app/routes/api.v1.platform-notifications.ts
new file mode 100644
index 00000000000..7299c407383
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.platform-notifications.ts
@@ -0,0 +1,22 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { getNextCliNotification } from "~/services/platformNotifications.server";
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
+  }
+
+  const url = new URL(request.url);
+  const projectRef = url.searchParams.get("projectRef") ?? undefined;
+
+  const notification = await getNextCliNotification({
+    userId: authenticationResult.userId,
+    projectRef,
+  });
+
+  return json({ notification });
+}
diff --git a/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts b/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
index ad2372a654a..53bc4429c1d 100644
--- a/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
+++ b/apps/webapp/app/routes/api.v1.projects.$projectRef.envvars.$slug.import.ts
@@ -41,10 +41,13 @@ export async function action({ params, request }: ActionFunctionArgs) {
   const result = await repository.create(environment.project.id, {
     override: typeof body.override === "boolean" ? body.override : false,
     environmentIds: [environment.id],
+    // Pass parent environment ID so new variables can inherit isSecret from parent
+    parentEnvironmentId: environment.parentEnvironmentId ?? undefined,
     variables: Object.entries(body.variables).map(([key, value]) => ({
       key,
       value,
     })),
+    lastUpdatedBy: body.source,
   });
 
   // Only sync parent variables if this is a branch environment
@@ -56,6 +59,7 @@ export async function action({ params, request }: ActionFunctionArgs) {
         key,
         value,
       })),
+      lastUpdatedBy: body.source,
     });
 
     let childFailure = !result.success ? result : undefined;
diff --git a/apps/webapp/app/routes/api.v1.prompts.$slug.override.reactivate.ts b/apps/webapp/app/routes/api.v1.prompts.$slug.override.reactivate.ts
new file mode 100644
index 00000000000..1203682793a
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts.$slug.override.reactivate.ts
@@ -0,0 +1,71 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { PromptService } from "~/v3/services/promptService.server";
+
+const ParamsSchema = z.object({
+  slug: z.string(),
+});
+
+const Body = z.object({
+  version: z.number().int().positive(),
+});
+
+const { action } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    body: Body,
+    method: "POST",
+    allowJWT: true,
+    corsStrategy: "all",
+    authorization: {
+      action: "update",
+      resource: (params) => ({ prompts: params.slug }),
+      superScopes: ["admin"],
+    },
+  },
+  async ({ body, params, authentication }) => {
+    const prompt = await prisma.prompt.findUnique({
+      where: {
+        projectId_runtimeEnvironmentId_slug: {
+          projectId: authentication.environment.projectId,
+          runtimeEnvironmentId: authentication.environment.id,
+          slug: params.slug,
+        },
+      },
+    });
+
+    if (!prompt) {
+      return json({ error: "Prompt not found" }, { status: 404 });
+    }
+
+    const targetVersion = await prisma.promptVersion.findUnique({
+      where: {
+        promptId_version: {
+          promptId: prompt.id,
+          version: body.version,
+        },
+      },
+    });
+
+    if (!targetVersion) {
+      return json({ error: `Version ${body.version} not found` }, { status: 404 });
+    }
+
+    try {
+      const service = new PromptService();
+      await service.reactivateOverride(prompt.id, targetVersion.id);
+    } catch (e) {
+      if (e instanceof ServiceValidationError) {
+        return json({ error: e.message }, { status: e.status ?? 400 });
+      }
+      throw e;
+    }
+
+    return json({ ok: true });
+  }
+);
+
+export { action };
diff --git a/apps/webapp/app/routes/api.v1.prompts.$slug.override.ts b/apps/webapp/app/routes/api.v1.prompts.$slug.override.ts
new file mode 100644
index 00000000000..3ddf7b78416
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts.$slug.override.ts
@@ -0,0 +1,115 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { createMultiMethodApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { PromptService } from "~/v3/services/promptService.server";
+
+const ParamsSchema = z.object({
+  slug: z.string(),
+});
+
+const CreateBody = z.object({
+  textContent: z.string(),
+  model: z.string().optional(),
+  commitMessage: z.string().optional(),
+  source: z.string().optional(),
+});
+
+const UpdateBody = z.object({
+  textContent: z.string().optional(),
+  model: z.string().optional(),
+  commitMessage: z.string().optional(),
+});
+
+async function findPrompt(slug: string, authentication: { environment: { projectId: string; id: string } }) {
+  return prisma.prompt.findUnique({
+    where: {
+      projectId_runtimeEnvironmentId_slug: {
+        projectId: authentication.environment.projectId,
+        runtimeEnvironmentId: authentication.environment.id,
+        slug,
+      },
+    },
+  });
+}
+
+const { action, loader } = createMultiMethodApiRoute({
+  params: ParamsSchema,
+  allowJWT: true,
+  corsStrategy: "all",
+  authorization: {
+    action: "update",
+    resource: (params) => ({ prompts: params.slug }),
+    superScopes: ["admin"],
+  },
+  methods: {
+    POST: {
+      body: CreateBody,
+      handler: async ({ params, body, authentication }) => {
+        const prompt = await findPrompt(params.slug, authentication);
+        if (!prompt) return json({ error: "Prompt not found" }, { status: 404 });
+
+        const service = new PromptService();
+        const result = await service.createOverride(prompt.id, {
+          textContent: body.textContent,
+          model: body.model,
+          commitMessage: body.commitMessage,
+          source: body.source ?? "api",
+        });
+
+        return json({ ok: true, version: result.version });
+      },
+    },
+    PUT: {
+      body: UpdateBody,
+      handler: async ({ params, body, authentication }) => {
+        const prompt = await findPrompt(params.slug, authentication);
+        if (!prompt) return json({ error: "Prompt not found" }, { status: 404 });
+
+        try {
+          const service = new PromptService();
+          await service.updateOverride(prompt.id, body);
+        } catch (e) {
+          if (e instanceof ServiceValidationError) {
+            return json({ error: e.message }, { status: e.status ?? 400 });
+          }
+          throw e;
+        }
+
+        return json({ ok: true });
+      },
+    },
+    PATCH: {
+      body: UpdateBody,
+      handler: async ({ params, body, authentication }) => {
+        const prompt = await findPrompt(params.slug, authentication);
+        if (!prompt) return json({ error: "Prompt not found" }, { status: 404 });
+
+        try {
+          const service = new PromptService();
+          await service.updateOverride(prompt.id, body);
+        } catch (e) {
+          if (e instanceof ServiceValidationError) {
+            return json({ error: e.message }, { status: e.status ?? 400 });
+          }
+          throw e;
+        }
+
+        return json({ ok: true });
+      },
+    },
+    DELETE: {
+      handler: async ({ params, authentication }) => {
+        const prompt = await findPrompt(params.slug, authentication);
+        if (!prompt) return json({ error: "Prompt not found" }, { status: 404 });
+
+        const service = new PromptService();
+        await service.removeOverride(prompt.id);
+        return json({ ok: true });
+      },
+    },
+  },
+});
+
+export { action, loader };
diff --git a/apps/webapp/app/routes/api.v1.prompts.$slug.promote.ts b/apps/webapp/app/routes/api.v1.prompts.$slug.promote.ts
new file mode 100644
index 00000000000..6040fdb46e6
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts.$slug.promote.ts
@@ -0,0 +1,71 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import { PromptService } from "~/v3/services/promptService.server";
+
+const ParamsSchema = z.object({
+  slug: z.string(),
+});
+
+const Body = z.object({
+  version: z.number().int().positive(),
+});
+
+const { action } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    body: Body,
+    method: "POST",
+    allowJWT: true,
+    corsStrategy: "all",
+    authorization: {
+      action: "update",
+      resource: (params) => ({ prompts: params.slug }),
+      superScopes: ["admin"],
+    },
+  },
+  async ({ body, params, authentication }) => {
+    const prompt = await prisma.prompt.findUnique({
+      where: {
+        projectId_runtimeEnvironmentId_slug: {
+          projectId: authentication.environment.projectId,
+          runtimeEnvironmentId: authentication.environment.id,
+          slug: params.slug,
+        },
+      },
+    });
+
+    if (!prompt) {
+      return json({ error: "Prompt not found" }, { status: 404 });
+    }
+
+    const targetVersion = await prisma.promptVersion.findUnique({
+      where: {
+        promptId_version: {
+          promptId: prompt.id,
+          version: body.version,
+        },
+      },
+    });
+
+    if (!targetVersion) {
+      return json({ error: `Version ${body.version} not found` }, { status: 404 });
+    }
+
+    try {
+      const service = new PromptService();
+      await service.promoteVersion(prompt.id, targetVersion.id, { sourceGuard: true });
+    } catch (e) {
+      if (e instanceof ServiceValidationError) {
+        return json({ error: e.message }, { status: e.status ?? 400 });
+      }
+      throw e;
+    }
+
+    return json({ ok: true });
+  }
+);
+
+export { action };
diff --git a/apps/webapp/app/routes/api.v1.prompts.$slug.ts b/apps/webapp/app/routes/api.v1.prompts.$slug.ts
new file mode 100644
index 00000000000..32ea1525c14
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts.$slug.ts
@@ -0,0 +1,174 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import {
+  createActionApiRoute,
+  createLoaderApiRoute,
+} from "~/services/routeBuilders/apiBuilder.server";
+
+const ParamsSchema = z.object({
+  slug: z.string(),
+});
+
+const SearchParams = z.object({
+  label: z.string().optional(),
+  version: z.coerce.number().optional(),
+});
+
+// GET /api/v1/prompts/:slug — Get prompt + version
+export const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    searchParams: SearchParams,
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async (params, authentication) => {
+      return prisma.prompt.findUnique({
+        where: {
+          projectId_runtimeEnvironmentId_slug: {
+            projectId: authentication.environment.projectId,
+            runtimeEnvironmentId: authentication.environment.id,
+            slug: params.slug,
+          },
+        },
+      });
+    },
+    authorization: {
+      action: "read",
+      resource: (_resource, params) => ({ prompts: params.slug }),
+      superScopes: ["read:prompts", "admin"],
+    },
+  },
+  async ({ searchParams, resource: prompt }) => {
+    if (!prompt) {
+      return json({ error: "Prompt not found" }, { status: 404 });
+    }
+
+    const presenter = new PromptPresenter(clickhouseClient);
+    const version = await presenter.resolveVersion(prompt.id, {
+      version: searchParams.version,
+      label: searchParams.label,
+    });
+
+    if (!version) {
+      return json({ error: "No version found" }, { status: 404 });
+    }
+
+    return json({
+      data: {
+        id: prompt.friendlyId,
+        slug: prompt.slug,
+        description: prompt.description,
+        type: prompt.type,
+        tags: prompt.tags,
+        defaultModel: prompt.defaultModel,
+        defaultConfig: prompt.defaultConfig,
+        variableSchema: prompt.variableSchema,
+        version: {
+          version: version.version,
+          textContent: version.textContent,
+          model: version.model,
+          config: version.config,
+          source: version.source,
+          labels: version.labels,
+          contentHash: version.contentHash,
+          commitMessage: version.commitMessage,
+          createdAt: version.createdAt,
+        },
+      },
+    });
+  }
+);
+
+// POST /api/v1/prompts/:slug — Resolve prompt with variables
+
+const ResolveBody = z.object({
+  variables: z.record(z.unknown()).default({}),
+  label: z.string().optional(),
+  version: z.number().optional(),
+});
+
+const { action } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    body: ResolveBody,
+    allowJWT: true,
+    corsStrategy: "all",
+    authorization: {
+      action: "read",
+      resource: (params) => ({ prompts: params.slug }),
+      superScopes: ["read:prompts", "admin"],
+    },
+  },
+  async ({ body, params, authentication }) => {
+    const prompt = await prisma.prompt.findUnique({
+      where: {
+        projectId_runtimeEnvironmentId_slug: {
+          projectId: authentication.environment.projectId,
+          runtimeEnvironmentId: authentication.environment.id,
+          slug: params.slug,
+        },
+      },
+    });
+
+    if (!prompt) {
+      return json({ error: "Prompt not found" }, { status: 404 });
+    }
+
+    const presenter = new PromptPresenter(clickhouseClient);
+    const version = await presenter.resolveVersion(prompt.id, {
+      version: body.version,
+      label: body.label,
+    });
+
+    if (!version) {
+      return json({ error: "No version found" }, { status: 404 });
+    }
+
+    if (!version.textContent) {
+      return json({ error: "Prompt has no content" }, { status: 404 });
+    }
+
+    const text = compileTemplate(version.textContent, body.variables);
+    return json({
+      data: {
+        promptId: prompt.friendlyId,
+        slug: prompt.slug,
+        version: version.version,
+        labels: version.labels,
+        template: version.textContent,
+        text,
+        model: version.model ?? prompt.defaultModel,
+        config: version.config ?? prompt.defaultConfig,
+      },
+    });
+  }
+);
+
+export { action };
+
+function compileTemplate(
+  template: string,
+  variables: Record<string, unknown>
+): string {
+  let result = template.replace(
+    /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g,
+    (_match, key, content) => {
+      const value = variables[key];
+      return value
+        ? content.replace(/\{\{(\w+)\}\}/g, (_m: string, k: string) => {
+            return String(variables[k] ?? "");
+          })
+        : "";
+    }
+  );
+
+  result = result.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
+    const value = variables[key];
+    return value !== undefined && value !== null ? String(value) : "";
+  });
+
+  return result;
+}
diff --git a/apps/webapp/app/routes/api.v1.prompts.$slug.versions.ts b/apps/webapp/app/routes/api.v1.prompts.$slug.versions.ts
new file mode 100644
index 00000000000..c40b3e62dbf
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts.$slug.versions.ts
@@ -0,0 +1,56 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+
+const ParamsSchema = z.object({
+  slug: z.string(),
+});
+
+export const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async (params, authentication) => {
+      return prisma.prompt.findUnique({
+        where: {
+          projectId_runtimeEnvironmentId_slug: {
+            projectId: authentication.environment.projectId,
+            runtimeEnvironmentId: authentication.environment.id,
+            slug: params.slug,
+          },
+        },
+      });
+    },
+    authorization: {
+      action: "read",
+      resource: (_resource, params) => ({ prompts: params.slug }),
+      superScopes: ["read:prompts", "admin"],
+    },
+  },
+  async ({ resource: prompt }) => {
+    if (!prompt) {
+      return json({ error: "Prompt not found" }, { status: 404 });
+    }
+
+    const presenter = new PromptPresenter(clickhouseClient);
+    const versions = await presenter.listVersions(prompt.id);
+
+    return json({
+      data: versions.map((v) => ({
+        id: v.id,
+        version: v.version,
+        labels: v.labels,
+        source: v.source,
+        model: v.model,
+        textContent: v.textContent,
+        commitMessage: v.commitMessage,
+        contentHash: v.contentHash,
+        createdAt: v.createdAt.toISOString(),
+      })),
+    });
+  }
+);
diff --git a/apps/webapp/app/routes/api.v1.prompts._index.ts b/apps/webapp/app/routes/api.v1.prompts._index.ts
new file mode 100644
index 00000000000..ccbc0ec38d0
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.prompts._index.ts
@@ -0,0 +1,37 @@
+import { json } from "@remix-run/server-runtime";
+import { PromptPresenter } from "~/presenters/v3/PromptPresenter.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+
+export const loader = createLoaderApiRoute(
+  {
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async () => 1,
+    authorization: {
+      action: "read",
+      resource: () => ({ prompts: "all" }),
+      superScopes: ["read:prompts", "admin"],
+    },
+  },
+  async ({ authentication }) => {
+    const presenter = new PromptPresenter(clickhouseClient);
+    const prompts = await presenter.listPrompts(
+      authentication.environment.projectId,
+      authentication.environment.id
+    );
+
+    return json({
+      data: prompts.map((p) => ({
+        slug: p.slug,
+        friendlyId: p.friendlyId,
+        description: p.description,
+        tags: p.tags,
+        defaultModel: p.defaultModel,
+        currentVersion: p.currentVersion?.version ?? null,
+        hasOverride: p.hasOverride,
+        updatedAt: p.updatedAt.toISOString(),
+      })),
+    });
+  }
+);
diff --git a/apps/webapp/app/routes/api.v1.query.dashboards._index.ts b/apps/webapp/app/routes/api.v1.query.dashboards._index.ts
new file mode 100644
index 00000000000..fdc4dbc3852
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.query.dashboards._index.ts
@@ -0,0 +1,54 @@
+import { json } from "@remix-run/server-runtime";
+import type { DashboardSummary, DashboardWidgetSummary } from "@trigger.dev/core/v3/schemas";
+import type { BuiltInDashboard } from "~/presenters/v3/MetricDashboardPresenter.server";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { builtInDashboard } from "~/presenters/v3/BuiltInDashboards.server";
+
+const BUILT_IN_DASHBOARD_KEYS = ["overview", "llm"];
+
+function serializeDashboard(dashboard: BuiltInDashboard): DashboardSummary {
+  const widgets: DashboardWidgetSummary[] = [];
+
+  if (dashboard.layout.version === "1") {
+    for (const [id, widget] of Object.entries(dashboard.layout.widgets)) {
+      // Skip title widgets — they're just section headers
+      if (widget.display.type === "title") continue;
+
+      widgets.push({
+        id,
+        title: widget.title,
+        query: widget.query,
+        type: widget.display.type,
+      });
+    }
+  }
+
+  return {
+    key: dashboard.key,
+    title: dashboard.title,
+    widgets,
+  };
+}
+
+export const loader = createLoaderApiRoute(
+  {
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async () => 1,
+    authorization: {
+      action: "read",
+      resource: () => ({ query: "dashboards" }),
+      superScopes: ["read:query", "read:all", "admin"],
+    },
+  },
+  async () => {
+    const dashboards = BUILT_IN_DASHBOARD_KEYS.map((key) => {
+      try {
+        return serializeDashboard(builtInDashboard(key));
+      } catch {
+        return null;
+      }
+    }).filter((d): d is DashboardSummary => d !== null);
+    return json({ dashboards });
+  }
+);
diff --git a/apps/webapp/app/routes/api.v1.query.schema.ts b/apps/webapp/app/routes/api.v1.query.schema.ts
new file mode 100644
index 00000000000..aa4762af6f8
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.query.schema.ts
@@ -0,0 +1,58 @@
+import { json } from "@remix-run/server-runtime";
+import type { ColumnSchema, TableSchema } from "@internal/tsql";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { querySchemas } from "~/v3/querySchemas";
+
+function serializeColumn(col: ColumnSchema) {
+  const result: Record<string, unknown> = {
+    name: col.name,
+    type: col.type,
+  };
+
+  if (col.description) {
+    result.description = col.description;
+  }
+  if (col.example) {
+    result.example = col.example;
+  }
+  if (col.allowedValues && col.allowedValues.length > 0) {
+    if (col.valueMap) {
+      result.allowedValues = Object.values(col.valueMap);
+    } else {
+      result.allowedValues = col.allowedValues;
+    }
+  }
+  if (col.coreColumn) {
+    result.coreColumn = true;
+  }
+
+  return result;
+}
+
+function serializeTable(table: TableSchema) {
+  const columns = Object.values(table.columns).map(serializeColumn);
+
+  return {
+    name: table.name,
+    description: table.description,
+    timeColumn: table.timeConstraint,
+    columns,
+  };
+}
+
+export const loader = createLoaderApiRoute(
+  {
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async () => 1,
+    authorization: {
+      action: "read",
+      resource: () => ({ query: "schema" }),
+      superScopes: ["read:query", "read:all", "admin"],
+    },
+  },
+  async () => {
+    const tables = querySchemas.map(serializeTable);
+    return json({ tables });
+  }
+);
diff --git a/apps/webapp/app/routes/api.v1.query.ts b/apps/webapp/app/routes/api.v1.query.ts
new file mode 100644
index 00000000000..22500011671
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.query.ts
@@ -0,0 +1,98 @@
+import { json } from "@remix-run/server-runtime";
+import { QueryError } from "@internal/clickhouse";
+import { z } from "zod";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { executeQuery, type QueryScope } from "~/services/queryService.server";
+import { logger } from "~/services/logger.server";
+import { rowsToCSV } from "~/utils/dataExport";
+import { querySchemas } from "~/v3/querySchemas";
+
+const BodySchema = z.object({
+  query: z.string(),
+  scope: z.enum(["organization", "project", "environment"]).default("environment"),
+  period: z.string().nullish(),
+  from: z.string().nullish(),
+  to: z.string().nullish(),
+  format: z.enum(["json", "csv"]).default("json"),
+});
+
+/** Extract table names from a TRQL query for authorization */
+function detectTables(query: string): string[] {
+  return querySchemas
+    .filter((s) => {
+      const escaped = s.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`\\bFROM\\s+${escaped}\\b`, "i").test(query);
+    })
+    .map((s) => s.name);
+}
+
+const { action, loader } = createActionApiRoute(
+  {
+    body: BodySchema,
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async () => 1,
+    authorization: {
+      action: "read",
+      resource: (_, __, ___, body) => {
+        const tables = detectTables(body.query);
+        return { query: tables.length > 0 ? tables : "all" };
+      },
+      superScopes: ["read:query", "read:all", "admin"],
+    },
+  },
+  async ({ body, authentication }) => {
+    const { query, scope, period, from, to, format } = body;
+    const env = authentication.environment;
+
+    const queryResult = await executeQuery({
+      name: "api-query",
+      query,
+      scope: scope as QueryScope,
+      organizationId: env.organization.id,
+      projectId: env.project.id,
+      environmentId: env.id,
+      period,
+      from,
+      to,
+      history: {
+        source: "API",
+      },
+    });
+
+    if (!queryResult.success) {
+      const message =
+        queryResult.error instanceof QueryError
+          ? queryResult.error.message
+          : "An unexpected error occurred while executing the query.";
+
+      logger.error("Query API error", {
+        error: queryResult.error,
+        query,
+      });
+
+      return json(
+        { error: message },
+        { status: queryResult.error instanceof QueryError ? 400 : 500 }
+      );
+    }
+
+    const { result, periodClipped, maxQueryPeriod } = queryResult;
+
+    if (format === "csv") {
+      const csv = rowsToCSV(result.rows, result.columns);
+
+      return json({
+        format: "csv",
+        results: csv,
+      });
+    }
+
+    return json({
+      format: "json",
+      results: result.rows,
+    });
+  }
+);
+
+export { action, loader };
diff --git a/apps/webapp/app/routes/api.v1.runs.$runFriendlyId.input-streams.wait.ts b/apps/webapp/app/routes/api.v1.runs.$runFriendlyId.input-streams.wait.ts
new file mode 100644
index 00000000000..8e41e9fe4c8
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.runs.$runFriendlyId.input-streams.wait.ts
@@ -0,0 +1,148 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import {
+  CreateInputStreamWaitpointRequestBody,
+  type CreateInputStreamWaitpointResponseBody,
+} from "@trigger.dev/core/v3";
+import { WaitpointId } from "@trigger.dev/core/v3/isomorphic";
+import { $replica } from "~/db.server";
+import { createWaitpointTag, MAX_TAGS_PER_WAITPOINT } from "~/models/waitpointTag.server";
+import {
+  deleteInputStreamWaitpoint,
+  setInputStreamWaitpoint,
+} from "~/services/inputStreamWaitpointCache.server";
+import { getRealtimeStreamInstance } from "~/services/realtime/v1StreamsGlobal.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { parseDelay } from "~/utils/delays";
+import { resolveIdempotencyKeyTTL } from "~/utils/idempotencyKeys.server";
+import { engine } from "~/v3/runEngine.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+
+const ParamsSchema = z.object({
+  runFriendlyId: z.string(),
+});
+
+const { action, loader } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    body: CreateInputStreamWaitpointRequestBody,
+    maxContentLength: 1024 * 10, // 10KB
+    method: "POST",
+  },
+  async ({ authentication, body, params }) => {
+    try {
+      const run = await $replica.taskRun.findFirst({
+        where: {
+          friendlyId: params.runFriendlyId,
+          runtimeEnvironmentId: authentication.environment.id,
+        },
+        select: {
+          id: true,
+          friendlyId: true,
+          realtimeStreamsVersion: true,
+        },
+      });
+
+      if (!run) {
+        return json({ error: "Run not found" }, { status: 404 });
+      }
+
+      const idempotencyKeyExpiresAt = body.idempotencyKeyTTL
+        ? resolveIdempotencyKeyTTL(body.idempotencyKeyTTL)
+        : undefined;
+
+      const timeout = await parseDelay(body.timeout);
+
+      // Process tags (same pattern as api.v1.waitpoints.tokens.ts)
+      const bodyTags = typeof body.tags === "string" ? [body.tags] : body.tags;
+
+      if (bodyTags && bodyTags.length > MAX_TAGS_PER_WAITPOINT) {
+        throw new ServiceValidationError(
+          `Waitpoints can only have ${MAX_TAGS_PER_WAITPOINT} tags, you're trying to set ${bodyTags.length}.`
+        );
+      }
+
+      if (bodyTags && bodyTags.length > 0) {
+        for (const tag of bodyTags) {
+          await createWaitpointTag({
+            tag,
+            environmentId: authentication.environment.id,
+            projectId: authentication.environment.projectId,
+          });
+        }
+      }
+
+      // Step 1: Create the waitpoint
+      const result = await engine.createManualWaitpoint({
+        environmentId: authentication.environment.id,
+        projectId: authentication.environment.projectId,
+        idempotencyKey: body.idempotencyKey,
+        idempotencyKeyExpiresAt,
+        timeout,
+        tags: bodyTags,
+      });
+
+      // Step 2: Cache the mapping in Redis for fast lookup from .send()
+      const ttlMs = timeout ? timeout.getTime() - Date.now() : undefined;
+      await setInputStreamWaitpoint(
+        run.friendlyId,
+        body.streamId,
+        result.waitpoint.id,
+        ttlMs && ttlMs > 0 ? ttlMs : undefined
+      );
+
+      // Step 3: Check if data was already sent to this input stream (race condition handling).
+      // If .send() landed before .wait(), the data is in the S2 stream but no waitpoint
+      // existed to complete. We check from the client's last known position.
+      if (!result.isCached) {
+        try {
+          const realtimeStream = getRealtimeStreamInstance(
+            authentication.environment,
+            run.realtimeStreamsVersion
+          );
+
+          const records = await realtimeStream.readRecords(
+            run.friendlyId,
+            `$trigger.input:${body.streamId}`,
+            body.lastSeqNum
+          );
+
+          if (records.length > 0) {
+            const record = records[0]!;
+
+            // Record data is the raw user payload — no wrapper to unwrap
+            await engine.completeWaitpoint({
+              id: result.waitpoint.id,
+              output: {
+                value: record.data,
+                type: "application/json",
+                isError: false,
+              },
+            });
+
+            // Clean up the Redis cache since we completed it ourselves
+            await deleteInputStreamWaitpoint(run.friendlyId, body.streamId);
+          }
+        } catch {
+          // Non-fatal: if the S2 check fails, the waitpoint is still PENDING.
+          // The next .send() will complete it via the Redis cache path.
+        }
+      }
+
+      return json<CreateInputStreamWaitpointResponseBody>({
+        waitpointId: WaitpointId.toFriendlyId(result.waitpoint.id),
+        isCached: result.isCached,
+      });
+    } catch (error) {
+      if (error instanceof ServiceValidationError) {
+        return json({ error: error.message }, { status: 422 });
+      } else if (error instanceof Error) {
+        return json({ error: error.message }, { status: 500 });
+      }
+
+      return json({ error: "Something went wrong" }, { status: 500 });
+    }
+  }
+);
+
+export { action, loader };
diff --git a/apps/webapp/app/routes/api.v1.runs.$runId.spans.$spanId.ts b/apps/webapp/app/routes/api.v1.runs.$runId.spans.$spanId.ts
new file mode 100644
index 00000000000..7c093efd960
--- /dev/null
+++ b/apps/webapp/app/routes/api.v1.runs.$runId.spans.$spanId.ts
@@ -0,0 +1,134 @@
+import { json } from "@remix-run/server-runtime";
+import { BatchId } from "@trigger.dev/core/v3/isomorphic";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { extractAISpanData } from "~/components/runs/v3/ai";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { resolveEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
+
+const ParamsSchema = z.object({
+  runId: z.string(),
+  spanId: z.string(),
+});
+
+export const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: (params, auth) => {
+      return $replica.taskRun.findFirst({
+        where: {
+          friendlyId: params.runId,
+          runtimeEnvironmentId: auth.environment.id,
+        },
+      });
+    },
+    shouldRetryNotFound: true,
+    authorization: {
+      action: "read",
+      resource: (run) => ({
+        runs: run.friendlyId,
+        tags: run.runTags,
+        batch: run.batchId ? BatchId.toFriendlyId(run.batchId) : undefined,
+        tasks: run.taskIdentifier,
+      }),
+      superScopes: ["read:runs", "read:all", "admin"],
+    },
+  },
+  async ({ params, resource: run, authentication }) => {
+    const eventRepository = resolveEventRepositoryForStore(run.taskEventStore);
+    const eventStore = getTaskEventStoreTableForRun(run);
+
+    const span = await eventRepository.getSpan(
+      eventStore,
+      authentication.environment.id,
+      params.spanId,
+      run.traceId,
+      run.createdAt,
+      run.completedAt ?? undefined
+    );
+
+    if (!span) {
+      return json({ error: "Span not found" }, { status: 404 });
+    }
+
+    // Duration is nanoseconds from ClickHouse (Postgres store is deprecated)
+    const durationMs = span.duration / 1_000_000;
+
+    const aiData =
+      span.properties && typeof span.properties === "object"
+        ? extractAISpanData(span.properties as Record<string, unknown>, durationMs)
+        : undefined;
+
+    const triggeredRuns = await $replica.taskRun.findMany({
+      take: 50,
+      select: {
+        friendlyId: true,
+        taskIdentifier: true,
+        status: true,
+        createdAt: true,
+      },
+      where: {
+        runtimeEnvironmentId: authentication.environment.id,
+        parentSpanId: params.spanId,
+      },
+    });
+
+    const properties =
+      span.properties &&
+      typeof span.properties === "object" &&
+      Object.keys(span.properties as Record<string, unknown>).length > 0
+        ? (span.properties as Record<string, unknown>)
+        : undefined;
+
+    return json(
+      {
+        spanId: span.spanId,
+        parentId: span.parentId,
+        runId: run.friendlyId,
+        message: span.message,
+        isError: span.isError,
+        isPartial: span.isPartial,
+        isCancelled: span.isCancelled,
+        level: span.level,
+        startTime: span.startTime,
+        durationMs,
+        properties,
+        events: span.events?.length ? span.events : undefined,
+        entityType: span.entity.type ?? undefined,
+        ai: aiData
+          ? {
+              model: aiData.model,
+              provider: aiData.provider,
+              operationName: aiData.operationName,
+              inputTokens: aiData.inputTokens,
+              outputTokens: aiData.outputTokens,
+              totalTokens: aiData.totalTokens,
+              cachedTokens: aiData.cachedTokens,
+              reasoningTokens: aiData.reasoningTokens,
+              inputCost: aiData.inputCost,
+              outputCost: aiData.outputCost,
+              totalCost: aiData.totalCost,
+              tokensPerSecond: aiData.tokensPerSecond,
+              msToFirstChunk: aiData.msToFirstChunk,
+              durationMs: aiData.durationMs,
+              finishReason: aiData.finishReason,
+              responseText: aiData.responseText,
+            }
+          : undefined,
+        triggeredRuns:
+          triggeredRuns.length > 0
+            ? triggeredRuns.map((r) => ({
+                runId: r.friendlyId,
+                taskIdentifier: r.taskIdentifier,
+                status: r.status,
+                createdAt: r.createdAt,
+              }))
+            : undefined,
+      },
+      { status: 200 }
+    );
+  }
+);
diff --git a/apps/webapp/app/routes/api.v1.runs.$runParam.replay.ts b/apps/webapp/app/routes/api.v1.runs.$runParam.replay.ts
index 66f30ca1dff..72ad202467d 100644
--- a/apps/webapp/app/routes/api.v1.runs.$runParam.replay.ts
+++ b/apps/webapp/app/routes/api.v1.runs.$runParam.replay.ts
@@ -5,6 +5,7 @@ import { prisma } from "~/db.server";
 import { authenticateApiRequest } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { ReplayTaskRunService } from "~/v3/services/replayTaskRun.server";
+import { sanitizeTriggerSource } from "~/utils/triggerSource";
 
 const ParamsSchema = z.object({
   /* This is the run friendly ID */
@@ -41,8 +42,11 @@ export async function action({ request, params }: ActionFunctionArgs) {
       return json({ error: "Run not found" }, { status: 404 });
     }
 
+    const triggerSource =
+      sanitizeTriggerSource(request.headers.get("x-trigger-source")) ?? "api";
+
     const service = new ReplayTaskRunService();
-    const newRun = await service.call(taskRun);
+    const newRun = await service.call(taskRun, { triggerSource });
 
     if (!newRun) {
       return json({ error: "Failed to create new run" }, { status: 400 });
diff --git a/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts b/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts
index 0c188c17768..5811fc67709 100644
--- a/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts
+++ b/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts
@@ -19,6 +19,7 @@ import {
   handleRequestIdempotency,
   saveRequestIdempotency,
 } from "~/utils/requestIdempotency.server";
+import { sanitizeTriggerSource } from "~/utils/triggerSource";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { OutOfEntitlementError, TriggerTaskService } from "~/v3/services/triggerTask.server";
 
@@ -36,6 +37,7 @@ export const HeadersSchema = z.object({
   "x-trigger-engine-version": RunEngineVersionSchema.nullish(),
   "x-trigger-request-idempotency-key": z.string().nullish(),
   "x-trigger-realtime-streams-version": z.string().nullish(),
+  "x-trigger-source": z.string().nullish(),
   traceparent: z.string().optional(),
   tracestate: z.string().optional(),
 });
@@ -67,6 +69,7 @@ const { action, loader } = createActionApiRoute(
       "x-trigger-engine-version": engineVersion,
       "x-trigger-request-idempotency-key": requestIdempotencyKey,
       "x-trigger-realtime-streams-version": realtimeStreamsVersion,
+      "x-trigger-source": triggerSourceHeader,
     } = headers;
 
     const cachedResponse = await handleRequestIdempotency(requestIdempotencyKey, {
@@ -119,6 +122,8 @@ const { action, loader } = createActionApiRoute(
           realtimeStreamsVersion: determineRealtimeStreamsVersion(
             realtimeStreamsVersion ?? undefined
           ),
+          triggerSource: isFromWorker ? "sdk" : sanitizeTriggerSource(triggerSourceHeader) ?? "api",
+          triggerAction: "trigger",
         },
         engineVersion ?? undefined
       );
@@ -166,7 +171,7 @@ async function responseHeaders(
   const claims = {
     sub: environment.id,
     pub: true,
-    scopes: [`read:runs:${run.friendlyId}`],
+    scopes: [`read:runs:${run.friendlyId}`, `write:inputStreams:${run.friendlyId}`],
     realtime,
   };
 
diff --git a/apps/webapp/app/routes/api.v1.tasks.batch.ts b/apps/webapp/app/routes/api.v1.tasks.batch.ts
index 4a10ade0e60..e6ada1a739c 100644
--- a/apps/webapp/app/routes/api.v1.tasks.batch.ts
+++ b/apps/webapp/app/routes/api.v1.tasks.batch.ts
@@ -15,6 +15,7 @@ import {
   BatchTriggerV3Service,
 } from "~/v3/services/batchTriggerV3.server";
 import { OutOfEntitlementError } from "~/v3/services/triggerTask.server";
+import { sanitizeTriggerSource } from "~/utils/triggerSource";
 import { HeadersSchema } from "./api.v1.tasks.$taskId.trigger";
 import { determineRealtimeStreamsVersion } from "~/services/realtime/v1StreamsGlobal.server";
 import { extractJwtSigningSecretKey } from "~/services/realtime/jwtAuth.server";
@@ -72,6 +73,7 @@ const { action, loader } = createActionApiRoute(
       "x-trigger-engine-version": engineVersion,
       "batch-processing-strategy": batchProcessingStrategy,
       "x-trigger-realtime-streams-version": realtimeStreamsVersion,
+      "x-trigger-source": triggerSourceHeader,
       traceparent,
       tracestate,
     } = headers;
@@ -113,6 +115,8 @@ const { action, loader } = createActionApiRoute(
         realtimeStreamsVersion: determineRealtimeStreamsVersion(
           realtimeStreamsVersion ?? undefined
         ),
+        triggerSource: isFromWorker ? "sdk" : sanitizeTriggerSource(triggerSourceHeader) ?? "api",
+        triggerAction: "trigger",
       });
 
       const $responseHeaders = await responseHeaders(
diff --git a/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.callback.$hash.ts b/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.callback.$hash.ts
index fd29764d653..e8a7f046edb 100644
--- a/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.callback.$hash.ts
+++ b/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.callback.$hash.ts
@@ -1,13 +1,11 @@
 import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
-import {
-  type CompleteWaitpointTokenResponseBody,
-  conditionallyExportPacket,
-  stringifyIO,
-} from "@trigger.dev/core/v3";
+import { type CompleteWaitpointTokenResponseBody, stringifyIO } from "@trigger.dev/core/v3";
 import { WaitpointId } from "@trigger.dev/core/v3/isomorphic";
 import { z } from "zod";
 import { $replica } from "~/db.server";
 import { env } from "~/env.server";
+import { processWaitpointCompletionPacket } from "~/runEngine/concerns/waitpointCompletionPacket.server";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { verifyHttpCallbackHash } from "~/services/httpCallback.server";
 import { logger } from "~/services/logger.server";
 import { engine } from "~/v3/runEngine.server";
@@ -41,8 +39,10 @@ export async function action({ request, params }: ActionFunctionArgs) {
       },
       include: {
         environment: {
-          select: {
-            apiKey: true,
+          include: {
+            project: true,
+            organization: true,
+            orgMember: true,
             parentEnvironment: {
               select: {
                 apiKey: true,
@@ -77,9 +77,10 @@ export async function action({ request, params }: ActionFunctionArgs) {
     const body = await request.json().catch(() => ({}));
 
     const stringifiedData = await stringifyIO(body);
-    const finalData = await conditionallyExportPacket(
+    const finalData = await processWaitpointCompletionPacket(
       stringifiedData,
-      `${waitpointId}/waitpoint/http-callback`
+      waitpoint.environment,
+      `${WaitpointId.toFriendlyId(waitpointId)}/http-callback`
     );
 
     const result = await engine.completeWaitpoint({
diff --git a/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts b/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts
index afd68850130..916bfd19864 100644
--- a/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts
+++ b/apps/webapp/app/routes/api.v1.waitpoints.tokens.$waitpointFriendlyId.complete.ts
@@ -2,7 +2,6 @@ import { json } from "@remix-run/server-runtime";
 import {
   CompleteWaitpointTokenRequestBody,
   type CompleteWaitpointTokenResponseBody,
-  conditionallyExportPacket,
   stringifyIO,
 } from "@trigger.dev/core/v3";
 import { WaitpointId } from "@trigger.dev/core/v3/isomorphic";
@@ -10,6 +9,7 @@ import { z } from "zod";
 import { $replica } from "~/db.server";
 import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
+import { processWaitpointCompletionPacket } from "~/runEngine/concerns/waitpointCompletionPacket.server";
 import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { engine } from "~/v3/runEngine.server";
 
@@ -52,9 +52,10 @@ const { action, loader } = createActionApiRoute(
       }
 
       const stringifiedData = await stringifyIO(body.data);
-      const finalData = await conditionallyExportPacket(
+      const finalData = await processWaitpointCompletionPacket(
         stringifiedData,
-        `${waitpointId}/waitpoint/token`
+        authentication.environment,
+        `${WaitpointId.toFriendlyId(waitpointId)}/token`
       );
 
       const result = await engine.completeWaitpoint({
diff --git a/apps/webapp/app/routes/api.v2.packets.$.ts b/apps/webapp/app/routes/api.v2.packets.$.ts
new file mode 100644
index 00000000000..8810dc6005a
--- /dev/null
+++ b/apps/webapp/app/routes/api.v2.packets.$.ts
@@ -0,0 +1,45 @@
+import type { ActionFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { authenticateApiRequest } from "~/services/apiAuth.server";
+import { generatePresignedUrl } from "~/v3/objectStore.server";
+
+const ParamsSchema = z.object({
+  "*": z.string(),
+});
+
+/**
+ * PUT-only presign for packet uploads (SDK offload). Uses OBJECT_STORE_DEFAULT_PROTOCOL for
+ * unprefixed keys; returns canonical storagePath for IOPacket.data. GET presigns use v1.
+ */
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method.toUpperCase() !== "PUT") {
+    return { status: 405, body: "Method Not Allowed" };
+  }
+
+  const authenticationResult = await authenticateApiRequest(request);
+
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const parsedParams = ParamsSchema.parse(params);
+  const filename = parsedParams["*"];
+
+  const signed = await generatePresignedUrl(
+    authenticationResult.environment.project.externalRef,
+    authenticationResult.environment.slug,
+    filename,
+    "PUT"
+  );
+
+  if (!signed.success) {
+    return json({ error: `Failed to generate presigned URL: ${signed.error}` }, { status: 500 });
+  }
+
+  if (signed.storagePath === undefined) {
+    return json({ error: "Failed to resolve storage path for packet upload" }, { status: 500 });
+  }
+
+  return json({ presignedUrl: signed.url, storagePath: signed.storagePath });
+}
diff --git a/apps/webapp/app/routes/api.v2.tasks.batch.ts b/apps/webapp/app/routes/api.v2.tasks.batch.ts
index cd351505b50..8db98b4d343 100644
--- a/apps/webapp/app/routes/api.v2.tasks.batch.ts
+++ b/apps/webapp/app/routes/api.v2.tasks.batch.ts
@@ -17,6 +17,7 @@ import {
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { BatchProcessingStrategy } from "~/v3/services/batchTriggerV3.server";
 import { OutOfEntitlementError } from "~/v3/services/triggerTask.server";
+import { sanitizeTriggerSource } from "~/utils/triggerSource";
 import { HeadersSchema } from "./api.v1.tasks.$taskId.trigger";
 import { determineRealtimeStreamsVersion } from "~/services/realtime/v1StreamsGlobal.server";
 import { extractJwtSigningSecretKey } from "~/services/realtime/jwtAuth.server";
@@ -62,6 +63,7 @@ const { action, loader } = createActionApiRoute(
       "batch-processing-strategy": batchProcessingStrategy,
       "x-trigger-request-idempotency-key": requestIdempotencyKey,
       "x-trigger-realtime-streams-version": realtimeStreamsVersion,
+      "x-trigger-source": triggerSourceHeader,
       traceparent,
       tracestate,
     } = headers;
@@ -127,6 +129,8 @@ const { action, loader } = createActionApiRoute(
         realtimeStreamsVersion: determineRealtimeStreamsVersion(
           realtimeStreamsVersion ?? undefined
         ),
+        triggerSource: isFromWorker ? "sdk" : sanitizeTriggerSource(triggerSourceHeader) ?? "api",
+        triggerAction: "trigger",
       });
 
       const $responseHeaders = await responseHeaders(
diff --git a/apps/webapp/app/routes/api.v3.batches.$batchId.items.ts b/apps/webapp/app/routes/api.v3.batches.$batchId.items.ts
index 8307f34afce..2d732d1555a 100644
--- a/apps/webapp/app/routes/api.v3.batches.$batchId.items.ts
+++ b/apps/webapp/app/routes/api.v3.batches.$batchId.items.ts
@@ -99,18 +99,12 @@ export async function action({ request, params }: ActionFunctionArgs) {
     if (error instanceof ServiceValidationError) {
       return json({ error: error.message }, { status: 422 });
     } else if (error instanceof Error) {
-      // Check for stream parsing errors
-      if (
-        error.message.includes("Invalid JSON") ||
-        error.message.includes("exceeds maximum size")
-      ) {
+      // Check for stream parsing errors (e.g. invalid JSON)
+      if (error.message.includes("Invalid JSON")) {
         return json({ error: error.message }, { status: 400 });
       }
 
-      return json(
-        { error: error.message },
-        { status: 500, headers: { "x-should-retry": "false" } }
-      );
+      return json({ error: error.message }, { status: 500 });
     }
 
     return json({ error: "Something went wrong" }, { status: 500 });
diff --git a/apps/webapp/app/routes/api.v3.batches.ts b/apps/webapp/app/routes/api.v3.batches.ts
index a2847c95667..5067eaef06e 100644
--- a/apps/webapp/app/routes/api.v3.batches.ts
+++ b/apps/webapp/app/routes/api.v3.batches.ts
@@ -13,6 +13,7 @@ import {
 } from "~/utils/requestIdempotency.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { OutOfEntitlementError } from "~/v3/services/triggerTask.server";
+import { sanitizeTriggerSource } from "~/utils/triggerSource";
 import { HeadersSchema } from "./api.v1.tasks.$taskId.trigger";
 import { determineRealtimeStreamsVersion } from "~/services/realtime/v1StreamsGlobal.server";
 import { extractJwtSigningSecretKey } from "~/services/realtime/jwtAuth.server";
@@ -65,6 +66,7 @@ const { action, loader } = createActionApiRoute(
       "x-trigger-worker": isFromWorker,
       "x-trigger-client": triggerClient,
       "x-trigger-realtime-streams-version": realtimeStreamsVersion,
+      "x-trigger-source": triggerSourceHeader,
       traceparent,
       tracestate,
     } = headers;
@@ -132,6 +134,7 @@ const { action, loader } = createActionApiRoute(
         realtimeStreamsVersion: determineRealtimeStreamsVersion(
           realtimeStreamsVersion ?? undefined
         ),
+        triggerSource: isFromWorker ? "sdk" : sanitizeTriggerSource(triggerSourceHeader) ?? "api",
       });
 
       const $responseHeaders = await responseHeaders(
@@ -158,7 +161,7 @@ const { action, loader } = createActionApiRoute(
             status: 429,
             headers: {
               "X-RateLimit-Limit": error.limit.toString(),
-              "X-RateLimit-Remaining": error.remaining.toString(),
+              "X-RateLimit-Remaining": Math.max(0, error.remaining).toString(),
               "X-RateLimit-Reset": Math.floor(error.resetAt.getTime() / 1000).toString(),
               "Retry-After": Math.max(
                 1,
diff --git a/apps/webapp/app/routes/auth.github.callback.tsx b/apps/webapp/app/routes/auth.github.callback.tsx
index 42473c64a49..2313b348f4a 100644
--- a/apps/webapp/app/routes/auth.github.callback.tsx
+++ b/apps/webapp/app/routes/auth.github.callback.tsx
@@ -5,6 +5,7 @@ import { getSession, redirectWithErrorMessage } from "~/models/message.server";
 import { authenticator } from "~/services/auth.server";
 import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
 import { commitSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
 import { redirectCookie } from "./auth.github";
 import { sanitizeRedirectPath } from "~/utils";
 
@@ -17,7 +18,6 @@ export let loader: LoaderFunction = async ({ request }) => {
     failureRedirect: "/login", // If auth fails, the failureRedirect will be thrown as a Response
   });
 
-  // manually get the session
   const session = await getSession(request.headers.get("cookie"));
 
   const userRecord = await prisma.user.findFirst({
@@ -49,12 +49,13 @@ export let loader: LoaderFunction = async ({ request }) => {
     return redirect("/login/mfa", { headers });
   }
 
-  // and store the user data
   session.set(authenticator.sessionKey, auth);
 
   const headers = new Headers();
   headers.append("Set-Cookie", await commitSession(session));
   headers.append("Set-Cookie", await setLastAuthMethodHeader("github"));
 
+  await trackAndClearReferralSource(request, auth.userId, headers);
+
   return redirect(redirectTo, { headers });
 };
diff --git a/apps/webapp/app/routes/auth.google.callback.tsx b/apps/webapp/app/routes/auth.google.callback.tsx
index 783ddce3a3f..65dabd605ce 100644
--- a/apps/webapp/app/routes/auth.google.callback.tsx
+++ b/apps/webapp/app/routes/auth.google.callback.tsx
@@ -5,6 +5,7 @@ import { getSession, redirectWithErrorMessage } from "~/models/message.server";
 import { authenticator } from "~/services/auth.server";
 import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
 import { commitSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
 import { redirectCookie } from "./auth.google";
 import { sanitizeRedirectPath } from "~/utils";
 
@@ -17,7 +18,6 @@ export let loader: LoaderFunction = async ({ request }) => {
     failureRedirect: "/login", // If auth fails, the failureRedirect will be thrown as a Response
   });
 
-  // manually get the session
   const session = await getSession(request.headers.get("cookie"));
 
   const userRecord = await prisma.user.findFirst({
@@ -49,13 +49,14 @@ export let loader: LoaderFunction = async ({ request }) => {
     return redirect("/login/mfa", { headers });
   }
 
-  // and store the user data
   session.set(authenticator.sessionKey, auth);
 
   const headers = new Headers();
   headers.append("Set-Cookie", await commitSession(session));
   headers.append("Set-Cookie", await setLastAuthMethodHeader("google"));
 
+  await trackAndClearReferralSource(request, auth.userId, headers);
+
   return redirect(redirectTo, { headers });
 };
 
diff --git a/apps/webapp/app/routes/confirm-basic-details.tsx b/apps/webapp/app/routes/confirm-basic-details.tsx
index 4187a2e9d0c..2c6209b74f0 100644
--- a/apps/webapp/app/routes/confirm-basic-details.tsx
+++ b/apps/webapp/app/routes/confirm-basic-details.tsx
@@ -1,11 +1,12 @@
 import { conform, useForm } from "@conform-to/react";
 import { parse } from "@conform-to/zod";
-import { ArrowRightIcon, EnvelopeIcon, HeartIcon, UserIcon } from "@heroicons/react/20/solid";
+import { ArrowRightIcon, EnvelopeIcon, UserGroupIcon, UserIcon } from "@heroicons/react/20/solid";
 import { HandRaisedIcon } from "@heroicons/react/24/solid";
-import { ActionFunction, json } from "@remix-run/node";
-import { Form, useActionData } from "@remix-run/react";
+import { RadioGroup } from "@radix-ui/react-radio-group";
+import { json, type ActionFunction } from "@remix-run/node";
+import { Form, useActionData, useNavigation } from "@remix-run/react";
 import { motion } from "framer-motion";
-import { forwardRef, useState } from "react";
+import { forwardRef, useEffect, useState } from "react";
 import { z } from "zod";
 import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
 import { BackgroundWrapper } from "~/components/BackgroundWrapper";
@@ -18,6 +19,8 @@ import { Hint } from "~/components/primitives/Hint";
 import { Input } from "~/components/primitives/Input";
 import { InputGroup } from "~/components/primitives/InputGroup";
 import { Label } from "~/components/primitives/Label";
+import { RadioGroupItem } from "~/components/primitives/RadioButton";
+import { Select, SelectItem } from "~/components/primitives/Select";
 import { prisma } from "~/db.server";
 import { useFeatures } from "~/hooks/useFeatures";
 import { useUser } from "~/hooks/useUser";
@@ -25,6 +28,41 @@ import { redirectWithSuccessMessage } from "~/models/message.server";
 import { updateUser } from "~/models/user.server";
 import { requireUserId } from "~/services/session.server";
 import { rootPath } from "~/utils/pathBuilder";
+import { getVercelInstallParams } from "~/v3/vercel";
+
+const referralSourceOptions = [
+  "Search engine",
+  "YouTube",
+  "Twitter/X",
+  "LinkedIn",
+  "Word of mouth",
+  "AI assistant/LLM",
+  "Blog/article",
+  "Event",
+  "Other",
+] as const;
+
+const roleOptions = [
+  "Founder",
+  "Staff/principal engineer",
+  "Senior software engineer",
+  "Software engineer",
+  "AI/ML engineer",
+  "Engineering manager",
+  "Product engineer",
+  "Non technical builder using AI tools",
+  "Student/learner",
+  "Other",
+] as const;
+
+function shuffleArray<T>(arr: T[]): T[] {
+  const shuffled = [...arr];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
 
 function createSchema(
   constraints: {
@@ -39,13 +77,11 @@ function createSchema(
         .email()
         .superRefine((email, ctx) => {
           if (constraints.isEmailUnique === undefined) {
-            //client-side validation skips this
             ctx.addIssue({
               code: z.ZodIssueCode.custom,
               message: conform.VALIDATION_UNDEFINED,
             });
           } else {
-            // Tell zod this is an async validation by returning the promise
             return constraints.isEmailUnique(email).then((isUnique) => {
               if (isUnique) {
                 return;
@@ -60,6 +96,11 @@ function createSchema(
         }),
       confirmEmail: z.string(),
       referralSource: z.string().optional(),
+      referralSourceOther: z.string().optional(),
+      role: z.string().optional(),
+      roleOther: z.string().optional(),
+      referralSourcePosition: z.coerce.number().optional(),
+      rolePosition: z.coerce.number().optional(),
     })
     .refine((value) => value.email === value.confirmEmail, {
       message: "Emails must match",
@@ -98,14 +139,57 @@ export const action: ActionFunction = async ({ request }) => {
   }
 
   try {
-    const updatedUser = await updateUser({
+    const onboardingData: Record<string, string | undefined> = {};
+
+    if (submission.value.referralSource) {
+      onboardingData.referralSource = submission.value.referralSource;
+      if (submission.value.referralSourcePosition) {
+        onboardingData.referralSourcePosition = String(submission.value.referralSourcePosition);
+      }
+      if (submission.value.referralSource === "Other" && submission.value.referralSourceOther) {
+        onboardingData.referralSourceOther = submission.value.referralSourceOther;
+      }
+    }
+
+    if (submission.value.role) {
+      onboardingData.role = submission.value.role;
+      if (submission.value.rolePosition) {
+        onboardingData.rolePosition = String(submission.value.rolePosition);
+      }
+      if (submission.value.role === "Other" && submission.value.roleOther) {
+        onboardingData.roleOther = submission.value.roleOther;
+      }
+    }
+
+    const referralSourceForLegacy =
+      submission.value.referralSource === "Other" && submission.value.referralSourceOther
+        ? `Other: ${submission.value.referralSourceOther}`
+        : submission.value.referralSource;
+
+    await updateUser({
       id: userId,
       name: submission.value.name,
       email: submission.value.email,
-      referralSource: submission.value.referralSource,
+      referralSource: referralSourceForLegacy,
+      onboardingData: Object.keys(onboardingData).length > 0 ? onboardingData : undefined,
     });
 
-    return redirectWithSuccessMessage(rootPath(), request, "Your details have been updated.");
+    const vercelParams = getVercelInstallParams(request);
+    let redirectUrl = rootPath();
+
+    if (vercelParams) {
+      const params = new URLSearchParams({
+        code: vercelParams.code,
+        configurationId: vercelParams.configurationId,
+        integration: "vercel",
+      });
+      if (vercelParams.next) {
+        params.set("next", vercelParams.next);
+      }
+      redirectUrl = `/orgs/new?${params.toString()}`;
+    }
+
+    return redirectWithSuccessMessage(redirectUrl, request, "Your details have been updated.");
   } catch (error: any) {
     return json({ errors: { body: error.message } }, { status: 400 });
   }
@@ -125,10 +209,26 @@ export default function Page() {
   const lastSubmission = useActionData();
   const [enteredEmail, setEnteredEmail] = useState<string>(user.email ?? "");
   const { isManagedCloud } = useFeatures();
+  const navigation = useNavigation();
+  const isSubmitting = navigation.state === "submitting" || navigation.state === "loading";
+  const [selectedReferralSource, setSelectedReferralSource] = useState<string | undefined>();
+  const [selectedRole, setSelectedRole] = useState<string>("");
+
+  const [shuffledReferralSources, setShuffledReferralSources] = useState<string[]>([
+    ...referralSourceOptions,
+  ]);
+  const [shuffledRoles, setShuffledRoles] = useState<string[]>([...roleOptions]);
+
+  useEffect(() => {
+    const nonOtherReferral = referralSourceOptions.filter((r) => r !== "Other");
+    setShuffledReferralSources([...shuffleArray(nonOtherReferral), "Other"]);
 
-  const [form, { name, email, confirmEmail, referralSource }] = useForm({
+    const nonOtherRoles = roleOptions.filter((r) => r !== "Other");
+    setShuffledRoles([...shuffleArray(nonOtherRoles), "Other"]);
+  }, []);
+
+  const [form, { name, email, confirmEmail }] = useForm({
     id: "confirm-basic-details",
-    // TODO: type this
     lastSubmission: lastSubmission as any,
     onValidate({ formData }) {
       return parse(formData, { schema: createSchema() });
@@ -141,7 +241,7 @@ export default function Page() {
   return (
     <AppContainer className="bg-charcoal-900">
       <BackgroundWrapper>
-        <MainCenteredContainer className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+        <MainCenteredContainer variant="onboarding" className="max-w-[29rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
           <Form method="post" {...form.props}>
             <FormTitle
               title="Welcome to Trigger.dev"
@@ -169,7 +269,9 @@ export default function Page() {
             />
             <Fieldset>
               <InputGroup>
-                <Label htmlFor={name.id}>Full name</Label>
+                <Label htmlFor={name.id}>
+                  Full name <span className="text-text-bright">*</span>
+                </Label>
                 <Input
                   {...conform.input(name, { type: "text" })}
                   defaultValue={user.name ?? ""}
@@ -177,11 +279,12 @@ export default function Page() {
                   icon={UserIcon}
                   autoFocus
                 />
-                <Hint>Your team will see this name and we'll use it to contact you.</Hint>
                 <FormError id={name.errorId}>{name.error}</FormError>
               </InputGroup>
               <InputGroup>
-                <Label htmlFor={email.id}>Email</Label>
+                <Label htmlFor={email.id}>
+                  Email <span className="text-text-bright">*</span>
+                </Label>
                 <Input
                   {...conform.input(email, { type: "email" })}
                   defaultValue={enteredEmail}
@@ -192,9 +295,6 @@ export default function Page() {
                   icon={EnvelopeIcon}
                   spellCheck={false}
                 />
-                {!shouldShowConfirm && (
-                  <Hint>Confirm this is the email you'd like for your Trigger.dev account.</Hint>
-                )}
                 <FormError id={email.errorId}>{email.error}</FormError>
               </InputGroup>
 
@@ -207,9 +307,6 @@ export default function Page() {
                     icon={EnvelopeIcon}
                     spellCheck={false}
                   />
-                  <Hint>
-                    Check this is the email you'd like associated with your Trigger.dev account.
-                  </Hint>
                   <FormError id={confirmEmail.errorId}>{confirmEmail.error}</FormError>
                 </InputGroup>
               ) : (
@@ -217,21 +314,106 @@ export default function Page() {
                   <input {...conform.input(confirmEmail, { type: "hidden" })} value={user.email} />
                 </>
               )}
+
               {isManagedCloud && (
-                <InputGroup>
-                  <Label htmlFor={confirmEmail.id}>How did you hear about us?</Label>
-                  <Input
-                    {...conform.input(referralSource, { type: "text" })}
-                    placeholder="LLM, Google, X (Twitter)…?"
-                    icon={HeartIcon}
-                    spellCheck={false}
-                  />
-                </InputGroup>
+                <>
+                  <div className="border-t border-charcoal-700" />
+                  <InputGroup>
+                    <Label className="mb-0.5" id="referral-label">
+                      How did you hear about us?
+                    </Label>
+                    <input
+                      type="hidden"
+                      name="referralSource"
+                      value={selectedReferralSource ?? ""}
+                    />
+                    <input
+                      type="hidden"
+                      name="referralSourcePosition"
+                      value={
+                        selectedReferralSource
+                          ? shuffledReferralSources.indexOf(selectedReferralSource) + 1
+                          : ""
+                      }
+                    />
+                    <RadioGroup
+                      value={selectedReferralSource}
+                      onValueChange={setSelectedReferralSource}
+                      className="flex flex-wrap gap-2"
+                      aria-labelledby="referral-label"
+                    >
+                      {shuffledReferralSources.map((option) => (
+                        <RadioGroupItem
+                          key={option}
+                          id={`referral-${option}`}
+                          label={option}
+                          value={option}
+                          variant="button/small"
+                        />
+                      ))}
+                    </RadioGroup>
+                    {selectedReferralSource === "Other" && (
+                      <div className="mt-2">
+                        <Input
+                          name="referralSourceOther"
+                          type="text"
+                          placeholder="What was the source?"
+                          spellCheck={false}
+                        />
+                      </div>
+                    )}
+                  </InputGroup>
+
+                  <InputGroup className="mt-1">
+                    <Label id="role-label">What role fits you best?</Label>
+                    <input type="hidden" name="role" value={selectedRole} />
+                    <input
+                      type="hidden"
+                      name="rolePosition"
+                      value={selectedRole ? shuffledRoles.indexOf(selectedRole) + 1 : ""}
+                    />
+                    <Select<string, string>
+                      value={selectedRole}
+                      setValue={setSelectedRole}
+                      placeholder="Select an option"
+                      aria-labelledby="role-label"
+                      variant="secondary/small"
+                      dropdownIcon
+                      icon={<UserGroupIcon className="mr-1 size-4.5 text-text-dimmed" />}
+                      items={shuffledRoles}
+                      className="h-8 min-w-0 border-0 bg-charcoal-750 pl-2 text-sm text-text-dimmed ring-charcoal-600 transition hover:bg-charcoal-650 hover:text-text-dimmed hover:ring-1"
+                      text={(v) => (v ? <span className="text-text-bright">{v}</span> : undefined)}
+                    >
+                      {(items) =>
+                        items.map((item) => (
+                          <SelectItem key={item} value={item}>
+                            <span className="text-text-bright">{item}</span>
+                          </SelectItem>
+                        ))
+                      }
+                    </Select>
+                    {selectedRole === "Other" && (
+                      <div>
+                        <Input
+                          name="roleOther"
+                          type="text"
+                          placeholder="What's your role?"
+                          spellCheck={false}
+                        />
+                      </div>
+                    )}
+                  </InputGroup>
+                </>
               )}
 
               <FormButtons
                 confirmButton={
-                  <Button type="submit" variant={"primary/small"} TrailingIcon={ArrowRightIcon}>
+                  <Button
+                    type="submit"
+                    variant={"primary/small"}
+                    TrailingIcon={ArrowRightIcon}
+                    isLoading={isSubmitting}
+                  >
                     Continue
                   </Button>
                 }
diff --git a/apps/webapp/app/routes/deployments.$deploymentParam.ts b/apps/webapp/app/routes/deployments.$deploymentParam.ts
new file mode 100644
index 00000000000..b13b0c5cc1e
--- /dev/null
+++ b/apps/webapp/app/routes/deployments.$deploymentParam.ts
@@ -0,0 +1,70 @@
+import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { requireUser } from "~/services/session.server";
+import { rootPath, v3DeploymentPath } from "~/utils/pathBuilder";
+
+const ParamsSchema = z.object({
+  deploymentParam: z.string(),
+});
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const user = await requireUser(request);
+
+  const { deploymentParam } = ParamsSchema.parse(params);
+
+  const deployment = await prisma.workerDeployment.findFirst({
+    where: {
+      friendlyId: deploymentParam,
+      project: {
+        organization: {
+          members: {
+            some: {
+              userId: user.id,
+            },
+          },
+        },
+      },
+    },
+    select: {
+      shortCode: true,
+      environment: {
+        select: {
+          slug: true,
+        },
+      },
+      project: {
+        select: {
+          slug: true,
+          organization: {
+            select: {
+              slug: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  if (!deployment) {
+    return redirectWithErrorMessage(
+      rootPath(),
+      request,
+      "Deployment either doesn't exist or you don't have permission to view it",
+      {
+        ephemeral: false,
+      }
+    );
+  }
+
+  return redirect(
+    v3DeploymentPath(
+      { slug: deployment.project.organization.slug },
+      { slug: deployment.project.slug },
+      { slug: deployment.environment.slug },
+      { shortCode: deployment.shortCode },
+      0
+    )
+  );
+}
diff --git a/apps/webapp/app/routes/engine.v1.dev.disconnect.ts b/apps/webapp/app/routes/engine.v1.dev.disconnect.ts
new file mode 100644
index 00000000000..0cf92a53b70
--- /dev/null
+++ b/apps/webapp/app/routes/engine.v1.dev.disconnect.ts
@@ -0,0 +1,180 @@
+import { json } from "@remix-run/server-runtime";
+import { Ratelimit } from "@upstash/ratelimit";
+import { tryCatch } from "@trigger.dev/core";
+import { DevDisconnectRequestBody } from "@trigger.dev/core/v3";
+import { BulkActionId, RunId } from "@trigger.dev/core/v3/isomorphic";
+import { BulkActionNotificationType, BulkActionType } from "@trigger.dev/database";
+import { prisma } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { RateLimiter } from "~/services/rateLimiter.server";
+import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { CancelTaskRunService } from "~/v3/services/cancelTaskRun.server";
+import { commonWorker } from "~/v3/commonWorker.server";
+import pMap from "p-map";
+
+const CANCEL_REASON = "Dev session ended (CLI exited)";
+
+// Below this threshold, cancel runs inline with pMap.
+// Above it, create a bulk action and process asynchronously.
+const BULK_ACTION_THRESHOLD = 25;
+
+// Maximum number of runs that can be cancelled in a single disconnect call.
+const MAX_RUNS = 500;
+
+// Rate limit: 5 calls per minute per environment
+const disconnectRateLimiter = new RateLimiter({
+  keyPrefix: "dev-disconnect",
+  limiter: Ratelimit.fixedWindow(5, "1 m"),
+  logFailure: true,
+});
+
+const { action } = createActionApiRoute(
+  {
+    body: DevDisconnectRequestBody,
+    maxContentLength: 1024 * 256, // 256KB
+    method: "POST",
+  },
+  async ({ authentication, body }) => {
+    // Only allow dev environments — this endpoint uses finalizeRun which
+    // skips PENDING_CANCEL and immediately finalizes executing runs.
+    if (authentication.environment.type !== "DEVELOPMENT") {
+      return json({ error: "This endpoint is only available for dev environments" }, { status: 403 });
+    }
+
+    const environmentId = authentication.environment.id;
+
+    // Rate limit per environment
+    const rateLimitResult = await disconnectRateLimiter.limit(environmentId);
+    if (!rateLimitResult.success) {
+      return json(
+        { error: "Rate limit exceeded", retryAfter: Math.ceil((rateLimitResult.reset - Date.now()) / 1000) },
+        { status: 429 }
+      );
+    }
+
+    if (body.runFriendlyIds.length > MAX_RUNS) {
+      return json(
+        { error: `A maximum of ${MAX_RUNS} runs can be cancelled per request` },
+        { status: 400 }
+      );
+    }
+
+    const { runFriendlyIds } = body;
+
+    if (runFriendlyIds.length === 0) {
+      return json({ cancelled: 0 }, { status: 200 });
+    }
+
+    logger.info("Dev disconnect: cancelling runs", {
+      environmentId,
+      runCount: runFriendlyIds.length,
+    });
+
+    // For small numbers of runs, cancel inline
+    if (runFriendlyIds.length <= BULK_ACTION_THRESHOLD) {
+      const cancelled = await cancelRunsInline(runFriendlyIds, environmentId);
+      return json({ cancelled }, { status: 200 });
+    }
+
+    // For large numbers, create a bulk action to process asynchronously
+    const bulkActionId = await createBulkCancelAction(
+      runFriendlyIds,
+      authentication.environment.project.id,
+      environmentId
+    );
+
+    logger.info("Dev disconnect: created bulk action for large run set", {
+      environmentId,
+      bulkActionId,
+      runCount: runFriendlyIds.length,
+    });
+
+    return json({ cancelled: 0, bulkActionId }, { status: 200 });
+  }
+);
+
+async function cancelRunsInline(
+  runFriendlyIds: string[],
+  environmentId: string
+): Promise<number> {
+  const runIds = runFriendlyIds.map((fid) => RunId.toId(fid));
+
+  const runs = await prisma.taskRun.findMany({
+    where: {
+      id: { in: runIds },
+      runtimeEnvironmentId: environmentId,
+    },
+    select: {
+      id: true,
+      engine: true,
+      friendlyId: true,
+      status: true,
+      createdAt: true,
+      completedAt: true,
+      taskEventStore: true,
+    },
+  });
+
+  let cancelled = 0;
+  const cancelService = new CancelTaskRunService(prisma);
+
+  await pMap(
+    runs,
+    async (run) => {
+      const [error, result] = await tryCatch(
+        cancelService.call(run, { reason: CANCEL_REASON, finalizeRun: true })
+      );
+
+      if (error) {
+        logger.error("Dev disconnect: failed to cancel run", {
+          runId: run.id,
+          error,
+        });
+      } else if (result && !result.alreadyFinished) {
+        cancelled++;
+      }
+    },
+    { concurrency: 10 }
+  );
+
+  logger.info("Dev disconnect: completed inline cancellation", {
+    environmentId,
+    cancelled,
+    total: runFriendlyIds.length,
+  });
+
+  return cancelled;
+}
+
+async function createBulkCancelAction(
+  runFriendlyIds: string[],
+  projectId: string,
+  environmentId: string
+): Promise<string> {
+  const { id, friendlyId } = BulkActionId.generate();
+
+  await prisma.bulkActionGroup.create({
+    data: {
+      id,
+      friendlyId,
+      projectId,
+      environmentId,
+      name: "Dev session disconnect",
+      type: BulkActionType.CANCEL,
+      params: { runId: runFriendlyIds, finalizeRun: true },
+      queryName: "bulk_action_v1",
+      totalCount: runFriendlyIds.length,
+      completionNotification: BulkActionNotificationType.NONE,
+    },
+  });
+
+  await commonWorker.enqueue({
+    id: `processBulkAction-${id}`,
+    job: "processBulkAction",
+    payload: { bulkActionId: id },
+  });
+
+  return friendlyId;
+}
+
+export { action };
diff --git a/apps/webapp/app/routes/invites.tsx b/apps/webapp/app/routes/invites.tsx
index 11998a4676a..7b234d4129b 100644
--- a/apps/webapp/app/routes/invites.tsx
+++ b/apps/webapp/app/routes/invites.tsx
@@ -101,7 +101,7 @@ export default function Page() {
   return (
     <AppContainer className="bg-charcoal-900">
       <BackgroundWrapper>
-        <MainCenteredContainer className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+        <MainCenteredContainer variant="onboarding" className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
           <div>
             <FormTitle
               LeadingIcon={<EnvelopeIcon className="size-6 text-cyan-500" />}
diff --git a/apps/webapp/app/routes/login._index/route.tsx b/apps/webapp/app/routes/login._index/route.tsx
index 40cea7905c8..72901fa5ddb 100644
--- a/apps/webapp/app/routes/login._index/route.tsx
+++ b/apps/webapp/app/routes/login._index/route.tsx
@@ -80,6 +80,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
         showGoogleAuth: isGoogleAuthSupported,
         lastAuthMethod,
         authError: null,
+        isVercelMarketplace: redirectTo.startsWith("/vercel/callback"),
       },
       {
         headers: {
@@ -106,6 +107,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
       showGoogleAuth: isGoogleAuthSupported,
       lastAuthMethod,
       authError,
+      isVercelMarketplace: false,
     });
   }
 }
@@ -128,7 +130,7 @@ export default function LoginPage() {
               <div className="relative w-full">
                 {data.lastAuthMethod === "github" && <LastUsedBadge />}
                 <Form
-                  action={`/auth/github${data.redirectTo ? `?redirectTo=${data.redirectTo}` : ""}`}
+                  action={`/auth/github${data.redirectTo ? `?redirectTo=${encodeURIComponent(data.redirectTo)}` : ""}`}
                   method="post"
                   className="w-full"
                 >
@@ -148,7 +150,7 @@ export default function LoginPage() {
               <div className="relative w-full">
                 {data.lastAuthMethod === "google" && <LastUsedBadge />}
                 <Form
-                  action={`/auth/google${data.redirectTo ? `?redirectTo=${data.redirectTo}` : ""}`}
+                  action={`/auth/google${data.redirectTo ? `?redirectTo=${encodeURIComponent(data.redirectTo)}` : ""}`}
                   method="post"
                   className="w-full"
                 >
@@ -164,19 +166,21 @@ export default function LoginPage() {
                 </Form>
               </div>
             )}
-            <div className="relative w-full">
-              {data.lastAuthMethod === "email" && <LastUsedBadge />}
-              <LinkButton
-                to="/login/magic"
-                variant="secondary/extra-large"
-                fullWidth
-                data-action="continue with email"
-                className="text-text-bright"
-              >
-                <EnvelopeIcon className="mr-2 size-5 text-text-bright" />
-                Continue with Email
-              </LinkButton>
-            </div>
+            {!data.isVercelMarketplace && (
+              <div className="relative w-full">
+                {data.lastAuthMethod === "email" && <LastUsedBadge />}
+                <LinkButton
+                  to={data.redirectTo ? `/login/magic?redirectTo=${encodeURIComponent(data.redirectTo)}` : "/login/magic"}
+                  variant="secondary/extra-large"
+                  fullWidth
+                  data-action="continue with email"
+                  className="text-text-bright"
+                >
+                  <EnvelopeIcon className="mr-2 size-5 text-text-bright" />
+                  Continue with Email
+                </LinkButton>
+              </div>
+            )}
             {data.authError && <FormError>{data.authError}</FormError>}
           </div>
           <Paragraph variant="extra-small" className="mt-2 text-center">
diff --git a/apps/webapp/app/routes/login.magic/route.tsx b/apps/webapp/app/routes/login.magic/route.tsx
index 8c2015c5e6c..8c4323be54e 100644
--- a/apps/webapp/app/routes/login.magic/route.tsx
+++ b/apps/webapp/app/routes/login.magic/route.tsx
@@ -22,6 +22,7 @@ import { Spinner } from "~/components/primitives/Spinner";
 import { TextLink } from "~/components/primitives/TextLink";
 import { authenticator } from "~/services/auth.server";
 import { commitSession, getUserSession } from "~/services/sessionStorage.server";
+import { setRedirectTo, commitSession as commitRedirectSession } from "~/services/redirectTo.server";
 import {
   checkMagicLinkEmailRateLimit,
   checkMagicLinkEmailDailyRateLimit,
@@ -30,6 +31,7 @@ import {
 } from "~/services/magicLinkRateLimiter.server";
 import { logger, tryCatch } from "@trigger.dev/core/v3";
 import { env } from "~/env.server";
+import { extractClientIp } from "~/utils/extractClientIp.server";
 
 export const meta: MetaFunction = ({ matches }) => {
   const parentMeta = matches
@@ -58,6 +60,16 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const session = await getUserSession(request);
   const error = session.get("auth:error");
 
+  // Get redirectTo from URL params and store in session if present
+  const url = new URL(request.url);
+  const redirectTo = url.searchParams.get("redirectTo");
+  const headers = new Headers();
+  
+  if (redirectTo) {
+    const redirectSession = await setRedirectTo(request, redirectTo);
+    headers.append("Set-Cookie", await commitRedirectSession(redirectSession));
+  }
+
   let magicLinkError: string | undefined;
   if (error) {
     if ("message" in error) {
@@ -67,13 +79,15 @@ export async function loader({ request }: LoaderFunctionArgs) {
     }
   }
 
+  headers.append("Set-Cookie", await commitSession(session));
+
   return typedjson(
     {
       magicLinkSent: session.has("triggerdotdev:magiclink"),
       magicLinkError,
     },
     {
-      headers: { "Set-Cookie": await commitSession(session) },
+      headers,
     }
   );
 }
@@ -169,13 +183,6 @@ export async function action({ request }: ActionFunctionArgs) {
   }
 }
 
-const extractClientIp = (xff: string | null) => {
-  if (!xff) return null;
-
-  const parts = xff.split(",").map((p) => p.trim());
-  return parts[parts.length - 1]; // take last item, ALB appends the real client IP by default
-};
-
 export default function LoginMagicLinkPage() {
   const { magicLinkSent, magicLinkError } = useTypedLoaderData<typeof loader>();
   const navigate = useNavigation();
diff --git a/apps/webapp/app/routes/login.mfa/route.tsx b/apps/webapp/app/routes/login.mfa/route.tsx
index 0d1a347d4b5..1a71cd7227a 100644
--- a/apps/webapp/app/routes/login.mfa/route.tsx
+++ b/apps/webapp/app/routes/login.mfa/route.tsx
@@ -20,12 +20,13 @@ import { InputOTP, InputOTPGroup, InputOTPSlot } from "~/components/primitives/I
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { Spinner } from "~/components/primitives/Spinner";
 import { authenticator } from "~/services/auth.server";
-import { commitSession, getUserSession, sessionStorage } from "~/services/sessionStorage.server";
+import { commitSession, getUserSession } from "~/services/sessionStorage.server";
 import { getSession as getMessageSession } from "~/models/message.server";
 import { MultiFactorAuthenticationService } from "~/services/mfa/multiFactorAuthentication.server";
 import { redirectWithErrorMessage, redirectBackWithErrorMessage } from "~/models/message.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { checkMfaRateLimit, MfaRateLimitError } from "~/services/mfa/mfaRateLimiter.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
 
 export const meta: MetaFunction = ({ matches }) => {
   const parentMeta = matches
@@ -151,20 +152,21 @@ export async function action({ request }: ActionFunctionArgs) {
 }
 
 async function completeLogin(request: Request, session: Session, userId: string) {
-  // Create a new authenticated session
-  const authSession = await sessionStorage.getSession(request.headers.get("Cookie"));
-  authSession.set(authenticator.sessionKey, { userId });
+  // Set the auth key on the same session object to avoid conflicting Set-Cookie headers
+  // (both authSession and session share the same __session cookie name)
+  session.set(authenticator.sessionKey, { userId });
 
   // Get the redirect URL and clean up pending MFA data
   const redirectTo = session.get("pending-mfa-redirect-to") ?? "/";
   session.unset("pending-mfa-user-id");
   session.unset("pending-mfa-redirect-to");
 
-  return redirect(redirectTo, {
-    headers: {
-      "Set-Cookie": await sessionStorage.commitSession(authSession),
-    },
-  });
+  const headers = new Headers();
+  headers.append("Set-Cookie", await commitSession(session));
+
+  await trackAndClearReferralSource(request, userId, headers);
+
+  return redirect(redirectTo, { headers });
 }
 
 export default function LoginMfaPage() {
diff --git a/apps/webapp/app/routes/magic.tsx b/apps/webapp/app/routes/magic.tsx
index c45b6882caf..682f0ef46e5 100644
--- a/apps/webapp/app/routes/magic.tsx
+++ b/apps/webapp/app/routes/magic.tsx
@@ -6,6 +6,7 @@ import { authenticator } from "~/services/auth.server";
 import { setLastAuthMethodHeader } from "~/services/lastAuthMethod.server";
 import { getRedirectTo } from "~/services/redirectTo.server";
 import { commitSession, getSession } from "~/services/sessionStorage.server";
+import { trackAndClearReferralSource } from "~/services/referralSource.server";
 
 export async function loader({ request }: LoaderFunctionArgs) {
   const redirectTo = await getRedirectTo(request);
@@ -53,5 +54,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
   headers.append("Set-Cookie", await commitSession(session));
   headers.append("Set-Cookie", await setLastAuthMethodHeader("email"));
 
+  await trackAndClearReferralSource(request, auth.userId, headers);
+
   return redirect(redirectTo ?? "/", { headers });
 }
diff --git a/apps/webapp/app/routes/orgs.$organizationSlug.projects.$projectParam.settings.ts b/apps/webapp/app/routes/orgs.$organizationSlug.projects.$projectParam.settings.ts
index 0948caec680..dbd84280830 100644
--- a/apps/webapp/app/routes/orgs.$organizationSlug.projects.$projectParam.settings.ts
+++ b/apps/webapp/app/routes/orgs.$organizationSlug.projects.$projectParam.settings.ts
@@ -2,7 +2,7 @@ import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import { prisma } from "~/db.server";
 import { SelectBestEnvironmentPresenter } from "~/presenters/SelectBestEnvironmentPresenter.server";
 import { requireUser } from "~/services/session.server";
-import { ProjectParamSchema, v3ProjectSettingsPath } from "~/utils/pathBuilder";
+import { ProjectParamSchema, v3ProjectSettingsGeneralPath } from "~/utils/pathBuilder";
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const user = await requireUser(request);
@@ -39,5 +39,5 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const selector = new SelectBestEnvironmentPresenter();
   const environment = await selector.selectBestEnvironment(project.id, user, project.environments);
 
-  return redirect(v3ProjectSettingsPath({ slug: organizationSlug }, project, environment));
+  return redirect(v3ProjectSettingsGeneralPath({ slug: organizationSlug }, project, environment));
 };
diff --git a/apps/webapp/app/routes/otel.v1.metrics.ts b/apps/webapp/app/routes/otel.v1.metrics.ts
new file mode 100644
index 00000000000..5529f9310ec
--- /dev/null
+++ b/apps/webapp/app/routes/otel.v1.metrics.ts
@@ -0,0 +1,41 @@
+import { ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import {
+  ExportMetricsServiceRequest,
+  ExportMetricsServiceResponse,
+} from "@trigger.dev/otlp-importer";
+import { otlpExporter } from "~/v3/otlpExporter.server";
+
+export async function action({ request }: ActionFunctionArgs) {
+  try {
+    const contentType = request.headers.get("content-type")?.toLowerCase() ?? "";
+
+    if (contentType.startsWith("application/json")) {
+      const body = await request.json();
+
+      const exportResponse = await otlpExporter.exportMetrics(
+        body as ExportMetricsServiceRequest
+      );
+
+      return json(exportResponse, { status: 200 });
+    } else if (contentType.startsWith("application/x-protobuf")) {
+      const buffer = await request.arrayBuffer();
+
+      const exportRequest = ExportMetricsServiceRequest.decode(new Uint8Array(buffer));
+
+      const exportResponse = await otlpExporter.exportMetrics(exportRequest);
+
+      return new Response(ExportMetricsServiceResponse.encode(exportResponse).finish(), {
+        status: 200,
+      });
+    } else {
+      return new Response(
+        "Unsupported content type. Must be either application/x-protobuf or application/json",
+        { status: 400 }
+      );
+    }
+  } catch (error) {
+    console.error(error);
+
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}
diff --git a/apps/webapp/app/routes/realtime.v1.streams.$runId.input.$streamId.ts b/apps/webapp/app/routes/realtime.v1.streams.$runId.input.$streamId.ts
new file mode 100644
index 00000000000..98c348a023a
--- /dev/null
+++ b/apps/webapp/app/routes/realtime.v1.streams.$runId.input.$streamId.ts
@@ -0,0 +1,174 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import {
+  getInputStreamWaitpoint,
+  deleteInputStreamWaitpoint,
+} from "~/services/inputStreamWaitpointCache.server";
+import {
+  createActionApiRoute,
+  createLoaderApiRoute,
+} from "~/services/routeBuilders/apiBuilder.server";
+import { getRealtimeStreamInstance } from "~/services/realtime/v1StreamsGlobal.server";
+import { engine } from "~/v3/runEngine.server";
+
+const ParamsSchema = z.object({
+  runId: z.string(),
+  streamId: z.string(),
+});
+
+const BodySchema = z.object({
+  data: z.unknown(),
+});
+
+// POST: Send data to an input stream
+const { action } = createActionApiRoute(
+  {
+    params: ParamsSchema,
+    maxContentLength: 1024 * 1024, // 1MB max
+    allowJWT: true,
+    corsStrategy: "all",
+    authorization: {
+      action: "write",
+      resource: (params) => ({ inputStreams: params.runId }),
+      superScopes: ["write:inputStreams", "write:all", "admin"],
+    },
+  },
+  async ({ request, params, authentication }) => {
+    const run = await $replica.taskRun.findFirst({
+      where: {
+        friendlyId: params.runId,
+        runtimeEnvironmentId: authentication.environment.id,
+      },
+      select: {
+        id: true,
+        friendlyId: true,
+        completedAt: true,
+        realtimeStreamsVersion: true,
+      },
+    });
+
+    if (!run) {
+      return json({ ok: false, error: "Run not found" }, { status: 404 });
+    }
+
+    if (run.completedAt) {
+      return json(
+        { ok: false, error: "Cannot send to input stream on a completed run" },
+        { status: 400 }
+      );
+    }
+
+    const body = BodySchema.safeParse(await request.json());
+
+    if (!body.success) {
+      return json({ ok: false, error: "Invalid request body" }, { status: 400 });
+    }
+
+    const realtimeStream = getRealtimeStreamInstance(
+      authentication.environment,
+      run.realtimeStreamsVersion
+    );
+
+    // Build the input stream record (raw user data, no wrapper)
+    const recordId = `inp_${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
+    const record = JSON.stringify(body.data.data);
+
+    // Append the record to the per-stream S2 stream (auto-creates on first write)
+    await realtimeStream.appendPart(
+      record,
+      recordId,
+      run.friendlyId,
+      `$trigger.input:${params.streamId}`
+    );
+
+    // Check Redis cache for a linked .wait() waitpoint (fast, no DB hit if none)
+    // Get first, complete, then delete — so the mapping survives if completeWaitpoint throws
+    const waitpointId = await getInputStreamWaitpoint(params.runId, params.streamId);
+    if (waitpointId) {
+      await engine.completeWaitpoint({
+        id: waitpointId,
+        output: {
+          value: JSON.stringify(body.data.data),
+          type: "application/json",
+          isError: false,
+        },
+      });
+      await deleteInputStreamWaitpoint(params.runId, params.streamId);
+    }
+
+    return json({ ok: true });
+  }
+);
+
+// GET: SSE stream for reading input stream data (used by the in-task SSE tail)
+const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    allowJWT: true,
+    corsStrategy: "all",
+    findResource: async (params, auth) => {
+      return $replica.taskRun.findFirst({
+        where: {
+          friendlyId: params.runId,
+          runtimeEnvironmentId: auth.environment.id,
+        },
+        include: {
+          batch: {
+            select: {
+              friendlyId: true,
+            },
+          },
+        },
+      });
+    },
+    authorization: {
+      action: "read",
+      resource: (run) => ({
+        runs: run.friendlyId,
+        tags: run.runTags,
+        batch: run.batch?.friendlyId,
+        tasks: run.taskIdentifier,
+      }),
+      superScopes: ["read:runs", "read:all", "admin"],
+    },
+  },
+  async ({ params, request, resource: run, authentication }) => {
+    const lastEventId = request.headers.get("Last-Event-ID") || undefined;
+
+    const timeoutInSecondsRaw = request.headers.get("Timeout-Seconds") ?? undefined;
+    const timeoutInSeconds =
+      timeoutInSecondsRaw !== undefined ? parseInt(timeoutInSecondsRaw, 10) : undefined;
+
+    if (timeoutInSeconds !== undefined && isNaN(timeoutInSeconds)) {
+      return new Response("Invalid timeout seconds", { status: 400 });
+    }
+
+    if (timeoutInSeconds !== undefined && timeoutInSeconds < 1) {
+      return new Response("Timeout seconds must be greater than 0", { status: 400 });
+    }
+
+    if (timeoutInSeconds !== undefined && timeoutInSeconds > 600) {
+      return new Response("Timeout seconds must be less than 600", { status: 400 });
+    }
+
+    const realtimeStream = getRealtimeStreamInstance(
+      authentication.environment,
+      run.realtimeStreamsVersion
+    );
+
+    // Read from the internal S2 stream name (prefixed to avoid user stream collisions)
+    return realtimeStream.streamResponse(
+      request,
+      run.friendlyId,
+      `$trigger.input:${params.streamId}`,
+      request.signal,
+      {
+        lastEventId,
+        timeoutInSeconds,
+      }
+    );
+  }
+);
+
+export { action, loader };
diff --git a/apps/webapp/app/routes/resources.branches.archive.tsx b/apps/webapp/app/routes/resources.branches.archive.tsx
index 57ba061bf01..6421e5588e1 100644
--- a/apps/webapp/app/routes/resources.branches.archive.tsx
+++ b/apps/webapp/app/routes/resources.branches.archive.tsx
@@ -120,7 +120,7 @@ export function ArchiveButton({
               }
               cancelButton={
                 <DialogClose asChild>
-                  <Button variant="tertiary/medium">Cancel</Button>
+                  <Button variant="secondary/medium">Cancel</Button>
                 </DialogClose>
               }
             />
diff --git a/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx b/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
index 7ad6b1c6c57..5efb69bc723 100644
--- a/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
+++ b/apps/webapp/app/routes/resources.environments.$environmentId.regenerate-api-key.tsx
@@ -2,8 +2,10 @@ import type { ActionFunctionArgs } from "@remix-run/server-runtime";
 import { z } from "zod";
 import { environmentFullTitle } from "~/components/environments/EnvironmentLabel";
 import { regenerateApiKey } from "~/models/api-key.server";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
 import { jsonWithErrorMessage, jsonWithSuccessMessage } from "~/models/message.server";
 import { requireUserId } from "~/services/session.server";
+import { logger } from "~/services/logger.server";
 
 const ParamsSchema = z.object({
   environmentId: z.string(),
@@ -19,9 +21,21 @@ export async function action({ request, params }: ActionFunctionArgs) {
 
   const { environmentId } = ParamsSchema.parse(params);
 
+  const formData = await request.formData();
+  const syncToVercel = formData.get("syncToVercel") === "on";
+
   try {
     const updatedEnvironment = await regenerateApiKey({ userId, environmentId });
 
+    // Sync the regenerated API key to Vercel only when requested and not for DEVELOPMENT
+    if (syncToVercel && updatedEnvironment.type !== "DEVELOPMENT") {
+      await syncApiKeyToVercel(
+        updatedEnvironment.projectId,
+        updatedEnvironment.type as "PRODUCTION" | "STAGING" | "PREVIEW",
+        updatedEnvironment.apiKey
+      );
+    }
+
     return jsonWithSuccessMessage(
       { ok: true },
       request,
@@ -37,3 +51,27 @@ export async function action({ request, params }: ActionFunctionArgs) {
     );
   }
 }
+
+/**
+ * Sync the API key to Vercel.
+ * Errors are logged but won't fail the API key regeneration.
+ */
+async function syncApiKeyToVercel(
+  projectId: string,
+  environmentType: "PRODUCTION" | "STAGING" | "PREVIEW" | "DEVELOPMENT",
+  apiKey: string
+): Promise<void> {
+  const result = await VercelIntegrationRepository.syncSingleApiKeyToVercel({
+    projectId,
+    environmentType,
+    apiKey,
+  });
+
+  if (result.isErr()) {
+    logger.warn("syncSingleApiKeyToVercel returned failure", {
+      projectId,
+      environmentType,
+      error: result.error.message,
+    });
+  }
+}
diff --git a/apps/webapp/app/routes/resources.incidents.tsx b/apps/webapp/app/routes/resources.incidents.tsx
index 319242c8d80..d9e107e5454 100644
--- a/apps/webapp/app/routes/resources.incidents.tsx
+++ b/apps/webapp/app/routes/resources.incidents.tsx
@@ -1,83 +1,158 @@
 import { ExclamationTriangleIcon } from "@heroicons/react/20/solid";
 import { json } from "@remix-run/node";
-import { useFetcher } from "@remix-run/react";
-import { useCallback, useEffect } from "react";
+import { useFetcher, type ShouldRevalidateFunction } from "@remix-run/react";
 import { motion } from "framer-motion";
+import { useEffect, useRef } from "react";
 import { LinkButton } from "~/components/primitives/Buttons";
 import { Paragraph } from "~/components/primitives/Paragraph";
+import { Popover, PopoverContent, PopoverTrigger } from "~/components/primitives/Popover";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
 import { useFeatures } from "~/hooks/useFeatures";
-import { BetterStackClient } from "~/services/betterstack/betterstack.server";
+import { BetterStackClient, type AggregateState } from "~/services/betterstack/betterstack.server";
+
+// Prevent Remix from revalidating this route when other fetchers submit
+export const shouldRevalidate: ShouldRevalidateFunction = () => false;
+
+export type IncidentLoaderData = {
+  status: AggregateState;
+  title: string | null;
+};
 
 export async function loader() {
   const client = new BetterStackClient();
-  const result = await client.getIncidents();
+  const result = await client.getIncidentStatus();
 
   if (!result.success) {
-    return json({ operational: true });
+    return json<IncidentLoaderData>({ status: "operational", title: null });
   }
 
-  return json({
-    operational: result.data.attributes.aggregate_state === "operational",
+  return json<IncidentLoaderData>({
+    status: result.data.status,
+    title: result.data.title,
   });
 }
 
-export function IncidentStatusPanel() {
-  const { isManagedCloud } = useFeatures();
-  if (!isManagedCloud) {
-    return null;
-  }
+const DEFAULT_MESSAGE =
+  "Our team is working on resolving the issue. Check our status page for more information.";
+
+const POLL_INTERVAL_MS = 60_000;
 
+/** Hook to fetch and poll incident status */
+export function useIncidentStatus() {
+  const { isManagedCloud } = useFeatures();
   const fetcher = useFetcher<typeof loader>();
+  const hasInitiallyFetched = useRef(false);
+
+  useEffect(() => {
+    if (!isManagedCloud) return;
 
-  const fetchIncidents = useCallback(() => {
-    if (fetcher.state === "idle") {
+    // Initial fetch on mount
+    if (!hasInitiallyFetched.current && fetcher.state === "idle") {
+      hasInitiallyFetched.current = true;
       fetcher.load("/resources/incidents");
     }
-  }, [fetcher]);
 
-  useEffect(() => {
-    fetchIncidents();
-
-    const interval = setInterval(fetchIncidents, 60 * 1000); // 1 minute
+    // Poll every 60 seconds
+    const interval = setInterval(() => {
+      if (fetcher.state === "idle") {
+        fetcher.load("/resources/incidents");
+      }
+    }, POLL_INTERVAL_MS);
 
     return () => clearInterval(interval);
-  }, []);
+  }, [isManagedCloud]);
+
+  return {
+    status: fetcher.data?.status ?? "operational",
+    title: fetcher.data?.title ?? null,
+    hasIncident: (fetcher.data?.status ?? "operational") !== "operational",
+    isManagedCloud,
+  };
+}
+
+export function IncidentStatusPanel({
+  isCollapsed = false,
+  title,
+  hasIncident,
+  isManagedCloud,
+}: {
+  isCollapsed?: boolean;
+  title: string | null;
+  hasIncident: boolean;
+  isManagedCloud: boolean;
+}) {
+  if (!isManagedCloud || !hasIncident) {
+    return null;
+  }
 
-  const operational = fetcher.data?.operational ?? true;
+  const message = title || DEFAULT_MESSAGE;
 
   return (
-    <>
-      {!operational && (
+    <Popover>
+      <div className="p-1">
+        <motion.div
+          initial={false}
+          animate={{
+            height: isCollapsed ? 0 : "auto",
+            opacity: isCollapsed ? 0 : 1,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
+        >
+          <IncidentPanelContent message={message} />
+        </motion.div>
+
         <motion.div
-          initial={{ opacity: 0 }}
-          animate={{ opacity: 1 }}
-          exit={{ opacity: 0 }}
-          transition={{ duration: 0.3 }}
-          className="p-1"
+          initial={false}
+          animate={{
+            height: isCollapsed ? "auto" : 0,
+            opacity: isCollapsed ? 1 : 0,
+          }}
+          transition={{ duration: 0.15 }}
+          className="overflow-hidden"
         >
-          <div className="flex flex-col gap-2 rounded border border-warning/20 bg-warning/5 p-2 pt-1.5">
-            <div className="flex items-center gap-1 border-b border-warning/20 pb-1 text-warning">
-              <ExclamationTriangleIcon className="size-4" />
-              <Paragraph variant="small/bright" className="text-warning">
-                Active incident
-              </Paragraph>
-            </div>
-            <Paragraph variant="extra-small/bright" className="text-warning/80">
-              Our team is working on resolving the issue. Check our status page for more
-              information.
-            </Paragraph>
-            <LinkButton
-              variant="secondary/small"
-              to="https://status.trigger.dev"
-              target="_blank"
-              fullWidth
-              className="border-warning/20 bg-warning/10 hover:!border-warning/30 hover:!bg-warning/20"
-            >
-              <span className="text-warning">View status page</span>
-            </LinkButton>
-          </div>
+          <SimpleTooltip
+            button={
+              <PopoverTrigger className="flex !h-8 w-full items-center justify-center rounded border border-yellow-500/30 bg-yellow-500/15 transition-colors hover:border-yellow-500/50 hover:bg-yellow-500/25">
+                <ExclamationTriangleIcon className="size-5 text-yellow-400" />
+              </PopoverTrigger>
+            }
+            content="Active incident"
+            side="right"
+            sideOffset={8}
+            disableHoverableContent
+            asChild
+          />
         </motion.div>
-      )}
-    </>
+      </div>
+      <PopoverContent side="right" sideOffset={8} align="start" className="!min-w-0 w-52 p-0">
+        <IncidentPanelContent message={message} />
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function IncidentPanelContent({ message }: { message: string }) {
+  return (
+    <div className="flex flex-col gap-2 rounded border border-yellow-500/30 bg-yellow-500/10 p-2 pt-1.5">
+      <div className="flex items-center gap-1 border-b border-yellow-500/30 pb-1">
+        <ExclamationTriangleIcon className="size-4 text-yellow-400" />
+        <Paragraph variant="small/bright" className="text-yellow-300">
+          Active incident
+        </Paragraph>
+      </div>
+      <Paragraph variant="extra-small/bright" className="text-yellow-300">
+        {message}
+      </Paragraph>
+      <LinkButton
+        variant="secondary/small"
+        to="https://status.trigger.dev"
+        target="_blank"
+        fullWidth
+        className="border-yellow-500/30 bg-yellow-500/15 hover:!border-yellow-500/50 hover:!bg-yellow-500/25"
+      >
+        <span className="text-yellow-300">View status page</span>
+      </LinkButton>
+    </div>
   );
 }
diff --git a/apps/webapp/app/routes/resources.metric.tsx b/apps/webapp/app/routes/resources.metric.tsx
new file mode 100644
index 00000000000..bc6e46318e1
--- /dev/null
+++ b/apps/webapp/app/routes/resources.metric.tsx
@@ -0,0 +1,312 @@
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { z } from "zod";
+import { requireUserId } from "~/services/session.server";
+import { hasAccessToEnvironment } from "~/models/runtimeEnvironment.server";
+import { executeQuery } from "~/services/queryService.server";
+import {
+  QueryWidget,
+  type QueryWidgetConfig,
+  type QueryWidgetData,
+} from "~/components/metrics/QueryWidget";
+import { useElementVisibility } from "~/hooks/useElementVisibility";
+import { useInterval } from "~/hooks/useInterval";
+import { env } from "~/env.server";
+
+const Scope = z.union([z.literal("environment"), z.literal("organization"), z.literal("project")]);
+
+// Response type for the action
+type MetricWidgetActionResponse =
+  | { success: false; error: string }
+  | {
+      success: true;
+      data: {
+        rows: Record<string, unknown>[];
+        columns: OutputColumnMetadata[];
+        stats: { elapsed_ns: string } | null;
+        hiddenColumns: string[] | null;
+        reachedMaxRows: boolean;
+        periodClipped: number | null;
+        maxQueryPeriod: number | undefined;
+        timeRange: { from: string; to: string };
+      };
+    };
+
+const MetricWidgetQuery = z.object({
+  query: z.string(),
+  organizationId: z.string(),
+  projectId: z.string(),
+  environmentId: z.string(),
+  scope: Scope,
+  period: z.string().nullable(),
+  from: z.string().nullable(),
+  to: z.string().nullable(),
+  taskIdentifiers: z.array(z.string()).optional(),
+  queues: z.array(z.string()).optional(),
+  responseModels: z.array(z.string()).optional(),
+  promptSlugs: z.array(z.string()).optional(),
+  promptVersions: z.array(z.number()).optional(),
+  operations: z.array(z.string()).optional(),
+  providers: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export const action = async ({ request }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+
+  const data = await request.json();
+  const submission = MetricWidgetQuery.safeParse(data);
+
+  if (!submission.success) {
+    return json(
+      {
+        success: false as const,
+        error: "Invalid input",
+      },
+      { status: 400 }
+    );
+  }
+
+  const {
+    query,
+    organizationId,
+    projectId,
+    environmentId,
+    scope,
+    period,
+    from,
+    to,
+    taskIdentifiers,
+    queues,
+    responseModels,
+    promptSlugs,
+    promptVersions,
+    operations,
+    providers,
+    tags,
+  } = submission.data;
+
+  // Check they should be able to access it
+  const hasAccess = await hasAccessToEnvironment({
+    environmentId,
+    projectId,
+    organizationId,
+    userId,
+  });
+
+  if (!hasAccess) {
+    return json(
+      {
+        success: false as const,
+        error: "You don't have permission for this resource",
+      },
+      { status: 400 }
+    );
+  }
+
+  const queryResult = await executeQuery({
+    name: "query-page",
+    query,
+    scope,
+    organizationId,
+    projectId,
+    environmentId,
+    period,
+    from,
+    to,
+    taskIdentifiers,
+    queues,
+    responseModels,
+    promptSlugs,
+    promptVersions,
+    operations,
+    providers,
+    // Set higher concurrency if many widgets are on screen at once
+    customOrgConcurrencyLimit: env.METRIC_WIDGET_DEFAULT_ORG_CONCURRENCY_LIMIT,
+  });
+
+  if (!queryResult.success) {
+    return json(
+      {
+        success: false as const,
+        error: queryResult.error.message,
+      },
+      { status: 400 }
+    );
+  }
+
+  return json({
+    success: true as const,
+    data: {
+      rows: queryResult.result.rows,
+      columns: queryResult.result.columns,
+      stats: queryResult.result.stats,
+      hiddenColumns: queryResult.result.hiddenColumns ?? null,
+      reachedMaxRows: queryResult.result.reachedMaxRows,
+      periodClipped: queryResult.periodClipped,
+      maxQueryPeriod: queryResult.maxQueryPeriod,
+      timeRange: {
+        from: queryResult.timeRange.from.toISOString(),
+        to: queryResult.timeRange.to.toISOString(),
+      },
+    },
+  });
+};
+
+type MetricWidgetProps = {
+  /** Unique key for this widget - used to identify the fetcher */
+  widgetKey: string;
+  title: string;
+  config: QueryWidgetConfig;
+  refreshIntervalMs?: number;
+  isResizing?: boolean;
+  isDraggable?: boolean;
+  /** Callback when edit button is clicked - receives current data */
+  onEdit?: (data: QueryWidgetData) => void;
+  /** Callback when rename is clicked - receives new title */
+  onRename?: (newTitle: string) => void;
+  /** Callback when delete is clicked */
+  onDelete?: () => void;
+  /** Callback when duplicate is clicked - receives current data */
+  onDuplicate?: (data: QueryWidgetData) => void;
+  /** Column names to hide from table display but keep in row data (useful for linking) */
+  hiddenColumns?: string[];
+} & z.infer<typeof MetricWidgetQuery>;
+
+export function MetricWidget({
+  widgetKey,
+  title,
+  config,
+  refreshIntervalMs,
+  isResizing,
+  isDraggable,
+  onEdit,
+  onRename,
+  onDelete,
+  onDuplicate,
+  hiddenColumns,
+  ...props
+}: MetricWidgetProps) {
+  const [response, setResponse] = useState<MetricWidgetActionResponse | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const isDirtyRef = useRef(false);
+
+  // Track the latest props so the submit callback always uses fresh values
+  // without needing to be recreated (which would cause useInterval to re-register listeners).
+  const propsRef = useRef(props);
+  propsRef.current = props;
+
+  const submit = useCallback(() => {
+    if (!isVisibleRef.current) {
+      isDirtyRef.current = true;
+      return;
+    }
+    isDirtyRef.current = false;
+
+    // Abort any in-flight request for this widget
+    abortControllerRef.current?.abort();
+
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+    setIsLoading(true);
+
+    fetch(`/resources/metric`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(propsRef.current),
+      signal: controller.signal,
+    })
+      .then(async (res) => {
+        try {
+          return (await res.json()) as MetricWidgetActionResponse;
+        } catch {
+          throw new Error(`Request failed (${res.status})`);
+        }
+      })
+      .then((data) => {
+        if (!controller.signal.aborted) {
+          setResponse(data);
+          setIsLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (!controller.signal.aborted) {
+          // Only surface the error if there's no existing successful data to preserve
+          setResponse((prev) =>
+            prev?.success ? prev : { success: false, error: err.message || "Network error" }
+          );
+          setIsLoading(false);
+        }
+      });
+  }, []);
+
+  // Track visibility so we only fetch for on-screen widgets.
+  // When a widget scrolls into view and has no data yet, trigger a load.
+  const { ref: visibilityRef, isVisibleRef } = useElementVisibility({
+    onVisibilityChange: (visible) => {
+      if (visible && (!response || isDirtyRef.current)) {
+        submit();
+      }
+    },
+  });
+
+  // Clean up on unmount
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+
+  // Reload periodically and on focus (onLoad: false — the useEffect below handles initial load)
+  useInterval({ interval: refreshIntervalMs, callback: submit, onLoad: false });
+
+  // Reload on mount and when query, time period, or filters change
+  useEffect(() => {
+    submit();
+  }, [
+    submit,
+    props.query,
+    props.from,
+    props.to,
+    props.period,
+    props.scope,
+    JSON.stringify(props.taskIdentifiers),
+    JSON.stringify(props.queues),
+    JSON.stringify(props.responseModels),
+    JSON.stringify(props.promptSlugs),
+    JSON.stringify(props.promptVersions),
+    JSON.stringify(props.operations),
+    JSON.stringify(props.providers),
+  ]);
+
+  const data = response?.success
+    ? { rows: response.data.rows, columns: response.data.columns }
+    : { rows: [], columns: [] };
+
+  const timeRange = response?.success ? response.data.timeRange : undefined;
+
+  return (
+    <div ref={visibilityRef} className="h-full">
+      <QueryWidget
+        title={title}
+        titleString={title}
+        query={props.query}
+        config={config}
+        isLoading={isLoading}
+        data={data}
+        timeRange={timeRange}
+        error={response?.success === false ? response.error : undefined}
+        isResizing={isResizing}
+        isDraggable={isDraggable}
+        onEdit={onEdit}
+        onRename={onRename}
+        onDelete={onDelete}
+        onDuplicate={onDuplicate}
+        hiddenColumns={hiddenColumns}
+      />
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.can-view-logs-page/route.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.can-view-logs-page/route.tsx
new file mode 100644
index 00000000000..f55307c7c34
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.can-view-logs-page/route.tsx
@@ -0,0 +1,53 @@
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { typedjson } from "remix-typedjson";
+import { requireUser } from "~/services/session.server";
+import { prisma } from "~/db.server";
+import { FEATURE_FLAG, validateFeatureFlagValue } from "~/v3/featureFlags";
+import { OrganizationParamsSchema } from "~/utils/pathBuilder";
+
+async function hasLogsPageAccess(
+  userId: string,
+  isAdmin: boolean,
+  isImpersonating: boolean,
+  organizationSlug: string
+): Promise<boolean> {
+  if (isAdmin || isImpersonating) {
+    return true;
+  }
+
+  const organization = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+    },
+    select: {
+      featureFlags: true,
+    },
+  });
+
+  if (!organization?.featureFlags) {
+    return false;
+  }
+
+  const flags = organization.featureFlags as Record<string, unknown>;
+  const hasLogsPageAccessResult = validateFeatureFlagValue(
+    FEATURE_FLAG.hasLogsPageAccess,
+    flags.hasLogsPageAccess
+  );
+
+  return hasLogsPageAccessResult.success && hasLogsPageAccessResult.data === true;
+}
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+
+  const canViewLogsPage = user.admin || user.isImpersonating || await hasLogsPageAccess(
+    user.id,
+    user.admin,
+    user.isImpersonating,
+    organizationSlug
+  );
+
+  return typedjson({ canViewLogsPage });
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardId.widgets.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardId.widgets.tsx
new file mode 100644
index 00000000000..51bbded5932
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.$dashboardId.widgets.tsx
@@ -0,0 +1,492 @@
+import { type ActionFunctionArgs } from "@remix-run/node";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { typedjson } from "remix-typedjson";
+import { prisma } from "~/db.server";
+import { QueryWidgetConfig } from "~/components/metrics/QueryWidget";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import {
+  DashboardLayout,
+  LayoutItem,
+} from "~/presenters/v3/MetricDashboardPresenter.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+
+// Schemas for each action type
+const AddWidgetSchema = z.object({
+  widgetId: z.string().min(1, "Widget ID is required").nullish(),
+  title: z.string().min(1, "Title is required"),
+  query: z.string().default(""),
+  config: z.string().transform((str, ctx) => {
+    try {
+      const parsed = JSON.parse(str);
+      const result = QueryWidgetConfig.safeParse(parsed);
+      if (!result.success) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Invalid widget config",
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    } catch {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid JSON",
+      });
+      return z.NEVER;
+    }
+  }),
+});
+
+const UpdateWidgetSchema = z.object({
+  widgetId: z.string().min(1, "Widget ID is required"),
+  title: z.string().min(1, "Title is required"),
+  query: z.string().min(1, "Query is required"),
+  config: z.string().transform((str, ctx) => {
+    try {
+      const parsed = JSON.parse(str);
+      const result = QueryWidgetConfig.safeParse(parsed);
+      if (!result.success) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Invalid widget config",
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    } catch {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid JSON",
+      });
+      return z.NEVER;
+    }
+  }),
+});
+
+const RenameWidgetSchema = z.object({
+  widgetId: z.string().min(1, "Widget ID is required"),
+  title: z.string().min(1, "Title is required"),
+});
+
+const DeleteWidgetSchema = z.object({
+  widgetId: z.string().min(1, "Widget ID is required"),
+});
+
+const DuplicateWidgetSchema = z.object({
+  widgetId: z.string().min(1, "Widget ID is required"),
+  newId: z.string().min(1, "New widget ID is required").nullish(),
+});
+
+const SaveLayoutSchema = z.object({
+  layout: z.string().transform((str, ctx) => {
+    try {
+      const parsed = JSON.parse(str);
+      const result = z.array(LayoutItem).safeParse(parsed);
+      if (!result.success) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Invalid layout format",
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    } catch {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid JSON",
+      });
+      return z.NEVER;
+    }
+  }),
+});
+
+const ParamsSchema = EnvironmentParamSchema.extend({
+  dashboardId: z.string(),
+});
+
+// Check widget limit for add/duplicate actions (title widgets don't count)
+async function checkWidgetLimit(
+  existingLayout: z.infer<typeof DashboardLayout>,
+  organizationId: string
+) {
+  const currentWidgetCount = Object.values(existingLayout.widgets).filter(
+    (w) => w.display.type !== "title"
+  ).length;
+  const plan = await getCurrentPlan(organizationId);
+  const metricWidgetsLimitValue = (plan?.v3Subscription?.plan?.limits as any)
+    ?.metricWidgetsPerDashboard;
+  const widgetLimit =
+    typeof metricWidgetsLimitValue === "number"
+      ? metricWidgetsLimitValue
+      : (metricWidgetsLimitValue?.number ?? 16);
+
+  if (currentWidgetCount >= widgetLimit) {
+    throw new Response("Widget limit reached", { status: 403 });
+  }
+}
+
+// Optimistic concurrency save: uses updateMany so we can include updatedAt
+// in the where clause. If another request modified the dashboard between our
+// read and this write, updatedAt won't match and count will be 0.
+async function saveDashboardLayout(
+  dashboardId: string,
+  expectedUpdatedAt: Date,
+  updatedLayout: z.infer<typeof DashboardLayout>
+) {
+  const result = await prisma.metricsDashboard.updateMany({
+    where: { id: dashboardId, updatedAt: expectedUpdatedAt },
+    data: {
+      layout: JSON.stringify(updatedLayout),
+    },
+  });
+
+  if (result.count === 0) {
+    throw new Response(
+      "Dashboard was modified by another request. Please refresh and try again.",
+      { status: 409 }
+    );
+  }
+}
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, dashboardId } = ParamsSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  // Load the dashboard
+  const dashboard = await prisma.metricsDashboard.findFirst({
+    where: {
+      friendlyId: dashboardId,
+      organizationId: project.organizationId,
+    },
+  });
+
+  if (!dashboard) {
+    throw new Response("Dashboard not found", { status: 404 });
+  }
+
+  const formData = await request.formData();
+  const action = formData.get("action");
+
+  // Parse existing layout (shared across all actions)
+  let existingLayout: z.infer<typeof DashboardLayout>;
+  try {
+    const parsed = JSON.parse(dashboard.layout);
+    const layoutResult = DashboardLayout.safeParse(parsed);
+    if (!layoutResult.success) {
+      // For add action, we can start with empty layout
+      if (action === "add") {
+        existingLayout = {
+          version: "1",
+          layout: [],
+          widgets: {},
+        };
+      } else {
+        throw new Response("Invalid dashboard layout", { status: 500 });
+      }
+    } else {
+      existingLayout = layoutResult.data;
+    }
+  } catch (e) {
+    if (e instanceof Response) throw e;
+    if (action === "add") {
+      existingLayout = {
+        version: "1",
+        layout: [],
+        widgets: {},
+      };
+    } else {
+      throw new Response("Failed to parse dashboard layout", { status: 500 });
+    }
+  }
+
+  switch (action) {
+    case "add": {
+      const rawData = {
+        widgetId: formData.get("widgetId"),
+        title: formData.get("title"),
+        query: formData.get("query"),
+        config: formData.get("config"),
+      };
+
+      const result = AddWidgetSchema.safeParse(rawData);
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      const { title, query, config } = result.data;
+
+      // Validate that non-title widgets have a query
+      if (config.type !== "title" && !query) {
+        throw new Response("Query is required for chart widgets", { status: 400 });
+      }
+
+      // Title widgets don't count against the limit
+      if (config.type !== "title") {
+        await checkWidgetLimit(existingLayout, project.organizationId);
+      }
+
+      // Use client-provided widget ID if available, otherwise generate one
+      // Using the client's ID ensures optimistic UI state stays in sync with the server
+      const widgetId = result.data.widgetId || nanoid(8);
+
+      // Calculate position at the bottom
+      let maxBottom = 0;
+      for (const item of existingLayout.layout) {
+        const itemBottom = item.y + item.h;
+        if (itemBottom > maxBottom) {
+          maxBottom = itemBottom;
+        }
+      }
+
+      // Add new layout item (full width, height depends on widget type)
+      const newLayoutItem = {
+        i: widgetId,
+        x: 0,
+        y: maxBottom,
+        w: 12,
+        h: config.type === "title" ? 2 : 15,
+      };
+
+      // Add new widget
+      const newWidget = {
+        title,
+        query,
+        display: config,
+      };
+
+      // Update the layout
+      const updatedLayout = {
+        ...existingLayout,
+        layout: [...existingLayout.layout, newLayoutItem],
+        widgets: {
+          ...existingLayout.widgets,
+          [widgetId]: newWidget,
+        },
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true, widgetId });
+    }
+
+    case "update": {
+      const rawData = {
+        widgetId: formData.get("widgetId"),
+        title: formData.get("title"),
+        query: formData.get("query"),
+        config: formData.get("config"),
+      };
+
+      const result = UpdateWidgetSchema.safeParse(rawData);
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      const { widgetId, title, query, config } = result.data;
+
+      // Check if widget exists
+      if (!existingLayout.widgets[widgetId]) {
+        throw new Response("Widget not found", { status: 404 });
+      }
+
+      // Update the widget
+      const updatedWidget = {
+        title,
+        query,
+        display: config,
+      };
+
+      // Update the layout
+      const updatedLayout = {
+        ...existingLayout,
+        widgets: {
+          ...existingLayout.widgets,
+          [widgetId]: updatedWidget,
+        },
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true, updatedTitle: title });
+    }
+
+    case "rename": {
+      const rawData = {
+        widgetId: formData.get("widgetId"),
+        title: formData.get("title"),
+      };
+
+      const result = RenameWidgetSchema.safeParse(rawData);
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      const { widgetId, title } = result.data;
+
+      // Check if widget exists
+      if (!existingLayout.widgets[widgetId]) {
+        throw new Response("Widget not found", { status: 404 });
+      }
+
+      // Update just the title
+      const updatedLayout = {
+        ...existingLayout,
+        widgets: {
+          ...existingLayout.widgets,
+          [widgetId]: {
+            ...existingLayout.widgets[widgetId],
+            title,
+          },
+        },
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true, renamedTitle: title });
+    }
+
+    case "delete": {
+      const rawData = {
+        widgetId: formData.get("widgetId"),
+      };
+
+      const result = DeleteWidgetSchema.safeParse(rawData);
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      const { widgetId } = result.data;
+
+      // Get widget title before deleting (for the success message)
+      const widget = existingLayout.widgets[widgetId];
+      const widgetTitle = widget?.title ?? "Widget";
+
+      // Remove widget from layout and widgets
+      const updatedLayout = {
+        ...existingLayout,
+        layout: existingLayout.layout.filter((item) => item.i !== widgetId),
+        widgets: Object.fromEntries(
+          Object.entries(existingLayout.widgets).filter(([key]) => key !== widgetId)
+        ),
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true, deletedTitle: widgetTitle });
+    }
+
+    case "duplicate": {
+      await checkWidgetLimit(existingLayout, project.organizationId);
+
+      const rawData = {
+        widgetId: formData.get("widgetId"),
+        newId: formData.get("newId"),
+      };
+
+      const result = DuplicateWidgetSchema.safeParse(rawData);
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      const { widgetId } = result.data;
+
+      // Find the original widget
+      const originalWidget = existingLayout.widgets[widgetId];
+      if (!originalWidget) {
+        throw new Response("Widget not found", { status: 404 });
+      }
+
+      // Find the original layout item
+      const originalLayoutItem = existingLayout.layout.find((item) => item.i === widgetId);
+      if (!originalLayoutItem) {
+        throw new Response("Widget layout not found", { status: 404 });
+      }
+
+      // Use client-provided ID if available, otherwise generate one
+      // Using the client's ID ensures optimistic UI state stays in sync with the server
+      const newWidgetId = result.data.newId || nanoid(8);
+
+      // Calculate position at the bottom
+      let maxBottom = 0;
+      for (const item of existingLayout.layout) {
+        const itemBottom = item.y + item.h;
+        if (itemBottom > maxBottom) {
+          maxBottom = itemBottom;
+        }
+      }
+
+      // Create new layout item with same dimensions but at the bottom
+      const newLayoutItem = {
+        i: newWidgetId,
+        x: 0,
+        y: maxBottom,
+        w: originalLayoutItem.w,
+        h: originalLayoutItem.h,
+      };
+
+      // Create new widget with "(Copy)" suffix
+      const newWidget = {
+        ...originalWidget,
+        title: `${originalWidget.title} (Copy)`,
+      };
+
+      // Update the layout
+      const updatedLayout = {
+        ...existingLayout,
+        layout: [...existingLayout.layout, newLayoutItem],
+        widgets: {
+          ...existingLayout.widgets,
+          [newWidgetId]: newWidget,
+        },
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true, duplicatedTitle: originalWidget.title });
+    }
+
+    case "layout": {
+      const result = SaveLayoutSchema.safeParse({
+        layout: formData.get("layout"),
+      });
+
+      if (!result.success) {
+        throw new Response("Invalid form data: " + result.error.message, { status: 400 });
+      }
+
+      // Update layout positions while preserving widgets
+      const updatedLayout = {
+        ...existingLayout,
+        layout: result.data.layout,
+      };
+
+      // Save to database (with optimistic concurrency check)
+      await saveDashboardLayout(dashboard.id, dashboard.updatedAt, updatedLayout);
+
+      return typedjson({ success: true });
+    }
+
+    default: {
+      throw new Response("Invalid action", { status: 400 });
+    }
+  }
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.create.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.create.tsx
new file mode 100644
index 00000000000..1e33b3b6817
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboards.create.tsx
@@ -0,0 +1,84 @@
+import { redirect, type ActionFunctionArgs } from "@remix-run/node";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema, v3CustomDashboardPath } from "~/utils/pathBuilder";
+import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
+
+const CreateDashboardSchema = z.object({
+  title: z.string().min(1, "Title is required"),
+  description: z.string().optional().default(""),
+});
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  // Check dashboard limit
+  const [plan, existingCount] = await Promise.all([
+    getCurrentPlan(project.organizationId),
+    prisma.metricsDashboard.count({
+      where: { organizationId: project.organizationId },
+    }),
+  ]);
+
+  const metricDashboardsLimitValue = (plan?.v3Subscription?.plan?.limits as any)
+    ?.metricDashboards;
+  const dashboardLimit =
+    typeof metricDashboardsLimitValue === "number"
+      ? metricDashboardsLimitValue
+      : (metricDashboardsLimitValue?.number ?? 3);
+
+  if (existingCount >= dashboardLimit) {
+    throw new Response("Dashboard limit reached", { status: 403 });
+  }
+
+  const formData = await request.formData();
+  const rawData = {
+    title: formData.get("title"),
+    description: formData.get("description") ?? "",
+  };
+
+  const result = CreateDashboardSchema.safeParse(rawData);
+  if (!result.success) {
+    throw new Response("Invalid form data", { status: 400 });
+  }
+
+  const { title, description } = result.data;
+
+  // Create empty default layout
+  const defaultLayout = JSON.stringify({
+    version: "1",
+    layout: [],
+    widgets: {},
+  });
+
+  const dashboard = await prisma.metricsDashboard.create({
+    data: {
+      friendlyId: generateFriendlyId("dashboard"),
+      title,
+      description,
+      organizationId: project.organizationId,
+      projectId: project.id,
+      ownerId: userId,
+      layout: defaultLayout,
+    },
+  });
+
+  // Redirect to the new dashboard
+  return redirect(
+    v3CustomDashboardPath(
+      { slug: organizationSlug },
+      { slug: projectParam },
+      { slug: envParam },
+      { friendlyId: dashboard.friendlyId }
+    )
+  );
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
index bb7406ed440..15062a718bc 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.github.tsx
@@ -3,7 +3,8 @@ import { parse } from "@conform-to/zod";
 import { CheckCircleIcon, LockClosedIcon, PlusIcon } from "@heroicons/react/20/solid";
 import { Form, useActionData, useNavigation, useNavigate, useSearchParams, useLocation } from "@remix-run/react";
 import { type ActionFunctionArgs, type LoaderFunctionArgs, json } from "@remix-run/server-runtime";
-import { typedjson, useTypedFetcher } from "remix-typedjson";
+import { redirect,
+typedjson, useTypedFetcher } from "remix-typedjson";
 import { z } from "zod";
 import { OctoKitty } from "~/components/GitHubLoginButton";
 import { Dialog, DialogContent, DialogHeader, DialogTrigger } from "~/components/primitives/Dialog";
@@ -39,11 +40,13 @@ import { findProjectBySlug } from "~/models/project.server";
 import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import { ProjectSettingsService } from "~/services/projectSettings.server";
 import { logger } from "~/services/logger.server";
+import { triggerInitialDeployment } from "~/services/platform.v3.server";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
 import { requireUserId } from "~/services/session.server";
 import {
   githubAppInstallPath,
   EnvironmentParamSchema,
-  v3ProjectSettingsPath,
+  v3ProjectSettingsIntegrationsPath,
 } from "~/utils/pathBuilder";
 import { cn } from "~/utils/cn";
 import { type BranchTrackingConfig } from "~/v3/github";
@@ -208,6 +211,24 @@ export async function action({ request, params }: ActionFunctionArgs) {
     );
 
     if (resultOrFail.isOk()) {
+      // Trigger initial deployment for marketplace flows now that GitHub is connected.
+      // We check the persisted onboardingOrigin on the Vercel integration rather than
+      // the redirectUrl, because the redirect URL loses the marketplace context when
+      // the user installs the GitHub App for the first time (full-page redirect cycle).
+      try {
+        const vercelService = new VercelIntegrationService();
+        const vercelIntegration = await vercelService.getVercelProjectIntegration(projectId);
+        if (
+          vercelIntegration?.parsedIntegrationData.onboardingCompleted &&
+          vercelIntegration.parsedIntegrationData.onboardingOrigin === "marketplace"
+        ) {
+          logger.info("Marketplace flow detected, triggering initial deployment", { projectId });
+          await triggerInitialDeployment(projectId, { environment: "prod" });
+        }
+      } catch (error) {
+        logger.error("Failed to check Vercel integration or trigger initial deployment", { projectId, error });
+      }
+
       return redirectWithMessage(
         request,
         redirectUrl,
@@ -330,12 +351,15 @@ export function ConnectGitHubRepoModal({
   projectSlug,
   environmentSlug,
   redirectUrl,
+  preventDismiss,
 }: {
   gitHubAppInstallations: GitHubAppInstallation[];
   organizationSlug: string;
   projectSlug: string;
   environmentSlug: string;
   redirectUrl?: string;
+  /** When true, prevents closing the modal via Escape key or clicking outside */
+  preventDismiss?: boolean;
 }) {
   const [isModalOpen, setIsModalOpen] = useState(false);
   const lastSubmission = useActionData() as any;
@@ -385,13 +409,34 @@ export function ConnectGitHubRepoModal({
   const actionUrl = gitHubResourcePath(organizationSlug, projectSlug, environmentSlug);
 
   return (
-    <Dialog open={isModalOpen} onOpenChange={setIsModalOpen}>
+    <Dialog
+      open={isModalOpen}
+      onOpenChange={(open) => {
+        // When preventDismiss is true, only allow opening, not closing
+        if (preventDismiss && !open) {
+          return;
+        }
+        setIsModalOpen(open);
+      }}
+    >
       <DialogTrigger asChild>
         <Button type="button" variant={"secondary/medium"} LeadingIcon={OctoKitty}>
           Connect GitHub repo
         </Button>
       </DialogTrigger>
-      <DialogContent>
+      <DialogContent
+        showCloseButton={!preventDismiss}
+        onInteractOutside={(e) => {
+          if (preventDismiss) {
+            e.preventDefault();
+          }
+        }}
+        onEscapeKeyDown={(e) => {
+          if (preventDismiss) {
+            e.preventDefault();
+          }
+        }}
+      >
         <DialogHeader>Connect GitHub repository</DialogHeader>
         <div className="mt-2 flex flex-col gap-4">
           <Form method="post" action={actionUrl} {...form.props} className="w-full">
@@ -435,7 +480,7 @@ export function ConnectGitHubRepoModal({
                         navigate(
                           githubAppInstallPath(
                             organizationSlug,
-                            `${v3ProjectSettingsPath(
+                            `${v3ProjectSettingsIntegrationsPath(
                               { slug: organizationSlug },
                               { slug: projectSlug },
                               { slug: environmentSlug }
@@ -514,9 +559,11 @@ export function ConnectGitHubRepoModal({
                   </Button>
                 }
                 cancelButton={
-                  <DialogClose asChild>
-                    <Button variant="tertiary/medium">Cancel</Button>
-                  </DialogClose>
+                  preventDismiss ? undefined : (
+                    <DialogClose asChild>
+                      <Button variant="tertiary/medium">Cancel</Button>
+                    </DialogClose>
+                  )
                 }
               />
             </Fieldset>
@@ -541,7 +588,7 @@ export function GitHubConnectionPrompt({
   redirectUrl?: string;
 }) {
 
-  const githubInstallationRedirect = redirectUrl || v3ProjectSettingsPath({ slug: organizationSlug }, { slug: projectSlug }, { slug: environmentSlug });
+  const githubInstallationRedirect = redirectUrl || v3ProjectSettingsIntegrationsPath({ slug: organizationSlug }, { slug: projectSlug }, { slug: environmentSlug });
   return (
     <Fieldset>
       <InputGroup fullWidth>
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.$logId.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.$logId.tsx
new file mode 100644
index 00000000000..f862ced6b05
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.$logId.tsx
@@ -0,0 +1,83 @@
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { typedjson } from "remix-typedjson";
+import { z } from "zod";
+import { logsClickhouseClient } from "~/services/clickhouseInstance.server";
+import { requireUserId } from "~/services/session.server";
+import { LogDetailPresenter } from "~/presenters/v3/LogDetailPresenter.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { $replica } from "~/db.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
+import type { TaskRunStatus } from "@trigger.dev/database";
+
+const LogIdParamsSchema = z.object({
+  organizationSlug: z.string(),
+  projectParam: z.string(),
+  envParam: z.string(),
+  logId: z.string(),
+});
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam, logId } = LogIdParamsSchema.parse(params);
+
+  // Validate access to project and environment
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  // Parse logId to extract traceId, spanId, runId, and startTime
+  // Format: {traceId}::{spanId}::{runId}::{startTime}
+  // All 4 parts are needed to uniquely identify a log entry (multiple events can share the same spanId)
+  const decodedLogId = decodeURIComponent(logId);
+  const parts = decodedLogId.split("::");
+  if (parts.length !== 4) {
+    throw new Response("Invalid log ID format", { status: 400 });
+  }
+
+  const [traceId, spanId, , startTime] = parts;
+
+  const presenter = new LogDetailPresenter($replica, logsClickhouseClient);
+
+  let result;
+  try {
+    result = await presenter.call({
+      environmentId: environment.id,
+      organizationId: project.organizationId,
+      projectId: project.id,
+      spanId,
+      traceId,
+      startTime,
+    });
+  } catch (error) {
+    if (error instanceof ServiceValidationError) {
+      throw new Response(error.message, { status: 400 });
+    }
+    throw error;
+  }
+
+  if (!result) {
+    throw new Response("Log not found", { status: 404 });
+  }
+
+  // Look up the run status from Postgres
+  let runStatus: TaskRunStatus | undefined;
+  if (result.runId) {
+    const run = await $replica.taskRun.findFirst({
+      select: { status: true },
+      where: {
+        friendlyId: result.runId,
+        runtimeEnvironmentId: environment.id,
+      },
+    });
+    runStatus = run?.status;
+  }
+
+  return typedjson({ ...result, runStatus });
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.ts b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.ts
new file mode 100644
index 00000000000..66ddebe4e2a
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.logs.ts
@@ -0,0 +1,79 @@
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/node";
+import { requireUser, requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { LogsListPresenter, type LogLevel, LogsListOptionsSchema } from "~/presenters/v3/LogsListPresenter.server";
+import { $replica } from "~/db.server";
+import { logsClickhouseClient } from "~/services/clickhouseInstance.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+
+// Valid log levels for filtering
+const validLevels: LogLevel[] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"];
+
+function parseLevelsFromUrl(url: URL): LogLevel[] | undefined {
+  const levelParams = url.searchParams.getAll("levels").filter((v) => v.length > 0);
+  if (levelParams.length === 0) return undefined;
+  return levelParams.filter((l): l is LogLevel => validLevels.includes(l as LogLevel));
+}
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const user = await requireUser(request);
+  const userId = user.id;
+
+  const { projectParam, organizationSlug, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  // Get the user's plan to determine log retention limit
+  const plan = await getCurrentPlan(project.organizationId);
+  const retentionLimitDays = plan?.v3Subscription?.plan?.limits.logRetentionDays.number ?? 30;
+
+  // Get filters from query params
+  const url = new URL(request.url);
+  const tasks = url.searchParams.getAll("tasks").filter((t) => t.length > 0);
+  const runId = url.searchParams.get("runId") ?? undefined;
+  const search = url.searchParams.get("search") ?? undefined;
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  const levels = parseLevelsFromUrl(url);
+  const period = url.searchParams.get("period") ?? undefined;
+  const fromStr = url.searchParams.get("from");
+  const toStr = url.searchParams.get("to");
+  let from = fromStr ? parseInt(fromStr, 10) : undefined;
+  let to = toStr ? parseInt(toStr, 10) : undefined;
+
+  if (Number.isNaN(from)) from = undefined;
+  if (Number.isNaN(to)) to = undefined;
+
+  const options = LogsListOptionsSchema.parse({
+    userId,
+    projectId: project.id,
+    tasks: tasks.length > 0 ? tasks : undefined,
+    runId,
+    search,
+    cursor,
+    period,
+    from,
+    to,
+    levels,
+    defaultPeriod: "1h",
+    retentionLimitDays,
+  }) as any; // Validated by LogsListOptionsSchema at runtime
+
+  const presenter = new LogsListPresenter($replica, logsClickhouseClient);
+  const result = await presenter.call(project.organizationId, environment.id, options);
+
+  return json({
+    logs: result.logs,
+    pagination: result.pagination,
+  });
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug.generations.ts b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug.generations.ts
new file mode 100644
index 00000000000..77a55ec3f0b
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.prompts.$promptSlug.generations.ts
@@ -0,0 +1,76 @@
+import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/node";
+import { z } from "zod";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { parsePeriodToMs } from "~/utils/periods";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import {
+  PromptPresenter,
+  type GenerationRow,
+  type GenerationsPagination,
+} from "~/presenters/v3/PromptPresenter.server";
+
+export type { GenerationRow, GenerationsPagination };
+
+export type GenerationsResponse = {
+  generations: GenerationRow[];
+  pagination: GenerationsPagination;
+};
+
+export const loader = async ({ request, params }: LoaderFunctionArgs) => {
+  const userId = await requireUserId(request);
+  const { projectParam, organizationSlug, envParam, promptSlug } =
+    EnvironmentParamSchema.extend({ promptSlug: z.string() }).parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) throw new Response("Project not found", { status: 404 });
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) throw new Response("Environment not found", { status: 404 });
+
+  const url = new URL(request.url);
+
+  const versions = url.searchParams
+    .getAll("versions")
+    .map(Number)
+    .filter((n) => Number.isInteger(n) && n > 0);
+
+  const period = url.searchParams.get("period") ?? "7d";
+  if (!/^\d+[mhdw]$/.test(period)) {
+    return json({ generations: [], pagination: {} } satisfies GenerationsResponse);
+  }
+
+  const fromTime = url.searchParams.get("from");
+  const toTime = url.searchParams.get("to");
+  const cursorParam = url.searchParams.get("cursor") ?? undefined;
+
+  const periodMs = parsePeriodToMs(period);
+  const startTime = fromTime ? new Date(fromTime) : new Date(Date.now() - periodMs);
+  const endTime = toTime ? new Date(toTime) : new Date();
+
+  if (isNaN(startTime.getTime()) || isNaN(endTime.getTime())) {
+    return json({ generations: [], pagination: {} } satisfies GenerationsResponse);
+  }
+
+  const models = url.searchParams.getAll("models").filter(Boolean);
+  const operations = url.searchParams.getAll("operations").filter(Boolean);
+  const providers = url.searchParams.getAll("providers").filter(Boolean);
+
+  const presenter = new PromptPresenter(clickhouseClient);
+  const result = await presenter.listGenerations({
+    environmentId: environment.id,
+    promptSlug,
+    promptVersions: versions.length > 0 ? versions : undefined,
+    startTime,
+    endTime,
+    cursor: cursorParam,
+    responseModels: models.length > 0 ? models : undefined,
+    operations: operations.length > 0 ? operations : undefined,
+    providers: providers.length > 0 ? providers : undefined,
+  });
+
+  return json(result satisfies GenerationsResponse);
+};
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-generate.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-generate.tsx
new file mode 100644
index 00000000000..91ff6218944
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-generate.tsx
@@ -0,0 +1,222 @@
+import { openai } from "@ai-sdk/openai";
+import { type ActionFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { env } from "~/env.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import type { AITimeFilter } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { AIQueryService } from "~/v3/services/aiQueryService.server";
+import { querySchemas } from "~/v3/querySchemas";
+
+const RequestSchema = z.object({
+  prompt: z.string().min(1, "Prompt is required"),
+  mode: z.enum(["new", "edit"]).default("new"),
+  currentQuery: z.string().optional(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  // Parse the request body
+  const formData = await request.formData();
+  const submission = RequestSchema.safeParse(Object.fromEntries(formData));
+
+  if (!submission.success) {
+    return new Response(
+      JSON.stringify({
+        type: "result",
+        success: false,
+        error: "Invalid request data",
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    return new Response(
+      JSON.stringify({
+        type: "result",
+        success: false,
+        error: "Project not found",
+      }),
+      {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    return new Response(
+      JSON.stringify({
+        type: "result",
+        success: false,
+        error: "Environment not found",
+      }),
+      {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+
+  if (!env.OPENAI_API_KEY) {
+    return new Response(
+      JSON.stringify({
+        type: "result",
+        success: false,
+        error: "OpenAI API key is not configured",
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+
+  const { prompt, mode, currentQuery } = submission.data;
+
+  const service = new AIQueryService(
+    querySchemas,
+    openai(env.AI_RUN_FILTER_MODEL ?? "gpt-4o-mini")
+  );
+
+  // Create a streaming response
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+
+      const sendEvent = (event: {
+        type: string;
+        content?: string;
+        tool?: string;
+        args?: unknown;
+        result?: unknown;
+        success?: boolean;
+        query?: string;
+        error?: string;
+        filter?: AITimeFilter;
+        timeFilter?: AITimeFilter;
+      }) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+      };
+
+      try {
+        const result = service.streamQuery(prompt, { mode, currentQuery });
+
+        // Process the stream
+        for await (const part of result.fullStream) {
+          switch (part.type) {
+            case "text-delta": {
+              sendEvent({ type: "thinking", content: part.textDelta });
+              break;
+            }
+            case "tool-call": {
+              sendEvent({
+                type: "tool_call",
+                tool: part.toolName,
+                args: part.args,
+              });
+
+              // If it's a setTimeFilter call, emit the time_filter event immediately
+              if (part.toolName === "setTimeFilter") {
+                const args = part.args as { period?: string; from?: string; to?: string };
+                sendEvent({
+                  type: "time_filter",
+                  filter: {
+                    period: args.period,
+                    from: args.from,
+                    to: args.to,
+                  },
+                });
+              }
+              break;
+            }
+            case "error": {
+              sendEvent({
+                type: "result",
+                success: false,
+                error: part.error instanceof Error ? part.error.message : String(part.error),
+              });
+              break;
+            }
+            case "finish": {
+              // Extract query from the final text
+              const finalText = await result.text;
+              const query = extractQueryFromText(finalText);
+              const timeFilter = service.getPendingTimeFilter();
+
+              if (query) {
+                sendEvent({
+                  type: "result",
+                  success: true,
+                  query,
+                  timeFilter,
+                });
+              } else if (
+                finalText.toLowerCase().includes("cannot") ||
+                finalText.toLowerCase().includes("unable")
+              ) {
+                sendEvent({
+                  type: "result",
+                  success: false,
+                  error: finalText.slice(0, 300),
+                });
+              } else {
+                sendEvent({
+                  type: "result",
+                  success: false,
+                  error: "Could not generate a valid query",
+                });
+              }
+              break;
+            }
+          }
+        }
+      } catch (error) {
+        sendEvent({
+          type: "result",
+          success: false,
+          error: error instanceof Error ? error.message : "An error occurred",
+        });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}
+
+/**
+ * Extract a SQL query from the AI response text
+ */
+function extractQueryFromText(text: string): string | null {
+  // Try to extract from code block first
+  const codeBlockMatch = text.match(/```(?:sql)?\s*([\s\S]*?)```/i);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+
+  // Try to find a SELECT statement
+  const selectMatch = text.match(/SELECT[\s\S]+?(?:LIMIT\s+\d+|;|$)/i);
+  if (selectMatch) {
+    return selectMatch[0].trim().replace(/;$/, "");
+  }
+
+  return null;
+}
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-title.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-title.tsx
new file mode 100644
index 00000000000..9fa57d7fbe8
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query.ai-title.tsx
@@ -0,0 +1,81 @@
+import { openai } from "@ai-sdk/openai";
+import { json, type ActionFunctionArgs } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { AIQueryTitleService } from "~/v3/services/aiQueryTitleService.server";
+
+const RequestSchema = z.object({
+  query: z.string().min(1, "Query is required"),
+  queryId: z.string().optional(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  // Parse the request body
+  const [error, data] = await tryCatch(request.json());
+  if (error) {
+    return json({ success: false as const, error: error.message, title: null }, { status: 400 });
+  }
+  const submission = RequestSchema.safeParse(data);
+
+  if (!submission.success) {
+    return json(
+      { success: false as const, error: "Invalid request data", title: null },
+      { status: 400 }
+    );
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    return json(
+      { success: false as const, error: "Project not found", title: null },
+      { status: 404 }
+    );
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    return json(
+      { success: false as const, error: "Environment not found", title: null },
+      { status: 404 }
+    );
+  }
+
+  if (!env.OPENAI_API_KEY) {
+    return json(
+      { success: false as const, error: "OpenAI API key is not configured", title: null },
+      { status: 400 }
+    );
+  }
+
+  const { query, queryId } = submission.data;
+
+  const service = new AIQueryTitleService(openai(env.AI_RUN_FILTER_MODEL ?? "gpt-4o-mini"));
+
+  const result = await service.generateTitle(query);
+
+  if (!result.success) {
+    return json({ success: false as const, error: result.error, title: null }, { status: 500 });
+  }
+
+  // Strip leading/trailing quotes that AI sometimes adds
+  const title = result.title.replace(/^["']|["']$/g, "");
+
+  // If a queryId was provided, update the CustomerQuery record with the title
+  if (queryId) {
+    await prisma.customerQuery.update({
+      where: { id: queryId, organizationId: project.organizationId },
+      data: { title },
+    });
+  }
+
+  return json({ success: true as const, title, error: null });
+}
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset.tsx
index 8c2ba59aff2..614b668f910 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset.tsx
@@ -1,32 +1,16 @@
-import { parse } from "@conform-to/zod";
 import { type ActionFunction, json } from "@remix-run/node";
-import { z } from "zod";
 import { prisma } from "~/db.server";
-import { jsonWithErrorMessage } from "~/models/message.server";
+import { jsonWithErrorMessage, jsonWithSuccessMessage } from "~/models/message.server";
 import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
 import { ResetIdempotencyKeyService } from "~/v3/services/resetIdempotencyKey.server";
 import { v3RunParamsSchema } from "~/utils/pathBuilder";
 
-export const resetIdempotencyKeySchema = z.object({
-  taskIdentifier: z.string().min(1, "Task identifier is required"),
-});
-
 export const action: ActionFunction = async ({ request, params }) => {
   const userId = await requireUserId(request);
-  const { projectParam, organizationSlug, envParam, runParam } =
-    v3RunParamsSchema.parse(params);
-
-  const formData = await request.formData();
-  const submission = parse(formData, { schema: resetIdempotencyKeySchema });
-
-  if (!submission.value) {
-    return json(submission);
-  }
+  const { projectParam, organizationSlug, envParam, runParam } = v3RunParamsSchema.parse(params);
 
   try {
-    const { taskIdentifier } = submission.value;
-
     const taskRun = await prisma.taskRun.findFirst({
       where: {
         friendlyId: runParam,
@@ -54,21 +38,11 @@ export const action: ActionFunction = async ({ request, params }) => {
     });
 
     if (!taskRun) {
-      submission.error = { runParam: ["Run not found"] };
-      return json(submission);
+      return jsonWithErrorMessage({}, request, "Run not found");
     }
 
     if (!taskRun.idempotencyKey) {
-      return jsonWithErrorMessage(
-        submission,
-        request,
-        "This run does not have an idempotency key"
-      );
-    }
-
-    if (taskRun.taskIdentifier !== taskIdentifier) {
-      submission.error = { taskIdentifier: ["Task identifier does not match this run"] };
-      return json(submission);
+      return jsonWithErrorMessage({}, request, "This run does not have an idempotency key");
     }
 
     const environment = await prisma.runtimeEnvironment.findUnique({
@@ -85,22 +59,18 @@ export const action: ActionFunction = async ({ request, params }) => {
     });
 
     if (!environment) {
-      return jsonWithErrorMessage(
-        submission,
-        request,
-        "Environment not found"
-      );
+      return jsonWithErrorMessage({}, request, "Environment not found");
     }
 
     const service = new ResetIdempotencyKeyService();
 
-    await service.call(taskRun.idempotencyKey, taskIdentifier, {
+    await service.call(taskRun.idempotencyKey, taskRun.taskIdentifier, {
       ...environment,
       organizationId: environment.project.organizationId,
       organization: environment.project.organization,
     });
 
-    return json({ success: true });
+    return jsonWithSuccessMessage({}, request, "Idempotency key reset successfully");
   } catch (error) {
     if (error instanceof Error) {
       logger.error("Failed to reset idempotency key", {
@@ -110,15 +80,11 @@ export const action: ActionFunction = async ({ request, params }) => {
           stack: error.stack,
         },
       });
-      return jsonWithErrorMessage(
-        submission,
-        request,
-        `Failed to reset idempotency key: ${error.message}`
-      );
+      return jsonWithErrorMessage({}, request, `Failed to reset idempotency key: ${error.message}`);
     } else {
       logger.error("Failed to reset idempotency key", { error });
       return jsonWithErrorMessage(
-        submission,
+        {},
         request,
         `Failed to reset idempotency key: ${JSON.stringify(error)}`
       );
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx
index e8e472bfc77..e0bec66ffb2 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx
@@ -1,9 +1,16 @@
 import {
   ArrowPathIcon,
+  ArrowRightIcon,
+  BookOpenIcon,
   CheckIcon,
+  ChevronUpIcon,
+  ClockIcon,
   CloudArrowDownIcon,
   EnvelopeIcon,
+  GlobeAltIcon,
+  KeyIcon,
   QueueListIcon,
+  SignalIcon,
 } from "@heroicons/react/20/solid";
 import { type LoaderFunctionArgs } from "@remix-run/server-runtime";
 import {
@@ -12,7 +19,7 @@ import {
   taskRunErrorEnhancer,
 } from "@trigger.dev/core/v3";
 import { assertNever } from "assert-never";
-import { useEffect } from "react";
+import { useEffect, useState } from "react";
 import { typedjson, useTypedFetcher } from "remix-typedjson";
 import { ExitIcon } from "~/assets/icons/ExitIcon";
 import { FlagIcon } from "~/assets/icons/RegionIcons";
@@ -25,12 +32,18 @@ import { MachineTooltipInfo } from "~/components/MachineTooltipInfo";
 import { Button, LinkButton } from "~/components/primitives/Buttons";
 import { Callout } from "~/components/primitives/Callout";
 import { CopyableText } from "~/components/primitives/CopyableText";
+import { CopyTextLink } from "~/components/primitives/CopyTextLink";
 import { DateTime, DateTimeAccurate } from "~/components/primitives/DateTime";
 import { Header2, Header3 } from "~/components/primitives/Headers";
 import { Paragraph } from "~/components/primitives/Paragraph";
+import {
+  Popover,
+  PopoverContent,
+  PopoverMenuItem,
+  PopoverTrigger,
+} from "~/components/primitives/Popover";
 import * as Property from "~/components/primitives/PropertyTable";
 import { Spinner } from "~/components/primitives/Spinner";
-import { toast } from "sonner";
 import {
   Table,
   TableBody,
@@ -42,12 +55,15 @@ import {
 import { TabButton, TabContainer } from "~/components/primitives/Tabs";
 import { TextLink } from "~/components/primitives/TextLink";
 import { InfoIconTooltip, SimpleTooltip } from "~/components/primitives/Tooltip";
-import { ToastUI } from "~/components/primitives/Toast";
 import { RunTimeline, RunTimelineEvent, SpanTimeline } from "~/components/run/RunTimeline";
+import { SpanHorizontalTimeline } from "~/components/runs/v3/SpanHorizontalTimeline";
 import { PacketDisplay } from "~/components/runs/v3/PacketDisplay";
 import { RunIcon } from "~/components/runs/v3/RunIcon";
 import { RunTag } from "~/components/runs/v3/RunTag";
+import { TruncatedCopyableValue } from "~/components/primitives/TruncatedCopyableValue";
 import { SpanEvents } from "~/components/runs/v3/SpanEvents";
+import { AISpanDetails, AIToolCallSpanDetails, AIEmbedSpanDetails } from "~/components/runs/v3/ai";
+import { PromptSpanDetails } from "~/components/runs/v3/PromptSpanDetails";
 import { SpanTitle } from "~/components/runs/v3/SpanTitle";
 import { TaskRunAttemptStatusCombo } from "~/components/runs/v3/TaskRunAttemptStatus";
 import {
@@ -62,15 +78,18 @@ import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { useSearchParams } from "~/hooks/useSearchParam";
 import { useHasAdminAccess } from "~/hooks/useUser";
+import { useCanViewLogsPage } from "~/hooks/useCanViewLogsPage";
 import { redirectWithErrorMessage } from "~/models/message.server";
 import { type Span, SpanPresenter, type SpanRun } from "~/presenters/v3/SpanPresenter.server";
 import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
 import { cn } from "~/utils/cn";
 import { formatCurrencyAccurate } from "~/utils/numberFormatter";
 import {
   docsPath,
   v3BatchPath,
   v3DeploymentVersionPath,
+  v3LogsPath,
   v3RunDownloadLogsPath,
   v3RunIdempotencyKeyResetPath,
   v3RunPath,
@@ -81,17 +100,19 @@ import {
   v3SpanParamsSchema,
 } from "~/utils/pathBuilder";
 import { createTimelineSpanEventsFromSpanEvents } from "~/utils/timelineSpanEvents";
-import { CompleteWaitpointForm } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route";
-import { requireUserId } from "~/services/session.server";
 import type { SpanOverride } from "~/v3/eventRepository/eventRepository.types";
+import { type action as resetIdempotencyKeyAction } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset";
 import { RealtimeStreamViewer } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.streams.$streamKey/route";
-import { action as resetIdempotencyKeyAction } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.idempotencyKey.reset";
+import { CompleteWaitpointForm } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route";
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const userId = await requireUserId(request);
   const { projectParam, organizationSlug, envParam, runParam, spanParam } =
     v3SpanParamsSchema.parse(params);
 
+  const url = new URL(request.url);
+  const linkedRunId = url.searchParams.get("linkedRunId") ?? undefined;
+
   const presenter = new SpanPresenter();
 
   try {
@@ -100,6 +121,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       spanId: spanParam,
       runFriendlyId: runParam,
       userId,
+      linkedRunId,
     });
 
     return typedjson(result);
@@ -109,7 +131,19 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
       organizationSlug,
       runParam,
       spanParam,
-      error,
+      linkedRunId,
+      error:
+        error instanceof Error
+          ? {
+              name: error.name,
+              message: error.message,
+              stack: error.stack,
+              cause:
+                error.cause instanceof Error
+                  ? { name: error.cause.name, message: error.cause.message }
+                  : error.cause,
+            }
+          : error,
     });
     return redirectWithErrorMessage(
       v3RunPath(
@@ -129,11 +163,13 @@ export function SpanView({
   spanId,
   spanOverrides,
   closePanel,
+  linkedRunId,
 }: {
   runParam: string;
   spanId: string | undefined;
   spanOverrides?: SpanOverride;
   closePanel?: () => void;
+  linkedRunId?: string;
 }) {
   const organization = useOrganization();
   const project = useProject();
@@ -142,16 +178,18 @@ export function SpanView({
 
   useEffect(() => {
     if (spanId === undefined) return;
-    fetcher.load(
-      `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${environment.slug}/runs/${runParam}/spans/${spanId}`
-    );
-  }, [organization.slug, project.slug, environment.slug, runParam, spanId]);
+    const url = `/resources/orgs/${organization.slug}/projects/${project.slug}/env/${
+      environment.slug
+    }/runs/${runParam}/spans/${spanId}${linkedRunId ? `?linkedRunId=${linkedRunId}` : ""}`;
+    fetcher.load(url);
+  }, [organization.slug, project.slug, environment.slug, runParam, spanId, linkedRunId]);
 
   if (spanId === undefined) {
     return null;
   }
 
-  if (fetcher.state !== "idle" || fetcher.data === undefined) {
+  // Only show loading spinner when there's no data yet, not during revalidation
+  if (fetcher.data === undefined) {
     return (
       <div
         className={cn(
@@ -218,37 +256,64 @@ function SpanBody({
 
   span = applySpanOverrides(span, spanOverrides);
 
+  const isAiInspector =
+    span.entity?.type === "ai-generation" ||
+    span.entity?.type === "ai-summary" ||
+    span.entity?.type === "ai-tool-call" ||
+    span.entity?.type === "ai-embed" ||
+    span.entity?.type === "prompt";
+
   return (
-    <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden bg-background-bright">
-      <div className="flex items-center justify-between gap-2 overflow-x-hidden border-b border-grid-bright px-3 pr-2">
-        <div className="flex items-center gap-1 overflow-x-hidden">
-          <RunIcon
-            name={span.style?.icon}
-            spanName={span.message}
-            className="size-5 min-h-5 min-w-5"
-          />
-          <Header2 className={cn("overflow-x-hidden")}>
-            <SpanTitle {...span} size="large" hideAccessory />
-          </Header2>
+    <div
+      className={cn(
+        "grid h-full max-h-full overflow-hidden bg-background-bright",
+        isAiInspector ? "grid-rows-[auto_1fr]" : "grid-rows-[2.5rem_1fr]"
+      )}
+    >
+      <div className="border-b border-grid-bright px-3 pr-2">
+        <div className="grid h-10 grid-cols-[minmax(0,1fr)_auto] items-center gap-2">
+          <div className="flex min-w-0 items-center gap-1">
+            <RunIcon
+              name={span.style?.icon}
+              spanName={span.message}
+              className="size-5 min-h-5 min-w-5"
+            />
+            <Header2 className="min-w-0">
+              <SpanTitle {...span} size="large" hideAccessory overrideDimmed />
+            </Header2>
+          </div>
+          {runParam && closePanel && (
+            <Button
+              onClick={closePanel}
+              variant="minimal/small"
+              TrailingIcon={ExitIcon}
+              shortcut={{ key: "esc" }}
+              shortcutPosition="before-trailing-icon"
+              className="pl-1"
+            />
+          )}
         </div>
-        {runParam && closePanel && (
-          <Button
-            onClick={closePanel}
-            variant="minimal/small"
-            TrailingIcon={ExitIcon}
-            shortcut={{ key: "esc" }}
-            shortcutPosition="before-trailing-icon"
-            className="pl-1"
-          />
-        )}
       </div>
-      <div className="overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+      {isAiInspector ? (
         <SpanEntity span={span} />
-      </div>
+      ) : (
+        <div className="scrollbar-gutter-stable overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <SpanEntity span={span} />
+        </div>
+      )}
     </div>
   );
 }
 
+function formatSpanDuration(nanoseconds: number): string {
+  const ms = nanoseconds / 1_000_000;
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60_000);
+  const secs = ((ms % 60_000) / 1000).toFixed(0);
+  return `${mins}m ${secs}s`;
+}
+
 function applySpanOverrides(span: Span, spanOverrides?: SpanOverride): Span {
   if (!spanOverrides) {
     return span;
@@ -299,30 +364,10 @@ function RunBody({
   const { value, replace } = useSearchParams();
   const tab = value("tab");
   const resetFetcher = useTypedFetcher<typeof resetIdempotencyKeyAction>();
-
-  // Handle toast messages from the reset action
-  useEffect(() => {
-    if (resetFetcher.data && resetFetcher.state === "idle") {
-      // Check if the response indicates success
-      if (resetFetcher.data && typeof resetFetcher.data === "object" && "success" in resetFetcher.data && resetFetcher.data.success === true) {
-        toast.custom(
-          (t) => (
-            <ToastUI
-              variant="success"
-              message="Idempotency key reset successfully"
-              t={t as string}
-            />
-          ),
-          {
-            duration: 5000,
-          }
-        );
-      }
-    }
-  }, [resetFetcher.data, resetFetcher.state]);
+  const canViewLogsPage = useCanViewLogsPage();
 
   return (
-    <div className="grid h-full max-h-full grid-rows-[2.5rem_2rem_1fr_3.25rem] overflow-hidden bg-background-bright">
+    <div className="grid h-full max-h-full grid-rows-[2.5rem_2rem_1fr_minmax(3.25rem,auto)] overflow-hidden bg-background-bright">
       <div className="flex items-center justify-between gap-2 overflow-x-hidden px-3 pr-2">
         <div className="flex items-center gap-1 overflow-x-hidden">
           <RunIcon
@@ -430,6 +475,12 @@ function RunBody({
                     />
                   </Property.Value>
                 </Property.Item>
+                <Property.Item>
+                  <Property.Label>Run ID</Property.Label>
+                  <Property.Value>
+                    <CopyableText value={run.friendlyId} copyValue={run.friendlyId} asChild />
+                  </Property.Value>
+                </Property.Item>
                 {run.relationships.root ? (
                   run.relationships.root.isParent ? (
                     <Property.Item>
@@ -568,28 +619,63 @@ function RunBody({
                   </Property.Item>
                 )}
                 <Property.Item>
-                  <Property.Label>Idempotency</Property.Label>
-                  <Property.Value>
-                    <div className="flex items-start justify-between gap-2">
-                      <div className="flex-1">
-                        <div className="break-all">{run.idempotencyKey ? run.idempotencyKey : "–"}</div>
-                        {run.idempotencyKey && (
-                          <div>
-                            Expires:{" "}
-                            {run.idempotencyKeyExpiresAt ? (
-                              <DateTime date={run.idempotencyKeyExpiresAt} />
-                            ) : (
-                              "–"
-                            )}
-                          </div>
-                        )}
-                      </div>
-                      {run.idempotencyKey && (
+                  <Property.Label>
+                    <div className="flex items-center justify-between">
+                      <span className="flex items-center gap-1">
+                        Idempotency
+                        <InfoIconTooltip
+                          content={
+                            <div className="flex max-w-xs flex-col gap-3 p-1 pb-2">
+                              <div>
+                                <div className="mb-0.5 flex items-center gap-1.5">
+                                  <KeyIcon className="size-4 text-text-dimmed" />
+                                  <Header3>Idempotency keys</Header3>
+                                </div>
+                                <Paragraph variant="small" className="!text-wrap text-text-dimmed">
+                                  Prevent duplicate task runs. If you trigger a task with the same
+                                  key twice, the second request returns the original run.
+                                </Paragraph>
+                              </div>
+                              <div>
+                                <div className="mb-1 flex items-center gap-1">
+                                  <GlobeAltIcon className="size-4 text-blue-500" />
+                                  <Header3>Scope</Header3>
+                                </div>
+                                <div className="flex flex-col gap-0.5 text-sm text-text-dimmed">
+                                  <div>Global: applies across all runs</div>
+                                  <div>Run: unique to a parent run</div>
+                                  <div>Attempt: unique to a specific attempt</div>
+                                </div>
+                              </div>
+                              <div>
+                                <div className="mb-1 flex items-center gap-1">
+                                  <SignalIcon className="size-4 text-success" />
+                                  <Header3>Status</Header3>
+                                </div>
+                                <div className="flex flex-col gap-0.5 text-sm text-text-dimmed">
+                                  <div>Active: duplicates are blocked</div>
+                                  <div>Expired: the TTL has passed</div>
+                                  <div>Inactive: the key was reset or cleared</div>
+                                </div>
+                              </div>
+                              <LinkButton
+                                to={docsPath("idempotency")}
+                                variant="docs/small"
+                                LeadingIcon={BookOpenIcon}
+                              >
+                                Read docs
+                              </LinkButton>
+                            </div>
+                          }
+                        />
+                      </span>
+                      {run.idempotencyKeyStatus === "active" ? (
                         <resetFetcher.Form
                           method="post"
-                          action={v3RunIdempotencyKeyResetPath(organization, project, environment, { friendlyId: runParam })}
+                          action={v3RunIdempotencyKeyResetPath(organization, project, environment, {
+                            friendlyId: run.friendlyId,
+                          })}
                         >
-                          <input type="hidden" name="taskIdentifier" value={run.taskIdentifier} />
                           <Button
                             type="submit"
                             variant="minimal/small"
@@ -599,8 +685,50 @@ function RunBody({
                             {resetFetcher.state === "submitting" ? "Resetting..." : "Reset"}
                           </Button>
                         </resetFetcher.Form>
-                      )}
+                      ) : run.idempotencyKeyStatus === "expired" ? (
+                        <span className="flex items-center gap-1 text-xs text-amber-500">
+                          <ClockIcon className="size-4" />
+                          Expired
+                        </span>
+                      ) : run.idempotencyKeyStatus === "inactive" ? (
+                        <span className="text-xs text-text-dimmed">Inactive</span>
+                      ) : null}
                     </div>
+                  </Property.Label>
+                  <Property.Value>
+                    {run.idempotencyKeyStatus ? (
+                      <div className="flex flex-col gap-0.5">
+                        <div>
+                          <span className="text-text-dimmed">Key: </span>
+                          {run.idempotencyKey ? (
+                            <CopyableText
+                              value={run.idempotencyKey}
+                              copyValue={run.idempotencyKey}
+                              asChild
+                              className="max-h-5"
+                            />
+                          ) : (
+                            "–"
+                          )}
+                        </div>
+                        <div>
+                          <span className="text-text-dimmed">Scope: </span>
+                          {run.idempotencyKeyScope ?? "–"}
+                        </div>
+                        <div>
+                          <span className="text-text-dimmed">
+                            {run.idempotencyKeyStatus === "expired" ? "Expired: " : "Expires: "}
+                          </span>
+                          {run.idempotencyKeyExpiresAt ? (
+                            <DateTime date={run.idempotencyKeyExpiresAt} />
+                          ) : (
+                            "–"
+                          )}
+                        </div>
+                      </div>
+                    ) : (
+                      "–"
+                    )}
                   </Property.Value>
                 </Property.Item>
                 <Property.Item>
@@ -836,18 +964,6 @@ function RunBody({
                       : "–"}
                   </Property.Value>
                 </Property.Item>
-                <Property.Item>
-                  <Property.Label>Run ID</Property.Label>
-                  <Property.Value>
-                    <CopyableText value={run.friendlyId} copyValue={run.friendlyId} asChild />
-                  </Property.Value>
-                </Property.Item>
-                <Property.Item>
-                  <Property.Label>Internal ID</Property.Label>
-                  <Property.Value>
-                    <CopyableText value={run.id} copyValue={run.id} asChild />
-                  </Property.Value>
-                </Property.Item>
                 <Property.Item>
                   <Property.Label>Run Engine</Property.Label>
                   <Property.Value>{run.engine}</Property.Value>
@@ -920,7 +1036,7 @@ function RunBody({
           )}
         </div>
       </div>
-      <div className="flex items-center justify-between gap-2 border-t border-grid-dimmed px-2">
+      <div className="flex flex-wrap items-center justify-between gap-2 border-t border-grid-dimmed px-2 py-2">
         <div className="flex items-center gap-4">
           {run.friendlyId !== runParam && (
             <LinkButton
@@ -940,18 +1056,59 @@ function RunBody({
           )}
           <AdminDebugRun friendlyId={run.friendlyId} />
         </div>
-        <div className="flex items-center gap-4">
+        <div className="flex items-center">
           {run.logsDeletedAt === null ? (
-            <LinkButton
-              to={v3RunDownloadLogsPath({ friendlyId: runParam })}
-              LeadingIcon={CloudArrowDownIcon}
-              leadingIconClassName="text-indigo-400"
-              variant="secondary/medium"
-              target="_blank"
-              download
-            >
-              Download logs
-            </LinkButton>
+            canViewLogsPage ? (
+              <div className="flex">
+                <LinkButton
+                  to={`${v3LogsPath(organization, project, environment)}?runId=${runParam}&from=${
+                    new Date(run.createdAt).getTime() - 60000
+                  }`}
+                  variant="secondary/medium"
+                  className="rounded-r-none border-r-0"
+                >
+                  View logs
+                </LinkButton>
+                <Popover>
+                  <PopoverTrigger asChild>
+                    <Button
+                      variant="secondary/medium"
+                      className="rounded-l-none border-l-charcoal-700 px-1.5"
+                    >
+                      <ChevronUpIcon className="size-4 transition group-hover/button:text-text-bright" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="min-w-[140px] p-1" align="end">
+                    <PopoverMenuItem
+                      to={`${v3LogsPath(
+                        organization,
+                        project,
+                        environment
+                      )}?runId=${runParam}&from=${new Date(run.createdAt).getTime() - 60000}`}
+                      title="View logs"
+                      icon={ArrowRightIcon}
+                      leadingIconClassName="text-blue-500"
+                    />
+                    <PopoverMenuItem
+                      to={v3RunDownloadLogsPath({ friendlyId: runParam })}
+                      title="Download logs"
+                      icon={CloudArrowDownIcon}
+                      leadingIconClassName="text-indigo-500"
+                      openInNewTab
+                    />
+                  </PopoverContent>
+                </Popover>
+              </div>
+            ) : (
+              <LinkButton
+                to={v3RunDownloadLogsPath({ friendlyId: runParam })}
+                LeadingIcon={CloudArrowDownIcon}
+                leadingIconClassName="text-indigo-400"
+                variant="secondary/medium"
+              >
+                Download logs
+              </LinkButton>
+            )
           ) : null}
         </div>
       </div>
@@ -1029,6 +1186,35 @@ function RunError({ error }: { error: TaskRunError }) {
   }
 }
 
+function CollapsibleProperties({ code }: { code: string }) {
+  const [open, setOpen] = useState(false);
+  return (
+    <div className="border-t border-grid-bright pt-2">
+      <button
+        onClick={() => setOpen(!open)}
+        className="flex w-full items-center gap-1 text-xs font-medium text-text-dimmed hover:text-text-bright"
+      >
+        <ChevronUpIcon
+          className={cn("size-3.5 transition-transform", open ? "rotate-180" : "rotate-90")}
+        />
+        Raw properties
+      </button>
+      {open && (
+        <div className="mt-1.5">
+          <CodeBlock
+            code={code}
+            maxLines={20}
+            showLineNumbers={false}
+            showCopyButton
+            showTextWrapping
+            showOpenInModal
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
 function SpanEntity({ span }: { span: Span }) {
   const isAdmin = useHasAdminAccess();
 
@@ -1075,53 +1261,14 @@ function SpanEntity({ span }: { span: Span }) {
         )}
         <Property.Table>
           <Property.Item>
-            <Property.Label>Message</Property.Label>
-            <Property.Value className="whitespace-pre-wrap">{span.message}</Property.Value>
+            <Property.Label className="flex items-center justify-between">
+              <span>Message</span>
+              <CopyTextLink value={span.message} />
+            </Property.Label>
+            <Property.Value className="whitespace-pre-wrap [overflow-wrap:break-word]">
+              {span.message}
+            </Property.Value>
           </Property.Item>
-          {span.triggeredRuns.length > 0 && (
-            <Property.Item>
-              <div className="flex flex-col gap-1.5">
-                <Header3>Triggered runs</Header3>
-                <Table containerClassName="max-h-[12.5rem]">
-                  <TableHeader className="bg-background-bright">
-                    <TableRow>
-                      <TableHeaderCell>Run #</TableHeaderCell>
-                      <TableHeaderCell>Task</TableHeaderCell>
-                      <TableHeaderCell>Version</TableHeaderCell>
-                      <TableHeaderCell>Created at</TableHeaderCell>
-                    </TableRow>
-                  </TableHeader>
-                  <TableBody>
-                    {span.triggeredRuns.map((run) => {
-                      const path = v3RunSpanPath(
-                        organization,
-                        project,
-                        environment,
-                        { friendlyId: run.friendlyId },
-                        { spanId: run.spanId }
-                      );
-                      return (
-                        <TableRow key={run.friendlyId}>
-                          <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
-                            {run.number}
-                          </TableCell>
-                          <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
-                            {run.taskIdentifier}
-                          </TableCell>
-                          <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
-                            {run.taskVersion ?? "–"}
-                          </TableCell>
-                          <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
-                            <DateTime date={run.createdAt} />
-                          </TableCell>
-                        </TableRow>
-                      );
-                    })}
-                  </TableBody>
-                </Table>
-              </div>
-            </Property.Item>
-          )}
         </Property.Table>
         {span.events.length > 0 && <SpanEvents spanEvents={span.events} />}
         {span.properties !== undefined ? (
@@ -1146,6 +1293,48 @@ function SpanEntity({ span }: { span: Span }) {
             showOpenInModal
           />
         ) : null}
+        {span.triggeredRuns.length > 0 && (
+          <div className="flex flex-col gap-1.5">
+            <Header3>Runs</Header3>
+            <Table containerClassName="max-h-[12.5rem]">
+              <TableHeader className="bg-background-bright">
+                <TableRow>
+                  <TableHeaderCell>ID</TableHeaderCell>
+                  <TableHeaderCell>Task</TableHeaderCell>
+                  <TableHeaderCell>Status</TableHeaderCell>
+                  <TableHeaderCell>Created</TableHeaderCell>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {span.triggeredRuns.map((run) => {
+                  const path = v3RunSpanPath(
+                    organization,
+                    project,
+                    environment,
+                    { friendlyId: run.friendlyId },
+                    { spanId: run.spanId }
+                  );
+                  return (
+                    <TableRow key={run.friendlyId}>
+                      <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
+                        <TruncatedCopyableValue value={run.friendlyId} />
+                      </TableCell>
+                      <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
+                        {run.taskIdentifier}
+                      </TableCell>
+                      <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
+                        <TaskRunStatusCombo status={run.status} />
+                      </TableCell>
+                      <TableCell to={path} actionClassName="py-1.5" rowHoverStyle="bright">
+                        <DateTimeAccurate date={run.createdAt} hour12={false} hideDate={true} />
+                      </TableCell>
+                    </TableRow>
+                  );
+                })}
+              </TableBody>
+            </Table>
+          </div>
+        )}
       </div>
     );
   }
@@ -1224,6 +1413,54 @@ function SpanEntity({ span }: { span: Span }) {
           runId={span.entity.object.runId}
           streamKey={span.entity.object.streamKey}
           metadata={span.entity.object.metadata}
+          displayName={span.entity.object.displayName}
+        />
+      );
+    }
+    case "ai-generation":
+    case "ai-summary": {
+      return (
+        <AISpanDetails
+          aiData={span.entity.object}
+          promptVersionData={span.entity.promptVersionData}
+          rawProperties={
+            typeof span.properties === "string"
+              ? span.properties
+              : span.properties != null
+              ? JSON.stringify(span.properties, null, 2)
+              : undefined
+          }
+          startTime={span.startTime}
+          duration={span.duration}
+        />
+      );
+    }
+    case "ai-tool-call": {
+      return (
+        <div className="overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <div className="px-3">
+            <SpanHorizontalTimeline startTime={span.startTime} duration={span.duration} />
+          </div>
+          <AIToolCallSpanDetails data={span.entity.object} />
+        </div>
+      );
+    }
+    case "ai-embed": {
+      return (
+        <div className="overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+          <div className="px-3">
+            <SpanHorizontalTimeline startTime={span.startTime} duration={span.duration} />
+          </div>
+          <AIEmbedSpanDetails data={span.entity.object} />
+        </div>
+      );
+    }
+    case "prompt": {
+      return (
+        <PromptSpanDetails
+          promptData={span.entity.object}
+          startTime={span.startTime}
+          duration={span.duration}
         />
       );
     }
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.streams.$streamKey/route.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.streams.$streamKey/route.tsx
index a1d94159700..b5763bb4e9c 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.streams.$streamKey/route.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.streams.$streamKey/route.tsx
@@ -98,10 +98,12 @@ export function RealtimeStreamViewer({
   runId,
   streamKey,
   metadata,
+  displayName,
 }: {
   runId: string;
   streamKey: string;
   metadata: Record<string, unknown> | undefined;
+  displayName?: string;
 }) {
   const organization = useOrganization();
   const project = useProject();
@@ -244,8 +246,8 @@ export function RealtimeStreamViewer({
               variant="small/bright"
               className="mb-0 flex min-w-0 items-center gap-1 truncate whitespace-nowrap"
             >
-              <span>Stream:</span>
-              <span className="truncate font-mono text-text-dimmed">{streamKey}</span>
+              <span>{displayName ? "Input stream:" : "Stream:"}</span>
+              <span className="truncate font-mono text-text-dimmed">{displayName ?? streamKey}</span>
             </Paragraph>
           </div>
           <div className="flex w-full flex-wrap items-center justify-between gap-3 @[300px]:w-auto @[300px]:flex-nowrap">
@@ -487,6 +489,9 @@ function useRealtimeStream(resourcePath: string, startIndex?: number) {
   const [isConnected, setIsConnected] = useState(false);
 
   useEffect(() => {
+    setChunks([]);
+    setError(null);
+
     const abortController = new AbortController();
     let reader: ReadableStreamDefaultReader<SSEStreamPart<unknown>> | null = null;
 
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.ai-generate-payload.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.ai-generate-payload.tsx
new file mode 100644
index 00000000000..2cfbe6a10b8
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.ai-generate-payload.tsx
@@ -0,0 +1,312 @@
+import { openai } from "@ai-sdk/openai";
+import { streamText, tool } from "ai";
+import { type ActionFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { env } from "~/env.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { requireUserId } from "~/services/session.server";
+import { EnvironmentParamSchema } from "~/utils/pathBuilder";
+import { inflate } from "node:zlib";
+import { promisify } from "node:util";
+
+const inflateAsync = promisify(inflate);
+import { $replica } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
+
+const RequestSchema = z.object({
+  prompt: z.string().min(1, "Prompt is required").max(1000),
+  taskIdentifier: z.string().max(256),
+  payloadSchema: z.string().max(50_000).optional(),
+  currentPayload: z.string().max(50_000).optional(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const formData = await request.formData();
+  const submission = RequestSchema.safeParse(Object.fromEntries(formData));
+
+  if (!submission.success) {
+    return new Response(
+      JSON.stringify({ type: "result", success: false, error: "Invalid request data" }),
+      { status: 400, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    return new Response(
+      JSON.stringify({ type: "result", success: false, error: "Project not found" }),
+      { status: 404, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    return new Response(
+      JSON.stringify({ type: "result", success: false, error: "Environment not found" }),
+      { status: 404, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  if (!env.OPENAI_API_KEY) {
+    return new Response(
+      JSON.stringify({
+        type: "result",
+        success: false,
+        error: "OpenAI API key is not configured",
+      }),
+      { status: 400, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  const { prompt, taskIdentifier, payloadSchema, currentPayload } = submission.data;
+
+  logger.info("[AI payload] Generating payload", {
+    taskIdentifier,
+    hasPayloadSchema: !!payloadSchema,
+    hasCurrentPayload: !!currentPayload,
+    promptLength: prompt.length,
+  });
+
+  const systemPrompt = buildSystemPrompt(taskIdentifier, payloadSchema, currentPayload);
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+
+      const sendEvent = (event: {
+        type: string;
+        content?: string;
+        success?: boolean;
+        payload?: string;
+        error?: string;
+      }) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+      };
+
+      try {
+        const result = streamText({
+          model: openai(env.AI_RUN_FILTER_MODEL ?? "gpt-5-mini"),
+          temperature: 1,
+          abortSignal: request.signal,
+          system: systemPrompt,
+          prompt,
+          tools: {
+            getTaskSourceCode: tool({
+              description:
+                "Look up the source code of the task to understand what payload shape it expects. Use this when there is no JSON Schema available and you need to infer the payload structure from the task implementation.",
+              parameters: z.object({}),
+              execute: async () => {
+                return getTaskSourceCode(environment.id, environment.type, taskIdentifier);
+              },
+            }),
+          },
+          maxSteps: 3,
+        });
+
+        for await (const part of result.fullStream) {
+          switch (part.type) {
+            case "text-delta": {
+              sendEvent({ type: "thinking", content: part.textDelta });
+              break;
+            }
+            case "tool-call": {
+              sendEvent({
+                type: "thinking",
+                content: "\n\nLooking up task source code...\n\n",
+              });
+              break;
+            }
+            case "error": {
+              sendEvent({
+                type: "result",
+                success: false,
+                error: part.error instanceof Error ? part.error.message : String(part.error),
+              });
+              break;
+            }
+          }
+        }
+
+        // Extract JSON from the final aggregated text (across all steps)
+        const finalText = await result.text;
+        const payload = extractJsonFromText(finalText);
+
+        if (payload) {
+          sendEvent({ type: "result", success: true, payload });
+        } else {
+          sendEvent({
+            type: "result",
+            success: false,
+            error: "Could not generate a valid JSON payload",
+          });
+        }
+      } catch (error) {
+        sendEvent({
+          type: "result",
+          success: false,
+          error: error instanceof Error ? error.message : "An error occurred",
+        });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}
+
+async function getTaskSourceCode(
+  environmentId: string,
+  environmentType: string,
+  taskIdentifier: string
+): Promise<string> {
+  try {
+    logger.info("[AI payload] Looking up task source code", {
+      taskIdentifier,
+      environmentId,
+      environmentType,
+    });
+
+    const task =
+      environmentType !== "DEVELOPMENT"
+        ? await getTaskFromDeployment(environmentId, taskIdentifier)
+        : await $replica.backgroundWorkerTask.findFirst({
+            where: { slug: taskIdentifier, runtimeEnvironmentId: environmentId },
+            orderBy: { createdAt: "desc" },
+            select: { fileId: true },
+          });
+
+    if (!task?.fileId) {
+      logger.info("[AI payload] No fileId found for task", { taskIdentifier });
+      return "Source code not available for this task.";
+    }
+
+    const file = await $replica.backgroundWorkerFile.findUnique({
+      where: { id: task.fileId },
+      select: { contents: true, filePath: true },
+    });
+
+    if (!file) {
+      logger.info("[AI payload] File record not found", { taskIdentifier, fileId: task.fileId });
+      return "Source code not available for this task.";
+    }
+
+    // File contents are zlib-deflated then base64-encoded by the CLI,
+    // stored as Buffer.from(base64String) in Prisma Bytes
+    const base64 = Buffer.from(file.contents).toString("utf-8");
+    const decompressed = (await inflateAsync(Buffer.from(base64, "base64"))).toString("utf-8");
+
+    logger.info("[AI payload] Found task source code", {
+      taskIdentifier,
+      filePath: file.filePath,
+      contentLength: decompressed.length,
+    });
+
+    return `File: ${file.filePath}\n\n${decompressed}`;
+  } catch (error) {
+    logger.error("[AI payload] Failed to retrieve task source code", {
+      taskIdentifier,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return "Failed to retrieve task source code.";
+  }
+}
+
+async function getTaskFromDeployment(environmentId: string, taskIdentifier: string) {
+  const deployment = await findCurrentWorkerDeployment({ environmentId });
+  if (!deployment?.worker) return null;
+
+  const task = deployment.worker.tasks.find((t) => t.slug === taskIdentifier);
+  if (!task) return null;
+
+  return { fileId: task.fileId };
+}
+
+function buildSystemPrompt(
+  taskIdentifier: string,
+  payloadSchema?: string,
+  currentPayload?: string
+): string {
+  let prompt = `You are a JSON payload generator for a Trigger.dev task with id "${taskIdentifier}".
+
+Your job is to generate a valid JSON payload that can be used to test this task. Return ONLY valid JSON wrapped in a \`\`\`json code block. Do not include any explanation outside the code block.
+
+Requirements:
+- Generate realistic, meaningful example data
+- All string values should be plausible (real-looking names, emails, URLs, etc.)
+- Number values should be reasonable for their context
+- The JSON must be valid and parseable`;
+
+  if (payloadSchema) {
+    prompt += `
+
+The task has the following JSON Schema that the payload must conform to:
+\`\`\`json
+${payloadSchema}
+\`\`\`
+
+Generate a payload that strictly conforms to this schema, respecting all type constraints, required fields, enums, formats, and validation rules.`;
+  } else {
+    prompt += `
+
+No JSON Schema is available for this task. Use the getTaskSourceCode tool to look up the task's source code file.
+
+IMPORTANT instructions for reading the source code:
+- The file may contain multiple task definitions. Find the one with id "${taskIdentifier}".
+- Look at the \`run\` function's payload parameter type to determine the expected shape.
+- If the payload is typed as \`any\`, \`unknown\`, or has no type annotation, check how payload properties are actually accessed inside the \`run\` function body to infer the structure.
+- If the payload type is explicitly defined (e.g. \`{ name: string, count: number }\`), use that exactly.
+- If the payload is typed as \`any\` and is never accessed or destructured in the function body, the task likely accepts any payload. In that case generate a simple \`{}\` empty object.
+- Do NOT invent complex payload structures that aren't supported by the code. Only include fields you can confirm from the type annotation or actual usage in the function body.`;
+  }
+
+  if (currentPayload) {
+    prompt += `
+
+The current payload in the editor is:
+\`\`\`json
+${currentPayload}
+\`\`\`
+
+Use this as context for what the user might want, but generate a new payload based on the user's prompt.`;
+  }
+
+  return prompt;
+}
+
+function extractJsonFromText(text: string): string | null {
+  // Try to extract from code block first
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (codeBlockMatch) {
+    const candidate = codeBlockMatch[1].trim();
+    try {
+      // Validate and pretty-print
+      return JSON.stringify(JSON.parse(candidate), null, 2);
+    } catch {
+      // Fall through
+    }
+  }
+
+  // Try to find a JSON object or array
+  const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  if (jsonMatch) {
+    try {
+      return JSON.stringify(JSON.parse(jsonMatch[1]), null, 2);
+    } catch {
+      // Fall through
+    }
+  }
+
+  return null;
+}
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel.tsx
new file mode 100644
index 00000000000..d1c4715a1c6
--- /dev/null
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.vercel.tsx
@@ -0,0 +1,970 @@
+import { useForm } from "@conform-to/react";
+import { parse } from "@conform-to/zod";
+import {
+  CheckCircleIcon,
+  ExclamationTriangleIcon,
+} from "@heroicons/react/20/solid";
+import {
+  Form,
+  useActionData,
+  useFetcher,
+  useNavigation,
+  useLocation,
+} from "@remix-run/react";
+import {
+  type ActionFunctionArgs,
+  type LoaderFunctionArgs,
+  json,
+} from "@remix-run/server-runtime";
+import { typedjson, useTypedFetcher } from "remix-typedjson";
+import { z } from "zod";
+import { Dialog, DialogContent, DialogHeader, DialogTrigger } from "~/components/primitives/Dialog";
+import { DialogClose } from "@radix-ui/react-dialog";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Callout } from "~/components/primitives/Callout";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormError } from "~/components/primitives/FormError";
+import { Hint } from "~/components/primitives/Hint";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { SpinnerWhite } from "~/components/primitives/Spinner";
+import { DateTime } from "~/components/primitives/DateTime";
+import { VercelLogo } from "~/components/integrations/VercelLogo";
+import { BuildSettingsFields } from "~/components/integrations/VercelBuildSettings";
+import {
+  redirectBackWithErrorMessage,
+  redirectWithSuccessMessage,
+  redirectWithErrorMessage,
+} from "~/models/message.server";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { sanitizeVercelNextUrl } from "~/v3/vercel/vercelUrls.server";
+import { EnvironmentParamSchema, v3ProjectSettingsIntegrationsPath, vercelAppInstallPath, vercelResourcePath } from "~/utils/pathBuilder";
+import {
+  VercelSettingsPresenter,
+  type VercelOnboardingData,
+} from "~/presenters/v3/VercelSettingsPresenter.server";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
+import {
+  type VercelProjectIntegrationData,
+  type SyncEnvVarsMapping,
+  type EnvSlug,
+  envSlugArrayField,
+  envTypeToSlug,
+  getAvailableEnvSlugs,
+  getAvailableEnvSlugsForBuildSettings,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+import { Result, fromPromise } from "neverthrow";
+import { useEffect, useState } from "react";
+
+export type ConnectedVercelProject = {
+  id: string;
+  vercelProjectId: string;
+  vercelProjectName: string;
+  vercelTeamId: string | null;
+  integrationData: VercelProjectIntegrationData;
+  createdAt: Date;
+};
+
+const safeJsonParse = Result.fromThrowable(
+  (val: string) => JSON.parse(val) as Record<string, unknown>,
+  () => null
+);
+
+function parseVercelStagingEnvironment(
+  value: string | null | undefined
+): { environmentId: string; displayName: string } | null {
+  if (!value) return null;
+  return safeJsonParse(value).match(
+    (parsed) => {
+      if (typeof parsed?.environmentId === "string" && typeof parsed?.displayName === "string") {
+        return { environmentId: parsed.environmentId, displayName: parsed.displayName };
+      }
+      return null;
+    },
+    () => null
+  );
+}
+
+const UpdateVercelConfigFormSchema = z.object({
+  action: z.literal("update-config"),
+  atomicBuilds: envSlugArrayField,
+  pullEnvVarsBeforeBuild: envSlugArrayField,
+  discoverEnvVars: envSlugArrayField,
+  vercelStagingEnvironment: z.string().nullable().optional(),
+});
+
+const DisconnectVercelFormSchema = z.object({
+  action: z.literal("disconnect"),
+});
+
+const CompleteOnboardingFormSchema = z.object({
+  action: z.literal("complete-onboarding"),
+  vercelStagingEnvironment: z.string().nullable().optional(),
+  pullEnvVarsBeforeBuild: envSlugArrayField,
+  atomicBuilds: envSlugArrayField,
+  discoverEnvVars: envSlugArrayField,
+  syncEnvVarsMapping: z.string().optional(),
+  next: z.string().optional(),
+  skipRedirect: z.string().optional().transform((val) => val === "true"),
+  origin: z.string().optional(),
+});
+
+const SkipOnboardingFormSchema = z.object({
+  action: z.literal("skip-onboarding"),
+});
+
+const SelectVercelProjectFormSchema = z.object({
+  action: z.literal("select-vercel-project"),
+  vercelProjectId: z.string().min(1, "Please select a Vercel project"),
+  vercelProjectName: z.string().min(1),
+});
+
+const UpdateEnvMappingFormSchema = z.object({
+  action: z.literal("update-env-mapping"),
+  vercelStagingEnvironment: z.string().nullable().optional(),
+});
+
+const DisableAutoAssignFormSchema = z.object({
+  action: z.literal("disable-auto-assign"),
+});
+
+const VercelActionSchema = z.discriminatedUnion("action", [
+  UpdateVercelConfigFormSchema,
+  DisconnectVercelFormSchema,
+  CompleteOnboardingFormSchema,
+  SkipOnboardingFormSchema,
+  SelectVercelProjectFormSchema,
+  UpdateEnvMappingFormSchema,
+  DisableAutoAssignFormSchema,
+]);
+
+export async function loader({ request, params }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Not Found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Not Found", { status: 404 });
+  }
+
+  const presenter = new VercelSettingsPresenter();
+  const resultOrFail = await presenter.call({
+    projectId: project.id,
+    organizationId: project.organizationId,
+  });
+
+  if (resultOrFail.isErr()) {
+    logger.error("Failed to load Vercel settings", {
+      url: request.url,
+      params,
+      error: resultOrFail.error,
+    });
+    throw new Response("Failed to load Vercel settings", { status: 500 });
+  }
+
+  const result = resultOrFail.value;
+  const url = new URL(request.url);
+  const needsOnboarding = url.searchParams.get("vercelOnboarding") === "true";
+  const vercelEnvironmentId = url.searchParams.get("vercelEnvironmentId") || undefined;
+
+  let onboardingData: VercelOnboardingData | null = null;
+  if (needsOnboarding) {
+    onboardingData = await presenter.getOnboardingData(
+      project.id,
+      project.organizationId,
+      vercelEnvironmentId
+    );
+  }
+
+  const authInvalid = onboardingData?.authInvalid || result.authInvalid || false;
+  const authError = onboardingData?.authError || result.authError;
+
+  return typedjson({
+    ...result,
+    authInvalid,
+    authError,
+    onboardingData,
+    organizationSlug,
+    projectSlug: projectParam,
+    environmentSlug: envParam,
+    projectId: project.id,
+    organizationId: project.organizationId,
+  });
+}
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response("Not Found", { status: 404 });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response("Not Found", { status: 404 });
+  }
+
+  const formData = await request.formData();
+  const submission = parse(formData, { schema: VercelActionSchema });
+
+  if (!submission.value || submission.intent !== "submit") {
+    return json(submission);
+  }
+
+  const settingsPath = v3ProjectSettingsIntegrationsPath(
+    { slug: organizationSlug },
+    { slug: projectParam },
+    { slug: envParam }
+  );
+
+  const vercelService = new VercelIntegrationService();
+  const { action: actionType } = submission.value;
+
+  switch (actionType) {
+    case "update-config": {
+      const {
+        atomicBuilds,
+        pullEnvVarsBeforeBuild,
+        discoverEnvVars,
+        vercelStagingEnvironment,
+      } = submission.value;
+
+      const parsedStagingEnv = parseVercelStagingEnvironment(vercelStagingEnvironment);
+
+      // Get the previous staging environment before updating
+      const previousIntegration = await vercelService.getVercelProjectIntegration(project.id);
+      const previousStagingEnvId =
+        previousIntegration?.parsedIntegrationData.config?.vercelStagingEnvironment?.environmentId ?? null;
+      const newStagingEnvId = parsedStagingEnv?.environmentId ?? null;
+
+      const result = await vercelService.updateVercelIntegrationConfig(project.id, {
+        atomicBuilds,
+        pullEnvVarsBeforeBuild,
+        discoverEnvVars,
+        vercelStagingEnvironment: parsedStagingEnv,
+      });
+
+      if (result) {
+        // Sync staging TRIGGER_SECRET_KEY if the custom environment changed
+        if (previousStagingEnvId !== newStagingEnvId) {
+          await vercelService.syncStagingKeyForCustomEnvironment(
+            project.id,
+            previousStagingEnvId,
+            newStagingEnvId
+          );
+        }
+
+        return redirectWithSuccessMessage(settingsPath, request, "Vercel settings updated successfully");
+      }
+
+      return redirectWithErrorMessage(settingsPath, request, "Failed to update Vercel settings");
+    }
+
+    case "disconnect": {
+      const success = await vercelService.disconnectVercelProject(project.id);
+
+      if (success) {
+        return redirectWithSuccessMessage(settingsPath, request, "Vercel project disconnected");
+      }
+
+      return redirectWithErrorMessage(settingsPath, request, "Failed to disconnect Vercel project");
+    }
+
+    case "complete-onboarding": {
+      const {
+        vercelStagingEnvironment,
+        pullEnvVarsBeforeBuild,
+        atomicBuilds,
+        discoverEnvVars,
+        syncEnvVarsMapping,
+        next,
+        skipRedirect,
+        origin,
+      } = submission.value;
+
+      const parsedStagingEnv = parseVercelStagingEnvironment(vercelStagingEnvironment);
+      const parsedSyncEnvVarsMapping = syncEnvVarsMapping
+        ? safeJsonParse(syncEnvVarsMapping).unwrapOr(undefined) as SyncEnvVarsMapping | undefined
+        : undefined;
+
+      const result = await vercelService.completeOnboarding(project.id, {
+        vercelStagingEnvironment: parsedStagingEnv,
+        pullEnvVarsBeforeBuild,
+        atomicBuilds,
+        discoverEnvVars,
+        syncEnvVarsMapping: parsedSyncEnvVarsMapping,
+        origin: origin === "marketplace" ? "marketplace" : "dashboard",
+      });
+
+      if (result) {
+        if (skipRedirect) {
+          return json({ success: true });
+        }
+
+        if (next) {
+          const sanitizedNext = sanitizeVercelNextUrl(next);
+          if (sanitizedNext) {
+            return json({ success: true, redirectTo: sanitizedNext });
+          }
+          logger.warn("Rejected next URL - not same-origin or vercel.com", { next });
+        }
+
+        return json({ success: true, redirectTo: settingsPath });
+      }
+
+      return redirectWithErrorMessage(settingsPath, request, "Failed to complete Vercel setup");
+    }
+
+    case "update-env-mapping": {
+      const { vercelStagingEnvironment } = submission.value;
+
+      const parsedStagingEnv = parseVercelStagingEnvironment(vercelStagingEnvironment);
+
+      const result = await vercelService.updateVercelIntegrationConfig(project.id, {
+        vercelStagingEnvironment: parsedStagingEnv,
+      });
+
+      if (result) {
+        // During onboarding there's no previous custom environment — just upsert
+        await vercelService.syncStagingKeyForCustomEnvironment(
+          project.id,
+          null,
+          parsedStagingEnv?.environmentId ?? null
+        );
+        return json({ success: true });
+      }
+
+      return json({ success: false, error: "Failed to update environment mapping" }, { status: 400 });
+    }
+
+    case "skip-onboarding": {
+      return redirectWithSuccessMessage(settingsPath, request, "Vercel integration setup skipped");
+    }
+
+    case "select-vercel-project": {
+      const { vercelProjectId, vercelProjectName } = submission.value;
+
+      const selectResult = await fromPromise(
+        vercelService.selectVercelProject({
+          organizationId: project.organizationId,
+          projectId: project.id,
+          vercelProjectId,
+          vercelProjectName,
+          userId,
+        }),
+        (error) => error
+      );
+
+      if (selectResult.isErr()) {
+        logger.error("Failed to select Vercel project", { error: selectResult.error });
+        return json({
+          error: "Failed to connect Vercel project. Please try again.",
+        });
+      }
+
+      const { integration, syncResult } = selectResult.value;
+
+      if (!syncResult.success && syncResult.errors.length > 0) {
+        logger.warn("Failed to send trigger secrets to Vercel", {
+          projectId: project.id,
+          vercelProjectId,
+          errors: syncResult.errors,
+        });
+      }
+
+      return json({
+        success: true,
+        integrationId: integration.id,
+        syncErrors: syncResult.errors,
+      });
+    }
+
+    case "disable-auto-assign": {
+      const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationForProject(
+        project.id
+      );
+
+      if (!orgIntegration) {
+        return redirectWithErrorMessage(settingsPath, request, "No Vercel integration found");
+      }
+
+      const projectIntegration = await vercelService.getVercelProjectIntegration(project.id);
+
+      if (!projectIntegration) {
+        return redirectWithErrorMessage(settingsPath, request, "No Vercel project connected");
+      }
+
+      const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+      const disableResult = await VercelIntegrationRepository.getVercelClient(orgIntegration)
+        .andThen((client) =>
+          VercelIntegrationRepository.disableAutoAssignCustomDomains(
+            client,
+            projectIntegration.parsedIntegrationData.vercelProjectId,
+            teamId
+          )
+        );
+
+      if (disableResult.isErr()) {
+        logger.error("Failed to disable auto-assign custom domains", { error: disableResult.error });
+        return redirectWithErrorMessage(settingsPath, request, "Failed to disable auto-assign custom domains");
+      }
+
+      return redirectWithSuccessMessage(settingsPath, request, "Auto-assign custom domains disabled");
+    }
+
+    default: {
+      submission.value satisfies never;
+      return redirectBackWithErrorMessage(request, "Failed to process request");
+    }
+  }
+}
+
+function VercelConnectionPrompt({
+  organizationSlug,
+  projectSlug,
+  environmentSlug,
+  hasOrgIntegration,
+  isGitHubConnected,
+  onOpenModal,
+  isLoading,
+}: {
+  organizationSlug: string;
+  projectSlug: string;
+  environmentSlug: string;
+  hasOrgIntegration: boolean;
+  isGitHubConnected: boolean;
+  onOpenModal?: () => void;
+  isLoading?: boolean;
+}) {
+  const installPath = vercelAppInstallPath(organizationSlug, projectSlug);
+
+  const handleConnectProject = () => {
+    if (onOpenModal) {
+      onOpenModal();
+    }
+  };
+
+  const isLoadingProjects = isLoading ?? false;
+  const isDisabled = isLoadingProjects || !onOpenModal;
+
+  return (
+    <Fieldset>
+      <InputGroup fullWidth>
+        <div className="flex flex-col gap-3">
+          <div className="flex items-center gap-3">
+            {hasOrgIntegration ? (
+              <>
+                <Button
+                  variant="secondary/medium"
+                  onClick={handleConnectProject}
+                  disabled={isDisabled}
+                  LeadingIcon={
+                    isLoadingProjects
+                      ? () => <SpinnerWhite className="size-4" />
+                      : () => <VercelLogo className="size-4 -mx-1" />
+                  }
+                >
+                  {isLoadingProjects ? "Loading projects..." : "Connect Vercel project"}
+                </Button>
+                <span className="flex items-center gap-1 text-xs text-text-dimmed">
+                  <CheckCircleIcon className="size-4 text-success" /> Vercel app is installed
+                </span>
+                {!onOpenModal && (
+                  <span className="text-xs text-amber-400">
+                    Please reconnect Vercel to continue
+                  </span>
+                )}
+              </>
+            ) : (
+              <>
+                <LinkButton
+                  to={installPath}
+                  variant="secondary/medium"
+                  LeadingIcon={() => <VercelLogo className="size-4 -mx-1" />}
+                >
+                  Install Vercel app
+                </LinkButton>
+              </>
+            )}
+          </div>
+        </div>
+      </InputGroup>
+    </Fieldset>
+  );
+}
+
+function VercelAuthInvalidBanner({ 
+  organizationSlug,
+  projectSlug,
+}: { 
+  organizationSlug: string;
+  projectSlug: string;
+}) {
+  const installUrl = vercelAppInstallPath(organizationSlug, projectSlug);
+
+  return (
+    <Callout variant="error" className="mb-4">
+      <div className="flex items-start gap-3">
+        <div className="flex-1">
+          <p className="font-sans text-sm font-medium text-text-bright mb-2">
+            Vercel connection expired
+          </p>
+          <p className="font-sans text-xs text-text-dimmed mb-3">
+            Your Vercel access token has expired or been revoked. Please reconnect to restore functionality.
+          </p>
+          <LinkButton
+            to={installUrl}
+            variant="minimal/small"
+            className="bg-error/10 hover:bg-error/20 text-error border-error/20"
+          >
+            Reconnect Vercel
+          </LinkButton>
+        </div>
+      </div>
+    </Callout>
+  );
+}
+
+function VercelGitHubWarning() {
+  return (
+    <Callout variant="warning" className="mb-4">
+      <p className="font-sans text-xs font-normal text-text-dimmed">
+        GitHub integration is not connected. Vercel integration cannot sync environment variables and
+        link deployments without a properly installed GitHub integration.
+      </p>
+    </Callout>
+  );
+}
+
+function envSlugLabel(slug: EnvSlug): string {
+  switch (slug) {
+    case "prod":
+      return "Production";
+    case "stg":
+      return "Staging";
+    case "preview":
+      return "Preview";
+    case "dev":
+      return "Development";
+  }
+}
+
+function ConnectedVercelProjectForm({
+  connectedProject,
+  hasStagingEnvironment,
+  hasPreviewEnvironment,
+  customEnvironments,
+  autoAssignCustomDomains,
+  organizationSlug,
+  projectSlug,
+  environmentSlug,
+}: {
+  connectedProject: ConnectedVercelProject;
+  hasStagingEnvironment: boolean;
+  hasPreviewEnvironment: boolean;
+  customEnvironments: Array<{ id: string; slug: string }>;
+  autoAssignCustomDomains: boolean | null;
+  organizationSlug: string;
+  projectSlug: string;
+  environmentSlug: string;
+}) {
+  const lastSubmission = useActionData() as any;
+  const navigation = useNavigation();
+
+  const [hasConfigChanges, setHasConfigChanges] = useState(false);
+  const [configValues, setConfigValues] = useState({
+    atomicBuilds: connectedProject.integrationData.config.atomicBuilds ?? [],
+    pullEnvVarsBeforeBuild: connectedProject.integrationData.config.pullEnvVarsBeforeBuild ?? [],
+    discoverEnvVars: connectedProject.integrationData.config.discoverEnvVars ?? [],
+    vercelStagingEnvironment:
+      connectedProject.integrationData.config.vercelStagingEnvironment ?? null,
+  });
+
+  const originalAtomicBuilds = connectedProject.integrationData.config.atomicBuilds ?? [];
+  const originalPullEnvVars = connectedProject.integrationData.config.pullEnvVarsBeforeBuild ?? [];
+  const originalDiscoverEnvVars = connectedProject.integrationData.config.discoverEnvVars ?? [];
+  const originalStagingEnv = connectedProject.integrationData.config.vercelStagingEnvironment ?? null;
+
+  useEffect(() => {
+    const atomicBuildsChanged =
+      JSON.stringify([...configValues.atomicBuilds].sort()) !==
+      JSON.stringify([...originalAtomicBuilds].sort());
+    const pullEnvVarsChanged =
+      JSON.stringify([...configValues.pullEnvVarsBeforeBuild].sort()) !==
+      JSON.stringify([...originalPullEnvVars].sort());
+    const discoverEnvVarsChanged =
+      JSON.stringify([...configValues.discoverEnvVars].sort()) !==
+      JSON.stringify([...originalDiscoverEnvVars].sort());
+    const stagingEnvChanged = configValues.vercelStagingEnvironment?.environmentId !== originalStagingEnv?.environmentId;
+
+    setHasConfigChanges(atomicBuildsChanged || pullEnvVarsChanged || discoverEnvVarsChanged || stagingEnvChanged);
+  }, [configValues, originalAtomicBuilds, originalPullEnvVars, originalDiscoverEnvVars, originalStagingEnv]);
+
+  const [configForm, fields] = useForm({
+    id: "update-vercel-config",
+    lastSubmission: lastSubmission,
+    shouldRevalidate: "onSubmit",
+    onValidate({ formData }) {
+      return parse(formData, {
+        schema: UpdateVercelConfigFormSchema,
+      });
+    },
+  });
+
+  const isConfigLoading =
+    navigation.formData?.get("action") === "update-config" &&
+    (navigation.state === "submitting" || navigation.state === "loading");
+
+  const actionUrl = vercelResourcePath(organizationSlug, projectSlug, environmentSlug);
+
+  const availableEnvSlugs = getAvailableEnvSlugs(hasStagingEnvironment, hasPreviewEnvironment);
+  const availableEnvSlugsForBuildSettings = getAvailableEnvSlugsForBuildSettings(hasStagingEnvironment, hasPreviewEnvironment);
+
+  const disabledEnvSlugsForBuildSettings: Partial<Record<EnvSlug, string>> | undefined =
+    hasStagingEnvironment && !configValues.vercelStagingEnvironment
+      ? { stg: "Map a custom Vercel environment to Staging to enable this" }
+      : undefined;
+
+  const formatSelectedEnvs = (selected: EnvSlug[], availableSlugs: EnvSlug[] = availableEnvSlugs): string => {
+    if (selected.length === 0) return "None selected";
+    if (selected.length === availableSlugs.length) return "All environments";
+    return selected.map(envSlugLabel).join(", ");
+  };
+
+  return (
+    <>
+      <div className="mb-4 flex items-center justify-between rounded-sm border bg-grid-dimmed p-2">
+        <div className="flex items-center gap-2">
+          <VercelLogo className="size-4" />
+          <span className="max-w-52 truncate text-sm text-text-bright">
+            {connectedProject.vercelProjectName}
+          </span>
+          <span className="text-xs text-text-dimmed">
+            <DateTime
+              date={connectedProject.createdAt}
+              includeTime={false}
+              includeSeconds={false}
+              showTimezone={false}
+              showTooltip={false}
+            />
+          </span>
+        </div>
+        <Dialog>
+          <DialogTrigger asChild>
+            <Button variant="minimal/small">Disconnect</Button>
+          </DialogTrigger>
+          <DialogContent className="max-w-md">
+            <DialogHeader>Disconnect Vercel project</DialogHeader>
+            <div className="flex flex-col gap-3 pt-3">
+              <Paragraph className="mb-1">
+                Are you sure you want to disconnect{" "}
+                <span className="font-semibold">{connectedProject.vercelProjectName}</span>?
+                This will stop pulling environment variables and disable atomic deployments.
+              </Paragraph>
+              <FormButtons
+                confirmButton={
+                  <Form method="post" action={actionUrl}>
+                    <input type="hidden" name="action" value="disconnect" />
+                    <Button type="submit" variant="danger/medium">
+                      Disconnect project
+                    </Button>
+                  </Form>
+                }
+                cancelButton={
+                  <DialogClose asChild>
+                    <Button variant="tertiary/medium">Cancel</Button>
+                  </DialogClose>
+                }
+              />
+            </div>
+          </DialogContent>
+        </Dialog>
+      </div>
+
+      {/* Configuration form */}
+      <Form method="post" action={actionUrl} {...configForm.props}>
+        <input
+          type="hidden"
+          name="atomicBuilds"
+          value={JSON.stringify(configValues.atomicBuilds)}
+        />
+        <input
+          type="hidden"
+          name="pullEnvVarsBeforeBuild"
+          value={JSON.stringify(configValues.pullEnvVarsBeforeBuild)}
+        />
+        <input
+          type="hidden"
+          name="discoverEnvVars"
+          value={JSON.stringify(configValues.discoverEnvVars)}
+        />
+        <input
+          type="hidden"
+          name="vercelStagingEnvironment"
+          value={configValues.vercelStagingEnvironment ? JSON.stringify(configValues.vercelStagingEnvironment) : ""}
+        />
+
+        <Fieldset>
+          <InputGroup fullWidth>
+            <div className="flex flex-col gap-4">
+              {/* Staging environment mapping */}
+              {hasStagingEnvironment && customEnvironments && customEnvironments.length > 0 && (
+                <div>
+                  <Label>Map Vercel environment to Staging</Label>
+                  <Hint className="mb-2">
+                    Select which custom Vercel environment should map to Trigger.dev's Staging
+                    environment.
+                  </Hint>
+                  <Select
+                    value={configValues.vercelStagingEnvironment?.environmentId || ""}
+                    setValue={(value) => {
+                      if (!Array.isArray(value)) {
+                        const env = customEnvironments?.find((e) => e.id === value);
+                        setConfigValues((prev) => {
+                          const next = {
+                            ...prev,
+                            vercelStagingEnvironment: env
+                              ? { environmentId: env.id, displayName: env.slug }
+                              : null,
+                          };
+                          // When clearing the staging mapping, strip "stg" from build settings
+                          if (!env) {
+                            next.pullEnvVarsBeforeBuild = prev.pullEnvVarsBeforeBuild.filter(
+                              (s) => s !== "stg"
+                            );
+                            next.discoverEnvVars = prev.discoverEnvVars.filter(
+                              (s) => s !== "stg"
+                            );
+                          }
+                          return next;
+                        });
+                      }
+                    }}
+                    items={[{ id: "", slug: "None" }, ...customEnvironments]}
+                    variant="tertiary/small"
+                    placeholder="Select environment"
+                    dropdownIcon
+                    text={configValues.vercelStagingEnvironment?.displayName || "None"}
+                  >
+                    {[
+                      <SelectItem key="" value="">
+                        None
+                      </SelectItem>,
+                      ...customEnvironments.map((env) => (
+                        <SelectItem key={env.id} value={env.id}>
+                          {env.slug}
+                        </SelectItem>
+                      )),
+                    ]}
+                  </Select>
+                </div>
+              )}
+
+              <BuildSettingsFields
+                availableEnvSlugs={availableEnvSlugsForBuildSettings}
+                pullEnvVarsBeforeBuild={configValues.pullEnvVarsBeforeBuild}
+                onPullEnvVarsChange={(slugs) =>
+                  setConfigValues((prev) => ({ ...prev, pullEnvVarsBeforeBuild: slugs }))
+                }
+                discoverEnvVars={configValues.discoverEnvVars}
+                onDiscoverEnvVarsChange={(slugs) =>
+                  setConfigValues((prev) => ({ ...prev, discoverEnvVars: slugs }))
+                }
+                atomicBuilds={configValues.atomicBuilds}
+                onAtomicBuildsChange={(slugs) =>
+                  setConfigValues((prev) => ({ ...prev, atomicBuilds: slugs }))
+                }
+                envVarsConfigLink={`/orgs/${organizationSlug}/projects/${projectSlug}/env/${environmentSlug}/environment-variables`}
+                disabledEnvSlugs={disabledEnvSlugsForBuildSettings}
+              />
+
+              {/* Warning: autoAssignCustomDomains must be disabled for atomic deployments */}
+              {autoAssignCustomDomains !== false &&
+                configValues.atomicBuilds.includes("prod") && (
+                  <Callout variant="warning">
+                    <div className="flex flex-col gap-2">
+                      <p className="font-sans text-xs font-normal text-text-dimmed">
+                        Atomic deployments require the "Auto-assign Custom Domains" setting to be
+                        disabled on your Vercel project. Without this, Vercel will promote
+                        deployments before Trigger.dev is ready.
+                      </p>
+                      <Form method="post" action={actionUrl}>
+                        <input type="hidden" name="action" value="disable-auto-assign" />
+                        <Button
+                          type="submit"
+                          variant="tertiary/small"
+                          disabled={
+                            navigation.formData?.get("action") === "disable-auto-assign" &&
+                            (navigation.state === "submitting" || navigation.state === "loading")
+                          }
+                          LeadingIcon={
+                            navigation.formData?.get("action") === "disable-auto-assign" &&
+                            (navigation.state === "submitting" || navigation.state === "loading")
+                              ? SpinnerWhite
+                              : undefined
+                          }
+                        >
+                          Disable auto-assign custom domains
+                        </Button>
+                      </Form>
+                    </div>
+                  </Callout>
+                )}
+            </div>
+
+            <FormError>{configForm.error}</FormError>
+          </InputGroup>
+
+          <FormButtons
+            confirmButton={
+              <Button
+                type="submit"
+                name="action"
+                value="update-config"
+                variant="secondary/small"
+                disabled={isConfigLoading || !hasConfigChanges}
+                LeadingIcon={isConfigLoading ? SpinnerWhite : undefined}
+              >
+                Save
+              </Button>
+            }
+          />
+        </Fieldset>
+      </Form>
+    </>
+  );
+}
+
+function VercelSettingsPanel({
+  organizationSlug,
+  projectSlug,
+  environmentSlug,
+  onOpenVercelModal,
+  isLoadingVercelData,
+}: {
+  organizationSlug: string;
+  projectSlug: string;
+  environmentSlug: string;
+  onOpenVercelModal?: () => void;
+  isLoadingVercelData?: boolean;
+}) {
+  const fetcher = useTypedFetcher<typeof loader>();
+  const location = useLocation();
+  const data = fetcher.data;
+  const [hasError, setHasError] = useState(false);
+  const [hasFetched, setHasFetched] = useState(false);
+
+  useEffect(() => {
+    if (!data?.authInvalid && !hasError && !data && !hasFetched) {
+      fetcher.load(vercelResourcePath(organizationSlug, projectSlug, environmentSlug));
+      setHasFetched(true);
+    }
+  }, [organizationSlug, projectSlug, environmentSlug, data?.authInvalid, hasError, data, hasFetched]);
+
+  useEffect(() => {
+    if (hasFetched && fetcher.state === "idle" && fetcher.data === undefined && !hasError) {
+      setHasError(true);
+    }
+  }, [fetcher.state, fetcher.data, hasError, hasFetched]);
+
+  if (hasError) {
+    return (
+      <div className="rounded-sm border border-rose-500/40 bg-rose-500/10 p-4">
+        <div className="flex items-start gap-3">
+          <ExclamationTriangleIcon className="h-5 w-5 text-rose-500 flex-shrink-0" />
+          <div>
+            <p className="font-medium text-rose-400">Failed to load Vercel settings</p>
+            <p className="text-sm text-rose-300 mt-1">
+              There was an error loading the Vercel integration settings. Please refresh the page to try again.
+            </p>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  if (fetcher.state === "loading" && !data) {
+    return (
+      <div className="flex items-center gap-2 text-text-dimmed">
+        <SpinnerWhite className="size-4" />
+        <span className="text-sm">Loading Vercel settings...</span>
+      </div>
+    );
+  }
+
+  if (!data || !data.enabled) {
+    return null;
+  }
+
+  const showGitHubWarning = data.connectedProject && !data.isGitHubConnected;
+  const showAuthInvalid = data.authInvalid || data.onboardingData?.authInvalid;
+
+  if (data.connectedProject) {
+    return (
+      <>
+        {showAuthInvalid && <VercelAuthInvalidBanner organizationSlug={organizationSlug} projectSlug={projectSlug} />}
+        {showGitHubWarning && <VercelGitHubWarning />}
+        {!showAuthInvalid && (<ConnectedVercelProjectForm
+          connectedProject={data.connectedProject}
+          hasStagingEnvironment={data.hasStagingEnvironment}
+          hasPreviewEnvironment={data.hasPreviewEnvironment}
+          customEnvironments={data.customEnvironments}
+          autoAssignCustomDomains={data.autoAssignCustomDomains ?? null}
+          organizationSlug={organizationSlug}
+          projectSlug={projectSlug}
+          environmentSlug={environmentSlug}
+        />)}
+      </>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-2">
+      {showAuthInvalid && <VercelAuthInvalidBanner organizationSlug={organizationSlug} projectSlug={projectSlug} />}
+      {!showAuthInvalid && (
+        <>
+          <VercelConnectionPrompt
+            organizationSlug={organizationSlug}
+            projectSlug={projectSlug}
+            environmentSlug={environmentSlug}
+            hasOrgIntegration={data.hasOrgIntegration}
+            isGitHubConnected={data.isGitHubConnected}
+            onOpenModal={showAuthInvalid ? undefined : onOpenVercelModal}
+            isLoading={isLoadingVercelData}
+          />
+          <Hint>
+            {data.hasOrgIntegration
+              ? "Connect your Vercel project to pull environment variables and trigger builds automatically."
+              : "Install the Vercel app to connect your projects and pull environment variables."}
+          </Hint>
+          {!data.isGitHubConnected && (
+            <Hint>
+              GitHub integration is not connected. Vercel integration cannot sync environment variables and
+              link deployments without a properly installed GitHub integration.
+            </Hint>
+          )}
+        </>
+      )}
+    </div>
+  );
+}
+
+
+import { VercelOnboardingModal } from "~/components/integrations/VercelOnboardingModal";
+
+export { VercelSettingsPanel, VercelOnboardingModal };
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route.tsx
index 2544b2ea52c..670aee165c1 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.waitpoints.$waitpointFriendlyId.complete/route.tsx
@@ -2,13 +2,7 @@ import { env } from "~/env.server";
 import { parse } from "@conform-to/zod";
 import { Form, useLocation, useNavigation, useSubmit } from "@remix-run/react";
 import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
-import {
-  conditionallyExportPacket,
-  IOPacket,
-  stringifyIO,
-  timeoutError,
-  WaitpointTokenStatus,
-} from "@trigger.dev/core/v3";
+import { stringifyIO, timeoutError, WaitpointTokenStatus } from "@trigger.dev/core/v3";
 import { WaitpointId } from "@trigger.dev/core/v3/isomorphic";
 import type { Waitpoint } from "@trigger.dev/database";
 import { useCallback, useRef } from "react";
@@ -24,6 +18,8 @@ import { $replica } from "~/db.server";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
+import { processWaitpointCompletionPacket } from "~/runEngine/concerns/waitpointCompletionPacket.server";
 import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
 import { EnvironmentParamSchema, ProjectParamSchema, v3RunsPath } from "~/utils/pathBuilder";
@@ -86,6 +82,7 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
     const waitpoint = await $replica.waitpoint.findFirst({
       select: {
         projectId: true,
+        environmentId: true,
       },
       where: {
         id: waitpointId,
@@ -150,11 +147,29 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
             );
           }
 
+          const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+          if (!environment) {
+            return redirectWithErrorMessage(
+              submission.value.failureRedirect,
+              request,
+              "Environment not found"
+            );
+          }
+
+          if (environment.id !== waitpoint.environmentId) {
+            return redirectWithErrorMessage(
+              submission.value.failureRedirect,
+              request,
+              "No waitpoint found"
+            );
+          }
+
           const data = submission.value.payload ? JSON.parse(submission.value.payload) : {};
           const stringifiedData = await stringifyIO(data);
-          const finalData = await conditionallyExportPacket(
+          const finalData = await processWaitpointCompletionPacket(
             stringifiedData,
-            `${waitpointId}/waitpoint/token`
+            environment,
+            `${WaitpointId.toFriendlyId(waitpointId)}/token`
           );
 
           const result = await engine.completeWaitpoint({
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.select-plan.tsx b/apps/webapp/app/routes/resources.orgs.$organizationSlug.select-plan.tsx
index 4e1c5ce40dd..131dc6b3e47 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.select-plan.tsx
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.select-plan.tsx
@@ -11,7 +11,7 @@ import { type ActionFunctionArgs } from "@remix-run/server-runtime";
 import { uiComponent } from "@team-plain/typescript-sdk";
 import { GitHubLightIcon } from "@trigger.dev/companyicons";
 import {
-  AddOnPricing,
+  type AddOnPricing,
   type FreePlanDefinition,
   type Limits,
   type PaidPlanDefinition,
@@ -210,7 +210,7 @@ const pricingDefinitions = {
   },
   additionalRealtimeConnections: {
     title: "Additional Realtime connections",
-    content: "Then $10/month per 100",
+    content: "Then $10/month per 1000",
   },
   additionalSeats: {
     title: "Additional seats",
@@ -225,6 +225,18 @@ const pricingDefinitions = {
     title: "Additional branches",
     content: "Then $10/month per branch",
   },
+  metricDashboards: {
+    title: "Custom dashboards",
+    content: "Custom metric dashboards for monitoring and visualizing your task data.",
+  },
+  additionalDashboards: {
+    title: "Additional dashboards",
+    content: "Then $10/month per dashboard",
+  },
+  queryPeriod: {
+    title: "Query period",
+    content: "The maximum number of days a query can look back when analyzing your task data.",
+  },
 };
 
 type PricingPlansProps = {
@@ -534,8 +546,10 @@ export function TierFree({
             <TeamMembers limits={plan.limits} />
             <Environments limits={plan.limits} />
             <Branches limits={plan.limits} />
+            <MetricDashboards limits={plan.limits} />
             <Schedules limits={plan.limits} />
             <LogRetention limits={plan.limits} />
+            <QueryPeriod limits={plan.limits} />
             <SupportLevel limits={plan.limits} />
             <Alerts limits={plan.limits} />
             <RealtimeConcurrency limits={plan.limits} />
@@ -651,8 +665,10 @@ export function TierHobby({
         <TeamMembers limits={plan.limits} />
         <Environments limits={plan.limits} />
         <Branches limits={plan.limits} />
+        <MetricDashboards limits={plan.limits} />
         <Schedules limits={plan.limits} />
         <LogRetention limits={plan.limits} />
+        <QueryPeriod limits={plan.limits} />
         <SupportLevel limits={plan.limits} />
         <Alerts limits={plan.limits} />
         <RealtimeConcurrency limits={plan.limits} />
@@ -774,8 +790,12 @@ export function TierPro({
         <TeamMembers limits={plan.limits}>{pricingDefinitions.additionalSeats.content}</TeamMembers>
         <Environments limits={plan.limits} />
         <Branches limits={plan.limits}>{pricingDefinitions.additionalBranches.content}</Branches>
+        <MetricDashboards limits={plan.limits}>
+          {pricingDefinitions.additionalDashboards.content}
+        </MetricDashboards>
         <Schedules limits={plan.limits}>{pricingDefinitions.additionalSchedules.content}</Schedules>
         <LogRetention limits={plan.limits} />
+        <QueryPeriod limits={plan.limits} />
         <SupportLevel limits={plan.limits} />
         <Alerts limits={plan.limits} />
         <RealtimeConcurrency limits={plan.limits}>
@@ -1139,6 +1159,53 @@ function RealtimeConcurrency({ limits, children }: { limits: Limits; children?:
   );
 }
 
+function MetricDashboards({ limits, children }: { limits: Limits; children?: React.ReactNode }) {
+  if (limits.metricDashboards.number === 0) {
+    return (
+      <FeatureItem>
+        <DefinitionTip
+          title={pricingDefinitions.metricDashboards.title}
+          content={pricingDefinitions.metricDashboards.content}
+        >
+          Custom dashboards
+        </DefinitionTip>
+      </FeatureItem>
+    );
+  }
+
+  return (
+    <FeatureItem checked>
+      <div className="flex flex-col gap-y-0.5">
+        <div className="flex items-center gap-1">
+          {limits.metricDashboards.number}
+          {limits.metricDashboards.canExceed ? "+" : ""}{" "}
+          <DefinitionTip
+            title={pricingDefinitions.metricDashboards.title}
+            content={pricingDefinitions.metricDashboards.content}
+          >
+            custom {limits.metricDashboards.number === 1 ? "dashboard" : "dashboards"}
+          </DefinitionTip>
+        </div>
+        {children && <span className="text-xs text-text-dimmed">{children}</span>}
+      </div>
+    </FeatureItem>
+  );
+}
+
+function QueryPeriod({ limits }: { limits: Limits }) {
+  return (
+    <FeatureItem checked>
+      {limits.queryPeriodDays.number} {limits.queryPeriodDays.number === 1 ? "day" : "days"}{" "}
+      <DefinitionTip
+        title={pricingDefinitions.queryPeriod.title}
+        content={pricingDefinitions.queryPeriod.content}
+      >
+        query period
+      </DefinitionTip>
+    </FeatureItem>
+  );
+}
+
 function Branches({ limits, children }: { limits: Limits; children?: React.ReactNode }) {
   return (
     <FeatureItem checked={limits.branches.number > 0}>
diff --git a/apps/webapp/app/routes/resources.packets.$environmentId.$.ts b/apps/webapp/app/routes/resources.packets.$environmentId.$.ts
index 2c3e280a7e5..4269e13d63a 100644
--- a/apps/webapp/app/routes/resources.packets.$environmentId.$.ts
+++ b/apps/webapp/app/routes/resources.packets.$environmentId.$.ts
@@ -3,7 +3,7 @@ import { basename } from "node:path";
 import { z } from "zod";
 import { prisma } from "~/db.server";
 import { requireUserId } from "~/services/session.server";
-import { generatePresignedRequest } from "~/v3/r2.server";
+import { generatePresignedRequest } from "~/v3/objectStore.server";
 
 const ParamSchema = z.object({
   environmentId: z.string(),
diff --git a/apps/webapp/app/routes/resources.platform-changelogs.tsx b/apps/webapp/app/routes/resources.platform-changelogs.tsx
new file mode 100644
index 00000000000..da71df2e279
--- /dev/null
+++ b/apps/webapp/app/routes/resources.platform-changelogs.tsx
@@ -0,0 +1,49 @@
+import { json } from "@remix-run/node";
+import type { LoaderFunctionArgs } from "@remix-run/node";
+import { useFetcher, type ShouldRevalidateFunction } from "@remix-run/react";
+import { useEffect, useRef } from "react";
+import { requireUserId } from "~/services/session.server";
+import { getRecentChangelogs } from "~/services/platformNotifications.server";
+
+export const shouldRevalidate: ShouldRevalidateFunction = () => false;
+
+export type PlatformChangelogsLoaderData = {
+  changelogs: Array<{ id: string; title: string; actionUrl?: string }>;
+};
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  await requireUserId(request);
+
+  const changelogs = await getRecentChangelogs();
+
+  return json<PlatformChangelogsLoaderData>({ changelogs });
+}
+
+const POLL_INTERVAL_MS = 60_000;
+
+export function useRecentChangelogs() {
+  const fetcher = useFetcher<typeof loader>();
+  const hasInitiallyFetched = useRef(false);
+
+  useEffect(() => {
+    const url = "/resources/platform-changelogs";
+
+    if (!hasInitiallyFetched.current && fetcher.state === "idle") {
+      hasInitiallyFetched.current = true;
+      fetcher.load(url);
+    }
+
+    const interval = setInterval(() => {
+      if (fetcher.state === "idle") {
+        fetcher.load(url);
+      }
+    }, POLL_INTERVAL_MS);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  return {
+    changelogs: fetcher.data?.changelogs ?? [],
+    isLoading: fetcher.state !== "idle",
+  };
+}
diff --git a/apps/webapp/app/routes/resources.platform-notifications.$id.clicked.tsx b/apps/webapp/app/routes/resources.platform-notifications.$id.clicked.tsx
new file mode 100644
index 00000000000..8ddf9adbc64
--- /dev/null
+++ b/apps/webapp/app/routes/resources.platform-notifications.$id.clicked.tsx
@@ -0,0 +1,17 @@
+import { json } from "@remix-run/node";
+import type { ActionFunctionArgs } from "@remix-run/node";
+import { requireUserId } from "~/services/session.server";
+import { recordNotificationClicked } from "~/services/platformNotifications.server";
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const notificationId = params.id;
+
+  if (!notificationId) {
+    return json({ success: false }, { status: 400 });
+  }
+
+  await recordNotificationClicked({ notificationId, userId });
+
+  return json({ success: true });
+}
diff --git a/apps/webapp/app/routes/resources.platform-notifications.$id.dismiss.tsx b/apps/webapp/app/routes/resources.platform-notifications.$id.dismiss.tsx
new file mode 100644
index 00000000000..e6a475692d9
--- /dev/null
+++ b/apps/webapp/app/routes/resources.platform-notifications.$id.dismiss.tsx
@@ -0,0 +1,17 @@
+import { json } from "@remix-run/node";
+import type { ActionFunctionArgs } from "@remix-run/node";
+import { requireUserId } from "~/services/session.server";
+import { dismissNotification } from "~/services/platformNotifications.server";
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const notificationId = params.id;
+
+  if (!notificationId) {
+    return json({ success: false }, { status: 400 });
+  }
+
+  await dismissNotification({ notificationId, userId });
+
+  return json({ success: true });
+}
diff --git a/apps/webapp/app/routes/resources.platform-notifications.$id.seen.tsx b/apps/webapp/app/routes/resources.platform-notifications.$id.seen.tsx
new file mode 100644
index 00000000000..652d4ee99c0
--- /dev/null
+++ b/apps/webapp/app/routes/resources.platform-notifications.$id.seen.tsx
@@ -0,0 +1,17 @@
+import { json } from "@remix-run/node";
+import type { ActionFunctionArgs } from "@remix-run/node";
+import { requireUserId } from "~/services/session.server";
+import { recordNotificationSeen } from "~/services/platformNotifications.server";
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const notificationId = params.id;
+
+  if (!notificationId) {
+    return json({ success: false }, { status: 400 });
+  }
+
+  await recordNotificationSeen({ notificationId, userId });
+
+  return json({ success: true });
+}
diff --git a/apps/webapp/app/routes/resources.platform-notifications.tsx b/apps/webapp/app/routes/resources.platform-notifications.tsx
new file mode 100644
index 00000000000..18d54ec352b
--- /dev/null
+++ b/apps/webapp/app/routes/resources.platform-notifications.tsx
@@ -0,0 +1,61 @@
+import { json } from "@remix-run/node";
+import type { LoaderFunctionArgs } from "@remix-run/node";
+import { useFetcher, type ShouldRevalidateFunction } from "@remix-run/react";
+import { useEffect, useRef } from "react";
+import { requireUserId } from "~/services/session.server";
+import {
+  getActivePlatformNotifications,
+  type PlatformNotificationWithPayload,
+} from "~/services/platformNotifications.server";
+
+export const shouldRevalidate: ShouldRevalidateFunction = () => false;
+
+export type PlatformNotificationsLoaderData = {
+  notifications: PlatformNotificationWithPayload[];
+  unreadCount: number;
+};
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const url = new URL(request.url);
+  const organizationId = url.searchParams.get("organizationId");
+  const projectId = url.searchParams.get("projectId") ?? undefined;
+
+  if (!organizationId) {
+    return json<PlatformNotificationsLoaderData>({ notifications: [], unreadCount: 0 });
+  }
+
+  const result = await getActivePlatformNotifications({ userId, organizationId, projectId });
+
+  return json<PlatformNotificationsLoaderData>(result);
+}
+
+const POLL_INTERVAL_MS = 60000; // 1 minute
+
+export function usePlatformNotifications(organizationId: string, projectId: string) {
+  const fetcher = useFetcher<typeof loader>();
+  const lastLoadedUrl = useRef<string | null>(null);
+
+  useEffect(() => {
+    const url = `/resources/platform-notifications?organizationId=${encodeURIComponent(organizationId)}&projectId=${encodeURIComponent(projectId)}`;
+
+    if (lastLoadedUrl.current !== url && fetcher.state === "idle") {
+      lastLoadedUrl.current = url;
+      fetcher.load(url);
+    }
+
+    const interval = setInterval(() => {
+      if (fetcher.state === "idle") {
+        fetcher.load(url);
+      }
+    }, POLL_INTERVAL_MS);
+
+    return () => clearInterval(interval);
+  }, [organizationId, projectId]);
+
+  return {
+    notifications: fetcher.data?.notifications ?? [],
+    unreadCount: fetcher.data?.unreadCount ?? 0,
+    isLoading: fetcher.state !== "idle",
+  };
+}
diff --git a/apps/webapp/app/routes/resources.preferences.sidemenu.tsx b/apps/webapp/app/routes/resources.preferences.sidemenu.tsx
new file mode 100644
index 00000000000..13f442aa610
--- /dev/null
+++ b/apps/webapp/app/routes/resources.preferences.sidemenu.tsx
@@ -0,0 +1,76 @@
+import { json, type ActionFunctionArgs } from "@remix-run/node";
+import { z } from "zod";
+import {
+  SideMenuSectionIdSchema,
+  type SideMenuSectionId,
+} from "~/components/navigation/sideMenuTypes";
+import {
+  updateItemOrder,
+  updateSideMenuPreferences,
+} from "~/services/dashboardPreferences.server";
+import { requireUser } from "~/services/session.server";
+
+// Transforms form data string "true"/"false" to boolean, or undefined if not present
+const booleanFromFormData = z
+  .enum(["true", "false"])
+  .transform((val) => val === "true")
+  .optional();
+
+const RequestSchema = z.object({
+  isCollapsed: booleanFromFormData,
+  sectionId: SideMenuSectionIdSchema.optional(),
+  sectionCollapsed: booleanFromFormData,
+  // Generic item order fields
+  organizationId: z.string().optional(),
+  listId: z.string().optional(),
+  itemOrder: z.string().optional(), // JSON-encoded string[]
+});
+
+export async function action({ request }: ActionFunctionArgs) {
+  const user = await requireUser(request);
+
+  const formData = await request.formData();
+  const rawData = Object.fromEntries(formData);
+
+  const result = RequestSchema.safeParse(rawData);
+  if (!result.success) {
+    return json({ success: false, error: "Invalid request data" }, { status: 400 });
+  }
+
+  // Handle item order update
+  if (result.data.organizationId && result.data.listId && result.data.itemOrder) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(result.data.itemOrder);
+    } catch {
+      parsed = [];
+    }
+    const orderResult = z.array(z.string()).safeParse(parsed);
+    if (orderResult.success) {
+      await updateItemOrder({
+        user,
+        organizationId: result.data.organizationId,
+        listId: result.data.listId,
+        order: orderResult.data,
+      });
+    }
+    return json({ success: true });
+  }
+
+  // Build sectionCollapsed parameter if both sectionId and sectionCollapsed are provided
+  const sectionCollapsed =
+    result.data.sectionId !== undefined && result.data.sectionCollapsed !== undefined
+      ? {
+          sectionId: result.data.sectionId as SideMenuSectionId,
+          collapsed: result.data.sectionCollapsed,
+        }
+      : undefined;
+
+  await updateSideMenuPreferences({
+    user,
+    isCollapsed: result.data.isCollapsed,
+    sectionCollapsed,
+  });
+
+  return json({ success: true });
+}
diff --git a/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts b/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts
index 57de7632a20..8a22822d06b 100644
--- a/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts
+++ b/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts
@@ -7,7 +7,7 @@ import { $replica, prisma } from "~/db.server";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { displayableEnvironment } from "~/models/runtimeEnvironment.server";
 import { logger } from "~/services/logger.server";
-import { requireUserId } from "~/services/session.server";
+import { requireUser } from "~/services/session.server";
 import { sortEnvironments } from "~/utils/environmentSort";
 import { v3RunSpanPath } from "~/utils/pathBuilder";
 import { ReplayTaskRunService } from "~/v3/services/replayTaskRun.server";
@@ -15,6 +15,7 @@ import parseDuration from "parse-duration";
 import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
 import { queueTypeFromType } from "~/presenters/v3/QueueRetrievePresenter.server";
 import { ReplayRunData } from "~/v3/replayTask";
+import { RegionsPresenter } from "~/presenters/v3/RegionsPresenter.server";
 
 const ParamSchema = z.object({
   runParam: z.string(),
@@ -25,7 +26,8 @@ const QuerySchema = z.object({
 });
 
 export async function loader({ request, params }: LoaderFunctionArgs) {
-  const userId = await requireUserId(request);
+  const user = await requireUser(request);
+  const userId = user.id;
   const { runParam } = ParamSchema.parse(params);
   const { environmentIdOverride } = QuerySchema.parse(
     Object.fromEntries(new URL(request.url).searchParams)
@@ -42,6 +44,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
       maxAttempts: true,
       maxDurationInSeconds: true,
       machinePreset: true,
+      workerQueue: true,
       ttl: true,
       idempotencyKey: true,
       runTags: true,
@@ -49,6 +52,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
       taskIdentifier: true,
       project: {
         select: {
+          slug: true,
           environments: {
             select: {
               id: true,
@@ -108,13 +112,22 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   const disableVersionSelection = environment.type === "DEVELOPMENT";
   const allowArbitraryQueues = backgroundWorkers.at(0)?.engine === "V1";
 
-  const payload = await prettyPrintPacket(run.payload, run.payloadType);
+  const [payload, regionsResult] = await Promise.all([
+    prettyPrintPacket(run.payload, run.payloadType),
+    new RegionsPresenter().call({
+      userId,
+      projectSlug: run.project.slug,
+      isAdmin: user.admin || user.isImpersonating,
+    }),
+  ]);
 
   return typedjson({
     concurrencyKey: run.concurrencyKey,
     maxAttempts: run.maxAttempts,
     maxDurationSeconds: run.maxDurationInSeconds,
     machinePreset: run.machinePreset,
+    region: environment.type === "DEVELOPMENT" ? undefined : run.workerQueue,
+    regions: regionsResult.regions,
     ttlSeconds: run.ttl ? parseDuration(run.ttl, "s") ?? undefined : undefined,
     idempotencyKey: run.idempotencyKey,
     runTags: run.runTags,
@@ -194,11 +207,14 @@ export const action: ActionFunction = async ({ request, params }) => {
       maxAttempts: submission.value.maxAttempts,
       maxDurationSeconds: submission.value.maxDurationSeconds,
       machine: submission.value.machine,
+      region: submission.value.region,
       delaySeconds: submission.value.delaySeconds,
       idempotencyKey: submission.value.idempotencyKey,
       idempotencyKeyTTLSeconds: submission.value.idempotencyKeyTTLSeconds,
       ttlSeconds: submission.value.ttlSeconds,
       version: submission.value.version,
+      prioritySeconds: submission.value.prioritySeconds,
+      triggerSource: "dashboard",
     });
 
     if (!newRun) {
diff --git a/apps/webapp/app/routes/resources.timezone.ts b/apps/webapp/app/routes/resources.timezone.ts
new file mode 100644
index 00000000000..f06b44e6149
--- /dev/null
+++ b/apps/webapp/app/routes/resources.timezone.ts
@@ -0,0 +1,43 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import {
+  setTimezonePreference,
+  uiPreferencesStorage,
+} from "~/services/preferences/uiPreferences.server";
+
+const schema = z.object({
+  timezone: z.string().min(1).max(100),
+});
+
+// Cache the supported timezones to avoid repeated calls
+const supportedTimezones = new Set(Intl.supportedValuesOf("timeZone"));
+
+export async function action({ request }: ActionFunctionArgs) {
+  let data: unknown;
+  try {
+    data = await request.json();
+  } catch {
+    return json({ success: false, error: "Invalid JSON" }, { status: 400 });
+  }
+
+  const result = schema.safeParse(data);
+
+  if (!result.success) {
+    return json({ success: false, error: "Invalid timezone" }, { status: 400 });
+  }
+
+  if (!supportedTimezones.has(result.data.timezone)) {
+    return json({ success: false, error: "Invalid timezone" }, { status: 400 });
+  }
+
+  const session = await setTimezonePreference(result.data.timezone, request);
+
+  return json(
+    { success: true },
+    {
+      headers: {
+        "Set-Cookie": await uiPreferencesStorage.commitSession(session),
+      },
+    }
+  );
+}
diff --git a/apps/webapp/app/routes/runs.$runParam.ts b/apps/webapp/app/routes/runs.$runParam.ts
new file mode 100644
index 00000000000..4a8d7a12d32
--- /dev/null
+++ b/apps/webapp/app/routes/runs.$runParam.ts
@@ -0,0 +1,68 @@
+import { redirect, type LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { requireUser } from "~/services/session.server";
+import { rootPath, v3RunPath } from "~/utils/pathBuilder";
+
+const ParamsSchema = z.object({
+  runParam: z.string(),
+});
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const user = await requireUser(request);
+
+  const { runParam } = ParamsSchema.parse(params);
+
+  const run = await prisma.taskRun.findFirst({
+    where: {
+      friendlyId: runParam,
+      project: {
+        organization: {
+          members: {
+            some: {
+              userId: user.id,
+            },
+          },
+        },
+      },
+    },
+    select: {
+      runtimeEnvironment: {
+        select: {
+          slug: true,
+        },
+      },
+      project: {
+        select: {
+          slug: true,
+          organization: {
+            select: {
+              slug: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  if (!run) {
+    return redirectWithErrorMessage(
+      rootPath(),
+      request,
+      "Run either doesn't exist or you don't have permission to view it",
+      {
+        ephemeral: false,
+      }
+    );
+  }
+
+  const path = v3RunPath(
+    { slug: run.project.organization.slug },
+    { slug: run.project.slug },
+    { slug: run.runtimeEnvironment.slug },
+    { friendlyId: runParam }
+  );
+
+  return redirect(path);
+}
diff --git a/apps/webapp/app/routes/storybook.animated-panel/route.tsx b/apps/webapp/app/routes/storybook.animated-panel/route.tsx
new file mode 100644
index 00000000000..2f136bddb19
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.animated-panel/route.tsx
@@ -0,0 +1,178 @@
+import { useState } from "react";
+import { ExitIcon } from "~/assets/icons/ExitIcon";
+import { Button } from "~/components/primitives/Buttons";
+import { Header2 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import * as Property from "~/components/primitives/PropertyTable";
+import {
+  RESIZABLE_PANEL_ANIMATION,
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  collapsibleHandleClassName,
+  useFrozenValue,
+} from "~/components/primitives/Resizable";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHeader,
+  TableHeaderCell,
+  TableRow,
+} from "~/components/primitives/Table";
+
+type DemoItem = {
+  id: string;
+  name: string;
+  status: "completed" | "running" | "failed" | "queued";
+  duration: string;
+  task: string;
+};
+
+const demoItems: DemoItem[] = [
+  { id: "run_a1b2c3d4", name: "Process invoices", status: "completed", duration: "2.3s", task: "invoice/process" },
+  { id: "run_e5f6g7h8", name: "Send welcome email", status: "running", duration: "0.8s", task: "email/welcome" },
+  { id: "run_i9j0k1l2", name: "Generate report", status: "failed", duration: "12.1s", task: "report/generate" },
+  { id: "run_m3n4o5p6", name: "Sync inventory", status: "completed", duration: "5.7s", task: "inventory/sync" },
+  { id: "run_q7r8s9t0", name: "Resize images", status: "queued", duration: "—", task: "image/resize" },
+  { id: "run_u1v2w3x4", name: "Update search index", status: "completed", duration: "1.1s", task: "search/index" },
+  { id: "run_y5z6a7b8", name: "Calculate analytics", status: "running", duration: "8.4s", task: "analytics/calc" },
+  { id: "run_c9d0e1f2", name: "Deploy preview", status: "completed", duration: "34.2s", task: "deploy/preview" },
+  { id: "run_g3h4i5j6", name: "Run migrations", status: "failed", duration: "0.3s", task: "db/migrate" },
+  { id: "run_k7l8m9n0", name: "Notify Slack", status: "completed", duration: "0.5s", task: "notify/slack" },
+];
+
+const statusColors: Record<DemoItem["status"], string> = {
+  completed: "text-success",
+  running: "text-blue-500",
+  failed: "text-error",
+  queued: "text-text-dimmed",
+};
+
+function DetailPanel({ item, onClose }: { item: DemoItem; onClose: () => void }) {
+  return (
+    <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden bg-background-bright">
+      <div className="flex items-center justify-between gap-2 overflow-x-hidden border-b border-grid-bright px-3 pr-2">
+        <Header2 className="truncate text-text-bright">{item.name}</Header2>
+        <Button
+          onClick={onClose}
+          variant="minimal/small"
+          TrailingIcon={ExitIcon}
+          shortcut={{ key: "esc" }}
+          shortcutPosition="before-trailing-icon"
+          className="pl-1"
+        />
+      </div>
+      <div className="overflow-y-auto px-3 py-3 scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
+        <Property.Table>
+          <Property.Item>
+            <Property.Label>Run ID</Property.Label>
+            <Property.Value>{item.id}</Property.Value>
+          </Property.Item>
+          <Property.Item>
+            <Property.Label>Task</Property.Label>
+            <Property.Value>{item.task}</Property.Value>
+          </Property.Item>
+          <Property.Item>
+            <Property.Label>Status</Property.Label>
+            <Property.Value>
+              <span className={statusColors[item.status]}>
+                {item.status.charAt(0).toUpperCase() + item.status.slice(1)}
+              </span>
+            </Property.Value>
+          </Property.Item>
+          <Property.Item>
+            <Property.Label>Duration</Property.Label>
+            <Property.Value>{item.duration}</Property.Value>
+          </Property.Item>
+        </Property.Table>
+        <div className="mt-4">
+          <Paragraph variant="small" className="text-text-dimmed">
+            This is a demo detail panel showing the animated slide-in/out behavior using
+            react-window-splitter&apos;s collapseAnimation. Click a different row to change the
+            detail, or press Esc / click the close button to dismiss.
+          </Paragraph>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default function Story() {
+  const [selectedItem, setSelectedItem] = useState<DemoItem | null>(null);
+  const show = !!selectedItem;
+  const frozenItem = useFrozenValue(selectedItem);
+  const displayItem = selectedItem ?? frozenItem;
+
+  return (
+    <div className="h-full">
+      <ResizablePanelGroup orientation="horizontal" className="max-h-full">
+        <ResizablePanel id="animated-panel-main" min="200px">
+          <div className="grid h-full max-h-full grid-rows-[2.5rem_1fr] overflow-hidden">
+            <div className="flex items-center border-b border-grid-bright px-3">
+              <Header2 className="text-text-bright">Runs</Header2>
+            </div>
+            <Table containerClassName="max-h-full" showTopBorder={false}>
+              <TableHeader>
+                <TableRow>
+                  <TableHeaderCell>Run ID</TableHeaderCell>
+                  <TableHeaderCell>Name</TableHeaderCell>
+                  <TableHeaderCell>Task</TableHeaderCell>
+                  <TableHeaderCell>Status</TableHeaderCell>
+                  <TableHeaderCell alignment="right">Duration</TableHeaderCell>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {demoItems.map((item) => (
+                  <TableRow key={item.id} isSelected={selectedItem?.id === item.id}>
+                    <TableCell onClick={() => setSelectedItem(item)} isTabbableCell>
+                      {item.id}
+                    </TableCell>
+                    <TableCell onClick={() => setSelectedItem(item)}>{item.name}</TableCell>
+                    <TableCell onClick={() => setSelectedItem(item)}>{item.task}</TableCell>
+                    <TableCell onClick={() => setSelectedItem(item)}>
+                      <span className={statusColors[item.status]}>
+                        {item.status.charAt(0).toUpperCase() + item.status.slice(1)}
+                      </span>
+                    </TableCell>
+                    <TableCell onClick={() => setSelectedItem(item)} alignment="right">
+                      {item.duration}
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        </ResizablePanel>
+        <ResizableHandle
+          id="animated-panel-handle"
+          className={collapsibleHandleClassName(show)}
+        />
+        <ResizablePanel
+          id="animated-panel-detail"
+          min="280px"
+          default="380px"
+          max="500px"
+          className="overflow-hidden"
+          collapsible
+          collapsed={!show}
+          onCollapseChange={(isCollapsed) => {
+            if (isCollapsed) setSelectedItem(null);
+          }}
+          collapsedSize="0px"
+          collapseAnimation={RESIZABLE_PANEL_ANIMATION}
+        >
+          <div className="h-full" style={{ minWidth: 280 }}>
+            {displayItem && (
+              <DetailPanel
+                key={displayItem.id}
+                item={displayItem}
+                onClose={() => setSelectedItem(null)}
+              />
+            )}
+          </div>
+        </ResizablePanel>
+      </ResizablePanelGroup>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/storybook.charts/route.tsx b/apps/webapp/app/routes/storybook.charts/route.tsx
new file mode 100644
index 00000000000..3f72904625a
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.charts/route.tsx
@@ -0,0 +1,771 @@
+import { ArrowTrendingUpIcon } from "@heroicons/react/20/solid";
+import { IconTimeline } from "@tabler/icons-react";
+import { useMemo, useState } from "react";
+import { Button } from "~/components/primitives/Buttons";
+import { BigNumberCard } from "~/components/primitives/charts/BigNumberCard";
+import { Card } from "~/components/primitives/charts/Card";
+import { type ChartConfig, type ChartState } from "~/components/primitives/charts/Chart";
+import { Chart } from "~/components/primitives/charts/ChartCompound";
+import {
+  DateRangeProvider,
+  formatISODate,
+  formatISODateLong,
+  useDateRange,
+} from "~/components/primitives/charts/DateRangeContext";
+import type { ZoomRange } from "~/components/primitives/charts/hooks/useZoomSelection";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { RadioGroup, RadioGroupItem } from "~/components/primitives/RadioButton";
+import SegmentedControl from "~/components/primitives/SegmentedControl";
+
+// Date formatters for chart display
+const xAxisTickFormatter = (value: string) => formatISODate(value);
+const tooltipLabelFormatter = (label: string) => formatISODateLong(label);
+
+/**
+ * Helper function to filter chart data by date range.
+ * In a real app, this would typically be handled server-side.
+ */
+function filterDataByDateRange<T extends Record<string, any>>(
+  data: T[],
+  dataKey: string,
+  startDate: string | undefined,
+  endDate: string | undefined
+): T[] {
+  if (!startDate || !endDate) return data;
+
+  const startIndex = data.findIndex((item) => item[dataKey] === startDate);
+  const endIndex = data.findIndex((item) => item[dataKey] === endDate);
+
+  if (startIndex === -1 || endIndex === -1) return data;
+
+  const [start, end] = [startIndex, endIndex].sort((a, b) => a - b);
+  return data.slice(start, end + 1);
+}
+
+function ChartsDashboard() {
+  const dateRange = useDateRange();
+  const [chartState, setChartState] = useState<ChartState>("loaded");
+
+  // Handle zoom change - updates the shared DateRangeContext
+  // In a real app, this would also trigger a server fetch for more granular data
+  const handleZoomChange = (range: ZoomRange) => {
+    console.log("Zoom changed:", range);
+    // Update the shared date range context so all charts sync
+    // dateRange?.setDateRange(range.start, range.end);
+    // In a real app, you would fetch new data here based on the range:
+    // fetchChartData(range.start, range.end).then(setData);
+  };
+
+  // Filter data based on the current date range from context
+  const filteredBarData = useMemo(
+    () =>
+      filterDataByDateRange(
+        API_DATA.barChartBigDatasetData,
+        "day",
+        dateRange?.startDate,
+        dateRange?.endDate
+      ),
+    [dateRange?.startDate, dateRange?.endDate]
+  );
+
+  const filteredBarData2 = useMemo(
+    () =>
+      filterDataByDateRange(API_DATA.barChartData, "day", dateRange?.startDate, dateRange?.endDate),
+    [dateRange?.startDate, dateRange?.endDate]
+  );
+
+  const filteredLineData = useMemo(
+    () =>
+      filterDataByDateRange(
+        API_DATA.lineChartData,
+        "day",
+        dateRange?.startDate,
+        dateRange?.endDate
+      ),
+    [dateRange?.startDate, dateRange?.endDate]
+  );
+
+  return (
+    <div className="grid">
+      <div className="flex items-center justify-between gap-4 border-b border-charcoal-700 bg-background-bright p-2 pl-3">
+        <div className="flex w-fit items-center">
+          <RadioGroup
+            name="chartState"
+            value={chartState}
+            onValueChange={(value) => setChartState(value as ChartState)}
+            className="flex items-center"
+          >
+            <RadioGroupItem id="loaded" label="Data loaded" value="loaded" variant="simple/small" />
+            <RadioGroupItem
+              id="loading"
+              label="Data loading"
+              value="loading"
+              variant="simple/small"
+            />
+            <RadioGroupItem id="noData" label="No data" value="noData" variant="simple/small" />
+            <RadioGroupItem
+              id="invalid"
+              label="Chart invalid"
+              value="invalid"
+              variant="simple/small"
+            />
+          </RadioGroup>
+        </div>
+        <div className="flex w-fit items-center gap-4">
+          <Paragraph variant="small/bright">
+            Current range: {dateRange?.startDate ? formatISODate(dateRange.startDate) : ""} -{" "}
+            {dateRange?.endDate ? formatISODate(dateRange.endDate) : ""}
+          </Paragraph>
+          <Button variant="secondary/small" onClick={() => dateRange?.resetDateRange()}>
+            Reset Zoom
+          </Button>
+        </div>
+      </div>
+
+      <div className="grid grid-cols-2 gap-3 p-3">
+        {/* Compound Component API Example */}
+        <Card>
+          <Card.Header>
+            <div className="flex items-center gap-1.5">
+              <ArrowTrendingUpIcon className="size-5 text-indigo-500" />
+              Compound API <span className="font-normal text-text-dimmed">(with zoom)</span>
+            </div>
+            <Card.Accessory>
+              <SegmentedControl
+                name="compoundByStatus"
+                options={[
+                  { label: "By status", value: "status" },
+                  { label: "By task", value: "task" },
+                ]}
+                defaultValue="status"
+                variant="secondary/small"
+              />
+            </Card.Accessory>
+          </Card.Header>
+          <Card.Content>
+            <Chart.Root
+              config={barChartBigDatasetConfig}
+              data={filteredBarData}
+              dataKey="day"
+              labelFormatter={tooltipLabelFormatter}
+              enableZoom
+              onZoomChange={handleZoomChange}
+              state={chartState === "loaded" ? undefined : chartState}
+              minHeight="400px"
+              showLegend
+              maxLegendItems={5}
+            >
+              <Chart.Bar
+                stackId="a"
+                referenceLine={{
+                  value: 45000,
+                  label: "Max concurrency",
+                }}
+                xAxisProps={{ tickFormatter: xAxisTickFormatter }}
+                tooltipLabelFormatter={tooltipLabelFormatter}
+              />
+            </Chart.Root>
+          </Card.Content>
+        </Card>
+
+
+        {/* Simple Line Chart (no zoom, but synced with date range) */}
+        <Card>
+          <Card.Header>
+            <div className="flex items-center gap-1.5">
+              <IconTimeline className="size-5 text-indigo-500" />
+              Simple Line <span className="font-normal text-text-dimmed">(synced, no zoom)</span>
+            </div>
+          </Card.Header>
+          <Card.Content>
+            <Chart.Root
+              config={lineChartConfig}
+              data={filteredLineData}
+              dataKey="day"
+              state={chartState === "loaded" ? undefined : chartState}
+              showLegend
+            >
+              <Chart.Line
+                lineType="step"
+                xAxisProps={{ tickFormatter: xAxisTickFormatter }}
+                tooltipLabelFormatter={tooltipLabelFormatter}
+              />
+            </Chart.Root>
+          </Card.Content>
+        </Card>
+
+        {/* Line Chart with Zoom */}
+        <Card>
+          <Card.Header>
+            <div className="flex items-center gap-1.5">
+              <IconTimeline className="size-5 text-green-500" />
+              Line with Zoom
+            </div>
+          </Card.Header>
+          <Card.Content>
+            <Chart.Root
+              config={lineChartConfig}
+              data={filteredLineData}
+              dataKey="day"
+              enableZoom
+              onZoomChange={handleZoomChange}
+              state={chartState === "loaded" ? undefined : chartState}
+              showLegend
+            >
+              <Chart.Line
+                lineType="natural"
+                xAxisProps={{ tickFormatter: xAxisTickFormatter }}
+                tooltipLabelFormatter={tooltipLabelFormatter}
+              />
+            </Chart.Root>
+          </Card.Content>
+        </Card>
+
+        {/* Stacked Area Chart (synced with date range) */}
+        <Card>
+          <Card.Header>
+            <div className="flex items-center gap-1.5">
+              <IconTimeline className="size-5 text-purple-500" />
+              Stacked Area <span className="font-normal text-text-dimmed">(synced)</span>
+            </div>
+          </Card.Header>
+          <Card.Content>
+            <Chart.Root
+              config={lineChartConfig}
+              data={filteredLineData}
+              dataKey="day"
+              state={chartState === "loaded" ? undefined : chartState}
+              showLegend
+            >
+              <Chart.Line
+                stacked
+                lineType="monotone"
+                xAxisProps={{ tickFormatter: xAxisTickFormatter }}
+                tooltipLabelFormatter={tooltipLabelFormatter}
+              />
+            </Chart.Root>
+          </Card.Content>
+        </Card>
+
+        {/* Big Number */}
+        <Card>
+          <Card.Header>
+            Big Number
+            <Card.Accessory>
+              <Button variant="secondary/small">Example button</Button>
+            </Card.Accessory>
+          </Card.Header>
+          <Card.Content>
+            <BigNumberCard
+              rows={[{ amount: 101 }]}
+              columns={[{ name: "amount", type: "Float64" }]}
+              config={{ column: "amount", aggregation: "sum", abbreviate: true }}
+            />
+          </Card.Content>
+        </Card>
+      </div>
+    </div>
+  );
+}
+
+export default function Story() {
+  return (
+    <DateRangeProvider
+      defaultStartDate={API_DATA.defaultDateRange.startDate}
+      defaultEndDate={API_DATA.defaultDateRange.endDate}
+    >
+      <ChartsDashboard />
+    </DateRangeProvider>
+  );
+}
+
+// Mock chart data
+
+const API_DATA = {
+  defaultDateRange: {
+    startDate: new Date(2023, 10, 1), // November 1, 2023
+    endDate: new Date(2023, 10, 30), // November 30, 2023
+  },
+  lineChartData: [
+    { day: "2023-11-01", "success-rate": 96.8, "failure-rate": 3.2 },
+    { day: "2023-11-02", "success-rate": 95.3, "failure-rate": 4.7 },
+    { day: "2023-11-03", "success-rate": 97.1, "failure-rate": 2.9 },
+    { day: "2023-11-04", "success-rate": 94.5, "failure-rate": 5.5 },
+    { day: "2023-11-05", "success-rate": 98.6, "failure-rate": 1.4 },
+    { day: "2023-11-06", "success-rate": 97.8, "failure-rate": 2.2 },
+    { day: "2023-11-07", "success-rate": 93.9, "failure-rate": 6.1 },
+    { day: "2023-11-08", "success-rate": 95.7, "failure-rate": 4.3 },
+    { day: "2023-11-09", "success-rate": 98.2, "failure-rate": 1.8 },
+    { day: "2023-11-10", "success-rate": 96.5, "failure-rate": 3.5 },
+    { day: "2023-11-11", "success-rate": 94.8, "failure-rate": 5.2 },
+    { day: "2023-11-12", "success-rate": 99.1, "failure-rate": 0.9 },
+    { day: "2023-11-13", "success-rate": 97.3, "failure-rate": 2.7 },
+    { day: "2023-11-14", "success-rate": 95.9, "failure-rate": 4.1 },
+    { day: "2023-11-15", "success-rate": 98.4, "failure-rate": 1.6 },
+    { day: "2023-11-16", "success-rate": 96.2, "failure-rate": 3.8 },
+    { day: "2023-11-17", "success-rate": 94.3, "failure-rate": 5.7 },
+    { day: "2023-11-18", "success-rate": 97.5, "failure-rate": 2.5 },
+    { day: "2023-11-19", "success-rate": 95.6, "failure-rate": 4.4 },
+    { day: "2023-11-20", "success-rate": 98.9, "failure-rate": 1.1 },
+    { day: "2023-11-21", "success-rate": 96.7, "failure-rate": 3.3 },
+    { day: "2023-11-22", "success-rate": 95.1, "failure-rate": 4.9 },
+    { day: "2023-11-23", "success-rate": 97.9, "failure-rate": 2.1 },
+    { day: "2023-11-24", "success-rate": 94.7, "failure-rate": 5.3 },
+    { day: "2023-11-25", "success-rate": 98.3, "failure-rate": 1.7 },
+    { day: "2023-11-26", "success-rate": 96.4, "failure-rate": 3.6 },
+    { day: "2023-11-27", "success-rate": 94.9, "failure-rate": 5.1 },
+    { day: "2023-11-28", "success-rate": 97.7, "failure-rate": 2.3 },
+    { day: "2023-11-29", "success-rate": 95.4, "failure-rate": 4.6 },
+    { day: "2023-11-30", "success-rate": 98.8, "failure-rate": 1.2 },
+  ],
+  barChartData: [
+    { day: "2023-11-01", completed: 3245, "in-progress": 4321, canceled: 657, failed: 2987 },
+    { day: "2023-11-02", completed: 4567, "in-progress": 3789, canceled: 879, failed: 3456 },
+    { day: "2023-11-03", completed: 5432, "in-progress": 4567, canceled: 1234, failed: 2345 },
+    { day: "2023-11-04", completed: 0, "in-progress": 5678, canceled: 0, failed: 3678 },
+    { day: "2023-11-05", completed: 6789, "in-progress": 3456, canceled: 2345, failed: 4321 },
+    { day: "2023-11-06", completed: 3456, "in-progress": 6543, canceled: 1567, failed: 2987 },
+    { day: "2023-11-07", completed: 6543, "in-progress": 3456, canceled: 2345, failed: 3456 },
+    { day: "2023-11-08", completed: 0, "in-progress": 7654, canceled: 0, failed: 4567 },
+    { day: "2023-11-09", completed: 8765, "in-progress": 3245, canceled: 3456, failed: 2109 },
+    { day: "2023-11-10", completed: 5432, "in-progress": 6543, canceled: 2109, failed: 3456 },
+    { day: "2023-11-11", completed: 3245, "in-progress": 5432, canceled: 1234, failed: 3987 },
+    { day: "2023-11-12", completed: 0, "in-progress": 6543, canceled: 0, failed: 3456 },
+    { day: "2023-11-13", completed: 7654, "in-progress": 3456, canceled: 2345, failed: 2987 },
+    { day: "2023-11-14", completed: 5432, "in-progress": 5432, canceled: 3456, failed: 3421 },
+    { day: "2023-11-15", completed: 6543, "in-progress": 4321, canceled: 2109, failed: 2345 },
+    { day: "2023-11-16", completed: 0, "in-progress": 7654, canceled: 0, failed: 4567 },
+    { day: "2023-11-17", completed: 8765, "in-progress": 3456, canceled: 3421, failed: 2987 },
+    { day: "2023-11-18", completed: 5432, "in-progress": 5432, canceled: 2345, failed: 3456 },
+    { day: "2023-11-19", completed: 4321, "in-progress": 6543, canceled: 1567, failed: 2987 },
+    { day: "2023-11-20", completed: 0, "in-progress": 7654, canceled: 0, failed: 3678 },
+    { day: "2023-11-21", completed: 4532, "in-progress": 3456, canceled: 1200, failed: 2876 },
+    { day: "2023-11-22", completed: 6789, "in-progress": 4567, canceled: 2345, failed: 3456 },
+    { day: "2023-11-23", completed: 5432, "in-progress": 6543, canceled: 0, failed: 2109 },
+    { day: "2023-11-24", completed: 6543, "in-progress": 0, canceled: 2345, failed: 0 },
+    { day: "2023-11-25", completed: 5432, "in-progress": 0, canceled: 0, failed: 2345 },
+    { day: "2023-11-26", completed: 6543, "in-progress": 6543, canceled: 0, failed: 0 },
+    { day: "2023-11-27", completed: 8765, "in-progress": 3456, canceled: 0, failed: 5678 },
+    { day: "2023-11-28", completed: 5432, "in-progress": 5678, canceled: 4567, failed: 2345 },
+    { day: "2023-11-29", completed: 0, "in-progress": 4567, canceled: 2345, failed: 3456 },
+    { day: "2023-11-30", completed: 7654, "in-progress": 3456, canceled: 5678, failed: 2345 },
+  ],
+  barChartBigDatasetData: [
+    {
+      day: "2023-11-01",
+      "sync-data": 6543,
+      "process-image": 3245,
+      "upload-file": 8765,
+      "extract-metadata": 4321,
+      "compress-video": 5432,
+      "schedule-backup": 0,
+      "convert-audio": 6543,
+      "analyze-document": 3245,
+    },
+    {
+      day: "2023-11-02",
+      "sync-data": 5432,
+      "process-image": 0,
+      "upload-file": 6789,
+      "extract-metadata": 5678,
+      "compress-video": 3456,
+      "schedule-backup": 7654,
+      "convert-audio": 4567,
+      "analyze-document": 2345,
+    },
+    {
+      day: "2023-11-03",
+      "sync-data": 7654,
+      "process-image": 5432,
+      "upload-file": 0,
+      "extract-metadata": 6543,
+      "compress-video": 4321,
+      "schedule-backup": 3456,
+      "convert-audio": 5678,
+      "analyze-document": 6543,
+    },
+    {
+      day: "2023-11-04",
+      "sync-data": 3456,
+      "process-image": 6543,
+      "upload-file": 7654,
+      "extract-metadata": 0,
+      "compress-video": 6789,
+      "schedule-backup": 5432,
+      "convert-audio": 3456,
+      "analyze-document": 4567,
+    },
+    {
+      day: "2023-11-05",
+      "sync-data": 0,
+      "process-image": 8765,
+      "upload-file": 4567,
+      "extract-metadata": 7654,
+      "compress-video": 5432,
+      "schedule-backup": 6543,
+      "convert-audio": 0,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-06",
+      "sync-data": 6789,
+      "process-image": 4321,
+      "upload-file": 5432,
+      "extract-metadata": 6543,
+      "compress-video": 0,
+      "schedule-backup": 8765,
+      "convert-audio": 5432,
+      "analyze-document": 3456,
+    },
+    {
+      day: "2023-11-07",
+      "sync-data": 7654,
+      "process-image": 0,
+      "upload-file": 6789,
+      "extract-metadata": 5432,
+      "compress-video": 7654,
+      "schedule-backup": 4321,
+      "convert-audio": 6543,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-08",
+      "sync-data": 5678,
+      "process-image": 6543,
+      "upload-file": 0,
+      "extract-metadata": 8765,
+      "compress-video": 5432,
+      "schedule-backup": 6543,
+      "convert-audio": 4321,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-09",
+      "sync-data": 0,
+      "process-image": 7654,
+      "upload-file": 5432,
+      "extract-metadata": 6543,
+      "compress-video": 8765,
+      "schedule-backup": 0,
+      "convert-audio": 7654,
+      "analyze-document": 5432,
+    },
+    {
+      day: "2023-11-10",
+      "sync-data": 8765,
+      "process-image": 5432,
+      "upload-file": 7654,
+      "extract-metadata": 0,
+      "compress-video": 6543,
+      "schedule-backup": 7654,
+      "convert-audio": 5432,
+      "analyze-document": 6543,
+    },
+    {
+      day: "2023-11-11",
+      "sync-data": 6543,
+      "process-image": 0,
+      "upload-file": 8765,
+      "extract-metadata": 5432,
+      "compress-video": 7654,
+      "schedule-backup": 5432,
+      "convert-audio": 0,
+      "analyze-document": 8765,
+    },
+    {
+      day: "2023-11-12",
+      "sync-data": 5432,
+      "process-image": 7654,
+      "upload-file": 0,
+      "extract-metadata": 6543,
+      "compress-video": 5432,
+      "schedule-backup": 7654,
+      "convert-audio": 6543,
+      "analyze-document": 5432,
+    },
+    {
+      day: "2023-11-13",
+      "sync-data": 0,
+      "process-image": 6543,
+      "upload-file": 7654,
+      "extract-metadata": 5432,
+      "compress-video": 0,
+      "schedule-backup": 8765,
+      "convert-audio": 5432,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-14",
+      "sync-data": 7654,
+      "process-image": 5432,
+      "upload-file": 6543,
+      "extract-metadata": 0,
+      "compress-video": 7654,
+      "schedule-backup": 5432,
+      "convert-audio": 8765,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-15",
+      "sync-data": 6543,
+      "process-image": 0,
+      "upload-file": 8765,
+      "extract-metadata": 7654,
+      "compress-video": 5432,
+      "schedule-backup": 6543,
+      "convert-audio": 5432,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-16",
+      "sync-data": 5432,
+      "process-image": 7654,
+      "upload-file": 0,
+      "extract-metadata": 6543,
+      "compress-video": 8765,
+      "schedule-backup": 0,
+      "convert-audio": 7654,
+      "analyze-document": 5432,
+    },
+    {
+      day: "2023-11-17",
+      "sync-data": 0,
+      "process-image": 6543,
+      "upload-file": 7654,
+      "extract-metadata": 5432,
+      "compress-video": 6543,
+      "schedule-backup": 7654,
+      "convert-audio": 5432,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-18",
+      "sync-data": 8765,
+      "process-image": 0,
+      "upload-file": 6543,
+      "extract-metadata": 0,
+      "compress-video": 7654,
+      "schedule-backup": 5432,
+      "convert-audio": 6543,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-19",
+      "sync-data": 5432,
+      "process-image": 7654,
+      "upload-file": 0,
+      "extract-metadata": 6543,
+      "compress-video": 5432,
+      "schedule-backup": 0,
+      "convert-audio": 7654,
+      "analyze-document": 5432,
+    },
+    {
+      day: "2023-11-20",
+      "sync-data": 6543,
+      "process-image": 5432,
+      "upload-file": 7654,
+      "extract-metadata": 0,
+      "compress-video": 6543,
+      "schedule-backup": 7654,
+      "convert-audio": 5432,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-21",
+      "sync-data": 8765,
+      "process-image": 4532,
+      "upload-file": 0,
+      "extract-metadata": 6789,
+      "compress-video": 3456,
+      "schedule-backup": 0,
+      "convert-audio": 5432,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-22",
+      "sync-data": 5432,
+      "process-image": 0,
+      "upload-file": 6789,
+      "extract-metadata": 4567,
+      "compress-video": 0,
+      "schedule-backup": 8765,
+      "convert-audio": 3456,
+      "analyze-document": 5678,
+    },
+    {
+      day: "2023-11-23",
+      "sync-data": 0,
+      "process-image": 6789,
+      "upload-file": 4567,
+      "extract-metadata": 0,
+      "compress-video": 7654,
+      "schedule-backup": 3456,
+      "convert-audio": 0,
+      "analyze-document": 5432,
+    },
+    {
+      day: "2023-11-24",
+      "sync-data": 9876,
+      "process-image": 3456,
+      "upload-file": 5678,
+      "extract-metadata": 0,
+      "compress-video": 4567,
+      "schedule-backup": 2345,
+      "convert-audio": 6789,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-25",
+      "sync-data": 5432,
+      "process-image": 0,
+      "upload-file": 8765,
+      "extract-metadata": 3456,
+      "compress-video": 5678,
+      "schedule-backup": 0,
+      "convert-audio": 4567,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-26",
+      "sync-data": 0,
+      "process-image": 7654,
+      "upload-file": 3456,
+      "extract-metadata": 5678,
+      "compress-video": 0,
+      "schedule-backup": 6789,
+      "convert-audio": 3456,
+      "analyze-document": 5678,
+    },
+    {
+      day: "2023-11-27",
+      "sync-data": 8765,
+      "process-image": 3456,
+      "upload-file": 0,
+      "extract-metadata": 5678,
+      "compress-video": 3456,
+      "schedule-backup": 5678,
+      "convert-audio": 0,
+      "analyze-document": 6789,
+    },
+    {
+      day: "2023-11-28",
+      "sync-data": 5678,
+      "process-image": 0,
+      "upload-file": 7654,
+      "extract-metadata": 3456,
+      "compress-video": 5678,
+      "schedule-backup": 3456,
+      "convert-audio": 7654,
+      "analyze-document": 0,
+    },
+    {
+      day: "2023-11-29",
+      "sync-data": 0,
+      "process-image": 8765,
+      "upload-file": 3456,
+      "extract-metadata": 0,
+      "compress-video": 6789,
+      "schedule-backup": 3456,
+      "convert-audio": 5678,
+      "analyze-document": 7654,
+    },
+    {
+      day: "2023-11-30",
+      "sync-data": 7654,
+      "process-image": 3456,
+      "upload-file": 5678,
+      "extract-metadata": 7654,
+      "compress-video": 5432,
+      "schedule-backup": 6789,
+      "convert-audio": 3456,
+      "analyze-document": 5678,
+    },
+  ],
+};
+
+const lineChartConfig = {
+  "success-rate": {
+    label: "Success Rate",
+    color: "#22C55E",
+  },
+  "failure-rate": {
+    label: "Failure Rate",
+    color: "#F43F5E",
+  },
+} satisfies ChartConfig;
+
+const barChartBigDatasetConfig = {
+  "sync-data": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>sync-data</span>
+        <span className="text-text-dimmed/50">7fj29d0ksl38ac5q</span>
+      </div>
+    ),
+    color: "#3B82F6",
+  },
+  "process-image": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>process-image</span>
+        <span className="text-text-dimmed/50">3lk49c7fm2d8r6p0</span>
+      </div>
+    ),
+    color: "#22C55E",
+  },
+  "upload-file": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>upload-file</span>
+        <span className="text-text-dimmed/50">j8k2p3d9f7a6s5l0</span>
+      </div>
+    ),
+    color: "#F59E0B",
+  },
+  "extract-metadata": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>extract-metadata</span>
+        <span className="text-text-dimmed/50">q7w6e5r4t3y2u1i0</span>
+      </div>
+    ),
+    color: "#F43F5E",
+  },
+  "compress-video": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>compress-video</span>
+        <span className="text-text-dimmed/50">a2s3d4f5g6h7j8k9</span>
+      </div>
+    ),
+    color: "#8B5CF6",
+  },
+  "schedule-backup": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>schedule-backup</span>
+        <span className="text-text-dimmed/50">z1x2c3v4b5n6m7l8</span>
+      </div>
+    ),
+    color: "#06B6D4",
+  },
+  "convert-audio": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>convert-audio</span>
+        <span className="text-text-dimmed/50">p0o9i8u7y6t5r4e3</span>
+      </div>
+    ),
+    color: "#EC4899",
+  },
+  "analyze-document": {
+    label: (
+      <div className="flex items-center gap-2">
+        <span>analyze-document</span>
+        <span className="text-text-dimmed/50">m2n3b4v5c6x7z8l9</span>
+      </div>
+    ),
+    color: "#F97316",
+  },
+} satisfies ChartConfig;
diff --git a/apps/webapp/app/routes/storybook.segmented-control/route.tsx b/apps/webapp/app/routes/storybook.segmented-control/route.tsx
index f97d3940399..e3a16590fa2 100644
--- a/apps/webapp/app/routes/storybook.segmented-control/route.tsx
+++ b/apps/webapp/app/routes/storybook.segmented-control/route.tsx
@@ -3,20 +3,48 @@ import { Paragraph } from "~/components/primitives/Paragraph";
 import SegmentedControl from "~/components/primitives/SegmentedControl";
 
 const options = [
-  { label: "Label 1", value: "developer" },
-  { label: "Label 2", value: "Users" },
+  { label: "Label 1", value: "label1" },
+  { label: "Label 2", value: "label2" },
 ];
 
 export default function Story() {
   return (
     <MainCenteredContainer className="flex flex-col gap-8">
       <div className="flex flex-col gap-2">
-        <Paragraph>Primary</Paragraph>
-        <SegmentedControl name="name" options={options} variant="primary" />
+        <Paragraph>primary/small</Paragraph>
+        <SegmentedControl
+          name="name1"
+          defaultValue={options[0].value}
+          options={options}
+          variant="primary/small"
+        />
       </div>
       <div className="flex flex-col gap-2">
-        <Paragraph>Secondary</Paragraph>
-        <SegmentedControl name="name" options={options} variant="secondary" />
+        <Paragraph>primary/medium</Paragraph>
+        <SegmentedControl
+          name="name2"
+          defaultValue={options[0].value}
+          options={options}
+          variant="primary/medium"
+        />
+      </div>
+      <div className="flex flex-col gap-2">
+        <Paragraph>secondary/small</Paragraph>
+        <SegmentedControl
+          name="name3"
+          defaultValue={options[0].value}
+          options={options}
+          variant="secondary/small"
+        />
+      </div>
+      <div className="flex flex-col gap-2">
+        <Paragraph>secondary/medium</Paragraph>
+        <SegmentedControl
+          name="name4"
+          defaultValue={options[0].value}
+          options={options}
+          variant="secondary/medium"
+        />
       </div>
     </MainCenteredContainer>
   );
diff --git a/apps/webapp/app/routes/storybook.table/route.tsx b/apps/webapp/app/routes/storybook.table/route.tsx
index 2a509e55510..afe48a2a71e 100644
--- a/apps/webapp/app/routes/storybook.table/route.tsx
+++ b/apps/webapp/app/routes/storybook.table/route.tsx
@@ -2,6 +2,7 @@ import React from "react";
 import { Header1, Header2 } from "~/components/primitives/Headers";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import {
+  CopyableTableCell,
   Table,
   TableBody,
   TableCell,
@@ -60,6 +61,33 @@ export default function Story() {
           </TableBody>
         </Table>
       </div>
+      <div className="flex flex-col gap-2">
+        <Header1>Copyable cells</Header1>
+        <Paragraph>
+          Hover over the first column to see the copy button. Click to copy the cell value.
+        </Paragraph>
+        <Table>
+          <TableHeader className="bg-background-bright">
+            <TableRow>
+              <TableHeaderCell>ID (copyable)</TableHeaderCell>
+              <TableHeaderCell>Name</TableHeaderCell>
+              <TableHeaderCell>Status</TableHeaderCell>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {Array.from({ length: 5 }, (_, index) => {
+              const id = `run_${crypto.randomUUID().slice(0, 8)}`;
+              return (
+                <TableRow key={index}>
+                  <CopyableTableCell value={id}>{id}</CopyableTableCell>
+                  <TableCell>Task {index + 1}</TableCell>
+                  <TableCell>Completed</TableCell>
+                </TableRow>
+              );
+            })}
+          </TableBody>
+        </Table>
+      </div>
     </div>
   );
 }
diff --git a/apps/webapp/app/routes/storybook.tsql-editor/route.tsx b/apps/webapp/app/routes/storybook.tsql-editor/route.tsx
new file mode 100644
index 00000000000..a461478b65d
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.tsql-editor/route.tsx
@@ -0,0 +1,331 @@
+import { useState } from "react";
+import { TSQLEditor } from "~/components/code/TSQLEditor";
+import { column, type TableSchema } from "@internal/tsql";
+
+const RUN_STATUSES = ["PENDING", "QUEUED", "EXECUTING", "COMPLETED", "FAILED", "CANCELED"] as const;
+const LOG_LEVELS = ["DEBUG", "INFO", "WARN", "ERROR"] as const;
+
+const runsSchema: TableSchema = {
+  name: "runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  description: "Task runs table - stores all task execution records",
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  columns: {
+    id: { name: "id", ...column("String", { description: "Unique run identifier" }) },
+    task_id: { name: "task_id", ...column("String", { description: "Task identifier" }) },
+    status: {
+      name: "status",
+      ...column("String", {
+        description: "Run status",
+        allowedValues: [...RUN_STATUSES],
+      }),
+    },
+    created_at: {
+      name: "created_at",
+      ...column("DateTime64", { description: "When the run was created" }),
+    },
+    started_at: {
+      name: "started_at",
+      ...column("Nullable(DateTime64)", { description: "When the run started executing" }),
+    },
+    completed_at: {
+      name: "completed_at",
+      ...column("Nullable(DateTime64)", { description: "When the run completed" }),
+    },
+    duration_ms: {
+      name: "duration_ms",
+      ...column("Nullable(UInt64)", { description: "Run duration in milliseconds" }),
+    },
+    // Virtual column: computed from started_at and completed_at
+    execution_duration: {
+      name: "execution_duration",
+      ...column("Nullable(Int64)", {
+        description: "Computed execution time in milliseconds (virtual column)",
+      }),
+      expression: "dateDiff('millisecond', started_at, completed_at)",
+    },
+    // Virtual column: duration in seconds for convenience
+    duration_seconds: {
+      name: "duration_seconds",
+      ...column("Float64", {
+        description: "Duration in seconds (virtual column)",
+      }),
+      expression: "duration_ms / 1000.0",
+    },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+};
+
+const logsSchema: TableSchema = {
+  name: "logs",
+  clickhouseName: "trigger_dev.task_events_v2",
+  description: "Task logs and events",
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  columns: {
+    id: { name: "id", ...column("String", { description: "Event identifier" }) },
+    run_id: { name: "run_id", ...column("String", { description: "Associated run ID" }) },
+    level: {
+      name: "level",
+      ...column("String", {
+        description: "Log level",
+        allowedValues: [...LOG_LEVELS],
+      }),
+    },
+    message: { name: "message", ...column("String", { description: "Log message content" }) },
+    timestamp: { name: "timestamp", ...column("DateTime64", { description: "Event timestamp" }) },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+};
+
+const exampleSchema = [runsSchema, logsSchema];
+
+const exampleQueries = [
+  {
+    name: "Simple SELECT",
+    query: "SELECT * FROM runs LIMIT 10",
+  },
+  {
+    name: "With WHERE clause",
+    query: "SELECT id, task_id, status, created_at FROM runs WHERE status = 'COMPLETED' LIMIT 100",
+  },
+  {
+    name: "Enum IN clause",
+    query: "SELECT * FROM runs WHERE status IN ('PENDING', 'QUEUED', 'EXECUTING') LIMIT 50",
+  },
+  {
+    name: "Virtual columns",
+    query: `SELECT 
+  id,
+  status,
+  execution_duration,
+  duration_seconds
+FROM runs
+WHERE execution_duration > 5000
+ORDER BY execution_duration DESC
+LIMIT 20`,
+  },
+  {
+    name: "Aggregation",
+    query: "SELECT status, count(*) as count FROM runs GROUP BY status ORDER BY count DESC",
+  },
+  {
+    name: "Join query",
+    query: `SELECT 
+  runs.id,
+  runs.status,
+  logs.message,
+  logs.level
+FROM runs
+JOIN logs ON runs.id = logs.run_id
+WHERE logs.level = 'ERROR'
+LIMIT 50`,
+  },
+  {
+    name: "Date filtering",
+    query: `SELECT 
+  toStartOfDay(created_at) as day,
+  count(*) as runs_count,
+  avg(duration_ms) as avg_duration
+FROM runs
+WHERE created_at > now() - INTERVAL 7 DAY
+GROUP BY day
+ORDER BY day DESC`,
+  },
+];
+
+export default function Story() {
+  const [query, setQuery] = useState(exampleQueries[0].query);
+
+  return (
+    <div className="flex flex-col gap-y-8 p-8">
+      <div>
+        <h1 className="mb-2 text-2xl font-bold text-text-bright">TSQL Editor</h1>
+        <p className="text-text-dimmed">
+          A CodeMirror-based SQL editor with syntax highlighting, schema-aware autocomplete, and
+          real-time error detection.
+        </p>
+      </div>
+
+      {/* Example queries */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">Example Queries</h2>
+        <div className="flex flex-wrap gap-2">
+          {exampleQueries.map((example) => (
+            <button
+              key={example.name}
+              onClick={() => setQuery(example.query)}
+              className="rounded bg-charcoal-700 px-3 py-1.5 text-sm text-text-dimmed transition hover:bg-charcoal-600 hover:text-text-bright"
+            >
+              {example.name}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* Main editor */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">Editor with Schema</h2>
+        <p className="text-sm text-text-dimmed">
+          Try typing to see autocomplete suggestions. Type <code>status = </code> to see enum value
+          suggestions. Available tables: <code>runs</code>, <code>logs</code>
+        </p>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue={query}
+            onChange={setQuery}
+            schema={exampleSchema}
+            linterEnabled={true}
+            showCopyButton={true}
+            showClearButton={true}
+            minHeight="200px"
+            className="min-h-[200px]"
+          />
+        </div>
+      </div>
+
+      {/* Read-only example */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">Read-only Mode</h2>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue="SELECT id, status, created_at FROM runs WHERE status = 'FAILED' ORDER BY created_at DESC LIMIT 10"
+            readOnly={true}
+            schema={exampleSchema}
+            linterEnabled={false}
+            showCopyButton={true}
+            showClearButton={false}
+            className="min-h-[100px]"
+          />
+        </div>
+      </div>
+
+      {/* Editor without schema (no autocomplete) */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">Without Schema (Basic Mode)</h2>
+        <p className="text-sm text-text-dimmed">
+          Editor without schema - still has SQL syntax highlighting and keyword completion.
+        </p>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue="SELECT * FROM my_table WHERE id = 1"
+            linterEnabled={true}
+            showCopyButton={true}
+            className="min-h-[100px]"
+          />
+        </div>
+      </div>
+
+      {/* Error example */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">With Syntax Error</h2>
+        <p className="text-sm text-text-dimmed">
+          The linter detects syntax errors and underlines them in red.
+        </p>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue="SELEC * FORM runs"
+            linterEnabled={true}
+            showCopyButton={true}
+            className="min-h-[100px]"
+          />
+        </div>
+      </div>
+
+      {/* Invalid enum value example */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">With Invalid Enum Value</h2>
+        <p className="text-sm text-text-dimmed">
+          The linter validates enum values against the schema. Try changing{" "}
+          <code>'INVALID_STATUS'</code> to a valid status like <code>'COMPLETED'</code>.
+        </p>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue="SELECT * FROM runs WHERE status = 'INVALID_STATUS' LIMIT 10"
+            schema={exampleSchema}
+            linterEnabled={true}
+            showCopyButton={true}
+            className="min-h-[100px]"
+          />
+        </div>
+      </div>
+
+      {/* Unknown column example */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">With Unknown Column</h2>
+        <p className="text-sm text-text-dimmed">
+          The linter warns about unknown column names. Try changing <code>unknown_col</code> to a
+          valid column like <code>status</code>.
+        </p>
+        <div className="overflow-hidden rounded-lg border border-grid-dimmed">
+          <TSQLEditor
+            defaultValue="SELECT id, unknown_col FROM runs LIMIT 10"
+            schema={exampleSchema}
+            linterEnabled={true}
+            showCopyButton={true}
+            className="min-h-[100px]"
+          />
+        </div>
+      </div>
+
+      {/* Available tables reference */}
+      <div className="flex flex-col gap-2">
+        <h2 className="text-lg font-semibold text-text-bright">Available Schema</h2>
+        <div className="grid gap-4 md:grid-cols-2">
+          {exampleSchema.map((table) => (
+            <div
+              key={table.name}
+              className="rounded-lg border border-grid-dimmed bg-charcoal-800 p-4"
+            >
+              <h3 className="mb-1 font-mono text-sm font-semibold text-text-bright">
+                {table.name}
+              </h3>
+              <p className="mb-3 text-xs text-text-dimmed">{table.description}</p>
+              <div className="space-y-1">
+                {Object.entries(table.columns).map(([name, col]) => (
+                  <div key={name} className="flex flex-col gap-0.5 text-xs">
+                    <div className="flex items-baseline gap-2">
+                      <code className={col.expression ? "text-purple-400" : "text-blue-400"}>
+                        {name}
+                      </code>
+                      <span className="text-charcoal-400">{col.type}</span>
+                      {col.expression && (
+                        <span className="rounded bg-purple-500/20 px-1 text-[10px] text-purple-300">
+                          virtual
+                        </span>
+                      )}
+                      {col.description && (
+                        <span className="text-text-dimmed">- {col.description}</span>
+                      )}
+                    </div>
+                    {col.allowedValues && col.allowedValues.length > 0 && (
+                      <div className="ml-4 text-green-400/70">
+                        Allowed: {col.allowedValues.join(", ")}
+                      </div>
+                    )}
+                    {col.expression && (
+                      <div className="ml-4 font-mono text-purple-400/70">
+                        Expression: {col.expression}
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/storybook.unordered-list/route.tsx b/apps/webapp/app/routes/storybook.unordered-list/route.tsx
new file mode 100644
index 00000000000..b17bb2dda11
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.unordered-list/route.tsx
@@ -0,0 +1,67 @@
+import { Header2 } from "~/components/primitives/Headers";
+import { Paragraph, type ParagraphVariant } from "~/components/primitives/Paragraph";
+import { UnorderedList } from "~/components/primitives/UnorderedList";
+
+const sampleItems = [
+  "A new issue is seen for the first time",
+  "A resolved issue re-occurs",
+  "An ignored issue re-occurs depending on the settings you configured",
+];
+
+const variantGroups: { label: string; variants: ParagraphVariant[] }[] = [
+  {
+    label: "Base",
+    variants: ["base", "base/bright"],
+  },
+  {
+    label: "Small",
+    variants: ["small", "small/bright", "small/dimmed"],
+  },
+  {
+    label: "Extra small",
+    variants: [
+      "extra-small",
+      "extra-small/bright",
+      "extra-small/dimmed",
+      "extra-small/mono",
+      "extra-small/bright/mono",
+      "extra-small/dimmed/mono",
+      "extra-small/caps",
+      "extra-small/bright/caps",
+    ],
+  },
+  {
+    label: "Extra extra small",
+    variants: [
+      "extra-extra-small",
+      "extra-extra-small/bright",
+      "extra-extra-small/caps",
+      "extra-extra-small/bright/caps",
+      "extra-extra-small/dimmed/caps",
+    ],
+  },
+];
+
+export default function Story() {
+  return (
+    <div className="flex flex-col gap-12 p-8">
+      {variantGroups.map((group) => (
+        <div key={group.label} className="flex flex-col gap-6">
+          <Header2>{group.label}</Header2>
+          {group.variants.map((variant) => (
+            <div key={variant} className="flex flex-col">
+              <code className="mb-2 font-mono text-xs text-charcoal-400">{variant}</code>
+              <Paragraph variant={variant}>This is a paragraph before the list.</Paragraph>
+              <UnorderedList variant={variant}>
+                {sampleItems.map((item) => (
+                  <li key={item}>{item}</li>
+                ))}
+              </UnorderedList>
+              <Paragraph variant={variant}>This is a paragraph after the list.</Paragraph>
+            </div>
+          ))}
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/apps/webapp/app/routes/storybook/route.tsx b/apps/webapp/app/routes/storybook/route.tsx
index d1898662181..3efa990548c 100644
--- a/apps/webapp/app/routes/storybook/route.tsx
+++ b/apps/webapp/app/routes/storybook/route.tsx
@@ -4,10 +4,14 @@ import { Fragment } from "react";
 import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
 import { AppContainer } from "~/components/layout/AppLayout";
 import { env } from "~/env.server";
-import { requireUserId } from "~/services/session.server";
+import { requireUser } from "~/services/session.server";
 import { cn } from "~/utils/cn";
 
 const stories: Story[] = [
+  {
+    name: "Animated panel",
+    slug: "animated-panel",
+  },
   {
     name: "Avatar",
     slug: "avatar",
@@ -24,6 +28,10 @@ const stories: Story[] = [
     name: "Callouts",
     slug: "callout",
   },
+  {
+    name: "Charts",
+    slug: "charts",
+  },
   {
     name: "Checkboxes",
     slug: "checkboxes",
@@ -64,10 +72,6 @@ const stories: Story[] = [
     name: "Loading bar divider",
     slug: "loading-bar-divider",
   },
-  {
-    name: "NamedIcon",
-    slug: "named-icon",
-  },
   {
     name: "Page header",
     slug: "page-header",
@@ -84,6 +88,10 @@ const stories: Story[] = [
     name: "Resizable",
     slug: "resizable",
   },
+  {
+    name: "Run & Span timeline",
+    slug: "run-and-span-timeline",
+  },
   {
     name: "Segemented control",
     slug: "segmented-control",
@@ -108,6 +116,10 @@ const stories: Story[] = [
     name: "Tabs",
     slug: "tabs",
   },
+  {
+    name: "Timeline",
+    slug: "timeline",
+  },
   {
     name: "Toast",
     slug: "toast",
@@ -121,21 +133,22 @@ const stories: Story[] = [
     slug: "tree-view",
   },
   {
-    name: "Timeline",
-    slug: "timeline",
-  },
-  {
-    name: "Run & Span timeline",
-    slug: "run-and-span-timeline",
+    name: "TSQL Editor",
+    slug: "tsql-editor",
   },
   {
     name: "Typography",
     slug: "typography",
   },
+  {
+    name: "Unordered list",
+    slug: "unordered-list",
+  },
   {
     name: "Usage",
     slug: "usage",
   },
+  // Forms section
   {
     sectionTitle: "Forms",
     name: "Date fields",
@@ -161,12 +174,9 @@ const stories: Story[] = [
     name: "Textarea",
     slug: "textarea",
   },
+  // Menus section
   {
     sectionTitle: "Menus",
-    name: "Select",
-    slug: "select",
-  },
-  {
     name: "Filter",
     slug: "filter",
   },
@@ -174,14 +184,16 @@ const stories: Story[] = [
     name: "Popover",
     slug: "popover",
   },
+  {
+    name: "Select",
+    slug: "select",
+  },
 ];
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
-  await requireUserId(request);
-
-  console.log("ENV", env.NODE_ENV);
+  const user = await requireUser(request);
 
-  if (env.NODE_ENV !== "development") {
+  if (!user.admin) {
     throw redirect("/");
   }
 
diff --git a/apps/webapp/app/routes/vercel.callback.ts b/apps/webapp/app/routes/vercel.callback.ts
new file mode 100644
index 00000000000..6a188acfa3f
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.callback.ts
@@ -0,0 +1,78 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { logger } from "~/services/logger.server";
+import { getUserId } from "~/services/session.server";
+import { setReferralSourceCookie } from "~/services/referralSource.server";
+import { requestUrl } from "~/utils/requestUrl.server";
+import { sanitizeVercelNextUrl } from "~/v3/vercel/vercelUrls.server";
+
+const VercelCallbackSchema = z
+  .object({
+    code: z.string().optional(),
+    state: z.string().optional(),
+    error: z.string().optional(),
+    error_description: z.string().optional(),
+    configurationId: z.string().optional(),
+    next: z.string().optional()
+  })
+  .passthrough();
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  if (request.method.toUpperCase() !== "GET") {
+    throw new Response("Method Not Allowed", { status: 405 });
+  }
+
+  const userId = await getUserId(request);
+  if (!userId) {
+    const currentUrl = new URL(request.url);
+    const redirectTo = `${currentUrl.pathname}${currentUrl.search}`;
+    const referralCookie = await setReferralSourceCookie("vercel");
+
+    const headers = new Headers();
+    headers.append("Set-Cookie", referralCookie);
+
+    throw redirect(`/login?redirectTo=${encodeURIComponent(redirectTo)}`, { headers });
+  }
+
+  const url = requestUrl(request);
+  const parsed = VercelCallbackSchema.safeParse(Object.fromEntries(url.searchParams));
+
+  if (!parsed.success) {
+    logger.error("Invalid Vercel callback params", { error: parsed.error });
+    throw new Response("Invalid callback parameters", { status: 400 });
+  }
+
+  const { code, state, error, error_description, configurationId, next: rawNextUrl } = parsed.data;
+
+  // Sanitize the `next` parameter to prevent open redirects
+  const nextUrl = sanitizeVercelNextUrl(rawNextUrl);
+
+  if (error) {
+    logger.error("Vercel OAuth error", { error, error_description });
+    throw new Response("Vercel OAuth error", { status: 500 });
+  }
+
+  if (!code) {
+    logger.error("Missing authorization code from Vercel callback");
+    throw new Response("Missing authorization code", { status: 400 });
+  }
+
+  // Route with state: dashboard-invoked flow
+  if (state) {
+    const params = new URLSearchParams({ state, code, origin: "dashboard" });
+    if (configurationId) params.set("configurationId", configurationId);
+    if (nextUrl) params.set("next", nextUrl);
+    return redirect(`/vercel/connect?${params.toString()}`);
+  }
+
+  // Route without state but with configurationId: marketplace-invoked flow
+  if (configurationId) {
+    const params = new URLSearchParams({ code, configurationId, origin: "marketplace" });
+    if (nextUrl) params.set("next", nextUrl);
+    return redirect(`/vercel/onboarding?${params.toString()}`);
+  }
+
+  logger.error("Missing both state and configurationId from Vercel callback");
+  throw new Response("Missing state or configurationId parameter", { status: 400 });
+}
diff --git a/apps/webapp/app/routes/vercel.configure.tsx b/apps/webapp/app/routes/vercel.configure.tsx
new file mode 100644
index 00000000000..25b9197176c
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.configure.tsx
@@ -0,0 +1,52 @@
+import type { LoaderFunctionArgs } from "@remix-run/node";
+import { redirect } from "@remix-run/node";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { requireUserId } from "~/services/session.server";
+import { organizationVercelIntegrationPath } from "~/utils/pathBuilder";
+
+const SearchParamsSchema = z.object({
+  configurationId: z.string(),
+});
+
+/**
+ * Endpoint to handle Vercel integration configuration request coming from marketplace
+ */
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  await requireUserId(request);
+  const url = new URL(request.url);
+  const searchParams = Object.fromEntries(url.searchParams);
+  
+  const { configurationId } = SearchParamsSchema.parse(searchParams);
+
+  // Find the organization integration by configurationId (installationId in integrationData)
+  const integration = await prisma.organizationIntegration.findFirst({
+    where: {
+      service: "VERCEL",
+      deletedAt: null,
+      integrationData: {
+        path: ["installationId"],
+        equals: configurationId,
+      },
+    },
+    include: {
+      organization: {
+        select: {
+          slug: true,
+        },
+      },
+    },
+  });
+
+  if (!integration) {
+    throw new Response("Integration not found", { status: 404 });
+  }
+
+  // Redirect to the organization's Vercel integration page
+  return redirect(organizationVercelIntegrationPath(integration.organization));
+};
+
+// This route doesn't render anything, it just redirects
+export default function VercelConfigurePage() {
+  return null;
+}
\ No newline at end of file
diff --git a/apps/webapp/app/routes/vercel.connect.tsx b/apps/webapp/app/routes/vercel.connect.tsx
new file mode 100644
index 00000000000..faf43ca35e6
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.connect.tsx
@@ -0,0 +1,170 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { VercelIntegrationRepository, type TokenResponse } from "~/models/vercelIntegration.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { requestUrl } from "~/utils/requestUrl.server";
+import { v3ProjectSettingsIntegrationsPath } from "~/utils/pathBuilder";
+import { validateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+
+const VercelConnectSchema = z.object({
+  state: z.string(),
+  configurationId: z.string().optional(),
+  code: z.string(),
+  next: z.string().optional(),
+  origin: z.enum(["marketplace", "dashboard"]),
+});
+
+async function createOrFindVercelIntegration(
+  organizationId: string,
+  projectId: string,
+  tokenResponse: TokenResponse,
+  configurationId: string | undefined,
+  origin: 'marketplace' | 'dashboard'
+): Promise<void> {
+  const project = await prisma.project.findUnique({
+    where: { id: projectId },
+    include: { organization: true },
+  });
+
+  if (!project) {
+    throw new Error("Project not found");
+  }
+
+  let orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationByTeamId(
+    organizationId,
+    tokenResponse.teamId ?? null
+  );
+
+  if (orgIntegration) {
+    await VercelIntegrationRepository.updateVercelOrgIntegrationToken({
+      integrationId: orgIntegration.id,
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      teamId: tokenResponse.teamId ?? null,
+      userId: tokenResponse.userId,
+      installationId: configurationId,
+      raw: tokenResponse.raw
+    });
+  } else {
+    await VercelIntegrationRepository.createVercelOrgIntegration({
+      accessToken: tokenResponse.accessToken,
+      tokenType: tokenResponse.tokenType,
+      teamId: tokenResponse.teamId ?? null,
+      userId: tokenResponse.userId,
+      installationId: configurationId,
+      organization: project.organization,
+      raw: tokenResponse.raw,
+      origin,
+    });
+  }
+}
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const url = requestUrl(request);
+
+  const parsed = VercelConnectSchema.safeParse(Object.fromEntries(url.searchParams));
+  if (!parsed.success) {
+    logger.warn("Invalid Vercel connect params", { error: parsed.error });
+    throw new Response("Invalid parameters", { status: 400 });
+  }
+
+  const { state, configurationId, code, next, origin } = parsed.data;
+
+  const validationResult = await validateVercelOAuthState(state);
+  if (!validationResult.ok) {
+    logger.warn("Invalid Vercel OAuth state JWT", { error: validationResult.error });
+
+    if (
+      validationResult.error?.includes("expired") ||
+      validationResult.error?.includes("Token has expired")
+    ) {
+      const params = new URLSearchParams({ error: "expired" });
+      return redirect(`/vercel/onboarding?${params.toString()}`);
+    }
+
+    throw new Response("Invalid state", { status: 400 });
+  }
+
+  const stateData = validationResult.state;
+
+  const project = await prisma.project.findFirst({
+    where: {
+      id: stateData.projectId,
+      organizationId: stateData.organizationId,
+      deletedAt: null,
+      organization: {
+        members: {
+          some: { userId },
+        },
+      },
+    },
+    include: {
+      organization: true,
+    },
+  });
+
+  if (!project) {
+    logger.warn("Project not found or access denied", {
+      projectId: stateData.projectId,
+      userId,
+    });
+    throw new Response("Project not found", { status: 404 });
+  }
+
+  const tokenResult = await VercelIntegrationRepository.exchangeCodeForToken(code);
+  if (tokenResult.isErr()) {
+    const params = new URLSearchParams({ error: "expired" });
+    return redirect(`/vercel/onboarding?${params.toString()}`);
+  }
+  const tokenResponse = tokenResult.value;
+
+  const environment = await prisma.runtimeEnvironment.findFirst({
+    where: {
+      projectId: project.id,
+      slug: stateData.environmentSlug,
+      archivedAt: null,
+    },
+  });
+
+  if (!environment) {
+    logger.warn("Environment not found", {
+      projectId: project.id,
+      environmentSlug: stateData.environmentSlug,
+    });
+    throw new Response("Environment not found", { status: 404 });
+  }
+
+  const settingsPath = v3ProjectSettingsIntegrationsPath(
+    { slug: stateData.organizationSlug },
+    { slug: stateData.projectSlug },
+    { slug: environment.slug }
+  );
+
+  const result = await fromPromise(
+    createOrFindVercelIntegration(stateData.organizationId, stateData.projectId, tokenResponse, configurationId, origin),
+    (error) => error
+  );
+
+  if (result.isErr()) {
+    logger.error("Failed to complete Vercel integration", { error: result.error });
+    throw redirect(settingsPath);
+  }
+
+  logger.info("Vercel organization integration created successfully", {
+    organizationId: stateData.organizationId,
+    projectId: stateData.projectId,
+    teamId: tokenResponse.teamId,
+  });
+
+  const params = new URLSearchParams({ vercelOnboarding: "true", origin });
+  if (next) {
+    params.set("next", next);
+  }
+
+  return redirect(`${settingsPath}?${params.toString()}`);
+}
diff --git a/apps/webapp/app/routes/vercel.install.tsx b/apps/webapp/app/routes/vercel.install.tsx
new file mode 100644
index 00000000000..86fa6fe1bc8
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.install.tsx
@@ -0,0 +1,83 @@
+import type { LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { redirect } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { $replica } from "~/db.server";
+import { requireUser } from "~/services/session.server";
+import { logger } from "~/services/logger.server";
+import { loopsClient } from "~/services/loops.server";
+import { OrgIntegrationRepository } from "~/models/orgIntegration.server";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+import { findProjectBySlug } from "~/models/project.server";
+
+const QuerySchema = z.object({
+  org_slug: z.string(),
+  project_slug: z.string(),
+});
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const searchParams = new URL(request.url).searchParams;
+  const parsed = QuerySchema.safeParse(Object.fromEntries(searchParams));
+
+  if (!parsed.success) {
+    logger.warn("Vercel App installation redirect with invalid params", {
+      searchParams,
+      error: parsed.error,
+    });
+    throw redirect("/");
+  }
+
+  const { org_slug, project_slug } = parsed.data;
+  const user = await requireUser(request);
+
+  // Find the organization
+  const org = await $replica.organization.findFirst({
+    where: { slug: org_slug, members: { some: { userId: user.id } }, deletedAt: null },
+    orderBy: { createdAt: "desc" },
+    select: {
+      id: true,
+    },
+  });
+
+  if (!org) {
+    throw redirect("/");
+  }
+
+  // Find the project
+  const project = await findProjectBySlug(org_slug, project_slug, user.id);
+  if (!project) {
+    logger.warn("Vercel App installation attempt for non-existent project", {
+      org_slug,
+      project_slug,
+      userId: user.id,
+    });
+    throw redirect("/");
+  }
+
+  // Use "prod" as the default environment slug for the redirect
+  // The callback will redirect to the settings page for this environment
+  const environmentSlug = "prod";
+
+  // Generate JWT state token
+  const stateToken = await generateVercelOAuthState({
+    organizationId: org.id,
+    projectId: project.id,
+    environmentSlug,
+    organizationSlug: org_slug,
+    projectSlug: project_slug,
+  });
+
+  // Send Loops.so event (fire-and-forget, don't block the redirect)
+  loopsClient
+    ?.vercelIntegrationStarted({
+      userId: user.id,
+      email: user.email,
+      name: user.name,
+    })
+    .catch(() => {});
+
+  // Generate Vercel install URL
+  const vercelInstallUrl = OrgIntegrationRepository.vercelInstallUrl(stateToken);
+
+  return redirect(vercelInstallUrl);
+};
+
diff --git a/apps/webapp/app/routes/vercel.onboarding.tsx b/apps/webapp/app/routes/vercel.onboarding.tsx
new file mode 100644
index 00000000000..1cf351532e9
--- /dev/null
+++ b/apps/webapp/app/routes/vercel.onboarding.tsx
@@ -0,0 +1,465 @@
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/server-runtime";
+import { json, redirect } from "@remix-run/server-runtime";
+import { fromPromise } from "neverthrow";
+import { useEffect, useState } from "react";
+import { Form, useNavigation } from "@remix-run/react";
+import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { z } from "zod";
+import { BuildingOfficeIcon, FolderIcon } from "@heroicons/react/20/solid";
+import { AppContainer, MainCenteredContainer } from "~/components/layout/AppLayout";
+import { BackgroundWrapper } from "~/components/BackgroundWrapper";
+import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Fieldset } from "~/components/primitives/Fieldset";
+import { FormButtons } from "~/components/primitives/FormButtons";
+import { FormTitle } from "~/components/primitives/FormTitle";
+import { InputGroup } from "~/components/primitives/InputGroup";
+import { Label } from "~/components/primitives/Label";
+import { Select, SelectItem } from "~/components/primitives/Select";
+import { ButtonSpinner } from "~/components/primitives/Spinner";
+import { prisma } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { confirmBasicDetailsPath, newProjectPath } from "~/utils/pathBuilder";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { generateVercelOAuthState } from "~/v3/vercel/vercelOAuthState.server";
+
+const LoaderParamsSchema = z.object({
+  organizationId: z.string().optional().nullable(),
+  code: z.string().optional().nullable(),
+  configurationId: z.string().optional().nullable(),
+  next: z.string().optional().nullable(),
+  error: z.string().optional().nullable(),
+});
+
+const SelectOrgActionSchema = z.object({
+  action: z.literal("select-org"),
+  organizationId: z.string(),
+  code: z.string(),
+  configurationId: z.string().optional().nullable(),
+  next: z.string().optional(),
+});
+
+const SelectProjectActionSchema = z.object({
+  action: z.literal("select-project"),
+  projectId: z.string(),
+  organizationId: z.string(),
+  code: z.string(),
+  configurationId: z.string().optional().nullable(),
+  next: z.string().optional().nullable(),
+});
+
+const ActionSchema = z.discriminatedUnion("action", [
+  SelectOrgActionSchema,
+  SelectProjectActionSchema,
+]);
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+  const url = new URL(request.url);
+
+  const params = LoaderParamsSchema.safeParse({
+    organizationId: url.searchParams.get("organizationId"),
+    code: url.searchParams.get("code"),
+    configurationId: url.searchParams.get("configurationId"),
+    next: url.searchParams.get("next"),
+    error: url.searchParams.get("error"),
+  });
+
+  if (!params.success) {
+    logger.error("Invalid params for Vercel onboarding", { error: params.error });
+    throw redirectWithErrorMessage(
+      "/",
+      request,
+      "Invalid installation parameters. Please try again from Vercel."
+    );
+  }
+
+  const { error } = params.data;
+  if (error === "expired") {
+    return typedjson({
+      step: "error" as const,
+      error: "Your installation session has expired. Please start the installation again.",
+      code: params.data.code ?? null,
+      configurationId: params.data.configurationId ?? null,
+      next: params.data.next ?? null,
+    });
+  }
+
+  if (!params.data.code) {
+    logger.error("Missing code parameter for Vercel onboarding");
+    throw redirectWithErrorMessage(
+      "/",
+      request,
+      "Invalid installation parameters. Please try again from Vercel."
+    );
+  }
+
+  const code = params.data.code;
+
+  const organizations = await prisma.organization.findMany({
+    where: {
+      members: {
+        some: { userId },
+      },
+      deletedAt: null,
+    },
+    select: {
+      id: true,
+      title: true,
+      slug: true,
+      projects: {
+        where: {
+          deletedAt: null,
+        },
+        select: {
+          id: true,
+          name: true,
+          slug: true,
+        },
+        orderBy: {
+          createdAt: "asc",
+        },
+      },
+    },
+    orderBy: {
+      createdAt: "asc",
+    },
+  });
+
+  // New user: no organizations
+  if (organizations.length === 0) {
+    const onboardingParams = new URLSearchParams();
+    onboardingParams.set("code", code);
+    if (params.data.configurationId) {
+      onboardingParams.set("configurationId", params.data.configurationId);
+    }
+    onboardingParams.set("integration", "vercel");
+    if (params.data.next) {
+      onboardingParams.set("next", params.data.next);
+    }
+    throw redirect(`${confirmBasicDetailsPath()}?${onboardingParams.toString()}`);
+  }
+
+  // If organizationId is provided, show project selection
+  if (params.data.organizationId) {
+    const organization = organizations.find((org) => org.id === params.data.organizationId);
+
+    if (!organization) {
+      logger.error("Organization not found or access denied", {
+        organizationId: params.data.organizationId,
+        userId,
+      });
+      throw redirectWithErrorMessage(
+        "/",
+        request,
+        "Organization not found. Please try again."
+      );
+    }
+
+    return typedjson({
+      step: "project" as const,
+      organization,
+      organizations,
+      code: code,
+      configurationId: params.data.configurationId ?? null,
+      next: params.data.next ?? null,
+    });
+  }
+
+  return typedjson({
+    step: "org" as const,
+    organizations,
+    code: code,
+    configurationId: params.data.configurationId ?? null,
+    next: params.data.next ?? null,
+  });
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  const userId = await requireUserId(request);
+  const formData = await request.formData();
+
+  const submission = ActionSchema.safeParse({
+    action: formData.get("action"),
+    organizationId: formData.get("organizationId"),
+    projectId: formData.get("projectId"),
+    code: formData.get("code"),
+    configurationId: formData.get("configurationId"),
+    next: formData.get("next"),
+  });
+
+  if (!submission.success) {
+    return json({ error: "Invalid submission" }, { status: 400 });
+  }
+
+  const { code, configurationId, next } = submission.data;
+
+  // Handle org selection
+  if (submission.data.action === "select-org") {
+    const { organizationId } = submission.data;
+
+    const projectParams = new URLSearchParams();
+    projectParams.set("organizationId", organizationId);
+    projectParams.set("code", code);
+    if (configurationId) {
+      projectParams.set("configurationId", configurationId);
+    }
+    if (next) {
+      projectParams.set("next", next);
+    }
+
+    return redirect(`/vercel/onboarding?${projectParams.toString()}`);
+  }
+
+  // Handle project selection
+  const { projectId, organizationId } = submission.data;
+
+  const project = await prisma.project.findFirst({
+    where: {
+      id: projectId,
+      organizationId,
+      deletedAt: null,
+      organization: {
+        members: { some: { userId } },
+      },
+    },
+    include: {
+      organization: true,
+    },
+  });
+
+  if (!project) {
+    logger.error("Project not found or access denied", { projectId, userId });
+    return json({ error: "Project not found" }, { status: 404 });
+  }
+
+  const environment = await prisma.runtimeEnvironment.findFirst({
+    where: {
+      projectId: project.id,
+      slug: "prod",
+      archivedAt: null,
+    },
+  });
+
+  if (!environment) {
+    logger.error("Environment not found", { projectId: project.id });
+    return json({ error: "Environment not found" }, { status: 404 });
+  }
+
+  const stateResult = await fromPromise(
+    generateVercelOAuthState({
+      organizationId: project.organizationId,
+      projectId: project.id,
+      environmentSlug: environment.slug,
+      organizationSlug: project.organization.slug,
+      projectSlug: project.slug,
+    }),
+    (error) => error
+  );
+
+  if (stateResult.isErr()) {
+    logger.error("Failed to generate Vercel OAuth state", { error: stateResult.error });
+    return json({ error: "Failed to generate installation state" }, { status: 500 });
+  }
+
+  const params = new URLSearchParams();
+  params.set("state", stateResult.value);
+  params.set("code", code);
+  if (configurationId) {
+    params.set("configurationId", configurationId);
+  }
+  params.set("origin", "marketplace");
+  if (next) {
+    params.set("next", next);
+  }
+
+  return redirect(`/vercel/connect?${params.toString()}`, 303);
+}
+
+export default function VercelOnboardingPage() {
+  const data = useTypedLoaderData<typeof loader>();
+  const navigation = useNavigation();
+  const isSubmitting = navigation.state === "submitting";
+  const [isInstalling, setIsInstalling] = useState(false);
+
+  // Reset isInstalling when navigation returns to idle (e.g. on error)
+  useEffect(() => {
+    if (navigation.state === "idle" && isInstalling) {
+      setIsInstalling(false);
+    }
+  }, [navigation.state, isInstalling]);
+
+  if (data.step === "error") {
+    return (
+      <AppContainer className="bg-charcoal-900">
+        <BackgroundWrapper>
+          <MainCenteredContainer variant="onboarding" className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+            <FormTitle title="Installation Expired" description={data.error} />
+            <Button
+              variant="primary/medium"
+              onClick={() => window.close()}
+              className="w-full"
+            >
+              Close
+            </Button>
+          </MainCenteredContainer>
+        </BackgroundWrapper>
+      </AppContainer>
+    );
+  }
+
+  if (data.step === "org") {
+    const newOrgUrl = (() => {
+      const params = new URLSearchParams();
+      params.set("code", data.code);
+      if (data.configurationId) {
+        params.set("configurationId", data.configurationId);
+      }
+      params.set("integration", "vercel");
+      if (data.next) {
+        params.set("next", data.next);
+      }
+      return `/orgs/new?${params.toString()}`;
+    })();
+
+    return (
+      <AppContainer className="bg-charcoal-900">
+        <BackgroundWrapper>
+          <MainCenteredContainer variant="onboarding" className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+            <FormTitle
+              LeadingIcon={<BuildingOfficeIcon className="size-7 text-indigo-500" />}
+              title="Select Organization"
+              description="Choose which organization to install the Vercel integration into."
+            />
+            <Form method="post">
+              <input type="hidden" name="action" value="select-org" />
+              <input type="hidden" name="code" value={data.code} />
+              {data.configurationId && (
+                <input type="hidden" name="configurationId" value={data.configurationId} />
+              )}
+              {data.next && <input type="hidden" name="next" value={data.next} />}
+
+              <Fieldset>
+                <InputGroup>
+                  <Label>Organization</Label>
+                  <Select
+                    name="organizationId"
+                    placeholder="Choose an organization"
+                    required
+                    variant="tertiary/medium"
+                    dropdownIcon
+                    defaultValue={data.organizations[0]?.id}
+                    text={(v) =>
+                      typeof v === "string"
+                        ? data.organizations.find((o) => o.id === v)?.title || "Choose an organization"
+                        : "Choose an organization"
+                    }
+                  >
+                    {data.organizations.map((org) => (
+                      <SelectItem key={org.id} value={org.id}>
+                        {org.title}
+                      </SelectItem>
+                    ))}
+                  </Select>
+                </InputGroup>
+                <FormButtons
+                  confirmButton={
+                    <div className="flex items-center gap-2">
+                      <LinkButton to={newOrgUrl} variant="tertiary/small">
+                        + New Organization
+                      </LinkButton>
+                      <Button type="submit" variant="primary/small">
+                        Continue
+                      </Button>
+                    </div>
+                  }
+                />
+              </Fieldset>
+            </Form>
+          </MainCenteredContainer>
+        </BackgroundWrapper>
+      </AppContainer>
+    );
+  }
+
+  const newProjectUrl = (() => {
+    const params = new URLSearchParams();
+    params.set("code", data.code);
+    if (data.configurationId) {
+      params.set("configurationId", data.configurationId);
+    }
+    params.set("integration", "vercel");
+    params.set("organizationId", data.organization.id);
+    if (data.next) {
+      params.set("next", data.next);
+    }
+    return `${newProjectPath({ slug: data.organization.slug })}?${params.toString()}`;
+  })();
+
+  const isLoading = isSubmitting || isInstalling;
+
+  return (
+    <AppContainer className="bg-charcoal-900">
+      <BackgroundWrapper>
+        <MainCenteredContainer variant="onboarding" className="max-w-[26rem] rounded-lg border border-grid-bright bg-background-dimmed p-5 shadow-lg">
+          <FormTitle
+            LeadingIcon={<FolderIcon className="size-7 text-indigo-500" />}
+            title="Select Project"
+            description={`Choose which project in "${data.organization.title}" to install the Vercel integration into.`}
+          />
+          <Form method="post" onSubmit={() => setIsInstalling(true)}>
+            <input type="hidden" name="action" value="select-project" />
+            <input type="hidden" name="organizationId" value={data.organization.id} />
+            <input type="hidden" name="code" value={data.code} />
+            {data.configurationId && (
+              <input type="hidden" name="configurationId" value={data.configurationId} />
+            )}
+            {data.next && <input type="hidden" name="next" value={data.next} />}
+
+            <Fieldset>
+              <InputGroup>
+                <Label>Project</Label>
+                <Select
+                  name="projectId"
+                  placeholder="Choose a project"
+                  required
+                  variant="tertiary/medium"
+                  dropdownIcon
+                  defaultValue={data.organization.projects[0]?.id}
+                  text={(v) =>
+                    typeof v === "string"
+                      ? data.organization.projects.find((p) => p.id === v)?.name || "Choose a project"
+                      : "Choose a project"
+                  }
+                >
+                  {data.organization.projects.map((project) => (
+                    <SelectItem key={project.id} value={project.id}>
+                      {project.name}
+                    </SelectItem>
+                  ))}
+                </Select>
+              </InputGroup>
+              <FormButtons
+                confirmButton={
+                  <div className="flex items-center gap-2">
+                    <LinkButton to={newProjectUrl} variant="tertiary/small" disabled={isLoading}>
+                      + New Project
+                    </LinkButton>
+                    <Button
+                      type="submit"
+                      variant="primary/small"
+                      disabled={isLoading}
+                      TrailingIcon={isLoading ? ButtonSpinner : undefined}
+                    >
+                      {isLoading ? "Continuing…" : "Continue"}
+                    </Button>
+                  </div>
+                }
+              />
+            </Fieldset>
+          </Form>
+        </MainCenteredContainer>
+      </BackgroundWrapper>
+    </AppContainer>
+  );
+}
diff --git a/apps/webapp/app/runEngine/concerns/batchLimits.server.ts b/apps/webapp/app/runEngine/concerns/batchLimits.server.ts
index 0fcbe67a4e9..f40088039eb 100644
--- a/apps/webapp/app/runEngine/concerns/batchLimits.server.ts
+++ b/apps/webapp/app/runEngine/concerns/batchLimits.server.ts
@@ -1,8 +1,10 @@
 import { Organization } from "@trigger.dev/database";
-import { Ratelimit } from "@upstash/ratelimit";
 import { z } from "zod";
 import { env } from "~/env.server";
-import { RateLimiterConfig } from "~/services/authorizationRateLimitMiddleware.server";
+import {
+  RateLimiterConfig,
+  createLimiterFromConfig,
+} from "~/services/authorizationRateLimitMiddleware.server";
 import { createRedisRateLimitClient, Duration, RateLimiter } from "~/services/rateLimiter.server";
 import { singleton } from "~/utils/singleton";
 
@@ -33,16 +35,7 @@ function createBatchLimitsRedisClient() {
 function createOrganizationRateLimiter(organization: Organization): RateLimiter {
   const limiterConfig = resolveBatchRateLimitConfig(organization.batchRateLimitConfig);
 
-  const limiter =
-    limiterConfig.type === "fixedWindow"
-      ? Ratelimit.fixedWindow(limiterConfig.tokens, limiterConfig.window)
-      : limiterConfig.type === "tokenBucket"
-      ? Ratelimit.tokenBucket(
-          limiterConfig.refillRate,
-          limiterConfig.interval,
-          limiterConfig.maxTokens
-        )
-      : Ratelimit.slidingWindow(limiterConfig.tokens, limiterConfig.window);
+  const limiter = createLimiterFromConfig(limiterConfig);
 
   return new RateLimiter({
     redisClient: batchLimitsRedisClient,
@@ -115,9 +108,7 @@ export class BatchRateLimitExceededError extends Error {
     public readonly resetAt: Date,
     public readonly itemCount: number
   ) {
-    super(
-      `Batch rate limit exceeded. Attempted to submit ${itemCount} items but only ${remaining} remaining. Limit resets at ${resetAt.toISOString()}`
-    );
+    super(`Batch rate limit exceeded. Limit resets at ${resetAt.toISOString()}`);
     this.name = "BatchRateLimitExceededError";
   }
 }
diff --git a/apps/webapp/app/runEngine/concerns/batchPayloads.server.ts b/apps/webapp/app/runEngine/concerns/batchPayloads.server.ts
index efd9062195c..ab464f03fa2 100644
--- a/apps/webapp/app/runEngine/concerns/batchPayloads.server.ts
+++ b/apps/webapp/app/runEngine/concerns/batchPayloads.server.ts
@@ -1,9 +1,10 @@
-import { IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/v3";
+import { type IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/v3";
+import pRetry from "p-retry";
 import { env } from "~/env.server";
-import { startActiveSpan } from "~/v3/tracer.server";
-import { uploadPacketToObjectStore, r2 } from "~/v3/r2.server";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
+import { hasObjectStoreClient, uploadPacketToObjectStore } from "~/v3/objectStore.server";
+import { startActiveSpan } from "~/v3/tracer.server";
 
 export type BatchPayloadProcessResult = {
   /** The processed payload - either the original or an R2 path */
@@ -31,7 +32,7 @@ export class BatchPayloadProcessor {
    * If not available, large payloads will be stored inline (which may fail for very large payloads).
    */
   isObjectStoreAvailable(): boolean {
-    return r2 !== undefined && env.OBJECT_STORE_BASE_URL !== undefined;
+    return hasObjectStoreClient();
   }
 
   /**
@@ -103,40 +104,60 @@ export class BatchPayloadProcessor {
         };
       }
 
-      // Upload to R2
+      // Upload to object store, retrying on transient network errors
+      const { data: packetData, dataType: packetDataType } = packet;
       const filename = `batch_${batchId}/item_${itemIndex}/payload.json`;
 
-      const [uploadError] = await tryCatch(
-        uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment)
+      const [uploadError, uploadedFilename] = await tryCatch(
+        pRetry(
+          () =>
+            uploadPacketToObjectStore(
+              filename,
+              packetData,
+              packetDataType,
+              environment,
+              env.OBJECT_STORE_DEFAULT_PROTOCOL
+            ),
+          {
+            retries: 3,
+            minTimeout: 500,
+            maxTimeout: 2000,
+            factor: 2,
+            onFailedAttempt: (error) => {
+              logger.warn("Batch item payload upload to object store failed, retrying", {
+                batchId,
+                itemIndex,
+                attempt: error.attemptNumber,
+                retriesLeft: error.retriesLeft,
+                error: error.message,
+              });
+            },
+          }
+        )
       );
 
       if (uploadError) {
-        logger.error("Failed to upload batch item payload to object store", {
+        logger.error("Failed to upload batch item payload to object store after retries", {
           batchId,
           itemIndex,
-          error: uploadError instanceof Error ? uploadError.message : String(uploadError),
+          error: uploadError.message,
         });
 
-        // Throw to fail this item - SDK can retry
-        throw new Error(
-          `Failed to upload large payload to object store: ${
-            uploadError instanceof Error ? uploadError.message : String(uploadError)
-          }`
-        );
+        throw new Error(`Failed to upload large payload to object store: ${uploadError.message}`);
       }
 
-      logger.debug("Batch item payload offloaded to R2", {
+      logger.debug("Batch item payload offloaded to object store", {
         batchId,
         itemIndex,
-        filename,
+        filename: uploadedFilename,
         size,
       });
 
       span.setAttribute("wasOffloaded", true);
-      span.setAttribute("offloadPath", filename);
+      span.setAttribute("offloadPath", uploadedFilename);
 
       return {
-        payload: filename,
+        payload: uploadedFilename!,
         payloadType: "application/store",
         wasOffloaded: true,
         size,
diff --git a/apps/webapp/app/runEngine/concerns/idempotencyKeys.server.ts b/apps/webapp/app/runEngine/concerns/idempotencyKeys.server.ts
index d22c8020d29..a6fe5babe2c 100644
--- a/apps/webapp/app/runEngine/concerns/idempotencyKeys.server.ts
+++ b/apps/webapp/app/runEngine/concerns/idempotencyKeys.server.ts
@@ -79,11 +79,21 @@ export class IdempotencyKeyConcern {
       }
 
       // We have an idempotent run, so we return it
-      const associatedWaitpoint = existingRun.associatedWaitpoint;
       const parentRunId = request.body.options?.parentRunId;
       const resumeParentOnCompletion = request.body.options?.resumeParentOnCompletion;
+
       //We're using `andWait` so we need to block the parent run with a waitpoint
-      if (associatedWaitpoint && resumeParentOnCompletion && parentRunId) {
+      if (resumeParentOnCompletion && parentRunId) {
+        // Get or create waitpoint lazily (existing run may not have one if it was standalone)
+        let associatedWaitpoint = existingRun.associatedWaitpoint;
+        if (!associatedWaitpoint) {
+          associatedWaitpoint = await this.engine.getOrCreateRunWaitpoint({
+            runId: existingRun.id,
+            projectId: request.environment.projectId,
+            environmentId: request.environment.id,
+          });
+        }
+
         await this.traceEventConcern.traceIdempotentRun(
           request,
           parentStore,
@@ -98,13 +108,13 @@ export class IdempotencyKeyConcern {
               request.options?.parentAsLinkType === "replay"
                 ? event.spanId
                 : event.traceparent?.spanId
-                ? `${event.traceparent.spanId}:${event.spanId}`
-                : event.spanId;
+                  ? `${event.traceparent.spanId}:${event.spanId}`
+                  : event.spanId;
 
             //block run with waitpoint
             await this.engine.blockRunWithWaitpoint({
               runId: RunId.fromFriendlyId(parentRunId),
-              waitpoints: associatedWaitpoint.id,
+              waitpoints: associatedWaitpoint!.id,
               spanIdToComplete: spanId,
               batch: request.options?.batchId
                 ? {
diff --git a/apps/webapp/app/runEngine/concerns/payloads.server.ts b/apps/webapp/app/runEngine/concerns/payloads.server.ts
index 5ad84f8dc66..7e1efbdf302 100644
--- a/apps/webapp/app/runEngine/concerns/payloads.server.ts
+++ b/apps/webapp/app/runEngine/concerns/payloads.server.ts
@@ -2,7 +2,7 @@ import { IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/
 import { PayloadProcessor, TriggerTaskRequest } from "../types";
 import { env } from "~/env.server";
 import { startActiveSpan } from "~/v3/tracer.server";
-import { uploadPacketToObjectStore } from "~/v3/r2.server";
+import { uploadPacketToObjectStore } from "~/v3/objectStore.server";
 import { ServiceValidationError } from "~/v3/services/common.server";
 
 export class DefaultPayloadProcessor implements PayloadProcessor {
@@ -31,8 +31,8 @@ export class DefaultPayloadProcessor implements PayloadProcessor {
 
       const filename = `${request.friendlyId}/payload.json`;
 
-      const [uploadError] = await tryCatch(
-        uploadPacketToObjectStore(filename, packet.data, packet.dataType, request.environment)
+      const [uploadError, uploadedFilename] = await tryCatch(
+        uploadPacketToObjectStore(filename, packet.data, packet.dataType, request.environment, env.OBJECT_STORE_DEFAULT_PROTOCOL)
       );
 
       if (uploadError) {
@@ -40,7 +40,7 @@ export class DefaultPayloadProcessor implements PayloadProcessor {
       }
 
       return {
-        data: filename,
+        data: uploadedFilename!,
         dataType: "application/store",
       };
     });
diff --git a/apps/webapp/app/runEngine/concerns/queues.server.ts b/apps/webapp/app/runEngine/concerns/queues.server.ts
index 3a853f9b254..eb00bf1c586 100644
--- a/apps/webapp/app/runEngine/concerns/queues.server.ts
+++ b/apps/webapp/app/runEngine/concerns/queues.server.ts
@@ -15,12 +15,57 @@ import type { RunEngine } from "~/v3/runEngine.server";
 import { env } from "~/env.server";
 import { tryCatch } from "@trigger.dev/core/v3";
 import { ServiceValidationError } from "~/v3/services/common.server";
+import { createCache, createLRUMemoryStore, DefaultStatefulContext, Namespace } from "@internal/cache";
+import { singleton } from "~/utils/singleton";
+
+// LRU cache for environment queue sizes to reduce Redis calls
+const queueSizeCache = singleton("queueSizeCache", () => {
+  const ctx = new DefaultStatefulContext();
+  const memory = createLRUMemoryStore(env.QUEUE_SIZE_CACHE_MAX_SIZE, "queue-size-cache");
+
+  return createCache({
+    queueSize: new Namespace<number>(ctx, {
+      stores: [memory],
+      fresh: env.QUEUE_SIZE_CACHE_TTL_MS,
+      stale: env.QUEUE_SIZE_CACHE_TTL_MS + 1000,
+    }),
+  });
+});
+
+/**
+ * Extract the queue name from a queue option that may be:
+ * - An object with a string `name` property: { name: "queue-name" }
+ * - A double-wrapped object (bug case): { name: { name: "queue-name", ... } }
+ *
+ * This handles the case where the SDK accidentally double-wraps the queue
+ * option when it's already an object with a name property.
+ */
+function extractQueueName(queue: { name?: unknown } | undefined): string | undefined {
+  if (!queue?.name) {
+    return undefined;
+  }
+
+  // Normal case: queue.name is a string
+  if (typeof queue.name === "string") {
+    return queue.name;
+  }
+
+  // Double-wrapped case: queue.name is an object with its own name property
+  if (typeof queue.name === "object" && queue.name !== null && "name" in queue.name) {
+    const innerName = (queue.name as { name: unknown }).name;
+    if (typeof innerName === "string") {
+      return innerName;
+    }
+  }
+
+  return undefined;
+}
 
 export class DefaultQueueManager implements QueueManager {
   constructor(
     private readonly prisma: PrismaClientOrTransaction,
     private readonly engine: RunEngine
-  ) {}
+  ) { }
 
   async resolveQueueProperties(
     request: TriggerTaskRequest,
@@ -28,34 +73,49 @@ export class DefaultQueueManager implements QueueManager {
   ): Promise<QueueProperties> {
     let queueName: string;
     let lockedQueueId: string | undefined;
+    let taskTtl: string | null | undefined;
 
     // Determine queue name based on lockToVersion and provided options
     if (lockedBackgroundWorker) {
       // Task is locked to a specific worker version
-      if (request.body.options?.queue?.name) {
-        const specifiedQueueName = request.body.options.queue.name;
-        // A specific queue name is provided
+      const specifiedQueueName = extractQueueName(request.body.options?.queue);
+
+      if (specifiedQueueName) {
+        // A specific queue name is provided, validate it exists for the locked worker
         const specifiedQueue = await this.prisma.taskQueue.findFirst({
-          // Validate it exists for the locked worker
           where: {
             name: specifiedQueueName,
             runtimeEnvironmentId: request.environment.id,
-            workers: { some: { id: lockedBackgroundWorker.id } }, // Ensure the queue is associated with any task of the locked worker
+            workers: { some: { id: lockedBackgroundWorker.id } },
           },
         });
 
         if (!specifiedQueue) {
           throw new ServiceValidationError(
-            `Specified queue '${specifiedQueueName}' not found or not associated with locked version '${
-              lockedBackgroundWorker.version ?? "<unknown>"
+            `Specified queue '${specifiedQueueName}' not found or not associated with locked version '${lockedBackgroundWorker.version ?? "<unknown>"
             }'.`
           );
         }
+
         // Use the validated queue name directly
         queueName = specifiedQueue.name;
         lockedQueueId = specifiedQueue.id;
+
+        // Only fetch task for TTL if caller didn't provide a per-trigger TTL
+        if (request.body.options?.ttl === undefined) {
+          const lockedTask = await this.prisma.backgroundWorkerTask.findFirst({
+            where: {
+              workerId: lockedBackgroundWorker.id,
+              runtimeEnvironmentId: request.environment.id,
+              slug: request.taskId,
+            },
+            select: { ttl: true },
+          });
+
+          taskTtl = lockedTask?.ttl;
+        }
       } else {
-        // No specific queue name provided, use the default queue for the task on the locked worker
+        // No queue override - fetch task with queue to get both default queue and TTL
         const lockedTask = await this.prisma.backgroundWorkerTask.findFirst({
           where: {
             workerId: lockedBackgroundWorker.id,
@@ -69,12 +129,13 @@ export class DefaultQueueManager implements QueueManager {
 
         if (!lockedTask) {
           throw new ServiceValidationError(
-            `Task '${request.taskId}' not found on locked version '${
-              lockedBackgroundWorker.version ?? "<unknown>"
+            `Task '${request.taskId}' not found on locked version '${lockedBackgroundWorker.version ?? "<unknown>"
             }'.`
           );
         }
 
+        taskTtl = lockedTask.ttl;
+
         if (!lockedTask.queue) {
           // This case should ideally be prevented by earlier checks or schema constraints,
           // but handle it defensively.
@@ -84,11 +145,11 @@ export class DefaultQueueManager implements QueueManager {
             version: lockedBackgroundWorker.version,
           });
           throw new ServiceValidationError(
-            `Default queue configuration for task '${request.taskId}' missing on locked version '${
-              lockedBackgroundWorker.version ?? "<unknown>"
+            `Default queue configuration for task '${request.taskId}' missing on locked version '${lockedBackgroundWorker.version ?? "<unknown>"
             }'.`
           );
         }
+
         // Use the task's default queue name
         queueName = lockedTask.queue.name;
         lockedQueueId = lockedTask.queue.id;
@@ -103,7 +164,9 @@ export class DefaultQueueManager implements QueueManager {
       }
 
       // Get queue name using the helper for non-locked case (handles provided name or finds default)
-      queueName = await this.getQueueName(request);
+      const taskInfo = await this.getTaskQueueInfo(request);
+      queueName = taskInfo.queueName;
+      taskTtl = taskInfo.taskTtl;
     }
 
     // Sanitize the final determined queue name once
@@ -119,19 +182,27 @@ export class DefaultQueueManager implements QueueManager {
     return {
       queueName,
       lockedQueueId,
+      taskTtl,
     };
   }
 
-  async getQueueName(request: TriggerTaskRequest): Promise<string> {
+  private async getTaskQueueInfo(
+    request: TriggerTaskRequest
+  ): Promise<{ queueName: string; taskTtl?: string | null }> {
     const { taskId, environment, body } = request;
     const { queue } = body.options ?? {};
 
-    if (queue?.name) {
-      return queue.name;
-    }
+    // Use extractQueueName to handle double-wrapped queue objects
+    const overriddenQueueName = extractQueueName(queue);
 
     const defaultQueueName = `task/${taskId}`;
 
+    // When caller provides both a queue override and a per-trigger TTL,
+    // we don't need any DB queries - the per-trigger TTL takes precedence
+    if (overriddenQueueName && body.options?.ttl !== undefined) {
+      return { queueName: overriddenQueueName, taskTtl: undefined };
+    }
+
     // Find the current worker for the environment
     const worker = await findCurrentWorkerFromEnvironment(environment, this.prisma);
 
@@ -141,7 +212,21 @@ export class DefaultQueueManager implements QueueManager {
         environmentId: environment.id,
       });
 
-      return defaultQueueName;
+      return { queueName: overriddenQueueName ?? defaultQueueName, taskTtl: undefined };
+    }
+
+    // When queue is overridden, we only need TTL from the task (no queue join needed)
+    if (overriddenQueueName) {
+      const task = await this.prisma.backgroundWorkerTask.findFirst({
+        where: {
+          workerId: worker.id,
+          runtimeEnvironmentId: environment.id,
+          slug: taskId,
+        },
+        select: { ttl: true },
+      });
+
+      return { queueName: overriddenQueueName, taskTtl: task?.ttl };
     }
 
     const task = await this.prisma.backgroundWorkerTask.findFirst({
@@ -161,7 +246,7 @@ export class DefaultQueueManager implements QueueManager {
         environmentId: environment.id,
       });
 
-      return defaultQueueName;
+      return { queueName: defaultQueueName, taskTtl: undefined };
     }
 
     if (!task.queue) {
@@ -171,20 +256,27 @@ export class DefaultQueueManager implements QueueManager {
         queueConfig: task.queueConfig,
       });
 
-      return defaultQueueName;
+      return { queueName: defaultQueueName, taskTtl: task.ttl };
     }
 
-    return task.queue.name ?? defaultQueueName;
+    return { queueName: task.queue.name ?? defaultQueueName, taskTtl: task.ttl };
   }
 
   async validateQueueLimits(
     environment: AuthenticatedEnvironment,
+    queueName: string,
     itemsToAdd?: number
   ): Promise<QueueValidationResult> {
-    const queueSizeGuard = await guardQueueSizeLimitsForEnv(this.engine, environment, itemsToAdd);
+    const queueSizeGuard = await guardQueueSizeLimitsForQueue(
+      this.engine,
+      environment,
+      queueName,
+      itemsToAdd
+    );
 
     logger.debug("Queue size guard result", {
       queueSizeGuard,
+      queueName,
       environment: {
         id: environment.id,
         type: environment.type,
@@ -203,9 +295,9 @@ export class DefaultQueueManager implements QueueManager {
   async getWorkerQueue(
     environment: AuthenticatedEnvironment,
     regionOverride?: string
-  ): Promise<string | undefined> {
+  ): Promise<{ masterQueue: string; enableFastPath: boolean } | undefined> {
     if (environment.type === "DEVELOPMENT") {
-      return environment.id;
+      return { masterQueue: environment.id, enableFastPath: true };
     }
 
     const workerGroupService = new WorkerGroupService({
@@ -228,11 +320,14 @@ export class DefaultQueueManager implements QueueManager {
       throw new ServiceValidationError("No worker group found");
     }
 
-    return workerGroup.masterQueue;
+    return {
+      masterQueue: workerGroup.masterQueue,
+      enableFastPath: workerGroup.enableFastPath,
+    };
   }
 }
 
-function getMaximumSizeForEnvironment(environment: AuthenticatedEnvironment): number | undefined {
+export function getMaximumSizeForEnvironment(environment: AuthenticatedEnvironment): number | undefined {
   if (environment.type === "DEVELOPMENT") {
     return environment.organization.maximumDevQueueSize ?? env.MAXIMUM_DEV_QUEUE_SIZE;
   } else {
@@ -240,9 +335,10 @@ function getMaximumSizeForEnvironment(environment: AuthenticatedEnvironment): nu
   }
 }
 
-async function guardQueueSizeLimitsForEnv(
+async function guardQueueSizeLimitsForQueue(
   engine: RunEngine,
   environment: AuthenticatedEnvironment,
+  queueName: string,
   itemsToAdd: number = 1
 ) {
   const maximumSize = getMaximumSizeForEnvironment(environment);
@@ -251,7 +347,7 @@ async function guardQueueSizeLimitsForEnv(
     return { isWithinLimits: true };
   }
 
-  const queueSize = await engine.lengthOfEnvQueue(environment);
+  const queueSize = await getCachedQueueSize(engine, environment, queueName);
   const projectedSize = queueSize + itemsToAdd;
 
   return {
@@ -260,3 +356,20 @@ async function guardQueueSizeLimitsForEnv(
     queueSize,
   };
 }
+
+async function getCachedQueueSize(
+  engine: RunEngine,
+  environment: AuthenticatedEnvironment,
+  queueName: string
+): Promise<number> {
+  if (!env.QUEUE_SIZE_CACHE_ENABLED) {
+    return engine.lengthOfQueue(environment, queueName);
+  }
+
+  const cacheKey = `${environment.id}:${queueName}`;
+  const result = await queueSizeCache.queueSize.swr(cacheKey, async () => {
+    return engine.lengthOfQueue(environment, queueName);
+  });
+
+  return result.val ?? 0;
+}
diff --git a/apps/webapp/app/runEngine/concerns/waitpointCompletionPacket.server.ts b/apps/webapp/app/runEngine/concerns/waitpointCompletionPacket.server.ts
new file mode 100644
index 00000000000..5e029221344
--- /dev/null
+++ b/apps/webapp/app/runEngine/concerns/waitpointCompletionPacket.server.ts
@@ -0,0 +1,63 @@
+import { type IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/v3";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { env } from "~/env.server";
+import { uploadPacketToObjectStore } from "~/v3/objectStore.server";
+import { ServiceValidationError } from "~/v3/services/common.server";
+
+function packetExtensionForDataType(dataType: string): string {
+  switch (dataType) {
+    case "application/json":
+    case "application/super+json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    default:
+      return "txt";
+  }
+}
+
+/**
+ * Offloads large waitpoint completion payloads to object store (same threshold and
+ * upload path pattern as DefaultPayloadProcessor). Object key prefix should use the
+ * waitpoint friendly id folder, e.g. `${WaitpointId.toFriendlyId(internalId)}/token`.
+ * Replaces no-op conditionallyExportPacket usage in webapp routes where apiClientManager is unset.
+ */
+export async function processWaitpointCompletionPacket(
+  packet: IOPacket,
+  environment: AuthenticatedEnvironment,
+  pathPrefix: string
+): Promise<IOPacket> {
+  if (!packet.data) {
+    return packet;
+  }
+
+  const { needsOffloading, size } = packetRequiresOffloading(
+    packet,
+    env.TASK_PAYLOAD_OFFLOAD_THRESHOLD
+  );
+
+  if (!needsOffloading) {
+    return packet;
+  }
+
+  const filename = `${pathPrefix}.${packetExtensionForDataType(packet.dataType)}`;
+
+  const [uploadError, uploadedFilename] = await tryCatch(
+    uploadPacketToObjectStore(
+      filename,
+      packet.data,
+      packet.dataType,
+      environment,
+      env.OBJECT_STORE_DEFAULT_PROTOCOL
+    )
+  );
+
+  if (uploadError) {
+    throw new ServiceValidationError("Failed to upload large waitpoint to object store", 500);
+  }
+
+  return {
+    data: uploadedFilename!,
+    dataType: "application/store",
+  };
+}
diff --git a/apps/webapp/app/runEngine/services/batchTrigger.server.ts b/apps/webapp/app/runEngine/services/batchTrigger.server.ts
index bd796f30624..4e504163fec 100644
--- a/apps/webapp/app/runEngine/services/batchTrigger.server.ts
+++ b/apps/webapp/app/runEngine/services/batchTrigger.server.ts
@@ -5,6 +5,7 @@ import {
   type IOPacket,
   packetRequiresOffloading,
   parsePacket,
+  TaskRunErrorCodes,
 } from "@trigger.dev/core/v3";
 import { BatchId, RunId } from "@trigger.dev/core/v3/isomorphic";
 import { type BatchTaskRun, Prisma } from "@trigger.dev/database";
@@ -15,12 +16,11 @@ import { env } from "~/env.server";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { batchTriggerWorker } from "~/v3/batchTriggerWorker.server";
-import { DefaultQueueManager } from "../concerns/queues.server";
-import { DefaultTriggerTaskValidator } from "../validators/triggerTaskValidator";
-import { downloadPacketFromObjectStore, uploadPacketToObjectStore } from "../../v3/r2.server";
+import { downloadPacketFromObjectStore, uploadPacketToObjectStore } from "../../v3/objectStore.server";
 import { ServiceValidationError, WithRunEngine } from "../../v3/services/baseService.server";
 import { TriggerTaskService } from "../../v3/services/triggerTask.server";
 import { startActiveSpan } from "../../v3/tracer.server";
+import { TriggerFailedTaskService } from "./triggerFailedTask.server";
 
 const PROCESSING_BATCH_SIZE = 50;
 const ASYNC_BATCH_PROCESS_SIZE_THRESHOLD = 20;
@@ -48,6 +48,8 @@ export type BatchTriggerTaskServiceOptions = {
   spanParentAsLink?: boolean;
   oneTimeUseToken?: string;
   realtimeStreamsVersion?: "v1" | "v2";
+  triggerSource?: string;
+  triggerAction?: string;
 };
 
 /**
@@ -56,8 +58,6 @@ export type BatchTriggerTaskServiceOptions = {
 export class RunEngineBatchTriggerService extends WithRunEngine {
   private _batchProcessingStrategy: BatchProcessingStrategy;
   public onBatchTaskRunCreated: Evt<BatchTaskRun> = new Evt();
-  private readonly queueConcern: DefaultQueueManager;
-  private readonly validator: DefaultTriggerTaskValidator;
 
   constructor(
     batchProcessingStrategy?: BatchProcessingStrategy,
@@ -65,9 +65,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
   ) {
     super({ prisma });
 
-    this.queueConcern = new DefaultQueueManager(this._prisma, this._engine);
-    this.validator = new DefaultTriggerTaskValidator();
-
     // Eric note: We need to force sequential processing because when doing parallel, we end up with high-contention on the parent run lock
     // becuase we are triggering a lot of runs at once, and each one is trying to lock the parent run.
     // by forcing sequential, we are only ever locking the parent run for a single run at a time.
@@ -88,18 +85,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
 
           span.setAttribute("batchId", friendlyId);
 
-          // Validate entitlement and extract planType for batch runs
-          const entitlementValidation = await this.validator.validateEntitlement({
-            environment,
-          });
-
-          if (!entitlementValidation.ok) {
-            throw entitlementValidation.error;
-          }
-
-          // Extract plan type from entitlement response
-          const planType = entitlementValidation.plan?.type;
-
           // Upload to object store
           const payloadPacket = await this.#handlePayloadPacket(
             body.items,
@@ -112,8 +97,7 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             payloadPacket,
             environment,
             body,
-            options,
-            planType
+            options
           );
 
           if (!batch) {
@@ -166,8 +150,7 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     payloadPacket: IOPacket,
     environment: AuthenticatedEnvironment,
     body: BatchTriggerTaskV2RequestBody,
-    options: BatchTriggerTaskServiceOptions = {},
-    planType?: string
+    options: BatchTriggerTaskServiceOptions = {}
   ) {
     if (body.items.length <= ASYNC_BATCH_PROCESS_SIZE_THRESHOLD) {
       const batch = await this._prisma.batchTaskRun.create({
@@ -206,7 +189,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
         options,
         parentRunId: body.parentRunId,
         resumeParentOnCompletion: body.resumeParentOnCompletion,
-        planType,
       });
 
       switch (result.status) {
@@ -236,7 +218,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: "sequential",
             parentRunId: body.parentRunId,
             resumeParentOnCompletion: body.resumeParentOnCompletion,
-            planType,
           });
 
           return batch;
@@ -259,7 +240,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: "sequential",
             parentRunId: body.parentRunId,
             resumeParentOnCompletion: body.resumeParentOnCompletion,
-            planType,
           });
 
           return batch;
@@ -303,7 +283,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: this._batchProcessingStrategy,
             parentRunId: body.parentRunId,
             resumeParentOnCompletion: body.resumeParentOnCompletion,
-            planType,
           });
 
           break;
@@ -326,7 +305,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
                 strategy: this._batchProcessingStrategy,
                 parentRunId: body.parentRunId,
                 resumeParentOnCompletion: body.resumeParentOnCompletion,
-                planType,
               })
             )
           );
@@ -430,7 +408,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
       options: $options,
       parentRunId: options.parentRunId,
       resumeParentOnCompletion: options.resumeParentOnCompletion,
-      planType: options.planType,
     });
 
     switch (result.status) {
@@ -464,7 +441,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: options.strategy,
             parentRunId: options.parentRunId,
             resumeParentOnCompletion: options.resumeParentOnCompletion,
-            planType: options.planType,
           });
         }
 
@@ -492,7 +468,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: options.strategy,
             parentRunId: options.parentRunId,
             resumeParentOnCompletion: options.resumeParentOnCompletion,
-            planType: options.planType,
           });
         } else {
           await this.#enqueueBatchTaskRun({
@@ -509,7 +484,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
             strategy: options.strategy,
             parentRunId: options.parentRunId,
             resumeParentOnCompletion: options.resumeParentOnCompletion,
-            planType: options.planType,
           });
         }
 
@@ -527,7 +501,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     options,
     parentRunId,
     resumeParentOnCompletion,
-    planType,
   }: {
     batch: BatchTaskRun;
     environment: AuthenticatedEnvironment;
@@ -537,7 +510,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     options?: BatchTriggerTaskServiceOptions;
     parentRunId?: string | undefined;
     resumeParentOnCompletion?: boolean | undefined;
-    planType?: string;
   }): Promise<
     | { status: "COMPLETE" }
     | { status: "INCOMPLETE"; workingIndex: number }
@@ -546,35 +518,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     // Grab the next PROCESSING_BATCH_SIZE items
     const itemsToProcess = items.slice(currentIndex, currentIndex + batchSize);
 
-    const newRunCount = await this.#countNewRuns(environment, itemsToProcess);
-
-    // Only validate queue size if we have new runs to create, i.e. they're not all cached
-    if (newRunCount > 0) {
-      const queueSizeGuard = await this.queueConcern.validateQueueLimits(environment, newRunCount);
-
-      logger.debug("Queue size guard result for chunk", {
-        batchId: batch.friendlyId,
-        currentIndex,
-        runCount: batch.runCount,
-        newRunCount,
-        queueSizeGuard,
-      });
-
-      if (!queueSizeGuard.ok) {
-        return {
-          status: "ERROR",
-          error: `Cannot trigger ${newRunCount} new tasks as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`,
-          workingIndex: currentIndex,
-        };
-      }
-    } else {
-      logger.debug("[RunEngineBatchTrigger][processBatchTaskRun] All runs are cached", {
-        batchId: batch.friendlyId,
-        currentIndex,
-        runCount: batch.runCount,
-      });
-    }
-
     logger.debug("[RunEngineBatchTrigger][processBatchTaskRun] Processing batch items", {
       batchId: batch.friendlyId,
       currentIndex,
@@ -585,7 +528,14 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
 
     let runIds: string[] = [];
 
+    const triggerFailedTaskService = new TriggerFailedTaskService({
+      prisma: this._prisma,
+      engine: this._engine,
+    });
+
     for (const item of itemsToProcess) {
+      let runFriendlyId: string | null = null;
+
       try {
         const run = await this.#processBatchTaskRunItem({
           batch,
@@ -595,34 +545,58 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
           options,
           parentRunId,
           resumeParentOnCompletion,
-          planType,
         });
 
-        if (!run) {
-          logger.error("[RunEngineBatchTrigger][processBatchTaskRun] Failed to process item", {
-            batchId: batch.friendlyId,
-            currentIndex: workingIndex,
-          });
-
-          throw new Error("[RunEngineBatchTrigger][processBatchTaskRun] Failed to process item");
+        if (run) {
+          runFriendlyId = run.friendlyId;
         }
-
-        runIds.push(run.friendlyId);
-
-        workingIndex++;
       } catch (error) {
-        logger.error("[RunEngineBatchTrigger][processBatchTaskRun] Failed to process item", {
+        // Trigger failed - will try to create pre-failed run below
+        runFriendlyId = null;
+      }
+
+      if (!runFriendlyId) {
+        const errorMessage =
+          "Trigger failed for batch item (queue limit, entitlement, or validation error)";
+        logger.debug("[RunEngineBatchTrigger][processBatchTaskRun] Item trigger failed, creating pre-failed run", {
           batchId: batch.friendlyId,
           currentIndex: workingIndex,
-          error,
+          task: item.task,
+        });
+
+        const failedRunId = await triggerFailedTaskService.call({
+          taskId: item.task,
+          environment,
+          payload: item.payload,
+          payloadType: item.options?.payloadType,
+          errorMessage,
+          parentRunId,
+          resumeParentOnCompletion,
+          batch: { id: batch.id, index: workingIndex },
+          options: item.options as Record<string, unknown>,
+          traceContext: options?.traceContext as Record<string, unknown> | undefined,
+          spanParentAsLink: options?.spanParentAsLink,
+          errorCode: TaskRunErrorCodes.BATCH_ITEM_COULD_NOT_TRIGGER,
         });
 
-        return {
-          status: "ERROR",
-          error: error instanceof Error ? error.message : String(error),
-          workingIndex,
-        };
+        if (failedRunId) {
+          runFriendlyId = failedRunId;
+        } else {
+          logger.error("[RunEngineBatchTrigger][processBatchTaskRun] Failed to create pre-failed run", {
+            batchId: batch.friendlyId,
+            currentIndex: workingIndex,
+          });
+
+          return {
+            status: "ERROR",
+            error: "Could not trigger item and could not create pre-failed run",
+            workingIndex,
+          };
+        }
       }
+
+      runIds.push(runFriendlyId);
+      workingIndex++;
     }
 
     //add the run ids to the batch
@@ -671,7 +645,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     options,
     parentRunId,
     resumeParentOnCompletion,
-    planType,
   }: {
     batch: BatchTaskRun;
     environment: AuthenticatedEnvironment;
@@ -680,7 +653,6 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
     options?: BatchTriggerTaskServiceOptions;
     parentRunId: string | undefined;
     resumeParentOnCompletion: boolean | undefined;
-    planType?: string;
   }) {
     logger.debug("[RunEngineBatchTrigger][processBatchTaskRunItem] Processing item", {
       batchId: batch.friendlyId,
@@ -707,9 +679,9 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
         spanParentAsLink: options?.spanParentAsLink,
         batchId: batch.id,
         batchIndex: currentIndex,
-        skipChecks: true, // Skip entitlement and queue checks since we already validated at batch/chunk level
-        planType, // Pass planType from batch-level entitlement check
         realtimeStreamsVersion: options?.realtimeStreamsVersion,
+        triggerSource: options?.triggerSource ?? "api",
+        triggerAction: options?.triggerAction ?? "trigger",
       },
       "V2"
     );
@@ -744,93 +716,12 @@ export class RunEngineBatchTriggerService extends WithRunEngine {
 
       const filename = `${pathPrefix}/payload.json`;
 
-      await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
+      const uploadedFilename = await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
 
       return {
-        data: filename,
+        data: uploadedFilename,
         dataType: "application/store",
       };
     });
   }
-
-  #groupItemsByTaskIdentifier(
-    items: BatchTriggerTaskV2RequestBody["items"]
-  ): Record<string, BatchTriggerTaskV2RequestBody["items"]> {
-    return items.reduce((acc, item) => {
-      if (!item.options?.idempotencyKey) return acc;
-
-      if (!acc[item.task]) {
-        acc[item.task] = [];
-      }
-      acc[item.task].push(item);
-      return acc;
-    }, {} as Record<string, BatchTriggerTaskV2RequestBody["items"]>);
-  }
-
-  async #countNewRuns(
-    environment: AuthenticatedEnvironment,
-    items: BatchTriggerTaskV2RequestBody["items"]
-  ): Promise<number> {
-    // If cached runs check is disabled, return the total number of items
-    if (!env.BATCH_TRIGGER_CACHED_RUNS_CHECK_ENABLED) {
-      return items.length;
-    }
-
-    // Group items by taskIdentifier for efficient lookup
-    const itemsByTask = this.#groupItemsByTaskIdentifier(items);
-
-    // If no items have idempotency keys, all are new runs
-    if (Object.keys(itemsByTask).length === 0) {
-      return items.length;
-    }
-
-    // Fetch cached runs for each task identifier separately to make use of the index
-    const cachedRuns = await Promise.all(
-      Object.entries(itemsByTask).map(([taskIdentifier, taskItems]) =>
-        this._prisma.taskRun.findMany({
-          where: {
-            runtimeEnvironmentId: environment.id,
-            taskIdentifier,
-            idempotencyKey: {
-              in: taskItems.map((i) => i.options?.idempotencyKey).filter(Boolean),
-            },
-          },
-          select: {
-            idempotencyKey: true,
-            idempotencyKeyExpiresAt: true,
-          },
-        })
-      )
-    ).then((results) => results.flat());
-
-    // Create a Map for O(1) lookups instead of O(m) find operations
-    const cachedRunsMap = new Map(cachedRuns.map((run) => [run.idempotencyKey, run]));
-
-    // Count items that are NOT cached (or have expired cache)
-    let newRunCount = 0;
-    const now = new Date();
-
-    for (const item of items) {
-      const idempotencyKey = item.options?.idempotencyKey;
-
-      if (!idempotencyKey) {
-        // No idempotency key = always a new run
-        newRunCount++;
-        continue;
-      }
-
-      const cachedRun = cachedRunsMap.get(idempotencyKey);
-
-      if (!cachedRun) {
-        // No cached run = new run
-        newRunCount++;
-      } else if (cachedRun.idempotencyKeyExpiresAt && cachedRun.idempotencyKeyExpiresAt < now) {
-        // Expired cached run = new run
-        newRunCount++;
-      }
-      // else: valid cached run = not a new run
-    }
-
-    return newRunCount;
-  }
 }
diff --git a/apps/webapp/app/runEngine/services/createBatch.server.ts b/apps/webapp/app/runEngine/services/createBatch.server.ts
index 9dc107321cc..309a7700f1a 100644
--- a/apps/webapp/app/runEngine/services/createBatch.server.ts
+++ b/apps/webapp/app/runEngine/services/createBatch.server.ts
@@ -17,6 +17,7 @@ export type CreateBatchServiceOptions = {
   spanParentAsLink?: boolean;
   oneTimeUseToken?: string;
   realtimeStreamsVersion?: "v1" | "v2";
+  triggerSource?: string;
 };
 
 /**
@@ -90,17 +91,8 @@ export class CreateBatchService extends WithRunEngine {
             );
           }
 
-          // Validate queue limits for the expected batch size
-          const queueSizeGuard = await this.queueConcern.validateQueueLimits(
-            environment,
-            body.runCount
-          );
-
-          if (!queueSizeGuard.ok) {
-            throw new ServiceValidationError(
-              `Cannot create batch with ${body.runCount} items as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`
-            );
-          }
+          // Note: Queue size limits are validated per-queue when batch items are processed,
+          // since we don't know which queues items will go to until they're streamed.
 
           // Create BatchTaskRun in Postgres with PENDING status
           // The batch will be sealed (status -> PROCESSING) when items are streamed
@@ -152,6 +144,7 @@ export class CreateBatchService extends WithRunEngine {
             idempotencyKey: body.idempotencyKey,
             processingConcurrency: config.processingConcurrency,
             planType,
+            triggerSource: options.triggerSource,
           };
 
           await this._engine.initializeBatch(initOptions);
diff --git a/apps/webapp/app/runEngine/services/streamBatchItems.server.ts b/apps/webapp/app/runEngine/services/streamBatchItems.server.ts
index 6fab01341c1..859dfe2e6b9 100644
--- a/apps/webapp/app/runEngine/services/streamBatchItems.server.ts
+++ b/apps/webapp/app/runEngine/services/streamBatchItems.server.ts
@@ -1,5 +1,4 @@
 import {
-  type BatchItemNDJSON,
   type StreamBatchItemsResponse,
   BatchItemNDJSON as BatchItemNDJSONSchema,
 } from "@trigger.dev/core/v3";
@@ -15,6 +14,14 @@ export type StreamBatchItemsServiceOptions = {
   maxItemBytes: number;
 };
 
+export type OversizedItemMarker = {
+  __batchItemError: "OVERSIZED";
+  index: number;
+  task: string;
+  actualSize: number;
+  maxSize: number;
+};
+
 export type StreamBatchItemsServiceConstructorOptions = {
   prisma?: PrismaClientOrTransaction;
   engine?: RunEngine;
@@ -111,6 +118,41 @@ export class StreamBatchItemsService extends WithRunEngine {
 
         // Process items from the stream
         for await (const rawItem of itemsIterator) {
+          // Check for oversized item markers from the NDJSON parser
+          if (rawItem && typeof rawItem === "object" && "__batchItemError" in rawItem) {
+            const marker = rawItem as OversizedItemMarker;
+            const itemIndex = marker.index >= 0 ? marker.index : lastIndex + 1;
+
+            const errorMessage = `Batch item payload is too large (${(marker.actualSize / 1024).toFixed(1)} KB). Maximum allowed size is ${(marker.maxSize / 1024).toFixed(1)} KB. Reduce the payload size or offload large data to external storage.`;
+
+            // Enqueue with __error metadata - processItemCallback will detect this
+            // and use TriggerFailedTaskService to create a pre-failed run
+            const batchItem: BatchItem = {
+              task: marker.task,
+              payload: "{}",
+              payloadType: "application/json",
+              options: {
+                __error: errorMessage,
+                __errorCode: "PAYLOAD_TOO_LARGE",
+              },
+            };
+
+            const result = await this._engine.enqueueBatchItem(
+              batchId,
+              environment.id,
+              itemIndex,
+              batchItem
+            );
+
+            if (result.enqueued) {
+              itemsAccepted++;
+            } else {
+              itemsDeduplicated++;
+            }
+            lastIndex = itemIndex;
+            continue;
+          }
+
           // Parse and validate the item
           const parseResult = BatchItemNDJSONSchema.safeParse(rawItem);
           if (!parseResult.success) {
@@ -169,6 +211,34 @@ export class StreamBatchItemsService extends WithRunEngine {
 
         // Validate we received the expected number of items
         if (enqueuedCount !== batch.runCount) {
+          // The batch queue consumers may have already processed all items and
+          // cleaned up the Redis keys before we got here (especially likely when
+          // items include pre-failed runs that complete instantly). Check if the
+          // batch was already sealed/completed in Postgres.
+          const currentBatch = await this._prisma.batchTaskRun.findUnique({
+            where: { id: batchId },
+            select: { sealed: true, status: true },
+          });
+
+          if (currentBatch?.sealed) {
+            logger.info("Batch already sealed before count check (fast completion)", {
+              batchId: batchFriendlyId,
+              itemsAccepted,
+              itemsDeduplicated,
+              enqueuedCount,
+              expectedCount: batch.runCount,
+              batchStatus: currentBatch.status,
+            });
+
+            return {
+              id: batchFriendlyId,
+              itemsAccepted,
+              itemsDeduplicated,
+              sealed: true,
+              runCount: batch.runCount,
+            };
+          }
+
           logger.warn("Batch item count mismatch", {
             batchId: batchFriendlyId,
             expected: batch.runCount,
@@ -186,6 +256,7 @@ export class StreamBatchItemsService extends WithRunEngine {
             sealed: false,
             enqueuedCount,
             expectedCount: batch.runCount,
+            runCount: batch.runCount,
           };
         }
 
@@ -237,6 +308,7 @@ export class StreamBatchItemsService extends WithRunEngine {
               itemsAccepted,
               itemsDeduplicated,
               sealed: true,
+              runCount: batch.runCount,
             };
           }
 
@@ -273,12 +345,128 @@ export class StreamBatchItemsService extends WithRunEngine {
           itemsAccepted,
           itemsDeduplicated,
           sealed: true,
+          runCount: batch.runCount,
         };
       }
     );
   }
 }
 
+/**
+ * Extract `index` and `task` from raw JSON bytes without decoding the full line.
+ * Scans at most 512 bytes, tracking JSON nesting depth to only match top-level keys.
+ */
+export function extractIndexAndTask(bytes: Uint8Array): { index: number; task: string } {
+  let index = -1;
+  let task = "unknown";
+  let depth = 0;
+  let foundIndex = false;
+  let foundTask = false;
+  const limit = Math.min(bytes.byteLength, 512);
+
+  const QUOTE = 0x22; // "
+  const COLON = 0x3a; // :
+  const LBRACE = 0x7b; // {
+  const RBRACE = 0x7d; // }
+  const LBRACKET = 0x5b; // [
+  const RBRACKET = 0x5d; // ]
+  const BACKSLASH = 0x5c; // \
+
+  // Byte patterns for "index" and "task" (without quotes)
+  const INDEX_BYTES = [0x69, 0x6e, 0x64, 0x65, 0x78]; // index
+  const TASK_BYTES = [0x74, 0x61, 0x73, 0x6b]; // task
+
+  let i = 0;
+  while (i < limit && !(foundIndex && foundTask)) {
+    const b = bytes[i];
+
+    if (b === LBRACE || b === LBRACKET) {
+      depth++;
+      i++;
+      continue;
+    }
+    if (b === RBRACE || b === RBRACKET) {
+      depth--;
+      i++;
+      continue;
+    }
+
+    // Only match keys at depth 1 (top-level object)
+    if (b === QUOTE && depth === 1) {
+      // Read the key inside quotes
+      const keyStart = i + 1;
+      let keyEnd = keyStart;
+      while (keyEnd < limit && bytes[keyEnd] !== QUOTE) {
+        if (bytes[keyEnd] === BACKSLASH) keyEnd++; // skip escaped char
+        keyEnd++;
+      }
+
+      const keyLen = keyEnd - keyStart;
+
+      // Check if this key matches "index" or "task"
+      const isIndex =
+        !foundIndex &&
+        keyLen === INDEX_BYTES.length &&
+        INDEX_BYTES.every((b, j) => bytes[keyStart + j] === b);
+      const isTask =
+        !foundTask &&
+        keyLen === TASK_BYTES.length &&
+        TASK_BYTES.every((b, j) => bytes[keyStart + j] === b);
+
+      if (isIndex || isTask) {
+        // Skip past closing quote and find colon
+        let pos = keyEnd + 1;
+        while (pos < limit && bytes[pos] !== COLON) pos++;
+        pos++; // skip colon
+        // Skip whitespace
+        while (pos < limit && (bytes[pos] === 0x20 || bytes[pos] === 0x09)) pos++;
+
+        if (isIndex) {
+          // Parse digits
+          let num = 0;
+          let hasDigit = false;
+          while (pos < limit && bytes[pos] >= 0x30 && bytes[pos] <= 0x39) {
+            num = num * 10 + (bytes[pos] - 0x30);
+            hasDigit = true;
+            pos++;
+          }
+          if (hasDigit) {
+            index = num;
+            foundIndex = true;
+          }
+        } else {
+          // Parse quoted string value
+          if (pos < limit && bytes[pos] === QUOTE) {
+            const valStart = pos + 1;
+            let valEnd = valStart;
+            while (valEnd < limit && bytes[valEnd] !== QUOTE) {
+              if (bytes[valEnd] === BACKSLASH) valEnd++;
+              valEnd++;
+            }
+            // Decode just this slice
+            try {
+              task = new TextDecoder("utf-8", { fatal: true }).decode(
+                bytes.slice(valStart, valEnd)
+              );
+              foundTask = true;
+            } catch {
+              // Leave as "unknown"
+            }
+          }
+        }
+      }
+
+      // Skip past the key's closing quote
+      i = keyEnd + 1;
+      continue;
+    }
+
+    i++;
+  }
+
+  return { index, task };
+}
+
 /**
  * Create an NDJSON parser transform stream.
  *
@@ -303,6 +491,9 @@ export function createNdjsonParserStream(
   let chunks: Uint8Array[] = [];
   let totalBytes = 0;
   let lineNumber = 0;
+  // When an oversized incomplete line is detected (Case 2), we must discard
+  // all remaining bytes of that line until the next newline delimiter.
+  let skipUntilNewline = false;
 
   const NEWLINE_BYTE = 0x0a; // '\n'
 
@@ -396,6 +587,24 @@ export function createNdjsonParserStream(
 
   return new TransformStream<Uint8Array, unknown>({
     transform(chunk, controller) {
+      // If we're skipping the remainder of an oversized line, scan for the
+      // next newline in this chunk and discard everything before it.
+      if (skipUntilNewline) {
+        const nlPos = chunk.indexOf(NEWLINE_BYTE);
+        if (nlPos === -1) {
+          // Entire chunk is still part of the oversized line — discard it
+          return;
+        }
+        // Found the newline — keep everything after it
+        skipUntilNewline = false;
+        const remaining = chunk.slice(nlPos + 1);
+        if (remaining.byteLength === 0) {
+          return;
+        }
+        // Replace chunk with the remainder and fall through to normal processing
+        chunk = remaining;
+      }
+
       // Append chunk to buffer
       chunks.push(chunk);
       totalBytes += chunk.byteLength;
@@ -405,11 +614,19 @@ export function createNdjsonParserStream(
       while ((newlineIndex = findNewlineIndex()) !== -1) {
         // Check size limit BEFORE extracting/decoding (bytes up to newline)
         if (newlineIndex > maxItemBytes) {
-          throw new Error(
-            `Item at line ${
-              lineNumber + 1
-            } exceeds maximum size of ${maxItemBytes} bytes (actual: ${newlineIndex})`
-          );
+          // Case 1: Complete line exceeds limit - emit marker instead of throwing
+          const lineBytes = extractLine(newlineIndex);
+          const extracted = extractIndexAndTask(lineBytes);
+          const marker: OversizedItemMarker = {
+            __batchItemError: "OVERSIZED",
+            index: extracted.index,
+            task: extracted.task,
+            actualSize: newlineIndex,
+            maxSize: maxItemBytes,
+          };
+          controller.enqueue(marker);
+          lineNumber++;
+          continue;
         }
 
         const lineBytes = extractLine(newlineIndex);
@@ -419,11 +636,23 @@ export function createNdjsonParserStream(
       // Check if the remaining buffer (incomplete line) exceeds the limit
       // This prevents OOM from a single huge line without newlines
       if (totalBytes > maxItemBytes) {
-        throw new Error(
-          `Item at line ${
-            lineNumber + 1
-          } exceeds maximum size of ${maxItemBytes} bytes (buffered: ${totalBytes}, no newline found)`
-        );
+        // Case 2: Incomplete line exceeds limit - emit marker instead of throwing
+        const extracted = extractIndexAndTask(concatenateChunks());
+        const marker: OversizedItemMarker = {
+          __batchItemError: "OVERSIZED",
+          index: extracted.index,
+          task: extracted.task,
+          actualSize: totalBytes,
+          maxSize: maxItemBytes,
+        };
+        controller.enqueue(marker);
+        lineNumber++;
+        // Clear buffer and skip remaining bytes of this oversized line
+        // until the next newline delimiter is found in a subsequent chunk
+        chunks = [];
+        totalBytes = 0;
+        skipUntilNewline = true;
+        return;
       }
     },
 
@@ -439,11 +668,17 @@ export function createNdjsonParserStream(
 
       // Check size limit before processing final line
       if (totalBytes > maxItemBytes) {
-        throw new Error(
-          `Item at line ${
-            lineNumber + 1
-          } exceeds maximum size of ${maxItemBytes} bytes (actual: ${totalBytes})`
-        );
+        // Case 3: Flush with oversized remaining - emit marker instead of throwing
+        const extracted = extractIndexAndTask(concatenateChunks());
+        const marker: OversizedItemMarker = {
+          __batchItemError: "OVERSIZED",
+          index: extracted.index,
+          task: extracted.task,
+          actualSize: totalBytes,
+          maxSize: maxItemBytes,
+        };
+        controller.enqueue(marker);
+        return;
       }
 
       const finalBytes = concatenateChunks();
diff --git a/apps/webapp/app/runEngine/services/triggerFailedTask.server.ts b/apps/webapp/app/runEngine/services/triggerFailedTask.server.ts
new file mode 100644
index 00000000000..cdcfa63ff0b
--- /dev/null
+++ b/apps/webapp/app/runEngine/services/triggerFailedTask.server.ts
@@ -0,0 +1,297 @@
+import { RunEngine } from "@internal/run-engine";
+import { TaskRunErrorCodes, type TaskRunError } from "@trigger.dev/core/v3";
+import { RunId } from "@trigger.dev/core/v3/isomorphic";
+import type { RuntimeEnvironmentType, TaskRun } from "@trigger.dev/database";
+import type { PrismaClientOrTransaction } from "@trigger.dev/database";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { logger } from "~/services/logger.server";
+import { getEventRepository } from "~/v3/eventRepository/index.server";
+import { DefaultQueueManager } from "../concerns/queues.server";
+import type { TriggerTaskRequest } from "../types";
+
+export type TriggerFailedTaskRequest = {
+  /** The task identifier (e.g. "my-task") */
+  taskId: string;
+  /** The fully-resolved authenticated environment */
+  environment: AuthenticatedEnvironment;
+  /** Raw payload — string or object */
+  payload: unknown;
+  /** MIME type of the payload (defaults to "application/json") */
+  payloadType?: string;
+  /** Error message describing why the run failed */
+  errorMessage: string;
+  /** Parent run friendly ID (e.g. "run_xxxx") */
+  parentRunId?: string;
+  /** Whether completing this run should resume the parent */
+  resumeParentOnCompletion?: boolean;
+  /** Batch association */
+  batch?: { id: string; index: number };
+  /** Trigger options from the original request (queue config, etc.) */
+  options?: Record<string, unknown>;
+  /** Trace context for span correlation */
+  traceContext?: Record<string, unknown>;
+  /** Whether the span parent should be treated as a link rather than a parent */
+  spanParentAsLink?: boolean;
+
+  errorCode?: TaskRunErrorCodes;
+};
+
+/**
+ * Creates a pre-failed TaskRun with a trace event span.
+ *
+ * This is used when a task cannot be triggered (e.g. queue limit reached, validation
+ * error, etc.) but we still need to record the failure so that:
+ * - Batch completion can track the item
+ * - Parent runs get unblocked
+ * - The failed run shows up in the run logs view
+ *
+ * This service resolves the parent run (for rootTaskRunId/depth) and queue properties
+ * the same way triggerTask does, so the run is correctly associated in the task tree
+ * and the SpanPresenter can find the TaskQueue.
+ */
+export class TriggerFailedTaskService {
+  private readonly prisma: PrismaClientOrTransaction;
+  private readonly engine: RunEngine;
+
+  constructor(opts: { prisma: PrismaClientOrTransaction; engine: RunEngine }) {
+    this.prisma = opts.prisma;
+    this.engine = opts.engine;
+  }
+
+  async call(request: TriggerFailedTaskRequest): Promise<string | null> {
+    const failedRunFriendlyId = RunId.generate().friendlyId;
+    const taskRunError: TaskRunError = {
+      type: "INTERNAL_ERROR" as const,
+      code: request.errorCode ?? TaskRunErrorCodes.UNSPECIFIED_ERROR,
+      message: request.errorMessage,
+    };
+
+    try {
+      const { repository, store } = await getEventRepository(
+        request.environment.organization.featureFlags as Record<string, unknown>,
+        undefined
+      );
+
+      // Resolve parent run for rootTaskRunId and depth (same as triggerTask.server.ts)
+      const parentRun = request.parentRunId
+        ? await this.prisma.taskRun.findFirst({
+          where: {
+            id: RunId.fromFriendlyId(request.parentRunId),
+            runtimeEnvironmentId: request.environment.id,
+          },
+        })
+        : undefined;
+
+      const depth = parentRun ? parentRun.depth + 1 : 0;
+      const rootTaskRunId = parentRun?.rootTaskRunId ?? parentRun?.id;
+
+      // Resolve queue properties (same as triggerTask) so span presenter can find TaskQueue.
+      // Best-effort: if resolution throws (e.g. request shape, missing worker), we still create
+      // the run without queue/lockedQueueId so run creation and trace events never regress.
+      let queueName: string | undefined;
+      let lockedQueueId: string | undefined;
+      try {
+        const queueConcern = new DefaultQueueManager(this.prisma, this.engine);
+        const bodyOptions = request.options as TriggerTaskRequest["body"]["options"];
+        const triggerRequest: TriggerTaskRequest = {
+          taskId: request.taskId,
+          friendlyId: failedRunFriendlyId,
+          environment: request.environment,
+          body: {
+            payload:
+              typeof request.payload === "string"
+                ? request.payload
+                : JSON.stringify(request.payload ?? {}),
+            options: bodyOptions,
+          },
+        };
+
+        // Resolve the locked background worker if lockToVersion is set (same as triggerTask).
+        // resolveQueueProperties requires the worker to be passed when lockToVersion is present.
+        const lockedToBackgroundWorker = bodyOptions?.lockToVersion
+          ? await this.prisma.backgroundWorker.findFirst({
+            where: {
+              projectId: request.environment.projectId,
+              runtimeEnvironmentId: request.environment.id,
+              version: bodyOptions.lockToVersion,
+            },
+            select: {
+              id: true,
+              version: true,
+              sdkVersion: true,
+              cliVersion: true,
+            },
+          })
+          : undefined;
+
+        const resolved = await queueConcern.resolveQueueProperties(
+          triggerRequest,
+          lockedToBackgroundWorker ?? undefined
+        );
+        queueName = resolved.queueName;
+        lockedQueueId = resolved.lockedQueueId;
+      } catch (queueResolveError) {
+        const err =
+          queueResolveError instanceof Error
+            ? queueResolveError
+            : new Error(String(queueResolveError));
+        logger.warn("TriggerFailedTaskService: queue resolution failed, using defaults", {
+          taskId: request.taskId,
+          friendlyId: failedRunFriendlyId,
+          error: err.message,
+        });
+      }
+
+      // Create the failed run inside a trace event span so it shows up in run logs
+      const failedRun: TaskRun = await repository.traceEvent(
+        request.taskId,
+        {
+          context: request.traceContext,
+          spanParentAsLink: request.spanParentAsLink,
+          kind: "SERVER",
+          environment: {
+            id: request.environment.id,
+            type: request.environment.type,
+            organizationId: request.environment.organizationId,
+            projectId: request.environment.projectId,
+            project: { externalRef: request.environment.project.externalRef },
+          },
+          taskSlug: request.taskId,
+          attributes: {
+            properties: {},
+            style: { icon: "task" },
+          },
+          incomplete: false,
+          isError: true,
+          immediate: true,
+        },
+        async (event, traceContext) => {
+          event.setAttribute("runId", failedRunFriendlyId);
+          event.failWithError(taskRunError);
+
+          return await this.engine.createFailedTaskRun({
+            friendlyId: failedRunFriendlyId,
+            environment: {
+              id: request.environment.id,
+              type: request.environment.type,
+              project: { id: request.environment.project.id },
+              organization: { id: request.environment.organization.id },
+            },
+            taskIdentifier: request.taskId,
+            payload:
+              typeof request.payload === "string"
+                ? request.payload
+                : JSON.stringify(request.payload ?? ""),
+            payloadType: request.payloadType ?? "application/json",
+            error: taskRunError,
+            parentTaskRunId: parentRun?.id,
+            rootTaskRunId,
+            depth,
+            resumeParentOnCompletion: request.resumeParentOnCompletion,
+            batch: request.batch,
+            traceId: event.traceId,
+            spanId: event.spanId,
+            traceContext: traceContext as Record<string, unknown>,
+            taskEventStore: store,
+            ...(queueName !== undefined && { queue: queueName }),
+            ...(lockedQueueId !== undefined && { lockedQueueId }),
+          });
+        }
+      );
+
+      return failedRun.friendlyId;
+    } catch (createError) {
+      const createErrorMsg =
+        createError instanceof Error ? createError.message : String(createError);
+      logger.error("TriggerFailedTaskService: failed to create pre-failed TaskRun", {
+        taskId: request.taskId,
+        friendlyId: failedRunFriendlyId,
+        originalError: request.errorMessage,
+        createError: createErrorMsg,
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Creates a pre-failed run without trace events.
+   * Used when the environment can't be fully resolved (e.g. environment not found)
+   * and we can't create trace events or look up parent runs.
+   */
+  async callWithoutTraceEvents(opts: {
+    environmentId: string;
+    environmentType: RuntimeEnvironmentType;
+    projectId: string;
+    organizationId: string;
+    taskId: string;
+    payload: unknown;
+    payloadType?: string;
+    errorMessage: string;
+    parentRunId?: string;
+    resumeParentOnCompletion?: boolean;
+    batch?: { id: string; index: number };
+    errorCode?: TaskRunErrorCodes;
+  }): Promise<string | null> {
+    const failedRunFriendlyId = RunId.generate().friendlyId;
+
+    try {
+      // Best-effort parent run lookup for rootTaskRunId/depth
+      let parentTaskRunId: string | undefined;
+      let rootTaskRunId: string | undefined;
+      let depth = 0;
+
+      if (opts.parentRunId) {
+        const parentRun = await this.prisma.taskRun.findFirst({
+          where: {
+            id: RunId.fromFriendlyId(opts.parentRunId),
+            runtimeEnvironmentId: opts.environmentId,
+          },
+        });
+
+        if (parentRun) {
+          parentTaskRunId = parentRun.id;
+          rootTaskRunId = parentRun.rootTaskRunId ?? parentRun.id;
+          depth = parentRun.depth + 1;
+        } else {
+          parentTaskRunId = RunId.fromFriendlyId(opts.parentRunId);
+        }
+      }
+
+      await this.engine.createFailedTaskRun({
+        friendlyId: failedRunFriendlyId,
+        environment: {
+          id: opts.environmentId,
+          type: opts.environmentType,
+          project: { id: opts.projectId },
+          organization: { id: opts.organizationId },
+        },
+        taskIdentifier: opts.taskId,
+        payload:
+          typeof opts.payload === "string"
+            ? opts.payload
+            : JSON.stringify(opts.payload ?? ""),
+        payloadType: opts.payloadType ?? "application/json",
+        error: {
+          type: "INTERNAL_ERROR" as const,
+          code: opts.errorCode ?? TaskRunErrorCodes.UNSPECIFIED_ERROR,
+          message: opts.errorMessage,
+        },
+        parentTaskRunId,
+        rootTaskRunId,
+        depth,
+        resumeParentOnCompletion: opts.resumeParentOnCompletion,
+        batch: opts.batch,
+      });
+
+      return failedRunFriendlyId;
+    } catch (createError) {
+      logger.error("TriggerFailedTaskService: failed to create pre-failed TaskRun (no trace)", {
+        taskId: opts.taskId,
+        friendlyId: failedRunFriendlyId,
+        originalError: opts.errorMessage,
+        createError: createError instanceof Error ? createError.message : String(createError),
+      });
+      return null;
+    }
+  }
+}
diff --git a/apps/webapp/app/runEngine/services/triggerTask.server.ts b/apps/webapp/app/runEngine/services/triggerTask.server.ts
index ab326828119..c8a6dca2c93 100644
--- a/apps/webapp/app/runEngine/services/triggerTask.server.ts
+++ b/apps/webapp/app/runEngine/services/triggerTask.server.ts
@@ -6,6 +6,7 @@ import {
 import { Tracer } from "@opentelemetry/api";
 import { tryCatch } from "@trigger.dev/core/utils";
 import {
+  RunAnnotations,
   TaskRunError,
   taskRunErrorEnhancer,
   taskRunErrorToString,
@@ -190,11 +191,6 @@ export class RunEngineTriggerTaskService {
         }
       }
 
-      const ttl =
-        typeof body.options?.ttl === "number"
-          ? stringifyDuration(body.options?.ttl)
-          : body.options?.ttl ?? (environment.type === "DEVELOPMENT" ? "10m" : undefined);
-
       // Get parent run if specified
       const parentRun = body.options?.parentRunId
         ? await this.prisma.taskRun.findFirst({
@@ -234,24 +230,6 @@ export class RunEngineTriggerTaskService {
         });
       }
 
-      if (!options.skipChecks) {
-        const queueSizeGuard = await this.queueConcern.validateQueueLimits(environment);
-
-        if (!queueSizeGuard.ok) {
-          throw new ServiceValidationError(
-            `Cannot trigger ${taskId} as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`
-          );
-        }
-      }
-
-      const metadataPacket = body.options?.metadata
-        ? handleMetadataPacket(
-            body.options?.metadata,
-            body.options?.metadataType ?? "application/json",
-            this.metadataMaximumSize
-          )
-        : undefined;
-
       const lockedToBackgroundWorker = body.options?.lockToVersion
         ? await this.prisma.backgroundWorker.findFirst({
             where: {
@@ -268,10 +246,46 @@ export class RunEngineTriggerTaskService {
           })
         : undefined;
 
-      const { queueName, lockedQueueId } = await this.queueConcern.resolveQueueProperties(
-        triggerRequest,
-        lockedToBackgroundWorker ?? undefined
-      );
+      const { queueName, lockedQueueId, taskTtl } =
+        await this.queueConcern.resolveQueueProperties(
+          triggerRequest,
+          lockedToBackgroundWorker ?? undefined
+        );
+
+      // Resolve TTL with precedence: per-trigger > task-level > dev default
+      let ttl: string | undefined;
+
+      if (body.options?.ttl !== undefined) {
+        ttl =
+          typeof body.options.ttl === "number"
+            ? stringifyDuration(body.options.ttl)
+            : body.options.ttl;
+      } else {
+        ttl = taskTtl ?? (environment.type === "DEVELOPMENT" ? "10m" : undefined);
+      }
+
+      if (!options.skipChecks) {
+        const queueSizeGuard = await this.queueConcern.validateQueueLimits(
+          environment,
+          queueName
+        );
+
+        if (!queueSizeGuard.ok) {
+          throw new ServiceValidationError(
+            `Cannot trigger ${taskId} as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`,
+            undefined,
+            "warn"
+          );
+        }
+      }
+
+      const metadataPacket = body.options?.metadata
+        ? handleMetadataPacket(
+            body.options?.metadata,
+            body.options?.metadataType ?? "application/json",
+            this.metadataMaximumSize
+          )
+        : undefined;
 
       //upsert tags
       const tags = await createTags(
@@ -284,7 +298,23 @@ export class RunEngineTriggerTaskService {
 
       const depth = parentRun ? parentRun.depth + 1 : 0;
 
-      const workerQueue = await this.queueConcern.getWorkerQueue(environment, body.options?.region);
+      const workerQueueResult = await this.queueConcern.getWorkerQueue(
+        environment,
+        body.options?.region
+      );
+      const workerQueue = workerQueueResult?.masterQueue;
+      const enableFastPath = workerQueueResult?.enableFastPath ?? false;
+
+      // Build annotations for this run
+      const triggerSource = options.triggerSource ?? "api";
+      const triggerAction = options.triggerAction ?? "trigger";
+      const parentAnnotations = RunAnnotations.safeParse(parentRun?.annotations).data;
+      const annotations = {
+        triggerSource,
+        triggerAction,
+        rootTriggerSource: parentAnnotations?.rootTriggerSource ?? triggerSource,
+        rootScheduleId: parentAnnotations?.rootScheduleId || options.scheduleId || undefined,
+      };
 
       try {
         return await this.traceEventConcern.traceRun(
@@ -304,6 +334,7 @@ export class RunEngineTriggerTaskService {
                 environment: environment,
                 idempotencyKey,
                 idempotencyKeyExpiresAt: idempotencyKey ? idempotencyKeyExpiresAt : undefined,
+                idempotencyKeyOptions: body.options?.idempotencyKeyOptions,
                 taskIdentifier: taskId,
                 payload: payloadPacket.data ?? "",
                 payloadType: payloadPacket.dataType,
@@ -326,6 +357,7 @@ export class RunEngineTriggerTaskService {
                 queue: queueName,
                 lockedQueueId,
                 workerQueue,
+                enableFastPath,
                 isTest: body.options?.test ?? false,
                 delayUntil,
                 queuedAt: delayUntil ? undefined : new Date(),
@@ -365,6 +397,7 @@ export class RunEngineTriggerTaskService {
                 planType,
                 realtimeStreamsVersion: options.realtimeStreamsVersion,
                 debounce: body.options?.debounce,
+                annotations,
                 // When debouncing with triggerAndWait, create a span for the debounced trigger
                 onDebounced:
                   body.options?.debounce && body.options?.resumeParentOnCompletion
diff --git a/apps/webapp/app/runEngine/types.ts b/apps/webapp/app/runEngine/types.ts
index 7186d81ff9b..d5e61d01889 100644
--- a/apps/webapp/app/runEngine/types.ts
+++ b/apps/webapp/app/runEngine/types.ts
@@ -48,6 +48,7 @@ export type QueueValidationResult =
 export type QueueProperties = {
   queueName: string;
   lockedQueueId?: string;
+  taskTtl?: string | null;
 };
 
 export type LockedBackgroundWorker = Pick<
@@ -61,15 +62,15 @@ export interface QueueManager {
     request: TriggerTaskRequest,
     lockedBackgroundWorker?: LockedBackgroundWorker
   ): Promise<QueueProperties>;
-  getQueueName(request: TriggerTaskRequest): Promise<string>;
   validateQueueLimits(
     env: AuthenticatedEnvironment,
+    queueName: string,
     itemsToAdd?: number
   ): Promise<QueueValidationResult>;
   getWorkerQueue(
     env: AuthenticatedEnvironment,
     regionOverride?: string
-  ): Promise<string | undefined>;
+  ): Promise<{ masterQueue: string; enableFastPath: boolean } | undefined>;
 }
 
 export interface PayloadProcessor {
diff --git a/apps/webapp/app/services/admin/missingLlmModels.server.ts b/apps/webapp/app/services/admin/missingLlmModels.server.ts
new file mode 100644
index 00000000000..7ce6bc2ab7e
--- /dev/null
+++ b/apps/webapp/app/services/admin/missingLlmModels.server.ts
@@ -0,0 +1,129 @@
+import { adminClickhouseClient } from "~/services/clickhouseInstance.server";
+import { llmPricingRegistry } from "~/v3/llmPricingRegistry.server";
+
+export type MissingLlmModel = {
+  model: string;
+  system: string;
+  count: number;
+};
+
+export async function getMissingLlmModels(opts: {
+  lookbackHours?: number;
+} = {}): Promise<MissingLlmModel[]> {
+  const lookbackHours = opts.lookbackHours ?? 24;
+  const since = new Date(Date.now() - lookbackHours * 60 * 60 * 1000);
+
+  // queryBuilderFast returns a factory function — call it to get the builder
+  const createBuilder = adminClickhouseClient.reader.queryBuilderFast<{
+    model: string;
+    system: string;
+    cnt: string;
+  }>({
+    name: "missingLlmModels",
+    table: "trigger_dev.task_events_v2",
+    columns: [
+      { name: "model", expression: "attributes.gen_ai.response.model.:String" },
+      { name: "system", expression: "attributes.gen_ai.system.:String" },
+      { name: "cnt", expression: "count()" },
+    ],
+  });
+  const qb = createBuilder();
+
+  // Partition pruning on inserted_at (partition key is toDate(inserted_at))
+  qb.where("inserted_at >= {since: DateTime64(3)}", {
+    since: formatDateTime(since),
+  });
+
+  // Only spans that have a model set
+  qb.where("attributes.gen_ai.response.model.:String != {empty: String}", { empty: "" });
+
+  // Only spans that were NOT cost-enriched (trigger.llm.total_cost is NULL)
+  qb.where("attributes.trigger.llm.total_cost.:Float64 IS NULL", {});
+
+  // Only completed spans
+  qb.where("kind = {kind: String}", { kind: "SPAN" });
+  qb.where("status = {status: String}", { status: "OK" });
+
+  qb.groupBy("model, system");
+  qb.orderBy("cnt DESC");
+  qb.limit(100);
+
+  const [err, rows] = await qb.execute();
+
+  if (err) {
+    throw err;
+  }
+
+  if (!rows) {
+    return [];
+  }
+
+  const candidates = rows
+    .filter((r) => r.model)
+    .map((r) => ({
+      model: r.model,
+      system: r.system,
+      count: parseInt(r.cnt, 10),
+    }));
+
+  if (candidates.length === 0) return [];
+
+  // Filter out models that now have pricing in the database (added after spans were inserted).
+  // The registry's match() handles prefix stripping for gateway/openrouter models.
+  if (!llmPricingRegistry || !llmPricingRegistry.isLoaded) return candidates;
+  const registry = llmPricingRegistry;
+  return candidates.filter((c) => !registry.match(c.model));
+}
+
+export type MissingModelSample = {
+  span_id: string;
+  run_id: string;
+  message: string;
+  attributes_text: string;
+  duration: string;
+  start_time: string;
+};
+
+export async function getMissingModelSamples(opts: {
+  model: string;
+  lookbackHours?: number;
+  limit?: number;
+}): Promise<MissingModelSample[]> {
+  const lookbackHours = opts.lookbackHours ?? 24;
+  const limit = opts.limit ?? 10;
+  const since = new Date(Date.now() - lookbackHours * 60 * 60 * 1000);
+
+  const createBuilder = adminClickhouseClient.reader.queryBuilderFast<MissingModelSample>({
+    name: "missingModelSamples",
+    table: "trigger_dev.task_events_v2",
+    columns: [
+      "span_id",
+      "run_id",
+      "message",
+      "attributes_text",
+      "duration",
+      "start_time",
+    ],
+  });
+  const qb = createBuilder();
+
+  qb.where("inserted_at >= {since: DateTime64(3)}", { since: formatDateTime(since) });
+  qb.where("attributes.gen_ai.response.model.:String = {model: String}", { model: opts.model });
+  qb.where("attributes.trigger.llm.total_cost.:Float64 IS NULL", {});
+  qb.where("kind = {kind: String}", { kind: "SPAN" });
+  qb.where("status = {status: String}", { status: "OK" });
+  qb.orderBy("start_time DESC");
+  qb.limit(limit);
+
+  const [err, rows] = await qb.execute();
+
+  if (err) {
+    throw err;
+  }
+
+  return rows ?? [];
+}
+
+function formatDateTime(date: Date): string {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
diff --git a/apps/webapp/app/services/apiAuth.server.ts b/apps/webapp/app/services/apiAuth.server.ts
index 09984e7b7bf..611953efc4f 100644
--- a/apps/webapp/app/services/apiAuth.server.ts
+++ b/apps/webapp/app/services/apiAuth.server.ts
@@ -3,7 +3,7 @@ import { type Prettify } from "@trigger.dev/core";
 import { SignJWT, errors, jwtVerify } from "jose";
 import { z } from "zod";
 
-import { prisma } from "~/db.server";
+import { $replica } from "~/db.server";
 import { env } from "~/env.server";
 import { findProjectByRef } from "~/models/project.server";
 import {
@@ -479,7 +479,7 @@ export async function authenticatedEnvironmentForAuthentication(
       return auth.result.environment;
     }
     case "personalAccessToken": {
-      const user = await prisma.user.findUnique({
+      const user = await $replica.user.findUnique({
         where: {
           id: auth.result.userId,
         },
@@ -498,7 +498,7 @@ export async function authenticatedEnvironmentForAuthentication(
       const sanitizedBranch = sanitizeBranchName(branch);
 
       if (!sanitizedBranch) {
-        const environment = await prisma.runtimeEnvironment.findFirst({
+        const environment = await $replica.runtimeEnvironment.findFirst({
           where: {
             projectId: project.id,
             slug: slug,
@@ -523,7 +523,7 @@ export async function authenticatedEnvironmentForAuthentication(
         return environment;
       }
 
-      const environment = await prisma.runtimeEnvironment.findFirst({
+      const environment = await $replica.runtimeEnvironment.findFirst({
         where: {
           projectId: project.id,
           type: "PREVIEW",
@@ -553,7 +553,7 @@ export async function authenticatedEnvironmentForAuthentication(
       };
     }
     case "organizationAccessToken": {
-      const organization = await prisma.organization.findUnique({
+      const organization = await $replica.organization.findUnique({
         where: {
           id: auth.result.organizationId,
         },
@@ -563,7 +563,7 @@ export async function authenticatedEnvironmentForAuthentication(
         throw json({ error: "Invalid or missing organization access token" }, { status: 401 });
       }
 
-      const project = await prisma.project.findFirst({
+      const project = await $replica.project.findFirst({
         where: {
           organizationId: organization.id,
           externalRef: projectRef,
@@ -577,7 +577,7 @@ export async function authenticatedEnvironmentForAuthentication(
       const sanitizedBranch = sanitizeBranchName(branch);
 
       if (!sanitizedBranch) {
-        const environment = await prisma.runtimeEnvironment.findFirst({
+        const environment = await $replica.runtimeEnvironment.findFirst({
           where: {
             projectId: project.id,
             slug: slug,
@@ -595,7 +595,7 @@ export async function authenticatedEnvironmentForAuthentication(
         return environment;
       }
 
-      const environment = await prisma.runtimeEnvironment.findFirst({
+      const environment = await $replica.runtimeEnvironment.findFirst({
         where: {
           projectId: project.id,
           type: "PREVIEW",
diff --git a/apps/webapp/app/services/apiRateLimit.server.ts b/apps/webapp/app/services/apiRateLimit.server.ts
index 4cf27450a92..dee0a889d1b 100644
--- a/apps/webapp/app/services/apiRateLimit.server.ts
+++ b/apps/webapp/app/services/apiRateLimit.server.ts
@@ -61,7 +61,7 @@ export const apiRateLimiter = authorizationRateLimitMiddleware({
     "/api/v1/auth/jwt/claims",
     /^\/api\/v1\/runs\/[^\/]+\/attempts$/, // /api/v1/runs/$runFriendlyId/attempts
     /^\/api\/v1\/waitpoints\/tokens\/[^\/]+\/callback\/[^\/]+$/, // /api/v1/waitpoints/tokens/$waitpointFriendlyId/callback/$hash
-    /^\/api\/v1\/deployments/, // /api/v1/deployments/*
+    /^\/api\/v\d+\/deployments/, // /api/v{1,2,3,n}/deployments/*
   ],
   log: {
     rejections: env.API_RATE_LIMIT_REJECTION_LOGS_ENABLED === "1",
diff --git a/apps/webapp/app/services/authorization.server.ts b/apps/webapp/app/services/authorization.server.ts
index 15f85cc3278..0406c02438e 100644
--- a/apps/webapp/app/services/authorization.server.ts
+++ b/apps/webapp/app/services/authorization.server.ts
@@ -1,6 +1,6 @@
 export type AuthorizationAction = "read" | "write" | string; // Add more actions as needed
 
-const ResourceTypes = ["tasks", "tags", "runs", "batch", "waitpoints", "deployments"] as const;
+const ResourceTypes = ["tasks", "tags", "runs", "batch", "waitpoints", "deployments", "inputStreams", "query", "prompts"] as const;
 
 export type AuthorizationResources = {
   [key in (typeof ResourceTypes)[number]]?: string | string[];
diff --git a/apps/webapp/app/services/authorizationRateLimitMiddleware.server.ts b/apps/webapp/app/services/authorizationRateLimitMiddleware.server.ts
index b94a664a361..431a0062db8 100644
--- a/apps/webapp/app/services/authorizationRateLimitMiddleware.server.ts
+++ b/apps/webapp/app/services/authorizationRateLimitMiddleware.server.ts
@@ -1,5 +1,5 @@
 import { createCache, DefaultStatefulContext, Namespace, Cache as UnkeyCache } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { Ratelimit } from "@upstash/ratelimit";
 import { Request as ExpressRequest, Response as ExpressResponse, NextFunction } from "express";
 import { createHash } from "node:crypto";
@@ -7,7 +7,7 @@ import { z } from "zod";
 import { env } from "~/env.server";
 import { RedisWithClusterOptions } from "~/redis.server";
 import { logger } from "./logger.server";
-import { createRedisRateLimitClient, Duration, RateLimiter } from "./rateLimiter.server";
+import { createRedisRateLimitClient, Duration, Limiter, RateLimiter } from "./rateLimiter.server";
 import { RedisCacheStore } from "./unkey/redisCacheStore.server";
 
 const DurationSchema = z.custom<Duration>((value) => {
@@ -130,6 +130,18 @@ async function resolveLimitConfig(
   return cacheResult.val ?? defaultLimiter;
 }
 
+/**
+ * Creates a Ratelimit limiter from a RateLimiterConfig.
+ * This function is shared across the codebase to ensure consistent limiter creation.
+ */
+export function createLimiterFromConfig(config: RateLimiterConfig): Limiter {
+  return config.type === "fixedWindow"
+    ? Ratelimit.fixedWindow(config.tokens, config.window)
+    : config.type === "tokenBucket"
+    ? Ratelimit.tokenBucket(config.refillRate, config.interval, config.maxTokens)
+    : Ratelimit.slidingWindow(config.tokens, config.window);
+}
+
 //returns an Express middleware that rate limits using the Bearer token in the Authorization header
 export function authorizationRateLimitMiddleware({
   redis,
@@ -145,10 +157,7 @@ export function authorizationRateLimitMiddleware({
   limiterConfigOverride,
 }: Options) {
   const ctx = new DefaultStatefulContext();
-  const memory = new MemoryStore({
-    persistentMap: new Map(),
-    unstableEvictOnSet: { frequency: 0.001, maxItems: limiterCache?.maxItems ?? 1000 },
-  });
+  const memory = createLRUMemoryStore(limiterCache?.maxItems ?? 1000);
   const redisCacheStore = new RedisCacheStore({
     connection: {
       keyPrefix: `cache:${keyPrefix}:rate-limit-cache:`,
@@ -249,16 +258,7 @@ export function authorizationRateLimitMiddleware({
       limiterConfigOverride
     );
 
-    const limiter =
-      limiterConfig.type === "fixedWindow"
-        ? Ratelimit.fixedWindow(limiterConfig.tokens, limiterConfig.window)
-        : limiterConfig.type === "tokenBucket"
-        ? Ratelimit.tokenBucket(
-            limiterConfig.refillRate,
-            limiterConfig.interval,
-            limiterConfig.maxTokens
-          )
-        : Ratelimit.slidingWindow(limiterConfig.tokens, limiterConfig.window);
+    const limiter = createLimiterFromConfig(limiterConfig);
 
     const rateLimiter = new RateLimiter({
       redisClient,
diff --git a/apps/webapp/app/services/betterstack/betterstack.server.ts b/apps/webapp/app/services/betterstack/betterstack.server.ts
index 41a43b3a699..95fe2208836 100644
--- a/apps/webapp/app/services/betterstack/betterstack.server.ts
+++ b/apps/webapp/app/services/betterstack/betterstack.server.ts
@@ -1,26 +1,56 @@
-import { type ApiResult, wrapZodFetch } from "@trigger.dev/core/v3/zodfetch";
+import { wrapZodFetch } from "@trigger.dev/core/v3/zodfetch";
 import { createCache, DefaultStatefulContext, Namespace } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { z } from "zod";
 import { env } from "~/env.server";
 
-const IncidentSchema = z.object({
+const StatusPageSchema = z.object({
   data: z.object({
     id: z.string(),
     type: z.string(),
     attributes: z.object({
-      aggregate_state: z.string(),
+      aggregate_state: z.enum(["operational", "degraded", "downtime"]),
     }),
   }),
 });
 
-export type Incident = z.infer<typeof IncidentSchema>;
+const StatusReportsSchema = z.object({
+  data: z.array(
+    z.object({
+      id: z.string(),
+      type: z.literal("status_report"),
+      attributes: z.object({
+        title: z.string().nullable(),
+        starts_at: z.string().nullable(),
+        ends_at: z.string().nullable(),
+        aggregate_state: z.string().nullable(),
+      }),
+    })
+  ),
+  pagination: z.object({
+    first: z.string().nullable(),
+    last: z.string().nullable(),
+    prev: z.string().nullable(),
+    next: z.string().nullable(),
+  }),
+});
+
+export type AggregateState = "operational" | "degraded" | "downtime";
+
+export type IncidentStatus = {
+  status: AggregateState;
+  title: string | null;
+};
+
+type CachedResult =
+  | { success: true; data: IncidentStatus }
+  | { success: false; error: unknown };
 
 const ctx = new DefaultStatefulContext();
-const memory = new MemoryStore({ persistentMap: new Map() });
+const memory = createLRUMemoryStore(100);
 
 const cache = createCache({
-  query: new Namespace<ApiResult<Incident>>(ctx, {
+  query: new Namespace<CachedResult>(ctx, {
     stores: [memory],
     fresh: 15_000,
     stale: 30_000,
@@ -30,59 +60,115 @@ const cache = createCache({
 export class BetterStackClient {
   private readonly baseUrl = "https://uptime.betterstack.com/api/v2";
 
-  async getIncidents() {
+  async getIncidentStatus(): Promise<CachedResult> {
     const apiKey = env.BETTERSTACK_API_KEY;
-    if (!apiKey) {
-      return { success: false as const, error: "BETTERSTACK_API_KEY is not set" };
+    const statusPageId = env.BETTERSTACK_STATUS_PAGE_ID;
+
+    if (!apiKey || !statusPageId) {
+      return { success: false, error: "Missing BetterStack configuration" };
     }
 
-    const statusPageId = env.BETTERSTACK_STATUS_PAGE_ID;
-    if (!statusPageId) {
-      return { success: false as const, error: "BETTERSTACK_STATUS_PAGE_ID is not set" };
+    const cachedResult = await cache.query.swr("betterstack-incident-status", () =>
+      this.fetchIncidentStatus(apiKey, statusPageId)
+    );
+
+    if (cachedResult.err || !cachedResult.val) {
+      return { success: false, error: cachedResult.err ?? "No result from cache" };
     }
 
-    const cachedResult = await cache.query.swr("betterstack", async () => {
-      try {
-        const result = await wrapZodFetch(
-          IncidentSchema,
-          `${this.baseUrl}/status-pages/${statusPageId}`,
-          {
-            headers: {
-              Authorization: `Bearer ${apiKey}`,
-              "Content-Type": "application/json",
-            },
-          },
-          {
-            retry: {
-              maxAttempts: 3,
-              minTimeoutInMs: 1000,
-              maxTimeoutInMs: 5000,
-            },
-          }
-        );
-
-        return result;
-      } catch (error) {
-        console.error("Failed to fetch incidents from BetterStack:", error);
-        return {
-          success: false as const,
-          error: error instanceof Error ? error.message : "Unknown error",
-        };
+    return cachedResult.val;
+  }
+
+  private async fetchIncidentStatus(
+    apiKey: string,
+    statusPageId: string
+  ): Promise<CachedResult> {
+    const headers = {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+    };
+    const retryConfig = {
+      retry: { maxAttempts: 3, minTimeoutInMs: 1000, maxTimeoutInMs: 5000 },
+    };
+
+    try {
+      // Fetch the status page to get aggregate state
+      const statusPageResult = await wrapZodFetch(
+        StatusPageSchema,
+        `${this.baseUrl}/status-pages/${statusPageId}`,
+        { headers },
+        retryConfig
+      );
+
+      if (!statusPageResult.success) {
+        return { success: false, error: statusPageResult.error };
+      }
+
+      const status = statusPageResult.data.data.attributes.aggregate_state;
+
+      // If operational, no need to fetch reports
+      if (status === "operational") {
+        return { success: true, data: { status, title: null } };
       }
-    });
 
-    if (cachedResult.err) {
-      return { success: false as const, error: cachedResult.err };
+      // Fetch status reports to get the incident title
+      const title = await this.fetchActiveReportTitle(apiKey, statusPageId, headers, retryConfig);
+
+      return { success: true, data: { status, title } };
+    } catch (error) {
+      console.error("Failed to fetch incident status from BetterStack:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  }
+
+  private async fetchActiveReportTitle(
+    apiKey: string,
+    statusPageId: string,
+    headers: Record<string, string>,
+    retryConfig: { retry: { maxAttempts: number; minTimeoutInMs: number; maxTimeoutInMs: number } }
+  ): Promise<string | null> {
+    const reportsUrl = `${this.baseUrl}/status-pages/${statusPageId}/status-reports`;
+
+    let reportsResult = await wrapZodFetch(
+      StatusReportsSchema,
+      reportsUrl,
+      { headers },
+      retryConfig
+    );
+
+    if (!reportsResult.success) {
+      return null;
     }
 
-    if (!cachedResult.val) {
-      return { success: false as const, error: "No result from BetterStack" };
+    // Fetch last page if there are multiple pages (most recent reports are at the end)
+    const { first, last } = reportsResult.data.pagination;
+    if (last && last !== first) {
+      const lastPageResult = await wrapZodFetch(
+        StatusReportsSchema,
+        last,
+        { headers },
+        retryConfig
+      );
+      if (lastPageResult.success) {
+        reportsResult = lastPageResult;
+      }
     }
 
-    if (!cachedResult.val.success) {
-      return { success: false as const, error: cachedResult.val.error };
+    // Find active reports (not resolved, not ended)
+    const activeReports = reportsResult.data.data.filter(
+      (report) =>
+        report.attributes.aggregate_state !== "resolved" && report.attributes.ends_at === null
+    );
+
+    if (activeReports.length === 0) {
+      return null;
     }
 
-    return { success: true as const, data: cachedResult.val.data.data };
+    // Return the title from the most recent active report
+    const mostRecent = activeReports[activeReports.length - 1];
+    return mostRecent.attributes.title;
   }
 }
diff --git a/apps/webapp/app/services/clickhouseInstance.server.ts b/apps/webapp/app/services/clickhouseInstance.server.ts
index 32fc9bc0d4b..9c4941671f3 100644
--- a/apps/webapp/app/services/clickhouseInstance.server.ts
+++ b/apps/webapp/app/services/clickhouseInstance.server.ts
@@ -28,3 +28,103 @@ function initializeClickhouseClient() {
 
   return clickhouse;
 }
+
+export const logsClickhouseClient = singleton(
+  "logsClickhouseClient",
+  initializeLogsClickhouseClient
+);
+
+function initializeLogsClickhouseClient() {
+  if (!env.LOGS_CLICKHOUSE_URL) {
+    throw new Error("LOGS_CLICKHOUSE_URL is not set");
+  }
+
+  const url = new URL(env.LOGS_CLICKHOUSE_URL);
+
+  // Remove secure param
+  url.searchParams.delete("secure");
+
+  return new ClickHouse({
+    url: url.toString(),
+    name: "logs-clickhouse",
+    keepAlive: {
+      enabled: env.CLICKHOUSE_KEEP_ALIVE_ENABLED === "1",
+      idleSocketTtl: env.CLICKHOUSE_KEEP_ALIVE_IDLE_SOCKET_TTL_MS,
+    },
+    logLevel: env.CLICKHOUSE_LOG_LEVEL,
+    compression: {
+      request: true,
+    },
+    maxOpenConnections: env.CLICKHOUSE_MAX_OPEN_CONNECTIONS,
+    clickhouseSettings: {
+      max_memory_usage: env.CLICKHOUSE_LOGS_LIST_MAX_MEMORY_USAGE.toString(),
+      max_bytes_before_external_sort:
+        env.CLICKHOUSE_LOGS_LIST_MAX_BYTES_BEFORE_EXTERNAL_SORT.toString(),
+      max_threads: env.CLICKHOUSE_LOGS_LIST_MAX_THREADS,
+      ...(env.CLICKHOUSE_LOGS_LIST_MAX_ROWS_TO_READ && {
+        max_rows_to_read: env.CLICKHOUSE_LOGS_LIST_MAX_ROWS_TO_READ.toString(),
+      }),
+      ...(env.CLICKHOUSE_LOGS_LIST_MAX_EXECUTION_TIME && {
+        max_execution_time: env.CLICKHOUSE_LOGS_LIST_MAX_EXECUTION_TIME,
+      }),
+    },
+  });
+}
+
+export const adminClickhouseClient = singleton(
+  "adminClickhouseClient",
+  initializeAdminClickhouseClient
+);
+
+function initializeAdminClickhouseClient() {
+  if (!env.ADMIN_CLICKHOUSE_URL) {
+    throw new Error("ADMIN_CLICKHOUSE_URL is not set");
+  }
+
+  const url = new URL(env.ADMIN_CLICKHOUSE_URL);
+  url.searchParams.delete("secure");
+
+  return new ClickHouse({
+    url: url.toString(),
+    name: "admin-clickhouse",
+    keepAlive: {
+      enabled: env.CLICKHOUSE_KEEP_ALIVE_ENABLED === "1",
+      idleSocketTtl: env.CLICKHOUSE_KEEP_ALIVE_IDLE_SOCKET_TTL_MS,
+    },
+    logLevel: env.CLICKHOUSE_LOG_LEVEL,
+    compression: {
+      request: true,
+    },
+    maxOpenConnections: env.CLICKHOUSE_MAX_OPEN_CONNECTIONS,
+  });
+}
+
+export const queryClickhouseClient = singleton(
+  "queryClickhouseClient",
+  initializeQueryClickhouseClient
+);
+
+function initializeQueryClickhouseClient() {
+  if (!env.QUERY_CLICKHOUSE_URL) {
+    throw new Error("QUERY_CLICKHOUSE_URL is not set");
+  }
+
+  const url = new URL(env.QUERY_CLICKHOUSE_URL);
+
+  // Remove secure param
+  url.searchParams.delete("secure");
+
+  return new ClickHouse({
+    url: url.toString(),
+    name: "query-clickhouse",
+    keepAlive: {
+      enabled: env.CLICKHOUSE_KEEP_ALIVE_ENABLED === "1",
+      idleSocketTtl: env.CLICKHOUSE_KEEP_ALIVE_IDLE_SOCKET_TTL_MS,
+    },
+    logLevel: env.CLICKHOUSE_LOG_LEVEL,
+    compression: {
+      request: true,
+    },
+    maxOpenConnections: env.CLICKHOUSE_MAX_OPEN_CONNECTIONS,
+  });
+}
diff --git a/apps/webapp/app/services/dashboardPreferences.server.ts b/apps/webapp/app/services/dashboardPreferences.server.ts
index 3649704b811..7af007dc381 100644
--- a/apps/webapp/app/services/dashboardPreferences.server.ts
+++ b/apps/webapp/app/services/dashboardPreferences.server.ts
@@ -3,6 +3,26 @@ import { prisma } from "~/db.server";
 import { logger } from "./logger.server";
 import { type UserFromSession } from "./session.server";
 
+const SideMenuPreferences = z.object({
+  isCollapsed: z.boolean().default(false),
+  // Map for section collapsed states - keys are section identifiers
+  collapsedSections: z.record(z.string(), z.boolean()).optional(),
+  /** Organization-specific settings */
+  organizations: z
+    .record(
+      z.string(),
+      z.object({
+        orderedItems: z.record(z.string(), z.array(z.string())),
+      })
+    )
+    .optional(),
+});
+
+export type SideMenuPreferences = z.infer<typeof SideMenuPreferences>;
+
+import { type SideMenuSectionId } from "~/components/navigation/sideMenuTypes";
+export type { SideMenuSectionId };
+
 const DashboardPreferences = z.object({
   version: z.literal("1"),
   currentProjectId: z.string().optional(),
@@ -12,6 +32,7 @@ const DashboardPreferences = z.object({
       currentEnvironment: z.object({ id: z.string() }),
     })
   ),
+  sideMenu: SideMenuPreferences.optional(),
 });
 
 export type DashboardPreferences = z.infer<typeof DashboardPreferences>;
@@ -99,3 +120,113 @@ export async function clearCurrentProject({ user }: { user: UserFromSession }) {
     },
   });
 }
+
+export async function updateSideMenuPreferences({
+  user,
+  isCollapsed,
+  sectionCollapsed,
+}: {
+  user: UserFromSession;
+  isCollapsed?: boolean;
+  /** Update a specific section's collapsed state */
+  sectionCollapsed?: { sectionId: SideMenuSectionId; collapsed: boolean };
+}) {
+  if (user.isImpersonating) {
+    return;
+  }
+
+  // Parse with schema to apply defaults, then overlay any new values
+  const currentSideMenu = SideMenuPreferences.parse(user.dashboardPreferences.sideMenu ?? {});
+
+  // Build the updated collapsedSections map
+  let updatedCollapsedSections = { ...currentSideMenu.collapsedSections };
+
+  if (sectionCollapsed) {
+    updatedCollapsedSections[sectionCollapsed.sectionId] = sectionCollapsed.collapsed;
+  }
+
+  const updatedSideMenu = SideMenuPreferences.parse({
+    ...currentSideMenu,
+    ...(isCollapsed !== undefined && { isCollapsed }),
+    collapsedSections: updatedCollapsedSections,
+  });
+
+  // Only update if something changed
+  const hasCollapsedSectionsChanged =
+    JSON.stringify(updatedSideMenu.collapsedSections) !==
+    JSON.stringify(currentSideMenu.collapsedSections);
+
+  if (updatedSideMenu.isCollapsed === currentSideMenu.isCollapsed && !hasCollapsedSectionsChanged) {
+    return;
+  }
+
+  const updatedPreferences: DashboardPreferences = {
+    ...user.dashboardPreferences,
+    sideMenu: updatedSideMenu,
+  };
+
+  return prisma.user.update({
+    where: {
+      id: user.id,
+    },
+    data: {
+      dashboardPreferences: updatedPreferences,
+    },
+  });
+}
+
+/** Get the stored item order for a specific list within an organization */
+export function getItemOrder(
+  sideMenu: SideMenuPreferences | undefined,
+  organizationId: string,
+  listId: string
+): string[] | undefined {
+  return sideMenu?.organizations?.[organizationId]?.orderedItems?.[listId];
+}
+
+export async function updateItemOrder({
+  user,
+  organizationId,
+  listId,
+  order,
+}: {
+  user: UserFromSession;
+  organizationId: string;
+  listId: string;
+  order: string[];
+}) {
+  if (user.isImpersonating) {
+    return;
+  }
+
+  const currentSideMenu = SideMenuPreferences.parse(user.dashboardPreferences.sideMenu ?? {});
+  const currentOrg = currentSideMenu.organizations?.[organizationId];
+
+  const updatedSideMenu = SideMenuPreferences.parse({
+    ...currentSideMenu,
+    organizations: {
+      ...currentSideMenu.organizations,
+      [organizationId]: {
+        ...currentOrg,
+        orderedItems: {
+          ...currentOrg?.orderedItems,
+          [listId]: order,
+        },
+      },
+    },
+  });
+
+  const updatedPreferences: DashboardPreferences = {
+    ...user.dashboardPreferences,
+    sideMenu: updatedSideMenu,
+  };
+
+  return prisma.user.update({
+    where: {
+      id: user.id,
+    },
+    data: {
+      dashboardPreferences: updatedPreferences,
+    },
+  });
+}
diff --git a/apps/webapp/app/services/inputStreamWaitpointCache.server.ts b/apps/webapp/app/services/inputStreamWaitpointCache.server.ts
new file mode 100644
index 00000000000..ab360c837a8
--- /dev/null
+++ b/apps/webapp/app/services/inputStreamWaitpointCache.server.ts
@@ -0,0 +1,100 @@
+import { Redis } from "ioredis";
+import { env } from "~/env.server";
+import { singleton } from "~/utils/singleton";
+import { logger } from "./logger.server";
+
+const KEY_PREFIX = "isw:";
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+function buildKey(runFriendlyId: string, streamId: string): string {
+  return `${KEY_PREFIX}${runFriendlyId}:${streamId}`;
+}
+
+function initializeRedis(): Redis | undefined {
+  const host = env.CACHE_REDIS_HOST;
+  if (!host) {
+    return undefined;
+  }
+
+  return new Redis({
+    connectionName: "inputStreamWaitpointCache",
+    host,
+    port: env.CACHE_REDIS_PORT,
+    username: env.CACHE_REDIS_USERNAME,
+    password: env.CACHE_REDIS_PASSWORD,
+    keyPrefix: "tr:",
+    enableAutoPipelining: true,
+    ...(env.CACHE_REDIS_TLS_DISABLED === "true" ? {} : { tls: {} }),
+  });
+}
+
+const redis = singleton("inputStreamWaitpointCache", initializeRedis);
+
+/**
+ * Store a mapping from input stream to waitpoint ID in Redis.
+ * Called when `.wait()` creates a new waitpoint.
+ */
+export async function setInputStreamWaitpoint(
+  runFriendlyId: string,
+  streamId: string,
+  waitpointId: string,
+  ttlMs?: number
+): Promise<void> {
+  if (!redis) return;
+
+  try {
+    const key = buildKey(runFriendlyId, streamId);
+    await redis.set(key, waitpointId, "PX", ttlMs ?? DEFAULT_TTL_MS);
+  } catch (error) {
+    logger.error("Failed to set input stream waitpoint cache", {
+      runFriendlyId,
+      streamId,
+      error,
+    });
+  }
+}
+
+/**
+ * Get the waitpoint ID for an input stream without deleting it.
+ * Called from the `.send()` route before completing the waitpoint.
+ */
+export async function getInputStreamWaitpoint(
+  runFriendlyId: string,
+  streamId: string
+): Promise<string | null> {
+  if (!redis) return null;
+
+  try {
+    const key = buildKey(runFriendlyId, streamId);
+    return await redis.get(key);
+  } catch (error) {
+    logger.error("Failed to get input stream waitpoint cache", {
+      runFriendlyId,
+      streamId,
+      error,
+    });
+    return null;
+  }
+}
+
+/**
+ * Delete the cache entry for an input stream waitpoint.
+ * Called when a waitpoint is completed or timed out.
+ */
+export async function deleteInputStreamWaitpoint(
+  runFriendlyId: string,
+  streamId: string
+): Promise<void> {
+  if (!redis) return;
+
+  try {
+    const key = buildKey(runFriendlyId, streamId);
+    await redis.del(key);
+  } catch (error) {
+    logger.error("Failed to delete input stream waitpoint cache", {
+      runFriendlyId,
+      streamId,
+      error,
+    });
+  }
+}
diff --git a/apps/webapp/app/services/logger.server.ts b/apps/webapp/app/services/logger.server.ts
index be5baff9c85..e93cd138704 100644
--- a/apps/webapp/app/services/logger.server.ts
+++ b/apps/webapp/app/services/logger.server.ts
@@ -48,7 +48,7 @@ function flattenArgs(args: Array<Record<string, unknown> | undefined>) {
 }
 export const logger = new Logger(
   "webapp",
-  (process.env.APP_LOG_LEVEL ?? "debug") as LogLevel,
+  (process.env.APP_LOG_LEVEL ?? "info") as LogLevel,
   ["examples", "output", "connectionString", "payload"],
   sensitiveDataReplacer,
   () => {
@@ -60,7 +60,7 @@ export const logger = new Logger(
 
 export const workerLogger = new Logger(
   "worker",
-  (process.env.APP_LOG_LEVEL ?? "debug") as LogLevel,
+  (process.env.APP_LOG_LEVEL ?? "info") as LogLevel,
   ["examples", "output", "connectionString"],
   sensitiveDataReplacer,
   () => {
@@ -71,7 +71,7 @@ export const workerLogger = new Logger(
 
 export const socketLogger = new Logger(
   "socket",
-  (process.env.APP_LOG_LEVEL ?? "debug") as LogLevel,
+  (process.env.APP_LOG_LEVEL ?? "info") as LogLevel,
   [],
   sensitiveDataReplacer,
   () => {
diff --git a/apps/webapp/app/services/loops.server.ts b/apps/webapp/app/services/loops.server.ts
index 6509d894701..78c7faad81b 100644
--- a/apps/webapp/app/services/loops.server.ts
+++ b/apps/webapp/app/services/loops.server.ts
@@ -22,6 +22,24 @@ class LoopsClient {
     });
   }
 
+  async vercelIntegrationStarted({
+    userId,
+    email,
+    name,
+  }: {
+    userId: string;
+    email: string;
+    name: string | null;
+  }) {
+    logger.info(`Loops send "vercel-integration" event`, { userId, email, name });
+    return this.#sendEvent({
+      email,
+      userId,
+      firstName: name?.split(" ").at(0),
+      eventName: "vercel-integration",
+    });
+  }
+
   async #sendEvent({
     email,
     userId,
diff --git a/apps/webapp/app/services/org.server.ts b/apps/webapp/app/services/org.server.ts
new file mode 100644
index 00000000000..75c1467ab24
--- /dev/null
+++ b/apps/webapp/app/services/org.server.ts
@@ -0,0 +1,20 @@
+import { prisma } from "~/db.server";
+import { requireUserId } from "./session.server";
+
+export async function requireOrganization(request: Request, organizationSlug: string) {
+  const userId = await requireUserId(request);
+  
+  const organization = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+      deletedAt: null,
+    },
+  });
+
+  if (!organization) {
+    throw new Response("Organization not found", { status: 404 });
+  }
+
+  return { organization, userId };
+}
diff --git a/apps/webapp/app/services/platform.v3.server.ts b/apps/webapp/app/services/platform.v3.server.ts
index d83da275dc5..3a981396003 100644
--- a/apps/webapp/app/services/platform.v3.server.ts
+++ b/apps/webapp/app/services/platform.v3.server.ts
@@ -5,8 +5,12 @@ import {
   defaultMachine as defaultMachineFromPlatform,
   machines as machinesFromPlatform,
   type BillingAlertsResult,
+  type CreatePrivateLinkConnectionBody,
   type Limits,
   type MachineCode,
+  type PrivateLinkConnection,
+  type PrivateLinkConnectionList,
+  type PrivateLinkRegionsResult,
   type ReportUsageResult,
   type SetPlanBody,
   type UpdateBillingAlertsRequest,
@@ -15,7 +19,7 @@ import {
   type CurrentPlan,
 } from "@trigger.dev/platform";
 import { createCache, DefaultStatefulContext, Namespace } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { existsSync, readFileSync } from "node:fs";
 import { redirect } from "remix-typedjson";
 import { z } from "zod";
@@ -34,10 +38,7 @@ function initializeClient() {
       url: process.env.BILLING_API_URL,
       apiKey: process.env.BILLING_API_KEY,
     });
-    console.log(`🤑 Billing client initialized: ${process.env.BILLING_API_URL}`);
     return client;
-  } else {
-    console.log(`🤑 Billing client not initialized`);
   }
 }
 
@@ -45,13 +46,7 @@ const client = singleton("billingClient", initializeClient);
 
 function initializePlatformCache() {
   const ctx = new DefaultStatefulContext();
-  const memory = new MemoryStore({
-    persistentMap: new Map(),
-    unstableEvictOnSet: {
-      frequency: 0.01,
-      maxItems: 1000,
-    },
-  });
+  const memory = createLRUMemoryStore(1000);
   const redisCacheStore = new RedisCacheStore({
     connection: {
       keyPrefix: "tr:cache:platform:v3",
@@ -415,6 +410,38 @@ export async function setConcurrencyAddOn(organizationId: string, amount: number
   }
 }
 
+export async function setSeatsAddOn(organizationId: string, amount: number) {
+  if (!client) return undefined;
+
+  try {
+    const result = await client.setAddOn(organizationId, { type: "seats", amount });
+    if (!result.success) {
+      logger.error("Error setting seats add on - no success", { error: result.error });
+      return undefined;
+    }
+    return result;
+  } catch (e) {
+    logger.error("Error setting seats add on - caught error", { error: e });
+    return undefined;
+  }
+}
+
+export async function setBranchesAddOn(organizationId: string, amount: number) {
+  if (!client) return undefined;
+
+  try {
+    const result = await client.setAddOn(organizationId, { type: "branches", amount });
+    if (!result.success) {
+      logger.error("Error setting branches add on - no success", { error: result.error });
+      return undefined;
+    }
+    return result;
+  } catch (e) {
+    logger.error("Error setting branches add on - caught error", { error: e });
+    return undefined;
+  }
+}
+
 export async function getUsage(organizationId: string, { from, to }: { from: Date; to: Date }) {
   if (!client) return undefined;
 
@@ -616,6 +643,112 @@ export async function enqueueBuild(
   return result;
 }
 
+export async function getPrivateLinks(
+  organizationId: string
+): Promise<PrivateLinkConnectionList | undefined> {
+  if (!client) return undefined;
+
+  const [error, result] = await tryCatch(client.getPrivateLinks(organizationId));
+
+  if (error) {
+    logger.error("Error getting private links", { organizationId, error });
+    return undefined;
+  }
+
+  if (!result.success) {
+    logger.error("Error getting private links - no success", { organizationId, error: result.error });
+    return undefined;
+  }
+
+  return result;
+}
+
+export async function createPrivateLink(
+  organizationId: string,
+  body: CreatePrivateLinkConnectionBody
+): Promise<PrivateLinkConnection | undefined> {
+  if (!client) throw new Error("Platform client not configured");
+
+  const [error, result] = await tryCatch(client.createPrivateLink(organizationId, body));
+
+  if (error) {
+    logger.error("Error creating private link", { organizationId, error });
+    throw error;
+  }
+
+  if (!result.success) {
+    logger.error("Error creating private link - no success", { organizationId, error: result.error });
+    throw new Error(result.error ?? "Failed to create private link");
+  }
+
+  return result;
+}
+
+export async function deletePrivateLink(
+  organizationId: string,
+  connectionId: string
+): Promise<void> {
+  if (!client) throw new Error("Platform client not configured");
+
+  const [error, result] = await tryCatch(client.deletePrivateLink(organizationId, connectionId));
+
+  if (error) {
+    logger.error("Error deleting private link", { organizationId, connectionId, error });
+    throw error;
+  }
+
+  if (!result.success) {
+    logger.error("Error deleting private link - no success", { organizationId, connectionId, error: result.error });
+    throw new Error(result.error ?? "Failed to delete private link");
+  }
+}
+
+export async function getPrivateLinkRegions(
+  organizationId: string
+): Promise<PrivateLinkRegionsResult | undefined> {
+  if (!client) return undefined;
+
+  const [error, result] = await tryCatch(client.getPrivateLinkRegions(organizationId));
+
+  if (error) {
+    logger.error("Error getting private link regions", { organizationId, error });
+    return undefined;
+  }
+
+  if (!result.success) {
+    logger.error("Error getting private link regions - no success", { organizationId, error: result.error });
+    return undefined;
+  }
+
+  return result;
+}
+
+export async function triggerInitialDeployment(
+  projectId: string,
+  options: { environment: "preview" | "prod" | "staging" }
+): Promise<void> {
+  if (!client) return;
+
+  const [error, result] = await tryCatch(client.triggerInitialDeployment(projectId, options));
+
+  if (error) {
+    logger.warn("Error triggering initial deployment", {
+      projectId,
+      environment: options.environment,
+      error,
+    });
+    return;
+  }
+
+  if (!result.success) {
+    logger.warn("Failed to trigger initial deployment", {
+      projectId,
+      environment: options.environment,
+      error: result.error,
+    });
+  }
+}
+
 function isCloud(): boolean {
   const acceptableHosts = [
     "https://cloud.trigger.dev",
diff --git a/apps/webapp/app/services/platformNotificationCounter.server.ts b/apps/webapp/app/services/platformNotificationCounter.server.ts
new file mode 100644
index 00000000000..dc2970045da
--- /dev/null
+++ b/apps/webapp/app/services/platformNotificationCounter.server.ts
@@ -0,0 +1,45 @@
+import { Redis } from "ioredis";
+import { env } from "~/env.server";
+import { singleton } from "~/utils/singleton";
+import { logger } from "./logger.server";
+
+const KEY_PREFIX = "cli-notif-ctr:";
+const MAX_COUNTER = 1000;
+
+function initializeRedis(): Redis | undefined {
+  const host = env.CACHE_REDIS_HOST;
+  if (!host) return undefined;
+
+  return new Redis({
+    connectionName: "platformNotificationCounter",
+    host,
+    port: env.CACHE_REDIS_PORT,
+    username: env.CACHE_REDIS_USERNAME,
+    password: env.CACHE_REDIS_PASSWORD,
+    keyPrefix: "tr:",
+    enableAutoPipelining: true,
+    ...(env.CACHE_REDIS_TLS_DISABLED === "true" ? {} : { tls: {} }),
+  });
+}
+
+const redis = singleton("platformNotificationCounter", initializeRedis);
+
+/** Increment and return the user's CLI request counter (0-based, wraps at 1000→0). */
+export async function incrementCliRequestCounter(userId: string): Promise<number> {
+  if (!redis) return 0;
+
+  try {
+    const key = `${KEY_PREFIX}${userId}`;
+    const value = await redis.incr(key);
+
+    if (value > MAX_COUNTER) {
+      await redis.set(key, "0");
+      return 0;
+    }
+
+    return value;
+  } catch (error) {
+    logger.error("Failed to increment CLI notification counter", { userId, error });
+    return 0;
+  }
+}
diff --git a/apps/webapp/app/services/platformNotifications.server.ts b/apps/webapp/app/services/platformNotifications.server.ts
new file mode 100644
index 00000000000..ff91f48708f
--- /dev/null
+++ b/apps/webapp/app/services/platformNotifications.server.ts
@@ -0,0 +1,661 @@
+import { z } from "zod";
+import { errAsync, fromPromise, type ResultAsync } from "neverthrow";
+import { prisma } from "~/db.server";
+import { type PlatformNotificationScope, type PlatformNotificationSurface } from "@trigger.dev/database";
+import { incrementCliRequestCounter } from "./platformNotificationCounter.server";
+
+// --- Payload schema (spec v1) ---
+
+const DiscoverySchema = z.object({
+  filePatterns: z.array(z.string().min(1)).min(1),
+  contentPattern: z
+    .string()
+    .max(200)
+    .optional()
+    .refine(
+      (val) => {
+        if (!val) return true;
+        try {
+          new RegExp(val);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      { message: "contentPattern must be a valid regular expression" }
+    ),
+  matchBehavior: z.enum(["show-if-found", "show-if-not-found"]),
+});
+
+const CardDataV1Schema = z.object({
+  type: z.enum(["card", "info", "warn", "error", "success", "changelog"]),
+  title: z.string(),
+  description: z.string(),
+  image: z.string().url().optional(),
+  actionLabel: z.string().optional(),
+  actionUrl: z.string().url().optional(),
+  dismissOnAction: z.boolean().optional(),
+  discovery: DiscoverySchema.optional(),
+});
+
+const PayloadV1Schema = z.object({
+  version: z.literal("1"),
+  data: CardDataV1Schema,
+});
+
+export type PayloadV1 = z.infer<typeof PayloadV1Schema>;
+
+export type PlatformNotificationWithPayload = {
+  id: string;
+  friendlyId: string;
+  scope: string;
+  priority: number;
+  payload: PayloadV1;
+  isRead: boolean;
+};
+
+// --- Read: admin list with interaction stats ---
+
+export async function getAdminNotificationsList({
+  page = 1,
+  pageSize = 20,
+  hideArchived = false,
+}: {
+  page?: number;
+  pageSize?: number;
+  hideArchived?: boolean;
+}) {
+  const where = hideArchived ? { archivedAt: null } : {};
+
+  const [notifications, total] = await Promise.all([
+    prisma.platformNotification.findMany({
+      where,
+      orderBy: [{ createdAt: "desc" }],
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+      include: {
+        _count: {
+          select: { interactions: true },
+        },
+        interactions: {
+          select: {
+            webappDismissedAt: true,
+            webappClickedAt: true,
+            cliDismissedAt: true,
+          },
+        },
+      },
+    }),
+    prisma.platformNotification.count({ where }),
+  ]);
+
+  return {
+    notifications: notifications.map((n) => {
+      const parsed = PayloadV1Schema.safeParse(n.payload);
+      return {
+        id: n.id,
+        friendlyId: n.friendlyId,
+        title: n.title,
+        surface: n.surface,
+        scope: n.scope,
+        priority: n.priority,
+        startsAt: n.startsAt,
+        endsAt: n.endsAt,
+        archivedAt: n.archivedAt,
+        createdAt: n.createdAt,
+        payload: n.payload,
+        payloadTitle: parsed.success ? parsed.data.data.title : null,
+        payloadType: parsed.success ? parsed.data.data.type : null,
+        payloadDescription: parsed.success ? parsed.data.data.description : null,
+        payloadActionUrl: parsed.success ? parsed.data.data.actionUrl : null,
+        payloadImage: parsed.success ? parsed.data.data.image : null,
+        cliMaxShowCount: n.cliMaxShowCount,
+        cliMaxDaysAfterFirstSeen: n.cliMaxDaysAfterFirstSeen,
+        cliShowEvery: n.cliShowEvery,
+        stats: {
+          seen: n._count.interactions,
+          clicked: n.interactions.filter((i) => i.webappClickedAt !== null).length,
+          dismissed: n.interactions.filter(
+            (i) => i.webappDismissedAt !== null || i.cliDismissedAt !== null
+          ).length,
+        },
+      };
+    }),
+    total,
+    page,
+    pageCount: Math.ceil(total / pageSize),
+  };
+}
+
+// --- Read: active notifications for webapp ---
+
+export async function getActivePlatformNotifications({
+  userId,
+  organizationId,
+  projectId,
+}: {
+  userId: string;
+  organizationId: string;
+  projectId?: string;
+}) {
+  const now = new Date();
+
+  const notifications = await prisma.platformNotification.findMany({
+    where: {
+      surface: "WEBAPP",
+      archivedAt: null,
+      startsAt: { lte: now },
+      endsAt: { gt: now },
+      AND: [
+        {
+          OR: [
+            { scope: "GLOBAL" },
+            { scope: "ORGANIZATION", organizationId },
+            ...(projectId ? [{ scope: "PROJECT" as const, projectId }] : []),
+            { scope: "USER", userId },
+          ],
+        },
+      ],
+    },
+    include: {
+      interactions: {
+        where: { userId },
+      },
+    },
+    orderBy: [{ priority: "desc" }, { createdAt: "desc" }],
+  });
+
+  type InternalNotification = PlatformNotificationWithPayload & { createdAt: Date };
+  const result: InternalNotification[] = [];
+
+  for (const n of notifications) {
+    const interaction = n.interactions[0] ?? null;
+
+    if (interaction?.webappDismissedAt) continue;
+
+    const parsed = PayloadV1Schema.safeParse(n.payload);
+    if (!parsed.success) continue;
+
+    result.push({
+      id: n.id,
+      friendlyId: n.friendlyId,
+      scope: n.scope,
+      priority: n.priority,
+      createdAt: n.createdAt,
+      payload: parsed.data,
+      isRead: !!interaction,
+    });
+  }
+
+  result.sort(compareNotifications);
+
+  const unreadCount = result.filter((n) => !n.isRead).length;
+  const notifications_out: PlatformNotificationWithPayload[] = result.map(
+    ({ createdAt: _, ...rest }) => rest
+  );
+
+  return { notifications: notifications_out, unreadCount };
+}
+
+function compareNotifications(
+  a: { priority: number; createdAt: Date },
+  b: { priority: number; createdAt: Date }
+) {
+  const priorityDiff = b.priority - a.priority;
+  if (priorityDiff !== 0) return priorityDiff;
+
+  return b.createdAt.getTime() - a.createdAt.getTime();
+}
+
+// --- Write: upsert interaction ---
+
+async function upsertInteraction({
+  notificationId,
+  userId,
+  onUpdate,
+  onCreate,
+}: {
+  notificationId: string;
+  userId: string;
+  onUpdate: Record<string, unknown>;
+  onCreate: Record<string, unknown>;
+}) {
+  await prisma.platformNotificationInteraction.upsert({
+    where: { notificationId_userId: { notificationId, userId } },
+    update: onUpdate,
+    create: {
+      notificationId,
+      userId,
+      firstSeenAt: new Date(),
+      showCount: 1,
+      ...onCreate,
+    },
+  });
+}
+
+export async function recordNotificationSeen({
+  notificationId,
+  userId,
+}: {
+  notificationId: string;
+  userId: string;
+}) {
+  return upsertInteraction({
+    notificationId,
+    userId,
+    onUpdate: { showCount: { increment: 1 } },
+    onCreate: {},
+  });
+}
+
+export async function dismissNotification({
+  notificationId,
+  userId,
+}: {
+  notificationId: string;
+  userId: string;
+}) {
+  const now = new Date();
+  return upsertInteraction({
+    notificationId,
+    userId,
+    onUpdate: { webappDismissedAt: now },
+    onCreate: { webappDismissedAt: now },
+  });
+}
+
+export async function recordNotificationClicked({
+  notificationId,
+  userId,
+}: {
+  notificationId: string;
+  userId: string;
+}) {
+  const now = new Date();
+  return upsertInteraction({
+    notificationId,
+    userId,
+    onUpdate: { webappClickedAt: now },
+    onCreate: { webappClickedAt: now },
+  });
+}
+
+// --- Read: recent changelogs (for Help & Feedback) ---
+
+export async function getRecentChangelogs({ limit = 2 }: { limit?: number } = {}) {
+  // NOTE: Intentionally not filtering by archivedAt, startsAt, or endsAt.
+  // We want to show archived and expired changelogs in the "What's new" section
+  // so users can still find recent release notes.
+  const notifications = await prisma.platformNotification.findMany({
+    where: {
+      surface: "WEBAPP",
+      payload: { path: ["data", "type"], equals: "changelog" },
+    },
+    orderBy: [{ createdAt: "desc" }],
+    take: limit,
+  });
+
+  return notifications
+    .map((n) => {
+      const parsed = PayloadV1Schema.safeParse(n.payload);
+      if (!parsed.success) return null;
+      return { id: n.id, title: parsed.data.data.title, actionUrl: parsed.data.data.actionUrl };
+    })
+    .filter(Boolean) as Array<{ id: string; title: string; actionUrl?: string }>;
+}
+
+// --- CLI: next notification for CLI surface ---
+
+function isCliNotificationExpired(
+  interaction: {
+    userId: string;
+    firstSeenAt: Date;
+    showCount: number;
+    cliDismissedAt: Date | null;
+  } | null,
+  notification: {
+    id: string;
+    cliMaxDaysAfterFirstSeen: number | null;
+    cliMaxShowCount: number | null;
+  }
+): boolean {
+  if (!interaction) return false;
+
+  let expired = false;
+
+  if (
+    notification.cliMaxShowCount !== null &&
+    interaction.showCount >= notification.cliMaxShowCount
+  ) {
+    expired = true;
+  }
+
+  if (!expired && notification.cliMaxDaysAfterFirstSeen !== null) {
+    const daysSinceFirstSeen =
+      (Date.now() - interaction.firstSeenAt.getTime()) / (1000 * 60 * 60 * 24);
+    if (daysSinceFirstSeen > notification.cliMaxDaysAfterFirstSeen) {
+      expired = true;
+    }
+  }
+
+  // For time-based expiration, persist the dismiss on the next request
+  // (showCount-based dismissal is handled inline at display time)
+  if (expired && !interaction.cliDismissedAt) {
+    void prisma.platformNotificationInteraction.update({
+      where: {
+        notificationId_userId: {
+          notificationId: notification.id,
+          userId: interaction.userId,
+        },
+      },
+      data: { cliDismissedAt: new Date() },
+    });
+  }
+
+  return expired;
+}
+
+export async function getNextCliNotification({
+  userId,
+  projectRef,
+}: {
+  userId: string;
+  projectRef?: string;
+}): Promise<{
+  id: string;
+  payload: PayloadV1;
+  showCount: number;
+  firstSeenAt: string;
+} | null> {
+  const now = new Date();
+
+  // Resolve organizationId and projectId from projectRef if provided
+  let organizationId: string | undefined;
+  let projectId: string | undefined;
+
+  if (projectRef) {
+    const project = await prisma.project.findFirst({
+      where: {
+        externalRef: projectRef,
+        deletedAt: null,
+        organization: {
+          deletedAt: null,
+          members: { some: { userId } },
+        },
+      },
+      select: { id: true, organizationId: true },
+    });
+
+    if (project) {
+      projectId = project.id;
+      organizationId = project.organizationId;
+    }
+  }
+
+  // If no projectRef or project not found, get org from membership
+  if (!organizationId) {
+    const membership = await prisma.orgMember.findFirst({
+      where: { userId },
+      select: { organizationId: true },
+    });
+    if (membership) {
+      organizationId = membership.organizationId;
+    }
+  }
+
+  const scopeFilter: Array<Record<string, unknown>> = [
+    { scope: "GLOBAL" },
+    { scope: "USER", userId },
+  ];
+
+  if (organizationId) {
+    scopeFilter.push({ scope: "ORGANIZATION", organizationId });
+  }
+
+  if (projectId) {
+    scopeFilter.push({ scope: "PROJECT", projectId });
+  }
+
+  const notifications = await prisma.platformNotification.findMany({
+    where: {
+      surface: "CLI",
+      archivedAt: null,
+      startsAt: { lte: now },
+      endsAt: { gt: now },
+      AND: [{ OR: scopeFilter }],
+    },
+    include: {
+      interactions: {
+        where: { userId },
+      },
+    },
+    orderBy: [{ priority: "desc" }, { createdAt: "desc" }],
+  });
+
+  const sorted = [...notifications].sort(compareNotifications);
+
+  // Global per-user request counter stored in Redis, used for cliShowEvery modulo.
+  // This is independent of per-notification showCount so that cliMaxShowCount
+  // correctly tracks actual displays, not API encounters.
+  const requestCounter = await incrementCliRequestCounter(userId);
+
+  for (const n of sorted) {
+    const interaction = n.interactions[0] ?? null;
+
+    if (interaction?.cliDismissedAt) continue;
+    if (isCliNotificationExpired(interaction, n)) continue;
+
+    const parsed = PayloadV1Schema.safeParse(n.payload);
+    if (!parsed.success) continue;
+
+    // Check cliShowEvery using the global request counter
+    if (n.cliShowEvery !== null && requestCounter % n.cliShowEvery !== 0) {
+      continue;
+    }
+
+    // Only increment showCount when the notification will actually be displayed.
+    // If this display reaches cliMaxShowCount, also set cliDismissedAt now
+    // so it's recorded immediately rather than waiting for a future request.
+    const reachedMaxShows =
+      n.cliMaxShowCount !== null &&
+      ((interaction?.showCount ?? 0) + 1) >= n.cliMaxShowCount;
+
+    const updated = await prisma.platformNotificationInteraction.upsert({
+      where: { notificationId_userId: { notificationId: n.id, userId } },
+      update: {
+        showCount: { increment: 1 },
+        ...(reachedMaxShows ? { cliDismissedAt: now } : {}),
+      },
+      create: {
+        notificationId: n.id,
+        userId,
+        firstSeenAt: now,
+        showCount: 1,
+        ...(reachedMaxShows ? { cliDismissedAt: now } : {}),
+      },
+    });
+
+    return {
+      id: n.id,
+      payload: parsed.data,
+      showCount: updated.showCount,
+      firstSeenAt: updated.firstSeenAt.toISOString(),
+    };
+  }
+
+  return null;
+}
+
+// --- Create: admin endpoint support ---
+
+const SCOPE_REQUIRED_FK: Record<string, "userId" | "organizationId" | "projectId"> = {
+  USER: "userId",
+  ORGANIZATION: "organizationId",
+  PROJECT: "projectId",
+};
+
+const ALL_FK_FIELDS = ["userId", "organizationId", "projectId"] as const;
+const CLI_ONLY_FIELDS = ["cliMaxDaysAfterFirstSeen", "cliMaxShowCount", "cliShowEvery"] as const;
+
+export const CreatePlatformNotificationSchema = z
+  .object({
+    title: z.string().min(1),
+    payload: PayloadV1Schema,
+    surface: z.enum(["WEBAPP", "CLI"]),
+    scope: z.enum(["USER", "PROJECT", "ORGANIZATION", "GLOBAL"]),
+    userId: z.string().optional(),
+    organizationId: z.string().optional(),
+    projectId: z.string().optional(),
+    startsAt: z
+      .string()
+      .datetime()
+      .transform((s) => new Date(s))
+      .optional(),
+    endsAt: z
+      .string()
+      .datetime()
+      .transform((s) => new Date(s)),
+    priority: z.number().int().default(0),
+    cliMaxDaysAfterFirstSeen: z.number().int().positive().optional(),
+    cliMaxShowCount: z.number().int().positive().optional(),
+    cliShowEvery: z.number().int().min(2).optional(),
+  })
+  .superRefine((data, ctx) => {
+    validateScopeForeignKeys(data, ctx);
+    validateSurfaceFields(data, ctx);
+    validatePayloadTypeForSurface(data, ctx);
+    validateStartsAt(data, ctx);
+    validateEndsAt(data, ctx);
+  });
+
+function validateScopeForeignKeys(
+  data: { scope: string; userId?: string; organizationId?: string; projectId?: string },
+  ctx: z.RefinementCtx
+) {
+  const requiredFk = SCOPE_REQUIRED_FK[data.scope];
+
+  if (requiredFk && !data[requiredFk]) {
+    ctx.addIssue({
+      code: "custom",
+      message: `${requiredFk} is required when scope is ${data.scope}`,
+      path: [requiredFk],
+    });
+  }
+
+  const forbiddenFks = ALL_FK_FIELDS.filter((fk) => fk !== requiredFk);
+  for (const fk of forbiddenFks) {
+    if (data[fk]) {
+      ctx.addIssue({
+        code: "custom",
+        message: `${fk} must not be set when scope is ${data.scope}`,
+        path: [fk],
+      });
+    }
+  }
+}
+
+function validateSurfaceFields(
+  data: {
+    surface: string;
+    cliMaxDaysAfterFirstSeen?: number;
+    cliMaxShowCount?: number;
+    cliShowEvery?: number;
+  },
+  ctx: z.RefinementCtx
+) {
+  if (data.surface !== "WEBAPP") return;
+
+  for (const field of CLI_ONLY_FIELDS) {
+    if (data[field] !== undefined) {
+      ctx.addIssue({
+        code: "custom",
+        message: `${field} is not allowed for WEBAPP surface`,
+        path: [field],
+      });
+    }
+  }
+}
+
+function validateStartsAt(data: { startsAt?: Date }, ctx: z.RefinementCtx) {
+  if (!data.startsAt) return;
+
+  const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
+  if (data.startsAt < oneHourAgo) {
+    ctx.addIssue({
+      code: "custom",
+      message: "startsAt must be within the last hour or in the future",
+      path: ["startsAt"],
+    });
+  }
+}
+
+const CLI_TYPES = new Set(["info", "warn", "error", "success"]);
+const WEBAPP_TYPES = new Set(["card", "changelog"]);
+
+function validatePayloadTypeForSurface(
+  data: { surface: string; payload: PayloadV1 },
+  ctx: z.RefinementCtx
+) {
+  const allowedTypes = data.surface === "CLI" ? CLI_TYPES : WEBAPP_TYPES;
+  if (!allowedTypes.has(data.payload.data.type)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `payload.data.type "${data.payload.data.type}" is not allowed for ${data.surface} surface`,
+      path: ["payload", "data", "type"],
+    });
+  }
+}
+
+function validateEndsAt(data: { startsAt?: Date; endsAt: Date }, ctx: z.RefinementCtx) {
+  const effectiveStart = data.startsAt ?? new Date();
+  if (data.endsAt <= effectiveStart) {
+    ctx.addIssue({
+      code: "custom",
+      message: "endsAt must be after startsAt",
+      path: ["endsAt"],
+    });
+  }
+}
+
+export type CreatePlatformNotificationInput = z.input<typeof CreatePlatformNotificationSchema>;
+
+type CreateError =
+  | { type: "validation"; issues: z.ZodIssue[] }
+  | { type: "db"; message: string };
+
+export function createPlatformNotification(
+  input: CreatePlatformNotificationInput
+): ResultAsync<{ id: string; friendlyId: string }, CreateError> {
+  const parseResult = CreatePlatformNotificationSchema.safeParse(input);
+
+  if (!parseResult.success) {
+    return errAsync({ type: "validation", issues: parseResult.error.issues });
+  }
+
+  const data = parseResult.data;
+
+  return fromPromise(
+    prisma.platformNotification.create({
+      data: {
+        title: data.title,
+        payload: data.payload,
+        surface: data.surface as PlatformNotificationSurface,
+        scope: data.scope as PlatformNotificationScope,
+        userId: data.userId,
+        organizationId: data.organizationId,
+        projectId: data.projectId,
+        startsAt: data.startsAt ?? new Date(),
+        endsAt: data.endsAt,
+        priority: data.priority,
+        cliMaxDaysAfterFirstSeen: data.cliMaxDaysAfterFirstSeen,
+        cliMaxShowCount: data.cliMaxShowCount,
+        cliShowEvery: data.cliShowEvery,
+      },
+      select: { id: true, friendlyId: true },
+    }),
+    (e): CreateError => ({
+      type: "db",
+      message: e instanceof Error ? e.message : String(e),
+    })
+  );
+}
diff --git a/apps/webapp/app/services/postAuth.server.ts b/apps/webapp/app/services/postAuth.server.ts
index 39e914129a1..feb42ccaef8 100644
--- a/apps/webapp/app/services/postAuth.server.ts
+++ b/apps/webapp/app/services/postAuth.server.ts
@@ -10,5 +10,8 @@ export async function postAuthentication({
   loginMethod: User["authenticationMethod"];
   isNewUser: boolean;
 }) {
-  telemetry.user.identify({ user, isNewUser });
+  telemetry.user.identify({
+    user,
+    isNewUser,
+  });
 }
diff --git a/apps/webapp/app/services/preferences/uiPreferences.server.ts b/apps/webapp/app/services/preferences/uiPreferences.server.ts
index 0d23a546c2d..44282499db3 100644
--- a/apps/webapp/app/services/preferences/uiPreferences.server.ts
+++ b/apps/webapp/app/services/preferences/uiPreferences.server.ts
@@ -42,3 +42,15 @@ export async function setRootOnlyFilterPreference(rootOnly: boolean, request: Re
   session.set("rootOnly", rootOnly);
   return session;
 }
+
+export async function getTimezonePreference(request: Request): Promise<string> {
+  const session = await getUiPreferencesSession(request);
+  const timezone = session.get("timezone");
+  return typeof timezone === "string" ? timezone : "UTC";
+}
+
+export async function setTimezonePreference(timezone: string, request: Request) {
+  const session = await getUiPreferencesSession(request);
+  session.set("timezone", timezone);
+  return session;
+}
diff --git a/apps/webapp/app/services/projectSettings.server.ts b/apps/webapp/app/services/projectSettings.server.ts
index ae035d53008..3e265ee5e77 100644
--- a/apps/webapp/app/services/projectSettings.server.ts
+++ b/apps/webapp/app/services/projectSettings.server.ts
@@ -30,10 +30,10 @@ export class ProjectSettingsService {
     );
   }
 
-  deleteProject(projectSlug: string, userId: string) {
+  deleteProject(projectId: string, userId: string) {
     const deleteProjectService = new DeleteProjectService(this.#prismaClient);
 
-    return fromPromise(deleteProjectService.call({ projectSlug, userId }), (error) => ({
+    return fromPromise(deleteProjectService.call({ projectId, userId }), (error) => ({
       type: "other" as const,
       cause: error,
     }));
diff --git a/apps/webapp/app/services/queryConcurrencyLimiter.server.ts b/apps/webapp/app/services/queryConcurrencyLimiter.server.ts
new file mode 100644
index 00000000000..b623f018b1c
--- /dev/null
+++ b/apps/webapp/app/services/queryConcurrencyLimiter.server.ts
@@ -0,0 +1,29 @@
+import { env } from "~/env.server";
+import { singleton } from "~/utils/singleton";
+import { RedisConcurrencyLimiter } from "./redisConcurrencyLimiter.server";
+
+function initializeQueryConcurrencyLimiter() {
+  return new RedisConcurrencyLimiter({
+    keyPrefix: "query:concurrency",
+    redis: {
+      port: env.RATE_LIMIT_REDIS_PORT,
+      host: env.RATE_LIMIT_REDIS_HOST,
+      username: env.RATE_LIMIT_REDIS_USERNAME,
+      password: env.RATE_LIMIT_REDIS_PASSWORD,
+      tlsDisabled: env.RATE_LIMIT_REDIS_TLS_DISABLED === "true",
+      clusterMode: env.RATE_LIMIT_REDIS_CLUSTER_MODE_ENABLED === "1",
+    },
+  });
+}
+
+export const queryConcurrencyLimiter = singleton(
+  "queryConcurrencyLimiter",
+  initializeQueryConcurrencyLimiter
+);
+
+/** Default per-org concurrency limit from environment */
+export const DEFAULT_ORG_CONCURRENCY_LIMIT = env.QUERY_DEFAULT_ORG_CONCURRENCY_LIMIT;
+
+/** Global concurrency limit from environment */
+export const GLOBAL_CONCURRENCY_LIMIT = env.QUERY_GLOBAL_CONCURRENCY_LIMIT;
+
diff --git a/apps/webapp/app/services/queryService.server.ts b/apps/webapp/app/services/queryService.server.ts
new file mode 100644
index 00000000000..1f3bdbba18a
--- /dev/null
+++ b/apps/webapp/app/services/queryService.server.ts
@@ -0,0 +1,380 @@
+import {
+  executeTSQL,
+  QueryError,
+  type ClickHouseSettings,
+  type ExecuteTSQLOptions,
+  type FieldMappings,
+  type TSQLQueryResult,
+} from "@internal/clickhouse";
+import type { CustomerQuerySource } from "@trigger.dev/database";
+import type { TableSchema, WhereClauseCondition } from "@internal/tsql";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { queryClickhouseClient } from "./clickhouseInstance.server";
+import {
+  queryConcurrencyLimiter,
+  DEFAULT_ORG_CONCURRENCY_LIMIT,
+  GLOBAL_CONCURRENCY_LIMIT,
+} from "./queryConcurrencyLimiter.server";
+import { getLimit } from "./platform.v3.server";
+import { timeFilters, timeFilterFromTo } from "~/components/runs/v3/SharedFilters";
+import parse from "parse-duration";
+import { querySchemas, QueryScopeSchema, type QueryScope } from "~/v3/querySchemas";
+
+export { QueryScopeSchema };
+export type { TableSchema, TSQLQueryResult, QueryScope };
+
+const scopeToEnum = {
+  organization: "ORGANIZATION",
+  project: "PROJECT",
+  environment: "ENVIRONMENT",
+} as const;
+
+/**
+ * Default ClickHouse settings for query protection
+ * Based on PostHog's HogQL settings to prevent expensive queries
+ */
+function getDefaultClickhouseSettings(): ClickHouseSettings {
+  return {
+    // Query execution limits
+    max_execution_time: env.QUERY_CLICKHOUSE_MAX_EXECUTION_TIME,
+    timeout_overflow_mode: "throw",
+    max_memory_usage: String(env.QUERY_CLICKHOUSE_MAX_MEMORY_USAGE),
+
+    // AST complexity limits to prevent extremely complex queries
+    max_ast_elements: String(env.QUERY_CLICKHOUSE_MAX_AST_ELEMENTS),
+    max_expanded_ast_elements: String(env.QUERY_CLICKHOUSE_MAX_EXPANDED_AST_ELEMENTS),
+
+    // Memory management for GROUP BY operations
+    max_bytes_before_external_group_by: String(
+      env.QUERY_CLICKHOUSE_MAX_BYTES_BEFORE_EXTERNAL_GROUP_BY
+    ),
+
+    // Safety settings
+    format_csv_allow_double_quotes: 0,
+    readonly: "1", // Ensure queries are read-only
+  };
+}
+
+export type ExecuteQueryOptions<TOut extends z.ZodSchema> = Omit<
+  ExecuteTSQLOptions<TOut>,
+  "tableSchema" | "fieldMappings" | "enforcedWhereClause" | "whereClauseFallback" | "schema"
+> & {
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  /** The scope of the query - determines tenant isolation */
+  scope: QueryScope;
+  period?: string | null;
+  from?: string | null;
+  to?: string | null;
+  /** Filter to specific task identifiers */
+  taskIdentifiers?: string[];
+  /** Filter to specific queues */
+  queues?: string[];
+  /** Filter to specific response models */
+  responseModels?: string[];
+  /** Filter to specific prompt slugs */
+  promptSlugs?: string[];
+  /** Filter to specific prompt versions */
+  promptVersions?: number[];
+  /** Filter to specific operations (e.g. ai.generateText.doGenerate) */
+  operations?: string[];
+  /** Filter to specific providers (e.g. openai.responses) */
+  providers?: string[];
+  /** History options for saving query to billing/audit */
+  history?: {
+    /** Where the query originated from */
+    source: CustomerQuerySource;
+    /** User ID (optional, null for API calls) */
+    userId?: string | null;
+    /** Skip saving to history (e.g., when impersonating) */
+    skip?: boolean;
+  };
+  /** Custom per-org concurrency limit (overrides default) */
+  customOrgConcurrencyLimit?: number;
+};
+
+/**
+ * Extended result type that includes the optional queryId when saved to history
+ */
+export type ExecuteQueryResult<T> =
+  | {
+      success: true;
+      result: T;
+      queryId: string | null;
+      periodClipped: number | null;
+      maxQueryPeriod: number;
+      timeRange: { from: Date; to: Date };
+    }
+  | { success: false; error: Error };
+
+export async function getDefaultPeriod(organizationId: string): Promise<string> {
+  const idealDefaultPeriodDays = 7;
+  const maxQueryPeriod = await getLimit(organizationId, "queryPeriodDays", 30);
+  if (maxQueryPeriod < idealDefaultPeriodDays) {
+    return `${maxQueryPeriod}d`;
+  }
+  return `${idealDefaultPeriodDays}d`;
+}
+
+/**
+ * Execute a TSQL query against ClickHouse with tenant isolation
+ * Handles building tenant options, field mappings, and optionally saves to history
+ * Returns [error, result, queryId] where queryId is the CustomerQuery ID if saved to history
+ */
+export async function executeQuery<TOut extends z.ZodSchema>(
+  options: ExecuteQueryOptions<TOut>
+): Promise<ExecuteQueryResult<Exclude<TSQLQueryResult<z.output<TOut>>[1], null>>> {
+  const {
+    period,
+    from,
+    to,
+    scope,
+    organizationId,
+    projectId,
+    environmentId,
+    taskIdentifiers,
+    queues,
+    responseModels,
+    promptSlugs,
+    promptVersions,
+    operations,
+    providers,
+    history,
+    customOrgConcurrencyLimit,
+    ...baseOptions
+  } = options;
+
+  // Generate unique request ID for concurrency tracking
+  const requestId = crypto.randomUUID();
+  const orgLimit = customOrgConcurrencyLimit ?? DEFAULT_ORG_CONCURRENCY_LIMIT;
+
+  // Acquire concurrency slot
+  const acquireResult = await queryConcurrencyLimiter.acquire({
+    key: projectId,
+    requestId,
+    keyLimit: orgLimit,
+    globalLimit: GLOBAL_CONCURRENCY_LIMIT,
+  });
+
+  if (!acquireResult.success) {
+    const errorMessage =
+      acquireResult.reason === "key_limit"
+        ? `You've exceeded your query concurrency of ${orgLimit} for this project. Please try again later.`
+        : "We're experiencing a lot of queries at the moment. Please try again later.";
+    return { success: false, error: new QueryError(errorMessage, { query: options.query }) };
+  }
+
+  // Detect which table the query targets to determine the time column
+  // Each table schema declares its primary time column via timeConstraint
+  const matchedSchema = querySchemas.find((s) =>
+    new RegExp(`\\bFROM\\s+${s.name}\\b`, "i").test(options.query)
+  );
+  const timeColumn = matchedSchema?.timeConstraint ?? "triggered_at";
+
+  // Build time filter fallback for the table's time column
+  const defaultPeriod = await getDefaultPeriod(organizationId);
+  const timeFilter = timeFilters({
+    period: period ?? undefined,
+    from: from ?? undefined,
+    to: to ?? undefined,
+    defaultPeriod,
+  });
+
+  // Calculate the effective "from" date the user is requesting (for period clipping check)
+  // This is null only when the user specifies just a "to" date (rare case)
+  let requestedFromDate: Date | null = null;
+  if (timeFilter.from) {
+    requestedFromDate = new Date(timeFilter.from);
+  } else if (!timeFilter.to) {
+    // Period specified (or default) - calculate from now
+    const periodMs = parse(timeFilter.period ?? defaultPeriod) ?? 7 * 24 * 60 * 60 * 1000;
+    requestedFromDate = new Date(Date.now() - periodMs);
+  }
+
+  // Build the fallback WHERE condition based on what the user specified
+  let timeFallback: WhereClauseCondition;
+  if (timeFilter.from && timeFilter.to) {
+    timeFallback = { op: "between", low: timeFilter.from, high: timeFilter.to };
+  } else if (timeFilter.from) {
+    timeFallback = { op: "gte", value: timeFilter.from };
+  } else if (timeFilter.to) {
+    timeFallback = { op: "lte", value: timeFilter.to };
+  } else {
+    timeFallback = { op: "gte", value: requestedFromDate! };
+  }
+
+  const maxQueryPeriod = await getLimit(organizationId, "queryPeriodDays", 30);
+  const maxQueryPeriodDate = new Date(Date.now() - maxQueryPeriod * 24 * 60 * 60 * 1000);
+
+  // Check if the requested time period exceeds the plan limit
+  const periodClipped = requestedFromDate !== null && requestedFromDate < maxQueryPeriodDate;
+
+  // Force tenant isolation and time period limits
+  // Global tables (no tenantColumns) skip tenant isolation — they contain anonymized cross-tenant data
+  const isGlobalTable = matchedSchema != null && !matchedSchema.tenantColumns;
+  const enforcedWhereClause = {
+    ...(isGlobalTable
+      ? {}
+      : {
+          organization_id: { op: "eq", value: organizationId },
+          project_id:
+            scope === "project" || scope === "environment"
+              ? { op: "eq", value: projectId }
+              : undefined,
+          environment_id:
+            scope === "environment" ? { op: "eq", value: environmentId } : undefined,
+        }),
+    [timeColumn]: { op: "gte", value: maxQueryPeriodDate },
+    // Optional filters for tasks and queues
+    task_identifier:
+      taskIdentifiers && taskIdentifiers.length > 0
+        ? { op: "in", values: taskIdentifiers }
+        : undefined,
+    queue: queues && queues.length > 0 ? { op: "in", values: queues } : undefined,
+    response_model:
+      responseModels && responseModels.length > 0
+        ? { op: "in", values: responseModels }
+        : undefined,
+    prompt_slug:
+      promptSlugs && promptSlugs.length > 0 ? { op: "in", values: promptSlugs } : undefined,
+    prompt_version:
+      promptVersions && promptVersions.length > 0
+        ? { op: "in", values: promptVersions }
+        : undefined,
+    operation_id:
+      operations && operations.length > 0 ? { op: "in", values: operations } : undefined,
+    gen_ai_system:
+      providers && providers.length > 0 ? { op: "in", values: providers } : undefined,
+  } satisfies Record<string, WhereClauseCondition | undefined>;
+
+  // Compute the effective time range for timeBucket() interval calculation
+  const timeRange = timeFilterFromTo({
+    period: period ?? undefined,
+    from: from ?? undefined,
+    to: to ?? undefined,
+    defaultPeriod,
+  });
+
+  try {
+    // Build field mappings for project_ref → project_id and environment_id → slug translation
+    const projects = await prisma.project.findMany({
+      where: { organizationId },
+      select: { id: true, externalRef: true },
+    });
+
+    const environments = await prisma.runtimeEnvironment.findMany({
+      where: { project: { organizationId } },
+      select: { id: true, slug: true },
+    });
+
+    const fieldMappings: FieldMappings = {
+      project: Object.fromEntries(projects.map((p) => [p.id, p.externalRef])),
+      environment: Object.fromEntries(environments.map((e) => [e.id, e.slug])),
+    };
+
+    const result = await executeTSQL(queryClickhouseClient.reader, {
+      ...baseOptions,
+      schema: z.record(z.any()),
+      tableSchema: querySchemas,
+      transformValues: true,
+      enforcedWhereClause,
+      fieldMappings,
+      whereClauseFallback: {
+        [timeColumn]: timeFallback,
+      },
+      timeRange,
+      clickhouseSettings: {
+        ...getDefaultClickhouseSettings(),
+        ...baseOptions.clickhouseSettings, // Allow caller overrides if needed
+      },
+      querySettings: {
+        maxRows: env.QUERY_CLICKHOUSE_MAX_RETURNED_ROWS,
+        ...baseOptions.querySettings, // Allow caller overrides if needed
+      },
+    });
+
+    // If query failed, return early with no queryId
+    if (result[0] !== null) {
+      return { success: false, error: result[0] };
+    }
+
+    let queryId: string | null = null;
+
+    // If query succeeded and history options provided, save to history
+    // Skip history for EXPLAIN queries (admin debugging) and when explicitly skipped (e.g., impersonating)
+    if (history && !history.skip && !baseOptions.explain) {
+      // Check if this query is the same as the last one saved (avoid duplicate history entries)
+      const lastQuery = await prisma.customerQuery.findFirst({
+        where: {
+          organizationId,
+          source: history.source,
+          userId: history.userId ?? null,
+        },
+        orderBy: { createdAt: "desc" },
+        select: {
+          id: true,
+          query: true,
+          scope: true,
+          filterPeriod: true,
+          filterFrom: true,
+          filterTo: true,
+        },
+      });
+
+      // Save the effective period used for the query (timeFilters() handles defaults)
+      // Only save period if no custom from/to range was specified
+      const historyTimeFilter = {
+        period: timeFilter.from || timeFilter.to ? undefined : timeFilter.period,
+        from: timeFilter.from,
+        to: timeFilter.to,
+      };
+      const isDuplicate =
+        lastQuery &&
+        lastQuery.query === options.query &&
+        lastQuery.scope === scopeToEnum[scope] &&
+        lastQuery.filterPeriod === (timeFilter?.period ?? null) &&
+        lastQuery.filterFrom?.getTime() === (timeFilter?.from?.getTime() ?? undefined) &&
+        lastQuery.filterTo?.getTime() === (timeFilter?.to?.getTime() ?? undefined);
+
+      if (isDuplicate && lastQuery) {
+        // Return the existing query's ID for duplicate queries
+        queryId = lastQuery.id;
+      } else {
+        const created = await prisma.customerQuery.create({
+          data: {
+            query: options.query,
+            scope: scopeToEnum[scope],
+            stats: { ...result[1].stats },
+            source: history.source,
+            organizationId,
+            projectId: scope === "project" || scope === "environment" ? projectId : null,
+            environmentId: scope === "environment" ? environmentId : null,
+            userId: history.userId ?? null,
+            filterPeriod: historyTimeFilter?.period ?? null,
+            filterFrom: historyTimeFilter?.from ?? null,
+            filterTo: historyTimeFilter?.to ?? null,
+          },
+        });
+        queryId = created.id;
+      }
+    }
+
+    return {
+      success: true,
+      result: result[1],
+      queryId,
+      periodClipped: periodClipped ? maxQueryPeriod : null,
+      maxQueryPeriod,
+      timeRange,
+    };
+  } finally {
+    // Always release the concurrency slot
+    await queryConcurrencyLimiter.release({
+      key: projectId,
+      requestId,
+    });
+  }
+}
diff --git a/apps/webapp/app/services/realtime/redisRealtimeStreams.server.ts b/apps/webapp/app/services/realtime/redisRealtimeStreams.server.ts
index 25fb2d08e1f..e742f770a99 100644
--- a/apps/webapp/app/services/realtime/redisRealtimeStreams.server.ts
+++ b/apps/webapp/app/services/realtime/redisRealtimeStreams.server.ts
@@ -272,7 +272,7 @@ export class RedisRealtimeStreams implements StreamIngestor, StreamResponder {
       await redis.quit().catch(console.error);
     }
 
-    signal.addEventListener("abort", cleanup);
+    signal.addEventListener("abort", cleanup, { once: true });
 
     return new Response(stream, {
       headers: {
@@ -466,4 +466,8 @@ export class RedisRealtimeStreams implements StreamIngestor, StreamResponder {
       });
     }
   }
+
+  async readRecords(): Promise<never> {
+    throw new Error("readRecords is not implemented for Redis realtime streams");
+  }
 }
diff --git a/apps/webapp/app/services/realtime/s2realtimeStreams.server.ts b/apps/webapp/app/services/realtime/s2realtimeStreams.server.ts
index 1d03116ff57..4a7acb60606 100644
--- a/apps/webapp/app/services/realtime/s2realtimeStreams.server.ts
+++ b/apps/webapp/app/services/realtime/s2realtimeStreams.server.ts
@@ -1,6 +1,6 @@
 // app/realtime/S2RealtimeStreams.ts
 import type { UnkeyCache } from "@internal/cache";
-import { StreamIngestor, StreamResponder, StreamResponseOptions } from "./types";
+import { StreamIngestor, StreamRecord, StreamResponder, StreamResponseOptions } from "./types";
 import { Logger, LogLevel } from "@trigger.dev/core/logger";
 import { randomUUID } from "node:crypto";
 
@@ -10,6 +10,12 @@ export type S2RealtimeStreamsOptions = {
   accessToken: string; // "Bearer" token issued in S2 console
   streamPrefix?: string; // defaults to ""
 
+  // Custom endpoint for s2-lite (self-hosted)
+  endpoint?: string; // e.g., "http://localhost:4566/v1"
+
+  // Skip access token issuance (s2-lite doesn't support /access-tokens)
+  skipAccessTokens?: boolean;
+
   // Read behavior
   s2WaitSeconds?: number;
 
@@ -37,8 +43,11 @@ type S2AppendAck = {
 export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
   private readonly basin: string;
   private readonly baseUrl: string;
+  private readonly accountUrl: string;
+  private readonly endpoint?: string;
   private readonly token: string;
   private readonly streamPrefix: string;
+  private readonly skipAccessTokens: boolean;
 
   private readonly s2WaitSeconds: number;
 
@@ -56,9 +65,12 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
 
   constructor(opts: S2RealtimeStreamsOptions) {
     this.basin = opts.basin;
-    this.baseUrl = `https://${this.basin}.b.aws.s2.dev/v1`;
+    this.baseUrl = opts.endpoint ?? `https://${this.basin}.b.aws.s2.dev/v1`;
+    this.accountUrl = opts.endpoint ?? `https://aws.s2.dev/v1`;
+    this.endpoint = opts.endpoint;
     this.token = opts.accessToken;
     this.streamPrefix = opts.streamPrefix ?? "";
+    this.skipAccessTokens = opts.skipAccessTokens ?? false;
 
     this.s2WaitSeconds = opts.s2WaitSeconds ?? 60;
 
@@ -80,17 +92,20 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
     runId: string,
     streamId: string
   ): Promise<{ responseHeaders?: Record<string, string> }> {
-    const id = randomUUID();
-
-    const accessToken = await this.getS2AccessToken(id);
+    const accessToken = this.skipAccessTokens
+      ? this.token
+      : await this.getS2AccessToken(randomUUID());
 
     return {
       responseHeaders: {
         "X-S2-Access-Token": accessToken,
-        "X-S2-Stream-Name": `/runs/${runId}/${streamId}`,
+        "X-S2-Stream-Name": this.skipAccessTokens
+          ? this.toStreamName(runId, streamId)
+          : `/runs/${runId}/${streamId}`,
         "X-S2-Basin": this.basin,
         "X-S2-Flush-Interval-Ms": this.flushIntervalMs.toString(),
         "X-S2-Max-Retries": this.maxRetries.toString(),
+        ...(this.endpoint ? { "X-S2-Endpoint": this.endpoint } : {}),
       },
     };
   }
@@ -121,6 +136,88 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
     throw new Error("S2 streams are written to S2 via the client, not from the server");
   }
 
+  async readRecords(
+    runId: string,
+    streamId: string,
+    afterSeqNum?: number
+  ): Promise<StreamRecord[]> {
+    const s2Stream = this.toStreamName(runId, streamId);
+    const startSeq = afterSeqNum != null ? afterSeqNum + 1 : 0;
+
+    const qs = new URLSearchParams();
+    qs.set("seq_num", String(startSeq));
+    qs.set("clamp", "true");
+    qs.set("wait", "0"); // Non-blocking: return immediately with existing records
+
+    const res = await fetch(
+      `${this.baseUrl}/streams/${encodeURIComponent(s2Stream)}/records?${qs}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          Accept: "text/event-stream",
+          "S2-Format": "raw",
+          "S2-Basin": this.basin,
+        },
+      }
+    );
+
+    if (!res.ok) {
+      // Stream may not exist yet (no data sent)
+      if (res.status === 404) {
+        return [];
+      }
+      const text = await res.text().catch(() => "");
+      throw new Error(`S2 readRecords failed: ${res.status} ${res.statusText} ${text}`);
+    }
+
+    // Parse the SSE response body to extract records
+    const body = await res.text();
+    return this.parseSSEBatchRecords(body);
+  }
+
+  private parseSSEBatchRecords(sseText: string): StreamRecord[] {
+    const records: StreamRecord[] = [];
+
+    // SSE events are separated by double newlines
+    const events = sseText.split("\n\n").filter((e) => e.trim());
+
+    for (const event of events) {
+      const lines = event.split("\n");
+      let eventType: string | undefined;
+      let data: string | undefined;
+
+      for (const line of lines) {
+        if (line.startsWith("event:")) {
+          eventType = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          data = line.slice(5).trim();
+        }
+      }
+
+      if (eventType === "batch" && data) {
+        try {
+          const parsed = JSON.parse(data) as {
+            records: Array<{ body: string; seq_num: number; timestamp: number }>;
+          };
+
+          for (const record of parsed.records) {
+            const parsedBody = JSON.parse(record.body) as { data: string; id: string };
+            records.push({
+              data: parsedBody.data,
+              id: parsedBody.id,
+              seqNum: record.seq_num,
+            });
+          }
+        } catch {
+          // Skip malformed events
+        }
+      }
+    }
+
+    return records;
+  }
+
   // ---------- Serve SSE from S2 ----------
 
   async streamResponse(
@@ -155,7 +252,8 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
       headers: {
         Authorization: `Bearer ${this.token}`,
         "Content-Type": "application/json",
-        "S2-Format": "raw", // UTF-8 JSON encoding (no base64 overhead) when your data is text. :contentReference[oaicite:8]{index=8}
+        "S2-Format": "raw",
+        "S2-Basin": this.basin,
       },
       body: JSON.stringify(body),
     });
@@ -184,7 +282,7 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
 
   private async s2IssueAccessToken(id: string): Promise<string> {
     // POST /v1/access-tokens
-    const res = await fetch(`https://aws.s2.dev/v1/access-tokens`, {
+    const res = await fetch(`${this.accountUrl}/access-tokens`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.token}`,
@@ -235,6 +333,7 @@ export class S2RealtimeStreams implements StreamResponder, StreamIngestor {
         Authorization: `Bearer ${this.token}`,
         Accept: "text/event-stream",
         "S2-Format": "raw",
+        "S2-Basin": this.basin,
       },
       signal: opts.signal,
     });
diff --git a/apps/webapp/app/services/realtime/types.ts b/apps/webapp/app/services/realtime/types.ts
index 912711019ab..64433a716f4 100644
--- a/apps/webapp/app/services/realtime/types.ts
+++ b/apps/webapp/app/services/realtime/types.ts
@@ -1,3 +1,9 @@
+export type StreamRecord = {
+  data: string;
+  id: string;
+  seqNum: number;
+};
+
 // Interface for stream ingestion
 export interface StreamIngestor {
   initializeStream(
@@ -16,6 +22,12 @@ export interface StreamIngestor {
   appendPart(part: string, partId: string, runId: string, streamId: string): Promise<void>;
 
   getLastChunkIndex(runId: string, streamId: string, clientId: string): Promise<number>;
+
+  readRecords(
+    runId: string,
+    streamId: string,
+    afterSeqNum?: number
+  ): Promise<StreamRecord[]>;
 }
 
 export type StreamResponseOptions = {
diff --git a/apps/webapp/app/services/realtime/v1StreamsGlobal.server.ts b/apps/webapp/app/services/realtime/v1StreamsGlobal.server.ts
index 6c008b107eb..b1bf15b9fed 100644
--- a/apps/webapp/app/services/realtime/v1StreamsGlobal.server.ts
+++ b/apps/webapp/app/services/realtime/v1StreamsGlobal.server.ts
@@ -1,6 +1,6 @@
 import {
   createCache,
-  createMemoryStore,
+  createLRUMemoryStore,
   DefaultStatefulContext,
   Namespace,
   RedisCacheStore,
@@ -36,10 +36,16 @@ export function getRealtimeStreamInstance(
   if (streamVersion === "v1") {
     return v1RealtimeStreams;
   } else {
-    if (env.REALTIME_STREAMS_S2_BASIN && env.REALTIME_STREAMS_S2_ACCESS_TOKEN) {
+    if (
+      env.REALTIME_STREAMS_S2_BASIN &&
+      (env.REALTIME_STREAMS_S2_ACCESS_TOKEN ||
+        env.REALTIME_STREAMS_S2_SKIP_ACCESS_TOKENS === "true")
+    ) {
       return new S2RealtimeStreams({
         basin: env.REALTIME_STREAMS_S2_BASIN,
-        accessToken: env.REALTIME_STREAMS_S2_ACCESS_TOKEN,
+        accessToken: env.REALTIME_STREAMS_S2_ACCESS_TOKEN ?? "",
+        endpoint: env.REALTIME_STREAMS_S2_ENDPOINT,
+        skipAccessTokens: env.REALTIME_STREAMS_S2_SKIP_ACCESS_TOKENS === "true",
         streamPrefix: [
           "org",
           environment.organization.id,
@@ -68,7 +74,7 @@ export function determineRealtimeStreamsVersion(streamVersion?: string): "v1" |
   if (
     streamVersion === "v2" &&
     env.REALTIME_STREAMS_S2_BASIN &&
-    env.REALTIME_STREAMS_S2_ACCESS_TOKEN
+    (env.REALTIME_STREAMS_S2_ACCESS_TOKEN || env.REALTIME_STREAMS_S2_SKIP_ACCESS_TOKENS === "true")
   ) {
     return "v2";
   }
@@ -97,7 +103,7 @@ function initializeS2RealtimeStreamsCache() {
     useModernCacheKeyBuilder: true,
   });
 
-  const memoryStore = createMemoryStore(5000, 0.001);
+  const memoryStore = createLRUMemoryStore(5000);
 
   return createCache({
     accessToken: new Namespace<string>(ctx, {
diff --git a/apps/webapp/app/services/realtimeClient.server.ts b/apps/webapp/app/services/realtimeClient.server.ts
index f51d863267a..d962a57426e 100644
--- a/apps/webapp/app/services/realtimeClient.server.ts
+++ b/apps/webapp/app/services/realtimeClient.server.ts
@@ -8,7 +8,7 @@ import { longPollingFetch } from "~/utils/longPollingFetch";
 import { logger } from "./logger.server";
 import { jumpHash } from "@trigger.dev/core/v3/serverOnly";
 import { Cache, createCache, DefaultStatefulContext, Namespace } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { RedisCacheStore } from "./unkey/redisCacheStore.server";
 import { env } from "~/env.server";
 import { API_VERSIONS, CURRENT_API_VERSION } from "~/api/versions";
@@ -84,10 +84,7 @@ export class RealtimeClient {
     this.#registerCommands();
 
     const ctx = new DefaultStatefulContext();
-    const memory = new MemoryStore({
-      persistentMap: new Map(),
-      unstableEvictOnSet: { frequency: 0.01, maxItems: 1000 },
-    });
+    const memory = createLRUMemoryStore(1000);
     const redisCacheStore = new RedisCacheStore({
       connection: {
         keyPrefix: "tr:cache:realtime",
diff --git a/apps/webapp/app/services/redisConcurrencyLimiter.server.ts b/apps/webapp/app/services/redisConcurrencyLimiter.server.ts
new file mode 100644
index 00000000000..a4f87f88f43
--- /dev/null
+++ b/apps/webapp/app/services/redisConcurrencyLimiter.server.ts
@@ -0,0 +1,143 @@
+import { createRedisClient, type RedisClient, type RedisWithClusterOptions } from "~/redis.server";
+
+export type RedisConcurrencyLimiterOptions = {
+  redis: RedisWithClusterOptions;
+  /** Prefix for Redis keys */
+  keyPrefix: string;
+  /** Auto-expire stale entries after this many seconds (default: 300 = 5 minutes) */
+  expiryTimeInSeconds?: number;
+};
+
+export type AcquireResult =
+  | { success: true }
+  | { success: false; reason: "key_limit" | "global_limit" };
+
+/**
+ * A generic Redis-based concurrency limiter that supports two-level limiting:
+ * - Key-level limit (e.g., per organization)
+ * - Global limit (across all keys)
+ *
+ * Uses Redis sorted sets with timestamps to track active requests,
+ * with automatic expiry of stale entries as a safety net.
+ */
+export class RedisConcurrencyLimiter {
+  private redis: RedisClient;
+  private keyPrefix: string;
+  private expiryTimeInSeconds: number;
+
+  constructor(options: RedisConcurrencyLimiterOptions) {
+    this.redis = createRedisClient(`${options.keyPrefix}:limiter`, options.redis);
+    this.keyPrefix = options.keyPrefix;
+    this.expiryTimeInSeconds = options.expiryTimeInSeconds ?? 300; // 5 minutes default
+    this.#registerCommands();
+  }
+
+  /**
+   * Acquire a concurrency slot atomically checking both key and global limits.
+   *
+   * @param options.key - The key to limit (e.g., organizationId)
+   * @param options.requestId - A unique identifier for this request
+   * @param options.keyLimit - The maximum concurrent requests for this key
+   * @param options.globalLimit - The maximum concurrent requests globally
+   * @returns Success or failure with reason
+   */
+  async acquire(options: {
+    key: string;
+    requestId: string;
+    keyLimit: number;
+    globalLimit: number;
+  }): Promise<AcquireResult> {
+    const { key, requestId, keyLimit, globalLimit } = options;
+    const keyKey = this.#getKeyKey(key);
+    const globalKey = this.#getGlobalKey();
+    const now = Date.now();
+    const cutoffTime = now - this.expiryTimeInSeconds * 1000;
+
+    // @ts-expect-error - Custom command defined via defineCommand
+    const result = await this.redis.acquireConcurrency(
+      keyKey,
+      globalKey,
+      now.toString(),
+      requestId,
+      this.expiryTimeInSeconds.toString(),
+      cutoffTime.toString(),
+      keyLimit.toString(),
+      globalLimit.toString()
+    );
+
+    // Result: 1 = success, 0 = key limit exceeded, -1 = global limit exceeded
+    if (result === 1) {
+      return { success: true };
+    } else if (result === 0) {
+      return { success: false, reason: "key_limit" };
+    } else {
+      return { success: false, reason: "global_limit" };
+    }
+  }
+
+  /**
+   * Release a concurrency slot.
+   *
+   * @param options.key - The key that was used to acquire
+   * @param options.requestId - The request identifier used to acquire
+   */
+  async release(options: { key: string; requestId: string }): Promise<void> {
+    const { key, requestId } = options;
+    const keyKey = this.#getKeyKey(key);
+    const globalKey = this.#getGlobalKey();
+
+    // Remove from both sets in a single round trip
+    await this.redis.pipeline().zrem(keyKey, requestId).zrem(globalKey, requestId).exec();
+  }
+
+  #getKeyKey(key: string): string {
+    return `${this.keyPrefix}:key:${key}`;
+  }
+
+  #getGlobalKey(): string {
+    return `${this.keyPrefix}:global`;
+  }
+
+  #registerCommands() {
+    this.redis.defineCommand("acquireConcurrency", {
+      numberOfKeys: 2,
+      lua: /* lua */ `
+        local keyKey = KEYS[1]
+        local globalKey = KEYS[2]
+
+        local timestamp = tonumber(ARGV[1])
+        local requestId = ARGV[2]
+        local expiryTime = tonumber(ARGV[3])
+        local cutoffTime = tonumber(ARGV[4])
+        local keyLimit = tonumber(ARGV[5])
+        local globalLimit = tonumber(ARGV[6])
+
+        -- Remove expired entries from both sets
+        redis.call('ZREMRANGEBYSCORE', keyKey, '-inf', cutoffTime)
+        redis.call('ZREMRANGEBYSCORE', globalKey, '-inf', cutoffTime)
+
+        -- Check global limit first (more restrictive check)
+        local globalCount = redis.call('ZCARD', globalKey)
+        if globalCount >= globalLimit then
+            return -1  -- Global limit exceeded
+        end
+
+        -- Check key-specific limit
+        local keyCount = redis.call('ZCARD', keyKey)
+        if keyCount >= keyLimit then
+            return 0  -- Key limit exceeded
+        end
+
+        -- Add the request to both sorted sets
+        redis.call('ZADD', keyKey, timestamp, requestId)
+        redis.call('ZADD', globalKey, timestamp, requestId)
+
+        -- Set expiry on both keys
+        redis.call('EXPIRE', keyKey, expiryTime)
+        redis.call('EXPIRE', globalKey, expiryTime)
+
+        return 1  -- Success
+      `,
+    });
+  }
+}
diff --git a/apps/webapp/app/services/referralSource.server.ts b/apps/webapp/app/services/referralSource.server.ts
new file mode 100644
index 00000000000..e98c8ebcb2c
--- /dev/null
+++ b/apps/webapp/app/services/referralSource.server.ts
@@ -0,0 +1,53 @@
+import { createCookie } from "@remix-run/node";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { telemetry } from "~/services/telemetry.server";
+
+const ReferralSourceSchema = z.enum(["vercel"]);
+
+export type ReferralSource = z.infer<typeof ReferralSourceSchema>;
+
+// Cookie that persists for 1 hour to track referral source during login flow
+export const referralSourceCookie = createCookie("referral-source", {
+  maxAge: 60 * 60, // 1 hour
+  httpOnly: true,
+  sameSite: "lax",
+  secure: env.NODE_ENV === "production",
+});
+
+export async function getReferralSource(request: Request): Promise<ReferralSource | null> {
+  const cookie = request.headers.get("Cookie");
+  const value = await referralSourceCookie.parse(cookie);
+  const parsed = ReferralSourceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+
+export async function setReferralSourceCookie(source: ReferralSource): Promise<string> {
+  return referralSourceCookie.serialize(source);
+}
+
+export async function clearReferralSourceCookie(): Promise<string> {
+  return referralSourceCookie.serialize("", {
+    maxAge: 0,
+  });
+}
+
+export async function trackAndClearReferralSource(
+  request: Request,
+  userId: string,
+  headers: Headers
+): Promise<void> {
+  const referralSource = await getReferralSource(request);
+  if (!referralSource) return;
+
+  headers.append("Set-Cookie", await clearReferralSourceCookie());
+
+  const user = await prisma.user.findUnique({ where: { id: userId } });
+  if (!user) return;
+
+  const userAge = Date.now() - user.createdAt.getTime();
+  if (userAge >= 30 * 1000) return;
+
+  telemetry.user.identify({ user, isNewUser: true, referralSource });
+}
diff --git a/apps/webapp/app/services/requestIdempotency.server.ts b/apps/webapp/app/services/requestIdempotency.server.ts
index cda697b9688..85767ed8951 100644
--- a/apps/webapp/app/services/requestIdempotency.server.ts
+++ b/apps/webapp/app/services/requestIdempotency.server.ts
@@ -1,6 +1,6 @@
 import { Logger, LogLevel } from "@trigger.dev/core/logger";
 import { createCache, DefaultStatefulContext, Namespace, Cache as UnkeyCache } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { RedisCacheStore } from "./unkey/redisCacheStore.server";
 import { RedisWithClusterOptions } from "~/redis.server";
 import { validate as uuidValidate, version as uuidVersion } from "uuid";
@@ -33,13 +33,7 @@ export class RequestIdempotencyService<TTypes extends string> {
       : "request-idempotency:";
 
     const ctx = new DefaultStatefulContext();
-    const memory = new MemoryStore({
-      persistentMap: new Map(),
-      unstableEvictOnSet: {
-        frequency: 0.001,
-        maxItems: 1000,
-      },
-    });
+    const memory = createLRUMemoryStore(1000);
     const redisCacheStore = new RedisCacheStore({
       name: "request-idempotency",
       connection: {
diff --git a/apps/webapp/app/services/routeBuilders/apiBuilder.server.ts b/apps/webapp/app/services/routeBuilders/apiBuilder.server.ts
index 9fa2b8e5d05..e1f248927ae 100644
--- a/apps/webapp/app/services/routeBuilders/apiBuilder.server.ts
+++ b/apps/webapp/app/services/routeBuilders/apiBuilder.server.ts
@@ -758,6 +758,289 @@ export function createActionApiRoute<
   return { loader, action };
 }
 
+// ---------------------------------------------------------------------------
+// Multi-method action route builder
+// ---------------------------------------------------------------------------
+
+type HttpMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+
+type InferZod<T> = T extends z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>
+  ? z.infer<T>
+  : undefined;
+
+type MethodHandlerArgs<TParamsSchema, TSearchParamsSchema, THeadersSchema, TBodySchema> = {
+  params: InferZod<TParamsSchema>;
+  searchParams: InferZod<TSearchParamsSchema>;
+  headers: InferZod<THeadersSchema>;
+  body: InferZod<TBodySchema>;
+  authentication: ApiAuthenticationResultSuccess;
+  request: Request;
+};
+
+type MethodConfig<TParamsSchema, TSearchParamsSchema, THeadersSchema> = {
+  body?: AnyZodSchema;
+  handler: (
+    args: MethodHandlerArgs<TParamsSchema, TSearchParamsSchema, THeadersSchema, any>
+  ) => Promise<Response>;
+};
+
+type MultiMethodApiRouteOptions<
+  TParamsSchema extends AnyZodSchema | undefined = undefined,
+  TSearchParamsSchema extends AnyZodSchema | undefined = undefined,
+  THeadersSchema extends AnyZodSchema | undefined = undefined
+> = {
+  params?: TParamsSchema;
+  searchParams?: TSearchParamsSchema;
+  headers?: THeadersSchema;
+  allowJWT?: boolean;
+  corsStrategy?: "all" | "none";
+  authorization?: {
+    action: AuthorizationAction;
+    resource: (params: InferZod<TParamsSchema>) => AuthorizationResources;
+    superScopes?: string[];
+  };
+  maxContentLength?: number;
+  methods: Partial<
+    Record<HttpMethod, MethodConfig<TParamsSchema, TSearchParamsSchema, THeadersSchema>>
+  >;
+};
+
+/**
+ * Creates a Remix route that dispatches to different handlers based on HTTP method.
+ * Shares authentication, param parsing, CORS, and authorization across all methods.
+ * Each method can define its own body schema.
+ */
+export function createMultiMethodApiRoute<
+  TParamsSchema extends AnyZodSchema | undefined = undefined,
+  TSearchParamsSchema extends AnyZodSchema | undefined = undefined,
+  THeadersSchema extends AnyZodSchema | undefined = undefined
+>(options: MultiMethodApiRouteOptions<TParamsSchema, TSearchParamsSchema, THeadersSchema>) {
+  const {
+    params: paramsSchema,
+    searchParams: searchParamsSchema,
+    headers: headersSchema,
+    allowJWT = false,
+    corsStrategy = "none",
+    authorization,
+    maxContentLength,
+    methods,
+  } = options;
+
+  const allowedMethods = Object.keys(methods).join(", ");
+
+  async function loader({ request }: LoaderFunctionArgs) {
+    if (corsStrategy !== "none" && request.method.toUpperCase() === "OPTIONS") {
+      return apiCors(request, json({}));
+    }
+    return new Response(null, { status: 405 });
+  }
+
+  async function action({ request, params }: ActionFunctionArgs) {
+    const method = request.method.toUpperCase() as HttpMethod;
+    const methodConfig = methods[method];
+
+    if (!methodConfig) {
+      return await wrapResponse(
+        request,
+        json(
+          { error: "Method not allowed" },
+          { status: 405, headers: { Allow: allowedMethods } }
+        ),
+        corsStrategy !== "none"
+      );
+    }
+
+    try {
+      // Authenticate
+      const authenticationResult = await authenticateApiRequestWithFailure(request, { allowJWT });
+
+      if (!authenticationResult) {
+        return await wrapResponse(
+          request,
+          json({ error: "Invalid or Missing API key" }, { status: 401 }),
+          corsStrategy !== "none"
+        );
+      }
+
+      if (!authenticationResult.ok) {
+        return await wrapResponse(
+          request,
+          json({ error: authenticationResult.error }, { status: 401 }),
+          corsStrategy !== "none"
+        );
+      }
+
+      if (maxContentLength) {
+        const contentLength = request.headers.get("content-length");
+        if (!contentLength || parseInt(contentLength) > maxContentLength) {
+          return await wrapResponse(
+            request,
+            json({ error: "Request body too large" }, { status: 413 }),
+            corsStrategy !== "none"
+          );
+        }
+      }
+
+      // Parse params
+      let parsedParams: any = undefined;
+      if (paramsSchema) {
+        const parsed = paramsSchema.safeParse(params);
+        if (!parsed.success) {
+          return await wrapResponse(
+            request,
+            json(
+              { error: "Params Error", details: fromZodError(parsed.error).details },
+              { status: 400 }
+            ),
+            corsStrategy !== "none"
+          );
+        }
+        parsedParams = parsed.data;
+      }
+
+      // Parse search params
+      let parsedSearchParams: any = undefined;
+      if (searchParamsSchema) {
+        const searchParams = Object.fromEntries(new URL(request.url).searchParams);
+        const parsed = searchParamsSchema.safeParse(searchParams);
+        if (!parsed.success) {
+          return await wrapResponse(
+            request,
+            json(
+              { error: "Query Error", details: fromZodError(parsed.error).details },
+              { status: 400 }
+            ),
+            corsStrategy !== "none"
+          );
+        }
+        parsedSearchParams = parsed.data;
+      }
+
+      // Parse headers
+      let parsedHeaders: any = undefined;
+      if (headersSchema) {
+        const rawHeaders = Object.fromEntries(request.headers);
+        const headers = headersSchema.safeParse(rawHeaders);
+        if (!headers.success) {
+          return await wrapResponse(
+            request,
+            json(
+              { error: "Headers Error", details: fromZodError(headers.error).details },
+              { status: 400 }
+            ),
+            corsStrategy !== "none"
+          );
+        }
+        parsedHeaders = headers.data;
+      }
+
+      // Authorize
+      if (authorization) {
+        const { action, resource, superScopes } = authorization;
+        const $resource = resource(parsedParams);
+
+        logger.debug("Checking authorization", {
+          action,
+          resource: $resource,
+          superScopes,
+          scopes: authenticationResult.scopes,
+        });
+
+        const authorizationResult = checkAuthorization(
+          authenticationResult,
+          action,
+          $resource,
+          superScopes
+        );
+
+        if (!authorizationResult.authorized) {
+          return await wrapResponse(
+            request,
+            json(
+              {
+                error: `Unauthorized: ${authorizationResult.reason}`,
+                code: "unauthorized",
+                param: "access_token",
+                type: "authorization",
+              },
+              { status: 403 }
+            ),
+            corsStrategy !== "none"
+          );
+        }
+      }
+
+      // Parse body (per-method schema)
+      let parsedBody: any = undefined;
+      if (methodConfig.body) {
+        const rawBody = await request.text();
+        if (rawBody.length === 0) {
+          return await wrapResponse(
+            request,
+            json({ error: "Request body is empty" }, { status: 400 }),
+            corsStrategy !== "none"
+          );
+        }
+
+        const rawParsedJson = safeJsonParse(rawBody);
+        if (!rawParsedJson) {
+          return await wrapResponse(
+            request,
+            json({ error: "Invalid JSON" }, { status: 400 }),
+            corsStrategy !== "none"
+          );
+        }
+
+        const body = methodConfig.body.safeParse(rawParsedJson);
+        if (!body.success) {
+          return await wrapResponse(
+            request,
+            json({ error: fromZodError(body.error).toString() }, { status: 400 }),
+            corsStrategy !== "none"
+          );
+        }
+        parsedBody = body.data;
+      }
+
+      // Dispatch to method handler
+      const result = await methodConfig.handler({
+        params: parsedParams,
+        searchParams: parsedSearchParams,
+        headers: parsedHeaders,
+        body: parsedBody,
+        authentication: authenticationResult,
+        request,
+      });
+      return await wrapResponse(request, result, corsStrategy !== "none");
+    } catch (error) {
+      try {
+        if (error instanceof Response) {
+          return await wrapResponse(request, error, corsStrategy !== "none");
+        }
+
+        logger.error("Error in action", {
+          error:
+            error instanceof Error
+              ? { name: error.name, message: error.message, stack: error.stack }
+              : String(error),
+          url: request.url,
+        });
+
+        return await wrapResponse(
+          request,
+          json({ error: "Internal Server Error" }, { status: 500 }),
+          corsStrategy !== "none"
+        );
+      } catch (innerError) {
+        logger.error("[apiBuilder] Failed to handle error", { error, innerError });
+        return json({ error: "Internal Server Error" }, { status: 500 });
+      }
+    }
+  }
+
+  return { loader, action };
+}
+
 async function wrapResponse(
   request: Request,
   response: Response,
diff --git a/apps/webapp/app/services/runsReplicationInstance.server.ts b/apps/webapp/app/services/runsReplicationInstance.server.ts
index 3830d3dd6d3..0a8ab5e1bde 100644
--- a/apps/webapp/app/services/runsReplicationInstance.server.ts
+++ b/apps/webapp/app/services/runsReplicationInstance.server.ts
@@ -2,7 +2,7 @@ import { ClickHouse } from "@internal/clickhouse";
 import invariant from "tiny-invariant";
 import { env } from "~/env.server";
 import { singleton } from "~/utils/singleton";
-import { provider } from "~/v3/tracer.server";
+import { meter, provider } from "~/v3/tracer.server";
 import { RunsReplicationService } from "./runsReplicationService.server";
 import { signalsEmitter } from "./signals.server";
 
@@ -62,11 +62,13 @@ function initializeRunsReplicationInstance() {
     logLevel: env.RUN_REPLICATION_LOG_LEVEL,
     waitForAsyncInsert: env.RUN_REPLICATION_WAIT_FOR_ASYNC_INSERT === "1",
     tracer: provider.getTracer("runs-replication-service"),
+    meter,
     insertMaxRetries: env.RUN_REPLICATION_INSERT_MAX_RETRIES,
     insertBaseDelayMs: env.RUN_REPLICATION_INSERT_BASE_DELAY_MS,
     insertMaxDelayMs: env.RUN_REPLICATION_INSERT_MAX_DELAY_MS,
     insertStrategy: env.RUN_REPLICATION_INSERT_STRATEGY,
     disablePayloadInsert: env.RUN_REPLICATION_DISABLE_PAYLOAD_INSERT === "1",
+    disableErrorFingerprinting: env.RUN_REPLICATION_DISABLE_ERROR_FINGERPRINTING === "1",
   });
 
   if (env.RUN_REPLICATION_ENABLED === "1") {
diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts
index c150eb2a005..7930c05481f 100644
--- a/apps/webapp/app/services/runsReplicationService.server.ts
+++ b/apps/webapp/app/services/runsReplicationService.server.ts
@@ -1,4 +1,5 @@
-import type { ClickHouse, RawTaskRunPayloadV1, TaskRunV2 } from "@internal/clickhouse";
+import type { ClickHouse, TaskRunInsertArray, PayloadInsertArray } from "@internal/clickhouse";
+import { getTaskRunField, getPayloadField } from "@internal/clickhouse";
 import { type RedisOptions } from "@internal/redis";
 import {
   LogicalReplicationClient,
@@ -7,15 +8,27 @@ import {
   type MessageUpdate,
   type PgoutputMessage,
 } from "@internal/replication";
-import { recordSpanError, startSpan, trace, type Tracer } from "@internal/tracing";
+import {
+  getMeter,
+  recordSpanError,
+  startSpan,
+  trace,
+  type Counter,
+  type Histogram,
+  type Meter,
+  type Tracer,
+} from "@internal/tracing";
 import { Logger, type LogLevel } from "@trigger.dev/core/logger";
 import { tryCatch } from "@trigger.dev/core/utils";
 import { parsePacketAsJson } from "@trigger.dev/core/v3/utils/ioSerialization";
+import { unsafeExtractIdempotencyKeyScope, unsafeExtractIdempotencyKeyUser } from "@trigger.dev/core/v3/serverOnly";
+import { RunAnnotations } from "@trigger.dev/core/v3";
 import { type TaskRun } from "@trigger.dev/database";
 import { nanoid } from "nanoid";
 import EventEmitter from "node:events";
 import pLimit from "p-limit";
 import { detectBadJsonStrings } from "~/utils/detectBadJsonStrings";
+import { calculateErrorFingerprint } from "~/utils/errorFingerprinting";
 
 interface TransactionEvent<T = any> {
   tag: "insert" | "update" | "delete";
@@ -51,6 +64,7 @@ export type RunsReplicationServiceOptions = {
   logger?: Logger;
   logLevel?: LogLevel;
   tracer?: Tracer;
+  meter?: Meter;
   waitForAsyncInsert?: boolean;
   insertStrategy?: "insert" | "insert_async";
   // Retry configuration for insert operations
@@ -58,6 +72,7 @@ export type RunsReplicationServiceOptions = {
   insertBaseDelayMs?: number;
   insertMaxDelayMs?: number;
   disablePayloadInsert?: boolean;
+  disableErrorFingerprinting?: boolean;
 };
 
 type PostgresTaskRun = TaskRun & { masterQueue: string };
@@ -71,7 +86,7 @@ type TaskRunInsert = {
 export type RunsReplicationServiceEvents = {
   message: [{ lsn: string; message: PgoutputMessage; service: RunsReplicationService }];
   batchFlushed: [
-    { flushId: string; taskRunInserts: TaskRunV2[]; payloadInserts: RawTaskRunPayloadV1[] }
+    { flushId: string; taskRunInserts: TaskRunInsertArray[]; payloadInserts: PayloadInsertArray[] }
   ];
 };
 
@@ -90,6 +105,7 @@ export class RunsReplicationService {
   private _isShuttingDown = false;
   private _isShutDownComplete = false;
   private _tracer: Tracer;
+  private _meter: Meter;
   private _currentParseDurationMs: number | null = null;
   private _lastAcknowledgedAt: number | null = null;
   private _acknowledgeTimeoutMs: number;
@@ -102,6 +118,17 @@ export class RunsReplicationService {
   private _insertMaxDelayMs: number;
   private _insertStrategy: "insert" | "insert_async";
   private _disablePayloadInsert: boolean;
+  private _disableErrorFingerprinting: boolean;
+
+  // Metrics
+  private _replicationLagHistogram: Histogram;
+  private _batchesFlushedCounter: Counter;
+  private _batchSizeHistogram: Histogram;
+  private _taskRunsInsertedCounter: Counter;
+  private _payloadsInsertedCounter: Counter;
+  private _insertRetriesCounter: Counter;
+  private _eventsProcessedCounter: Counter;
+  private _flushDurationHistogram: Histogram;
 
   public readonly events: EventEmitter<RunsReplicationServiceEvents>;
 
@@ -110,11 +137,63 @@ export class RunsReplicationService {
       options.logger ?? new Logger("RunsReplicationService", options.logLevel ?? "info");
     this.events = new EventEmitter();
     this._tracer = options.tracer ?? trace.getTracer("runs-replication-service");
+    this._meter = options.meter ?? getMeter("runs-replication");
+
+    // Initialize metrics
+    this._replicationLagHistogram = this._meter.createHistogram(
+      "runs_replication.replication_lag_ms",
+      {
+        description: "Replication lag from Postgres commit to processing",
+        unit: "ms",
+      }
+    );
+
+    this._batchesFlushedCounter = this._meter.createCounter("runs_replication.batches_flushed", {
+      description: "Total batches flushed to ClickHouse",
+    });
+
+    this._batchSizeHistogram = this._meter.createHistogram("runs_replication.batch_size", {
+      description: "Number of items per batch flush",
+      unit: "items",
+    });
+
+    this._taskRunsInsertedCounter = this._meter.createCounter(
+      "runs_replication.task_runs_inserted",
+      {
+        description: "Task run inserts to ClickHouse",
+        unit: "inserts",
+      }
+    );
+
+    this._payloadsInsertedCounter = this._meter.createCounter(
+      "runs_replication.payloads_inserted",
+      {
+        description: "Payload inserts to ClickHouse",
+        unit: "inserts",
+      }
+    );
+
+    this._insertRetriesCounter = this._meter.createCounter("runs_replication.insert_retries", {
+      description: "Insert retry attempts",
+    });
+
+    this._eventsProcessedCounter = this._meter.createCounter("runs_replication.events_processed", {
+      description: "Replication events processed (inserts, updates, deletes)",
+    });
+
+    this._flushDurationHistogram = this._meter.createHistogram(
+      "runs_replication.flush_duration_ms",
+      {
+        description: "Duration of batch flush operations",
+        unit: "ms",
+      }
+    );
 
     this._acknowledgeTimeoutMs = options.acknowledgeTimeoutMs ?? 1_000;
 
     this._insertStrategy = options.insertStrategy ?? "insert";
     this._disablePayloadInsert = options.disablePayloadInsert ?? false;
+    this._disableErrorFingerprinting = options.disableErrorFingerprinting ?? false;
 
     this._replicationClient = new LogicalReplicationClient({
       pgConfig: {
@@ -141,34 +220,18 @@ export class RunsReplicationService {
       flushInterval: options.flushIntervalMs ?? 100,
       maxConcurrency: options.maxFlushConcurrency ?? 100,
       callback: this.#flushBatch.bind(this),
-      // we can do some pre-merging to reduce the amount of data we need to send to clickhouse
-      mergeBatch: (existingBatch: TaskRunInsert[], newBatch: TaskRunInsert[]) => {
-        const merged = new Map<string, TaskRunInsert>();
-
-        for (const item of existingBatch) {
-          const key = `${item.event}_${item.run.id}`;
-          merged.set(key, item);
+      // Key-based deduplication to reduce duplicates sent to ClickHouse
+      getKey: (item) => {
+        if (!item?.run?.id) {
+          this.logger.warn("Skipping replication event with null run", { event: item });
+          return null;
         }
-
-        for (const item of newBatch) {
-          if (!item?.run?.id) {
-            this.logger.warn("Skipping replication event with null run", { event: item });
-            continue;
-          }
-
-          const key = `${item.event}_${item.run.id}`;
-          const existingItem = merged.get(key);
-
-          // Keep the run with the higher version (latest)
-          // and take the last occurrence for that version.
-          // Items originating from the same DB transaction have the same version.
-          if (!existingItem || item._version >= existingItem._version) {
-            merged.set(key, item);
-          }
-        }
-
-        return Array.from(merged.values());
+        return `${item.event}_${item.run.id}`;
       },
+      // Keep the run with the higher version (latest)
+      // and take the last occurrence for that version.
+      // Items originating from the same DB transaction have the same version.
+      shouldReplace: (existing, incoming) => incoming._version >= existing._version,
       logger: new Logger("ConcurrentFlushScheduler", options.logLevel ?? "info"),
       tracer: options.tracer,
     });
@@ -423,22 +486,15 @@ export class RunsReplicationService {
       }))
     );
 
-    this._tracer
-      .startSpan("handle_transaction", {
-        attributes: {
-          "transaction.xid": transaction.xid,
-          "transaction.replication_lag_ms": transaction.replicationLagMs,
-          "transaction.events": transaction.events.length,
-          "transaction.commit_end_lsn": transaction.commitEndLsn,
-          "transaction.parse_duration_ms": this._currentParseDurationMs ?? undefined,
-          "transaction.lsn_to_uint64_ms": lsnToUInt64DurationMs,
-          "transaction.version": _version.toString(),
-        },
-        startTime: transaction.beginStartTimestamp,
-      })
-      .end();
+    // Record metrics
+    this._replicationLagHistogram.record(transaction.replicationLagMs);
+
+    // Count events by type
+    for (const event of transaction.events) {
+      this._eventsProcessedCounter.add(1, { event_type: event.tag });
+    }
 
-    this.logger.info("handle_transaction", {
+    this.logger.debug("handle_transaction", {
       transaction: {
         xid: transaction.xid,
         commitLsn: transaction.commitLsn,
@@ -473,7 +529,7 @@ export class RunsReplicationService {
     this._lastAcknowledgedAt = now;
     this._lastAcknowledgedLsn = this._latestCommitEndLsn;
 
-    this.logger.info("acknowledge_latest_transaction", {
+    this.logger.debug("acknowledge_latest_transaction", {
       commitEndLsn: this._latestCommitEndLsn,
       lastAcknowledgedAt: this._lastAcknowledgedAt,
     });
@@ -501,6 +557,8 @@ export class RunsReplicationService {
       batchSize: batch.length,
     });
 
+    const flushStartTime = performance.now();
+
     await startSpan(this._tracer, "flushBatch", async (span) => {
       const preparedInserts = await startSpan(this._tracer, "prepare_inserts", async (span) => {
         return await Promise.all(batch.map(this.#prepareRunInserts.bind(this)));
@@ -508,32 +566,46 @@ export class RunsReplicationService {
 
       const taskRunInserts = preparedInserts
         .map(({ taskRunInsert }) => taskRunInsert)
-        .filter(Boolean)
+        .filter((x): x is TaskRunInsertArray => Boolean(x))
         // batch inserts in clickhouse are more performant if the items
         // are pre-sorted by the primary key
         .sort((a, b) => {
-          if (a.organization_id !== b.organization_id) {
-            return a.organization_id < b.organization_id ? -1 : 1;
+          const aOrgId = getTaskRunField(a, "organization_id");
+          const bOrgId = getTaskRunField(b, "organization_id");
+          if (aOrgId !== bOrgId) {
+            return aOrgId < bOrgId ? -1 : 1;
           }
-          if (a.project_id !== b.project_id) {
-            return a.project_id < b.project_id ? -1 : 1;
+          const aProjId = getTaskRunField(a, "project_id");
+          const bProjId = getTaskRunField(b, "project_id");
+          if (aProjId !== bProjId) {
+            return aProjId < bProjId ? -1 : 1;
           }
-          if (a.environment_id !== b.environment_id) {
-            return a.environment_id < b.environment_id ? -1 : 1;
+          const aEnvId = getTaskRunField(a, "environment_id");
+          const bEnvId = getTaskRunField(b, "environment_id");
+          if (aEnvId !== bEnvId) {
+            return aEnvId < bEnvId ? -1 : 1;
           }
-          if (a.created_at !== b.created_at) {
-            return a.created_at - b.created_at;
+          const aCreatedAt = getTaskRunField(a, "created_at");
+          const bCreatedAt = getTaskRunField(b, "created_at");
+          if (aCreatedAt !== bCreatedAt) {
+            return aCreatedAt - bCreatedAt;
           }
-          return a.run_id < b.run_id ? -1 : 1;
+          const aRunId = getTaskRunField(a, "run_id");
+          const bRunId = getTaskRunField(b, "run_id");
+          if (aRunId === bRunId) return 0;
+          return aRunId < bRunId ? -1 : 1;
         });
 
       const payloadInserts = preparedInserts
         .map(({ payloadInsert }) => payloadInsert)
-        .filter(Boolean)
+        .filter((x): x is PayloadInsertArray => Boolean(x))
         // batch inserts in clickhouse are more performant if the items
         // are pre-sorted by the primary key
         .sort((a, b) => {
-          return a.run_id < b.run_id ? -1 : 1;
+          const aRunId = getPayloadField(a, "run_id");
+          const bRunId = getPayloadField(b, "run_id");
+          if (aRunId === bRunId) return 0;
+          return aRunId < bRunId ? -1 : 1;
         });
 
       span.setAttribute("task_run_inserts", taskRunInserts.length);
@@ -563,7 +635,6 @@ export class RunsReplicationService {
         this.logger.error("Error inserting task run inserts", {
           error: taskRunError,
           flushId,
-          runIds: taskRunInserts.map((r) => r.run_id),
         });
         recordSpanError(span, taskRunError);
       }
@@ -572,7 +643,6 @@ export class RunsReplicationService {
         this.logger.error("Error inserting payload inserts", {
           error: payloadError,
           flushId,
-          runIds: payloadInserts.map((r) => r.run_id),
         });
         recordSpanError(span, payloadError);
       }
@@ -584,6 +654,22 @@ export class RunsReplicationService {
       });
 
       this.events.emit("batchFlushed", { flushId, taskRunInserts, payloadInserts });
+
+      // Record metrics
+      const flushDurationMs = performance.now() - flushStartTime;
+      const hasErrors = taskRunError !== null || payloadError !== null;
+
+      this._batchSizeHistogram.record(batch.length);
+      this._flushDurationHistogram.record(flushDurationMs);
+      this._batchesFlushedCounter.add(1, { success: !hasErrors });
+
+      if (!taskRunError) {
+        this._taskRunsInsertedCounter.add(taskRunInserts.length);
+      }
+
+      if (!payloadError) {
+        this._payloadsInsertedCounter.add(payloadInserts.length);
+      }
     });
   }
 
@@ -615,6 +701,10 @@ export class RunsReplicationService {
             delay,
           });
 
+          // Record retry metric
+          const operation = operationName.includes("task run") ? "task_runs" : "payloads";
+          this._insertRetriesCounter.add(1, { operation });
+
           await new Promise((resolve) => setTimeout(resolve, delay));
           continue;
         }
@@ -670,26 +760,24 @@ export class RunsReplicationService {
   #getClickhouseInsertSettings() {
     if (this._insertStrategy === "insert") {
       return {};
-    } else if (this._insertStrategy === "insert_async") {
-      return {
-        async_insert: 1 as const,
-        async_insert_max_data_size: "1000000",
-        async_insert_busy_timeout_ms: 1000,
-        wait_for_async_insert: this.options.waitForAsyncInsert ? (1 as const) : (0 as const),
-      };
     }
+
+    return {
+      async_insert: 1 as const,
+      async_insert_max_data_size: "1000000",
+      async_insert_busy_timeout_ms: 1000,
+      wait_for_async_insert: this.options.waitForAsyncInsert ? (1 as const) : (0 as const),
+    };
   }
 
-  async #insertTaskRunInserts(taskRunInserts: TaskRunV2[], attempt: number) {
+  async #insertTaskRunInserts(taskRunInserts: TaskRunInsertArray[], attempt: number) {
     return await startSpan(this._tracer, "insertTaskRunsInserts", async (span) => {
-      const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insert(
-        taskRunInserts,
-        {
+      const [insertError, insertResult] =
+        await this.options.clickhouse.taskRuns.insertCompactArrays(taskRunInserts, {
           params: {
             clickhouse_settings: this.#getClickhouseInsertSettings(),
           },
-        }
-      );
+        });
 
       if (insertError) {
         this.logger.error("Error inserting task run inserts attempt", {
@@ -705,16 +793,14 @@ export class RunsReplicationService {
     });
   }
 
-  async #insertPayloadInserts(payloadInserts: RawTaskRunPayloadV1[], attempt: number) {
+  async #insertPayloadInserts(payloadInserts: PayloadInsertArray[], attempt: number) {
     return await startSpan(this._tracer, "insertPayloadInserts", async (span) => {
-      const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertPayloads(
-        payloadInserts,
-        {
+      const [insertError, insertResult] =
+        await this.options.clickhouse.taskRuns.insertPayloadsCompactArrays(payloadInserts, {
           params: {
             clickhouse_settings: this.#getClickhouseInsertSettings(),
           },
-        }
-      );
+        });
 
       if (insertError) {
         this.logger.error("Error inserting payload inserts attempt", {
@@ -732,25 +818,15 @@ export class RunsReplicationService {
 
   async #prepareRunInserts(
     batchedRun: TaskRunInsert
-  ): Promise<{ taskRunInsert?: TaskRunV2; payloadInsert?: RawTaskRunPayloadV1 }> {
+  ): Promise<{ taskRunInsert?: TaskRunInsertArray; payloadInsert?: PayloadInsertArray }> {
     this.logger.debug("Preparing run", {
       batchedRun,
     });
 
     const { run, _version, event } = batchedRun;
 
-    if (!run.environmentType) {
-      return {
-        taskRunInsert: undefined,
-        payloadInsert: undefined,
-      };
-    }
-
-    if (!run.organizationId) {
-      return {
-        taskRunInsert: undefined,
-        payloadInsert: undefined,
-      };
+    if (!run.environmentType || !run.organizationId) {
+      return {};
     }
 
     if (event === "update" || event === "delete" || this._disablePayloadInsert) {
@@ -762,10 +838,7 @@ export class RunsReplicationService {
         _version
       );
 
-      return {
-        taskRunInsert,
-        payloadInsert: undefined,
-      };
+      return { taskRunInsert };
     }
 
     const [taskRunInsert, payloadInsert] = await Promise.all([
@@ -773,10 +846,7 @@ export class RunsReplicationService {
       this.#preparePayloadInsert(run, _version),
     ]);
 
-    return {
-      taskRunInsert,
-      payloadInsert,
-    };
+    return { taskRunInsert, payloadInsert };
   }
 
   async #prepareTaskRunInsert(
@@ -785,65 +855,89 @@ export class RunsReplicationService {
     environmentType: string,
     event: "insert" | "update" | "delete",
     _version: bigint
-  ): Promise<TaskRunV2> {
+  ): Promise<TaskRunInsertArray> {
     const output = await this.#prepareJson(run.output, run.outputType);
+    const errorData = { data: run.error };
+
+    // Calculate error fingerprint for failed runs
+    const errorFingerprint = (
+      !this._disableErrorFingerprinting &&
+      ['SYSTEM_FAILURE', 'CRASHED', 'INTERRUPTED', 'COMPLETED_WITH_ERRORS', 'TIMED_OUT'].includes(run.status)
+    )
+      ? calculateErrorFingerprint(run.error)
+      : '';
+
+    const annotations = this.#parseAnnotations(run.annotations);
+
+    // Return array matching TASK_RUN_COLUMNS order
+    return [
+      run.runtimeEnvironmentId, // environment_id
+      organizationId, // organization_id
+      run.projectId, // project_id
+      run.id, // run_id
+      run.updatedAt.getTime(), // updated_at
+      run.createdAt.getTime(), // created_at
+      run.status, // status
+      environmentType, // environment_type
+      run.friendlyId, // friendly_id
+      run.attemptNumber ?? 1, // attempt
+      run.engine, // engine
+      run.taskIdentifier, // task_identifier
+      run.queue, // queue
+      run.scheduleId ?? "", // schedule_id
+      run.batchId ?? "", // batch_id
+      run.completedAt?.getTime() ?? null, // completed_at
+      run.startedAt?.getTime() ?? null, // started_at
+      run.executedAt?.getTime() ?? null, // executed_at
+      run.delayUntil?.getTime() ?? null, // delay_until
+      run.queuedAt?.getTime() ?? null, // queued_at
+      run.expiredAt?.getTime() ?? null, // expired_at
+      run.usageDurationMs ?? 0, // usage_duration_ms
+      run.costInCents ?? 0, // cost_in_cents
+      run.baseCostInCents ?? 0, // base_cost_in_cents
+      output, // output
+      errorData, // error
+      errorFingerprint, // error_fingerprint
+      run.runTags ?? [], // tags
+      run.taskVersion ?? "", // task_version
+      run.sdkVersion ?? "", // sdk_version
+      run.cliVersion ?? "", // cli_version
+      run.machinePreset ?? "", // machine_preset
+      run.rootTaskRunId ?? "", // root_run_id
+      run.parentTaskRunId ?? "", // parent_run_id
+      run.depth ?? 0, // depth
+      run.spanId, // span_id
+      run.traceId, // trace_id
+      run.idempotencyKey ?? "", // idempotency_key
+      unsafeExtractIdempotencyKeyUser(run) ?? "", // idempotency_key_user
+      unsafeExtractIdempotencyKeyScope(run) ?? "", // idempotency_key_scope
+      run.ttl ?? "", // expiration_ttl
+      run.isTest ?? false, // is_test
+      _version.toString(), // _version
+      event === "delete" ? 1 : 0, // _is_deleted
+      run.concurrencyKey ?? "", // concurrency_key
+      run.bulkActionGroupIds ?? [], // bulk_action_group_ids
+      run.masterQueue ?? "", // worker_queue
+      run.maxDurationInSeconds ?? null, // max_duration_in_seconds
+      annotations?.triggerSource ?? "", // trigger_source
+      annotations?.rootTriggerSource ?? "", // root_trigger_source
+      run.isWarmStart ?? null, // is_warm_start
+    ];
+  }
 
-    return {
-      environment_id: run.runtimeEnvironmentId,
-      organization_id: organizationId,
-      project_id: run.projectId,
-      run_id: run.id,
-      updated_at: run.updatedAt.getTime(),
-      created_at: run.createdAt.getTime(),
-      status: run.status,
-      environment_type: environmentType,
-      friendly_id: run.friendlyId,
-      engine: run.engine,
-      task_identifier: run.taskIdentifier,
-      queue: run.queue,
-      span_id: run.spanId,
-      trace_id: run.traceId,
-      error: { data: run.error },
-      attempt: run.attemptNumber ?? 1,
-      schedule_id: run.scheduleId ?? "",
-      batch_id: run.batchId ?? "",
-      completed_at: run.completedAt?.getTime(),
-      started_at: run.startedAt?.getTime(),
-      executed_at: run.executedAt?.getTime(),
-      delay_until: run.delayUntil?.getTime(),
-      queued_at: run.queuedAt?.getTime(),
-      expired_at: run.expiredAt?.getTime(),
-      usage_duration_ms: run.usageDurationMs,
-      cost_in_cents: run.costInCents,
-      base_cost_in_cents: run.baseCostInCents,
-      tags: run.runTags ?? [],
-      task_version: run.taskVersion ?? "",
-      sdk_version: run.sdkVersion ?? "",
-      cli_version: run.cliVersion ?? "",
-      machine_preset: run.machinePreset ?? "",
-      root_run_id: run.rootTaskRunId ?? "",
-      parent_run_id: run.parentTaskRunId ?? "",
-      depth: run.depth,
-      is_test: run.isTest,
-      idempotency_key: run.idempotencyKey ?? "",
-      expiration_ttl: run.ttl ?? "",
-      output,
-      concurrency_key: run.concurrencyKey ?? "",
-      bulk_action_group_ids: run.bulkActionGroupIds ?? [],
-      worker_queue: run.masterQueue,
-      _version: _version.toString(),
-      _is_deleted: event === "delete" ? 1 : 0,
-    };
+  #parseAnnotations(annotations: unknown) {
+    return RunAnnotations.safeParse(annotations).data;
   }
 
-  async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise<RawTaskRunPayloadV1> {
+  async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise<PayloadInsertArray> {
     const payload = await this.#prepareJson(run.payload, run.payloadType);
 
-    return {
-      run_id: run.id,
-      created_at: run.createdAt.getTime(),
-      payload,
-    };
+    // Return array matching PAYLOAD_COLUMNS order
+    return [
+      run.id, // run_id
+      run.createdAt.getTime(), // created_at
+      payload, // payload
+    ];
   }
 
   async #prepareJson(
@@ -884,6 +978,7 @@ export class RunsReplicationService {
 
     return { data: parsedData };
   }
+
 }
 
 export type ConcurrentFlushSchedulerConfig<T> = {
@@ -891,13 +986,16 @@ export type ConcurrentFlushSchedulerConfig<T> = {
   flushInterval: number;
   maxConcurrency?: number;
   callback: (flushId: string, batch: T[]) => Promise<void>;
-  mergeBatch?: (existingBatch: T[], newBatch: T[]) => T[];
+  /** Key-based deduplication. Return null to skip the item. */
+  getKey: (item: T) => string | null;
+  /** Determine if incoming item should replace existing. */
+  shouldReplace: (existing: T, incoming: T) => boolean;
   tracer?: Tracer;
   logger?: Logger;
 };
 
 export class ConcurrentFlushScheduler<T> {
-  private currentBatch: T[];
+  private batch = new Map<string, T>();
   private readonly BATCH_SIZE: number;
   private readonly flushInterval: number;
   private readonly MAX_CONCURRENCY: number;
@@ -912,7 +1010,6 @@ export class ConcurrentFlushScheduler<T> {
     this.logger = config.logger ?? new Logger("ConcurrentFlushScheduler", "info");
     this._tracer = config.tracer ?? trace.getTracer("concurrent-flush-scheduler");
 
-    this.currentBatch = [];
     this.BATCH_SIZE = config.batchSize;
     this.flushInterval = config.flushInterval;
     this.MAX_CONCURRENCY = config.maxConcurrency || 1;
@@ -922,9 +1019,17 @@ export class ConcurrentFlushScheduler<T> {
   }
 
   addToBatch(items: T[]): void {
-    this.currentBatch = this.config.mergeBatch
-      ? this.config.mergeBatch(this.currentBatch, items)
-      : this.currentBatch.concat(items);
+    for (const item of items) {
+      const key = this.config.getKey(item);
+      if (key === null) {
+        continue;
+      }
+
+      const existing = this.batch.get(key);
+      if (!existing || this.config.shouldReplace(existing, item)) {
+        this.batch.set(key, item);
+      }
+    }
 
     this.#flushNextBatchIfNeeded();
   }
@@ -948,11 +1053,16 @@ export class ConcurrentFlushScheduler<T> {
     this.#flushNextBatchIfNeeded();
   }
 
+  #getBatchSize(): number {
+    return this.batch.size;
+  }
+
   #flushNextBatchIfNeeded(): void {
-    if (this.currentBatch.length >= this.BATCH_SIZE || this._isShutDown) {
+    const currentSize = this.#getBatchSize();
+    if (currentSize >= this.BATCH_SIZE || this._isShutDown) {
       this.logger.debug("Batch size threshold reached, initiating flush", {
         batchSize: this.BATCH_SIZE,
-        currentSize: this.currentBatch.length,
+        currentSize,
         isShutDown: this._isShutDown,
       });
 
@@ -977,19 +1087,20 @@ export class ConcurrentFlushScheduler<T> {
   }
 
   async #checkAndFlush(): Promise<void> {
-    if (this.currentBatch.length > 0) {
+    const currentSize = this.#getBatchSize();
+    if (currentSize > 0) {
       this.logger.debug("Periodic flush check triggered", {
-        currentBatchSize: this.currentBatch.length,
+        currentBatchSize: currentSize,
       });
       await this.#flushNextBatch();
     }
   }
 
   async #flushNextBatch(): Promise<void> {
-    if (this.currentBatch.length === 0) return;
+    if (this.batch.size === 0) return;
 
-    const batch = this.currentBatch;
-    this.currentBatch = [];
+    const batch = Array.from(this.batch.values());
+    this.batch.clear();
 
     const callback = this.config.callback;
 
diff --git a/apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts b/apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts
index 8b5cee04ca4..1368279e63d 100644
--- a/apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts
+++ b/apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts
@@ -1,5 +1,5 @@
 import { type ClickhouseQueryBuilder } from "@internal/clickhouse";
-import { RunId } from "@trigger.dev/core/v3/isomorphic";
+import { ErrorId, RunId } from "@trigger.dev/core/v3/isomorphic";
 import {
   type FilterRunsOptions,
   type IRunsRepository,
@@ -52,6 +52,29 @@ export class ClickHouseRunsRepository implements IRunsRepository {
     return runIds;
   }
 
+  async listFriendlyRunIds(options: ListRunsOptions) {
+    // First get internal IDs from ClickHouse
+    const internalIds = await this.listRunIds(options);
+
+    if (internalIds.length === 0) {
+      return [];
+    }
+
+    // Then get friendly IDs from Prisma
+    const runs = await this.options.prisma.taskRun.findMany({
+      where: {
+        id: {
+          in: internalIds,
+        },
+      },
+      select: {
+        friendlyId: true,
+      },
+    });
+
+    return runs.map((run) => run.friendlyId);
+  }
+
   async listRuns(options: ListRunsOptions) {
     const runIds = await this.listRunIds(options);
 
@@ -305,4 +328,10 @@ function applyRunFiltersToQueryBuilder<T>(
       machines: options.machines,
     });
   }
+
+  if (options.errorId) {
+    queryBuilder.where("error_fingerprint = {errorFingerprint: String}", {
+      errorFingerprint: ErrorId.toId(options.errorId),
+    });
+  }
 }
diff --git a/apps/webapp/app/services/runsRepository/postgresRunsRepository.server.ts b/apps/webapp/app/services/runsRepository/postgresRunsRepository.server.ts
deleted file mode 100644
index 93edbd93497..00000000000
--- a/apps/webapp/app/services/runsRepository/postgresRunsRepository.server.ts
+++ /dev/null
@@ -1,317 +0,0 @@
-import { RunId } from "@trigger.dev/core/v3/isomorphic";
-import { Prisma } from "@trigger.dev/database";
-import { sqlDatabaseSchema } from "~/db.server";
-import {
-  type FilterRunsOptions,
-  type IRunsRepository,
-  type ListRunsOptions,
-  type ListedRun,
-  type RunListInputOptions,
-  type RunsRepositoryOptions,
-  type TagListOptions,
-  convertRunListInputOptionsToFilterRunsOptions,
-} from "./runsRepository.server";
-
-export class PostgresRunsRepository implements IRunsRepository {
-  constructor(private readonly options: RunsRepositoryOptions) {}
-
-  get name() {
-    return "postgres";
-  }
-
-  async listRunIds(options: ListRunsOptions) {
-    const filterOptions = await convertRunListInputOptionsToFilterRunsOptions(
-      options,
-      this.options.prisma
-    );
-
-    const query = this.#buildRunIdsQuery(filterOptions, options.page);
-    const runs = await this.options.prisma.$queryRaw<{ id: string }[]>(query);
-
-    return runs.map((run) => run.id);
-  }
-
-  async listRuns(options: ListRunsOptions) {
-    const filterOptions = await convertRunListInputOptionsToFilterRunsOptions(
-      options,
-      this.options.prisma
-    );
-
-    const query = this.#buildRunsQuery(filterOptions, options.page);
-    const runs = await this.options.prisma.$queryRaw<ListedRun[]>(query);
-
-    // If there are more runs than the page size, we need to fetch the next page
-    const hasMore = runs.length > options.page.size;
-
-    let nextCursor: string | null = null;
-    let previousCursor: string | null = null;
-
-    // Get cursors for next and previous pages
-    const direction = options.page.direction ?? "forward";
-    switch (direction) {
-      case "forward": {
-        previousCursor = options.page.cursor ? runs.at(0)?.id ?? null : null;
-        if (hasMore) {
-          // The next cursor should be the last run ID from this page
-          nextCursor = runs[options.page.size - 1]?.id ?? null;
-        }
-        break;
-      }
-      case "backward": {
-        const reversedRuns = [...runs].reverse();
-        if (hasMore) {
-          previousCursor = reversedRuns.at(1)?.id ?? null;
-          nextCursor = reversedRuns.at(options.page.size)?.id ?? null;
-        } else {
-          nextCursor = reversedRuns.at(options.page.size - 1)?.id ?? null;
-        }
-        break;
-      }
-    }
-
-    const runsToReturn =
-      options.page.direction === "backward" && hasMore
-        ? runs.slice(1, options.page.size + 1)
-        : runs.slice(0, options.page.size);
-
-    // ClickHouse is slightly delayed, so we're going to do in-memory status filtering too
-    let filteredRuns = runsToReturn;
-    if (options.statuses && options.statuses.length > 0) {
-      filteredRuns = runsToReturn.filter((run) => options.statuses!.includes(run.status));
-    }
-
-    return {
-      runs: filteredRuns,
-      pagination: {
-        nextCursor,
-        previousCursor,
-      },
-    };
-  }
-
-  async countRuns(options: RunListInputOptions) {
-    const filterOptions = await convertRunListInputOptionsToFilterRunsOptions(
-      options,
-      this.options.prisma
-    );
-
-    const query = this.#buildCountQuery(filterOptions);
-    const result = await this.options.prisma.$queryRaw<{ count: bigint }[]>(query);
-
-    if (result.length === 0) {
-      throw new Error("No count rows returned");
-    }
-
-    return Number(result[0].count);
-  }
-
-  async listTags({ projectId, query, offset, limit }: TagListOptions) {
-    const tags = await this.options.prisma.taskRunTag.findMany({
-      select: {
-        name: true,
-      },
-      where: {
-        projectId,
-        name: query
-          ? {
-              startsWith: query,
-              mode: "insensitive",
-            }
-          : undefined,
-      },
-      orderBy: {
-        id: "desc",
-      },
-      take: limit + 1,
-      skip: offset,
-    });
-
-    return {
-      tags: tags.map((tag) => tag.name),
-    };
-  }
-
-  #buildRunIdsQuery(
-    filterOptions: FilterRunsOptions,
-    page: { size: number; cursor?: string; direction?: "forward" | "backward" }
-  ) {
-    const whereConditions = this.#buildWhereConditions(filterOptions, page.cursor, page.direction);
-
-    return Prisma.sql`
-      SELECT tr.id
-      FROM ${sqlDatabaseSchema}."TaskRun" tr
-      WHERE ${whereConditions}
-      ORDER BY ${page.direction === "backward" ? Prisma.sql`tr.id ASC` : Prisma.sql`tr.id DESC`}
-      LIMIT ${page.size + 1}
-    `;
-  }
-
-  #buildRunsQuery(
-    filterOptions: FilterRunsOptions,
-    page: { size: number; cursor?: string; direction?: "forward" | "backward" }
-  ) {
-    const whereConditions = this.#buildWhereConditions(filterOptions, page.cursor, page.direction);
-
-    return Prisma.sql`
-      SELECT
-        tr.id,
-        tr."friendlyId",
-        tr."taskIdentifier",
-        tr."taskVersion",
-        tr."runtimeEnvironmentId",
-        tr.status,
-        tr."createdAt",
-        tr."startedAt",
-        tr."lockedAt",
-        tr."delayUntil",
-        tr."updatedAt",
-        tr."completedAt",
-        tr."isTest",
-        tr."spanId",
-        tr."idempotencyKey",
-        tr."ttl",
-        tr."expiredAt",
-        tr."costInCents",
-        tr."baseCostInCents",
-        tr."usageDurationMs",
-        tr."runTags",
-        tr."depth",
-        tr."rootTaskRunId",
-        tr."batchId",
-        tr."metadata",
-        tr."metadataType",
-        tr."machinePreset",
-        tr."queue"
-      FROM ${sqlDatabaseSchema}."TaskRun" tr
-      WHERE ${whereConditions}
-      ORDER BY ${page.direction === "backward" ? Prisma.sql`tr.id ASC` : Prisma.sql`tr.id DESC`}
-      LIMIT ${page.size + 1}
-    `;
-  }
-
-  #buildCountQuery(filterOptions: FilterRunsOptions) {
-    const whereConditions = this.#buildWhereConditions(filterOptions);
-
-    return Prisma.sql`
-      SELECT COUNT(*) as count
-      FROM ${sqlDatabaseSchema}."TaskRun" tr
-      WHERE ${whereConditions}
-    `;
-  }
-
-  #buildWhereConditions(
-    filterOptions: FilterRunsOptions,
-    cursor?: string,
-    direction?: "forward" | "backward"
-  ) {
-    const conditions: Prisma.Sql[] = [];
-
-    // Environment filter
-    conditions.push(Prisma.sql`tr."runtimeEnvironmentId" = ${filterOptions.environmentId}`);
-
-    // Cursor pagination
-    if (cursor) {
-      if (direction === "forward" || !direction) {
-        conditions.push(Prisma.sql`tr.id < ${cursor}`);
-      } else {
-        conditions.push(Prisma.sql`tr.id > ${cursor}`);
-      }
-    }
-
-    // Task filters
-    if (filterOptions.tasks && filterOptions.tasks.length > 0) {
-      conditions.push(Prisma.sql`tr."taskIdentifier" IN (${Prisma.join(filterOptions.tasks)})`);
-    }
-
-    // Version filters
-    if (filterOptions.versions && filterOptions.versions.length > 0) {
-      conditions.push(Prisma.sql`tr."taskVersion" IN (${Prisma.join(filterOptions.versions)})`);
-    }
-
-    // Status filters
-    if (filterOptions.statuses && filterOptions.statuses.length > 0) {
-      conditions.push(
-        Prisma.sql`tr.status = ANY(ARRAY[${Prisma.join(
-          filterOptions.statuses
-        )}]::"TaskRunStatus"[])`
-      );
-    }
-
-    // Tag filters
-    if (filterOptions.tags && filterOptions.tags.length > 0) {
-      conditions.push(
-        Prisma.sql`tr."runTags" && ARRAY[${Prisma.join(filterOptions.tags)}]::text[]`
-      );
-    }
-
-    // Schedule filter
-    if (filterOptions.scheduleId) {
-      conditions.push(Prisma.sql`tr."scheduleId" = ${filterOptions.scheduleId}`);
-    }
-
-    // Time period filter
-    if (filterOptions.period) {
-      conditions.push(
-        Prisma.sql`tr."createdAt" >= NOW() - INTERVAL '1 millisecond' * ${filterOptions.period}`
-      );
-    }
-
-    // From date filter
-    if (filterOptions.from) {
-      conditions.push(
-        Prisma.sql`tr."createdAt" >= ${new Date(filterOptions.from).toISOString()}::timestamp`
-      );
-    }
-
-    // To date filter
-    if (filterOptions.to) {
-      const toDate = new Date(filterOptions.to);
-      const now = new Date();
-      const clampedDate = toDate > now ? now : toDate;
-      conditions.push(Prisma.sql`tr."createdAt" <= ${clampedDate.toISOString()}::timestamp`);
-    }
-
-    // Test filter
-    if (typeof filterOptions.isTest === "boolean") {
-      conditions.push(Prisma.sql`tr."isTest" = ${filterOptions.isTest}`);
-    }
-
-    // Root only filter
-    if (filterOptions.rootOnly) {
-      conditions.push(Prisma.sql`tr."rootTaskRunId" IS NULL`);
-    }
-
-    // Batch filter
-    if (filterOptions.batchId) {
-      conditions.push(Prisma.sql`tr."batchId" = ${filterOptions.batchId}`);
-    }
-
-    // Bulk action filter
-    if (filterOptions.bulkId) {
-      conditions.push(
-        Prisma.sql`tr."bulkActionGroupIds" && ARRAY[${filterOptions.bulkId}]::text[]`
-      );
-    }
-
-    // Run ID filter
-    if (filterOptions.runId && filterOptions.runId.length > 0) {
-      const friendlyIds = filterOptions.runId.map((runId) => RunId.toFriendlyId(runId));
-      conditions.push(Prisma.sql`tr."friendlyId" IN (${Prisma.join(friendlyIds)})`);
-    }
-
-    // Queue filter
-    if (filterOptions.queues && filterOptions.queues.length > 0) {
-      conditions.push(Prisma.sql`tr."queue" IN (${Prisma.join(filterOptions.queues)})`);
-    }
-
-    // Machine preset filter
-    if (filterOptions.machines && filterOptions.machines.length > 0) {
-      conditions.push(Prisma.sql`tr."machinePreset" IN (${Prisma.join(filterOptions.machines)})`);
-    }
-
-    // Combine all conditions with AND
-    return conditions.reduce((acc, condition) =>
-      acc === null ? condition : Prisma.sql`${acc} AND ${condition}`
-    );
-  }
-}
diff --git a/apps/webapp/app/services/runsRepository/runsRepository.server.ts b/apps/webapp/app/services/runsRepository/runsRepository.server.ts
index 7bf81a4aa55..4f097f61ce2 100644
--- a/apps/webapp/app/services/runsRepository/runsRepository.server.ts
+++ b/apps/webapp/app/services/runsRepository/runsRepository.server.ts
@@ -7,16 +7,13 @@ import { type Prisma, TaskRunStatus } from "@trigger.dev/database";
 import parseDuration from "parse-duration";
 import { z } from "zod";
 import { timeFilters } from "~/components/runs/v3/SharedFilters";
-import { type PrismaClient } from "~/db.server";
-import { FEATURE_FLAG, makeFlags } from "~/v3/featureFlags.server";
+import { type PrismaClient, type PrismaClientOrTransaction } from "~/db.server";
 import { startActiveSpan } from "~/v3/tracer.server";
-import { logger } from "../logger.server";
 import { ClickHouseRunsRepository } from "./clickhouseRunsRepository.server";
-import { PostgresRunsRepository } from "./postgresRunsRepository.server";
 
 export type RunsRepositoryOptions = {
   clickhouse: ClickHouse;
-  prisma: PrismaClient;
+  prisma: PrismaClientOrTransaction;
   logger?: Logger;
   logLevel?: LogLevel;
   tracer?: Tracer;
@@ -44,6 +41,7 @@ const RunListInputOptionsSchema = z.object({
   bulkId: z.string().optional(),
   queues: z.array(z.string()).optional(),
   machines: MachinePresetName.array().optional(),
+  errorId: z.string().optional(),
 });
 
 export type RunListInputOptions = z.infer<typeof RunListInputOptionsSchema>;
@@ -127,6 +125,8 @@ export type TagList = {
 export interface IRunsRepository {
   name: string;
   listRunIds(options: ListRunsOptions): Promise<string[]>;
+  /** Returns friendly IDs (e.g., run_xxx) instead of internal UUIDs. Used for ClickHouse task_events queries. */
+  listFriendlyRunIds(options: ListRunsOptions): Promise<string[]>;
   listRuns(options: ListRunsOptions): Promise<{
     runs: ListedRun[];
     pagination: {
@@ -140,81 +140,37 @@ export interface IRunsRepository {
 
 export class RunsRepository implements IRunsRepository {
   private readonly clickHouseRunsRepository: ClickHouseRunsRepository;
-  private readonly postgresRunsRepository: PostgresRunsRepository;
-  private readonly defaultRepository: "clickhouse" | "postgres";
-  private readonly logger: Logger;
 
-  constructor(
-    private readonly options: RunsRepositoryOptions & {
-      defaultRepository?: "clickhouse" | "postgres";
-    }
-  ) {
+  constructor(private readonly options: RunsRepositoryOptions) {
     this.clickHouseRunsRepository = new ClickHouseRunsRepository(options);
-    this.postgresRunsRepository = new PostgresRunsRepository(options);
-    this.defaultRepository = options.defaultRepository ?? "clickhouse";
-    this.logger = options.logger ?? logger;
   }
 
   get name() {
     return "runsRepository";
   }
 
-  async #getRepository(): Promise<IRunsRepository> {
-    return startActiveSpan("runsRepository.getRepository", async (span) => {
-      const getFlag = makeFlags(this.options.prisma);
-      const runsListRepository = await getFlag({
-        key: FEATURE_FLAG.runsListRepository,
-        defaultValue: this.defaultRepository,
-      });
-
-      span.setAttribute("repository.name", runsListRepository);
-
-      logger.log("runsListRepository", { runsListRepository });
-
-      switch (runsListRepository) {
-        case "postgres":
-          return this.postgresRunsRepository;
-        case "clickhouse":
-        default:
-          return this.clickHouseRunsRepository;
+  async listRunIds(options: ListRunsOptions): Promise<string[]> {
+    return startActiveSpan(
+      "runsRepository.listRunIds",
+      async () => this.clickHouseRunsRepository.listRunIds(options),
+      {
+        attributes: {
+          "repository.name": "clickhouse",
+          organizationId: options.organizationId,
+          projectId: options.projectId,
+          environmentId: options.environmentId,
+        },
       }
-    });
+    );
   }
 
-  async listRunIds(options: ListRunsOptions): Promise<string[]> {
-    const repository = await this.#getRepository();
+  async listFriendlyRunIds(options: ListRunsOptions): Promise<string[]> {
     return startActiveSpan(
-      "runsRepository.listRunIds",
-      async () => {
-        try {
-          return await repository.listRunIds(options);
-        } catch (error) {
-          // If ClickHouse fails, retry with Postgres
-          if (repository.name === "clickhouse") {
-            this.logger?.warn("ClickHouse failed, retrying with Postgres", { error });
-            return startActiveSpan(
-              "runsRepository.listRunIds.fallback",
-              async () => {
-                return await this.postgresRunsRepository.listRunIds(options);
-              },
-              {
-                attributes: {
-                  "repository.name": "postgres",
-                  "fallback.reason": "clickhouse_error",
-                  "fallback.error": error instanceof Error ? error.message : String(error),
-                  organizationId: options.organizationId,
-                  projectId: options.projectId,
-                  environmentId: options.environmentId,
-                },
-              }
-            );
-          }
-          throw error;
-        }
-      },
+      "runsRepository.listFriendlyRunIds",
+      async () => this.clickHouseRunsRepository.listFriendlyRunIds(options),
       {
         attributes: {
-          "repository.name": repository.name,
+          "repository.name": "clickhouse",
           organizationId: options.organizationId,
           projectId: options.projectId,
           environmentId: options.environmentId,
@@ -230,39 +186,12 @@ export class RunsRepository implements IRunsRepository {
       previousCursor: string | null;
     };
   }> {
-    const repository = await this.#getRepository();
     return startActiveSpan(
       "runsRepository.listRuns",
-      async () => {
-        try {
-          return await repository.listRuns(options);
-        } catch (error) {
-          // If ClickHouse fails, retry with Postgres
-          if (repository.name === "clickhouse") {
-            this.logger?.warn("ClickHouse failed, retrying with Postgres", { error });
-            return startActiveSpan(
-              "runsRepository.listRuns.fallback",
-              async () => {
-                return await this.postgresRunsRepository.listRuns(options);
-              },
-              {
-                attributes: {
-                  "repository.name": "postgres",
-                  "fallback.reason": "clickhouse_error",
-                  "fallback.error": error instanceof Error ? error.message : String(error),
-                  organizationId: options.organizationId,
-                  projectId: options.projectId,
-                  environmentId: options.environmentId,
-                },
-              }
-            );
-          }
-          throw error;
-        }
-      },
+      async () => this.clickHouseRunsRepository.listRuns(options),
       {
         attributes: {
-          "repository.name": repository.name,
+          "repository.name": "clickhouse",
           organizationId: options.organizationId,
           projectId: options.projectId,
           environmentId: options.environmentId,
@@ -272,39 +201,12 @@ export class RunsRepository implements IRunsRepository {
   }
 
   async countRuns(options: RunListInputOptions): Promise<number> {
-    const repository = await this.#getRepository();
     return startActiveSpan(
       "runsRepository.countRuns",
-      async () => {
-        try {
-          return await repository.countRuns(options);
-        } catch (error) {
-          // If ClickHouse fails, retry with Postgres
-          if (repository.name === "clickhouse") {
-            this.logger?.warn("ClickHouse failed, retrying with Postgres", { error });
-            return startActiveSpan(
-              "runsRepository.countRuns.fallback",
-              async () => {
-                return await this.postgresRunsRepository.countRuns(options);
-              },
-              {
-                attributes: {
-                  "repository.name": "postgres",
-                  "fallback.reason": "clickhouse_error",
-                  "fallback.error": error instanceof Error ? error.message : String(error),
-                  organizationId: options.organizationId,
-                  projectId: options.projectId,
-                  environmentId: options.environmentId,
-                },
-              }
-            );
-          }
-          throw error;
-        }
-      },
+      async () => this.clickHouseRunsRepository.countRuns(options),
       {
         attributes: {
-          "repository.name": repository.name,
+          "repository.name": "clickhouse",
           organizationId: options.organizationId,
           projectId: options.projectId,
           environmentId: options.environmentId,
@@ -314,15 +216,12 @@ export class RunsRepository implements IRunsRepository {
   }
 
   async listTags(options: TagListOptions): Promise<TagList> {
-    const repository = await this.#getRepository();
     return startActiveSpan(
       "runsRepository.listTags",
-      async () => {
-        return await repository.listTags(options);
-      },
+      async () => this.clickHouseRunsRepository.listTags(options),
       {
         attributes: {
-          "repository.name": repository.name,
+          "repository.name": "clickhouse",
           organizationId: options.organizationId,
           projectId: options.projectId,
           environmentId: options.environmentId,
diff --git a/apps/webapp/app/services/session.server.ts b/apps/webapp/app/services/session.server.ts
index 70450afb694..ea6831265c7 100644
--- a/apps/webapp/app/services/session.server.ts
+++ b/apps/webapp/app/services/session.server.ts
@@ -6,7 +6,18 @@ import { getImpersonationId } from "./impersonation.server";
 export async function getUserId(request: Request): Promise<string | undefined> {
   const impersonatedUserId = await getImpersonationId(request);
 
-  if (impersonatedUserId) return impersonatedUserId;
+  if (impersonatedUserId) {
+    // Verify the real user (from the session cookie) is still an admin
+    const authUser = await authenticator.isAuthenticated(request);
+    if (authUser?.userId) {
+      const realUser = await getUserById(authUser.userId);
+      if (realUser?.admin) {
+        return impersonatedUserId;
+      }
+    }
+    // Admin revoked or session invalid — fall through to return the real user's ID
+    return authUser?.userId;
+  }
 
   let authUser = await authenticator.isAuthenticated(request);
   return authUser?.userId;
@@ -54,7 +65,7 @@ export async function requireUser(request: Request) {
       dashboardPreferences: user.dashboardPreferences,
       confirmedBasicDetails: user.confirmedBasicDetails,
       mfaEnabledAt: user.mfaEnabledAt,
-      isImpersonating: !!impersonationId,
+      isImpersonating: !!impersonationId && impersonationId === userId,
     };
   }
 
diff --git a/apps/webapp/app/services/telemetry.server.ts b/apps/webapp/app/services/telemetry.server.ts
index 98ca11ed908..f8bd3d3d993 100644
--- a/apps/webapp/app/services/telemetry.server.ts
+++ b/apps/webapp/app/services/telemetry.server.ts
@@ -28,18 +28,32 @@ class Telemetry {
   }
 
   user = {
-    identify: ({ user, isNewUser }: { user: User; isNewUser: boolean }) => {
+    identify: ({
+      user,
+      isNewUser,
+      referralSource,
+    }: {
+      user: User;
+      isNewUser: boolean;
+      referralSource?: string;
+    }) => {
       if (this.#posthogClient) {
+        const properties: Record<string, any> = {
+          email: user.email,
+          name: user.name,
+          authenticationMethod: user.authenticationMethod,
+          admin: user.admin,
+          createdAt: user.createdAt,
+          isNewUser,
+        };
+        
+        if (referralSource) {
+          properties.referralSource = referralSource;
+        }
+        
         this.#posthogClient.identify({
           distinctId: user.id,
-          properties: {
-            email: user.email,
-            name: user.name,
-            authenticationMethod: user.authenticationMethod,
-            admin: user.admin,
-            createdAt: user.createdAt,
-            isNewUser,
-          },
+          properties,
         });
       }
       if (isNewUser) {
diff --git a/apps/webapp/app/services/upsertBranch.server.ts b/apps/webapp/app/services/upsertBranch.server.ts
index a11fdc350ab..3b4e18a58ea 100644
--- a/apps/webapp/app/services/upsertBranch.server.ts
+++ b/apps/webapp/app/services/upsertBranch.server.ts
@@ -5,7 +5,7 @@ import { createApiKeyForEnv, createPkApiKeyForEnv } from "~/models/api-key.serve
 import { type CreateBranchOptions } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route";
 import { isValidGitBranchName, sanitizeBranchName } from "~/v3/gitBranch";
 import { logger } from "./logger.server";
-import { getLimit } from "./platform.v3.server";
+import { getCurrentPlan, getLimit } from "./platform.v3.server";
 
 export class UpsertBranchService {
   #prismaClient: PrismaClient;
@@ -177,7 +177,10 @@ export async function checkBranchLimit(
   const count = newBranchName
     ? usedEnvs.filter((env) => env.branchName !== newBranchName).length
     : usedEnvs.length;
-  const limit = await getLimit(organizationId, "branches", 100_000_000);
+  const baseLimit = await getLimit(organizationId, "branches", 100_000_000);
+  const currentPlan = await getCurrentPlan(organizationId);
+  const purchasedBranches = currentPlan?.v3Subscription?.addOns?.branches?.purchased ?? 0;
+  const limit = baseLimit + purchasedBranches;
 
   return {
     used: count,
diff --git a/apps/webapp/app/services/vercelIntegration.server.ts b/apps/webapp/app/services/vercelIntegration.server.ts
new file mode 100644
index 00000000000..cf9e634afbb
--- /dev/null
+++ b/apps/webapp/app/services/vercelIntegration.server.ts
@@ -0,0 +1,733 @@
+import type {
+  PrismaClient,
+  OrganizationProjectIntegration,
+  OrganizationIntegration,
+  SecretReference,
+} from "@trigger.dev/database";
+import { ResultAsync } from "neverthrow";
+import { prisma, $transaction } from "~/db.server";
+import { logger } from "~/services/logger.server";
+import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
+import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
+import {
+  VercelProjectIntegrationDataSchema,
+  VercelProjectIntegrationData,
+  VercelIntegrationConfig,
+  SyncEnvVarsMapping,
+  TriggerEnvironmentType,
+  EnvSlug,
+  envTypeToSlug,
+  createDefaultVercelIntegrationData,
+} from "~/v3/vercel/vercelProjectIntegrationSchema";
+
+export type VercelProjectIntegrationWithParsedData = OrganizationProjectIntegration & {
+  parsedIntegrationData: VercelProjectIntegrationData;
+};
+
+export type VercelProjectIntegrationWithData = VercelProjectIntegrationWithParsedData & {
+  organizationIntegration: OrganizationIntegration;
+};
+
+export type VercelProjectIntegrationWithProject = VercelProjectIntegrationWithData & {
+  project: {
+    id: string;
+    name: string;
+    slug: string;
+  };
+};
+
+export class VercelIntegrationService {
+  #prismaClient: PrismaClient;
+
+  constructor(prismaClient: PrismaClient = prisma) {
+    this.#prismaClient = prismaClient;
+  }
+
+  async getVercelProjectIntegration(
+    projectId: string,
+  ): Promise<VercelProjectIntegrationWithData | null> {
+    const integration = await this.#prismaClient.organizationProjectIntegration.findFirst({
+      where: {
+        projectId,
+        deletedAt: null,
+        organizationIntegration: {
+          service: "VERCEL",
+          deletedAt: null,
+        },
+      },
+      include: {
+        organizationIntegration: true,
+      },
+    });
+
+    if (!integration) {
+      return null;
+    }
+
+    const parsedData = VercelProjectIntegrationDataSchema.safeParse(integration.integrationData);
+
+    if (!parsedData.success) {
+      logger.error("Failed to parse Vercel integration data", {
+        projectId,
+        integrationId: integration.id,
+        error: parsedData.error,
+      });
+      return null;
+    }
+
+    return {
+      ...integration,
+      parsedIntegrationData: parsedData.data,
+    };
+  }
+
+  async getConnectedVercelProjects(
+    organizationId: string
+  ): Promise<VercelProjectIntegrationWithProject[]> {
+    const integrations = await this.#prismaClient.organizationProjectIntegration.findMany({
+      where: {
+        deletedAt: null,
+        organizationIntegration: {
+          organizationId,
+          service: "VERCEL",
+          deletedAt: null,
+        },
+      },
+      include: {
+        organizationIntegration: true,
+        project: {
+          select: {
+            id: true,
+            name: true,
+            slug: true,
+          },
+        },
+      },
+    });
+
+    return integrations
+      .map((integration) => {
+        const parsedData = VercelProjectIntegrationDataSchema.safeParse(integration.integrationData);
+        if (!parsedData.success) {
+          logger.error("Failed to parse Vercel integration data", {
+            integrationId: integration.id,
+            error: parsedData.error,
+          });
+          return null;
+        }
+
+        return {
+          ...integration,
+          parsedIntegrationData: parsedData.data,
+        };
+      })
+      .filter((i): i is VercelProjectIntegrationWithProject => i !== null);
+  }
+
+  async createVercelProjectIntegration(params: {
+    organizationIntegrationId: string;
+    projectId: string;
+    vercelProjectId: string;
+    vercelProjectName: string;
+    vercelTeamId: string | null;
+    vercelTeamSlug?: string;
+    installedByUserId?: string;
+  }): Promise<OrganizationProjectIntegration> {
+    const integrationData = createDefaultVercelIntegrationData(
+      params.vercelProjectId,
+      params.vercelProjectName,
+      params.vercelTeamId,
+      params.vercelTeamSlug
+    );
+
+    return this.#prismaClient.organizationProjectIntegration.create({
+      data: {
+        organizationIntegrationId: params.organizationIntegrationId,
+        projectId: params.projectId,
+        externalEntityId: params.vercelProjectId,
+        integrationData: integrationData,
+        installedBy: params.installedByUserId,
+      },
+    });
+  }
+
+  async selectVercelProject(params: {
+    organizationId: string;
+    projectId: string;
+    vercelProjectId: string;
+    vercelProjectName: string;
+    userId: string;
+  }): Promise<{
+    integration: OrganizationProjectIntegration;
+    syncResult: { success: boolean; errors: string[] };
+  }> {
+    const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationByOrganization(
+      params.organizationId
+    );
+
+    if (!orgIntegration) {
+      throw new Error("No Vercel organization integration found");
+    }
+
+    const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+    const vercelTeamSlug = await VercelIntegrationRepository.getVercelClient(orgIntegration)
+      .andThen((client) => VercelIntegrationRepository.getTeamSlug(client, teamId))
+      .match(
+        (slug) => slug,
+        () => undefined
+      );
+
+    // Use a serializable transaction to prevent duplicate project integrations
+    // from concurrent selectVercelProject calls (read-then-write race condition).
+    const txResult = await $transaction(
+      this.#prismaClient,
+      "selectVercelProject",
+      async (tx) => {
+        const existing = await tx.organizationProjectIntegration.findFirst({
+          where: {
+            projectId: params.projectId,
+            deletedAt: null,
+            organizationIntegration: {
+              service: "VERCEL",
+              deletedAt: null,
+            },
+          },
+          include: {
+            organizationIntegration: true,
+          },
+        });
+
+        if (existing) {
+          const parsedData = VercelProjectIntegrationDataSchema.safeParse(
+            existing.integrationData
+          );
+
+          const updated = await tx.organizationProjectIntegration.update({
+            where: { id: existing.id },
+            data: {
+              externalEntityId: params.vercelProjectId,
+              integrationData: {
+                ...(parsedData.success ? parsedData.data : {}),
+                vercelProjectId: params.vercelProjectId,
+                vercelProjectName: params.vercelProjectName,
+                vercelTeamId: teamId,
+                vercelTeamSlug,
+              },
+            },
+          });
+
+          return {
+            integration: updated,
+            wasCreated: false,
+            vercelStagingEnvironment: parsedData.success
+              ? parsedData.data.config.vercelStagingEnvironment
+              : null,
+          };
+        }
+
+        const integrationData = createDefaultVercelIntegrationData(
+          params.vercelProjectId,
+          params.vercelProjectName,
+          teamId,
+          vercelTeamSlug
+        );
+
+        const created = await tx.organizationProjectIntegration.create({
+          data: {
+            organizationIntegrationId: orgIntegration.id,
+            projectId: params.projectId,
+            externalEntityId: params.vercelProjectId,
+            integrationData: integrationData,
+            installedBy: params.userId,
+          },
+        });
+
+        return {
+          integration: created,
+          wasCreated: true,
+          vercelStagingEnvironment: null,
+        };
+      },
+      { isolationLevel: "Serializable" }
+    );
+
+    if (!txResult) {
+      throw new Error("Failed to select Vercel project: transaction returned undefined");
+    }
+
+    const { integration, wasCreated, vercelStagingEnvironment } = txResult;
+
+    const syncResultAsync = await VercelIntegrationRepository.syncApiKeysToVercel({
+      projectId: params.projectId,
+      vercelProjectId: params.vercelProjectId,
+      teamId,
+      vercelStagingEnvironment,
+      orgIntegration,
+    });
+    const syncResult = syncResultAsync.isOk()
+      ? { success: syncResultAsync.value.errors.length === 0, errors: syncResultAsync.value.errors }
+      : { success: false, errors: [syncResultAsync.error.message] };
+
+    if (wasCreated) {
+      const disableResult = await VercelIntegrationRepository.getVercelClient(orgIntegration)
+        .andThen((client) =>
+          VercelIntegrationRepository.disableAutoAssignCustomDomains(
+            client,
+            params.vercelProjectId,
+            teamId
+          )
+        );
+
+      if (disableResult.isErr()) {
+        logger.warn("Failed to disable autoAssignCustomDomains during project selection", {
+          projectId: params.projectId,
+          vercelProjectId: params.vercelProjectId,
+          error: disableResult.error.message,
+        });
+      }
+
+      logger.info("Vercel project selected and API keys synced", {
+        projectId: params.projectId,
+        vercelProjectId: params.vercelProjectId,
+        vercelProjectName: params.vercelProjectName,
+        syncSuccess: syncResult.success,
+        syncErrors: syncResult.errors,
+      });
+    }
+
+    return { integration, syncResult };
+  }
+
+  async updateVercelIntegrationConfig(
+    projectId: string,
+    configUpdates: Partial<VercelIntegrationConfig>
+  ): Promise<VercelProjectIntegrationWithParsedData | null> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return null;
+    }
+
+    const updatedConfig = {
+      ...existing.parsedIntegrationData.config,
+      ...configUpdates,
+    };
+
+    const updatedData: VercelProjectIntegrationData = {
+      ...existing.parsedIntegrationData,
+      config: updatedConfig,
+    };
+
+    const updated = await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        integrationData: updatedData,
+      },
+    });
+
+    if (!updatedConfig.atomicBuilds?.includes("prod")) {
+      return { ...updated, parsedIntegrationData: updatedData };
+    }
+
+    const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationForProject(
+      projectId
+    );
+
+    if (orgIntegration) {
+      await this.#syncTriggerVersionToVercelProduction(
+        projectId,
+        updatedConfig.atomicBuilds,
+        orgIntegration
+      );
+    }
+
+    return {
+      ...updated,
+      parsedIntegrationData: updatedData,
+    };
+  }
+
+  async syncStagingKeyForCustomEnvironment(
+    projectId: string,
+    previousCustomEnvironmentId?: string | null,
+    newCustomEnvironmentId?: string | null
+  ) {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return;
+    }
+
+    const orgIntegration =
+      await VercelIntegrationRepository.findVercelOrgIntegrationForProject(projectId);
+    if (!orgIntegration) {
+      return;
+    }
+
+    const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+    const vercelProjectId = existing.parsedIntegrationData.vercelProjectId;
+
+    // Remove the key from the old custom environment (if it changed or was removed)
+    if (previousCustomEnvironmentId && previousCustomEnvironmentId !== newCustomEnvironmentId) {
+      const removeResult = await VercelIntegrationRepository.removeEnvVarForCustomEnvironment({
+        orgIntegration,
+        vercelProjectId,
+        teamId,
+        key: "TRIGGER_SECRET_KEY",
+        customEnvironmentId: previousCustomEnvironmentId,
+      });
+
+      if (removeResult.isErr()) {
+        logger.error("Failed to remove staging TRIGGER_SECRET_KEY from previous custom environment", {
+          projectId,
+          previousCustomEnvironmentId,
+          error: removeResult.error.message,
+        });
+      }
+    }
+
+    // Create/update the key for the new custom environment
+    if (newCustomEnvironmentId) {
+      const stagingEnv = await this.#prismaClient.runtimeEnvironment.findFirst({
+        where: {
+          projectId,
+          type: "STAGING",
+        },
+        select: {
+          apiKey: true,
+        },
+      });
+
+      if (!stagingEnv) {
+        logger.warn("No STAGING runtime environment found for project", { projectId });
+        return;
+      }
+
+      const upsertResult = await VercelIntegrationRepository.upsertEnvVarForCustomEnvironment({
+        orgIntegration,
+        vercelProjectId,
+        teamId,
+        key: "TRIGGER_SECRET_KEY",
+        value: stagingEnv.apiKey,
+        customEnvironmentId: newCustomEnvironmentId,
+        type: "encrypted",
+      });
+
+      if (upsertResult.isErr()) {
+        logger.warn("Failed to sync staging TRIGGER_SECRET_KEY to custom environment", {
+          projectId,
+          newCustomEnvironmentId,
+          error: upsertResult.error.message,
+        });
+      }
+    }
+  }
+
+  async updateSyncEnvVarsMapping(
+    projectId: string,
+    syncEnvVarsMapping: SyncEnvVarsMapping
+  ): Promise<VercelProjectIntegrationWithParsedData | null> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return null;
+    }
+
+    const updatedData: VercelProjectIntegrationData = {
+      ...existing.parsedIntegrationData,
+      syncEnvVarsMapping,
+    };
+
+    const updated = await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        integrationData: updatedData,
+      },
+    });
+
+    return {
+      ...updated,
+      parsedIntegrationData: updatedData,
+    };
+  }
+
+  async updateSyncEnvVarForEnvironment(
+    projectId: string,
+    envVarKey: string,
+    environmentType: TriggerEnvironmentType,
+    syncEnabled: boolean
+  ): Promise<VercelProjectIntegrationWithParsedData | null> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return null;
+    }
+
+    const currentMapping = existing.parsedIntegrationData.syncEnvVarsMapping || {};
+    const envSlug = envTypeToSlug(environmentType);
+
+    const currentEnvSettings = currentMapping[envSlug] || {};
+
+    const updatedMapping: SyncEnvVarsMapping = {
+      ...currentMapping,
+      [envSlug]: {
+        ...currentEnvSettings,
+        [envVarKey]: syncEnabled,
+      },
+    };
+
+    const updatedData: VercelProjectIntegrationData = {
+      ...existing.parsedIntegrationData,
+      syncEnvVarsMapping: updatedMapping,
+    };
+
+    const updated = await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        integrationData: updatedData,
+      },
+    });
+
+    return {
+      ...updated,
+      parsedIntegrationData: updatedData,
+    };
+  }
+
+  async removeSyncEnvVarForEnvironment(
+    projectId: string,
+    envVarKey: string,
+    environmentType: TriggerEnvironmentType
+  ): Promise<void> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) return;
+
+    const currentMapping = existing.parsedIntegrationData.syncEnvVarsMapping || {};
+    const envSlug = envTypeToSlug(environmentType);
+    const currentEnvSettings = currentMapping[envSlug];
+    if (!currentEnvSettings || !(envVarKey in currentEnvSettings)) return;
+
+    const { [envVarKey]: _, ...rest } = currentEnvSettings;
+    const updatedMapping = { ...currentMapping, [envSlug]: rest };
+
+    await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        integrationData: {
+          ...existing.parsedIntegrationData,
+          syncEnvVarsMapping: updatedMapping,
+        },
+      },
+    });
+  }
+
+  async completeOnboarding(
+    projectId: string,
+    params: {
+      vercelStagingEnvironment?: { environmentId: string; displayName: string } | null;
+      pullEnvVarsBeforeBuild?: EnvSlug[] | null;
+      atomicBuilds?: EnvSlug[] | null;
+      discoverEnvVars?: EnvSlug[] | null;
+      syncEnvVarsMapping?: SyncEnvVarsMapping;
+      origin?: "marketplace" | "dashboard";
+    }
+  ): Promise<VercelProjectIntegrationWithParsedData | null> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return null;
+    }
+
+    const syncEnvVarsMapping = params.syncEnvVarsMapping ?? { "dev":{}, "stg":{}, "prod":{}, "preview":{} };
+    const updatedData: VercelProjectIntegrationData = {
+      ...existing.parsedIntegrationData,
+      config: {
+        ...existing.parsedIntegrationData.config,
+        pullEnvVarsBeforeBuild: params.pullEnvVarsBeforeBuild ?? null,
+        atomicBuilds: params.atomicBuilds ?? null,
+        discoverEnvVars: params.discoverEnvVars ?? null,
+        vercelStagingEnvironment: params.vercelStagingEnvironment ?? null,
+      },
+      //This is intentionally not updated here, in case of resetting the onboarding it should not override the existing mapping with an empty one
+      syncEnvVarsMapping: existing.parsedIntegrationData.syncEnvVarsMapping,
+      onboardingCompleted: true,
+      onboardingOrigin: params.origin ?? existing.parsedIntegrationData.onboardingOrigin,
+    };
+
+    const updated = await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        integrationData: updatedData,
+      },
+    });
+
+    const orgIntegration = await VercelIntegrationRepository.findVercelOrgIntegrationForProject(
+      projectId
+    );
+
+    if (orgIntegration) {
+      const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+      const pullResult = await VercelIntegrationRepository.pullEnvVarsFromVercel({
+        projectId,
+        vercelProjectId: updatedData.vercelProjectId,
+        teamId,
+        vercelStagingEnvironment: params.vercelStagingEnvironment,
+        syncEnvVarsMapping,
+        orgIntegration,
+      });
+
+      if (pullResult.isErr()) {
+        logger.error("Failed to pull env vars from Vercel during onboarding", {
+          projectId,
+          error: pullResult.error.message,
+        });
+      } else if (pullResult.value.errors.length > 0) {
+        logger.warn("Errors pulling env vars from Vercel during onboarding", {
+          projectId,
+          errors: pullResult.value.errors,
+        });
+      }
+
+      await this.#syncTriggerVersionToVercelProduction(
+        projectId,
+        updatedData.config.atomicBuilds,
+        orgIntegration
+      );
+    }
+
+    return {
+      ...updated,
+      parsedIntegrationData: updatedData,
+    };
+  }
+
+  async #syncTriggerVersionToVercelProduction(
+    projectId: string,
+    atomicBuilds: string[] | null | undefined,
+    orgIntegration: OrganizationIntegration & { tokenReference: SecretReference }
+  ): Promise<void> {
+    if (!atomicBuilds?.includes("prod")) {
+      return;
+    }
+
+    const prodEnvironment = await this.#prismaClient.runtimeEnvironment.findFirst({
+      where: {
+        projectId,
+        type: "PRODUCTION",
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!prodEnvironment) {
+      return;
+    }
+
+    const currentDeployment = await findCurrentWorkerDeployment({
+      environmentId: prodEnvironment.id,
+    });
+
+    if (!currentDeployment?.version) {
+      return;
+    }
+
+    const clientResult = await VercelIntegrationRepository.getVercelClient(orgIntegration);
+    if (clientResult.isErr()) {
+      logger.error("Failed to get Vercel client for TRIGGER_VERSION sync", {
+        projectId,
+        error: clientResult.error.message,
+      });
+      return;
+    }
+    const client = clientResult.value;
+    const teamId = await VercelIntegrationRepository.getTeamIdFromIntegration(orgIntegration);
+
+    // Get the Vercel project ID from the project integration
+    const projectIntegration = await this.#prismaClient.organizationProjectIntegration.findFirst({
+      where: {
+        projectId,
+        organizationIntegrationId: orgIntegration.id,
+        deletedAt: null,
+      },
+      select: {
+        externalEntityId: true,
+      },
+    });
+
+    if (!projectIntegration) {
+      return;
+    }
+
+    const vercelProjectId = projectIntegration.externalEntityId;
+
+    // Check if TRIGGER_VERSION already exists targeting production
+    const envVarsResult = await VercelIntegrationRepository.getVercelEnvironmentVariables(
+      client,
+      vercelProjectId,
+      teamId
+    );
+
+    if (envVarsResult.isErr()) {
+      logger.warn("Failed to fetch Vercel env vars for TRIGGER_VERSION sync", {
+        projectId,
+        vercelProjectId,
+        error: envVarsResult.error.message,
+      });
+      return;
+    }
+
+    const existingTriggerVersion = envVarsResult.value.find(
+      (env) => env.key === "TRIGGER_VERSION" && env.target.includes("production")
+    );
+
+    if (existingTriggerVersion) {
+      return;
+    }
+
+    // Push TRIGGER_VERSION to Vercel production
+    const createResult = await ResultAsync.fromPromise(
+      client.projects.createProjectEnv({
+        idOrName: vercelProjectId,
+        ...(teamId && { teamId }),
+        upsert: "true",
+        requestBody: {
+          key: "TRIGGER_VERSION",
+          value: currentDeployment.version,
+          target: ["production"] as any,
+          type: "encrypted",
+        },
+      }),
+      (error) => error
+    );
+
+    if (createResult.isErr()) {
+      logger.error("Failed to sync TRIGGER_VERSION to Vercel production", {
+        projectId,
+        vercelProjectId,
+        error: createResult.error instanceof Error ? createResult.error.message : String(createResult.error),
+      });
+      return;
+    }
+
+    logger.info("Synced TRIGGER_VERSION to Vercel production", {
+      projectId,
+      vercelProjectId,
+      version: currentDeployment.version,
+    });
+  }
+
+  async disconnectVercelProject(projectId: string): Promise<boolean> {
+    const existing = await this.getVercelProjectIntegration(projectId);
+    if (!existing) {
+      return false;
+    }
+
+    await this.#prismaClient.organizationProjectIntegration.update({
+      where: { id: existing.id },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+
+    return true;
+  }
+}
+
diff --git a/apps/webapp/app/tailwind.css b/apps/webapp/app/tailwind.css
index 3d68e87811d..8ec29b91568 100644
--- a/apps/webapp/app/tailwind.css
+++ b/apps/webapp/app/tailwind.css
@@ -1,6 +1,38 @@
 @import url("non.geist");
 @import url("non.geist/mono");
 
+@import "react-grid-layout/css/styles.css";
+@import "react-resizable/css/styles.css";
+
+/* Override react-grid-layout placeholder color (default is red) */
+.react-grid-item.react-grid-placeholder {
+  background: rgb(99 102 241) !important; /* indigo-500 */
+  border-radius: 0.375rem !important; /* rounded-md */
+}
+
+/* Sidebar reorder grid: subtle placeholder */
+.sidebar-reorder-grid .react-grid-item.react-grid-placeholder {
+  background: rgb(39 42 46) !important; /* charcoal-700 */
+  border-radius: 0.25rem;
+  opacity: 1 !important;
+}
+
+/* Sidebar reorder grid: only animate transform (vertical position), not width/height */
+.sidebar-reorder-grid .react-grid-item {
+  transition: transform 200ms ease !important;
+}
+
+/* Override resize handle icon to white */
+.react-resizable-handle {
+  background-image: url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2IDYiIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiNmZmZmZmYwMCIgeD0iMHB4IiB5PSIwcHgiIHdpZHRoPSI2cHgiIGhlaWdodD0iNnB4Ij48ZyBvcGFjaXR5PSIwLjMwMiI+PHBhdGggZD0iTSA2IDYgTCAwIDYgTCAwIDQuMiBMIDQgNC4yIEwgNC4yIDQuMiBMIDQuMiAwIEwgNiAwIEwgNiA2IEwgNiA2IFoiIGZpbGw9IiNmZmZmZmYiLz48L2c+PC9zdmc+') !important;
+}
+.react-resizable-handle::after {
+  border-bottom-color: rgba(255, 255, 255, 0.4) !important;
+  border-right-color: rgba(255, 255, 255, 0.4) !important;
+  border-top-color: rgba(255, 255, 255, 0.4) !important;
+  border-left-color: rgba(255, 255, 255, 0.4) !important;
+}
+
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
@@ -11,6 +43,12 @@
   inherits: false;
 }
 
+@supports (-webkit-hyphens: none) {
+  .safari-only {
+    @apply border-b border-grid-dimmed;
+  }
+}
+
 @layer base {
   * {
     @apply border-grid-bright;
@@ -47,6 +85,10 @@
 }
 
 @layer utilities {
+  .scrollbar-gutter-stable {
+    scrollbar-gutter: stable;
+  }
+
   .animated-gradient-glow {
     position: relative;
     overflow: visible;
@@ -106,3 +148,102 @@
     --gradient-angle: 360deg;
   }
 }
+
+/* Streamdown markdown styling */
+.streamdown-container {
+  /* Streamdown uses shadcn/ui CSS variables - define them for our theme */
+  --muted: 220 13% 20%;
+  --muted-foreground: 215 14% 60%;
+  --foreground: 210 20% 90%;
+  --border: 217 19% 27%;
+
+  /* Code block styling */
+  & [data-code-block-container] {
+    @apply rounded border-charcoal-650 my-0;
+  }
+  & [data-code-block] {
+    border-top: none;
+  }
+
+  & p {
+    @apply my-1;
+  }
+  & h1, & h2, & h3, & h4, & h5, & h6 {
+    @apply font-semibold text-text-bright mt-2 mb-1;
+  }
+  & h1 {
+    @apply text-base;
+  }
+  & h2 {
+    @apply text-sm;
+  }
+  & h3, & h4, & h5, & h6 {
+    @apply text-xs;
+  }
+  & ul, & ol {
+    @apply ml-4 my-1;
+  }
+  & ul {
+    @apply list-disc;
+  }
+  & ol {
+    @apply list-decimal;
+  }
+  & li {
+    @apply my-0.5;
+  }
+  /* Inline code (not in pre blocks) */
+  & code:not(pre code) {
+    @apply bg-charcoal-700 px-1 py-0.5 rounded text-text-bright font-mono;
+  }
+  & blockquote {
+    @apply border-l-2 border-charcoal-600 pl-3 my-2 italic;
+  }
+  & a {
+    @apply text-blue-400 hover:underline;
+  }
+  & strong {
+    @apply font-semibold text-text-bright;
+  }
+  & em {
+    @apply italic;
+  }
+  & hr {
+    @apply my-2 border-charcoal-600;
+  }
+  & table {
+    @apply w-full my-2 border-collapse;
+  }
+  & th, & td {
+    @apply border border-charcoal-600 px-2 py-1 text-left;
+  }
+  & th {
+    @apply bg-charcoal-700 font-semibold;
+  }
+
+  /* Streamdown code block container */
+  & [data-code-block-container] {
+    @apply my-2 border-charcoal-700;
+  }
+  & [data-code-block-header] {
+    @apply bg-charcoal-800 text-text-dimmed border-b border-charcoal-700;
+  }
+  /* Hide light mode code block, show dark mode */
+  & [data-code-block].dark\:hidden {
+    display: none !important;
+  }
+  & [data-code-block].hidden.dark\:block {
+    display: block !important;
+  }
+  /* Override the bg-muted/40 class to let inline styles work */
+  & [data-code-block] pre {
+    background-color: inherit !important;
+    @apply scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600;
+  }
+  & [data-code-block] pre code {
+    @apply bg-transparent;
+  }
+  & [data-code-block] .line {
+    @apply leading-relaxed;
+  }
+}
diff --git a/apps/webapp/app/utils/columnFormat.ts b/apps/webapp/app/utils/columnFormat.ts
new file mode 100644
index 00000000000..c11226123ab
--- /dev/null
+++ b/apps/webapp/app/utils/columnFormat.ts
@@ -0,0 +1,83 @@
+import type { ColumnFormatType } from "@internal/clickhouse";
+import { formatDurationMilliseconds } from "@trigger.dev/core/v3";
+import { formatCurrencyAccurate } from "~/utils/numberFormatter";
+
+/**
+ * Format a number as binary bytes (KiB, MiB, GiB, TiB)
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  const i = Math.min(
+    Math.max(0, Math.floor(Math.log(Math.abs(bytes)) / Math.log(1024))),
+    units.length - 1
+  );
+  return `${(bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 2)} ${units[i]}`;
+}
+
+/**
+ * Format a number as decimal bytes (KB, MB, GB, TB)
+ */
+export function formatDecimalBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(
+    Math.max(0, Math.floor(Math.log(Math.abs(bytes)) / Math.log(1000))),
+    units.length - 1
+  );
+  return `${(bytes / Math.pow(1000, i)).toFixed(i === 0 ? 0 : 2)} ${units[i]}`;
+}
+
+/**
+ * Format a large number with human-readable suffix (K, M, B)
+ */
+export function formatQuantity(value: number): string {
+  const abs = Math.abs(value);
+  if (abs >= 1_000_000_000) return `${(value / 1_000_000_000).toFixed(2)}B`;
+  if (abs >= 1_000_000) return `${(value / 1_000_000).toFixed(2)}M`;
+  if (abs >= 1_000) return `${(value / 1_000).toFixed(2)}K`;
+  return value.toLocaleString();
+}
+
+/**
+ * Format a dollar amount with adaptive precision — avoids trailing zeros.
+ */
+function formatCostAdaptive(dollars: number): string {
+  if (dollars === 0) return "$0";
+  const abs = Math.abs(dollars);
+  if (abs >= 1000) return `$${dollars.toFixed(2)}`;
+  if (abs >= 1) return `$${dollars.toFixed(2)}`;
+  if (abs >= 0.01) return `$${dollars.toFixed(4)}`;
+  if (abs >= 0.0001) return `$${dollars.toFixed(6)}`;
+  return formatCurrencyAccurate(dollars);
+}
+
+/**
+ * Creates a value formatter function for a given column format type.
+ * Used by chart tooltips, legend values, and big number cards.
+ */
+export function createValueFormatter(
+  format?: ColumnFormatType
+): ((value: number) => string) | undefined {
+  if (!format) return undefined;
+  switch (format) {
+    case "bytes":
+      return (v) => formatBytes(v);
+    case "decimalBytes":
+      return (v) => formatDecimalBytes(v);
+    case "percent":
+      return (v) => `${v.toFixed(2)}%`;
+    case "quantity":
+      return (v) => formatQuantity(v);
+    case "duration":
+      return (v) => formatDurationMilliseconds(v, { style: "short" });
+    case "durationSeconds":
+      return (v) => formatDurationMilliseconds(v * 1000, { style: "short" });
+    case "costInDollars":
+      return (v) => formatCostAdaptive(v);
+    case "cost":
+      return (v) => formatCostAdaptive(v / 100);
+    default:
+      return undefined;
+  }
+}
diff --git a/apps/webapp/app/utils/dataExport.ts b/apps/webapp/app/utils/dataExport.ts
new file mode 100644
index 00000000000..be7cde397b8
--- /dev/null
+++ b/apps/webapp/app/utils/dataExport.ts
@@ -0,0 +1,79 @@
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+
+/**
+ * Escape a value for CSV format.
+ * - Wraps in quotes if the value contains commas, quotes, or newlines
+ * - Escapes quotes by doubling them
+ */
+function escapeCSVValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  const stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+
+  // Check if we need to quote the value
+  if (
+    stringValue.includes(",") ||
+    stringValue.includes('"') ||
+    stringValue.includes("\n") ||
+    stringValue.includes("\r")
+  ) {
+    // Escape quotes by doubling them and wrap in quotes
+    return `"${stringValue.replace(/"/g, '""')}"`;
+  }
+
+  return stringValue;
+}
+
+/**
+ * Convert query result rows to CSV format.
+ *
+ * @param rows - Array of row objects from query results
+ * @param columns - Column metadata describing the result columns
+ * @returns CSV string with header row and data rows
+ */
+export function rowsToCSV(rows: Record<string, unknown>[], columns: OutputColumnMetadata[]): string {
+  if (columns.length === 0) {
+    return "";
+  }
+
+  const columnNames = columns.map((col) => col.name);
+
+  // Header row
+  const headerRow = columnNames.map(escapeCSVValue).join(",");
+
+  // Data rows
+  const dataRows = rows.map((row) => columnNames.map((name) => escapeCSVValue(row[name])).join(","));
+
+  return [headerRow, ...dataRows].join("\n");
+}
+
+/**
+ * Convert query result rows to JSON format.
+ *
+ * @param rows - Array of row objects from query results
+ * @returns Formatted JSON string
+ */
+export function rowsToJSON(rows: Record<string, unknown>[]): string {
+  return JSON.stringify(rows, null, 2);
+}
+
+/**
+ * Trigger a file download in the browser.
+ *
+ * @param content - The file content as a string
+ * @param filename - The name for the downloaded file
+ * @param mimeType - The MIME type of the file
+ */
+export function downloadFile(content: string, filename: string, mimeType: string): void {
+  const blob = new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+
diff --git a/apps/webapp/app/utils/errorFingerprinting.ts b/apps/webapp/app/utils/errorFingerprinting.ts
new file mode 100644
index 00000000000..29ecaddb6a8
--- /dev/null
+++ b/apps/webapp/app/utils/errorFingerprinting.ts
@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Calculate error fingerprint using Sentry-style normalization.
+ * Groups similar errors together by normalizing dynamic values.
+ */
+export function calculateErrorFingerprint(error: unknown): string {
+  if (!error || typeof error !== "object" || Array.isArray(error)) return "";
+
+  // This is a but ugly but…
+  // 1. We can't use a schema here because it's a hot path and needs to be fast.
+  // 2. It won't be an instanceof Error because it's from the database.
+  const errorObj = error as any;
+  const errorType = String(errorObj.type || errorObj.name || "Error");
+  const message = String(errorObj.message || "");
+  const stack = String(errorObj.stack || errorObj.stacktrace || "");
+
+  // Normalize message to group similar errors
+  const normalizedMessage = normalizeErrorMessage(message);
+
+  // Extract and normalize first few stack frames
+  const normalizedStack = normalizeStackTrace(stack);
+
+  // Create fingerprint from type + normalized message + stack
+  const fingerprintInput = `${errorType}:${normalizedMessage}:${normalizedStack}`;
+
+  // Use SHA-256 hash, take first 16 chars for compact storage
+  return createHash("sha256").update(fingerprintInput).digest("hex").substring(0, 16);
+}
+
+/**
+ * Normalize error message by replacing dynamic values with placeholders.
+ * This allows similar errors to be grouped together.
+ */
+export function normalizeErrorMessage(message: string): string {
+  if (!message) return "";
+
+  return (
+    message
+      // UUIDs (8-4-4-4-12 format)
+      .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<uuid>")
+      // Run IDs (run_xxxxx format)
+      .replace(/run_[a-zA-Z0-9]+/g, "<run-id>")
+      // Task run friendly IDs (task_xxxxx or similar)
+      .replace(/\b[a-z]+_[a-zA-Z0-9]{8,}\b/g, "<id>")
+      // --- Specific patterns must run before generic numeric/path replacements ---
+      // ISO 8601 timestamps
+      .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, "<timestamp>")
+      // Unix timestamps (10 or 13 digits)
+      .replace(/\b\d{10,13}\b/g, "<timestamp>")
+      // URLs (before path regex, which would strip the URL's path component)
+      .replace(/https?:\/\/[^\s]+/g, "<url>")
+      // --- Generic replacements ---
+      // Standalone numeric IDs (4+ digits)
+      .replace(/\b\d{4,}\b/g, "<id>")
+      // File paths (Unix style)
+      .replace(/(?:\/[^\/\s]+){2,}/g, "<path>")
+      // File paths (Windows style)
+      .replace(/[A-Z]:\\(?:[^\\]+\\)+[^\\]+/g, "<path>")
+      // Email addresses
+      .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, "<email>")
+      // Memory addresses (0x...)
+      .replace(/0x[0-9a-fA-F]{8,}/g, "<addr>")
+      // Quoted strings with dynamic content
+      .replace(/"[^"]{20,}"/g, '"<string>"')
+      .replace(/'[^']{20,}'/g, "'<string>'")
+  );
+}
+
+/**
+ * Normalize stack trace by taking first few frames and removing dynamic parts.
+ */
+export function normalizeStackTrace(stack: string): string {
+  if (!stack) return "";
+
+  // Take first 5 stack frames only
+  const lines = stack.split("\n").slice(0, 5);
+
+  return lines
+    .map((line) => {
+      // Remove line and column numbers (file.ts:123:45 -> file.ts:_:_)
+      line = line.replace(/:\d+:\d+/g, ":_:_");
+      // Remove standalone numbers
+      line = line.replace(/\b\d+\b/g, "_");
+      // Remove file paths but keep filename
+      line = line.replace(/(?:\/[^\/\s]+)+\/([^\/\s]+)/g, "$1");
+      // Normalize whitespace
+      line = line.trim();
+      return line;
+    })
+    .filter((line) => line.length > 0)
+    .join("|");
+}
diff --git a/apps/webapp/app/utils/extractClientIp.server.ts b/apps/webapp/app/utils/extractClientIp.server.ts
new file mode 100644
index 00000000000..bbfa5180713
--- /dev/null
+++ b/apps/webapp/app/utils/extractClientIp.server.ts
@@ -0,0 +1,10 @@
+/**
+ * Extracts the client IP address from the X-Forwarded-For header.
+ * Takes the last item in the header since ALB appends the real client IP by default.
+ */
+export function extractClientIp(xff: string | null): string | null {
+  if (!xff) return null;
+
+  const parts = xff.split(",").map((p) => p.trim());
+  return parts[parts.length - 1]; // take last item, ALB appends the real client IP by default
+}
diff --git a/apps/webapp/app/utils/favicon.ts b/apps/webapp/app/utils/favicon.ts
new file mode 100644
index 00000000000..dbbedc21a66
--- /dev/null
+++ b/apps/webapp/app/utils/favicon.ts
@@ -0,0 +1,13 @@
+export function extractDomain(input: string): string | null {
+  try {
+    const withProtocol = input.includes("://") ? input : `https://${input}`;
+    const url = new URL(withProtocol);
+    return url.hostname;
+  } catch {
+    return null;
+  }
+}
+
+export function faviconUrl(domain: string, size: number = 128): string {
+  return `https://www.google.com/s2/favicons?domain=${domain}&sz=${size}`;
+}
diff --git a/apps/webapp/app/utils/httpErrors.ts b/apps/webapp/app/utils/httpErrors.ts
index 637b6bf4bf6..5131730e3bb 100644
--- a/apps/webapp/app/utils/httpErrors.ts
+++ b/apps/webapp/app/utils/httpErrors.ts
@@ -5,11 +5,26 @@ export function friendlyErrorDisplay(statusCode: number, statusText?: string) {
         title: "400: Bad request",
         message: statusText ?? "The request was invalid.",
       };
+    case 401:
+      return {
+        title: "401: Unauthorized",
+        message: statusText ?? "Please sign in to continue.",
+      };
+    case 403:
+      return {
+        title: "403: Forbidden",
+        message: statusText ?? "You don't have permission to access this resource.",
+      };
     case 404:
       return {
         title: "404: Page not found",
         message: statusText ?? "The page you're looking for doesn't exist.",
       };
+    case 429:
+      return {
+        title: "429: Too many requests",
+        message: statusText ?? "Please wait a moment and try again.",
+      };
     case 500:
       return {
         title: "500: Server error",
diff --git a/apps/webapp/app/utils/logUtils.ts b/apps/webapp/app/utils/logUtils.ts
new file mode 100644
index 00000000000..71ec44534b0
--- /dev/null
+++ b/apps/webapp/app/utils/logUtils.ts
@@ -0,0 +1,114 @@
+import { createElement, Fragment, type ReactNode } from "react";
+import { z } from "zod";
+
+export const LogLevelSchema = z.enum(["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]);
+export type LogLevel = z.infer<typeof LogLevelSchema>;
+
+export const validLogLevels: LogLevel[] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"];
+
+// Default styles for search highlighting
+const DEFAULT_HIGHLIGHT_STYLES: React.CSSProperties = {
+  backgroundColor: "#facc15", // yellow-400
+  color: "#000000",
+  fontWeight: "500",
+  borderRadius: "0.25rem",
+  padding: "0 0.125rem",
+} as const;
+
+/**
+ * Highlights all occurrences of a search term in text with consistent styling.
+ * Case-insensitive search with regex special character escaping.
+ *
+ * @param text - The text to search within
+ * @param searchTerm - The term to highlight (optional)
+ * @param style - Optional custom inline styles for highlights
+ * @returns React nodes with highlighted matches, or the original text if no matches
+ */
+export function highlightSearchText(
+  text: string,
+  searchTerm?: string,
+  style: React.CSSProperties = DEFAULT_HIGHLIGHT_STYLES
+): ReactNode {
+  if (!searchTerm || searchTerm.trim() === "") {
+    return text;
+  }
+
+  // Defense in depth: limit search term length to prevent ReDoS and performance issues
+  const MAX_SEARCH_LENGTH = 500;
+  if (searchTerm.length > MAX_SEARCH_LENGTH) {
+    return text;
+  }
+
+  // Escape special regex characters in search term
+  const escapedSearch = searchTerm.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(escapedSearch, "gi");
+
+  const parts: ReactNode[] = [];
+  let lastIndex = 0;
+  let match;
+  let matchCount = 0;
+
+  while ((match = regex.exec(text)) !== null) {
+    // Add text before match
+    if (match.index > lastIndex) {
+      parts.push(text.substring(lastIndex, match.index));
+    }
+    // Add highlighted match
+    parts.push(
+      createElement("span", { key: `match-${matchCount}`, style }, match[0])
+    );
+    lastIndex = regex.lastIndex;
+    matchCount++;
+  }
+
+  // Add remaining text
+  if (lastIndex < text.length) {
+    parts.push(text.substring(lastIndex));
+  }
+
+  return parts.length > 0 ? parts : text;
+}
+
+// Convert ClickHouse kind to display level
+export function kindToLevel(kind: string, status: string): LogLevel {
+  // ERROR can come from either kind or status
+  if (kind === "LOG_ERROR" || status === "ERROR") {
+    return "ERROR";
+  }
+
+  switch (kind) {
+    case "DEBUG_EVENT":
+    case "LOG_DEBUG":
+      return "DEBUG";
+    case "LOG_INFO":
+      return "INFO";
+    case "LOG_WARN":
+      return "WARN";
+    case "LOG_LOG":
+      return "INFO"; // Changed from "LOG"
+    case "SPAN":
+      return "TRACE";
+    case "ANCESTOR_OVERRIDE":
+    case "SPAN_EVENT":
+    default:
+      return "INFO";
+  }
+}
+
+// Level badge color styles
+export function getLevelColor(level: LogLevel): string {
+  switch (level) {
+    case "ERROR":
+      return "text-error bg-error/10 border-error/20";
+    case "WARN":
+      return "text-warning bg-warning/10 border-warning/20";
+    case "TRACE":
+      return "text-purple-400 bg-purple-500/10 border-purple-500/20";
+    case "DEBUG":
+      return "text-charcoal-400 bg-charcoal-700 border-charcoal-600";
+    case "INFO":
+      return "text-blue-400 bg-blue-500/10 border-blue-500/20";
+    default:
+      return "text-text-dimmed bg-charcoal-750 border-charcoal-700";
+  }
+}
diff --git a/apps/webapp/app/utils/modelFormatters.ts b/apps/webapp/app/utils/modelFormatters.ts
new file mode 100644
index 00000000000..9dffc395fb6
--- /dev/null
+++ b/apps/webapp/app/utils/modelFormatters.ts
@@ -0,0 +1,56 @@
+import { formatNumberCompact } from "./numberFormatter";
+
+/** Format a per-token price as $/1M tokens. */
+export function formatModelPrice(pricePerToken: number | null): string {
+  if (pricePerToken === null) return "—";
+  const perMillion = pricePerToken * 1_000_000;
+  if (perMillion < 0.01) return `$${perMillion.toFixed(4)}`;
+  if (perMillion < 1) return `$${perMillion.toFixed(3)}`;
+  return `$${perMillion.toFixed(2)}`;
+}
+
+/** Format a token count (context window, max output). */
+export function formatTokenCount(tokens: number | null): string {
+  if (tokens === null) return "—";
+  return formatNumberCompact(tokens);
+}
+
+/** Format a dollar cost value. */
+export function formatModelCost(dollars: number): string {
+  if (dollars === 0) return "$0";
+  if (dollars < 0.01) return `$${dollars.toFixed(4)}`;
+  if (dollars < 1) return `$${dollars.toFixed(3)}`;
+  return `$${dollars.toFixed(2)}`;
+}
+
+/** Format a feature slug (snake_case) to Title Case. */
+export function formatFeature(slug: string): string {
+  return slug
+    .toLowerCase()
+    .split("_")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+/** @deprecated Use formatFeature instead. */
+export const formatCapability = formatFeature;
+
+/** Capitalize a provider name. */
+export function formatProviderName(provider: string): string {
+  const names: Record<string, string> = {
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    google: "Google",
+    meta: "Meta",
+    mistral: "Mistral",
+    cohere: "Cohere",
+    ai21: "AI21",
+    amazon: "Amazon",
+    xai: "xAI",
+    deepseek: "DeepSeek",
+    qwen: "Qwen",
+    perplexity: "Perplexity",
+    nous: "Nous",
+  };
+  return names[provider.toLowerCase()] ?? provider.charAt(0).toUpperCase() + provider.slice(1);
+}
diff --git a/apps/webapp/app/utils/numberFormatter.ts b/apps/webapp/app/utils/numberFormatter.ts
index 13b59b1401c..8cdc2e07931 100644
--- a/apps/webapp/app/utils/numberFormatter.ts
+++ b/apps/webapp/app/utils/numberFormatter.ts
@@ -6,7 +6,18 @@ export const formatNumberCompact = (num: number): string => {
 
 const formatter = Intl.NumberFormat("en");
 
+// Formatter for small decimal values that need more precision
+const preciseFormatter = Intl.NumberFormat("en", {
+  minimumSignificantDigits: 1,
+  maximumSignificantDigits: 6,
+});
+
 export const formatNumber = (num: number): string => {
+  // For very small numbers (between -1 and 1, exclusive), use precise formatting
+  // to avoid rounding 0.000025 to 0
+  if (num !== 0 && Math.abs(num) < 1) {
+    return preciseFormatter.format(num);
+  }
   return formatter.format(num);
 };
 
diff --git a/apps/webapp/app/utils/pathBuilder.ts b/apps/webapp/app/utils/pathBuilder.ts
index f55ce8028d6..7a151053f5a 100644
--- a/apps/webapp/app/utils/pathBuilder.ts
+++ b/apps/webapp/app/utils/pathBuilder.ts
@@ -56,6 +56,11 @@ export function rootPath() {
   return `/`;
 }
 
+/** Given a path, it makes it an impersonation path */
+export function impersonate(path: string) {
+  return `/@${path}`;
+}
+
 export function accountPath() {
   return `/account`;
 }
@@ -121,6 +126,18 @@ export function organizationSettingsPath(organization: OrgForPath) {
   return `${organizationPath(organization)}/settings`;
 }
 
+export function organizationIntegrationsPath(organization: OrgForPath) {
+  return `${organizationPath(organization)}/settings/integrations`;
+}
+
+export function organizationVercelIntegrationPath(organization: OrgForPath) {
+  return `${organizationIntegrationsPath(organization)}/vercel`;
+}
+
+export function organizationSlackIntegrationPath(organization: OrgForPath) {
+  return `${organizationIntegrationsPath(organization)}/slack`;
+}
+
 function organizationParam(organization: OrgForPath) {
   return organization.slug;
 }
@@ -151,6 +168,22 @@ export function githubAppInstallPath(organizationSlug: string, redirectTo: strin
   )}`;
 }
 
+export function vercelAppInstallPath(organizationSlug: string, projectSlug: string) {
+  return `/vercel/install?org_slug=${organizationSlug}&project_slug=${projectSlug}`;
+}
+
+export function vercelCallbackPath() {
+  return `/vercel/callback`;
+}
+
+export function vercelResourcePath(
+  organizationSlug: string,
+  projectSlug: string,
+  environmentSlug: string
+) {
+  return `/resources/orgs/${organizationSlug}/projects/${projectSlug}/env/${environmentSlug}/vercel`;
+}
+
 export function v3EnvironmentPath(
   organization: OrgForPath,
   project: ProjectForPath,
@@ -242,6 +275,34 @@ export function v3TestPath(
   return `${v3EnvironmentPath(organization, project, environment)}/test`;
 }
 
+export function queryPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/query`;
+}
+
+export function v3CustomDashboardPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath,
+  dashboard: { friendlyId: string }
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/dashboards/custom/${
+    dashboard.friendlyId
+  }`;
+}
+
+export function v3BuiltInDashboardPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath,
+  key: string
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/dashboards/${key}`;
+}
+
 export function v3TestTaskPath(
   organization: OrgForPath,
   project: ProjectForPath,
@@ -269,7 +330,7 @@ export function v3CreateBulkActionPath(
   project: ProjectForPath,
   environment: EnvironmentForPath,
   filters?: TaskRunListSearchFilters,
-  mode?: "selected" | "filters",
+  mode?: "selected" | "filter",
   action?: "replay" | "cancel"
 ) {
   const searchParams = objectToSearchParams(filters) ?? new URLSearchParams();
@@ -298,11 +359,15 @@ export function v3RunPath(
 export function v3RunRedirectPath(
   organization: OrgForPath,
   project: ProjectForPath,
-  run: v3RunForPath,
+  run: v3RunForPath
 ) {
   return `${v3ProjectPath(organization, project)}/runs/${run.friendlyId}`;
 }
 
+export function v3RunPathFromFriendlyId(runId: string) {
+  return `/runs/${runId}`;
+}
+
 export function v3RunDownloadLogsPath(run: v3RunForPath) {
   return `/resources/runs/${run.friendlyId}/logs/download`;
 }
@@ -443,6 +508,99 @@ export function v3ProjectSettingsPath(
   return `${v3EnvironmentPath(organization, project, environment)}/settings`;
 }
 
+export function v3ProjectSettingsGeneralPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3ProjectSettingsPath(organization, project, environment)}/general`;
+}
+
+export function v3ProjectSettingsIntegrationsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3ProjectSettingsPath(organization, project, environment)}/integrations`;
+}
+
+export function v3LogsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/logs`;
+}
+
+export function v3PromptsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/prompts`;
+}
+
+export function v3PromptPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath,
+  promptSlug: string,
+  version?: string | number
+) {
+  const base = `${v3PromptsPath(organization, project, environment)}/${promptSlug}`;
+  return version != null ? `${base}?version=${version}` : base;
+}
+
+export function v3ModelsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/models`;
+}
+
+export function v3ModelDetailPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath,
+  modelId: string
+) {
+  return `${v3ModelsPath(organization, project, environment)}/${modelId}`;
+}
+
+export function v3ModelComparePath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3ModelsPath(organization, project, environment)}/compare`;
+}
+
+export function v3ErrorsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/errors`;
+}
+
+export function v3ErrorsConnectToSlackPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3ErrorsPath(organization, project, environment)}/connect-to-slack`;
+}
+
+export function v3ErrorPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath,
+  error: { fingerprint: string }
+) {
+  return `${v3ErrorsPath(organization, project, environment)}/${error.fingerprint}`;
+}
+
 export function v3DeploymentsPath(
   organization: OrgForPath,
   project: ProjectForPath,
@@ -487,6 +645,14 @@ export function concurrencyPath(
   return `${v3EnvironmentPath(organization, project, environment)}/concurrency`;
 }
 
+export function limitsPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  environment: EnvironmentForPath
+) {
+  return `${v3EnvironmentPath(organization, project, environment)}/limits`;
+}
+
 export function regionsPath(
   organization: OrgForPath,
   project: ProjectForPath,
@@ -505,6 +671,14 @@ export function v3BillingAlertsPath(organization: OrgForPath) {
   return `${organizationPath(organization)}/settings/billing-alerts`;
 }
 
+export function v3PrivateConnectionsPath(organization: OrgForPath) {
+  return `${organizationPath(organization)}/settings/private-connections`;
+}
+
+export function v3NewPrivateConnectionPath(organization: OrgForPath) {
+  return `${organizationPath(organization)}/settings/private-connections/new`;
+}
+
 export function v3StripePortalPath(organization: OrgForPath) {
   return `/resources/${organization.slug}/subscription/portal`;
 }
diff --git a/apps/webapp/app/utils/periods.ts b/apps/webapp/app/utils/periods.ts
new file mode 100644
index 00000000000..cdd576e9988
--- /dev/null
+++ b/apps/webapp/app/utils/periods.ts
@@ -0,0 +1,19 @@
+/** Convert a period string like "7d", "24h", "30m" to milliseconds. Defaults to 7d. */
+export function parsePeriodToMs(period: string): number {
+  const match = period.match(/^(\d+)([mhdw])$/);
+  if (!match) return 7 * 24 * 60 * 60 * 1000;
+  const [, numStr, unit] = match;
+  const num = parseInt(numStr, 10);
+  switch (unit) {
+    case "m":
+      return num * 60 * 1000;
+    case "h":
+      return num * 60 * 60 * 1000;
+    case "d":
+      return num * 24 * 60 * 60 * 1000;
+    case "w":
+      return num * 7 * 24 * 60 * 60 * 1000;
+    default:
+      return 7 * 24 * 60 * 60 * 1000;
+  }
+}
diff --git a/apps/webapp/app/utils/semver.ts b/apps/webapp/app/utils/semver.ts
new file mode 100644
index 00000000000..e53abf9ee09
--- /dev/null
+++ b/apps/webapp/app/utils/semver.ts
@@ -0,0 +1,41 @@
+/**
+ * Parses a version string into comparable numeric parts.
+ * Handles formats like "1.2.3", "20240115.1", "v1.0.0", plain timestamps, etc.
+ * Non-numeric pre-release suffixes (e.g. "-beta.1") are stripped for ordering purposes.
+ */
+function parseVersionParts(version: string): number[] {
+  const cleaned = version.replace(/^v/i, "").replace(/[-+].*$/, "");
+  return cleaned.split(".").map((p) => {
+    const n = parseInt(p, 10);
+    return isNaN(n) ? 0 : n;
+  });
+}
+
+/**
+ * Compares two version strings using numeric segment comparison (descending).
+ * Falls back to lexicographic comparison when segments are equal.
+ * Returns a negative number if `a` should come before `b` (i.e. `a` is newer).
+ */
+export function compareVersionsDescending(a: string, b: string): number {
+  const partsA = parseVersionParts(a);
+  const partsB = parseVersionParts(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const segA = partsA[i] ?? 0;
+    const segB = partsB[i] ?? 0;
+    if (segA !== segB) {
+      return segB - segA;
+    }
+  }
+
+  return b.localeCompare(a);
+}
+
+/**
+ * Sorts an array of version strings in descending order (newest first).
+ * Non-destructive – returns a new array.
+ */
+export function sortVersionsDescending(versions: string[]): string[] {
+  return [...versions].sort(compareVersionsDescending);
+}
diff --git a/apps/webapp/app/utils/throttle.ts b/apps/webapp/app/utils/throttle.ts
index a6c1a77a32d..5b264ebd862 100644
--- a/apps/webapp/app/utils/throttle.ts
+++ b/apps/webapp/app/utils/throttle.ts
@@ -1,13 +1,13 @@
 //From: https://kettanaito.com/blog/debounce-vs-throttle
 
 /** A very simple throttle. Will execute the function at the end of each period and discard any other calls during that period. */
-export function throttle(
-  func: (...args: any[]) => void,
+export function throttle<TArgs extends unknown[]>(
+  func: (...args: TArgs) => void,
   durationMs: number
-): (...args: any[]) => void {
+): (...args: TArgs) => void {
   let isPrimedToFire = false;
 
-  return (...args: any[]) => {
+  return (...args: TArgs) => {
     if (!isPrimedToFire) {
       isPrimedToFire = true;
 
diff --git a/apps/webapp/app/utils/timeGranularity.ts b/apps/webapp/app/utils/timeGranularity.ts
new file mode 100644
index 00000000000..0d8592d27bf
--- /dev/null
+++ b/apps/webapp/app/utils/timeGranularity.ts
@@ -0,0 +1,63 @@
+import { z } from "zod";
+import parseDuration from "parse-duration";
+
+const DurationString = z
+  .string()
+  .refine(
+    (val) => {
+      const ms = parseDuration(val);
+      return ms !== null && ms > 0;
+    },
+    (val) => ({ message: `Invalid or non-positive duration string: "${val}"` })
+  );
+
+const BracketSchema = z.object({
+  max: z.union([z.literal("Infinity"), DurationString]),
+  granularity: DurationString,
+});
+
+const BracketsSchema = z
+  .array(BracketSchema)
+  .min(1, "TimeGranularity requires at least one bracket");
+
+export type TimeGranularityBracket = z.input<typeof BracketSchema>;
+
+type ParsedBracket = {
+  maxMs: number;
+  granularityMs: number;
+};
+
+function requireParsedDuration(input: string): number {
+  const ms = parseDuration(input);
+  if (ms === null || ms <= 0) {
+    throw new Error(`Duration must be strictly positive, got "${input}" (${ms}ms)`);
+  }
+  return ms;
+}
+
+export class TimeGranularity {
+  private readonly parsed: ParsedBracket[];
+
+  constructor(brackets: TimeGranularityBracket[]) {
+    const validated = BracketsSchema.parse(brackets);
+
+    this.parsed = validated.map((b) => ({
+      maxMs: b.max === "Infinity" ? Infinity : requireParsedDuration(b.max),
+      granularityMs: requireParsedDuration(b.granularity),
+    }));
+  }
+
+  getTimeGranularityMs(from: Date, to: Date): number {
+    if (from.getTime() > to.getTime()) {
+      return this.parsed[this.parsed.length - 1].granularityMs;
+    }
+
+    const rangeMs = to.getTime() - from.getTime();
+    for (const bracket of this.parsed) {
+      if (rangeMs <= bracket.maxMs) {
+        return bracket.granularityMs;
+      }
+    }
+    return this.parsed[this.parsed.length - 1].granularityMs;
+  }
+}
diff --git a/apps/webapp/app/utils/triggerSource.ts b/apps/webapp/app/utils/triggerSource.ts
new file mode 100644
index 00000000000..720ba4231ac
--- /dev/null
+++ b/apps/webapp/app/utils/triggerSource.ts
@@ -0,0 +1,9 @@
+const ALLOWED_TRIGGER_SOURCES = new Set(["sdk", "cli", "mcp"]);
+
+/** Validates a client-provided trigger source header against the allowlist. */
+export function sanitizeTriggerSource(value: string | null | undefined): string | undefined {
+  if (value && ALLOWED_TRIGGER_SOURCES.has(value)) {
+    return value;
+  }
+  return undefined;
+}
diff --git a/apps/webapp/app/v3/alertsWorker.server.ts b/apps/webapp/app/v3/alertsWorker.server.ts
index 46670887a75..693b16b738a 100644
--- a/apps/webapp/app/v3/alertsWorker.server.ts
+++ b/apps/webapp/app/v3/alertsWorker.server.ts
@@ -1,10 +1,12 @@
 import { Logger } from "@trigger.dev/core/logger";
-import { Worker as RedisWorker } from "@trigger.dev/redis-worker";
+import { CronSchema, Worker as RedisWorker } from "@trigger.dev/redis-worker";
 import { z } from "zod";
 import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
 import { singleton } from "~/utils/singleton";
 import { DeliverAlertService } from "./services/alerts/deliverAlert.server";
+import { DeliverErrorGroupAlertService } from "./services/alerts/deliverErrorGroupAlert.server";
+import { ErrorAlertEvaluator } from "./services/alerts/errorAlertEvaluator.server";
 import { PerformDeploymentAlertsService } from "./services/alerts/performDeploymentAlerts.server";
 import { PerformTaskRunAlertsService } from "./services/alerts/performTaskRunAlerts.server";
 
@@ -55,6 +57,42 @@ function initializeWorker() {
         },
         logErrors: false,
       },
+      "v3.evaluateErrorAlerts": {
+        schema: z.object({
+          projectId: z.string(),
+          scheduledAt: z.number(),
+        }),
+        visibilityTimeoutMs: 60_000 * 5,
+        retry: {
+          maxAttempts: 3,
+        },
+        logErrors: true,
+      },
+      "v3.deliverErrorGroupAlert": {
+        schema: z.object({
+          channelId: z.string(),
+          projectId: z.string(),
+          classification: z.enum(["new_issue", "regression", "unignored"]),
+          error: z.object({
+            fingerprint: z.string(),
+            environmentId: z.string(),
+            environmentSlug: z.string(),
+            environmentName: z.string(),
+            taskIdentifier: z.string(),
+            errorType: z.string(),
+            errorMessage: z.string(),
+            sampleStackTrace: z.string(),
+            firstSeen: z.string(),
+            lastSeen: z.string(),
+            occurrenceCount: z.number(),
+          }),
+        }),
+        visibilityTimeoutMs: 60_000,
+        retry: {
+          maxAttempts: 3,
+        },
+        logErrors: true,
+      },
     },
     concurrency: {
       workers: env.ALERTS_WORKER_CONCURRENCY_WORKERS,
@@ -80,6 +118,14 @@ function initializeWorker() {
         const service = new PerformTaskRunAlertsService();
         await service.call(payload.runId);
       },
+      "v3.evaluateErrorAlerts": async ({ payload }) => {
+        const evaluator = new ErrorAlertEvaluator();
+        await evaluator.evaluate(payload.projectId, payload.scheduledAt);
+      },
+      "v3.deliverErrorGroupAlert": async ({ payload }) => {
+        const service = new DeliverErrorGroupAlertService();
+        await service.call(payload);
+      },
     },
   });
 
diff --git a/apps/webapp/app/v3/canAccessAi.server.ts b/apps/webapp/app/v3/canAccessAi.server.ts
new file mode 100644
index 00000000000..61e9258e0b7
--- /dev/null
+++ b/apps/webapp/app/v3/canAccessAi.server.ts
@@ -0,0 +1,47 @@
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
+
+export async function canAccessAi(options: {
+  userId: string;
+  isAdmin: boolean;
+  isImpersonating: boolean;
+  organizationSlug: string;
+}): Promise<boolean> {
+  const { userId, isAdmin, isImpersonating, organizationSlug } = options;
+
+  // 1. If env var is set then globally enabled
+  if (env.AI_FEATURES_ENABLED === "1") {
+    return true;
+  }
+
+  // 2. Admins always have access
+  if (isAdmin || isImpersonating) {
+    return true;
+  }
+
+  // 3. Check if org/global feature flag is on
+  const org = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+    },
+    select: {
+      featureFlags: true,
+    },
+  });
+
+  const flag = makeFlag();
+  const flagResult = await flag({
+    key: FEATURE_FLAG.hasAiAccess,
+    defaultValue: false,
+    overrides: (org?.featureFlags as Record<string, unknown>) ?? {},
+  });
+  if (flagResult) {
+    return true;
+  }
+
+  // 4. Not enabled anywhere
+  return false;
+}
diff --git a/apps/webapp/app/v3/canAccessPrivateConnections.server.ts b/apps/webapp/app/v3/canAccessPrivateConnections.server.ts
new file mode 100644
index 00000000000..a801a4d2f24
--- /dev/null
+++ b/apps/webapp/app/v3/canAccessPrivateConnections.server.ts
@@ -0,0 +1,28 @@
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
+
+export async function canAccessPrivateConnections(options: {
+  organizationSlug: string;
+  userId: string;
+}): Promise<boolean> {
+  const { organizationSlug, userId } = options;
+
+  const org = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+    },
+    select: {
+      featureFlags: true,
+    },
+  });
+
+  const flag = makeFlag();
+  return flag({
+    key: FEATURE_FLAG.hasPrivateConnections,
+    defaultValue: env.PRIVATE_CONNECTIONS_ENABLED === "1",
+    overrides: (org?.featureFlags as Record<string, unknown>) ?? {},
+  });
+}
diff --git a/apps/webapp/app/v3/canAccessQuery.server.ts b/apps/webapp/app/v3/canAccessQuery.server.ts
new file mode 100644
index 00000000000..13b7602d937
--- /dev/null
+++ b/apps/webapp/app/v3/canAccessQuery.server.ts
@@ -0,0 +1,48 @@
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
+
+export async function canAccessQuery(options: {
+  userId: string;
+  isAdmin: boolean;
+  isImpersonating: boolean;
+  organizationSlug: string;
+}): Promise<boolean> {
+  const { userId, isAdmin, isImpersonating, organizationSlug } = options;
+
+  // 1. If it's on then we have access
+  const globallyEnabled = env.QUERY_FEATURE_ENABLED === "1";
+  if (globallyEnabled) {
+    return true;
+  }
+
+  // 2. Admins always have access
+  if (isAdmin || isImpersonating) {
+    return true;
+  }
+
+  // 3. Check if org/global feature flag is on
+  const org = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+    },
+    select: {
+      featureFlags: true,
+    },
+  });
+
+  const flag = makeFlag();
+  const flagResult = await flag({
+    key: FEATURE_FLAG.hasQueryAccess,
+    defaultValue: false,
+    overrides: (org?.featureFlags as Record<string, unknown>) ?? {},
+  });
+  if (flagResult) {
+    return true;
+  }
+
+  // 4. Not enabled anywhere
+  return false;
+}
diff --git a/apps/webapp/app/v3/dynamicFlushScheduler.server.ts b/apps/webapp/app/v3/dynamicFlushScheduler.server.ts
index 946bc193667..9f2cffec9e6 100644
--- a/apps/webapp/app/v3/dynamicFlushScheduler.server.ts
+++ b/apps/webapp/app/v3/dynamicFlushScheduler.server.ts
@@ -52,7 +52,7 @@ export class DynamicFlushScheduler<T> {
   private readonly isDroppableEvent?: (item: T) => boolean;
   private isLoadShedding: boolean = false;
 
-  private readonly logger: Logger = new Logger("EventRepo.DynamicFlushScheduler", "debug");
+  private readonly logger: Logger = new Logger("EventRepo.DynamicFlushScheduler", "info");
 
   constructor(config: DynamicFlushSchedulerConfig<T>) {
     this.batchQueue = [];
@@ -329,7 +329,7 @@ export class DynamicFlushScheduler<T> {
         droppedByKind[kind] = count;
       });
 
-      this.logger.info("DynamicFlushScheduler metrics", {
+      this.logger.debug("DynamicFlushScheduler metrics", {
         totalQueuedItems: this.totalQueuedItems,
         batchQueueLength: this.batchQueue.length,
         currentBatchLength: this.currentBatch.length,
diff --git a/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts b/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
index 0ade9436d47..c6c72d79567 100644
--- a/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
+++ b/apps/webapp/app/v3/environmentVariables/environmentVariablesRepository.server.ts
@@ -6,9 +6,12 @@ import { env } from "~/env.server";
 import { getSecretStore } from "~/services/secrets/secretStore.server";
 import { generateFriendlyId } from "../friendlyIdentifiers";
 import {
+  type CreateEnvironmentVariables,
   type CreateResult,
   type DeleteEnvironmentVariable,
   type DeleteEnvironmentVariableValue,
+  type EditEnvironmentVariable,
+  type EditEnvironmentVariableValue,
   type EnvironmentVariable,
   type EnvironmentVariableWithSecret,
   type ProjectEnvironmentVariable,
@@ -45,18 +48,7 @@ const SecretValue = z.object({ secret: z.string() });
 export class EnvironmentVariablesRepository implements Repository {
   constructor(private prismaClient: PrismaClient = prisma) {}
 
-  async create(
-    projectId: string,
-    options: {
-      override: boolean;
-      environmentIds: string[];
-      isSecret?: boolean;
-      variables: {
-        key: string;
-        value: string;
-      }[];
-    }
-  ): Promise<CreateResult> {
+  async create(projectId: string, options: CreateEnvironmentVariables): Promise<CreateResult> {
     const project = await this.prismaClient.project.findFirst({
       where: {
         id: projectId,
@@ -164,10 +156,49 @@ export class EnvironmentVariablesRepository implements Repository {
             prismaClient: tx,
           });
 
+          // If parentEnvironmentId is provided and isSecret is not explicitly set,
+          // look up if the parent has this variable marked as secret
+          let inheritedIsSecret: boolean | undefined = undefined;
+          if (options.isSecret === undefined && options.parentEnvironmentId) {
+            const parentVariableValue = await tx.environmentVariableValue.findFirst({
+              where: {
+                variableId: environmentVariable.id,
+                environmentId: options.parentEnvironmentId,
+              },
+              select: {
+                isSecret: true,
+              },
+            });
+            if (parentVariableValue?.isSecret) {
+              inheritedIsSecret = true;
+            }
+          }
+
+          const effectiveIsSecret = options.isSecret ?? inheritedIsSecret;
+
           //set the secret values and references
           for (const environmentId of options.environmentIds) {
             const key = secretKey(projectId, environmentId, variable.key);
 
+            const existingValueRecord = await tx.environmentVariableValue.findFirst({
+              where: {
+                variableId: environmentVariable.id,
+                environmentId,
+              },
+            });
+
+            // Check if value already exists and is the same, and no metadata change (e.g. isSecret toggle)
+            const existingSecret = await secretStore.getSecret(SecretValue, key);
+            const canSkip =
+              existingSecret &&
+              existingSecret.secret === variable.value &&
+              existingValueRecord &&
+              (options.isSecret === undefined ||
+                existingValueRecord.isSecret === options.isSecret);
+            if (canSkip) {
+              continue;
+            }
+
             //create the secret reference
             const secretReference = await tx.secretReference.upsert({
               where: {
@@ -180,23 +211,36 @@ export class EnvironmentVariablesRepository implements Repository {
               update: {},
             });
 
-            const variableValue = await tx.environmentVariableValue.upsert({
-              where: {
-                variableId_environmentId: {
+            if (existingValueRecord) {
+              await tx.environmentVariableValue.update({
+                where: {
+                  id: existingValueRecord.id,
+                },
+                data: {
+                  version: {
+                    increment: 1,
+                  },
+                  ...(options.lastUpdatedBy ? { lastUpdatedBy: options.lastUpdatedBy } : {}),
+                  valueReferenceId: secretReference.id,
+                  ...(options.isSecret !== undefined
+                    ? {
+                        isSecret: options.isSecret,
+                      }
+                    : {}),
+                },
+              });
+            } else {
+              await tx.environmentVariableValue.create({
+                data: {
                   variableId: environmentVariable.id,
-                  environmentId,
+                  environmentId: environmentId,
+                  valueReferenceId: secretReference.id,
+                  isSecret: effectiveIsSecret,
+                  version: 1,
+                  lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : Prisma.JsonNull,
                 },
-              },
-              create: {
-                variableId: environmentVariable.id,
-                environmentId: environmentId,
-                valueReferenceId: secretReference.id,
-                isSecret: options.isSecret,
-              },
-              update: {
-                isSecret: options.isSecret,
-              },
-            });
+              });
+            }
 
             await secretStore.setSecret<{ secret: string }>(key, {
               secret: variable.value,
@@ -226,14 +270,7 @@ export class EnvironmentVariablesRepository implements Repository {
     }
   }
 
-  async edit(
-    projectId: string,
-    options: {
-      values: { value: string; environmentId: string }[];
-      id: string;
-      keepEmptyValues?: boolean;
-    }
-  ): Promise<Result> {
+  async edit(projectId: string, options: EditEnvironmentVariable): Promise<Result> {
     const project = await this.prismaClient.project.findFirst({
       where: {
         id: projectId,
@@ -323,6 +360,20 @@ export class EnvironmentVariablesRepository implements Repository {
               await secretStore.setSecret<{ secret: string }>(key, {
                 secret: value.value,
               });
+              await tx.environmentVariableValue.update({
+                where: {
+                  variableId_environmentId: {
+                    variableId: environmentVariable.id,
+                    environmentId: value.environmentId,
+                  },
+                },
+                data: {
+                  version: {
+                    increment: 1,
+                  },
+                  lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : undefined,
+                },
+              });
             }
             continue;
           }
@@ -340,6 +391,8 @@ export class EnvironmentVariablesRepository implements Repository {
               variableId: environmentVariable.id,
               environmentId: value.environmentId,
               valueReferenceId: secretReference.id,
+              version: 1,
+              lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : Prisma.JsonNull,
             },
           });
 
@@ -360,14 +413,7 @@ export class EnvironmentVariablesRepository implements Repository {
     }
   }
 
-  async editValue(
-    projectId: string,
-    options: {
-      id: string;
-      environmentId: string;
-      value: string;
-    }
-  ): Promise<Result> {
+  async editValue(projectId: string, options: EditEnvironmentVariableValue): Promise<Result> {
     const project = await this.prismaClient.project.findFirst({
       where: {
         id: projectId,
@@ -426,6 +472,21 @@ export class EnvironmentVariablesRepository implements Repository {
         await secretStore.setSecret<{ secret: string }>(key, {
           secret: options.value,
         });
+
+        await tx.environmentVariableValue.update({
+          where: {
+            variableId_environmentId: {
+              variableId: environmentVariable.id,
+              environmentId: options.environmentId,
+            },
+          },
+          data: {
+            version: {
+              increment: 1,
+            },
+            lastUpdatedBy: options.lastUpdatedBy ? options.lastUpdatedBy : undefined,
+          },
+        });
       });
 
       return {
@@ -895,6 +956,34 @@ async function resolveBuiltInDevVariables(runtimeEnvironment: RuntimeEnvironment
     },
   ];
 
+  if (env.DEV_OTEL_METRICS_ENDPOINT) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_ENDPOINT",
+      value: env.DEV_OTEL_METRICS_ENDPOINT,
+    });
+  }
+
+  if (env.DEV_OTEL_METRICS_EXPORT_INTERVAL_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_EXPORT_INTERVAL_MILLIS",
+      value: env.DEV_OTEL_METRICS_EXPORT_INTERVAL_MILLIS,
+    });
+  }
+
+  if (env.DEV_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS",
+      value: env.DEV_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS,
+    });
+  }
+
+  if (env.DEV_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS",
+      value: env.DEV_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS,
+    });
+  }
+
   if (env.DEV_OTEL_BATCH_PROCESSING_ENABLED === "1") {
     result = result.concat([
       {
@@ -1026,6 +1115,27 @@ async function resolveBuiltInProdVariables(
     ]);
   }
 
+  if (env.PROD_OTEL_METRICS_EXPORT_INTERVAL_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_EXPORT_INTERVAL_MILLIS",
+      value: env.PROD_OTEL_METRICS_EXPORT_INTERVAL_MILLIS,
+    });
+  }
+
+  if (env.PROD_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS",
+      value: env.PROD_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS,
+    });
+  }
+
+  if (env.PROD_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS) {
+    result.push({
+      key: "TRIGGER_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS",
+      value: env.PROD_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS,
+    });
+  }
+
   if (env.PROD_OTEL_BATCH_PROCESSING_ENABLED === "1") {
     result = result.concat([
       {
diff --git a/apps/webapp/app/v3/environmentVariables/repository.ts b/apps/webapp/app/v3/environmentVariables/repository.ts
index 521e22f7a28..ea027bc2ca8 100644
--- a/apps/webapp/app/v3/environmentVariables/repository.ts
+++ b/apps/webapp/app/v3/environmentVariables/repository.ts
@@ -6,9 +6,25 @@ export const EnvironmentVariableKey = z
   .nonempty("Key is required")
   .regex(/^\w+$/, "Keys can only use alphanumeric characters and underscores");
 
+export const EnvironmentVariableUpdaterSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("user"),
+    userId: z.string(),
+  }),
+  z.object({
+    type: z.literal("integration"),
+    integration: z.string(),
+  }),
+]);
+export type EnvironmentVariableUpdater = z.infer<typeof EnvironmentVariableUpdaterSchema>;
+
 export const CreateEnvironmentVariables = z.object({
+  override: z.boolean(),
   environmentIds: z.array(z.string()),
+  isSecret: z.boolean().optional(),
+  parentEnvironmentId: z.string().optional(),
   variables: z.array(z.object({ key: EnvironmentVariableKey, value: z.string() })),
+  lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
 });
 
 export type CreateEnvironmentVariables = z.infer<typeof CreateEnvironmentVariables>;
@@ -32,6 +48,7 @@ export const EditEnvironmentVariable = z.object({
     })
   ),
   keepEmptyValues: z.boolean().optional(),
+  lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
 });
 export type EditEnvironmentVariable = z.infer<typeof EditEnvironmentVariable>;
 
@@ -51,6 +68,7 @@ export const EditEnvironmentVariableValue = z.object({
   id: z.string(),
   environmentId: z.string(),
   value: z.string(),
+  lastUpdatedBy: EnvironmentVariableUpdaterSchema.optional(),
 });
 export type EditEnvironmentVariableValue = z.infer<typeof EditEnvironmentVariableValue>;
 
diff --git a/apps/webapp/app/v3/eventRepository/clickhouseEventRepository.server.ts b/apps/webapp/app/v3/eventRepository/clickhouseEventRepository.server.ts
index ebf20637d5b..27b96ed7d37 100644
--- a/apps/webapp/app/v3/eventRepository/clickhouseEventRepository.server.ts
+++ b/apps/webapp/app/v3/eventRepository/clickhouseEventRepository.server.ts
@@ -1,5 +1,6 @@
 import type {
   ClickHouse,
+  LlmMetricsV1Input,
   TaskEventDetailedSummaryV1Result,
   TaskEventDetailsV1Result,
   TaskEventSummaryV1Result,
@@ -7,6 +8,7 @@ import type {
   TaskEventV2Input,
 } from "@internal/clickhouse";
 import { Attributes, startSpan, trace, Tracer } from "@internal/tracing";
+
 import { createJsonErrorObject } from "@trigger.dev/core/v3/errors";
 import { serializeTraceparent } from "@trigger.dev/core/v3/isomorphic";
 import {
@@ -59,7 +61,6 @@ import type {
   TraceEventOptions,
   TraceSummary,
 } from "./eventRepository.types";
-import { originalRunIdCache } from "./originalRunIdCache.server";
 
 export type ClickhouseEventRepositoryConfig = {
   clickhouse: ClickHouse;
@@ -85,6 +86,11 @@ export type ClickhouseEventRepositoryConfig = {
    * - "v2": Uses task_events_v2 (partitioned by inserted_at to avoid "too many parts" errors)
    */
   version?: "v1" | "v2";
+  /** LLM metrics flush scheduler config */
+  llmMetricsBatchSize?: number;
+  llmMetricsFlushInterval?: number;
+  llmMetricsMaxBatchSize?: number;
+  llmMetricsMaxConcurrency?: number;
 };
 
 /**
@@ -95,6 +101,7 @@ export class ClickhouseEventRepository implements IEventRepository {
   private _clickhouse: ClickHouse;
   private _config: ClickhouseEventRepositoryConfig;
   private readonly _flushScheduler: DynamicFlushScheduler<TaskEventV1Input | TaskEventV2Input>;
+  private readonly _llmMetricsFlushScheduler: DynamicFlushScheduler<LlmMetricsV1Input>;
   private _tracer: Tracer;
   private _version: "v1" | "v2";
 
@@ -119,6 +126,17 @@ export class ClickhouseEventRepository implements IEventRepository {
         return event.kind === "DEBUG_EVENT";
       },
     });
+
+    this._llmMetricsFlushScheduler = new DynamicFlushScheduler({
+      batchSize: config.llmMetricsBatchSize ?? 5000,
+      flushInterval: config.llmMetricsFlushInterval ?? 2000,
+      callback: this.#flushLlmMetricsBatch.bind(this),
+      minConcurrency: 1,
+      maxConcurrency: config.llmMetricsMaxConcurrency ?? 2,
+      maxBatchSize: config.llmMetricsMaxBatchSize ?? 10000,
+      memoryPressureThreshold: config.llmMetricsMaxBatchSize ?? 10000,
+      loadSheddingEnabled: false,
+    });
   }
 
   get version() {
@@ -217,6 +235,63 @@ export class ClickhouseEventRepository implements IEventRepository {
     });
   }
 
+  async #flushLlmMetricsBatch(flushId: string, rows: LlmMetricsV1Input[]) {
+
+    const [insertError] = await this._clickhouse.llmMetrics.insert(rows, {
+      params: {
+        clickhouse_settings: this.#getClickhouseInsertSettings(),
+      },
+    });
+
+    if (insertError) {
+      throw insertError;
+    }
+
+    logger.info("ClickhouseEventRepository.flushLlmMetricsBatch Inserted LLM metrics batch", {
+      rows: rows.length,
+    });
+  }
+
+  #createLlmMetricsInput(event: CreateEventInput): LlmMetricsV1Input {
+    const llmMetrics = event._llmMetrics!;
+
+    return {
+      organization_id: event.organizationId,
+      project_id: event.projectId,
+      environment_id: event.environmentId,
+      run_id: event.runId,
+      task_identifier: event.taskSlug,
+      trace_id: event.traceId,
+      span_id: event.spanId,
+      gen_ai_system: llmMetrics.genAiSystem,
+      request_model: llmMetrics.requestModel,
+      response_model: llmMetrics.responseModel,
+      base_response_model: llmMetrics.baseResponseModel,
+      matched_model_id: llmMetrics.matchedModelId,
+      operation_id: llmMetrics.operationId,
+      finish_reason: llmMetrics.finishReason,
+      cost_source: llmMetrics.costSource,
+      pricing_tier_id: llmMetrics.pricingTierId,
+      pricing_tier_name: llmMetrics.pricingTierName,
+      input_tokens: llmMetrics.inputTokens,
+      output_tokens: llmMetrics.outputTokens,
+      total_tokens: llmMetrics.totalTokens,
+      usage_details: llmMetrics.usageDetails,
+      input_cost: llmMetrics.inputCost,
+      output_cost: llmMetrics.outputCost,
+      total_cost: llmMetrics.totalCost,
+      cost_details: llmMetrics.costDetails,
+      provider_cost: llmMetrics.providerCost,
+      ms_to_first_chunk: llmMetrics.msToFirstChunk,
+      tokens_per_second: llmMetrics.tokensPerSecond,
+      metadata: llmMetrics.metadata,
+      prompt_slug: llmMetrics.promptSlug,
+      prompt_version: llmMetrics.promptVersion,
+      start_time: this.#clampAndFormatStartTime(event.startTime.toString()),
+      duration: formatClickhouseUnsignedIntegerString(event.duration ?? 0),
+    };
+  }
+
   #getClickhouseInsertSettings() {
     if (this._config.insertStrategy === "insert") {
       return {};
@@ -237,6 +312,15 @@ export class ClickhouseEventRepository implements IEventRepository {
 
   async insertMany(events: CreateEventInput[]): Promise<void> {
     this.addToBatch(events.flatMap((event) => this.createEventToTaskEventV1Input(event)));
+
+    // Dual-write LLM metrics records for spans with cost enrichment
+    const llmMetricsRows = events
+      .filter((e) => e._llmMetrics != null)
+      .map((e) => this.#createLlmMetricsInput(e));
+
+    if (llmMetricsRows.length > 0) {
+      this._llmMetricsFlushScheduler.addToBatch(llmMetricsRows);
+    }
   }
 
   async insertManyImmediate(events: CreateEventInput[]): Promise<void> {
@@ -267,6 +351,7 @@ export class ClickhouseEventRepository implements IEventRepository {
         expires_at: convertDateToClickhouseDateTime(
           new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // 1 year
         ),
+        machine_id: event.machineId ?? "",
       },
       ...this.spanEventsToTaskEventV1Input(event),
     ];
@@ -705,13 +790,6 @@ export class ClickhouseEventRepository implements IEventRepository {
       expires_at: convertDateToClickhouseDateTime(new Date(Date.now() + 365 * 24 * 60 * 60 * 1000)),
     };
 
-    const originalRunId =
-      options.attributes.properties?.[SemanticInternalAttributes.ORIGINAL_RUN_ID];
-
-    if (typeof originalRunId === "string") {
-      await originalRunIdCache.set(traceId, spanId, originalRunId);
-    }
-
     const events = [event];
 
     if (failedWithError) {
@@ -1151,7 +1229,7 @@ export class ClickhouseEventRepository implements IEventRepository {
     endCreatedAt?: Date,
     options?: { includeDebugLogs?: boolean }
   ): Promise<SpanDetail | undefined> {
-    const startCreatedAtWithBuffer = new Date(startCreatedAt.getTime() - 1000);
+    const startCreatedAtWithBuffer = new Date(startCreatedAt.getTime() - 60_000);
 
     const queryBuilder =
       this._version === "v2"
@@ -1197,17 +1275,6 @@ export class ClickhouseEventRepository implements IEventRepository {
     return span;
   }
 
-  async getSpanOriginalRunId(
-    storeTable: TaskEventStoreTable,
-    environmentId: string,
-    spanId: string,
-    traceId: string,
-    startCreatedAt: Date,
-    endCreatedAt?: Date
-  ): Promise<string | undefined> {
-    return await originalRunIdCache.lookup(traceId, spanId);
-  }
-
   #mergeRecordsIntoSpanDetail(
     spanId: string,
     records: TaskEventDetailsV1Result[],
@@ -1300,6 +1367,8 @@ export class ClickhouseEventRepository implements IEventRepository {
       }
 
       if (record.kind === "SPAN") {
+        // Prefer SPAN record message for span title (task name); SPAN_EVENT "exception" must not override it
+        span.message = record.message;
         if (record.status === "ERROR") {
           span.isError = true;
           span.isPartial = false;
@@ -1315,24 +1384,29 @@ export class ClickhouseEventRepository implements IEventRepository {
         if (record.status !== "PARTIAL") {
           span.duration =
             typeof record.duration === "number" ? record.duration : Number(record.duration);
-        } else {
-          span.message = record.message;
         }
       }
 
-      if (
-        (span.properties == null ||
-          (typeof span.properties === "object" && Object.keys(span.properties).length === 0)) &&
-        typeof record.attributes_text === "string"
-      ) {
-        const parsedAttributes = this.#parseAttributes(record.attributes_text);
-        const resourceAttributes = parsedAttributes["$resource"];
-
-        // Remove the $resource key from the attributes
-        delete parsedAttributes["$resource"];
-
-        span.properties = parsedAttributes;
-        span.resourceProperties = resourceAttributes as Record<string, unknown> | undefined;
+      // Parse attributes from the first record that has them, then re-parse for the
+      // completed SPAN record. The completed record's attributes are a superset of the
+      // partial's (includes enriched trigger.llm.* cost data added during ingestion).
+      // This means at most 2x JSON.parse per span detail query, but only on this
+      // read path (span detail view), not on ingestion.
+      if (typeof record.attributes_text === "string") {
+        const shouldUpdate =
+          span.properties == null ||
+          (typeof span.properties === "object" && Object.keys(span.properties).length === 0) ||
+          (record.kind === "SPAN" && record.status !== "PARTIAL");
+
+        if (shouldUpdate) {
+          const parsedAttributes = this.#parseAttributes(record.attributes_text);
+          const resourceAttributes = parsedAttributes["$resource"];
+
+          delete parsedAttributes["$resource"];
+
+          span.properties = parsedAttributes;
+          span.resourceProperties = resourceAttributes as Record<string, unknown> | undefined;
+        }
       }
     }
 
@@ -1543,10 +1617,18 @@ export class ClickhouseEventRepository implements IEventRepository {
       }
 
       if (parsedMetadata && "style" in parsedMetadata && parsedMetadata.style) {
-        span.data.style = parsedMetadata.style as TaskEventStyle;
+        const newStyle = parsedMetadata.style as TaskEventStyle;
+        // Merge styles: prefer the most complete value for each field
+        span.data.style = {
+          icon: newStyle.icon ?? span.data.style.icon,
+          variant: newStyle.variant ?? span.data.style.variant,
+          accessory: newStyle.accessory ?? span.data.style.accessory,
+        };
       }
 
       if (record.kind === "SPAN") {
+        // Prefer SPAN record message for span title (task name); SPAN_EVENT "exception" must not override it
+        span.data.message = record.message;
         if (record.status === "ERROR") {
           span.data.isError = true;
           span.data.isPartial = false;
@@ -1562,8 +1644,6 @@ export class ClickhouseEventRepository implements IEventRepository {
         if (record.status !== "PARTIAL") {
           span.data.duration =
             typeof record.duration === "number" ? record.duration : Number(record.duration);
-        } else {
-          span.data.message = record.message;
         }
       }
     }
@@ -1799,6 +1879,8 @@ export class ClickhouseEventRepository implements IEventRepository {
       }
 
       if (record.kind === "SPAN") {
+        // Prefer SPAN record message for span title (task name); SPAN_EVENT "exception" must not override it
+        span.data.message = record.message;
         if (record.status === "ERROR") {
           span.data.isError = true;
           span.data.isPartial = false;
@@ -1814,8 +1896,6 @@ export class ClickhouseEventRepository implements IEventRepository {
         if (record.status !== "PARTIAL") {
           span.data.duration =
             typeof record.duration === "number" ? record.duration : Number(record.duration);
-        } else {
-          span.data.message = record.message;
         }
       }
     }
diff --git a/apps/webapp/app/v3/eventRepository/clickhouseEventRepositoryInstance.server.ts b/apps/webapp/app/v3/eventRepository/clickhouseEventRepositoryInstance.server.ts
index 36fb13c6e96..d4e28c5841a 100644
--- a/apps/webapp/app/v3/eventRepository/clickhouseEventRepositoryInstance.server.ts
+++ b/apps/webapp/app/v3/eventRepository/clickhouseEventRepositoryInstance.server.ts
@@ -64,6 +64,10 @@ function initializeClickhouseRepository() {
     asyncInsertMaxDataSize: env.EVENTS_CLICKHOUSE_ASYNC_INSERT_MAX_DATA_SIZE,
     asyncInsertBusyTimeoutMs: env.EVENTS_CLICKHOUSE_ASYNC_INSERT_BUSY_TIMEOUT_MS,
     startTimeMaxAgeMs: env.EVENTS_CLICKHOUSE_START_TIME_MAX_AGE_MS,
+    llmMetricsBatchSize: env.LLM_METRICS_BATCH_SIZE,
+    llmMetricsFlushInterval: env.LLM_METRICS_FLUSH_INTERVAL_MS,
+    llmMetricsMaxBatchSize: env.LLM_METRICS_MAX_BATCH_SIZE,
+    llmMetricsMaxConcurrency: env.LLM_METRICS_MAX_CONCURRENCY,
     version: "v1",
   });
 
@@ -97,6 +101,10 @@ function initializeClickhouseRepositoryV2() {
     waitForAsyncInsert: env.EVENTS_CLICKHOUSE_WAIT_FOR_ASYNC_INSERT === "1",
     asyncInsertMaxDataSize: env.EVENTS_CLICKHOUSE_ASYNC_INSERT_MAX_DATA_SIZE,
     asyncInsertBusyTimeoutMs: env.EVENTS_CLICKHOUSE_ASYNC_INSERT_BUSY_TIMEOUT_MS,
+    llmMetricsBatchSize: env.LLM_METRICS_BATCH_SIZE,
+    llmMetricsFlushInterval: env.LLM_METRICS_FLUSH_INTERVAL_MS,
+    llmMetricsMaxBatchSize: env.LLM_METRICS_MAX_BATCH_SIZE,
+    llmMetricsMaxConcurrency: env.LLM_METRICS_MAX_CONCURRENCY,
     version: "v2",
   });
 
diff --git a/apps/webapp/app/v3/eventRepository/common.server.ts b/apps/webapp/app/v3/eventRepository/common.server.ts
index 2e3bdf37c50..3ba8a50c7f7 100644
--- a/apps/webapp/app/v3/eventRepository/common.server.ts
+++ b/apps/webapp/app/v3/eventRepository/common.server.ts
@@ -140,7 +140,8 @@ export function createExceptionPropertiesFromError(error: TaskRunError): Excepti
   }
 }
 
-// removes keys that start with a $ sign. If there are no keys left, return undefined
+// Removes internal/private attribute keys from span properties.
+// Filters: "$" prefixed keys (private metadata) and "ctx." prefixed keys (Trigger.dev run context)
 export function removePrivateProperties(
   attributes: Attributes | undefined | null
 ): Attributes | undefined {
@@ -151,7 +152,7 @@ export function removePrivateProperties(
   const result: Attributes = {};
 
   for (const [key, value] of Object.entries(attributes)) {
-    if (key.startsWith("$")) {
+    if (key.startsWith("$") || key.startsWith("ctx.")) {
       continue;
     }
 
diff --git a/apps/webapp/app/v3/eventRepository/eventRepository.server.ts b/apps/webapp/app/v3/eventRepository/eventRepository.server.ts
index 96df1fb3538..de2a19e395e 100644
--- a/apps/webapp/app/v3/eventRepository/eventRepository.server.ts
+++ b/apps/webapp/app/v3/eventRepository/eventRepository.server.ts
@@ -64,7 +64,6 @@ import type {
   TraceEventOptions,
   TraceSummary,
 } from "./eventRepository.types";
-import { originalRunIdCache } from "./originalRunIdCache.server";
 
 const MAX_FLUSH_DEPTH = 5;
 
@@ -817,40 +816,6 @@ export class EventRepository implements IEventRepository {
     });
   }
 
-  async getSpanOriginalRunId(
-    storeTable: TaskEventStoreTable,
-    environmentId: string,
-    spanId: string,
-    traceId: string,
-    startCreatedAt: Date,
-    endCreatedAt?: Date
-  ): Promise<string | undefined> {
-    return await startActiveSpan("getSpanOriginalRunId", async (s) => {
-      return await originalRunIdCache.swr(traceId, spanId, async () => {
-        const spanEvent = await this.#getSpanEvent({
-          storeTable,
-          spanId,
-          environmentId,
-          startCreatedAt,
-          endCreatedAt,
-          options: { includeDebugLogs: false },
-        });
-
-        if (!spanEvent) {
-          return;
-        }
-        // This is used when the span is a cached run (because of idempotency key)
-        // so this span isn't the actual run span, but points to the original run
-        const originalRun = rehydrateAttribute<string>(
-          spanEvent.properties,
-          SemanticInternalAttributes.ORIGINAL_RUN_ID
-        );
-
-        return originalRun;
-      });
-    });
-  }
-
   async #createSpanFromEvent(
     storeTable: TaskEventStoreTable,
     event: PreparedEvent,
diff --git a/apps/webapp/app/v3/eventRepository/eventRepository.types.ts b/apps/webapp/app/v3/eventRepository/eventRepository.types.ts
index dcbdb07a3d0..0b45e536490 100644
--- a/apps/webapp/app/v3/eventRepository/eventRepository.types.ts
+++ b/apps/webapp/app/v3/eventRepository/eventRepository.types.ts
@@ -21,6 +21,33 @@ export type { ExceptionEventProperties };
 // Event Creation Types
 // ============================================================================
 
+export type LlmMetricsData = {
+  genAiSystem: string;
+  requestModel: string;
+  responseModel: string;
+  baseResponseModel: string;
+  matchedModelId: string;
+  operationId: string;
+  finishReason: string;
+  costSource: string;
+  pricingTierId: string;
+  pricingTierName: string;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  usageDetails: Record<string, number>;
+  inputCost: number;
+  outputCost: number;
+  totalCost: number;
+  costDetails: Record<string, number>;
+  providerCost: number;
+  msToFirstChunk: number;
+  tokensPerSecond: number;
+  metadata: Record<string, string>;
+  promptSlug: string;
+  promptVersion: number;
+};
+
 export type CreateEventInput = Omit<
   Prisma.TaskEventCreateInput,
   | "id"
@@ -56,6 +83,10 @@ export type CreateEventInput = Omit<
   resourceProperties?: Attributes;
   metadata: Attributes | undefined;
   style: Attributes | undefined;
+  machineId?: string;
+  runTags?: string[];
+  /** Side-channel data for LLM cost tracking, populated by enrichCreatableEvents */
+  _llmMetrics?: LlmMetricsData;
 };
 
 export type CreatableEventKind = TaskEventKind;
@@ -393,15 +424,6 @@ export interface IEventRepository {
     options?: { includeDebugLogs?: boolean }
   ): Promise<SpanDetail | undefined>;
 
-  getSpanOriginalRunId(
-    storeTable: TaskEventStoreTable,
-    environmentId: string,
-    spanId: string,
-    traceId: string,
-    startCreatedAt: Date,
-    endCreatedAt?: Date
-  ): Promise<string | undefined>;
-
   // Event recording methods
   recordEvent(
     message: string,
diff --git a/apps/webapp/app/v3/eventRepository/index.server.ts b/apps/webapp/app/v3/eventRepository/index.server.ts
index a8f66dab70c..70ea6440321 100644
--- a/apps/webapp/app/v3/eventRepository/index.server.ts
+++ b/apps/webapp/app/v3/eventRepository/index.server.ts
@@ -5,9 +5,10 @@ import {
   clickhouseEventRepositoryV2,
 } from "./clickhouseEventRepositoryInstance.server";
 import { IEventRepository, TraceEventOptions } from "./eventRepository.types";
-import { $replica, prisma } from "~/db.server";
+import { prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
-import { FEATURE_FLAG, flags } from "../featureFlags.server";
+import { FEATURE_FLAG } from "../featureFlags";
+import { flag } from "../featureFlags.server";
 import { getTaskEventStore } from "../taskEventStore.server";
 
 export function resolveEventRepositoryForStore(store: string | undefined): IEventRepository {
@@ -24,6 +25,50 @@ export function resolveEventRepositoryForStore(store: string | undefined): IEven
   return eventRepository;
 }
 
+export const EVENT_STORE_TYPES = {
+  POSTGRES: "postgres",
+  CLICKHOUSE: "clickhouse",
+  CLICKHOUSE_V2: "clickhouse_v2",
+} as const;
+
+export type EventStoreType = (typeof EVENT_STORE_TYPES)[keyof typeof EVENT_STORE_TYPES];
+
+export async function getConfiguredEventRepository(
+  organizationId: string
+): Promise<{ repository: IEventRepository; store: EventStoreType }> {
+  const organization = await prisma.organization.findFirst({
+    select: {
+      id: true,
+      featureFlags: true,
+    },
+    where: {
+      id: organizationId,
+    },
+  });
+
+  if (!organization) {
+    throw new Error("Organization not found when configuring event repository");
+  }
+
+  // resolveTaskEventRepositoryFlag checks:
+  // 1. organization.featureFlags (highest priority)
+  // 2. global feature flags (via flags() function)
+  // 3. env.EVENT_REPOSITORY_DEFAULT_STORE (fallback)
+  const taskEventStore = await resolveTaskEventRepositoryFlag(
+    (organization.featureFlags as Record<string, unknown> | null) ?? undefined
+  );
+
+  if (taskEventStore === EVENT_STORE_TYPES.CLICKHOUSE_V2) {
+    return { repository: clickhouseEventRepositoryV2, store: EVENT_STORE_TYPES.CLICKHOUSE_V2 };
+  }
+
+  if (taskEventStore === EVENT_STORE_TYPES.CLICKHOUSE) {
+    return { repository: clickhouseEventRepository, store: EVENT_STORE_TYPES.CLICKHOUSE };
+  }
+
+  return { repository: eventRepository, store: EVENT_STORE_TYPES.POSTGRES };
+}
+
 export async function getEventRepository(
   featureFlags: Record<string, unknown> | undefined,
   parentStore: string | undefined
@@ -78,35 +123,21 @@ export async function getV3EventRepository(
 async function resolveTaskEventRepositoryFlag(
   featureFlags: Record<string, unknown> | undefined
 ): Promise<"clickhouse" | "clickhouse_v2" | "postgres"> {
-  const flag = await flags({
+  const flagResult = await flag({
     key: FEATURE_FLAG.taskEventRepository,
     defaultValue: env.EVENT_REPOSITORY_DEFAULT_STORE,
     overrides: featureFlags,
   });
 
-  if (flag === "clickhouse_v2") {
+  if (flagResult === "clickhouse_v2") {
     return "clickhouse_v2";
   }
 
-  if (flag === "clickhouse") {
+  if (flagResult === "clickhouse") {
     return "clickhouse";
   }
 
-  if (env.EVENT_REPOSITORY_CLICKHOUSE_ROLLOUT_PERCENT) {
-    const rolloutPercent = env.EVENT_REPOSITORY_CLICKHOUSE_ROLLOUT_PERCENT;
-
-    const randomNumber = Math.random();
-
-    if (randomNumber < rolloutPercent) {
-      // Use the default store when rolling out (could be clickhouse or clickhouse_v2)
-      if (env.EVENT_REPOSITORY_DEFAULT_STORE === "clickhouse_v2") {
-        return "clickhouse_v2";
-      }
-      return "clickhouse";
-    }
-  }
-
-  return flag;
+  return flagResult;
 }
 
 export async function recordRunDebugLog(
diff --git a/apps/webapp/app/v3/eventRepository/originalRunIdCache.server.ts b/apps/webapp/app/v3/eventRepository/originalRunIdCache.server.ts
deleted file mode 100644
index caad8885ef9..00000000000
--- a/apps/webapp/app/v3/eventRepository/originalRunIdCache.server.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import {
-  createCache,
-  DefaultStatefulContext,
-  Namespace,
-  RedisCacheStore,
-  type UnkeyCache,
-} from "@internal/cache";
-import type { RedisOptions } from "@internal/redis";
-import { env } from "~/env.server";
-import { singleton } from "~/utils/singleton";
-
-export type OriginalRunIdCacheOptions = {
-  redisOptions: RedisOptions;
-};
-
-const ORIGINAL_RUN_ID_FRESH_TTL = 60000 * 60 * 24 * 30; // 30 days
-const ORIGINAL_RUN_ID_STALE_TTL = 60000 * 60 * 24 * 31; // 31 days
-
-export class OriginalRunIdCache {
-  private readonly cache: UnkeyCache<{
-    originalRunId: string;
-  }>;
-
-  constructor(options: OriginalRunIdCacheOptions) {
-    // Initialize cache
-    const ctx = new DefaultStatefulContext();
-    const redisCacheStore = new RedisCacheStore({
-      name: "original-run-id-cache",
-      connection: {
-        ...options.redisOptions,
-        keyPrefix: "original-run-id-cache:",
-      },
-      useModernCacheKeyBuilder: true,
-    });
-
-    this.cache = createCache({
-      originalRunId: new Namespace<string>(ctx, {
-        stores: [redisCacheStore],
-        fresh: ORIGINAL_RUN_ID_FRESH_TTL,
-        stale: ORIGINAL_RUN_ID_STALE_TTL,
-      }),
-    });
-  }
-
-  public async lookup(traceId: string, spanId: string) {
-    const result = await this.cache.originalRunId.get(`${traceId}:${spanId}`);
-
-    return result.val;
-  }
-
-  public async set(traceId: string, spanId: string, originalRunId: string) {
-    await this.cache.originalRunId.set(`${traceId}:${spanId}`, originalRunId);
-  }
-
-  public async swr(traceId: string, spanId: string, callback: () => Promise<string | undefined>) {
-    const result = await this.cache.originalRunId.swr(`${traceId}:${spanId}`, callback);
-
-    return result.val;
-  }
-}
-
-export const originalRunIdCache = singleton(
-  "originalRunIdCache",
-  () =>
-    new OriginalRunIdCache({
-      redisOptions: {
-        port: env.REDIS_PORT ?? undefined,
-        host: env.REDIS_HOST ?? undefined,
-        username: env.REDIS_USERNAME ?? undefined,
-        password: env.REDIS_PASSWORD ?? undefined,
-        enableAutoPipelining: true,
-        ...(env.REDIS_TLS_DISABLED === "true" ? {} : { tls: {} }),
-      },
-    })
-);
diff --git a/apps/webapp/app/v3/featureFlags.server.ts b/apps/webapp/app/v3/featureFlags.server.ts
index 6e00e7772ca..03353c914e6 100644
--- a/apps/webapp/app/v3/featureFlags.server.ts
+++ b/apps/webapp/app/v3/featureFlags.server.ts
@@ -1,19 +1,10 @@
-import { z } from "zod";
+import { type z } from "zod";
 import { prisma, type PrismaClientOrTransaction } from "~/db.server";
-
-export const FEATURE_FLAG = {
-  defaultWorkerInstanceGroupId: "defaultWorkerInstanceGroupId",
-  runsListRepository: "runsListRepository",
-  taskEventRepository: "taskEventRepository",
-} as const;
-
-const FeatureFlagCatalog = {
-  [FEATURE_FLAG.defaultWorkerInstanceGroupId]: z.string(),
-  [FEATURE_FLAG.runsListRepository]: z.enum(["clickhouse", "postgres"]),
-  [FEATURE_FLAG.taskEventRepository]: z.enum(["clickhouse", "clickhouse_v2", "postgres"]),
-};
-
-type FeatureFlagKey = keyof typeof FeatureFlagCatalog;
+import {
+  type FeatureFlagKey,
+  FeatureFlagCatalog,
+  FeatureFlagCatalogSchema,
+} from "~/v3/featureFlags";
 
 export type FlagsOptions<T extends FeatureFlagKey> = {
   key: T;
@@ -21,17 +12,17 @@ export type FlagsOptions<T extends FeatureFlagKey> = {
   overrides?: Record<string, unknown>;
 };
 
-export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
-  function flags<T extends FeatureFlagKey>(
+export function makeFlag(_prisma: PrismaClientOrTransaction = prisma) {
+  function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T> & { defaultValue: z.infer<(typeof FeatureFlagCatalog)[T]> }
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]>>;
-  function flags<T extends FeatureFlagKey>(
+  function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T>
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]> | undefined>;
-  async function flags<T extends FeatureFlagKey>(
+  async function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T>
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]> | undefined> {
-    const value = await _prisma.featureFlag.findUnique({
+    const value = await _prisma.featureFlag.findFirst({
       where: {
         key: opts.key,
       },
@@ -39,7 +30,7 @@ export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
 
     const flagSchema = FeatureFlagCatalog[opts.key];
 
-    if (opts.overrides?.[opts.key]) {
+    if (opts.overrides?.[opts.key] !== undefined) {
       const parsed = flagSchema.safeParse(opts.overrides[opts.key]);
 
       if (parsed.success) {
@@ -47,20 +38,22 @@ export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
       }
     }
 
-    const parsed = flagSchema.safeParse(value?.value);
+    if (value !== null) {
+      const parsed = flagSchema.safeParse(value.value);
 
-    if (!parsed.success) {
-      return opts.defaultValue;
+      if (parsed.success) {
+        return parsed.data;
+      }
     }
 
-    return parsed.data;
+    return opts.defaultValue;
   }
 
-  return flags;
+  return flag;
 }
 
-export function makeSetFlags(_prisma: PrismaClientOrTransaction = prisma) {
-  return async function setFlags<T extends FeatureFlagKey>(
+export function makeSetFlag(_prisma: PrismaClientOrTransaction = prisma) {
+  return async function setFlag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T> & { value: z.infer<(typeof FeatureFlagCatalog)[T]> }
   ): Promise<void> {
     await _prisma.featureFlag.upsert({
@@ -78,36 +71,66 @@ export function makeSetFlags(_prisma: PrismaClientOrTransaction = prisma) {
   };
 }
 
-export const flags = makeFlags();
-export const setFlags = makeSetFlags();
+export type AllFlagsOptions = {
+  defaultValues?: Partial<FeatureFlagCatalog>;
+  overrides?: Record<string, unknown>;
+};
 
-// Create a Zod schema from the existing catalog
-export const FeatureFlagCatalogSchema = z.object(FeatureFlagCatalog);
+export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
+  return async function flags(options?: AllFlagsOptions): Promise<Partial<FeatureFlagCatalog>> {
+    const rows = await _prisma.featureFlag.findMany();
 
-// Utility function to validate a feature flag value
-export function validateFeatureFlagValue<T extends FeatureFlagKey>(
-  key: T,
-  value: unknown
-): z.SafeParseReturnType<unknown, z.infer<(typeof FeatureFlagCatalog)[T]>> {
-  return FeatureFlagCatalog[key].safeParse(value);
-}
+    // Build a map of key -> value from database
+    const dbValues = new Map<string, unknown>();
+    for (const row of rows) {
+      dbValues.set(row.key, row.value);
+    }
 
-// Utility function to validate all feature flags at once
-export function validateAllFeatureFlags(values: Record<string, unknown>) {
-  return FeatureFlagCatalogSchema.safeParse(values);
-}
+    const result: Partial<FeatureFlagCatalog> = {};
+
+    // Process each flag in the catalog
+    for (const key of Object.keys(FeatureFlagCatalog) as FeatureFlagKey[]) {
+      const schema = FeatureFlagCatalog[key];
+
+      // Priority: overrides > database > defaultValues
+      if (options?.overrides?.[key] !== undefined) {
+        const parsed = schema.safeParse(options.overrides[key]);
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+          continue;
+        }
+      }
+
+      if (dbValues.has(key)) {
+        const parsed = schema.safeParse(dbValues.get(key));
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+          continue;
+        }
+      }
 
-// Utility function to validate partial feature flags (all keys optional)
-export function validatePartialFeatureFlags(values: Record<string, unknown>) {
-  return FeatureFlagCatalogSchema.partial().safeParse(values);
+      if (options?.defaultValues?.[key] !== undefined) {
+        const parsed = schema.safeParse(options.defaultValues[key]);
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+        }
+      }
+    }
+
+    return result;
+  };
 }
 
+export const flag = makeFlag();
+export const flags = makeFlags();
+export const setFlag = makeSetFlag();
+
 // Utility function to set multiple feature flags at once
 export function makeSetMultipleFlags(_prisma: PrismaClientOrTransaction = prisma) {
   return async function setMultipleFlags(
     flags: Partial<z.infer<typeof FeatureFlagCatalogSchema>>
   ): Promise<{ key: string; value: any }[]> {
-    const setFlag = makeSetFlags(_prisma);
+    const setFlag = makeSetFlag(_prisma);
     const updatedFlags: { key: string; value: any }[] = [];
 
     for (const [key, value] of Object.entries(flags)) {
diff --git a/apps/webapp/app/v3/featureFlags.ts b/apps/webapp/app/v3/featureFlags.ts
new file mode 100644
index 00000000000..b40a83c3a35
--- /dev/null
+++ b/apps/webapp/app/v3/featureFlags.ts
@@ -0,0 +1,87 @@
+import { z } from "zod";
+
+export const FEATURE_FLAG = {
+  defaultWorkerInstanceGroupId: "defaultWorkerInstanceGroupId",
+  taskEventRepository: "taskEventRepository",
+  hasQueryAccess: "hasQueryAccess",
+  hasLogsPageAccess: "hasLogsPageAccess",
+  hasAiAccess: "hasAiAccess",
+  hasComputeAccess: "hasComputeAccess",
+  hasPrivateConnections: "hasPrivateConnections",
+} as const;
+
+export const FeatureFlagCatalog = {
+  [FEATURE_FLAG.defaultWorkerInstanceGroupId]: z.string(),
+  [FEATURE_FLAG.taskEventRepository]: z.enum(["clickhouse", "clickhouse_v2", "postgres"]),
+  [FEATURE_FLAG.hasQueryAccess]: z.coerce.boolean(),
+  [FEATURE_FLAG.hasLogsPageAccess]: z.coerce.boolean(),
+  [FEATURE_FLAG.hasAiAccess]: z.coerce.boolean(),
+  [FEATURE_FLAG.hasComputeAccess]: z.coerce.boolean(),
+  [FEATURE_FLAG.hasPrivateConnections]: z.coerce.boolean(),
+};
+
+export type FeatureFlagKey = keyof typeof FeatureFlagCatalog;
+
+// Infrastructure flags that are read-only on the global flags page.
+// Shown with current/resolved value but no controls.
+export const GLOBAL_LOCKED_FLAGS: FeatureFlagKey[] = [
+  FEATURE_FLAG.defaultWorkerInstanceGroupId,
+  FEATURE_FLAG.taskEventRepository,
+];
+
+// Flags that are read-only on the org-level dialog.
+// Shown with global value but no controls (org can't override these).
+export const ORG_LOCKED_FLAGS: FeatureFlagKey[] = [
+  FEATURE_FLAG.defaultWorkerInstanceGroupId,
+  FEATURE_FLAG.taskEventRepository,
+];
+
+// Create a Zod schema from the existing catalog
+export const FeatureFlagCatalogSchema = z.object(FeatureFlagCatalog);
+export type FeatureFlagCatalog = z.infer<typeof FeatureFlagCatalogSchema>;
+
+// Utility function to validate a feature flag value
+export function validateFeatureFlagValue<T extends FeatureFlagKey>(
+  key: T,
+  value: unknown
+): z.SafeParseReturnType<unknown, z.infer<(typeof FeatureFlagCatalog)[T]>> {
+  return FeatureFlagCatalog[key].safeParse(value);
+}
+
+// Utility function to validate all feature flags at once
+export function validateAllFeatureFlags(values: Record<string, unknown>) {
+  return FeatureFlagCatalogSchema.safeParse(values);
+}
+
+// Utility function to validate partial feature flags (all keys optional)
+export function validatePartialFeatureFlags(values: Record<string, unknown>) {
+  return FeatureFlagCatalogSchema.partial().safeParse(values);
+}
+
+// Utility types for catalog-driven UI rendering
+export type FlagControlType =
+  | { type: "boolean" }
+  | { type: "enum"; options: string[] }
+  | { type: "string" };
+
+export function getFlagControlType(schema: z.ZodTypeAny): FlagControlType {
+  const typeName = schema._def.typeName;
+
+  if (typeName === "ZodBoolean") {
+    return { type: "boolean" };
+  }
+
+  if (typeName === "ZodEnum") {
+    return { type: "enum", options: schema._def.values as string[] };
+  }
+
+  return { type: "string" };
+}
+
+export function getAllFlagControlTypes(): Record<string, FlagControlType> {
+  const result: Record<string, FlagControlType> = {};
+  for (const [key, schema] of Object.entries(FeatureFlagCatalog)) {
+    result[key] = getFlagControlType(schema);
+  }
+  return result;
+}
diff --git a/apps/webapp/app/v3/legacyRunEngineWorker.server.ts b/apps/webapp/app/v3/legacyRunEngineWorker.server.ts
index 09fdbf886cf..7a381063bdc 100644
--- a/apps/webapp/app/v3/legacyRunEngineWorker.server.ts
+++ b/apps/webapp/app/v3/legacyRunEngineWorker.server.ts
@@ -5,7 +5,10 @@ import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
 import { singleton } from "~/utils/singleton";
 import { TaskRunHeartbeatFailedService } from "./taskRunHeartbeatFailed.server";
-import { completeBatchTaskRunItemV3 } from "./services/batchTriggerV3.server";
+import {
+  completeBatchTaskRunItemV3,
+  tryCompleteBatchV3,
+} from "./services/batchTriggerV3.server";
 import { prisma } from "~/db.server";
 import { marqs } from "./marqs/index.server";
 
@@ -50,6 +53,16 @@ function initializeWorker() {
           maxAttempts: 10,
         },
       },
+      tryCompleteBatchV3: {
+        schema: z.object({
+          batchId: z.string(),
+          scheduleResumeOnComplete: z.boolean(),
+        }),
+        visibilityTimeoutMs: 30_000,
+        retry: {
+          maxAttempts: 5,
+        },
+      },
       scheduleRequeueMessage: {
         schema: z.object({
           messageId: z.string(),
@@ -85,6 +98,9 @@ function initializeWorker() {
           attempt
         );
       },
+      tryCompleteBatchV3: async ({ payload }) => {
+        await tryCompleteBatchV3(payload.batchId, prisma, payload.scheduleResumeOnComplete);
+      },
       scheduleRequeueMessage: async ({ payload }) => {
         await marqs.requeueMessageById(payload.messageId);
       },
diff --git a/apps/webapp/app/v3/llmPricingRegistry.server.ts b/apps/webapp/app/v3/llmPricingRegistry.server.ts
new file mode 100644
index 00000000000..2212c41779d
--- /dev/null
+++ b/apps/webapp/app/v3/llmPricingRegistry.server.ts
@@ -0,0 +1,62 @@
+import { ModelPricingRegistry, seedLlmPricing } from "@internal/llm-model-catalog";
+import { prisma, $replica } from "~/db.server";
+import { env } from "~/env.server";
+import { signalsEmitter } from "~/services/signals.server";
+import { singleton } from "~/utils/singleton";
+import { setLlmPricingRegistry } from "./utils/enrichCreatableEvents.server";
+
+async function initRegistry(registry: ModelPricingRegistry) {
+  if (env.LLM_PRICING_SEED_ON_STARTUP) {
+    await seedLlmPricing(prisma);
+  }
+
+  await registry.loadFromDatabase();
+}
+
+export const llmPricingRegistry = singleton("llmPricingRegistry", () => {
+  if (!env.LLM_COST_TRACKING_ENABLED) {
+    return null;
+  }
+
+  const registry = new ModelPricingRegistry($replica);
+
+  // Wire up the registry so enrichCreatableEvents can use it
+  setLlmPricingRegistry(registry);
+
+  initRegistry(registry).catch((err) => {
+    console.error("Failed to initialize LLM pricing registry", err);
+  });
+
+  // Periodic reload
+  const reloadInterval = env.LLM_PRICING_RELOAD_INTERVAL_MS;
+  const interval = setInterval(() => {
+    registry.reload().catch((err) => {
+      console.error("Failed to reload LLM pricing registry", err);
+    });
+  }, reloadInterval);
+
+  signalsEmitter.on("SIGTERM", () => {
+    clearInterval(interval);
+  });
+  signalsEmitter.on("SIGINT", () => {
+    clearInterval(interval);
+  });
+
+  return registry;
+});
+
+/**
+ * Wait for the LLM pricing registry to finish its initial load, with a timeout.
+ * After the first call resolves (or times out), subsequent calls are no-ops.
+ */
+export async function waitForLlmPricingReady(): Promise<void> {
+  if (!llmPricingRegistry || llmPricingRegistry.isLoaded) return;
+
+  const timeoutMs = env.LLM_PRICING_READY_TIMEOUT_MS;
+  if (timeoutMs <= 0) return;
+
+  await Promise.race([
+    llmPricingRegistry.isReady,
+    new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),
+  ]);
+}
diff --git a/apps/webapp/app/v3/marqs/fairDequeuingStrategy.server.ts b/apps/webapp/app/v3/marqs/fairDequeuingStrategy.server.ts
index cbae7e84683..e9205cd000e 100644
--- a/apps/webapp/app/v3/marqs/fairDequeuingStrategy.server.ts
+++ b/apps/webapp/app/v3/marqs/fairDequeuingStrategy.server.ts
@@ -1,5 +1,5 @@
 import { createCache, DefaultStatefulContext, Namespace, Cache as UnkeyCache } from "@unkey/cache";
-import { MemoryStore } from "@unkey/cache/stores";
+import { createLRUMemoryStore } from "@internal/cache";
 import { randomUUID } from "crypto";
 import { Redis } from "ioredis";
 import { EnvQueues, MarQSFairDequeueStrategy, MarQSKeyProducer } from "./types";
@@ -99,13 +99,7 @@ export class FairDequeuingStrategy implements MarQSFairDequeueStrategy {
 
   constructor(private options: FairDequeuingStrategyOptions) {
     const ctx = new DefaultStatefulContext();
-    const memory = new MemoryStore({
-      persistentMap: new Map(),
-      unstableEvictOnSet: {
-        frequency: 0.01,
-        maxItems: 500,
-      },
-    });
+    const memory = createLRUMemoryStore(500);
 
     this._cache = createCache({
       concurrencyLimit: new Namespace<number>(ctx, {
diff --git a/apps/webapp/app/v3/models/workerDeployment.server.ts b/apps/webapp/app/v3/models/workerDeployment.server.ts
index 66e1024eb85..4af4bdd2157 100644
--- a/apps/webapp/app/v3/models/workerDeployment.server.ts
+++ b/apps/webapp/app/v3/models/workerDeployment.server.ts
@@ -55,6 +55,8 @@ type WorkerDeploymentWithWorkerTasks = Prisma.WorkerDeploymentGetPayload<{
             maxDurationInSeconds: true;
             queueConfig: true;
             queueId: true;
+            payloadSchema: true;
+            fileId: true;
           };
         };
       };
diff --git a/apps/webapp/app/v3/objectStore.server.ts b/apps/webapp/app/v3/objectStore.server.ts
new file mode 100644
index 00000000000..bd85fb905fa
--- /dev/null
+++ b/apps/webapp/app/v3/objectStore.server.ts
@@ -0,0 +1,317 @@
+import { type IOPacket } from "@trigger.dev/core/v3";
+import { env } from "~/env.server";
+import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { logger } from "~/services/logger.server";
+import { singleton } from "~/utils/singleton";
+import { ObjectStoreClient, type ObjectStoreClientConfig } from "./objectStoreClient.server";
+
+/**
+ * Parsed storage URI with optional protocol prefix
+ * @example { protocol: "s3", path: "run_abc/payload.json" }
+ * @example { protocol: undefined, path: "batch_123/item_0/payload.json" } // legacy, uses default
+ */
+export type ParsedStorageUri = {
+  protocol?: string;
+  path: string;
+};
+
+/**
+ * Parse a storage URI into protocol and path components
+ * @param uri Storage URI, optionally prefixed with protocol (e.g., "s3://path" or "path")
+ * @returns Parsed components { protocol?, path }
+ */
+export function parseStorageUri(uri: string): ParsedStorageUri {
+  const match = uri.match(/^([a-z0-9]+):\/\/(.+)$/);
+  if (match) {
+    return {
+      protocol: match[1],
+      path: match[2],
+    };
+  }
+  return {
+    protocol: undefined,
+    path: uri,
+  };
+}
+
+/**
+ * Format a storage URI with optional protocol prefix
+ * @param path Storage path
+ * @param protocol Optional protocol to prefix (e.g., "s3", "r2")
+ * @returns Formatted URI (e.g., "s3://path" or "path")
+ */
+export function formatStorageUri(path: string, protocol?: string): string {
+  if (protocol) {
+    return `${protocol}://${path}`;
+  }
+  return path;
+}
+
+/**
+ * Get object storage configuration for a given protocol.
+ * Returns a config if baseUrl is set, even without explicit credentials —
+ * in that case the AWS credential chain (ECS task role, EC2 IMDS, etc.) is used,
+ * and OBJECT_STORE_BUCKET must also be set.
+ */
+function getObjectStoreConfig(protocol?: string): ObjectStoreClientConfig | undefined {
+  if (protocol) {
+    // Named provider (e.g., OBJECT_STORE_S3_*)
+    const prefix = `OBJECT_STORE_${protocol.toUpperCase()}_`;
+    const baseUrl = process.env[`${prefix}BASE_URL`];
+    if (!baseUrl) return undefined;
+
+    return {
+      baseUrl,
+      bucket: process.env[`${prefix}BUCKET`] || undefined,
+      accessKeyId: process.env[`${prefix}ACCESS_KEY_ID`] || undefined,
+      secretAccessKey: process.env[`${prefix}SECRET_ACCESS_KEY`] || undefined,
+      region: process.env[`${prefix}REGION`] || undefined,
+      service: process.env[`${prefix}SERVICE`] || undefined,
+    };
+  }
+
+  // Default provider (backward compatible)
+  if (!env.OBJECT_STORE_BASE_URL) {
+    return undefined;
+  }
+
+  return {
+    baseUrl: env.OBJECT_STORE_BASE_URL,
+    bucket: env.OBJECT_STORE_BUCKET || undefined,
+    accessKeyId: env.OBJECT_STORE_ACCESS_KEY_ID || undefined,
+    secretAccessKey: env.OBJECT_STORE_SECRET_ACCESS_KEY || undefined,
+    region: env.OBJECT_STORE_REGION || undefined,
+    service: env.OBJECT_STORE_SERVICE || undefined,
+  };
+}
+
+/**
+ * Object storage client registry. Maps protocol name to ObjectStoreClient singleton.
+ * ObjectStoreClient internally uses either aws4fetch (static credentials) or the
+ * AWS SDK S3Client (IAM credential chain), selected at creation time.
+ */
+const objectStoreClients = singleton(
+  "objectStoreClients",
+  () => new Map<string, ObjectStoreClient>()
+);
+
+function getObjectStoreClient(protocol?: string): ObjectStoreClient | undefined {
+  const config = getObjectStoreConfig(protocol);
+  if (!config) return undefined;
+
+  // Key includes baseUrl so that config changes (e.g. different containers in tests)
+  // always produce a fresh client while production usage (stable env) is effectively
+  // a per-protocol singleton.
+  const cacheKey = `${protocol ?? "default"}:${config.baseUrl}`;
+  if (objectStoreClients.has(cacheKey)) {
+    return objectStoreClients.get(cacheKey);
+  }
+
+  const client = ObjectStoreClient.create(config);
+  objectStoreClients.set(cacheKey, client);
+  return client;
+}
+
+export function hasObjectStoreClient(): boolean {
+  const defaultConfig = getObjectStoreConfig();
+  const protocolConfig = env.OBJECT_STORE_DEFAULT_PROTOCOL
+    ? getObjectStoreConfig(env.OBJECT_STORE_DEFAULT_PROTOCOL)
+    : undefined;
+  return !!(defaultConfig || protocolConfig);
+}
+
+export async function uploadPacketToObjectStore(
+  filename: string,
+  data: ReadableStream | string,
+  contentType: string,
+  environment: AuthenticatedEnvironment,
+  storageProtocol?: string
+): Promise<string> {
+  const protocol = storageProtocol || env.OBJECT_STORE_DEFAULT_PROTOCOL;
+  const client = getObjectStoreClient(protocol);
+
+  if (!client) {
+    throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
+  }
+
+  const key = `packets/${environment.project.externalRef}/${environment.slug}/${filename}`;
+
+  logger.debug("Uploading to object store", { key, protocol: protocol || "default" });
+
+  await client.putObject(key, data, contentType);
+
+  // Return filename with protocol prefix if specified
+  return formatStorageUri(filename, protocol);
+}
+
+export async function downloadPacketFromObjectStore(
+  packet: IOPacket,
+  environment: AuthenticatedEnvironment
+): Promise<IOPacket> {
+  if (packet.dataType !== "application/store") {
+    return packet;
+  }
+
+  // There shouldn't be an offloaded packet with undefined data…
+  if (!packet.data) {
+    logger.error("Object store packet has undefined data", { packet, environment });
+    return {
+      dataType: "application/json",
+      data: undefined,
+    };
+  }
+
+  const { protocol, path } = parseStorageUri(packet.data);
+  const client = getObjectStoreClient(protocol);
+
+  if (!client) {
+    throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
+  }
+
+  const key = `packets/${environment.project.externalRef}/${environment.slug}/${path}`;
+
+  logger.debug("Downloading from object store", { key, protocol: protocol || "default" });
+
+  const data = await client.getObject(key);
+
+  return { data, dataType: "application/json" };
+}
+
+export type GeneratePacketPresignOptions = {
+  /**
+   * When true (v1 packet PUT only), unprefixed keys use the legacy default object store only.
+   * When false/omitted (v2 packet PUT), unprefixed keys also use OBJECT_STORE_DEFAULT_PROTOCOL.
+   * Ignored for GET — reads never infer protocol from env for unprefixed keys.
+   */
+  forceNoPrefix?: boolean;
+};
+
+/**
+ * Resolve object-store protocol for packet presigns.
+ * GET: never apply OBJECT_STORE_DEFAULT_PROTOCOL to unprefixed keys.
+ * PUT: optional forceNoPrefix for v1 legacy upload behavior.
+ */
+export function resolveStoreProtocolForPacketPresign(
+  filename: string,
+  method: "PUT" | "GET",
+  forceNoPrefix?: boolean
+): { path: string; storeProtocol: string | undefined } {
+  const { protocol: explicitProtocol, path } = parseStorageUri(filename);
+
+  if (method === "GET") {
+    return { path, storeProtocol: explicitProtocol };
+  }
+
+  if (explicitProtocol !== undefined) {
+    return { path, storeProtocol: explicitProtocol };
+  }
+
+  if (forceNoPrefix) {
+    return { path, storeProtocol: undefined };
+  }
+
+  return { path, storeProtocol: env.OBJECT_STORE_DEFAULT_PROTOCOL };
+}
+
+export async function generatePresignedRequest(
+  projectRef: string,
+  envSlug: string,
+  filename: string,
+  method: "PUT" | "GET" = "PUT",
+  options?: GeneratePacketPresignOptions
+): Promise<
+  | {
+      success: false;
+      error: string;
+    }
+  | {
+      success: true;
+      request: Request;
+      /** Canonical pointer for IOPacket.data (PUT only). */
+      storagePath?: string;
+    }
+> {
+  const { path, storeProtocol } = resolveStoreProtocolForPacketPresign(
+    filename,
+    method,
+    options?.forceNoPrefix
+  );
+
+  const config = getObjectStoreConfig(storeProtocol);
+  if (!config?.baseUrl) {
+    return {
+      success: false,
+      error: `Object store is not configured for protocol: ${storeProtocol || "default"}`,
+    };
+  }
+
+  const client = getObjectStoreClient(storeProtocol);
+  if (!client) {
+    return {
+      success: false,
+      error: `Object store is not configured for protocol: ${storeProtocol || "default"}`,
+    };
+  }
+
+  const key = `packets/${projectRef}/${envSlug}/${path}`;
+
+  try {
+    const url = await client.presign(key, method, 300); // 5 minutes
+
+    logger.debug("Generated presigned URL", {
+      url,
+      projectRef,
+      envSlug,
+      filename,
+      protocol: storeProtocol || "default",
+    });
+
+    const storagePath = method === "PUT" ? formatStorageUri(path, storeProtocol) : undefined;
+
+    return {
+      success: true,
+      request: new Request(url, { method }),
+      storagePath,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to generate presigned URL: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    };
+  }
+}
+
+export async function generatePresignedUrl(
+  projectRef: string,
+  envSlug: string,
+  filename: string,
+  method: "PUT" | "GET" = "PUT",
+  options?: GeneratePacketPresignOptions
+): Promise<
+  | {
+      success: false;
+      error: string;
+    }
+  | {
+      success: true;
+      url: string;
+      storagePath?: string;
+    }
+> {
+  const signed = await generatePresignedRequest(projectRef, envSlug, filename, method, options);
+
+  if (!signed.success) {
+    return {
+      success: false,
+      error: signed.error,
+    };
+  }
+
+  return {
+    success: true,
+    url: signed.request.url,
+    storagePath: signed.storagePath,
+  };
+}
diff --git a/apps/webapp/app/v3/objectStoreClient.server.ts b/apps/webapp/app/v3/objectStoreClient.server.ts
new file mode 100644
index 00000000000..d7a85924220
--- /dev/null
+++ b/apps/webapp/app/v3/objectStoreClient.server.ts
@@ -0,0 +1,200 @@
+import { AwsClient } from "aws4fetch";
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+interface IObjectStoreClient {
+  putObject(key: string, body: ReadableStream | string, contentType: string): Promise<string>;
+  getObject(key: string): Promise<string>;
+  presign(key: string, method: "PUT" | "GET", expiresIn: number): Promise<string>;
+}
+
+type Aws4FetchConfig = {
+  baseUrl: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  region?: string;
+  service?: string;
+};
+
+class Aws4FetchClient implements IObjectStoreClient {
+  private readonly awsClient: AwsClient;
+
+  constructor(private readonly config: Aws4FetchConfig) {
+    this.awsClient = new AwsClient({
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey,
+      region: config.region,
+      // We set the default value to "s3" in the schema to enhance interoperability with various
+      // S3-compatible services. Setting this env var to an empty string restores the old behaviour.
+      service: config.service || undefined,
+    });
+  }
+
+  private buildUrl(key: string): string {
+    const url = new URL(this.config.baseUrl);
+    url.pathname = `/${key}`;
+    return url.toString();
+  }
+
+  async putObject(key: string, body: ReadableStream | string, contentType: string): Promise<string> {
+    const objectUrl = this.buildUrl(key);
+    const response = await this.awsClient.fetch(objectUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body,
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to upload to object store: ${response.statusText}`);
+    }
+    return objectUrl;
+  }
+
+  async getObject(key: string): Promise<string> {
+    const response = await this.awsClient.fetch(this.buildUrl(key));
+    if (!response.ok) {
+      throw new Error(`Failed to download from object store: ${response.statusText}`);
+    }
+    return response.text();
+  }
+
+  async presign(key: string, method: "PUT" | "GET", expiresIn: number): Promise<string> {
+    const url = new URL(this.config.baseUrl);
+    url.pathname = `/${key}`;
+    url.searchParams.set("X-Amz-Expires", String(expiresIn));
+
+    const signed = await this.awsClient.sign(new Request(url, { method }), {
+      aws: { signQuery: true },
+    });
+    return signed.url;
+  }
+}
+
+type AwsSdkConfig = {
+  bucket: string;
+  baseUrl: string;
+  region?: string;
+};
+
+class AwsSdkClient implements IObjectStoreClient {
+  private readonly s3Client: S3Client;
+
+  constructor(private readonly config: AwsSdkConfig) {
+    this.s3Client = new S3Client({
+      endpoint: config.baseUrl,
+      forcePathStyle: true,
+      ...(config.region ? { region: config.region } : {}),
+    });
+  }
+
+  /**
+   * Callers use a single logical key (same as aws4fetch path: `bucket/object/...`).
+   * S3 APIs take Bucket + Key where Key must not repeat the bucket name.
+   */
+  private toS3ObjectKey(logicalKey: string): string {
+    const prefix = `${this.config.bucket}/`;
+    if (logicalKey.startsWith(prefix)) {
+      return logicalKey.slice(prefix.length);
+    }
+    return logicalKey;
+  }
+
+  private logicalObjectUrl(logicalKey: string): string {
+    const url = new URL(this.config.baseUrl);
+    url.pathname = `/${logicalKey}`;
+    return url.href;
+  }
+
+  async putObject(key: string, body: ReadableStream | string, contentType: string): Promise<string> {
+    const s3Key = this.toS3ObjectKey(key);
+    await this.s3Client.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: s3Key,
+        Body: body,
+        ContentType: contentType,
+      })
+    );
+    return this.logicalObjectUrl(key);
+  }
+
+  async getObject(key: string): Promise<string> {
+    const s3Key = this.toS3ObjectKey(key);
+    const response = await this.s3Client.send(
+      new GetObjectCommand({ Bucket: this.config.bucket, Key: s3Key })
+    );
+    if (!response.Body) {
+      throw new Error(`Empty response body from object store for key: ${key}`);
+    }
+    return response.Body.transformToString();
+  }
+
+  async presign(key: string, method: "PUT" | "GET", expiresIn: number): Promise<string> {
+    const s3Key = this.toS3ObjectKey(key);
+    const command =
+      method === "PUT"
+        ? new PutObjectCommand({ Bucket: this.config.bucket, Key: s3Key })
+        : new GetObjectCommand({ Bucket: this.config.bucket, Key: s3Key });
+
+    return getSignedUrl(this.s3Client, command, { expiresIn });
+  }
+}
+
+export type ObjectStoreClientConfig = {
+  baseUrl: string;
+  bucket?: string;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  region?: string;
+  service?: string;
+};
+
+export class ObjectStoreClient implements IObjectStoreClient {
+  private constructor(
+    private readonly impl: IObjectStoreClient,
+    /** When set, logical keys may start with `${bucket}/…`; AwsSdkClient strips that prefix for S3 APIs. */
+    readonly bucket: string | undefined
+  ) {}
+
+  static create(config: ObjectStoreClientConfig): ObjectStoreClient {
+    if (config.accessKeyId && config.secretAccessKey) {
+      return new ObjectStoreClient(
+        new Aws4FetchClient({
+          baseUrl: config.baseUrl,
+          accessKeyId: config.accessKeyId,
+          secretAccessKey: config.secretAccessKey,
+          region: config.region,
+          service: config.service,
+        }),
+        config.bucket
+      );
+    }
+
+    // IAM credential chain — AWS SDK S3Client handles credential refresh automatically
+    if (!config.bucket) {
+      throw new Error(
+        "OBJECT_STORE_BUCKET is required when not using access key credentials (IAM mode)"
+      );
+    }
+
+    return new ObjectStoreClient(
+      new AwsSdkClient({
+        bucket: config.bucket,
+        baseUrl: config.baseUrl,
+        region: config.region,
+      }),
+      config.bucket
+    );
+  }
+
+  putObject(key: string, body: ReadableStream | string, contentType: string): Promise<string> {
+    return this.impl.putObject(key, body, contentType);
+  }
+
+  getObject(key: string): Promise<string> {
+    return this.impl.getObject(key);
+  }
+
+  presign(key: string, method: "PUT" | "GET", expiresIn: number): Promise<string> {
+    return this.impl.presign(key, method, expiresIn);
+  }
+}
diff --git a/apps/webapp/app/v3/otlpExporter.server.ts b/apps/webapp/app/v3/otlpExporter.server.ts
index f7337b3b167..7505693e3ab 100644
--- a/apps/webapp/app/v3/otlpExporter.server.ts
+++ b/apps/webapp/app/v3/otlpExporter.server.ts
@@ -4,10 +4,13 @@ import {
   AnyValue,
   ExportLogsServiceRequest,
   ExportLogsServiceResponse,
+  ExportMetricsServiceRequest,
+  ExportMetricsServiceResponse,
   ExportTraceServiceRequest,
   ExportTraceServiceResponse,
   KeyValue,
   ResourceLogs,
+  ResourceMetrics,
   ResourceSpans,
   SeverityNumber,
   Span,
@@ -15,7 +18,10 @@ import {
   Span_SpanKind,
   Status_StatusCode,
 } from "@trigger.dev/otlp-importer";
+import type { MetricsV1Input } from "@internal/clickhouse";
 import { logger } from "~/services/logger.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { DynamicFlushScheduler } from "./dynamicFlushScheduler.server";
 import { ClickhouseEventRepository } from "./eventRepository/clickhouseEventRepository.server";
 import {
   clickhouseEventRepository,
@@ -31,6 +37,7 @@ import type {
 } from "./eventRepository/eventRepository.types";
 import { startSpan } from "./tracing.server";
 import { enrichCreatableEvents } from "./utils/enrichCreatableEvents.server";
+import { waitForLlmPricingReady } from "./llmPricingRegistry.server";
 import { env } from "~/env.server";
 import { detectBadJsonStrings } from "~/utils/detectBadJsonStrings";
 import { singleton } from "~/utils/singleton";
@@ -42,6 +49,7 @@ class OTLPExporter {
     private readonly _eventRepository: EventRepository,
     private readonly _clickhouseEventRepository: ClickhouseEventRepository,
     private readonly _clickhouseEventRepositoryV2: ClickhouseEventRepository,
+    private readonly _metricsFlushScheduler: DynamicFlushScheduler<MetricsV1Input>,
     private readonly _verbose: boolean,
     private readonly _spanAttributeValueLengthLimit: number
   ) {
@@ -66,6 +74,29 @@ class OTLPExporter {
     });
   }
 
+  async exportMetrics(
+    request: ExportMetricsServiceRequest
+  ): Promise<ExportMetricsServiceResponse> {
+    return await startSpan(this._tracer, "exportMetrics", async (span) => {
+      const rows = this.#filterResourceMetrics(request.resourceMetrics).flatMap(
+        (resourceMetrics) => {
+          return convertMetricsToClickhouseRows(
+            resourceMetrics,
+            this._spanAttributeValueLengthLimit
+          );
+        }
+      );
+
+      span.setAttribute("metric_row_count", rows.length);
+
+      if (rows.length > 0) {
+        this._metricsFlushScheduler.addToBatch(rows);
+      }
+
+      return ExportMetricsServiceResponse.create();
+    });
+  }
+
   async exportLogs(request: ExportLogsServiceRequest): Promise<ExportLogsServiceResponse> {
     return await startSpan(this._tracer, "exportLogs", async (span) => {
       this.#logExportLogsVerbose(request);
@@ -98,6 +129,7 @@ class OTLPExporter {
     for (const [store, events] of Object.entries(eventsGroupedByStore)) {
       const eventRepository = this.#getEventRepositoryForStore(store);
 
+      await waitForLlmPricingReady();
       const enrichedEvents = enrichCreatableEvents(events);
 
       this.#logEventsVerbose(enrichedEvents, `exportEvents ${store}`);
@@ -202,6 +234,18 @@ class OTLPExporter {
       return isBoolValue(attribute.value) ? attribute.value.boolValue : false;
     });
   }
+
+  #filterResourceMetrics(resourceMetrics: ResourceMetrics[]): ResourceMetrics[] {
+    return resourceMetrics.filter((rm) => {
+      const triggerAttribute = rm.resource?.attributes.find(
+        (attribute) => attribute.key === SemanticInternalAttributes.TRIGGER
+      );
+
+      if (!triggerAttribute) return false;
+
+      return isBoolValue(triggerAttribute.value) ? triggerAttribute.value.boolValue : false;
+    });
+  }
 }
 
 function convertLogsToCreateableEvents(
@@ -289,6 +333,7 @@ function convertLogsToCreateableEvents(
           projectId: logProperties.projectId ?? resourceProperties.projectId ?? "unknown",
           runId: logProperties.runId ?? resourceProperties.runId ?? "unknown",
           taskSlug: logProperties.taskSlug ?? resourceProperties.taskSlug ?? "unknown",
+          machineId: logProperties.machineId ?? resourceProperties.machineId,
           attemptNumber:
             extractNumberAttribute(
               log.attributes ?? [],
@@ -348,6 +393,8 @@ function convertSpansToCreateableEvents(
           SemanticInternalAttributes.METADATA
         );
 
+        const runTags = extractArrayAttribute(span.attributes ?? [], SemanticInternalAttributes.RUN_TAGS);
+
         const properties =
           truncateAttributes(
             convertKeyValueItemsToMap(span.attributes ?? [], [], undefined, [
@@ -395,6 +442,8 @@ function convertSpansToCreateableEvents(
           projectId: spanProperties.projectId ?? resourceProperties.projectId ?? "unknown",
           runId: spanProperties.runId ?? resourceProperties.runId ?? "unknown",
           taskSlug: spanProperties.taskSlug ?? resourceProperties.taskSlug ?? "unknown",
+          machineId: spanProperties.machineId ?? resourceProperties.machineId,
+          runTags,
           attemptNumber:
             extractNumberAttribute(
               span.attributes ?? [],
@@ -410,6 +459,194 @@ function convertSpansToCreateableEvents(
   return { events, taskEventStore };
 }
 
+function floorToTenSecondBucket(timeUnixNano: bigint | number): string {
+  const epochMs = Number(BigInt(timeUnixNano) / BigInt(1_000_000));
+  const flooredMs = Math.floor(epochMs / 10_000) * 10_000;
+  const date = new Date(flooredMs);
+  // Format as ClickHouse DateTime: YYYY-MM-DD HH:MM:SS
+  return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+}
+
+function convertMetricsToClickhouseRows(
+  resourceMetrics: ResourceMetrics,
+  spanAttributeValueLengthLimit: number
+): MetricsV1Input[] {
+  const resourceAttributes = resourceMetrics.resource?.attributes ?? [];
+  const resourceProperties = extractEventProperties(resourceAttributes);
+
+  const organizationId = resourceProperties.organizationId ?? "unknown";
+  const projectId = resourceProperties.projectId ?? "unknown";
+  const environmentId = resourceProperties.environmentId ?? "unknown";
+  const resourceCtx = {
+    taskSlug: resourceProperties.taskSlug,
+    runId: resourceProperties.runId,
+    attemptNumber: resourceProperties.attemptNumber,
+    machineId: extractStringAttribute(resourceAttributes, SemanticInternalAttributes.MACHINE_ID),
+    workerId: extractStringAttribute(resourceAttributes, SemanticInternalAttributes.WORKER_ID),
+    workerVersion: extractStringAttribute(
+      resourceAttributes,
+      SemanticInternalAttributes.WORKER_VERSION
+    ),
+  };
+
+  const rows: MetricsV1Input[] = [];
+
+  for (const scopeMetrics of resourceMetrics.scopeMetrics) {
+    for (const metric of scopeMetrics.metrics) {
+      const metricName = metric.name;
+
+      // Process gauge data points
+      if (metric.gauge) {
+        for (const dp of metric.gauge.dataPoints) {
+          const value: number =
+            dp.asDouble !== undefined ? dp.asDouble : dp.asInt !== undefined ? Number(dp.asInt) : 0;
+          const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
+
+          rows.push({
+            organization_id: organizationId,
+            project_id: projectId,
+            environment_id: environmentId,
+            metric_name: metricName,
+            metric_type: "gauge",
+            metric_subject: resolved.machineId ?? "unknown",
+            bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
+            value,
+            attributes: resolved.attributes,
+          });
+        }
+      }
+
+      // Process sum data points
+      if (metric.sum) {
+        for (const dp of metric.sum.dataPoints) {
+          const value: number =
+            dp.asDouble !== undefined ? dp.asDouble : dp.asInt !== undefined ? Number(dp.asInt) : 0;
+          const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
+
+          rows.push({
+            organization_id: organizationId,
+            project_id: projectId,
+            environment_id: environmentId,
+            metric_name: metricName,
+            metric_type: "sum",
+            metric_subject: resolved.machineId ?? "unknown",
+            bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
+            value,
+            attributes: resolved.attributes,
+          });
+        }
+      }
+
+      // Process histogram data points
+      if (metric.histogram) {
+        for (const dp of metric.histogram.dataPoints) {
+          const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
+          const count = Number(dp.count);
+          const sum = dp.sum ?? 0;
+
+          rows.push({
+            organization_id: organizationId,
+            project_id: projectId,
+            environment_id: environmentId,
+            metric_name: metricName,
+            metric_type: "histogram",
+            metric_subject: resolved.machineId ?? "unknown",
+            bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
+            value: count > 0 ? sum / count : 0,
+            attributes: resolved.attributes,
+          });
+        }
+      }
+    }
+  }
+
+  return rows;
+}
+
+// Prefixes injected by TaskContextMetricExporter — these are extracted into
+// the nested `trigger` key and should not appear as top-level user attributes.
+const INTERNAL_METRIC_ATTRIBUTE_PREFIXES = ["ctx.", "worker."];
+
+interface ResourceContext {
+  taskSlug: string | undefined;
+  runId: string | undefined;
+  attemptNumber: number | undefined;
+  machineId: string | undefined;
+  workerId: string | undefined;
+  workerVersion: string | undefined;
+}
+
+function resolveDataPointContext(
+  dpAttributes: KeyValue[],
+  resourceCtx: ResourceContext
+): {
+  machineId: string | undefined;
+  attributes: Record<string, unknown>;
+} {
+  const runId =
+    resourceCtx.runId ??
+    extractStringAttribute(dpAttributes, SemanticInternalAttributes.RUN_ID);
+  const taskSlug =
+    resourceCtx.taskSlug ??
+    extractStringAttribute(dpAttributes, SemanticInternalAttributes.TASK_SLUG);
+  const attemptNumber =
+    resourceCtx.attemptNumber ??
+    extractNumberAttribute(dpAttributes, SemanticInternalAttributes.ATTEMPT_NUMBER);
+  const machineId =
+    resourceCtx.machineId ??
+    extractStringAttribute(dpAttributes, SemanticInternalAttributes.MACHINE_ID);
+  const workerId =
+    resourceCtx.workerId ??
+    extractStringAttribute(dpAttributes, SemanticInternalAttributes.WORKER_ID);
+  const workerVersion =
+    resourceCtx.workerVersion ??
+    extractStringAttribute(dpAttributes, SemanticInternalAttributes.WORKER_VERSION);
+  const machineName = extractStringAttribute(
+    dpAttributes,
+    SemanticInternalAttributes.MACHINE_PRESET_NAME
+  );
+  const environmentType = extractStringAttribute(
+    dpAttributes,
+    SemanticInternalAttributes.ENVIRONMENT_TYPE
+  );
+
+  // Build the trigger context object with only defined values
+  const trigger: Record<string, string | number> = {};
+  if (runId) trigger.run_id = runId;
+  if (taskSlug) trigger.task_slug = taskSlug;
+  if (attemptNumber !== undefined) trigger.attempt_number = attemptNumber;
+  if (machineId) trigger.machine_id = machineId;
+  if (machineName) trigger.machine_name = machineName;
+  if (workerId) trigger.worker_id = workerId;
+  if (workerVersion) trigger.worker_version = workerVersion;
+  if (environmentType) trigger.environment_type = environmentType;
+
+  // Build user attributes, filtering out internal ctx/worker keys
+  const result: Record<string, unknown> = {};
+
+  if (Object.keys(trigger).length > 0) {
+    result.trigger = trigger;
+  }
+
+  for (const attr of dpAttributes) {
+    if (INTERNAL_METRIC_ATTRIBUTE_PREFIXES.some((prefix) => attr.key.startsWith(prefix))) {
+      continue;
+    }
+
+    if (isStringValue(attr.value)) {
+      result[attr.key] = attr.value.stringValue;
+    } else if (isIntValue(attr.value)) {
+      result[attr.key] = Number(attr.value.intValue);
+    } else if (isDoubleValue(attr.value)) {
+      result[attr.key] = attr.value.doubleValue;
+    } else if (isBoolValue(attr.value)) {
+      result[attr.key] = attr.value.boolValue;
+    }
+  }
+
+  return { machineId, attributes: result };
+}
+
 function extractEventProperties(attributes: KeyValue[], prefix?: string) {
   return {
     metadata: convertSelectedKeyValueItemsToMap(attributes, [SemanticInternalAttributes.METADATA]),
@@ -428,6 +665,7 @@ function extractEventProperties(attributes: KeyValue[], prefix?: string) {
       SemanticInternalAttributes.ATTEMPT_NUMBER,
     ]),
     taskSlug: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.TASK_SLUG]),
+    machineId: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.MACHINE_ID]),
   };
 }
 
@@ -475,6 +713,8 @@ function convertKeyValueItemsToMap(
         ? attribute.value.boolValue
         : isBytesValue(attribute.value)
         ? binaryToHex(attribute.value.bytesValue)
+        : isArrayValue(attribute.value)
+        ? serializeArrayValue(attribute.value.arrayValue!.values)
         : undefined;
 
       return map;
@@ -511,6 +751,8 @@ function convertSelectedKeyValueItemsToMap(
         ? attribute.value.boolValue
         : isBytesValue(attribute.value)
         ? binaryToHex(attribute.value.bytesValue)
+        : isArrayValue(attribute.value)
+        ? serializeArrayValue(attribute.value.arrayValue!.values)
         : undefined;
 
       return map;
@@ -767,6 +1009,21 @@ function extractBooleanAttribute(
   return isBoolValue(attribute?.value) ? attribute.value.boolValue : fallback;
 }
 
+function extractArrayAttribute(
+  attributes: KeyValue[],
+  name: string | Array<string | undefined>
+): string[] | undefined {
+  const key = Array.isArray(name) ? name.filter(Boolean).join(".") : name;
+
+  const attribute = attributes.find((attribute) => attribute.key === key);
+
+  if (!attribute?.value?.arrayValue?.values) return undefined;
+
+  return attribute.value.arrayValue.values
+    .filter((v): v is { stringValue: string } => isStringValue(v))
+    .map((v) => v.stringValue);
+}
+
 function isPartialSpan(span: Span): boolean {
   if (!span.attributes) return false;
 
@@ -809,6 +1066,31 @@ function isBytesValue(value: AnyValue | undefined): value is { bytesValue: Buffe
   return Buffer.isBuffer(value.bytesValue);
 }
 
+function isArrayValue(
+  value: AnyValue | undefined
+): value is { arrayValue: { values: AnyValue[] } } {
+  if (!value) return false;
+
+  return value.arrayValue != null && Array.isArray(value.arrayValue.values);
+}
+
+/**
+ * Serialize an OTEL array value into a JSON string.
+ * For arrays of strings, produces a JSON array: `["item1","item2"]`
+ * For mixed types, extracts primitives and serializes.
+ */
+function serializeArrayValue(values: AnyValue[]): string {
+  const items = values.map((v) => {
+    if (isStringValue(v)) return v.stringValue;
+    if (isIntValue(v)) return Number(v.intValue);
+    if (isDoubleValue(v)) return v.doubleValue;
+    if (isBoolValue(v)) return v.boolValue;
+    return null;
+  });
+
+  return JSON.stringify(items);
+}
+
 function binaryToHex(buffer: Buffer | string): string;
 function binaryToHex(buffer: Buffer | string | undefined): string | undefined;
 function binaryToHex(buffer: Buffer | string | undefined): string | undefined {
@@ -891,13 +1173,25 @@ function hasUnpairedSurrogateAtEnd(str: string): boolean {
 export const otlpExporter = singleton("otlpExporter", initializeOTLPExporter);
 
 function initializeOTLPExporter() {
+  const metricsFlushScheduler = new DynamicFlushScheduler<MetricsV1Input>({
+    batchSize: env.METRICS_CLICKHOUSE_BATCH_SIZE,
+    flushInterval: env.METRICS_CLICKHOUSE_FLUSH_INTERVAL_MS,
+    callback: async (_flushId, batch) => {
+      await clickhouseClient.metrics.insert(batch);
+    },
+    minConcurrency: 1,
+    maxConcurrency: env.METRICS_CLICKHOUSE_MAX_CONCURRENCY,
+    loadSheddingEnabled: false,
+  });
+
   return new OTLPExporter(
     eventRepository,
     clickhouseEventRepository,
     clickhouseEventRepositoryV2,
+    metricsFlushScheduler,
     process.env.OTLP_EXPORTER_VERBOSE === "1",
     process.env.SERVER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT
       ? parseInt(process.env.SERVER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, 10)
       : 8192
   );
-}
+}
\ No newline at end of file
diff --git a/apps/webapp/app/v3/querySchemas.ts b/apps/webapp/app/v3/querySchemas.ts
new file mode 100644
index 00000000000..1d2c5467742
--- /dev/null
+++ b/apps/webapp/app/v3/querySchemas.ts
@@ -0,0 +1,974 @@
+import { column, type BucketThreshold, type TableSchema } from "@internal/tsql";
+import { z } from "zod";
+import { autoFormatSQL } from "~/components/code/TSQLEditor";
+import { runFriendlyStatus, runStatusTitleFromStatus } from "~/components/runs/v3/TaskRunStatus";
+import { logger } from "~/services/logger.server";
+
+export const QueryScopeSchema = z.enum(["organization", "project", "environment"]);
+export type QueryScope = z.infer<typeof QueryScopeSchema>;
+
+/**
+ * Environment type values
+ */
+const ENVIRONMENT_TYPES = ["PRODUCTION", "STAGING", "DEVELOPMENT", "PREVIEW"] as const;
+
+/**
+ * Machine preset values
+ */
+const MACHINE_PRESETS = [
+  "micro",
+  "small-1x",
+  "small-2x",
+  "medium-1x",
+  "medium-2x",
+  "large-1x",
+  "large-2x",
+] as const;
+
+/**
+ * Schema definition for the runs table (trigger_dev.task_runs_v2)
+ */
+export const runsSchema: TableSchema = {
+  name: "runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  description: "Task runs - stores all task execution records",
+  timeConstraint: "triggered_at",
+  useFinal: true,
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  requiredFilters: [{ column: "engine", value: "V2" }],
+  columns: {
+    run_id: {
+      name: "run_id",
+      clickhouseName: "friendly_id",
+      ...column("String", {
+        description:
+          "A unique ID for a run. They always start with `run_`, e.g., run_cm1a2b3c4d5e6f7g8h9i",
+        customRenderType: "runId",
+        example: "run_cm1a2b3c4d5e6f7g8h9i",
+        coreColumn: true,
+      }),
+    },
+    environment: {
+      name: "environment",
+      clickhouseName: "environment_id",
+      ...column("String", { description: "The environment slug", example: "prod" }),
+      fieldMapping: "environment",
+      customRenderType: "environment",
+    },
+    project: {
+      name: "project",
+      clickhouseName: "project_id",
+      ...column("String", {
+        description: "The project reference, they always start with `proj_`.",
+        example: "proj_howcnaxbfxdmwmxazktx",
+      }),
+      fieldMapping: "project",
+      customRenderType: "project",
+    },
+    environment_type: {
+      name: "environment_type",
+      ...column("LowCardinality(String)", {
+        description: "Environment type",
+        allowedValues: [...ENVIRONMENT_TYPES],
+        customRenderType: "environmentType",
+        example: "PRODUCTION",
+      }),
+    },
+    attempt_count: {
+      name: "attempt_count",
+      clickhouseName: "attempt",
+      ...column("UInt8", {
+        description: "Number of attempts (starts at 1)",
+        example: "1",
+        customRenderType: "number",
+      }),
+    },
+    status: {
+      name: "status",
+      ...column("LowCardinality(String)", {
+        description: "Run status",
+        allowedValues: [...runFriendlyStatus],
+        valueMap: runStatusTitleFromStatus,
+        customRenderType: "runStatus",
+        example: "Completed",
+        coreColumn: true,
+      }),
+    },
+    is_finished: {
+      name: "is_finished",
+      ...column("UInt8", {
+        description:
+          "Whether the run is finished. This includes failed and successful runs. (0 or 1)",
+        example: "0",
+      }),
+      expression:
+        "if(status IN ('COMPLETED_SUCCESSFULLY', 'COMPLETED_WITH_ERRORS', 'CANCELED', 'TIMED_OUT', 'CRASHED', 'SYSTEM_FAILURE', 'EXPIRED', 'PAUSED'), true, false)",
+    },
+
+    // Task & queue
+    task_identifier: {
+      name: "task_identifier",
+      ...column("String", {
+        description: "Task identifier/slug",
+        example: "my-background-task",
+        coreColumn: true,
+      }),
+    },
+    queue: {
+      name: "queue",
+      ...column("String", {
+        description: "Queue name",
+        example: "task/my-background-task",
+        customRenderType: "queue",
+      }),
+    },
+
+    batch_id: {
+      name: "batch_id",
+      ...column("String", {
+        description: "Batch ID (if part of a batch)",
+        example: "batch_5678efgh",
+        expression: "if(batch_id = '', NULL, 'batch_' || batch_id)",
+      }),
+      whereTransform: (value: string) => value.replace(/^batch_/, ""),
+    },
+
+    // Related runs
+    root_run_id: {
+      name: "root_run_id",
+      ...column("String", {
+        description: "Root run ID (for child runs)",
+        example: "run_cm1a2b3c4d5e6f7g8h9i",
+        customRenderType: "runId",
+        expression: "if(root_run_id = '', NULL, 'run_' || root_run_id)",
+      }),
+      whereTransform: (value: string) => value.replace(/^run_/, ""),
+    },
+    parent_run_id: {
+      name: "parent_run_id",
+      ...column("String", {
+        description: "Parent run ID (for child runs)",
+        example: "run_cm1a2b3c4d5e6f7g8h9i",
+        customRenderType: "runId",
+        expression: "if(parent_run_id = '', NULL, 'run_' || parent_run_id)",
+      }),
+      whereTransform: (value: string) => value.replace(/^run_/, ""),
+    },
+    depth: {
+      name: "depth",
+      ...column("UInt8", { description: "Nesting depth (0 for root runs)", example: "0" }),
+    },
+    is_root_run: {
+      name: "is_root_run",
+      ...column("UInt8", { description: "Whether this is a root run (0 or 1)", example: "0" }),
+      expression: "if(depth = 0, true, false)",
+    },
+    is_child_run: {
+      name: "is_child_run",
+      ...column("UInt8", { description: "Whether this is a child run (0 or 1)", example: "0" }),
+      expression: "if(depth > 0, true, false)",
+    },
+
+    idempotency_key: {
+      name: "idempotency_key",
+      clickhouseName: "idempotency_key_user",
+      ...column("String", { description: "Idempotency key (available from 4.3.3)", example: "user-123-action-456" }),
+    },
+    idempotency_key_scope: {
+      name: "idempotency_key_scope",
+      ...column("String", { description: "The idempotency key scope determines whether a task should be considered unique within a parent run, a specific attempt, or globally. An empty value means there's no idempotency key set (available from 4.3.3).", example: "run", allowedValues: ["global", "run", "attempt"], }),
+    },
+    region: {
+      name: "region",
+      clickhouseName: "worker_queue",
+      ...column("String", {
+        description: "Region",
+        example: "us-east-1",
+      }),
+      expression: "if(startsWith(worker_queue, 'cm'), NULL, worker_queue)",
+    },
+
+    // Timing
+    triggered_at: {
+      name: "triggered_at",
+      clickhouseName: "created_at",
+      ...column("DateTime64", {
+        description: "When the run was triggered.",
+        example: "2024-01-15 09:30:00.000",
+        coreColumn: true,
+      }),
+    },
+    queued_at: {
+      name: "queued_at",
+      ...column("Nullable(DateTime64)", {
+        description:
+          "When the run was added to the queue. This is normally the same time as the triggered_at time, unless a delay is passed in or it's a scheduled run.",
+        example: "2024-01-15 09:30:01.000",
+      }),
+    },
+    dequeued_at: {
+      name: "dequeued_at",
+      clickhouseName: "started_at",
+      ...column("Nullable(DateTime64)", {
+        description:
+          "When the run was dequeued for execution. This happens when there is available concurrency to execute your run.",
+        example: "2024-01-15 09:30:01.000",
+      }),
+    },
+    executed_at: {
+      name: "executed_at",
+      ...column("Nullable(DateTime64)", {
+        description: "When execution of the run began.",
+        example: "2024-01-15 09:30:01.500",
+      }),
+    },
+    completed_at: {
+      name: "completed_at",
+      ...column("Nullable(DateTime64)", {
+        description: "When the run completed",
+        example: "2024-01-15 09:30:05.000",
+      }),
+    },
+    delay_until: {
+      name: "delay_until",
+      ...column("Nullable(DateTime64)", {
+        description: "Delayed execution until this time",
+        example: "2024-01-15 10:00:00.000",
+      }),
+    },
+    has_delay: {
+      name: "has_delay",
+      ...column("UInt8", { description: "Whether the run had a delay passed in", example: "1" }),
+      expression: "if(isNotNull(delay_until), true, false)",
+    },
+    expired_at: {
+      name: "expired_at",
+      ...column("Nullable(DateTime64)", {
+        description:
+          'If there was a TTL on the run, this is when the run "expired". By default dev runs have a TTL of 10 minutes.',
+        example: "2024-01-15 09:35:00.000",
+      }),
+    },
+    ttl: {
+      name: "ttl",
+      clickhouseName: "expiration_ttl",
+      ...column("String", {
+        description: "The TTL string for expiration – by default dev runs have a TTL of '10m'.",
+        example: "10m",
+      }),
+    },
+
+    // Useful time periods
+    execution_duration: {
+      name: "execution_duration",
+      ...column("Nullable(Int64)", {
+        description:
+          "The time between starting to execute and completing. This includes any time spent waiting (it is not compute time, use `usage_duration` for that).",
+        customRenderType: "duration",
+        example: "4000",
+      }),
+      expression: "dateDiff('millisecond', executed_at, completed_at)",
+    },
+    total_duration: {
+      name: "total_duration",
+      ...column("Nullable(Int64)", {
+        description:
+          "The time between being triggered and completing (if it has). This includes any time spent waiting (it is not compute time, use `usage_duration` for that).",
+        customRenderType: "duration",
+        example: "4000",
+      }),
+      expression: "dateDiff('millisecond', created_at, completed_at)",
+    },
+    queued_duration: {
+      name: "queued_duration",
+      ...column("Nullable(Int64)", {
+        description:
+          "The time between being queued and dequeued. Remember you need enough available concurrency for runs to be dequeued and start executing.",
+        customRenderType: "duration",
+        example: "4000",
+      }),
+      expression: "dateDiff('millisecond', queued_at, started_at)",
+    },
+
+    // Cost & usage
+    usage_duration: {
+      name: "usage_duration",
+      clickhouseName: "usage_duration_ms",
+      ...column("UInt32", {
+        description: "Compute usage duration in milliseconds.",
+        customRenderType: "duration",
+        example: "3500",
+      }),
+    },
+    compute_cost: {
+      name: "compute_cost",
+      ...column("Float64", {
+        description: "Compute cost in dollars",
+        customRenderType: "costInDollars",
+        example: "0.000676",
+      }),
+      expression: "cost_in_cents / 100.0",
+    },
+    invocation_cost: {
+      name: "invocation_cost",
+      ...column("Float64", {
+        description: "Invocation cost in dollars – the cost to start a run.",
+        customRenderType: "costInDollars",
+        example: "0.000025",
+      }),
+      expression: "base_cost_in_cents / 100.0",
+    },
+    total_cost: {
+      name: "total_cost",
+      ...column("Float64", {
+        description: "Total cost in dollars (compute_cost + invocation_cost)",
+        customRenderType: "costInDollars",
+        example: "0.000701",
+      }),
+      expression: "(cost_in_cents + base_cost_in_cents) / 100.0",
+    },
+
+    // Output & error (JSON columns)
+    // For JSON columns, NULL checks are transformed to check for empty object '{}'
+    // So `error IS NULL` becomes `error = '{}'` and `error IS NOT NULL` becomes `error != '{}'`
+    // textColumn uses the pre-materialized text columns for better performance
+    // dataPrefix handles the internal {"data": ...} wrapper transparently
+    output: {
+      name: "output",
+      ...column("JSON", {
+        description: "The data you returned from the task.",
+        example: '{"result": "success"}',
+      }),
+      nullValue: "'{}'", // Transform NULL checks to compare against empty object
+      textColumn: "output_text", // Use output_text for full JSON value queries
+      dataPrefix: "data", // Internal data is wrapped in {"data": ...}
+    },
+    error: {
+      name: "error",
+      ...column("JSON", {
+        description:
+          "If a run completely failed (after all attempts) then this error will be populated.",
+        example: '{"message": "Task failed"}',
+      }),
+      nullValue: "'{}'", // Transform NULL checks to compare against empty object
+      textColumn: "error_text", // Use error_text for full JSON value queries
+      dataPrefix: "data", // Internal data is wrapped in {"data": ...}
+    },
+
+    // Tags & versions
+    tags: {
+      name: "tags",
+      ...column("Array(String)", {
+        description: "Tags you have added to the run.",
+        customRenderType: "tags",
+        example: '["user:123", "priority:high"]',
+      }),
+    },
+    task_version: {
+      name: "task_version",
+      ...column("String", {
+        description: "The version of your code in reverse date format.",
+        example: "20240115.1",
+      }),
+    },
+    sdk_version: {
+      name: "sdk_version",
+      ...column("String", {
+        description: "The SDK package version for this run.",
+        example: "3.3.0",
+      }),
+    },
+    cli_version: {
+      name: "cli_version",
+      ...column("String", {
+        description: "The CLI package version for this run.",
+        example: "3.3.0",
+      }),
+    },
+    machine: {
+      name: "machine",
+      clickhouseName: "machine_preset",
+      ...column("LowCardinality(String)", {
+        description: "The machine that the run executed on.",
+        allowedValues: [...MACHINE_PRESETS],
+        customRenderType: "machine",
+        example: "small-1x",
+      }),
+    },
+    is_test: {
+      name: "is_test",
+      ...column("UInt8", { description: "Whether this is a test run (0 or 1)", example: "0" }),
+      expression: "if(is_test > 0, true, false)",
+    },
+    concurrency_key: {
+      name: "concurrency_key",
+      ...column("String", {
+        description: "The concurrency key you passed in when triggering the run.",
+        example: "user:1234567",
+      }),
+    },
+    max_duration: {
+      name: "max_duration",
+      clickhouseName: "max_duration_in_seconds",
+      ...column("Nullable(UInt32)", {
+        description:
+          "The maximum allowed compute duration for this run in seconds. If the run exceeds this duration, the run will fail with an error. Can be set on an individual task, in the trigger.config, or per-run when triggering.",
+        example: "300",
+        customRenderType: "durationSeconds",
+      }),
+    },
+    bulk_action_group_ids: {
+      name: "bulk_action_group_ids",
+      ...column("Array(String)", {
+        description: "Any bulk actions that operated on this run.",
+        example: '["bulk_12345678", "bulk_34567890"]',
+        whereTransform: (value: string) => {
+          logger.log(`WHERE TRANSFORM: ${value}`);
+          return value.replace(/^bulk_/, "");
+        },
+      }),
+    },
+  },
+};
+
+/**
+ * Schema definition for the metrics table (trigger_dev.metrics_v1)
+ */
+export const metricsSchema: TableSchema = {
+  name: "metrics",
+  clickhouseName: "trigger_dev.metrics_v1",
+  description: "Host and runtime metrics collected during task execution",
+  timeConstraint: "bucket_start",
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  columns: {
+    environment: {
+      name: "environment",
+      clickhouseName: "environment_id",
+      ...column("String", { description: "The environment slug", example: "prod" }),
+      fieldMapping: "environment",
+      customRenderType: "environment",
+    },
+    project: {
+      name: "project",
+      clickhouseName: "project_id",
+      ...column("String", {
+        description: "The project reference, they always start with `proj_`.",
+        example: "proj_howcnaxbfxdmwmxazktx",
+      }),
+      fieldMapping: "project",
+      customRenderType: "project",
+    },
+    metric_name: {
+      name: "metric_name",
+      ...column("LowCardinality(String)", {
+        description: "The name of the metric (e.g. process.cpu.utilization, system.memory.usage)",
+        example: "process.cpu.utilization",
+        coreColumn: true,
+      }),
+    },
+    metric_type: {
+      name: "metric_type",
+      ...column("LowCardinality(String)", {
+        description: "The type of metric",
+        allowedValues: ["gauge", "sum", "histogram"],
+        example: "gauge",
+      }),
+    },
+    machine_id: {
+      name: "machine_id",
+      clickhouseName: "metric_subject",
+      ...column("String", {
+        description: "The machine ID that produced this metric",
+        example: "machine-abc123",
+      }),
+    },
+    bucket_start: {
+      name: "bucket_start",
+      ...column("DateTime", {
+        description: "The start of the 10-second aggregation bucket",
+        example: "2024-01-15 09:30:00",
+        coreColumn: true,
+      }),
+    },
+    metric_value: {
+      name: "metric_value",
+      clickhouseName: "value",
+      ...column("Float64", {
+        description: "The metric value",
+        example: "0.75",
+        coreColumn: true,
+      }),
+    },
+
+    // Attributes (JSON column for user-defined and system attributes)
+    attributes: {
+      name: "attributes",
+      ...column("JSON", {
+        description: "JSON attributes attached to the metric data point.",
+        example: '{"region": "us-east-1"}',
+      }),
+    },
+
+    // Trigger context columns (from attributes.trigger.* JSON subpaths)
+    run_id: {
+      name: "run_id",
+      ...column("String", {
+        description: "The run ID associated with this metric",
+        customRenderType: "runId",
+        example: "run_cm1a2b3c4d5e6f7g8h9i",
+        coreColumn: true,
+      }),
+      expression: "attributes.trigger.run_id",
+    },
+    task_identifier: {
+      name: "task_identifier",
+      ...column("String", {
+        description: "Task identifier/slug",
+        example: "my-background-task",
+        coreColumn: true,
+      }),
+      expression: "attributes.trigger.task_slug",
+    },
+    attempt_number: {
+      name: "attempt_number",
+      ...column("UInt64", {
+        description: "The attempt number for this metric",
+        example: "1",
+      }),
+      expression: "attributes.trigger.attempt_number",
+    },
+    machine_name: {
+      name: "machine_name",
+      ...column("String", {
+        description: "The machine preset used for execution",
+        allowedValues: [...MACHINE_PRESETS],
+        example: "small-1x",
+      }),
+      expression: "attributes.trigger.machine_name",
+    },
+    environment_type: {
+      name: "environment_type",
+      ...column("String", {
+        description: "Environment type",
+        allowedValues: [...ENVIRONMENT_TYPES],
+        customRenderType: "environmentType",
+        example: "PRODUCTION",
+      }),
+      expression: "attributes.trigger.environment_type",
+    },
+    worker_id: {
+      name: "worker_id",
+      ...column("String", {
+        description: "The worker ID that produced this metric",
+        customRenderType: "deploymentId",
+        example: "deployment_cm1a2b3c4d5e",
+      }),
+      expression: "attributes.trigger.worker_id",
+    },
+    worker_version: {
+      name: "worker_version",
+      ...column("String", {
+        description: "The worker version that produced this metric",
+        example: "20240115.1",
+      }),
+      expression: "attributes.trigger.worker_version",
+    },
+  },
+  timeBucketThresholds: [
+    // Metrics are pre-aggregated into 10-second buckets, so 10s is the most granular interval.
+    // All thresholds are shifted coarser compared to the runs table defaults.
+    { maxRangeSeconds: 3 * 60 * 60, interval: { value: 10, unit: "SECOND" } },
+    { maxRangeSeconds: 12 * 60 * 60, interval: { value: 1, unit: "MINUTE" } },
+    { maxRangeSeconds: 2 * 24 * 60 * 60, interval: { value: 5, unit: "MINUTE" } },
+    { maxRangeSeconds: 7 * 24 * 60 * 60, interval: { value: 15, unit: "MINUTE" } },
+    { maxRangeSeconds: 30 * 24 * 60 * 60, interval: { value: 1, unit: "HOUR" } },
+    { maxRangeSeconds: 90 * 24 * 60 * 60, interval: { value: 6, unit: "HOUR" } },
+    { maxRangeSeconds: 180 * 24 * 60 * 60, interval: { value: 1, unit: "DAY" } },
+    { maxRangeSeconds: 365 * 24 * 60 * 60, interval: { value: 1, unit: "WEEK" } },
+  ] satisfies BucketThreshold[],
+};
+
+/**
+ * All available schemas for the query editor
+ */
+/**
+ * Schema definition for the llm_metrics table (trigger_dev.llm_metrics_v1)
+ */
+export const llmMetricsSchema: TableSchema = {
+  name: "llm_metrics",
+  clickhouseName: "trigger_dev.llm_metrics_v1",
+  description: "LLM metrics: token usage, cost, performance, and behavior from GenAI spans",
+  timeConstraint: "start_time",
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  columns: {
+    environment: {
+      name: "environment",
+      clickhouseName: "environment_id",
+      ...column("String", { description: "The environment slug", example: "prod" }),
+      fieldMapping: "environment",
+      customRenderType: "environment",
+    },
+    project: {
+      name: "project",
+      clickhouseName: "project_id",
+      ...column("String", {
+        description: "The project reference, they always start with `proj_`.",
+        example: "proj_howcnaxbfxdmwmxazktx",
+      }),
+      fieldMapping: "project",
+      customRenderType: "project",
+    },
+    run_id: {
+      name: "run_id",
+      ...column("String", {
+        description: "The run ID",
+        customRenderType: "runId",
+        coreColumn: true,
+      }),
+    },
+    trace_id: {
+      name: "trace_id",
+      ...column("String", {
+        description: "The trace ID",
+      }),
+    },
+    span_id: {
+      name: "span_id",
+      ...column("String", {
+        description: "The span ID",
+      }),
+    },
+    task_identifier: {
+      name: "task_identifier",
+      ...column("LowCardinality(String)", {
+        description: "The task identifier",
+        example: "my-task",
+        coreColumn: true,
+      }),
+    },
+    gen_ai_system: {
+      name: "gen_ai_system",
+      ...column("LowCardinality(String)", {
+        description: "AI provider (e.g. openai, anthropic)",
+        example: "openai",
+        coreColumn: true,
+      }),
+    },
+    request_model: {
+      name: "request_model",
+      ...column("String", {
+        description: "The model name requested",
+        example: "gpt-4o",
+      }),
+    },
+    response_model: {
+      name: "response_model",
+      ...column("String", {
+        description: "The model name returned by the provider",
+        example: "gpt-4o-2024-08-06",
+        coreColumn: true,
+      }),
+    },
+    operation_id: {
+      name: "operation_id",
+      ...column("LowCardinality(String)", {
+        description: "Operation type (e.g. ai.streamText.doStream, ai.generateText.doGenerate)",
+        example: "ai.streamText.doStream",
+      }),
+    },
+    finish_reason: {
+      name: "finish_reason",
+      ...column("LowCardinality(String)", {
+        description: "Why the LLM stopped generating (e.g. stop, tool-calls, length)",
+        example: "stop",
+        coreColumn: true,
+      }),
+    },
+    cost_source: {
+      name: "cost_source",
+      ...column("LowCardinality(String)", {
+        description: "Where cost data came from (registry, gateway, openrouter)",
+        example: "registry",
+      }),
+    },
+    input_tokens: {
+      name: "input_tokens",
+      ...column("UInt64", {
+        description: "Number of input tokens",
+        example: "702",
+      }),
+    },
+    output_tokens: {
+      name: "output_tokens",
+      ...column("UInt64", {
+        description: "Number of output tokens",
+        example: "22",
+      }),
+    },
+    total_tokens: {
+      name: "total_tokens",
+      ...column("UInt64", {
+        description: "Total token count",
+        example: "724",
+      }),
+    },
+    cached_read_tokens: {
+      name: "cached_read_tokens",
+      ...column("UInt64", {
+        description:
+          "Input tokens served from the provider's prompt cache (cheaper than regular input tokens). Supported by Anthropic and OpenAI.",
+        example: "8200",
+      }),
+      expression: "usage_details['input_cached_tokens']",
+    },
+    cache_creation_tokens: {
+      name: "cache_creation_tokens",
+      ...column("UInt64", {
+        description:
+          "Input tokens written to create a new prompt cache entry. Supported by Anthropic.",
+        example: "1751",
+      }),
+      expression: "usage_details['cache_creation_input_tokens']",
+    },
+    reasoning_tokens: {
+      name: "reasoning_tokens",
+      ...column("UInt64", {
+        description:
+          "Tokens used for chain-of-thought reasoning (e.g. OpenAI o-series, DeepSeek R1). These count toward output but are not visible in the response.",
+        example: "512",
+      }),
+      expression: "usage_details['reasoning_tokens']",
+    },
+    input_cost: {
+      name: "input_cost",
+      ...column("Decimal64(12)", {
+        description: "Input cost in USD (from pricing registry)",
+        customRenderType: "costInDollars",
+      }),
+    },
+    output_cost: {
+      name: "output_cost",
+      ...column("Decimal64(12)", {
+        description: "Output cost in USD (from pricing registry)",
+        customRenderType: "costInDollars",
+      }),
+    },
+    total_cost: {
+      name: "total_cost",
+      ...column("Decimal64(12)", {
+        description: "Total cost in USD",
+        customRenderType: "costInDollars",
+        coreColumn: true,
+      }),
+    },
+    cached_read_cost: {
+      name: "cached_read_cost",
+      ...column("Decimal64(12)", {
+        description:
+          "Cost of cached input tokens (discounted vs regular input). Only present when the pricing tier has a separate cached input price.",
+        customRenderType: "costInDollars",
+      }),
+      expression: "cost_details['input_cached_tokens']",
+    },
+    cache_creation_cost: {
+      name: "cache_creation_cost",
+      ...column("Decimal64(12)", {
+        description: "Cost of tokens written to create a prompt cache entry.",
+        customRenderType: "costInDollars",
+      }),
+      expression: "cost_details['cache_creation_input_tokens']",
+    },
+    provider_cost: {
+      name: "provider_cost",
+      ...column("Decimal64(12)", {
+        description: "Provider-reported cost in USD (from gateway or openrouter)",
+        customRenderType: "costInDollars",
+      }),
+    },
+    ms_to_first_chunk: {
+      name: "ms_to_first_chunk",
+      ...column("Float64", {
+        description: "Time to first chunk in milliseconds (TTFC)",
+        example: "245.3",
+        coreColumn: true,
+      }),
+    },
+    tokens_per_second: {
+      name: "tokens_per_second",
+      ...column("Float64", {
+        description: "Average output tokens per second",
+        example: "72.5",
+      }),
+    },
+    pricing_tier_name: {
+      name: "pricing_tier_name",
+      ...column("LowCardinality(String)", {
+        description: "The matched pricing tier name",
+        example: "Standard",
+      }),
+    },
+    start_time: {
+      name: "start_time",
+      ...column("DateTime64(9)", {
+        description: "When the LLM call started",
+        coreColumn: true,
+      }),
+    },
+    duration: {
+      name: "duration",
+      ...column("UInt64", {
+        description: "Span duration in nanoseconds",
+        customRenderType: "durationNs",
+      }),
+    },
+    prompt_slug: {
+      name: "prompt_slug",
+      ...column("LowCardinality(String)", {
+        description: "The managed prompt slug used for this LLM call",
+        example: "customer-support",
+        coreColumn: true,
+      }),
+    },
+    prompt_version: {
+      name: "prompt_version",
+      ...column("UInt32", {
+        description: "The managed prompt version number used for this LLM call",
+        example: "3",
+      }),
+    },
+    metadata: {
+      name: "metadata",
+      ...column("Map(LowCardinality(String), String)", {
+        description:
+          "Key-value metadata from run tags (key:value format) and AI SDK telemetry metadata. Access keys with dot notation (metadata.userId) or bracket syntax (metadata['userId']).",
+        example: "{'userId':'user_123','org':'acme'}",
+      }),
+    },
+  },
+};
+
+/**
+ * Schema definition for the llm_models table (trigger_dev.llm_model_aggregates_v1)
+ * Global table — no tenant columns. Contains anonymized cross-tenant model performance data.
+ */
+export const llmModelsSchema: TableSchema = {
+  name: "llm_models",
+  clickhouseName: "trigger_dev.llm_model_aggregates_v1",
+  description:
+    "Cross-tenant model performance aggregates: calls, cost, latency, and throughput per model per minute. No tenant-specific data.",
+  timeConstraint: "minute",
+  // No tenantColumns — this is a global table with anonymized data
+  columns: {
+    response_model: {
+      name: "response_model",
+      ...column("String", {
+        description: "The model name as returned by the provider",
+        example: "gpt-4o-2024-08-06",
+        coreColumn: true,
+      }),
+    },
+    base_response_model: {
+      name: "base_response_model",
+      ...column("String", {
+        description: "The base model name with dated variants grouped",
+        example: "gpt-4o",
+        coreColumn: true,
+      }),
+    },
+    gen_ai_system: {
+      name: "gen_ai_system",
+      ...column("String", {
+        description: "The AI provider system identifier",
+        example: "openai.responses",
+        coreColumn: true,
+      }),
+    },
+    minute: {
+      name: "minute",
+      ...column("DateTime", {
+        description: "Aggregation time bucket (per minute)",
+        coreColumn: true,
+      }),
+    },
+    call_count: {
+      name: "call_count",
+      ...column("UInt64", {
+        description: "Number of LLM calls in this time bucket",
+        coreColumn: true,
+      }),
+    },
+    total_input_tokens: {
+      name: "total_input_tokens",
+      ...column("UInt64", {
+        description: "Total input tokens consumed",
+      }),
+    },
+    total_output_tokens: {
+      name: "total_output_tokens",
+      ...column("UInt64", {
+        description: "Total output tokens generated",
+      }),
+    },
+    total_cost: {
+      name: "total_cost",
+      ...column("Float64", {
+        description: "Total cost in USD",
+        customRenderType: "costInDollars",
+        coreColumn: true,
+      }),
+    },
+    // Aggregate state columns — use quantilesMerge() in queries to extract values
+    // Example: quantilesMerge(0.5)(ttfc_quantiles)[1] AS ttfc_p50
+    ttfc_quantiles: {
+      name: "ttfc_quantiles",
+      ...column("String", {
+        description:
+          "Time to first chunk quantile state. Use quantilesMerge(0.5)(ttfc_quantiles)[1] AS ttfc_p50 in queries.",
+        example: "quantilesMerge(0.5)(ttfc_quantiles)[1]",
+      }),
+    },
+    tps_quantiles: {
+      name: "tps_quantiles",
+      ...column("String", {
+        description:
+          "Tokens per second quantile state. Use quantilesMerge(0.5)(tps_quantiles)[1] AS tps_p50 in queries.",
+        example: "quantilesMerge(0.5)(tps_quantiles)[1]",
+      }),
+    },
+    duration_quantiles: {
+      name: "duration_quantiles",
+      ...column("String", {
+        description:
+          "Duration quantile state. Use quantilesMerge(0.5)(duration_quantiles)[1] AS duration_p50 in queries.",
+        example: "quantilesMerge(0.5)(duration_quantiles)[1]",
+      }),
+    },
+  },
+};
+
+export const querySchemas: TableSchema[] = [
+  runsSchema,
+  metricsSchema,
+  llmMetricsSchema,
+  llmModelsSchema,
+];
+
+/**
+ * Default query for the query editor
+ */
+export const defaultQuery = autoFormatSQL(`SELECT run_id, task_identifier, triggered_at, status
+FROM runs
+ORDER BY triggered_at DESC
+LIMIT 100`);
diff --git a/apps/webapp/app/v3/r2.server.ts b/apps/webapp/app/v3/r2.server.ts
deleted file mode 100644
index 67170094075..00000000000
--- a/apps/webapp/app/v3/r2.server.ts
+++ /dev/null
@@ -1,240 +0,0 @@
-import { AwsClient } from "aws4fetch";
-import { env } from "~/env.server";
-import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { logger } from "~/services/logger.server";
-import { singleton } from "~/utils/singleton";
-import { startActiveSpan } from "./tracer.server";
-import { IOPacket } from "@trigger.dev/core/v3";
-
-export const r2 = singleton("r2", initializeR2);
-
-function initializeR2() {
-  if (!env.OBJECT_STORE_ACCESS_KEY_ID || !env.OBJECT_STORE_SECRET_ACCESS_KEY) {
-    return;
-  }
-
-  return new AwsClient({
-    accessKeyId: env.OBJECT_STORE_ACCESS_KEY_ID,
-    secretAccessKey: env.OBJECT_STORE_SECRET_ACCESS_KEY,
-    region: env.OBJECT_STORE_REGION,
-    // We now set the default value to "s3" in the schema to enhance interoperability with various S3-compatible services.
-    // Setting this env var to an empty string will restore the previous behavior of not setting a service.
-    service: env.OBJECT_STORE_SERVICE ? env.OBJECT_STORE_SERVICE : undefined,
-  });
-}
-
-export async function uploadPacketToObjectStore(
-  filename: string,
-  data: ReadableStream | string,
-  contentType: string,
-  environment: AuthenticatedEnvironment
-): Promise<string> {
-  return await startActiveSpan("uploadPacketToObjectStore()", async (span) => {
-    if (!r2) {
-      throw new Error("Object store credentials are not set");
-    }
-
-    if (!env.OBJECT_STORE_BASE_URL) {
-      throw new Error("Object store base URL is not set");
-    }
-
-    span.setAttributes({
-      projectRef: environment.project.externalRef,
-      environmentSlug: environment.slug,
-      filename: filename,
-    });
-
-    const url = new URL(env.OBJECT_STORE_BASE_URL);
-    url.pathname = `/packets/${environment.project.externalRef}/${environment.slug}/${filename}`;
-
-    logger.debug("Uploading to object store", { url: url.href });
-
-    const response = await r2.fetch(url.toString(), {
-      method: "PUT",
-      headers: {
-        "Content-Type": contentType,
-      },
-      body: data,
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to upload output to ${url}: ${response.statusText}`);
-    }
-
-    return url.href;
-  });
-}
-
-export async function downloadPacketFromObjectStore(
-  packet: IOPacket,
-  environment: AuthenticatedEnvironment
-): Promise<IOPacket> {
-  if (packet.dataType !== "application/store") {
-    return packet;
-  }
-
-  return await startActiveSpan("downloadPacketFromObjectStore()", async (span) => {
-    if (!r2) {
-      throw new Error("Object store credentials are not set");
-    }
-
-    if (!env.OBJECT_STORE_BASE_URL) {
-      throw new Error("Object store base URL is not set");
-    }
-
-    span.setAttributes({
-      projectRef: environment.project.externalRef,
-      environmentSlug: environment.slug,
-      filename: packet.data,
-    });
-
-    const url = new URL(env.OBJECT_STORE_BASE_URL);
-    url.pathname = `/packets/${environment.project.externalRef}/${environment.slug}/${packet.data}`;
-
-    logger.debug("Downloading from object store", { url: url.href });
-
-    const response = await r2.fetch(url.toString());
-
-    if (!response.ok) {
-      throw new Error(`Failed to download input from ${url}: ${response.statusText}`);
-    }
-
-    const data = await response.text();
-
-    const rawPacket = {
-      data,
-      dataType: "application/json",
-    };
-
-    return rawPacket;
-  });
-}
-
-export async function uploadDataToObjectStore(
-  filename: string,
-  data: string,
-  contentType: string,
-  prefix?: string
-): Promise<string> {
-  return await startActiveSpan("uploadDataToObjectStore()", async (span) => {
-    if (!r2) {
-      throw new Error("Object store credentials are not set");
-    }
-
-    if (!env.OBJECT_STORE_BASE_URL) {
-      throw new Error("Object store base URL is not set");
-    }
-
-    span.setAttributes({
-      prefix,
-      filename,
-    });
-
-    const url = new URL(env.OBJECT_STORE_BASE_URL);
-    url.pathname = `${prefix}/${filename}`;
-
-    logger.debug("Uploading to object store", { url: url.href });
-
-    const response = await r2.fetch(url.toString(), {
-      method: "PUT",
-      headers: {
-        "Content-Type": contentType,
-      },
-      body: data,
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to upload data to ${url}: ${response.statusText}`);
-    }
-
-    return url.href;
-  });
-}
-
-export async function generatePresignedRequest(
-  projectRef: string,
-  envSlug: string,
-  filename: string,
-  method: "PUT" | "GET" = "PUT"
-): Promise<
-  | {
-      success: false;
-      error: string;
-    }
-  | {
-      success: true;
-      request: Request;
-    }
-> {
-  if (!env.OBJECT_STORE_BASE_URL) {
-    return {
-      success: false,
-      error: "Object store base URL is not set",
-    };
-  }
-
-  if (!r2) {
-    return {
-      success: false,
-      error: "Object store client is not initialized",
-    };
-  }
-
-  const url = new URL(env.OBJECT_STORE_BASE_URL);
-  url.pathname = `/packets/${projectRef}/${envSlug}/${filename}`;
-  url.searchParams.set("X-Amz-Expires", "300"); // 5 minutes
-
-  const signed = await r2.sign(
-    new Request(url, {
-      method,
-    }),
-    {
-      aws: { signQuery: true },
-    }
-  );
-
-  logger.debug("Generated presigned URL", {
-    url: signed.url,
-    headers: Object.fromEntries(signed.headers),
-    projectRef,
-    envSlug,
-    filename,
-  });
-
-  return {
-    success: true,
-    request: signed,
-  };
-}
-
-export async function generatePresignedUrl(
-  projectRef: string,
-  envSlug: string,
-  filename: string,
-  method: "PUT" | "GET" = "PUT"
-): Promise<
-  | {
-      success: false;
-      error: string;
-    }
-  | {
-      success: true;
-      url: string;
-    }
-> {
-  const signed = await generatePresignedRequest(projectRef, envSlug, filename, method);
-
-  if (!signed.success) {
-    return {
-      success: false,
-      error: signed.error,
-    };
-  }
-
-  signed;
-
-  return {
-    success: true,
-    url: signed.request.url,
-  };
-}
diff --git a/apps/webapp/app/v3/runEngine.server.ts b/apps/webapp/app/v3/runEngine.server.ts
index 5f88d5f6a40..b55bc352a24 100644
--- a/apps/webapp/app/v3/runEngine.server.ts
+++ b/apps/webapp/app/v3/runEngine.server.ts
@@ -80,6 +80,16 @@ function createRunEngine() {
         scanJitterInMs: env.RUN_ENGINE_CONCURRENCY_SWEEPER_SCAN_JITTER_IN_MS,
         processMarkedJitterInMs: env.RUN_ENGINE_CONCURRENCY_SWEEPER_PROCESS_MARKED_JITTER_IN_MS,
       },
+      ttlSystem: {
+        disabled: env.RUN_ENGINE_TTL_SYSTEM_DISABLED,
+        consumersDisabled: env.RUN_ENGINE_TTL_CONSUMERS_DISABLED,
+        shardCount: env.RUN_ENGINE_TTL_SYSTEM_SHARD_COUNT,
+        pollIntervalMs: env.RUN_ENGINE_TTL_SYSTEM_POLL_INTERVAL_MS,
+        batchSize: env.RUN_ENGINE_TTL_SYSTEM_BATCH_SIZE,
+        workerConcurrency: env.RUN_ENGINE_TTL_WORKER_CONCURRENCY,
+        batchMaxSize: env.RUN_ENGINE_TTL_WORKER_BATCH_MAX_SIZE,
+        batchMaxWaitMs: env.RUN_ENGINE_TTL_WORKER_BATCH_MAX_WAIT_MS,
+      },
     },
     runLock: {
       redis: {
@@ -104,6 +114,7 @@ function createRunEngine() {
     },
     tracer,
     meter,
+    defaultMaxTtl: env.RUN_ENGINE_DEFAULT_MAX_TTL,
     heartbeatTimeoutsMs: {
       PENDING_EXECUTING: env.RUN_ENGINE_TIMEOUT_PENDING_EXECUTING,
       PENDING_CANCEL: env.RUN_ENGINE_TIMEOUT_PENDING_CANCEL,
@@ -153,6 +164,7 @@ function createRunEngine() {
         return {
           isPaying: plan.v3Subscription.isPaying,
           type: plan.v3Subscription.plan.type,
+          hasPrivateLink: plan.v3Subscription.plan.limits.hasPrivateNetworking ?? false,
         };
       },
     },
@@ -171,9 +183,15 @@ function createRunEngine() {
       drr: {
         quantum: env.BATCH_QUEUE_DRR_QUANTUM,
         maxDeficit: env.BATCH_QUEUE_MAX_DEFICIT,
+        masterQueueLimit: env.BATCH_QUEUE_MASTER_QUEUE_LIMIT,
       },
+      shardCount: env.BATCH_QUEUE_SHARD_COUNT,
+      workerQueueBlockingTimeoutSeconds: env.BATCH_QUEUE_WORKER_QUEUE_ENABLED
+        ? env.BATCH_QUEUE_WORKER_QUEUE_TIMEOUT_SECONDS
+        : undefined,
       consumerCount: env.BATCH_QUEUE_CONSUMER_COUNT,
       consumerIntervalMs: env.BATCH_QUEUE_CONSUMER_INTERVAL_MS,
+      consumerEnabled: env.BATCH_QUEUE_WORKER_ENABLED,
       // Default processing concurrency when no specific limit is set
       // This is overridden per-batch based on the plan type at batch creation
       defaultConcurrency: env.BATCH_CONCURRENCY_LIMIT_DEFAULT,
@@ -181,6 +199,15 @@ function createRunEngine() {
       globalRateLimiter: env.BATCH_QUEUE_GLOBAL_RATE_LIMIT
         ? createBatchGlobalRateLimiter(env.BATCH_QUEUE_GLOBAL_RATE_LIMIT)
         : undefined,
+      // Worker queue depth cap - prevents unbounded growth protecting visibility timeouts
+      workerQueueMaxDepth: env.BATCH_QUEUE_WORKER_QUEUE_MAX_DEPTH,
+      retry: {
+        maxAttempts: 6,
+        minTimeoutInMs: 1_000,
+        maxTimeoutInMs: 30_000,
+        factor: 2,
+        randomize: true,
+      },
     },
     // Debounce configuration
     debounce: {
diff --git a/apps/webapp/app/v3/runEngineHandlers.server.ts b/apps/webapp/app/v3/runEngineHandlers.server.ts
index 7992ffbc70e..411f91ff75d 100644
--- a/apps/webapp/app/v3/runEngineHandlers.server.ts
+++ b/apps/webapp/app/v3/runEngineHandlers.server.ts
@@ -3,7 +3,8 @@ import { SpanKind } from "@internal/tracing";
 import { tryCatch } from "@trigger.dev/core/utils";
 import { createJsonErrorObject, sanitizeError } from "@trigger.dev/core/v3";
 import { RunId } from "@trigger.dev/core/v3/isomorphic";
-import { BatchTaskRunStatus, Prisma } from "@trigger.dev/database";
+import { BatchTaskRunStatus, Prisma, RuntimeEnvironmentType } from "@trigger.dev/database";
+import { TriggerFailedTaskService } from "~/runEngine/services/triggerFailedTask.server";
 import { $replica, prisma } from "~/db.server";
 import { env } from "~/env.server";
 import { findEnvironmentById, findEnvironmentFromRun } from "~/models/runtimeEnvironment.server";
@@ -15,10 +16,14 @@ import { MetadataTooLargeError } from "~/utils/packets";
 import { TriggerTaskService } from "~/v3/services/triggerTask.server";
 import { tracer } from "~/v3/tracer.server";
 import { createExceptionPropertiesFromError } from "./eventRepository/common.server";
-import { recordRunDebugLog, resolveEventRepositoryForStore } from "./eventRepository/index.server";
+import {
+  recordRunDebugLog,
+  resolveEventRepositoryForStore,
+} from "./eventRepository/index.server";
 import { roomFromFriendlyRunId, socketIo } from "./handleSocketIo.server";
 import { engine } from "./runEngine.server";
 import { PerformTaskRunAlertsService } from "./services/alerts/performTaskRunAlerts.server";
+import { TaskRunErrorCodes } from "@trigger.dev/core/v3";
 
 export function registerRunEngineEventBusHandlers() {
   engine.eventBus.on("runSucceeded", async ({ time, run }) => {
@@ -413,9 +418,8 @@ export function registerRunEngineEventBusHandlers() {
         return;
       }
 
-      let retryMessage = `Retry ${
-        typeof run.attemptNumber === "number" ? `#${run.attemptNumber - 1}` : ""
-      } delay`;
+      let retryMessage = `Retry ${typeof run.attemptNumber === "number" ? `#${run.attemptNumber - 1}` : ""
+        } delay`;
 
       if (run.nextMachineAfterOOM) {
         retryMessage += ` after OOM`;
@@ -480,10 +484,10 @@ export function registerRunEngineEventBusHandlers() {
           error:
             e instanceof Error
               ? {
-                  name: e.name,
-                  message: e.message,
-                  stack: e.stack,
-                }
+                name: e.name,
+                message: e.message,
+                stack: e.stack,
+              }
               : e,
         });
       } else {
@@ -492,10 +496,10 @@ export function registerRunEngineEventBusHandlers() {
           error:
             e instanceof Error
               ? {
-                  name: e.name,
-                  message: e.message,
-                  stack: e.stack,
-                }
+                name: e.name,
+                message: e.message,
+                stack: e.stack,
+              }
               : e,
         });
       }
@@ -644,7 +648,7 @@ export function registerRunEngineEventBusHandlers() {
  */
 export function setupBatchQueueCallbacks() {
   // Item processing callback - creates a run for each batch item
-  engine.setBatchProcessItemCallback(async ({ batchId, friendlyId, itemIndex, item, meta }) => {
+  engine.setBatchProcessItemCallback(async ({ batchId, friendlyId, itemIndex, item, meta, attempt, isFinalAttempt }) => {
     return tracer.startActiveSpan(
       "batch.processItem",
       {
@@ -655,15 +659,64 @@ export function setupBatchQueueCallbacks() {
           "batch.task": item.task,
           "batch.environment_id": meta.environmentId,
           "batch.parent_run_id": meta.parentRunId ?? "",
+          "batch.attempt": attempt,
+          "batch.is_final_attempt": isFinalAttempt,
         },
       },
       async (span) => {
+        const triggerFailedTaskService = new TriggerFailedTaskService({
+          prisma,
+          engine,
+        });
+
+        // Check for pre-marked error items (e.g. oversized payloads)
+        const itemError = item.options?.__error as string | undefined;
+        if (itemError) {
+          const errorCode = (item.options?.__errorCode as string) ?? "ITEM_ERROR";
+
+          let environment: AuthenticatedEnvironment | undefined;
+          try {
+            environment = (await findEnvironmentById(meta.environmentId)) ?? undefined;
+          } catch {
+            // Best-effort environment lookup
+          }
+
+          if (environment) {
+            const failedRunId = await triggerFailedTaskService.call({
+              taskId: item.task,
+              environment,
+              payload: item.payload ?? "{}",
+              payloadType: item.payloadType as string,
+              errorMessage: itemError,
+              errorCode: errorCode as TaskRunErrorCodes,
+              parentRunId: meta.parentRunId,
+              resumeParentOnCompletion: meta.resumeParentOnCompletion,
+              batch: { id: batchId, index: itemIndex },
+              traceContext: meta.traceContext as Record<string, unknown> | undefined,
+              spanParentAsLink: meta.spanParentAsLink,
+            });
+
+            if (failedRunId) {
+              span.setAttribute("batch.result.pre_failed", true);
+              span.setAttribute("batch.result.run_id", failedRunId);
+              span.end();
+              return { success: true as const, runId: failedRunId };
+            }
+          }
+
+          // Fallback if TriggerFailedTaskService or environment lookup fails
+          span.end();
+          return { success: false as const, error: itemError, errorCode };
+        }
+
+        let environment: AuthenticatedEnvironment | undefined;
         try {
-          const environment = await findEnvironmentById(meta.environmentId);
+          environment = (await findEnvironmentById(meta.environmentId)) ?? undefined;
 
           if (!environment) {
             span.setAttribute("batch.result.error", "Environment not found");
             span.end();
+
             return {
               success: false as const,
               error: "Environment not found",
@@ -695,9 +748,10 @@ export function setupBatchQueueCallbacks() {
               spanParentAsLink: meta.spanParentAsLink,
               batchId,
               batchIndex: itemIndex,
-              skipChecks: true, // Already validated at batch level
               realtimeStreamsVersion: meta.realtimeStreamsVersion,
               planType: meta.planType,
+              triggerSource: meta.parentRunId ? "sdk" : meta.triggerSource ?? "api",
+              triggerAction: "trigger",
             },
             "V2"
           );
@@ -707,8 +761,44 @@ export function setupBatchQueueCallbacks() {
             span.end();
             return { success: true as const, runId: result.run.friendlyId };
           } else {
+            logger.error("[BatchQueue] TriggerTaskService returned undefined", {
+              batchId,
+              friendlyId,
+              itemIndex,
+              task: item.task,
+              environmentId: meta.environmentId,
+              attempt,
+              isFinalAttempt,
+            });
+
             span.setAttribute("batch.result.error", "TriggerTaskService returned undefined");
-            span.end();
+
+            // Only create a pre-failed run on the final attempt; otherwise let the retry mechanism handle it
+            if (isFinalAttempt) {
+              const failedRunId = await triggerFailedTaskService.call({
+                taskId: item.task,
+                environment,
+                payload: item.payload,
+                payloadType: item.payloadType as string,
+                errorMessage: "TriggerTaskService returned undefined",
+                parentRunId: meta.parentRunId,
+                resumeParentOnCompletion: meta.resumeParentOnCompletion,
+                batch: { id: batchId, index: itemIndex },
+                options: item.options as Record<string, unknown>,
+                traceContext: meta.traceContext as Record<string, unknown> | undefined,
+                spanParentAsLink: meta.spanParentAsLink,
+                errorCode: TaskRunErrorCodes.BATCH_ITEM_COULD_NOT_TRIGGER,
+              });
+
+              span.end();
+
+              if (failedRunId) {
+                return { success: true as const, runId: failedRunId };
+              }
+            } else {
+              span.end();
+            }
+
             return {
               success: false as const,
               error: "TriggerTaskService returned undefined",
@@ -716,15 +806,51 @@ export function setupBatchQueueCallbacks() {
             };
           }
         } catch (error) {
-          span.setAttribute(
-            "batch.result.error",
-            error instanceof Error ? error.message : String(error)
-          );
+          const errorMessage = error instanceof Error ? error.message : String(error);
+
+          logger.error("[BatchQueue] Failed to trigger batch item", {
+            batchId,
+            friendlyId,
+            itemIndex,
+            task: item.task,
+            environmentId: meta.environmentId,
+            attempt,
+            isFinalAttempt,
+            error,
+          });
+
+          span.setAttribute("batch.result.error", errorMessage);
           span.recordException(error instanceof Error ? error : new Error(String(error)));
-          span.end();
+
+          // Only create a pre-failed run on the final attempt; otherwise let the retry mechanism handle it
+          if (isFinalAttempt && environment) {
+            const failedRunId = await triggerFailedTaskService.call({
+              taskId: item.task,
+              environment,
+              payload: item.payload,
+              payloadType: item.payloadType as string,
+              errorMessage,
+              parentRunId: meta.parentRunId,
+              resumeParentOnCompletion: meta.resumeParentOnCompletion,
+              batch: { id: batchId, index: itemIndex },
+              options: item.options as Record<string, unknown>,
+              traceContext: meta.traceContext as Record<string, unknown> | undefined,
+              spanParentAsLink: meta.spanParentAsLink,
+              errorCode: TaskRunErrorCodes.BATCH_ITEM_COULD_NOT_TRIGGER,
+            });
+
+            span.end();
+
+            if (failedRunId) {
+              return { success: true as const, runId: failedRunId };
+            }
+          } else {
+            span.end();
+          }
+
           return {
             success: false as const,
-            error: error instanceof Error ? error.message : String(error),
+            error: errorMessage,
             errorCode: "TRIGGER_ERROR",
           };
         }
diff --git a/apps/webapp/app/v3/scheduleEngine.server.ts b/apps/webapp/app/v3/scheduleEngine.server.ts
index ef3cabe64df..4a12046a890 100644
--- a/apps/webapp/app/v3/scheduleEngine.server.ts
+++ b/apps/webapp/app/v3/scheduleEngine.server.ts
@@ -1,4 +1,5 @@
 import { ScheduleEngine } from "@internal/schedule-engine";
+import type { TriggerScheduledTaskErrorType } from "@internal/schedule-engine";
 import { stringifyIO } from "@trigger.dev/core/v3";
 import { prisma } from "~/db.server";
 import { env } from "~/env.server";
@@ -8,6 +9,7 @@ import { singleton } from "~/utils/singleton";
 import { TriggerTaskService } from "./services/triggerTask.server";
 import { meter, tracer } from "./tracer.server";
 import { workerQueue } from "~/services/worker.server";
+import { ServiceValidationError } from "./services/common.server";
 
 export const scheduleEngine = singleton("ScheduleEngine", createScheduleEngine);
 
@@ -106,14 +108,27 @@ function createScheduleEngine() {
             scheduleInstanceId,
             queueTimestamp: exactScheduleTime,
             overrideCreatedAt: exactScheduleTime,
+            triggerSource: "schedule",
+            triggerAction: "trigger",
           }
         );
 
         return { success: !!result };
       } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        let errorType: TriggerScheduledTaskErrorType = "SYSTEM_ERROR";
+
+        if (
+          error instanceof ServiceValidationError &&
+          errorMessage.includes("queue size limit for this environment has been reached")
+        ) {
+          errorType = "QUEUE_LIMIT";
+        }
+
         return {
           success: false,
-          error: error instanceof Error ? error.message : String(error),
+          error: errorMessage,
+          errorType,
         };
       }
     },
diff --git a/apps/webapp/app/v3/services/aiQueryService.server.ts b/apps/webapp/app/v3/services/aiQueryService.server.ts
new file mode 100644
index 00000000000..3e40fc810de
--- /dev/null
+++ b/apps/webapp/app/v3/services/aiQueryService.server.ts
@@ -0,0 +1,655 @@
+import { openai } from "@ai-sdk/openai";
+import {
+  parseTSQLSelect,
+  validateQuery,
+  type TableSchema,
+  type ValidationIssue,
+} from "@internal/tsql";
+import { streamText, type LanguageModelV1, tool } from "ai";
+import { z } from "zod";
+import type { AITimeFilter } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.query/types";
+
+// Re-export for backwards compatibility
+export type { AITimeFilter };
+
+/**
+ * Stream event types for AI query generation
+ */
+export type AIQueryStreamEvent =
+  | { type: "thinking"; content: string }
+  | { type: "tool_call"; tool: string; args: unknown }
+  | { type: "tool_result"; tool: string; result: unknown }
+  | { type: "time_filter"; filter: AITimeFilter }
+  | { type: "result"; success: true; query: string; timeFilter?: AITimeFilter }
+  | { type: "result"; success: false; error: string };
+
+/**
+ * Result type for non-streaming call
+ */
+export type AIQueryResult =
+  | { success: true; query: string; timeFilter?: AITimeFilter }
+  | { success: false; error: string };
+
+/**
+ * Options for query generation
+ */
+export interface AIQueryOptions {
+  mode?: "new" | "edit";
+  currentQuery?: string;
+}
+
+/**
+ * Validation result from the validateTSQLQuery tool
+ */
+interface QueryValidationResult {
+  valid: boolean;
+  syntaxError?: string;
+  issues: ValidationIssue[];
+}
+
+/**
+ * Service for generating TSQL queries from natural language using AI
+ */
+export class AIQueryService {
+  private pendingTimeFilter: AITimeFilter | undefined;
+
+  constructor(
+    private readonly tableSchema: TableSchema[],
+    private readonly model: LanguageModelV1 = openai("gpt-4.1-mini")
+  ) {}
+
+  /**
+   * Build the setTimeFilter tool definition
+   * Used by both streamQuery() and call() to keep behavior consistent
+   */
+  private buildSetTimeFilterTool() {
+    return tool({
+      description:
+        "Set the time filter for the query page UI instead of adding time conditions to the query. ALWAYS use this tool when the user wants to filter by time (e.g., 'last 7 days', 'past hour', 'yesterday'). The UI will apply this filter automatically using the table's time column (triggered_at for runs, bucket_start for metrics). Do NOT add triggered_at or bucket_start to the WHERE clause for time filtering - use this tool instead.",
+      parameters: z.object({
+        period: z
+          .string()
+          .optional()
+          .describe(
+            "Relative time period like '1m', '5m', '30m', '1h', '6h', '12h', '1d', '3d', '7d', '14d', '30d', '90d'. Use this for 'last X days/hours/minutes' requests."
+          ),
+        from: z
+          .string()
+          .optional()
+          .describe(
+            "ISO 8601 timestamp for the start of an absolute date range. Use with 'to' for specific date ranges."
+          ),
+        to: z
+          .string()
+          .optional()
+          .describe(
+            "ISO 8601 timestamp for the end of an absolute date range. Use with 'from' for specific date ranges."
+          ),
+      }),
+      execute: async ({ period, from, to }) => {
+        // Store the time filter so we can include it in the result
+        this.pendingTimeFilter = { period, from, to };
+        return {
+          success: true,
+          message: period
+            ? `Time filter set to: last ${period}`
+            : `Time filter set to: ${from ?? "start"} - ${to ?? "now"}`,
+        };
+      },
+    });
+  }
+
+  /**
+   * Generate a TSQL query from natural language, streaming the result
+   */
+  streamQuery(prompt: string, options: AIQueryOptions = {}) {
+    const { mode = "new", currentQuery } = options;
+    // Reset pending time filter for new request
+    this.pendingTimeFilter = undefined;
+
+    const schemaDescription = this.buildSchemaDescription();
+    const systemPrompt =
+      mode === "edit" && currentQuery
+        ? this.buildEditSystemPrompt(schemaDescription)
+        : this.buildSystemPrompt(schemaDescription);
+
+    // Build the user prompt based on mode
+    const userPrompt =
+      mode === "edit" && currentQuery ? this.buildEditUserPrompt(prompt, currentQuery) : prompt;
+
+    return streamText({
+      model: this.model,
+      system: systemPrompt,
+      prompt: userPrompt,
+      tools: {
+        validateTSQLQuery: tool({
+          description:
+            "Validate a TSQL query for syntax errors and schema compliance. Always use this tool to verify your query before returning it to the user.",
+          parameters: z.object({
+            query: z.string().describe("The TSQL query to validate"),
+          }),
+          execute: async ({ query }) => {
+            return this.validateQuery(query);
+          },
+        }),
+        getTableSchema: tool({
+          description:
+            "Get detailed schema information about available tables and columns. Use this to understand what data is available and how to query it.",
+          parameters: z.object({
+            tableName: z
+              .string()
+              .optional()
+              .describe("Optional: specific table name to get details for"),
+          }),
+          execute: async ({ tableName }) => {
+            return this.getSchemaInfo(tableName);
+          },
+        }),
+        setTimeFilter: this.buildSetTimeFilterTool(),
+      },
+      maxSteps: 5,
+      experimental_telemetry: {
+        isEnabled: true,
+        metadata: {
+          feature: "ai-query-generator",
+          mode,
+        },
+      },
+    });
+  }
+
+  /**
+   * Get the pending time filter (set by the AI during query generation)
+   */
+  getPendingTimeFilter(): AITimeFilter | undefined {
+    return this.pendingTimeFilter;
+  }
+
+  /**
+   * Generate a TSQL query from natural language (non-streaming)
+   */
+  async call(prompt: string, options: AIQueryOptions = {}): Promise<AIQueryResult> {
+    const { mode = "new", currentQuery } = options;
+    // Reset pending time filter for new request
+    this.pendingTimeFilter = undefined;
+
+    const schemaDescription = this.buildSchemaDescription();
+    const systemPrompt =
+      mode === "edit" && currentQuery
+        ? this.buildEditSystemPrompt(schemaDescription)
+        : this.buildSystemPrompt(schemaDescription);
+
+    // Build the user prompt based on mode
+    const userPrompt =
+      mode === "edit" && currentQuery ? this.buildEditUserPrompt(prompt, currentQuery) : prompt;
+
+    const result = await streamText({
+      model: this.model,
+      system: systemPrompt,
+      prompt: userPrompt,
+      tools: {
+        validateTSQLQuery: tool({
+          description:
+            "Validate a TSQL query for syntax errors and schema compliance. Always use this tool to verify your query before returning it to the user.",
+          parameters: z.object({
+            query: z.string().describe("The TSQL query to validate"),
+          }),
+          execute: async ({ query }) => {
+            return this.validateQuery(query);
+          },
+        }),
+        getTableSchema: tool({
+          description:
+            "Get detailed schema information about available tables and columns. Use this to understand what data is available and how to query it.",
+          parameters: z.object({
+            tableName: z
+              .string()
+              .optional()
+              .describe("Optional: specific table name to get details for"),
+          }),
+          execute: async ({ tableName }) => {
+            return this.getSchemaInfo(tableName);
+          },
+        }),
+        setTimeFilter: this.buildSetTimeFilterTool(),
+      },
+      maxSteps: 5,
+      experimental_telemetry: {
+        isEnabled: true,
+        metadata: {
+          feature: "ai-query-generator",
+          mode,
+        },
+      },
+    });
+
+    // Wait for the full response
+    const text = await result.text;
+
+    // Try to extract a valid query from the response
+    const query = this.extractQueryFromResponse(text);
+
+    if (query) {
+      // Validate the extracted query one more time
+      const validation = this.validateQuery(query);
+      if (validation.valid) {
+        return { success: true, query, timeFilter: this.pendingTimeFilter };
+      } else {
+        const errorMessages = validation.issues.map((i) => i.message).join("; ");
+        return {
+          success: false,
+          error: validation.syntaxError || errorMessages || "Query validation failed",
+        };
+      }
+    }
+
+    // If no query was found, check if there's an error message
+    if (text.toLowerCase().includes("cannot") || text.toLowerCase().includes("unable")) {
+      return { success: false, error: text.slice(0, 200) };
+    }
+
+    return { success: false, error: "Could not generate a valid query" };
+  }
+
+  /**
+   * Validate a TSQL query using the parser and validator
+   */
+  private validateQuery(query: string): QueryValidationResult {
+    try {
+      // First, try to parse the query
+      const ast = parseTSQLSelect(query);
+
+      // Then validate against the schema
+      const validationResult = validateQuery(ast, this.tableSchema);
+
+      return {
+        valid: validationResult.valid,
+        issues: validationResult.issues,
+      };
+    } catch (error) {
+      // Syntax error during parsing
+      return {
+        valid: false,
+        syntaxError: error instanceof Error ? error.message : String(error),
+        issues: [],
+      };
+    }
+  }
+
+  /**
+   * Get schema information for the AI
+   */
+  private getSchemaInfo(tableName?: string): {
+    tables: Array<{
+      name: string;
+      description?: string;
+      columns: Array<{
+        name: string;
+        type: string;
+        description?: string;
+        allowedValues?: string[];
+        example?: string;
+      }>;
+    }>;
+  } {
+    const tables = tableName
+      ? this.tableSchema.filter((t) => t.name.toLowerCase() === tableName?.toLowerCase())
+      : this.tableSchema;
+
+    return {
+      tables: tables.map((table) => ({
+        name: table.name,
+        description: table.description,
+        columns: Object.values(table.columns).map((col) => ({
+          name: col.name,
+          type: col.type,
+          description: col.description,
+          allowedValues: col.valueMap ? Object.values(col.valueMap) : col.allowedValues,
+          example: col.example,
+        })),
+      })),
+    };
+  }
+
+  /**
+   * Build a description of the schema for the system prompt
+   */
+  private buildSchemaDescription(): string {
+    const parts: string[] = [];
+
+    for (const table of this.tableSchema) {
+      parts.push(`## Table: ${table.name}`);
+      if (table.description) {
+        parts.push(table.description);
+      }
+      parts.push("");
+
+      // Identify core columns
+      const coreColumns = Object.values(table.columns)
+        .filter((col) => col.coreColumn === true)
+        .map((col) => col.name);
+      if (coreColumns.length > 0) {
+        parts.push(`Core columns (use these as defaults): ${coreColumns.join(", ")}`);
+        parts.push("");
+      }
+
+      parts.push("Columns:");
+
+      for (const col of Object.values(table.columns)) {
+        let colDesc = `- ${col.name} (${col.type})`;
+        if (col.coreColumn) {
+          colDesc += " [CORE]";
+        }
+        if (col.description) {
+          colDesc += `: ${col.description}`;
+        }
+        parts.push(colDesc);
+
+        // Add allowed values for enum-like columns
+        const allowedValues = col.valueMap ? Object.values(col.valueMap) : col.allowedValues;
+        if (allowedValues && allowedValues.length > 0 && allowedValues.length <= 20) {
+          parts.push(`  Allowed values: ${allowedValues.join(", ")}`);
+        }
+
+        // Add example if available
+        if (col.example) {
+          parts.push(`  Example: ${col.example}`);
+        }
+      }
+      parts.push("");
+    }
+
+    return parts.join("\n");
+  }
+
+  /**
+   * Build the system prompt for the AI
+   */
+  private buildSystemPrompt(schemaDescription: string): string {
+    return `You are an expert SQL assistant that generates TSQL queries for a task analytics system. TSQL is a SQL dialect similar to ClickHouse SQL.
+
+## Your Task
+Convert natural language requests into valid TSQL SELECT queries. Always validate your queries using the validateTSQLQuery tool before returning them.
+
+## Available Schema
+${schemaDescription}
+
+## Choosing the Right Table
+
+- **runs** — Task run records (status, timing, cost, output, etc.). Use for questions about runs, tasks, failures, durations, costs, queues.
+- **metrics** — Host and runtime metrics collected during task execution (CPU, memory). Use for questions about resource usage, CPU utilization, memory consumption, or performance monitoring. Each row is a 10-second aggregation bucket tied to a specific run.
+
+When the user mentions "CPU", "memory", "utilization", "resource usage", or similar terms, query the \`metrics\` table. When they mention "runs", "tasks", "failures", "status", "duration", or "cost", query the \`runs\` table.
+
+## TSQL Syntax Guide
+
+TSQL supports standard SQL syntax with some ClickHouse-specific features:
+
+### Basic SELECT
+\`\`\`sql
+SELECT column1, column2, ...
+FROM table_name
+WHERE conditions
+ORDER BY column [ASC|DESC]
+LIMIT n
+\`\`\`
+
+### Filtering (WHERE clause)
+- Comparison: =, !=, <, >, <=, >=
+- Logical: AND, OR, NOT
+- Pattern matching: LIKE, ILIKE (case-insensitive), NOT LIKE
+- Range: BETWEEN value1 AND value2
+- Set membership: IN ('value1', 'value2'), NOT IN (...)
+- Null checks: IS NULL, IS NOT NULL
+- Array contains: has(array_column, 'value')
+
+### Aggregations
+- count() - count rows
+- countIf(condition) - count rows matching condition
+- sum(column), sumIf(column, condition)
+- avg(column), min(column), max(column)
+- uniq(column) - approximate unique count
+- quantile(p)(column) - percentile (p between 0 and 1)
+- groupArray(column) - collect values into array
+
+### Grouping
+\`\`\`sql
+SELECT column, count() as cnt
+FROM table
+GROUP BY column
+HAVING cnt > 10
+\`\`\`
+
+### Date/Time Functions
+- timeBucket() - automatically bucket by time. Uses the table's time column and picks the best interval based on the query's time range. Use in SELECT and reference as \`timeBucket\` in GROUP BY / ORDER BY.
+- now() - current timestamp
+- today() - current date
+- toDate(datetime) - extract date
+- toStartOfDay/Hour/Minute(datetime)
+- dateDiff('unit', start, end) - difference in units (second, minute, hour, day, week, month, year)
+- INTERVAL n unit - time interval (e.g., INTERVAL 7 DAY)
+
+### Time Bucketing
+When the user wants to see data "over time", "by hour", "by day", or any time-series aggregation, prefer \`timeBucket()\` over manual \`toStartOfHour\`/\`toStartOfDay\` calls. \`timeBucket()\` automatically picks the right interval for the current time range.
+
+\`\`\`sql
+-- Runs over time (bucket size auto-selected)
+SELECT timeBucket(), count() AS run_count
+FROM runs
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000
+\`\`\`
+
+Only use explicit \`toStartOfHour\`/\`toStartOfDay\` etc. if the user specifically requests a particular bucket size (e.g., "group by hour", "bucket by day").
+
+### Common Patterns
+
+#### Runs table
+- Status filter: WHERE status = 'Failed' or WHERE status IN ('Failed', 'Crashed')
+- Time filtering: Use the \`setTimeFilter\` tool (NOT triggered_at/bucket_start in WHERE clause)
+
+#### Metrics table
+- Filter by metric name: WHERE metric_name = 'process.cpu.utilization'
+- Filter by run: WHERE run_id = 'run_abc123'
+- Filter by task: WHERE task_identifier = 'my-task'
+- Available metric names: process.cpu.utilization, process.cpu.time, process.memory.usage, system.memory.usage, system.memory.utilization, system.network.io, system.network.dropped, system.network.errors, nodejs.event_loop.utilization, nodejs.event_loop.delay.p95, nodejs.event_loop.delay.max, nodejs.heap.used, nodejs.heap.total
+- Use \`metric_value\` — the metric's observed value
+- Use prettyFormat(expr, 'bytes') to tell the UI to format values as bytes (e.g., "1.50 GiB") — keeps values numeric for charts
+- Use prettyFormat(expr, 'percent') for percentage values
+- prettyFormat does NOT change the SQL — it only adds a display hint
+- Available format types: bytes, decimalBytes, percent, quantity, duration, durationSeconds, costInDollars
+- For memory metrics (including nodejs.heap.*), always use prettyFormat with 'bytes'
+- For CPU utilization, consider prettyFormat with 'percent'
+
+\`\`\`sql
+-- CPU utilization over time for a task
+SELECT timeBucket(), task_identifier, prettyFormat(avg(metric_value), 'percent') AS avg_cpu
+FROM metrics
+WHERE metric_name = 'process.cpu.utilization'
+GROUP BY timeBucket, task_identifier
+ORDER BY timeBucket
+LIMIT 1000
+\`\`\`
+
+\`\`\`sql
+-- Peak memory usage per run
+SELECT run_id, task_identifier, prettyFormat(max(metric_value), 'bytes') AS peak_memory
+FROM metrics
+WHERE metric_name = 'process.memory.usage'
+GROUP BY run_id, task_identifier
+ORDER BY peak_memory DESC
+LIMIT 100
+\`\`\`
+
+## Important Rules
+
+1. NEVER use SELECT * - ClickHouse is a columnar database where SELECT * has very poor performance
+2. Always select only the specific columns needed for the request
+3. When column selection is ambiguous, use the core columns marked [CORE] in the schema
+4. **TIME FILTERING**: When the user wants to filter by time (e.g., "last 7 days", "past hour", "yesterday"), ALWAYS use the \`setTimeFilter\` tool instead of adding time conditions to the WHERE clause. The UI has a time filter that will apply this automatically. This applies to both the \`runs\` table (triggered_at) and the \`metrics\` table (bucket_start).
+5. Do NOT add \`triggered_at\` or \`bucket_start\` to WHERE clauses for time filtering - use \`setTimeFilter\` tool instead. If the user doesn't specify a time period, do NOT add any time filter (the UI defaults to 7 days).
+6. **TIME BUCKETING**: When the user wants to see data over time or in time buckets, use \`timeBucket()\` in SELECT and reference it as \`timeBucket\` in GROUP BY / ORDER BY. Only use manual bucketing functions (toStartOfHour, toStartOfDay, etc.) when the user explicitly requests a specific bucket size.
+7. ALWAYS use the validateTSQLQuery tool to check your query before returning it
+8. If validation fails, fix the issues and try again (up to 3 attempts)
+9. Use column names exactly as defined in the schema (case-sensitive)
+10. For enum columns like status, use the allowed values shown in the schema
+11. Always include a LIMIT clause (default to 100 if not specified)
+12. Use meaningful column aliases with AS for aggregations
+13. Format queries with proper indentation for readability
+
+## Response Format
+
+After validating successfully, return ONLY the SQL query wrapped in a code block:
+
+\`\`\`sql
+SELECT ...
+FROM ...
+\`\`\`
+
+If you cannot generate a valid query, explain why briefly.`;
+  }
+
+  /**
+   * Build the system prompt for edit mode
+   */
+  private buildEditSystemPrompt(schemaDescription: string): string {
+    return `You are an expert SQL assistant that modifies existing TSQL queries for a task analytics system. TSQL is a SQL dialect similar to ClickHouse SQL.
+
+## Your Task
+Modify the provided TSQL query according to the user's instructions. Make only the changes requested - preserve the existing query structure where possible.
+
+## Available Schema
+${schemaDescription}
+
+## Choosing the Right Table
+
+- **runs** — Task run records (status, timing, cost, output, etc.). Use for questions about runs, tasks, failures, durations, costs, queues.
+- **metrics** — Host and runtime metrics collected during task execution (CPU, memory). Use for questions about resource usage, CPU utilization, memory consumption, or performance monitoring. Each row is a 10-second aggregation bucket tied to a specific run.
+
+## TSQL Syntax Guide
+
+TSQL supports standard SQL syntax with some ClickHouse-specific features:
+
+### Basic SELECT
+\`\`\`sql
+SELECT column1, column2, ...
+FROM table_name
+WHERE conditions
+ORDER BY column [ASC|DESC]
+LIMIT n
+\`\`\`
+
+### Filtering (WHERE clause)
+- Comparison: =, !=, <, >, <=, >=
+- Logical: AND, OR, NOT
+- Pattern matching: LIKE, ILIKE (case-insensitive), NOT LIKE
+- Range: BETWEEN value1 AND value2
+- Set membership: IN ('value1', 'value2'), NOT IN (...)
+- Null checks: IS NULL, IS NOT NULL
+- Array contains: has(array_column, 'value')
+
+### Aggregations
+- count() - count rows
+- countIf(condition) - count rows matching condition
+- sum(column), sumIf(column, condition)
+- avg(column), min(column), max(column)
+- uniq(column) - approximate unique count
+- quantile(p)(column) - percentile (p between 0 and 1)
+- groupArray(column) - collect values into array
+
+### Grouping
+\`\`\`sql
+SELECT column, count() as cnt
+FROM table
+GROUP BY column
+HAVING cnt > 10
+\`\`\`
+
+### Date/Time Functions
+- timeBucket() - automatically bucket by time. Uses the table's time column and picks the best interval based on the query's time range. Use in SELECT and reference as \`timeBucket\` in GROUP BY / ORDER BY.
+- now() - current timestamp
+- today() - current date
+- toDate(datetime) - extract date
+- toStartOfDay/Hour/Minute(datetime)
+- dateDiff('unit', start, end) - difference in units (second, minute, hour, day, week, month, year)
+- INTERVAL n unit - time interval (e.g., INTERVAL 7 DAY)
+
+### Time Bucketing
+When the user wants to see data "over time", "by hour", "by day", or any time-series aggregation, prefer \`timeBucket()\` over manual \`toStartOfHour\`/\`toStartOfDay\` calls unless the user specifically requests a particular bucket size.
+
+\`\`\`sql
+SELECT timeBucket(), count() AS run_count
+FROM runs
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000
+\`\`\`
+
+### Common Metrics Patterns
+- Filter by metric: WHERE metric_name = 'process.cpu.utilization'
+- Available metric names: process.cpu.utilization, process.cpu.time, process.memory.usage, system.memory.usage, system.memory.utilization, system.network.io, system.network.dropped, system.network.errors, nodejs.event_loop.utilization, nodejs.event_loop.delay.p50, nodejs.event_loop.delay.p99, nodejs.event_loop.delay.max, nodejs.heap.used, nodejs.heap.total
+- Use \`metric_value\` — the metric's observed value
+- Use prettyFormat(expr, 'bytes') for memory metrics (including nodejs.heap.*), prettyFormat(expr, 'percent') for CPU utilization
+- prettyFormat does NOT change the SQL — it only adds a display hint for the UI
+
+## Important Rules
+
+1. NEVER use SELECT * - ClickHouse is a columnar database where SELECT * has very poor performance
+2. If the existing query uses SELECT *, replace it with specific columns (use core columns marked [CORE] as defaults)
+3. **TIME FILTERING**: When the user wants to change time filtering (e.g., "change to last 30 days"), use the \`setTimeFilter\` tool instead of modifying time column conditions. If the existing query has \`triggered_at\` or \`bucket_start\` in WHERE for time filtering, consider removing it and using \`setTimeFilter\` instead.
+4. **TIME BUCKETING**: When adding time-series grouping, use \`timeBucket()\` in SELECT and reference it as \`timeBucket\` in GROUP BY / ORDER BY. Only use manual bucketing functions (toStartOfHour, toStartOfDay, etc.) when the user explicitly requests a specific bucket size.
+5. ALWAYS use the validateTSQLQuery tool to check your modified query before returning it
+6. If validation fails, fix the issues and try again (up to 3 attempts)
+7. Use column names exactly as defined in the schema (case-sensitive)
+8. For enum columns like status, use the allowed values shown in the schema
+9. Always include a LIMIT clause (default to 100 if not specified)
+10. Preserve the user's existing query structure and style where possible
+11. Only make the changes specifically requested by the user
+
+## Response Format
+
+After validating successfully, return ONLY the modified SQL query wrapped in a code block:
+
+\`\`\`sql
+SELECT ...
+FROM ...
+\`\`\`
+
+If you cannot make the requested modification, explain why briefly.`;
+  }
+
+  /**
+   * Build the user prompt for edit mode
+   */
+  private buildEditUserPrompt(userRequest: string, currentQuery: string): string {
+    return `Here is the current TSQL query:
+
+\`\`\`sql
+${currentQuery}
+\`\`\`
+
+Please modify this query according to the following instructions:
+
+${userRequest}`;
+  }
+
+  /**
+   * Extract a SQL query from the AI response text
+   */
+  private extractQueryFromResponse(text: string): string | null {
+    // Try to extract from code block first
+    const codeBlockMatch = text.match(/```(?:sql)?\s*([\s\S]*?)```/i);
+    if (codeBlockMatch) {
+      return codeBlockMatch[1].trim();
+    }
+
+    // Try to find a SELECT statement
+    const selectMatch = text.match(/SELECT[\s\S]+?(?:LIMIT\s+\d+|;|$)/i);
+    if (selectMatch) {
+      return selectMatch[0].trim().replace(/;$/, "");
+    }
+
+    return null;
+  }
+}
diff --git a/apps/webapp/app/v3/services/aiQueryTitleService.server.ts b/apps/webapp/app/v3/services/aiQueryTitleService.server.ts
new file mode 100644
index 00000000000..983f732453a
--- /dev/null
+++ b/apps/webapp/app/v3/services/aiQueryTitleService.server.ts
@@ -0,0 +1,71 @@
+import { openai } from "@ai-sdk/openai";
+import { generateText, type LanguageModelV1 } from "ai";
+import { env } from "~/env.server";
+
+/**
+ * Result type for title generation
+ */
+export type AIQueryTitleResult =
+  | { success: true; title: string }
+  | { success: false; error: string };
+
+/**
+ * Service for generating concise titles for SQL queries using AI
+ */
+export class AIQueryTitleService {
+  constructor(private readonly model: LanguageModelV1 = openai("gpt-4o-mini")) {}
+
+  /**
+   * Generate a concise title for a SQL query
+   */
+  async generateTitle(query: string): Promise<AIQueryTitleResult> {
+    if (!env.OPENAI_API_KEY) {
+      return { success: false, error: "OpenAI API key is not configured" };
+    }
+
+    try {
+      const result = await generateText({
+        model: this.model,
+        system: `You are a helpful assistant that generates concise titles for SQL queries.
+
+Your task is to create a short, descriptive title (5-10 words) that summarizes what the query does.
+
+Guidelines:
+- Focus on the main purpose/intent of the query
+- Use plain language, not technical SQL terms
+- Start with an action verb when appropriate (e.g., "Count", "List", "Show", "Find")
+- Be specific about what data is being retrieved
+- Do not include quotes around the title
+- Do not include punctuation at the end
+
+Examples:
+- "Failed runs by hour over 7 days"
+- "Top 50 most expensive task runs"
+- "Run counts grouped by status"
+- "Average execution time by task"
+- "Recent runs with errors"`,
+        prompt: `Generate a concise title for this SQL query:\n\n${query}`,
+        maxTokens: 50,
+        experimental_telemetry: {
+          isEnabled: true,
+          metadata: {
+            feature: "ai-query-title",
+          },
+        },
+      });
+
+      const title = result.text.trim();
+
+      if (!title) {
+        return { success: false, error: "No title generated" };
+      }
+
+      return { success: true, title };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to generate title",
+      };
+    }
+  }
+}
diff --git a/apps/webapp/app/v3/services/alerts/createAlertChannel.server.ts b/apps/webapp/app/v3/services/alerts/createAlertChannel.server.ts
index b2bbb423983..3b0a3a13360 100644
--- a/apps/webapp/app/v3/services/alerts/createAlertChannel.server.ts
+++ b/apps/webapp/app/v3/services/alerts/createAlertChannel.server.ts
@@ -1,12 +1,13 @@
 import {
-  ProjectAlertChannel,
-  ProjectAlertType,
-  RuntimeEnvironmentType,
+  type ProjectAlertChannel,
+  type ProjectAlertType,
+  type RuntimeEnvironmentType,
 } from "@trigger.dev/database";
 import { nanoid } from "nanoid";
 import { env } from "~/env.server";
 import { findProjectByRef } from "~/models/project.server";
 import { encryptSecret } from "~/services/secrets/secretStore.server";
+import { alertsWorker } from "~/v3/alertsWorker.server";
 import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
 import { BaseService, ServiceValidationError } from "../baseService.server";
 
@@ -60,7 +61,7 @@ export class CreateAlertChannelService extends BaseService {
       : undefined;
 
     if (existingAlertChannel) {
-      return await this._prisma.projectAlertChannel.update({
+      const updated = await this._prisma.projectAlertChannel.update({
         where: { id: existingAlertChannel.id },
         data: {
           name: options.name,
@@ -68,8 +69,15 @@ export class CreateAlertChannelService extends BaseService {
           type: options.channel.type,
           properties: await this.#createProperties(options.channel),
           environmentTypes,
+          enabled: true,
         },
       });
+
+      if (options.alertTypes.includes("ERROR_GROUP")) {
+        await this.#scheduleErrorAlertEvaluation(project.id);
+      }
+
+      return updated;
     }
 
     const alertChannel = await this._prisma.projectAlertChannel.create({
@@ -87,9 +95,24 @@ export class CreateAlertChannelService extends BaseService {
       },
     });
 
+    if (options.alertTypes.includes("ERROR_GROUP")) {
+      await this.#scheduleErrorAlertEvaluation(project.id);
+    }
+
     return alertChannel;
   }
 
+  async #scheduleErrorAlertEvaluation(projectId: string): Promise<void> {
+    await alertsWorker.enqueue({
+      id: `evaluateErrorAlerts:${projectId}`,
+      job: "v3.evaluateErrorAlerts",
+      payload: {
+        projectId,
+        scheduledAt: Date.now(),
+      },
+    });
+  }
+
   async #createProperties(channel: CreateAlertChannelOptions["channel"]) {
     switch (channel.type) {
       case "EMAIL":
diff --git a/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts b/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
index a27d7380942..5ab99bf8046 100644
--- a/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
+++ b/apps/webapp/app/v3/services/alerts/deliverAlert.server.ts
@@ -22,6 +22,7 @@ import { environmentTitle } from "~/components/environments/EnvironmentLabel";
 import { type Prisma, type prisma, type PrismaClientOrTransaction } from "~/db.server";
 import { env } from "~/env.server";
 import {
+  isIntegrationForService,
   type OrganizationIntegrationForService,
   OrgIntegrationRepository,
 } from "~/models/orgIntegration.server";
@@ -32,14 +33,20 @@ import {
   ProjectAlertWebhookProperties,
 } from "~/models/projectAlert.server";
 import { ApiRetrieveRunPresenter } from "~/presenters/v3/ApiRetrieveRunPresenter.server";
+import {
+  processGitMetadata,
+  type GitMetaLinks,
+} from "~/presenters/v3/BranchesPresenter.server";
 import { DeploymentPresenter } from "~/presenters/v3/DeploymentPresenter.server";
 import { sendAlertEmail } from "~/services/email.server";
+import { VercelProjectIntegrationDataSchema } from "~/v3/vercel/vercelProjectIntegrationSchema";
 import { logger } from "~/services/logger.server";
 import { decryptSecret } from "~/services/secrets/secretStore.server";
 import { v3RunPath } from "~/utils/pathBuilder";
 import { alertsRateLimiter } from "~/v3/alertsRateLimiter.server";
 import { alertsWorker } from "~/v3/alertsWorker.server";
 import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
+import { fromPromise } from "neverthrow";
 import { BaseService } from "../baseService.server";
 import { CURRENT_API_VERSION } from "~/api/versions";
 
@@ -88,6 +95,11 @@ type FoundAlert = Prisma.Result<
 
 class SkipRetryError extends Error {}
 
+type DeploymentIntegrationMetadata = {
+  git: GitMetaLinks | null;
+  vercelDeploymentUrl: string | undefined;
+};
+
 export class DeliverAlertService extends BaseService {
   public async call(alertId: string) {
     const alert: FoundAlert | null = await this._prisma.projectAlert.findFirst({
@@ -138,18 +150,27 @@ export class DeliverAlertService extends BaseService {
       return;
     }
 
+    const emptyMeta: DeploymentIntegrationMetadata = { git: null, vercelDeploymentUrl: undefined };
+
+    const deploymentMeta =
+      alert.type === "DEPLOYMENT_SUCCESS" || alert.type === "DEPLOYMENT_FAILURE"
+        ? (
+            await fromPromise(this.#resolveDeploymentMetadata(alert), (e) => e)
+          ).unwrapOr(emptyMeta)
+        : emptyMeta;
+
     try {
       switch (alert.channel.type) {
         case "EMAIL": {
-          await this.#sendEmail(alert);
+          await this.#sendEmail(alert, deploymentMeta);
           break;
         }
         case "SLACK": {
-          await this.#sendSlack(alert);
+          await this.#sendSlack(alert, deploymentMeta);
           break;
         }
         case "WEBHOOK": {
-          await this.#sendWebhook(alert);
+          await this.#sendWebhook(alert, deploymentMeta);
           break;
         }
         default: {
@@ -176,7 +197,7 @@ export class DeliverAlertService extends BaseService {
     });
   }
 
-  async #sendEmail(alert: FoundAlert) {
+  async #sendEmail(alert: FoundAlert, deploymentMeta: DeploymentIntegrationMetadata) {
     const emailProperties = ProjectAlertEmailProperties.safeParse(alert.channel.properties);
 
     if (!emailProperties.success) {
@@ -242,6 +263,19 @@ export class DeliverAlertService extends BaseService {
             error: preparedError,
             deploymentLink: `${env.APP_ORIGIN}/projects/v3/${alert.project.externalRef}/deployments/${alert.workerDeployment.shortCode}`,
             organization: alert.project.organization.title,
+            git: deploymentMeta.git
+              ? {
+                  branchName: deploymentMeta.git.branchName,
+                  shortSha: deploymentMeta.git.shortSha,
+                  commitMessage: deploymentMeta.git.commitMessage,
+                  commitUrl: deploymentMeta.git.commitUrl,
+                  branchUrl: deploymentMeta.git.branchUrl,
+                  pullRequestNumber: deploymentMeta.git.pullRequestNumber,
+                  pullRequestTitle: deploymentMeta.git.pullRequestTitle,
+                  pullRequestUrl: deploymentMeta.git.pullRequestUrl,
+                }
+              : undefined,
+            vercelDeploymentUrl: deploymentMeta.vercelDeploymentUrl,
           });
         } else {
           logger.error("[DeliverAlert] Worker deployment not found", {
@@ -263,6 +297,19 @@ export class DeliverAlertService extends BaseService {
             deploymentLink: `${env.APP_ORIGIN}/projects/v3/${alert.project.externalRef}/deployments/${alert.workerDeployment.shortCode}`,
             taskCount: alert.workerDeployment.worker?.tasks.length ?? 0,
             organization: alert.project.organization.title,
+            git: deploymentMeta.git
+              ? {
+                  branchName: deploymentMeta.git.branchName,
+                  shortSha: deploymentMeta.git.shortSha,
+                  commitMessage: deploymentMeta.git.commitMessage,
+                  commitUrl: deploymentMeta.git.commitUrl,
+                  branchUrl: deploymentMeta.git.branchUrl,
+                  pullRequestNumber: deploymentMeta.git.pullRequestNumber,
+                  pullRequestTitle: deploymentMeta.git.pullRequestTitle,
+                  pullRequestUrl: deploymentMeta.git.pullRequestUrl,
+                }
+              : undefined,
+            vercelDeploymentUrl: deploymentMeta.vercelDeploymentUrl,
           });
         } else {
           logger.error("[DeliverAlert] Worker deployment not found", {
@@ -272,13 +319,16 @@ export class DeliverAlertService extends BaseService {
 
         break;
       }
+      case "ERROR_GROUP": {
+        break;
+      }
       default: {
         assertNever(alert.type);
       }
     }
   }
 
-  async #sendWebhook(alert: FoundAlert) {
+  async #sendWebhook(alert: FoundAlert, deploymentMeta: DeploymentIntegrationMetadata) {
     const webhookProperties = ProjectAlertWebhookProperties.safeParse(alert.channel.properties);
 
     if (!webhookProperties.success) {
@@ -451,6 +501,8 @@ export class DeliverAlertService extends BaseService {
                   name: alert.project.name,
                 },
                 error: preparedError,
+                git: this.#buildWebhookGitObject(deploymentMeta.git),
+                vercel: this.#buildWebhookVercelObject(deploymentMeta.vercelDeploymentUrl),
               };
 
               await this.#deliverWebhook(payload, webhookProperties.data);
@@ -487,6 +539,8 @@ export class DeliverAlertService extends BaseService {
                     name: alert.project.name,
                   },
                   error: preparedError,
+                  git: this.#buildWebhookGitObject(deploymentMeta.git),
+                  vercel: this.#buildWebhookVercelObject(deploymentMeta.vercelDeploymentUrl),
                 },
               };
 
@@ -541,6 +595,8 @@ export class DeliverAlertService extends BaseService {
                   slug: alert.project.slug,
                   name: alert.project.name,
                 },
+                git: this.#buildWebhookGitObject(deploymentMeta.git),
+                vercel: this.#buildWebhookVercelObject(deploymentMeta.vercelDeploymentUrl),
               };
 
               await this.#deliverWebhook(payload, webhookProperties.data);
@@ -583,6 +639,8 @@ export class DeliverAlertService extends BaseService {
                     slug: alert.project.slug,
                     name: alert.project.name,
                   },
+                  git: this.#buildWebhookGitObject(deploymentMeta.git),
+                  vercel: this.#buildWebhookVercelObject(deploymentMeta.vercelDeploymentUrl),
                 },
               };
 
@@ -602,13 +660,16 @@ export class DeliverAlertService extends BaseService {
 
         break;
       }
+      case "ERROR_GROUP": {
+        break;
+      }
       default: {
         assertNever(alert.type);
       }
     }
   }
 
-  async #sendSlack(alert: FoundAlert) {
+  async #sendSlack(alert: FoundAlert, deploymentMeta: DeploymentIntegrationMetadata) {
     const slackProperties = ProjectAlertSlackProperties.safeParse(alert.channel.properties);
 
     if (!slackProperties.success) {
@@ -644,7 +705,7 @@ export class DeliverAlertService extends BaseService {
           },
         });
 
-    if (!integration) {
+    if (!integration || !isIntegrationForService(integration, "SLACK")) {
       logger.error("[DeliverAlert] Slack integration not found", {
         alert,
       });
@@ -693,9 +754,7 @@ export class DeliverAlertService extends BaseService {
                 type: "section",
                 text: {
                   type: "mrkdwn",
-                  text: `:rotating_light: Error in *${taskIdentifier}* _<!date^${Math.round(
-                    timestamp.getTime() / 1000
-                  )}^at {date_num} {time_secs}|${timestamp.toLocaleString()}>_`,
+                  text: `:rotating_light: Error in *${taskIdentifier}*`,
                 },
               },
               {
@@ -705,18 +764,7 @@ export class DeliverAlertService extends BaseService {
                   text: this.#wrapInCodeBlock(error.stackTrace ?? error.message),
                 },
               },
-              {
-                type: "context",
-                elements: [
-                  {
-                    type: "mrkdwn",
-                    text: `${runId} | ${taskIdentifier} | ${version}.${environment} | ${alert.project.name}`,
-                  },
-                ],
-              },
-              {
-                type: "divider",
-              },
+              this.#buildRunQuoteBlock(taskIdentifier, version, environment, runId, alert.project.name, timestamp),
               {
                 type: "actions",
                 elements: [
@@ -788,14 +836,13 @@ export class DeliverAlertService extends BaseService {
 
           await this.#postSlackMessage(integration, {
             channel: slackProperties.data.channelId,
+            text: `:rotating_light: Deployment failed *${version}.${environment}*`,
             blocks: [
               {
                 type: "section",
                 text: {
                   type: "mrkdwn",
-                  text: `:rotating_light: Deployment failed *${version}.${environment}* _<!date^${Math.round(
-                    timestamp.getTime() / 1000
-                  )}^at {date_num} {time_secs}|${timestamp.toLocaleString()}>_`,
+                  text: `:rotating_light: Deployment failed *${version}.${environment}*`,
                 },
               },
               {
@@ -805,15 +852,7 @@ export class DeliverAlertService extends BaseService {
                   text: this.#wrapInCodeBlock(preparedError.stack ?? preparedError.message),
                 },
               },
-              {
-                type: "context",
-                elements: [
-                  {
-                    type: "mrkdwn",
-                    text: `${alert.workerDeployment.shortCode} | ${version}.${environment} | ${alert.project.name}`,
-                  },
-                ],
-              },
+              this.#buildDeploymentQuoteBlock(alert, deploymentMeta, version, environment, timestamp),
               {
                 type: "actions",
                 elements: [
@@ -841,7 +880,6 @@ export class DeliverAlertService extends BaseService {
         if (alert.workerDeployment) {
           const version = alert.workerDeployment.version;
           const environment = alert.environment.slug;
-          const numberOfTasks = alert.workerDeployment.worker?.tasks.length ?? 0;
           const timestamp = alert.workerDeployment.deployedAt ?? new Date();
 
           await this.#postSlackMessage(integration, {
@@ -852,20 +890,10 @@ export class DeliverAlertService extends BaseService {
                 type: "section",
                 text: {
                   type: "mrkdwn",
-                  text: `:rocket: Deployed *${version}.${environment}* successfully _<!date^${Math.round(
-                    timestamp.getTime() / 1000
-                  )}^at {date_num} {time_secs}|${timestamp.toLocaleString()}>_`,
+                  text: `:rocket: Deployed *${version}.${environment}* successfully`,
                 },
               },
-              {
-                type: "context",
-                elements: [
-                  {
-                    type: "mrkdwn",
-                    text: `${numberOfTasks} tasks | ${alert.workerDeployment.shortCode} | ${version}.${environment} | ${alert.project.name}`,
-                  },
-                ],
-              },
+              this.#buildDeploymentQuoteBlock(alert, deploymentMeta, version, environment, timestamp),
               {
                 type: "actions",
                 elements: [
@@ -891,6 +919,9 @@ export class DeliverAlertService extends BaseService {
           return;
         }
       }
+      case "ERROR_GROUP": {
+        break;
+      }
       default: {
         assertNever(alert.type);
       }
@@ -948,7 +979,11 @@ export class DeliverAlertService extends BaseService {
     );
 
     try {
-      return await client.chat.postMessage(message);
+      return await client.chat.postMessage({
+        ...message,
+        unfurl_links: false,
+        unfurl_media: false,
+      });
     } catch (error) {
       if (isWebAPIRateLimitedError(error)) {
         logger.warn("[DeliverAlert] Slack rate limited", {
@@ -1012,6 +1047,174 @@ export class DeliverAlertService extends BaseService {
     }
   }
 
+  async #resolveDeploymentMetadata(
+    alert: FoundAlert
+  ): Promise<DeploymentIntegrationMetadata> {
+    const deployment = alert.workerDeployment;
+    if (!deployment) {
+      return { git: null, vercelDeploymentUrl: undefined };
+    }
+
+    const git = processGitMetadata(deployment.git);
+    const vercelDeploymentUrl = await this.#resolveVercelDeploymentUrl(
+      deployment.projectId,
+      deployment.id
+    );
+
+    return { git, vercelDeploymentUrl };
+  }
+
+  async #resolveVercelDeploymentUrl(
+    projectId: string,
+    deploymentId: string
+  ): Promise<string | undefined> {
+    const vercelProjectIntegration =
+      await this._prisma.organizationProjectIntegration.findFirst({
+        where: {
+          projectId,
+          deletedAt: null,
+          organizationIntegration: {
+            service: "VERCEL",
+            deletedAt: null,
+          },
+        },
+        select: {
+          integrationData: true,
+        },
+      });
+
+    if (!vercelProjectIntegration) {
+      return undefined;
+    }
+
+    const parsed = VercelProjectIntegrationDataSchema.safeParse(
+      vercelProjectIntegration.integrationData
+    );
+
+    if (!parsed.success || !parsed.data.vercelTeamSlug) {
+      return undefined;
+    }
+
+    const integrationDeployment =
+      await this._prisma.integrationDeployment.findFirst({
+        where: {
+          deploymentId,
+          integrationName: "vercel",
+        },
+        select: {
+          integrationDeploymentId: true,
+        },
+        orderBy: {
+          createdAt: "desc",
+        },
+      });
+
+    if (!integrationDeployment) {
+      return undefined;
+    }
+
+    const vercelId = integrationDeployment.integrationDeploymentId.replace(/^dpl_/, "");
+    return `https://vercel.com/${parsed.data.vercelTeamSlug}/${parsed.data.vercelProjectName}/${vercelId}`;
+  }
+
+  #buildDeploymentQuoteBlock(
+    alert: FoundAlert,
+    deploymentMeta: DeploymentIntegrationMetadata,
+    version: string,
+    environment: string,
+    timestamp: Date
+  ) {
+    const git = deploymentMeta.git;
+    const shortCode = alert.workerDeployment!.shortCode;
+    const lines: string[] = [];
+
+    // Line 1: git author + branch (if available)
+    if (git) {
+      lines.push(`> By *${git.commitAuthor}* on <${git.branchUrl}|\`${git.branchName}\`>`);
+    }
+
+    // Line 2: deployment info
+    lines.push(`> ${shortCode} | ${version}.${environment} | ${alert.project.name} `);
+
+    // Line 3: provider + commit link + vercel link (conditional parts)
+    const integrationParts: string[] = [];
+    if (git?.provider === "github") {
+      integrationParts.push(`via GitHub | <${git.commitUrl}|${git.shortSha}>`);
+    }
+    if (deploymentMeta.vercelDeploymentUrl) {
+      integrationParts.push(`with <${deploymentMeta.vercelDeploymentUrl}|Vercel>`);
+    }
+    if (integrationParts.length > 0) {
+      lines.push(`> ${integrationParts.join(" | ")} `);
+    }
+
+    // Line 4: timestamp
+    lines.push(`> ${this.#formatTimestamp(timestamp)}`);
+
+    return {
+      type: "context" as const,
+      elements: [
+        {
+          type: "mrkdwn" as const,
+          text: lines.join("\n"),
+        },
+      ],
+    };
+  }
+
+  #buildRunQuoteBlock(
+    taskIdentifier: string,
+    version: string,
+    environment: string,
+    runId: string,
+    projectName: string,
+    timestamp: Date
+  ) {
+    return {
+      type: "context" as const,
+      elements: [
+        {
+          type: "mrkdwn" as const,
+          text: `> *${taskIdentifier}* | ${version}.${environment}\n> ${runId} | ${projectName}\n> ${this.#formatTimestamp(timestamp)}`,
+        },
+      ],
+    };
+  }
+
+  #formatTimestamp(date: Date): string {
+    return new Intl.DateTimeFormat("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: true,
+    }).format(date);
+  }
+
+  #buildWebhookGitObject(git: GitMetaLinks | null) {
+    if (!git) return undefined;
+
+    return {
+      branch: git.branchName,
+      commitSha: git.shortSha,
+      commitMessage: git.commitMessage,
+      commitUrl: git.commitUrl,
+      branchUrl: git.branchUrl,
+      pullRequestNumber: git.pullRequestNumber,
+      pullRequestTitle: git.pullRequestTitle,
+      pullRequestUrl: git.pullRequestUrl,
+      provider: git.provider,
+    };
+  }
+
+  #buildWebhookVercelObject(url: string | undefined) {
+    if (!url) return undefined;
+
+    return { deploymentUrl: url };
+  }
+
   #getRunError(alert: FoundAlert): TaskRunError {
     if (alert.taskRun) {
       const res = TaskRunError.safeParse(alert.taskRun.error);
diff --git a/apps/webapp/app/v3/services/alerts/deliverErrorGroupAlert.server.ts b/apps/webapp/app/v3/services/alerts/deliverErrorGroupAlert.server.ts
new file mode 100644
index 00000000000..422811cdee3
--- /dev/null
+++ b/apps/webapp/app/v3/services/alerts/deliverErrorGroupAlert.server.ts
@@ -0,0 +1,404 @@
+import {
+  type ChatPostMessageArguments,
+  ErrorCode,
+  type WebAPIPlatformError,
+  type WebAPIRateLimitedError,
+} from "@slack/web-api";
+import { type ProjectAlertChannelType } from "@trigger.dev/database";
+import assertNever from "assert-never";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { v3ErrorPath } from "~/utils/pathBuilder";
+import {
+  isIntegrationForService,
+  type OrganizationIntegrationForService,
+  OrgIntegrationRepository,
+} from "~/models/orgIntegration.server";
+import {
+  ProjectAlertEmailProperties,
+  ProjectAlertSlackProperties,
+  ProjectAlertWebhookProperties,
+} from "~/models/projectAlert.server";
+import { sendAlertEmail } from "~/services/email.server";
+import { logger } from "~/services/logger.server";
+import { decryptSecret } from "~/services/secrets/secretStore.server";
+import { subtle } from "crypto";
+import { generateErrorGroupWebhookPayload } from "./errorGroupWebhook.server";
+
+type ErrorAlertClassification = "new_issue" | "regression" | "unignored";
+
+interface ErrorAlertPayload {
+  channelId: string;
+  projectId: string;
+  classification: ErrorAlertClassification;
+  error: {
+    fingerprint: string;
+    environmentId: string;
+    environmentSlug: string;
+    environmentName: string;
+    taskIdentifier: string;
+    errorType: string;
+    errorMessage: string;
+    sampleStackTrace: string;
+    firstSeen: string;
+    lastSeen: string;
+    occurrenceCount: number;
+  };
+}
+
+class SkipRetryError extends Error {}
+
+export class DeliverErrorGroupAlertService {
+  async call(payload: ErrorAlertPayload): Promise<void> {
+    const channel = await prisma.projectAlertChannel.findFirst({
+      where: { id: payload.channelId, enabled: true },
+      include: {
+        project: {
+          include: {
+            organization: true,
+          },
+        },
+      },
+    });
+
+    if (!channel) {
+      logger.warn("[DeliverErrorGroupAlert] Channel not found or disabled", {
+        channelId: payload.channelId,
+      });
+      return;
+    }
+
+    const errorLink = this.#buildErrorLink(channel.project.organization, channel.project, payload.error);
+
+    try {
+      switch (channel.type) {
+        case "EMAIL":
+          await this.#sendEmail(channel, payload, errorLink);
+          break;
+        case "SLACK":
+          await this.#sendSlack(channel, payload, errorLink);
+          break;
+        case "WEBHOOK":
+          await this.#sendWebhook(channel, payload, errorLink);
+          break;
+        default:
+          assertNever(channel.type);
+      }
+    } catch (error) {
+      if (error instanceof SkipRetryError) {
+        logger.warn("[DeliverErrorGroupAlert] Skipping retry", { reason: (error as Error).message });
+        return;
+      }
+      throw error;
+    }
+  }
+
+  #buildErrorLink(
+    organization: { slug: string },
+    project: { slug: string },
+    error: ErrorAlertPayload["error"]
+  ): string {
+    return `${env.APP_ORIGIN}${v3ErrorPath(organization, project, { slug: error.environmentSlug }, { fingerprint: error.fingerprint })}`;
+  }
+
+  #classificationLabel(classification: ErrorAlertClassification): string {
+    switch (classification) {
+      case "new_issue":
+        return "New error";
+      case "regression":
+        return "Regression";
+      case "unignored":
+        return "Error resurfaced";
+    }
+  }
+
+  async #sendEmail(
+    channel: { type: ProjectAlertChannelType; properties: unknown; project: { name: string; organization: { title: string } } },
+    payload: ErrorAlertPayload,
+    errorLink: string
+  ): Promise<void> {
+    const emailProperties = ProjectAlertEmailProperties.safeParse(channel.properties);
+    if (!emailProperties.success) {
+      logger.error("[DeliverErrorGroupAlert] Failed to parse email properties", {
+        issues: emailProperties.error.issues,
+      });
+      return;
+    }
+
+    await sendAlertEmail({
+      email: "alert-error-group",
+      to: emailProperties.data.email,
+      classification: payload.classification,
+      taskIdentifier: payload.error.taskIdentifier,
+      environment: payload.error.environmentName,
+      error: {
+        message: payload.error.errorMessage,
+        type: payload.error.errorType,
+        stackTrace: payload.error.sampleStackTrace || undefined,
+      },
+      occurrenceCount: payload.error.occurrenceCount,
+      errorLink,
+      organization: channel.project.organization.title,
+      project: channel.project.name,
+    });
+  }
+
+  async #sendSlack(
+    channel: {
+      type: ProjectAlertChannelType;
+      properties: unknown;
+      project: { organizationId: string; name: string; organization: { title: string } };
+    },
+    payload: ErrorAlertPayload,
+    errorLink: string
+  ): Promise<void> {
+    const slackProperties = ProjectAlertSlackProperties.safeParse(channel.properties);
+    if (!slackProperties.success) {
+      logger.error("[DeliverErrorGroupAlert] Failed to parse slack properties", {
+        issues: slackProperties.error.issues,
+      });
+      return;
+    }
+
+    const integration = slackProperties.data.integrationId
+      ? await prisma.organizationIntegration.findFirst({
+          where: {
+            id: slackProperties.data.integrationId,
+            organizationId: channel.project.organizationId,
+          },
+          include: { tokenReference: true },
+        })
+      : await prisma.organizationIntegration.findFirst({
+          where: {
+            service: "SLACK",
+            organizationId: channel.project.organizationId,
+          },
+          orderBy: { createdAt: "desc" },
+          include: { tokenReference: true },
+        });
+
+    if (!integration || !isIntegrationForService(integration, "SLACK")) {
+      logger.error("[DeliverErrorGroupAlert] Slack integration not found");
+      return;
+    }
+
+    const message = this.#buildErrorGroupSlackMessage(
+      payload,
+      errorLink,
+      channel.project.name
+    );
+
+    await this.#postSlackMessage(integration, {
+      channel: slackProperties.data.channelId,
+      ...message,
+    } as ChatPostMessageArguments);
+  }
+
+  async #sendWebhook(
+    channel: {
+      type: ProjectAlertChannelType;
+      properties: unknown;
+      project: { id: string; externalRef: string; slug: string; name: string; organizationId: string; organization: { slug: string; title: string } };
+    },
+    payload: ErrorAlertPayload,
+    errorLink: string
+  ): Promise<void> {
+    const webhookProperties = ProjectAlertWebhookProperties.safeParse(channel.properties);
+    if (!webhookProperties.success) {
+      logger.error("[DeliverErrorGroupAlert] Failed to parse webhook properties", {
+        issues: webhookProperties.error.issues,
+      });
+      return;
+    }
+
+    const webhookPayload = generateErrorGroupWebhookPayload({
+      classification: payload.classification,
+      error: payload.error,
+      organization: {
+        id: channel.project.organizationId,
+        slug: channel.project.organization.slug,
+        name: channel.project.organization.title,
+      },
+      project: {
+        id: channel.project.id,
+        externalRef: channel.project.externalRef,
+        slug: channel.project.slug,
+        name: channel.project.name,
+      },
+      dashboardUrl: errorLink,
+    });
+
+    const rawPayload = JSON.stringify(webhookPayload);
+    const hashPayload = Buffer.from(rawPayload, "utf-8");
+    const secret = await decryptSecret(env.ENCRYPTION_KEY, webhookProperties.data.secret);
+    const hmacSecret = Buffer.from(secret, "utf-8");
+    const key = await subtle.importKey(
+      "raw",
+      hmacSecret,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const signature = await subtle.sign("HMAC", key, hashPayload);
+    const signatureHex = Buffer.from(signature).toString("hex");
+
+    const response = await fetch(webhookProperties.data.url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-trigger-signature-hmacsha256": signatureHex,
+      },
+      body: rawPayload,
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!response.ok) {
+      logger.info("[DeliverErrorGroupAlert] Failed to send webhook", {
+        status: response.status,
+        statusText: response.statusText,
+        url: webhookProperties.data.url,
+      });
+      throw new Error(`Failed to send error group alert webhook to ${webhookProperties.data.url}`);
+    }
+  }
+
+  async #postSlackMessage(
+    integration: OrganizationIntegrationForService<"SLACK">,
+    message: ChatPostMessageArguments
+  ) {
+    const client = await OrgIntegrationRepository.getAuthenticatedClientForIntegration(
+      integration,
+      { forceBotToken: true }
+    );
+
+    try {
+      return await client.chat.postMessage({
+        ...message,
+        unfurl_links: false,
+        unfurl_media: false,
+      });
+    } catch (error) {
+      if (isWebAPIRateLimitedError(error)) {
+        throw new Error("Slack rate limited");
+      }
+      if (isWebAPIPlatformError(error)) {
+        if (
+          (error as WebAPIPlatformError).data.error === "invalid_blocks" ||
+          (error as WebAPIPlatformError).data.error === "account_inactive"
+        ) {
+          throw new SkipRetryError(`Slack: ${(error as WebAPIPlatformError).data.error}`);
+        }
+        throw new Error("Slack platform error");
+      }
+      throw error;
+    }
+  }
+
+  #buildErrorGroupSlackMessage(
+    payload: ErrorAlertPayload,
+    errorLink: string,
+    projectName: string
+  ): { text: string; blocks: object[]; attachments: object[] } {
+    const label = this.#classificationLabel(payload.classification);
+    const errorType = payload.error.errorType || "Error";
+    const task = payload.error.taskIdentifier;
+    const envName = payload.error.environmentName;
+
+    return {
+      text: `${label}: ${errorType} in ${task} [${envName}]`,
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `*${label} in ${task} [${envName}]*`,
+          },
+        },
+      ],
+      attachments: [
+        {
+          color: "danger",
+          blocks: [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: this.#wrapInCodeBlock(
+                  payload.error.sampleStackTrace || payload.error.errorMessage
+                ),
+              },
+            },
+            {
+              type: "section",
+              fields: [
+                {
+                  type: "mrkdwn",
+                  text: `*Task:*\n${task}`,
+                },
+                {
+                  type: "mrkdwn",
+                  text: `*Environment:*\n${envName}`,
+                },
+                {
+                  type: "mrkdwn",
+                  text: `*Project:*\n${projectName}`,
+                },
+                {
+                  type: "mrkdwn",
+                  text: `*Occurrences:*\n${payload.error.occurrenceCount}`,
+                },
+                {
+                  type: "mrkdwn",
+                  text: `*Last seen:*\n${this.#formatTimestamp(new Date(Number(payload.error.lastSeen)))}`,
+                },
+              ],
+            },
+            {
+              type: "actions",
+              elements: [
+                {
+                  type: "button",
+                  text: { type: "plain_text", text: "Investigate" },
+                  url: errorLink,
+                  style: "primary",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  #wrapInCodeBlock(text: string, maxLength = 3000) {
+    const wrapperLength = 6; // ``` prefix + ``` suffix
+    const truncationSuffix = "\n\n...truncated — check dashboard for full error";
+    const innerMax = maxLength - wrapperLength;
+
+    const truncated =
+      text.length > innerMax
+        ? text.slice(0, innerMax - truncationSuffix.length) + truncationSuffix
+        : text;
+    return `\`\`\`${truncated}\`\`\``;
+  }
+
+  #formatTimestamp(date: Date): string {
+    return new Intl.DateTimeFormat("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: true,
+    }).format(date);
+  }
+}
+
+function isWebAPIPlatformError(error: unknown): error is WebAPIPlatformError {
+  return (error as WebAPIPlatformError).code === ErrorCode.PlatformError;
+}
+
+function isWebAPIRateLimitedError(error: unknown): error is WebAPIRateLimitedError {
+  return (error as WebAPIRateLimitedError).code === ErrorCode.RateLimitedError;
+}
diff --git a/apps/webapp/app/v3/services/alerts/errorAlertEvaluator.server.ts b/apps/webapp/app/v3/services/alerts/errorAlertEvaluator.server.ts
new file mode 100644
index 00000000000..e935a8a6911
--- /dev/null
+++ b/apps/webapp/app/v3/services/alerts/errorAlertEvaluator.server.ts
@@ -0,0 +1,484 @@
+import { type ActiveErrorsSinceQueryResult, type ClickHouse } from "@internal/clickhouse";
+import {
+  type ErrorGroupState,
+  type PrismaClientOrTransaction,
+  type ProjectAlertChannel,
+  type RuntimeEnvironmentType,
+} from "@trigger.dev/database";
+import { $replica, prisma } from "~/db.server";
+import { ErrorAlertConfig } from "~/models/projectAlert.server";
+import { clickhouseClient } from "~/services/clickhouseInstance.server";
+import { logger } from "~/services/logger.server";
+import { alertsWorker } from "~/v3/alertsWorker.server";
+
+type ErrorClassification = "new_issue" | "regression" | "unignored";
+
+interface AlertableError {
+  classification: ErrorClassification;
+  error: ActiveErrorsSinceQueryResult;
+  environmentSlug: string;
+  environmentName: string;
+}
+
+interface ResolvedEnvironment {
+  id: string;
+  slug: string;
+  type: RuntimeEnvironmentType;
+  displayName: string;
+}
+
+const DEFAULT_INTERVAL_MS = 300_000;
+
+/**
+ * For a project evalutes whether to send error alerts
+ *
+ * Alerts are sent if an error is
+ * 1. A new issue
+ * 2. A regression (was resolved and now back)
+ * 3. Unignored (was ignored and is no longer)
+ *
+ * Unignored happens in 3 situations
+ * 1. It was ignored with a future date, and that's now in the past
+ * 2. It was ignored until reaching an error rate (e.g. 10/minute) and that has been exceeded
+ * 3. It was ignored until reaching a total occurrence count (e.g. 1,000) and that has been exceeded
+ */
+export class ErrorAlertEvaluator {
+  constructor(
+    protected readonly _prisma: PrismaClientOrTransaction = prisma,
+    protected readonly _replica: PrismaClientOrTransaction = $replica,
+    protected readonly _clickhouse: ClickHouse = clickhouseClient
+  ) {}
+
+  async evaluate(projectId: string, scheduledAt: number): Promise<void> {
+    const nextScheduledAt = Date.now();
+
+    const channels = await this.resolveChannels(projectId);
+    if (channels.length === 0) {
+      logger.info("[ErrorAlertEvaluator] No active ERROR_GROUP channels, self-terminating", {
+        projectId,
+      });
+      return;
+    }
+
+    const minIntervalMs = this.computeMinInterval(channels);
+    const windowMs = nextScheduledAt - scheduledAt;
+
+    if (windowMs > minIntervalMs * 2) {
+      logger.info("[ErrorAlertEvaluator] Large evaluation window (gap detected)", {
+        projectId,
+        scheduledAt,
+        nextScheduledAt,
+        windowMs,
+        minIntervalMs,
+      });
+    }
+
+    const allEnvTypes = this.collectEnvironmentTypes(channels);
+
+    try {
+      const [project, environments] = await Promise.all([
+        this._replica.project.findFirst({
+          where: { id: projectId },
+          select: { organizationId: true },
+        }),
+        this.resolveEnvironments(projectId, allEnvTypes),
+      ]);
+
+      if (!project) {
+        logger.error("[ErrorAlertEvaluator] Project not found", { projectId });
+        return;
+      }
+
+      if (environments.length === 0) {
+        return;
+      }
+
+      const envIds = environments.map((e) => e.id);
+      const envMap = new Map(environments.map((e) => [e.id, e]));
+      const channelsByEnvId = this.buildChannelsByEnvId(channels, environments);
+
+      const activeErrors = await this.getActiveErrors(
+        project.organizationId,
+        projectId,
+        envIds,
+        scheduledAt
+      );
+
+      if (activeErrors.length === 0) {
+        return;
+      }
+
+      const states = await this.getErrorGroupStates(activeErrors);
+      const stateMap = this.buildStateMap(states);
+
+      const occurrenceCounts = await this.getOccurrenceCountsSince(
+        project.organizationId,
+        projectId,
+        envIds,
+        scheduledAt
+      );
+      const occurrenceMap = this.buildOccurrenceMap(occurrenceCounts);
+
+      const alertableErrors: AlertableError[] = [];
+
+      for (const error of activeErrors) {
+        const key = `${error.environment_id}:${error.task_identifier}:${error.error_fingerprint}`;
+        const state = stateMap.get(key);
+        const env = envMap.get(error.environment_id);
+        const firstSeenMs = Number(error.first_seen);
+
+        const classification = this.classifyError(error, state, firstSeenMs, scheduledAt, {
+          occurrencesSince: occurrenceMap.get(key) ?? 0,
+          windowMs,
+          totalOccurrenceCount: error.occurrence_count,
+        });
+
+        if (classification) {
+          alertableErrors.push({
+            classification,
+            error,
+            environmentSlug: env?.slug ?? "",
+            environmentName: env?.displayName ?? error.environment_id,
+          });
+        }
+      }
+
+      for (const alertable of alertableErrors) {
+        const envChannels = channelsByEnvId.get(alertable.error.environment_id) ?? [];
+        for (const channel of envChannels) {
+          await alertsWorker.enqueue({
+            id: `deliverErrorGroupAlert:${channel.id}:${alertable.error.error_fingerprint}:${scheduledAt}`,
+            job: "v3.deliverErrorGroupAlert",
+            payload: {
+              channelId: channel.id,
+              projectId,
+              classification: alertable.classification,
+              error: {
+                fingerprint: alertable.error.error_fingerprint,
+                environmentId: alertable.error.environment_id,
+                environmentSlug: alertable.environmentSlug,
+                environmentName: alertable.environmentName,
+                taskIdentifier: alertable.error.task_identifier,
+                errorType: alertable.error.error_type,
+                errorMessage: alertable.error.error_message,
+                sampleStackTrace: alertable.error.sample_stack_trace,
+                firstSeen: alertable.error.first_seen,
+                lastSeen: alertable.error.last_seen,
+                occurrenceCount: alertable.error.occurrence_count,
+              },
+            },
+          });
+        }
+      }
+
+      await this.updateErrorGroupStates(
+        alertableErrors,
+        stateMap,
+        project.organizationId,
+        projectId
+      );
+
+      logger.info("[ErrorAlertEvaluator] Evaluation complete", {
+        projectId,
+        activeErrors: activeErrors.length,
+        alertableErrors: alertableErrors.length,
+        deliveryJobsEnqueued: alertableErrors.reduce(
+          (sum, a) => sum + (channelsByEnvId.get(a.error.environment_id)?.length ?? 0),
+          0
+        ),
+      });
+    } catch (error) {
+      logger.error("[ErrorAlertEvaluator] Evaluation failed, will retry on next cycle", {
+        projectId,
+        error,
+      });
+    } finally {
+      await this.selfChain(projectId, nextScheduledAt, minIntervalMs);
+    }
+  }
+
+  private classifyError(
+    error: ActiveErrorsSinceQueryResult,
+    state: ErrorGroupState | undefined,
+    firstSeenMs: number,
+    scheduledAt: number,
+    thresholdContext: { occurrencesSince: number; windowMs: number; totalOccurrenceCount: number }
+  ): ErrorClassification | null {
+    if (!state) {
+      return firstSeenMs > scheduledAt ? "new_issue" : null;
+    }
+
+    switch (state.status) {
+      case "UNRESOLVED":
+        return null;
+
+      case "RESOLVED": {
+        if (!state.resolvedAt) return null;
+        const lastSeenMs = Number(error.last_seen);
+        return lastSeenMs > state.resolvedAt.getTime() ? "regression" : null;
+      }
+
+      case "IGNORED":
+        return this.isIgnoreBreached(state, thresholdContext) ? "unignored" : null;
+
+      default:
+        return null;
+    }
+  }
+
+  private isIgnoreBreached(
+    state: ErrorGroupState,
+    context: { occurrencesSince: number; windowMs: number; totalOccurrenceCount: number }
+  ): boolean {
+    if (state.ignoredUntil && state.ignoredUntil.getTime() <= Date.now()) {
+      return true;
+    }
+
+    if (
+      state.ignoredUntilOccurrenceRate !== null &&
+      state.ignoredUntilOccurrenceRate !== undefined
+    ) {
+      const windowMinutes = Math.max(context.windowMs / 60_000, 1);
+      const rate = context.occurrencesSince / windowMinutes;
+      if (rate > state.ignoredUntilOccurrenceRate) {
+        return true;
+      }
+    }
+
+    if (
+      state.ignoredUntilTotalOccurrences != null &&
+      state.ignoredAtOccurrenceCount != null
+    ) {
+      const occurrencesSinceIgnored =
+        context.totalOccurrenceCount - Number(state.ignoredAtOccurrenceCount);
+      if (occurrencesSinceIgnored >= state.ignoredUntilTotalOccurrences) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private async resolveChannels(projectId: string): Promise<ProjectAlertChannel[]> {
+    return this._replica.projectAlertChannel.findMany({
+      where: {
+        projectId,
+        alertTypes: { has: "ERROR_GROUP" },
+        enabled: true,
+      },
+    });
+  }
+
+  private computeMinInterval(channels: ProjectAlertChannel[]): number {
+    let min = DEFAULT_INTERVAL_MS;
+    for (const ch of channels) {
+      const config = ErrorAlertConfig.safeParse(ch.errorAlertConfig);
+      if (config.success) {
+        min = Math.min(min, config.data.evaluationIntervalMs);
+      }
+    }
+    return min;
+  }
+
+  private collectEnvironmentTypes(channels: ProjectAlertChannel[]): RuntimeEnvironmentType[] {
+    const types = new Set<RuntimeEnvironmentType>();
+    for (const ch of channels) {
+      for (const t of ch.environmentTypes) {
+        types.add(t);
+      }
+    }
+    return Array.from(types);
+  }
+
+  private async resolveEnvironments(
+    projectId: string,
+    types: RuntimeEnvironmentType[]
+  ): Promise<ResolvedEnvironment[]> {
+    const envs = await this._replica.runtimeEnvironment.findMany({
+      where: {
+        projectId,
+        type: { in: types },
+      },
+      select: {
+        id: true,
+        type: true,
+        slug: true,
+        branchName: true,
+      },
+    });
+
+    return envs.map((e) => ({
+      id: e.id,
+      slug: e.slug,
+      type: e.type,
+      displayName: e.branchName ?? e.slug,
+    }));
+  }
+
+  private buildChannelsByEnvId(
+    channels: ProjectAlertChannel[],
+    environments: ResolvedEnvironment[]
+  ): Map<string, ProjectAlertChannel[]> {
+    const result = new Map<string, ProjectAlertChannel[]>();
+    for (const env of environments) {
+      const matching = channels.filter((ch) => ch.environmentTypes.includes(env.type));
+      if (matching.length > 0) {
+        result.set(env.id, matching);
+      }
+    }
+    return result;
+  }
+
+  private async getActiveErrors(
+    organizationId: string,
+    projectId: string,
+    envIds: string[],
+    scheduledAt: number
+  ): Promise<ActiveErrorsSinceQueryResult[]> {
+    const qb = this._clickhouse.errors.activeErrorsSinceQueryBuilder();
+    qb.where("organization_id = {organizationId: String}", { organizationId });
+    qb.where("project_id = {projectId: String}", { projectId });
+    qb.where("environment_id IN {envIds: Array(String)}", { envIds });
+    qb.groupBy("environment_id, task_identifier, error_fingerprint");
+    qb.having("toInt64(last_seen) > {scheduledAt: Int64}", {
+      scheduledAt,
+    });
+
+    const [err, results] = await qb.execute();
+    if (err) {
+      logger.error("[ErrorAlertEvaluator] Failed to query active errors", { error: err });
+      return [];
+    }
+    return results ?? [];
+  }
+
+  private async getErrorGroupStates(
+    activeErrors: ActiveErrorsSinceQueryResult[]
+  ): Promise<ErrorGroupState[]> {
+    if (activeErrors.length === 0) return [];
+
+    return this._replica.errorGroupState.findMany({
+      where: {
+        OR: activeErrors.map((e) => ({
+          environmentId: e.environment_id,
+          taskIdentifier: e.task_identifier,
+          errorFingerprint: e.error_fingerprint,
+        })),
+      },
+    });
+  }
+
+  private buildStateMap(states: ErrorGroupState[]): Map<string, ErrorGroupState> {
+    const map = new Map<string, ErrorGroupState>();
+    for (const s of states) {
+      map.set(`${s.environmentId}:${s.taskIdentifier}:${s.errorFingerprint}`, s);
+    }
+    return map;
+  }
+
+  private async getOccurrenceCountsSince(
+    organizationId: string,
+    projectId: string,
+    envIds: string[],
+    scheduledAt: number
+  ): Promise<
+    Array<{
+      environment_id: string;
+      task_identifier: string;
+      error_fingerprint: string;
+      occurrences_since: number;
+    }>
+  > {
+    const qb = this._clickhouse.errors.occurrenceCountsSinceQueryBuilder();
+    qb.where("organization_id = {organizationId: String}", { organizationId });
+    qb.where("project_id = {projectId: String}", { projectId });
+    qb.where("environment_id IN {envIds: Array(String)}", { envIds });
+    qb.where("minute >= toStartOfMinute(fromUnixTimestamp64Milli({scheduledAt: Int64}))", {
+      scheduledAt,
+    });
+    qb.groupBy("environment_id, task_identifier, error_fingerprint");
+
+    const [err, results] = await qb.execute();
+    if (err) {
+      logger.error("[ErrorAlertEvaluator] Failed to query occurrence counts", { error: err });
+      return [];
+    }
+    return results ?? [];
+  }
+
+  private buildOccurrenceMap(
+    counts: Array<{
+      environment_id: string;
+      task_identifier: string;
+      error_fingerprint: string;
+      occurrences_since: number;
+    }>
+  ): Map<string, number> {
+    const map = new Map<string, number>();
+    for (const c of counts) {
+      map.set(
+        `${c.environment_id}:${c.task_identifier}:${c.error_fingerprint}`,
+        c.occurrences_since
+      );
+    }
+    return map;
+  }
+
+  private async updateErrorGroupStates(
+    alertableErrors: AlertableError[],
+    stateMap: Map<string, ErrorGroupState>,
+    organizationId: string,
+    projectId: string
+  ): Promise<void> {
+    for (const alertable of alertableErrors) {
+      const key = `${alertable.error.environment_id}:${alertable.error.task_identifier}:${alertable.error.error_fingerprint}`;
+      const state = stateMap.get(key);
+
+      if (state) {
+        await this._prisma.errorGroupState.update({
+          where: { id: state.id },
+          data: {
+            status: "UNRESOLVED",
+            ignoredUntil: null,
+            ignoredUntilOccurrenceRate: null,
+            ignoredUntilTotalOccurrences: null,
+            ignoredAtOccurrenceCount: null,
+            ignoredAt: null,
+            ignoredReason: null,
+            ignoredByUserId: null,
+            resolvedAt: null,
+            resolvedInVersion: null,
+            resolvedBy: null,
+          },
+        });
+      } else if (alertable.classification === "new_issue") {
+        await this._prisma.errorGroupState.create({
+          data: {
+            organizationId,
+            projectId,
+            environmentId: alertable.error.environment_id,
+            taskIdentifier: alertable.error.task_identifier,
+            errorFingerprint: alertable.error.error_fingerprint,
+            status: "UNRESOLVED",
+          },
+        });
+      }
+    }
+  }
+
+  private async selfChain(
+    projectId: string,
+    nextScheduledAt: number,
+    intervalMs: number
+  ): Promise<void> {
+    await alertsWorker.enqueue({
+      id: `evaluateErrorAlerts:${projectId}`,
+      job: "v3.evaluateErrorAlerts",
+      payload: {
+        projectId,
+        scheduledAt: nextScheduledAt,
+      },
+      availableAt: new Date(nextScheduledAt + intervalMs),
+    });
+  }
+}
diff --git a/apps/webapp/app/v3/services/alerts/errorGroupWebhook.server.ts b/apps/webapp/app/v3/services/alerts/errorGroupWebhook.server.ts
new file mode 100644
index 00000000000..1c0f939862c
--- /dev/null
+++ b/apps/webapp/app/v3/services/alerts/errorGroupWebhook.server.ts
@@ -0,0 +1,74 @@
+import { nanoid } from "nanoid";
+import type { ErrorWebhook } from "@trigger.dev/core/v3/schemas";
+
+export type ErrorAlertClassification = "new_issue" | "regression" | "unignored";
+
+export type ErrorGroupAlertData = {
+  classification: ErrorAlertClassification;
+  error: {
+    fingerprint: string;
+    environmentId: string;
+    environmentName: string;
+    taskIdentifier: string;
+    errorType: string;
+    errorMessage: string;
+    sampleStackTrace: string;
+    firstSeen: string;
+    lastSeen: string;
+    occurrenceCount: number;
+  };
+  organization: {
+    id: string;
+    slug: string;
+    name: string;
+  };
+  project: {
+    id: string;
+    externalRef: string;
+    slug: string;
+    name: string;
+  };
+  dashboardUrl: string;
+};
+
+/**
+ * Generates a webhook payload for an error group alert that conforms to the
+ * ErrorWebhook schema from @trigger.dev/core/v3/schemas
+ */
+export function generateErrorGroupWebhookPayload(data: ErrorGroupAlertData): ErrorWebhook {
+  return {
+    id: nanoid(),
+    created: new Date(),
+    webhookVersion: "2025-01-01",
+    type: "alert.error" as const,
+    object: {
+      classification: data.classification,
+      error: {
+        fingerprint: data.error.fingerprint,
+        type: data.error.errorType,
+        message: data.error.errorMessage,
+        stackTrace: data.error.sampleStackTrace || undefined,
+        firstSeen: new Date(Number(data.error.firstSeen)),
+        lastSeen: new Date(Number(data.error.lastSeen)),
+        occurrenceCount: data.error.occurrenceCount,
+        taskIdentifier: data.error.taskIdentifier,
+      },
+      environment: {
+        id: data.error.environmentId,
+        name: data.error.environmentName,
+      },
+      organization: {
+        id: data.organization.id,
+        slug: data.organization.slug,
+        name: data.organization.name,
+      },
+      project: {
+        id: data.project.id,
+        ref: data.project.externalRef,
+        slug: data.project.slug,
+        name: data.project.name,
+      },
+      dashboardUrl: data.dashboardUrl,
+    },
+  };
+}
diff --git a/apps/webapp/app/v3/services/batchTriggerTask.server.ts b/apps/webapp/app/v3/services/batchTriggerTask.server.ts
deleted file mode 100644
index a7bf1846f4a..00000000000
--- a/apps/webapp/app/v3/services/batchTriggerTask.server.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { BatchTriggerTaskRequestBody, logger } from "@trigger.dev/core/v3";
-import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { generateFriendlyId } from "../friendlyIdentifiers";
-import { BaseService, ServiceValidationError } from "./baseService.server";
-import { TriggerTaskService } from "./triggerTask.server";
-import { batchTaskRunItemStatusForRunStatus } from "~/models/taskRun.server";
-import { isFinalAttemptStatus, isFinalRunStatus } from "../taskStatus";
-
-export type BatchTriggerTaskServiceOptions = {
-  idempotencyKey?: string;
-  triggerVersion?: string;
-  traceContext?: Record<string, string | undefined>;
-  spanParentAsLink?: boolean;
-};
-
-export class BatchTriggerTaskService extends BaseService {
-  public async call(
-    taskId: string,
-    environment: AuthenticatedEnvironment,
-    body: BatchTriggerTaskRequestBody,
-    options: BatchTriggerTaskServiceOptions = {}
-  ) {
-    return await this.traceWithEnv("call()", environment, async (span) => {
-      span.setAttribute("taskId", taskId);
-
-      const existingBatch = options.idempotencyKey
-        ? await this._prisma.batchTaskRun.findUnique({
-            where: {
-              runtimeEnvironmentId_idempotencyKey: {
-                runtimeEnvironmentId: environment.id,
-                idempotencyKey: options.idempotencyKey,
-              },
-            },
-            include: {
-              items: {
-                include: {
-                  taskRun: {
-                    select: {
-                      friendlyId: true,
-                    },
-                  },
-                },
-              },
-            },
-          })
-        : undefined;
-
-      if (existingBatch) {
-        span.setAttribute("batchId", existingBatch.friendlyId);
-        return {
-          batch: existingBatch,
-          runs: existingBatch.items.map((item) => item.taskRun.friendlyId),
-        };
-      }
-
-      const dependentAttempt = body?.dependentAttempt
-        ? await this._prisma.taskRunAttempt.findUnique({
-            where: { friendlyId: body.dependentAttempt },
-            include: {
-              taskRun: {
-                select: {
-                  id: true,
-                  status: true,
-                },
-              },
-            },
-          })
-        : undefined;
-
-      if (
-        dependentAttempt &&
-        (isFinalAttemptStatus(dependentAttempt.status) ||
-          isFinalRunStatus(dependentAttempt.taskRun.status))
-      ) {
-        logger.debug("Dependent attempt or run is in a terminal state", {
-          dependentAttempt: dependentAttempt,
-        });
-
-        if (isFinalAttemptStatus(dependentAttempt.status)) {
-          throw new ServiceValidationError(
-            `Cannot batch trigger ${taskId} as the parent attempt has a status of ${dependentAttempt.status}`
-          );
-        } else {
-          throw new ServiceValidationError(
-            `Cannot batch trigger ${taskId} as the parent run has a status of ${dependentAttempt.taskRun.status}`
-          );
-        }
-      }
-
-      const batch = await this._prisma.batchTaskRun.create({
-        data: {
-          friendlyId: generateFriendlyId("batch"),
-          runtimeEnvironmentId: environment.id,
-          idempotencyKey: options.idempotencyKey,
-          taskIdentifier: taskId,
-          dependentTaskAttemptId: dependentAttempt?.id,
-        },
-      });
-
-      const triggerTaskService = new TriggerTaskService();
-
-      const runs: string[] = [];
-      let index = 0;
-
-      for (const item of body.items) {
-        try {
-          const result = await triggerTaskService.call(
-            taskId,
-            environment,
-            {
-              ...item,
-              options: {
-                ...item.options,
-                dependentBatch: dependentAttempt?.id ? batch.friendlyId : undefined, // Only set dependentBatch if dependentAttempt is set which means batchTriggerAndWait was called
-                parentBatch: dependentAttempt?.id ? undefined : batch.friendlyId, // Only set parentBatch if dependentAttempt is NOT set which means batchTrigger was called
-              },
-            },
-            {
-              triggerVersion: options.triggerVersion,
-              traceContext: options.traceContext,
-              spanParentAsLink: options.spanParentAsLink,
-              batchId: batch.friendlyId,
-            }
-          );
-
-          if (result) {
-            await this._prisma.batchTaskRunItem.create({
-              data: {
-                batchTaskRunId: batch.id,
-                taskRunId: result.run.id,
-                status: batchTaskRunItemStatusForRunStatus(result.run.status),
-              },
-            });
-
-            runs.push(result.run.friendlyId);
-          }
-
-          index++;
-        } catch (error) {
-          logger.error("[BatchTriggerTaskService] Error triggering task", {
-            taskId,
-            error,
-          });
-        }
-      }
-
-      span.setAttribute("batchId", batch.friendlyId);
-
-      return { batch, runs };
-    });
-  }
-}
diff --git a/apps/webapp/app/v3/services/batchTriggerV3.server.ts b/apps/webapp/app/v3/services/batchTriggerV3.server.ts
index 337130f4439..22aa64b5e16 100644
--- a/apps/webapp/app/v3/services/batchTriggerV3.server.ts
+++ b/apps/webapp/app/v3/services/batchTriggerV3.server.ts
@@ -14,7 +14,7 @@ import {
   TaskRunAttempt,
 } from "@trigger.dev/database";
 import { z } from "zod";
-import { $transaction, prisma, PrismaClientOrTransaction } from "~/db.server";
+import { prisma, PrismaClientOrTransaction } from "~/db.server";
 import { env } from "~/env.server";
 import { batchTaskRunItemStatusForRunStatus } from "~/models/taskRun.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
@@ -25,7 +25,7 @@ import { generateFriendlyId } from "../friendlyIdentifiers";
 import { legacyRunEngineWorker } from "../legacyRunEngineWorker.server";
 import { marqs } from "../marqs/index.server";
 import { guardQueueSizeLimitsForEnv } from "../queueSizeLimits.server";
-import { downloadPacketFromObjectStore, uploadPacketToObjectStore } from "../r2.server";
+import { downloadPacketFromObjectStore, uploadPacketToObjectStore } from "../objectStore.server";
 import { isFinalAttemptStatus, isFinalRunStatus } from "../taskStatus";
 import { startActiveSpan } from "../tracer.server";
 import { BaseService, ServiceValidationError } from "./baseService.server";
@@ -57,6 +57,8 @@ export type BatchTriggerTaskServiceOptions = {
   spanParentAsLink?: boolean;
   oneTimeUseToken?: string;
   realtimeStreamsVersion?: "v1" | "v2";
+  triggerSource?: string;
+  triggerAction?: string;
 };
 
 type RunItemData = {
@@ -249,7 +251,9 @@ export class BatchTriggerV3Service extends BaseService {
 
           if (!queueSizeGuard.isWithinLimits) {
             throw new ServiceValidationError(
-              `Cannot trigger ${newRunCount} tasks as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`
+              `Cannot trigger ${newRunCount} tasks as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`,
+              undefined,
+              "warn"
             );
           }
 
@@ -853,6 +857,8 @@ export class BatchTriggerV3Service extends BaseService {
         skipChecks: true,
         runFriendlyId: task.runId,
         realtimeStreamsVersion: options?.realtimeStreamsVersion,
+        triggerSource: options?.triggerSource ?? "api",
+        triggerAction: options?.triggerAction ?? "trigger",
       }
     );
 
@@ -924,16 +930,79 @@ export class BatchTriggerV3Service extends BaseService {
 
       const filename = `${pathPrefix}/payload.json`;
 
-      await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
+      const uploadedFilename = await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
 
       return {
-        data: filename,
+        data: uploadedFilename,
         dataType: "application/store",
       };
     });
   }
 }
 
+export async function tryCompleteBatchV3(
+  batchId: string,
+  tx: PrismaClientOrTransaction,
+  scheduleResumeOnComplete: boolean
+) {
+  const batch = await tx.batchTaskRun.findFirst({
+    where: { id: batchId },
+    select: {
+      id: true,
+      sealed: true,
+      status: true,
+      expectedCount: true,
+      dependentTaskAttemptId: true,
+    },
+  });
+
+  if (!batch) {
+    logger.debug("tryCompleteBatchV3: Batch not found", { batchId });
+    return;
+  }
+
+  if (batch.status === "COMPLETED") {
+    logger.debug("tryCompleteBatchV3: Already completed", { batchId });
+    return;
+  }
+
+  if (!batch.sealed) {
+    logger.debug("tryCompleteBatchV3: Not sealed yet", { batchId });
+    return;
+  }
+
+  // Count completed items (read-only, no contention)
+  const completedCount = await tx.batchTaskRunItem.count({
+    where: { batchTaskRunId: batchId, status: "COMPLETED" },
+  });
+
+  if (completedCount < batch.expectedCount) {
+    logger.debug("tryCompleteBatchV3: Not all items completed", {
+      batchId,
+      completedCount,
+      expectedCount: batch.expectedCount,
+    });
+    return;
+  }
+
+  // Mark batch COMPLETED (idempotent via status check)
+  const updated = await tx.batchTaskRun.updateMany({
+    where: { id: batchId, status: "PENDING" },
+    data: { status: "COMPLETED", completedAt: new Date(), completedCount },
+  });
+
+  if (updated.count === 0) {
+    logger.debug("tryCompleteBatchV3: Already transitioned", { batchId });
+    return;
+  }
+
+  logger.debug("tryCompleteBatchV3: Batch completed", { batchId, completedCount });
+
+  if (scheduleResumeOnComplete && batch.dependentTaskAttemptId) {
+    await ResumeBatchRunService.enqueue(batchId, true, tx);
+  }
+}
+
 export async function completeBatchTaskRunItemV3(
   itemId: string,
   batchTaskRunId: string,
@@ -953,86 +1022,32 @@ export async function completeBatchTaskRunItemV3(
     isRetry,
   });
 
-  if (isRetry) {
-    logger.debug("completeBatchTaskRunItemV3 retrying", {
-      itemId,
-      batchTaskRunId,
-      scheduleResumeOnComplete,
-      taskRunAttemptId,
-      retryAttempt,
-    });
-  }
-
   try {
-    await $transaction(
-      tx,
-      "completeBatchTaskRunItemV3",
-      async (tx, span) => {
-        span?.setAttribute("batch_id", batchTaskRunId);
-
-        // Update the item to complete
-        const updated = await tx.batchTaskRunItem.updateMany({
-          where: {
-            id: itemId,
-            status: "PENDING",
-          },
-          data: {
-            status: "COMPLETED",
-            taskRunAttemptId,
-          },
-        });
-
-        if (updated.count === 0) {
-          return;
-        }
-
-        const updatedBatchRun = await tx.batchTaskRun.update({
-          where: {
-            id: batchTaskRunId,
-          },
-          data: {
-            completedCount: {
-              increment: 1,
-            },
-          },
-          select: {
-            sealed: true,
-            status: true,
-            completedCount: true,
-            expectedCount: true,
-            dependentTaskAttemptId: true,
-          },
-        });
+    // Update item to COMPLETED (no transaction needed, no contention)
+    const updated = await tx.batchTaskRunItem.updateMany({
+      where: { id: itemId, status: "PENDING" },
+      data: { status: "COMPLETED", taskRunAttemptId },
+    });
 
-        if (
-          updatedBatchRun.status === "PENDING" &&
-          updatedBatchRun.completedCount === updatedBatchRun.expectedCount &&
-          updatedBatchRun.sealed
-        ) {
-          await tx.batchTaskRun.update({
-            where: {
-              id: batchTaskRunId,
-            },
-            data: {
-              status: "COMPLETED",
-              completedAt: new Date(),
-            },
-          });
+    if (updated.count === 0) {
+      logger.debug("completeBatchTaskRunItemV3: Item already completed", {
+        itemId,
+        batchTaskRunId,
+      });
+      return;
+    }
 
-          // We only need to resume the batch if it has a dependent task attempt ID
-          if (scheduleResumeOnComplete && updatedBatchRun.dependentTaskAttemptId) {
-            await ResumeBatchRunService.enqueue(batchTaskRunId, true, tx);
-          }
-        }
-      },
-      {
-        timeout: 10_000,
-        maxWait: 4_000,
-      }
-    );
+    // Schedule debounced completion check
+    // enqueue with same ID overwrites, resetting the 200ms timer (debounce behavior)
+    await legacyRunEngineWorker.enqueue({
+      id: `tryCompleteBatchV3:${batchTaskRunId}`,
+      job: "tryCompleteBatchV3",
+      payload: { batchId: batchTaskRunId, scheduleResumeOnComplete },
+      availableAt: new Date(Date.now() + 200),
+    });
   } catch (error) {
     if (isPrismaRetriableError(error) || isPrismaRaceConditionError(error)) {
-      logger.error("completeBatchTaskRunItemV3 failed with a Prisma Error, scheduling a retry", {
+      logger.error("completeBatchTaskRunItemV3 failed, scheduling retry", {
         itemId,
         batchTaskRunId,
         error,
@@ -1041,24 +1056,17 @@ export async function completeBatchTaskRunItemV3(
       });
 
       if (isRetry) {
-        //throwing this error will cause the Redis worker to retry the job
         throw error;
       } else {
-        //schedule a retry
         await legacyRunEngineWorker.enqueue({
           id: `completeBatchTaskRunItem:${itemId}`,
           job: "completeBatchTaskRunItem",
-          payload: {
-            itemId,
-            batchTaskRunId,
-            scheduleResumeOnComplete,
-            taskRunAttemptId,
-          },
+          payload: { itemId, batchTaskRunId, scheduleResumeOnComplete, taskRunAttemptId },
           availableAt: new Date(Date.now() + 2_000),
         });
       }
     } else {
-      logger.error("completeBatchTaskRunItemV3 failed with a non-retriable error", {
+      logger.error("completeBatchTaskRunItemV3 failed with non-retriable error", {
         itemId,
         batchTaskRunId,
         error,
diff --git a/apps/webapp/app/v3/services/bulk/BulkActionV2.server.ts b/apps/webapp/app/v3/services/bulk/BulkActionV2.server.ts
index 98b6079c108..156b68bff59 100644
--- a/apps/webapp/app/v3/services/bulk/BulkActionV2.server.ts
+++ b/apps/webapp/app/v3/services/bulk/BulkActionV2.server.ts
@@ -138,11 +138,13 @@ export class BulkActionService extends BaseService {
     }
 
     // 2. Parse the params
+    const rawParams = group.params && typeof group.params === "object" ? group.params : {};
+    const finalizeRun = "finalizeRun" in rawParams && (rawParams as any).finalizeRun === true;
     const filters = parseRunListInputOptions({
       organizationId: group.project.organizationId,
       projectId: group.projectId,
       environmentId: group.environmentId,
-      ...(group.params && typeof group.params === "object" ? group.params : {}),
+      ...rawParams,
     });
 
     const runsRepository = new RunsRepository({
@@ -199,6 +201,7 @@ export class BulkActionService extends BaseService {
               cancelService.call(run, {
                 reason: `Bulk action ${group.friendlyId} cancelled run`,
                 bulkActionId: bulkActionId,
+                finalizeRun,
               })
             );
             if (error) {
@@ -239,6 +242,7 @@ export class BulkActionService extends BaseService {
             const [error, result] = await tryCatch(
               replayService.call(run, {
                 bulkActionId: bulkActionId,
+                triggerSource: "dashboard",
               })
             );
             if (error) {
diff --git a/apps/webapp/app/v3/services/bulk/performBulkAction.server.ts b/apps/webapp/app/v3/services/bulk/performBulkAction.server.ts
index dc2a8d11ded..e535fd7db32 100644
--- a/apps/webapp/app/v3/services/bulk/performBulkAction.server.ts
+++ b/apps/webapp/app/v3/services/bulk/performBulkAction.server.ts
@@ -27,7 +27,7 @@ export class PerformBulkActionService extends BaseService {
     switch (item.group.type) {
       case "REPLAY": {
         const service = new ReplayTaskRunService(this._prisma);
-        const result = await service.call(item.sourceRun);
+        const result = await service.call(item.sourceRun, { triggerSource: "dashboard" });
 
         await this._prisma.bulkActionItem.update({
           where: { id: item.id },
diff --git a/apps/webapp/app/v3/services/cancelTaskRun.server.ts b/apps/webapp/app/v3/services/cancelTaskRun.server.ts
index 0c27a0b957f..76db56535ae 100644
--- a/apps/webapp/app/v3/services/cancelTaskRun.server.ts
+++ b/apps/webapp/app/v3/services/cancelTaskRun.server.ts
@@ -8,6 +8,8 @@ export type CancelTaskRunServiceOptions = {
   cancelAttempts?: boolean;
   cancelledAt?: Date;
   bulkActionId?: string;
+  /** Skip PENDING_CANCEL and finalize immediately (use when the worker is known to be dead). */
+  finalizeRun?: boolean;
 };
 
 type CancelTaskRunServiceResult = {
@@ -57,6 +59,7 @@ export class CancelTaskRunService extends BaseService {
       runId: taskRun.id,
       completedAt: options?.cancelledAt,
       reason: options?.reason,
+      finalizeRun: options?.finalizeRun,
       bulkActionId: options?.bulkActionId,
       tx: this._prisma,
     });
diff --git a/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts b/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts
index bc0dd04eaa5..00360df946c 100644
--- a/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts
+++ b/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts
@@ -7,7 +7,11 @@ import { CURRENT_DEPLOYMENT_LABEL } from "@trigger.dev/core/v3/isomorphic";
 export type ChangeCurrentDeploymentDirection = "promote" | "rollback";
 
 export class ChangeCurrentDeploymentService extends BaseService {
-  public async call(deployment: WorkerDeployment, direction: ChangeCurrentDeploymentDirection) {
+  public async call(
+    deployment: WorkerDeployment,
+    direction: ChangeCurrentDeploymentDirection,
+    disableVersionCheck?: boolean
+  ) {
     if (!deployment.workerId) {
       throw new ServiceValidationError(
         direction === "promote"
@@ -42,26 +46,34 @@ export class ChangeCurrentDeploymentService extends BaseService {
       }
 
       // if there is a current promotion, we have to validate we are moving in the right direction based on the deployment versions
-      switch (direction) {
-        case "promote": {
-          if (
-            compareDeploymentVersions(currentPromotion.deployment.version, deployment.version) >= 0
-          ) {
-            throw new ServiceValidationError(
-              "Cannot promote a deployment that is older than the current deployment."
-            );
+      if (!disableVersionCheck) {
+        switch (direction) {
+          case "promote": {
+            if (
+              compareDeploymentVersions(
+                currentPromotion.deployment.version,
+                deployment.version
+              ) >= 0
+            ) {
+              throw new ServiceValidationError(
+                "Cannot promote a deployment that is older than the current deployment."
+              );
+            }
+            break;
           }
-          break;
-        }
-        case "rollback": {
-          if (
-            compareDeploymentVersions(currentPromotion.deployment.version, deployment.version) <= 0
-          ) {
-            throw new ServiceValidationError(
-              "Cannot rollback to a deployment that is newer than the current deployment."
-            );
+          case "rollback": {
+            if (
+              compareDeploymentVersions(
+                currentPromotion.deployment.version,
+                deployment.version
+              ) <= 0
+            ) {
+              throw new ServiceValidationError(
+                "Cannot rollback to a deployment that is newer than the current deployment."
+              );
+            }
+            break;
           }
-          break;
         }
       }
     }
diff --git a/apps/webapp/app/v3/services/checkSchedule.server.ts b/apps/webapp/app/v3/services/checkSchedule.server.ts
index 25a0944dc6e..7c85641c404 100644
--- a/apps/webapp/app/v3/services/checkSchedule.server.ts
+++ b/apps/webapp/app/v3/services/checkSchedule.server.ts
@@ -92,7 +92,7 @@ export class CheckScheduleService extends BaseService {
       const limit = await getLimit(project.organizationId, "schedules", 100_000_000);
       const schedulesCount = await CheckScheduleService.getUsedSchedulesCount({
         prisma: this._prisma,
-        environments: project.environments,
+        projectId,
       });
 
       if (schedulesCount >= limit) {
@@ -105,26 +105,25 @@ export class CheckScheduleService extends BaseService {
 
   static async getUsedSchedulesCount({
     prisma,
-    environments,
+    projectId,
   }: {
     prisma: PrismaClientOrTransaction;
-    environments: { id: string; type: RuntimeEnvironmentType; archivedAt: Date | null }[];
+    projectId: string;
   }) {
-    const deployedEnvironments = environments.filter(
-      (env) => env.type !== "DEVELOPMENT" && !env.archivedAt
-    );
-    const schedulesCount = await prisma.taskScheduleInstance.count({
+    return await prisma.taskScheduleInstance.count({
       where: {
-        environmentId: {
-          in: deployedEnvironments.map((env) => env.id),
-        },
+        projectId,
         active: true,
+        environment: {
+          type: {
+            not: "DEVELOPMENT",
+          },
+          archivedAt: null,
+        },
         taskSchedule: {
           active: true,
         },
       },
     });
-
-    return schedulesCount;
   }
 }
diff --git a/apps/webapp/app/v3/services/common.server.ts b/apps/webapp/app/v3/services/common.server.ts
index 31f401e00e5..015e8e23d53 100644
--- a/apps/webapp/app/v3/services/common.server.ts
+++ b/apps/webapp/app/v3/services/common.server.ts
@@ -1,5 +1,11 @@
+export type ServiceValidationErrorLevel = "error" | "warn" | "info";
+
 export class ServiceValidationError extends Error {
-  constructor(message: string, public status?: number) {
+  constructor(
+    message: string,
+    public status?: number,
+    public logLevel?: ServiceValidationErrorLevel
+  ) {
     super(message);
     this.name = "ServiceValidationError";
   }
diff --git a/apps/webapp/app/v3/services/computeTemplateCreation.server.ts b/apps/webapp/app/v3/services/computeTemplateCreation.server.ts
new file mode 100644
index 00000000000..4daa2667f25
--- /dev/null
+++ b/apps/webapp/app/v3/services/computeTemplateCreation.server.ts
@@ -0,0 +1,186 @@
+import { ComputeClient, stripImageDigest } from "@internal/compute";
+import { machinePresetFromName } from "~/v3/machinePresets.server";
+import { env } from "~/env.server";
+import { logger } from "~/services/logger.server";
+import type { PrismaClientOrTransaction } from "~/db.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag } from "~/v3/featureFlags.server";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { ServiceValidationError } from "./baseService.server";
+import { FailDeploymentService } from "./failDeployment.server";
+
+type TemplateCreationMode = "required" | "shadow" | "skip";
+
+export class ComputeTemplateCreationService {
+  private client: ComputeClient | undefined;
+
+  constructor() {
+    if (env.COMPUTE_GATEWAY_URL) {
+      this.client = new ComputeClient({
+        gatewayUrl: env.COMPUTE_GATEWAY_URL,
+        authToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
+        timeoutMs: 5 * 60 * 1000, // 5 minutes
+      });
+    }
+  }
+
+  /**
+   * Handle template creation for a deployment. Call this before setting DEPLOYED.
+   *
+   * - Required mode: creates template synchronously, fails deployment on error
+   * - Shadow mode: fires background template creation (returns immediately)
+   * - Skip: no-op
+   *
+   * Throws ServiceValidationError if required mode fails (caller should stop finalize).
+   */
+  async handleDeployTemplate(options: {
+    projectId: string;
+    imageReference: string;
+    deploymentFriendlyId: string;
+    authenticatedEnv: AuthenticatedEnvironment;
+    prisma: PrismaClientOrTransaction;
+    writer?: WritableStreamDefaultWriter;
+  }): Promise<void> {
+    const mode = await this.resolveMode(options.projectId, options.prisma);
+
+    if (mode === "skip") {
+      return;
+    }
+
+    if (mode === "shadow") {
+      this.createTemplate(options.imageReference, { background: true })
+        .then((result) => {
+          if (!result.success) {
+            logger.error("Shadow template creation failed", {
+              id: options.deploymentFriendlyId,
+              imageReference: options.imageReference,
+              error: result.error,
+            });
+          }
+        })
+        .catch((error) => {
+          logger.error("Shadow template creation threw unexpectedly", {
+            id: options.deploymentFriendlyId,
+            imageReference: options.imageReference,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+      return;
+    }
+
+    // Required mode
+    if (options.writer) {
+      try {
+        await options.writer.write(
+          `event: log\ndata: ${JSON.stringify({ message: "Building compute template..." })}\n\n`
+        );
+      } catch {
+        // Stream may be closed if client disconnected - continue with template creation
+      }
+    }
+
+    logger.info("Creating compute template (required mode)", {
+      id: options.deploymentFriendlyId,
+      imageReference: options.imageReference,
+    });
+
+    const result = await this.createTemplate(options.imageReference);
+
+    if (!result.success) {
+      logger.error("Compute template creation failed", {
+        id: options.deploymentFriendlyId,
+        imageReference: options.imageReference,
+        error: result.error,
+      });
+
+      const failService = new FailDeploymentService();
+      await failService.call(options.authenticatedEnv, options.deploymentFriendlyId, {
+        error: {
+          name: "TemplateCreationFailed",
+          message: `Failed to create compute template: ${result.error}`,
+        },
+      });
+
+      throw new ServiceValidationError(
+        `Compute template creation failed: ${result.error}`
+      );
+    }
+
+    logger.info("Compute template created", {
+      id: options.deploymentFriendlyId,
+      imageReference: options.imageReference,
+    });
+  }
+
+  async resolveMode(
+    projectId: string,
+    prisma: PrismaClientOrTransaction
+  ): Promise<TemplateCreationMode> {
+    if (!this.client) {
+      return "skip";
+    }
+
+    const project = await prisma.project.findFirst({
+      where: { id: projectId },
+      select: {
+        defaultWorkerGroup: {
+          select: { workloadType: true },
+        },
+        organization: {
+          select: { featureFlags: true },
+        },
+      },
+    });
+
+    if (project?.defaultWorkerGroup?.workloadType === "MICROVM") {
+      return "required";
+    }
+
+    const flag = makeFlag(prisma);
+    const hasComputeAccess = await flag({
+      key: FEATURE_FLAG.hasComputeAccess,
+      defaultValue: false,
+      overrides: (project?.organization?.featureFlags as Record<string, unknown>) ?? {},
+    });
+
+    if (hasComputeAccess) {
+      return "shadow";
+    }
+
+    const rolloutPct = Number(env.COMPUTE_TEMPLATE_SHADOW_ROLLOUT_PCT ?? "0");
+    if (rolloutPct > 0 && Math.random() * 100 < rolloutPct) {
+      return "shadow";
+    }
+
+    return "skip";
+  }
+
+  async createTemplate(
+    imageReference: string,
+    options?: { background?: boolean }
+  ): Promise<{ success: boolean; error?: string }> {
+    if (!this.client) {
+      return { success: false, error: "Compute gateway not configured" };
+    }
+
+    try {
+      // Templates are resource-agnostic - these values don't affect template content.
+      const machine = machinePresetFromName("small-1x");
+
+      await this.client.templates.create({
+        image: stripImageDigest(imageReference),
+        cpu: machine.cpu,
+        memory_gb: machine.memory,
+        background: options?.background,
+      });
+      return { success: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to create compute template", {
+        imageReference,
+        error: message,
+      });
+      return { success: false, error: message };
+    }
+  }
+}
diff --git a/apps/webapp/app/v3/services/createBackgroundWorker.server.ts b/apps/webapp/app/v3/services/createBackgroundWorker.server.ts
index 41fbf2afe27..1b51ec04aee 100644
--- a/apps/webapp/app/v3/services/createBackgroundWorker.server.ts
+++ b/apps/webapp/app/v3/services/createBackgroundWorker.server.ts
@@ -2,13 +2,14 @@ import {
   BackgroundWorkerMetadata,
   BackgroundWorkerSourceFileMetadata,
   CreateBackgroundWorkerRequestBody,
+  PromptResource,
   QueueManifest,
   TaskResource,
 } from "@trigger.dev/core/v3";
-import { BackgroundWorkerId } from "@trigger.dev/core/v3/isomorphic";
+import { BackgroundWorkerId, stringifyDuration } from "@trigger.dev/core/v3/isomorphic";
 import type { BackgroundWorker, TaskQueue, TaskQueueType } from "@trigger.dev/database";
 import cronstrue from "cronstrue";
-import { Prisma, PrismaClientOrTransaction } from "~/db.server";
+import { $transaction, Prisma, PrismaClientOrTransaction } from "~/db.server";
 import { sanitizeQueueName } from "~/models/taskQueue.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
@@ -216,6 +217,11 @@ export async function createWorkerResources(
 
   // Create the tasks
   await createWorkerTasks(metadata, queues, worker, environment, prisma, tasksToBackgroundFiles);
+
+  // Register prompts
+  if (metadata.prompts && metadata.prompts.length > 0) {
+    await createWorkerPrompts(metadata.prompts, worker, environment, prisma);
+  }
 }
 
 async function createWorkerTasks(
@@ -280,6 +286,8 @@ async function createWorkerTask(
         triggerSource: task.triggerSource === "schedule" ? "SCHEDULED" : "STANDARD",
         fileId: tasksToBackgroundFiles?.get(task.id) ?? null,
         maxDurationInSeconds: task.maxDuration ? clampMaxDuration(task.maxDuration) : null,
+        ttl:
+          typeof task.ttl === "number" ? stringifyDuration(task.ttl) ?? null : task.ttl ?? null,
         queueId: queue.id,
         payloadSchema: task.payloadSchema as any,
       },
@@ -593,6 +601,7 @@ export async function syncDeclarativeSchedules(
             create: [
               {
                 environmentId: environment.id,
+                projectId: environment.projectId,
               },
             ],
           },
@@ -700,3 +709,133 @@ export async function createBackgroundFiles(
 
   return results;
 }
+
+import { createHash } from "crypto";
+
+function hashContent(content: string): string {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+async function createWorkerPrompts(
+  prompts: PromptResource[],
+  worker: BackgroundWorker,
+  environment: AuthenticatedEnvironment,
+  prisma: PrismaClientOrTransaction
+) {
+  for (const promptResource of prompts) {
+    try {
+      // Upsert the Prompt record (identity + schema)
+      const prompt = await prisma.prompt.upsert({
+        where: {
+          projectId_runtimeEnvironmentId_slug: {
+            projectId: worker.projectId,
+            runtimeEnvironmentId: environment.id,
+            slug: promptResource.id,
+          },
+        },
+        create: {
+          friendlyId: generateFriendlyId("prompt"),
+          organizationId: environment.organizationId,
+          projectId: worker.projectId,
+          runtimeEnvironmentId: environment.id,
+          slug: promptResource.id,
+          description: promptResource.description,
+          filePath: promptResource.filePath,
+          exportName: promptResource.exportName,
+          variableSchema: promptResource.variableSchema as any,
+          defaultModel: promptResource.model,
+          defaultConfig: promptResource.config as any,
+        },
+        update: {
+          description: promptResource.description,
+          filePath: promptResource.filePath,
+          exportName: promptResource.exportName,
+          variableSchema: promptResource.variableSchema as any,
+          defaultModel: promptResource.model,
+          defaultConfig: promptResource.config as any,
+        },
+      });
+
+      // Compute content hash for dedup
+      const contentString = promptResource.content ?? "";
+      const contentHash = hashContent(contentString);
+
+      // Find the latest version overall (for version numbering) and the latest
+      // code-sourced version (for content dedup). We compare against the latest
+      // code version specifically so that dashboard edits don't interfere with
+      // dedup — if the code hasn't changed since the last deploy, we skip even
+      // if a dashboard edit happened in between.
+      const latestVersion = await prisma.promptVersion.findFirst({
+        where: { promptId: prompt.id },
+        orderBy: { version: "desc" },
+      });
+
+      const latestCodeVersion = await prisma.promptVersion.findFirst({
+        where: { promptId: prompt.id, source: "code" },
+        orderBy: { version: "desc" },
+      });
+
+      if (latestCodeVersion?.contentHash === contentHash) {
+        // Code content unchanged since last deploy — skip creating a new version
+        continue;
+      }
+
+      const nextVersion = (latestVersion?.version ?? 0) + 1;
+
+      // Determine labels for the new version.
+      // Deploys always move "current" to the new code version. If a dashboard
+      // override exists, it sits on top via the "override" label and the API
+      // serves that instead — so "current" movement is safe.
+      const labels = ["latest", "current"];
+
+      // Wrap label removal + version creation in a transaction so labels
+      // aren't stripped if the create fails (e.g. concurrent deploy race).
+      await $transaction(prisma, async (tx) => {
+        // Remove "latest" label from all existing versions
+        if (latestVersion) {
+          await tx.$executeRaw`
+            UPDATE "prompt_versions"
+            SET "labels" = array_remove("labels", 'latest')
+            WHERE "promptId" = ${prompt.id} AND 'latest' = ANY("labels")
+          `;
+        }
+
+        // Remove "current" from any existing version
+        await tx.$executeRaw`
+          UPDATE "prompt_versions"
+          SET "labels" = array_remove("labels", 'current')
+          WHERE "promptId" = ${prompt.id} AND 'current' = ANY("labels")
+        `;
+
+        await tx.promptVersion.create({
+          data: {
+            promptId: prompt.id,
+            version: nextVersion,
+            textContent: contentString,
+            model: promptResource.model,
+            config: promptResource.config as any,
+            source: "code",
+            contentHash,
+            labels,
+            workerId: worker.id,
+          },
+        });
+      });
+
+      logger.debug("Registered prompt version", {
+        promptSlug: promptResource.id,
+        version: nextVersion,
+        labels,
+      });
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2002") {
+        logger.warn("Prompt version already exists", { prompt: promptResource.id });
+      } else {
+        logger.error("Error creating prompt version", {
+          error: error instanceof Error ? error.message : String(error),
+          prompt: promptResource.id,
+        });
+      }
+    }
+  }
+}
diff --git a/apps/webapp/app/v3/services/deployment.server.ts b/apps/webapp/app/v3/services/deployment.server.ts
index 11d659ab221..71292f4093b 100644
--- a/apps/webapp/app/v3/services/deployment.server.ts
+++ b/apps/webapp/app/v3/services/deployment.server.ts
@@ -2,13 +2,18 @@ import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { BaseService } from "./baseService.server";
 import { errAsync, fromPromise, okAsync, type ResultAsync } from "neverthrow";
 import { type WorkerDeployment, type Project } from "@trigger.dev/database";
-import { logger, type GitMeta, type DeploymentEvent } from "@trigger.dev/core/v3";
+import {
+  BuildServerMetadata,
+  logger,
+  type GitMeta,
+  type DeploymentEvent,
+} from "@trigger.dev/core/v3";
 import { TimeoutDeploymentService } from "./timeoutDeployment.server";
 import { env } from "~/env.server";
 import { createRemoteImageBuild } from "../remoteImageBuilder.server";
 import { FINAL_DEPLOYMENT_STATUSES } from "./failDeployment.server";
 import { enqueueBuild, generateRegistryCredentials } from "~/services/platform.v3.server";
-import { AppendRecord, S2 } from "@s2-dev/streamstore";
+import { AppendInput, AppendRecord, S2 } from "@s2-dev/streamstore";
 import { createRedisClient } from "~/redis.server";
 
 const S2_TOKEN_KEY_PREFIX = "s2-token:read:deployment-event-stream:project:";
@@ -38,9 +43,20 @@ export class DeploymentService extends BaseService {
   public progressDeployment(
     authenticatedEnv: AuthenticatedEnvironment,
     friendlyId: string,
-    updates: Partial<Pick<WorkerDeployment, "contentHash" | "runtime"> & { git: GitMeta }>
+    updates: Partial<
+      Pick<WorkerDeployment, "contentHash" | "runtime"> & {
+        git: GitMeta;
+        buildServerMetadata: BuildServerMetadata;
+      }
+    >
   ) {
-    const validateDeployment = (deployment: Pick<WorkerDeployment, "id" | "status">) => {
+    const { buildServerMetadata: newBuildServerMetadata, ...restUpdates } = updates;
+
+    const validateDeployment = (
+      deployment: Pick<WorkerDeployment, "id" | "status"> & {
+        buildServerMetadata?: BuildServerMetadata;
+      }
+    ) => {
       if (deployment.status !== "PENDING" && deployment.status !== "INSTALLING") {
         logger.warn(
           "Attempted progressing deployment that is not in PENDING or INSTALLING status",
@@ -54,12 +70,24 @@ export class DeploymentService extends BaseService {
       return okAsync(deployment);
     };
 
-    const progressToInstalling = (deployment: Pick<WorkerDeployment, "id">) =>
-      fromPromise(
+    const progressToInstalling = (
+      deployment: Pick<WorkerDeployment, "id"> & { buildServerMetadata?: BuildServerMetadata }
+    ) => {
+      const existingBuildServerMetadata = deployment.buildServerMetadata;
+
+      return fromPromise(
         this._prisma.workerDeployment.updateMany({
           where: { id: deployment.id, status: "PENDING" }, // status could've changed in the meantime, we're not locking the row
           data: {
-            ...updates,
+            ...restUpdates,
+            ...(newBuildServerMetadata
+              ? {
+                  buildServerMetadata: {
+                    ...(existingBuildServerMetadata ?? {}),
+                    ...newBuildServerMetadata,
+                  },
+                }
+              : {}),
             status: "INSTALLING",
             startedAt: new Date(),
           },
@@ -74,22 +102,39 @@ export class DeploymentService extends BaseService {
         }
         return okAsync({ id: deployment.id, status: "INSTALLING" as const });
       });
+    };
 
-    const createRemoteBuild = (deployment: Pick<WorkerDeployment, "id">) =>
-      fromPromise(createRemoteImageBuild(authenticatedEnv.project), (error) => ({
-        type: "failed_to_create_remote_build" as const,
-        cause: error,
-      }));
+    const progressToBuilding = (
+      deployment: Pick<WorkerDeployment, "id"> & { buildServerMetadata?: BuildServerMetadata }
+    ) => {
+      const createRemoteBuildIfNeeded = deployment.buildServerMetadata?.isNativeBuild
+        ? okAsync(undefined)
+        : fromPromise(createRemoteImageBuild(authenticatedEnv.project), (error) => ({
+            type: "failed_to_create_remote_build" as const,
+            cause: error,
+          }));
+
+      const existingBuildServerMetadata = deployment.buildServerMetadata as
+        | BuildServerMetadata
+        | null
+        | undefined;
 
-    const progressToBuilding = (deployment: Pick<WorkerDeployment, "id">) =>
-      createRemoteBuild(deployment)
+      return createRemoteBuildIfNeeded
         .andThen((externalBuildData) =>
           fromPromise(
             this._prisma.workerDeployment.updateMany({
               where: { id: deployment.id, status: "INSTALLING" }, // status could've changed in the meantime, we're not locking the row
               data: {
-                ...updates,
-                externalBuildData,
+                ...restUpdates,
+                ...(newBuildServerMetadata
+                  ? {
+                      buildServerMetadata: {
+                        ...(existingBuildServerMetadata ?? {}),
+                        ...newBuildServerMetadata,
+                      },
+                    }
+                  : {}),
+                ...(externalBuildData ? { externalBuildData } : {}),
                 status: "BUILDING",
                 installedAt: new Date(),
               },
@@ -106,6 +151,7 @@ export class DeploymentService extends BaseService {
           }
           return okAsync({ id: deployment.id, status: "BUILDING" as const });
         });
+    };
 
     const extendTimeout = (deployment: Pick<WorkerDeployment, "id" | "status">) =>
       fromPromise(
@@ -322,7 +368,11 @@ export class DeploymentService extends BaseService {
     );
 
     return fromPromise(
-      stream.append(events.map((event) => AppendRecord.make(JSON.stringify(event)))),
+      stream.append(
+        AppendInput.create(
+          events.map((event) => AppendRecord.string({ body: JSON.stringify(event) }))
+        )
+      ),
       (error) => ({
         type: "failed_to_append_to_event_log" as const,
         cause: error,
@@ -350,9 +400,9 @@ export class DeploymentService extends BaseService {
         type: "failed_to_create_event_stream" as const,
         cause: error,
       })
-    ).map(({ name }) => ({
+    ).map(() => ({
       basin: basin.name,
-      stream: name,
+      stream: `projects/${project.externalRef}/deployments/${deployment.shortCode}`,
     }));
   }
 
@@ -380,7 +430,7 @@ export class DeploymentService extends BaseService {
       fromPromise(
         s2.accessTokens.issue({
           id: `${project.externalRef}-${new Date().getTime()}`,
-          expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour
+          expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 1 hour
           scope: {
             ops: ["read"],
             basins: {
@@ -395,7 +445,7 @@ export class DeploymentService extends BaseService {
           type: "other" as const,
           cause: error,
         })
-      ).map(({ access_token }) => access_token);
+      ).map(({ accessToken }) => accessToken);
 
     const cacheToken = (token: string) =>
       fromPromise(
@@ -432,6 +482,7 @@ export class DeploymentService extends BaseService {
         select: {
           status: true,
           id: true,
+          buildServerMetadata: true,
           imageReference: true,
           shortCode: true,
           environment: {
@@ -449,11 +500,16 @@ export class DeploymentService extends BaseService {
         type: "other" as const,
         cause: error,
       })
-    ).andThen((deployment) => {
-      if (!deployment) {
-        return errAsync({ type: "deployment_not_found" as const });
-      }
-      return okAsync(deployment);
-    });
+    )
+      .andThen((deployment) => {
+        if (!deployment) {
+          return errAsync({ type: "deployment_not_found" as const });
+        }
+        return okAsync(deployment);
+      })
+      .map((deployment) => ({
+        ...deployment,
+        buildServerMetadata: BuildServerMetadata.safeParse(deployment.buildServerMetadata).data,
+      }));
   }
 }
diff --git a/apps/webapp/app/v3/services/errorGroupActions.server.ts b/apps/webapp/app/v3/services/errorGroupActions.server.ts
new file mode 100644
index 00000000000..c026efe2aba
--- /dev/null
+++ b/apps/webapp/app/v3/services/errorGroupActions.server.ts
@@ -0,0 +1,144 @@
+import { type PrismaClientOrTransaction, prisma } from "~/db.server";
+
+type ErrorGroupIdentifier = {
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  taskIdentifier: string;
+  errorFingerprint: string;
+};
+
+export class ErrorGroupActions {
+  constructor(private readonly _prisma: PrismaClientOrTransaction = prisma) {}
+
+  async resolveError(
+    identifier: ErrorGroupIdentifier,
+    params: {
+      userId: string;
+      resolvedInVersion?: string;
+    }
+  ) {
+    const where = {
+      environmentId_taskIdentifier_errorFingerprint: {
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+      },
+    };
+
+    const now = new Date();
+
+    return this._prisma.errorGroupState.upsert({
+      where,
+      update: {
+        status: "RESOLVED",
+        resolvedAt: now,
+        resolvedInVersion: params.resolvedInVersion ?? null,
+        resolvedBy: params.userId,
+        ignoredUntil: null,
+        ignoredUntilOccurrenceRate: null,
+        ignoredUntilTotalOccurrences: null,
+        ignoredAtOccurrenceCount: null,
+        ignoredAt: null,
+        ignoredReason: null,
+        ignoredByUserId: null,
+      },
+      create: {
+        organizationId: identifier.organizationId,
+        projectId: identifier.projectId,
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+        status: "RESOLVED",
+        resolvedAt: now,
+        resolvedInVersion: params.resolvedInVersion ?? null,
+        resolvedBy: params.userId,
+      },
+    });
+  }
+
+  async ignoreError(
+    identifier: ErrorGroupIdentifier,
+    params: {
+      userId: string;
+      duration?: number;
+      occurrenceRateThreshold?: number;
+      totalOccurrencesThreshold?: number;
+      occurrenceCountAtIgnoreTime?: number;
+      reason?: string;
+    }
+  ) {
+    const where = {
+      environmentId_taskIdentifier_errorFingerprint: {
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+      },
+    };
+
+    const now = new Date();
+    const ignoredUntil = params.duration ? new Date(now.getTime() + params.duration) : null;
+
+    const data = {
+      status: "IGNORED" as const,
+      ignoredAt: now,
+      ignoredUntil,
+      ignoredUntilOccurrenceRate: params.occurrenceRateThreshold ?? null,
+      ignoredUntilTotalOccurrences: params.totalOccurrencesThreshold ?? null,
+      ignoredAtOccurrenceCount: params.occurrenceCountAtIgnoreTime ?? null,
+      ignoredReason: params.reason ?? null,
+      ignoredByUserId: params.userId,
+      resolvedAt: null,
+      resolvedInVersion: null,
+      resolvedBy: null,
+    };
+
+    return this._prisma.errorGroupState.upsert({
+      where,
+      update: data,
+      create: {
+        organizationId: identifier.organizationId,
+        projectId: identifier.projectId,
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+        ...data,
+      },
+    });
+  }
+
+  async unresolveError(identifier: ErrorGroupIdentifier) {
+    const where = {
+      environmentId_taskIdentifier_errorFingerprint: {
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+      },
+    };
+
+    return this._prisma.errorGroupState.upsert({
+      where,
+      update: {
+        status: "UNRESOLVED",
+        resolvedAt: null,
+        resolvedInVersion: null,
+        resolvedBy: null,
+        ignoredUntil: null,
+        ignoredUntilOccurrenceRate: null,
+        ignoredUntilTotalOccurrences: null,
+        ignoredAtOccurrenceCount: null,
+        ignoredAt: null,
+        ignoredReason: null,
+        ignoredByUserId: null,
+      },
+      create: {
+        organizationId: identifier.organizationId,
+        projectId: identifier.projectId,
+        environmentId: identifier.environmentId,
+        taskIdentifier: identifier.taskIdentifier,
+        errorFingerprint: identifier.errorFingerprint,
+        status: "UNRESOLVED",
+      },
+    });
+  }
+}
diff --git a/apps/webapp/app/v3/services/executeTasksWaitingForDeploy.ts b/apps/webapp/app/v3/services/executeTasksWaitingForDeploy.ts
index 931c8046148..7839b9e6e07 100644
--- a/apps/webapp/app/v3/services/executeTasksWaitingForDeploy.ts
+++ b/apps/webapp/app/v3/services/executeTasksWaitingForDeploy.ts
@@ -33,7 +33,7 @@ export class ExecuteTasksWaitingForDeployService extends BaseService {
 
     const maxCount = env.LEGACY_RUN_ENGINE_WAITING_FOR_DEPLOY_BATCH_SIZE;
 
-    const runsWaitingForDeploy = await this._prisma.taskRun.findMany({
+    const runsWaitingForDeploy = await this._replica.taskRun.findMany({
       where: {
         runtimeEnvironmentId: backgroundWorker.runtimeEnvironmentId,
         projectId: backgroundWorker.projectId,
diff --git a/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts b/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts
index 2ad2b7b8258..7ca8a379a3d 100644
--- a/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts
+++ b/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts
@@ -15,6 +15,7 @@ import { remoteBuildsEnabled } from "../remoteImageBuilder.server";
 import { getEcrAuthToken, isEcrRegistry } from "../getDeploymentImageRef.server";
 import { tryCatch } from "@trigger.dev/core";
 import { getRegistryConfig, type RegistryConfig } from "../registryConfig.server";
+import { ComputeTemplateCreationService } from "./computeTemplateCreation.server";
 
 export class FinalizeDeploymentV2Service extends BaseService {
   public async call(
@@ -23,12 +24,6 @@ export class FinalizeDeploymentV2Service extends BaseService {
     body: FinalizeDeploymentRequestBody,
     writer?: WritableStreamDefaultWriter
   ) {
-    // If remote builds are not enabled, lets just use the v1 finalize deployment service
-    if (!remoteBuildsEnabled()) {
-      const finalizeService = new FinalizeDeploymentService();
-      return finalizeService.call(authenticatedEnv, id, body);
-    }
-
     const deployment = await this._prisma.workerDeployment.findFirst({
       where: {
         friendlyId: id,
@@ -62,7 +57,6 @@ export class FinalizeDeploymentV2Service extends BaseService {
 
     if (deployment.status === "DEPLOYED") {
       logger.debug("Worker deployment is already deployed", { id });
-
       return deployment;
     }
 
@@ -73,11 +67,16 @@ export class FinalizeDeploymentV2Service extends BaseService {
 
     const finalizeService = new FinalizeDeploymentService();
 
-    if (body.skipPushToRegistry) {
-      logger.debug("Skipping push to registry during deployment finalization", {
-        deployment,
-      });
-      return await finalizeService.call(authenticatedEnv, id, body);
+    // If remote builds are not enabled, skip image push and go straight to template + finalize
+    if (!remoteBuildsEnabled() || body.skipPushToRegistry) {
+      if (body.skipPushToRegistry) {
+        logger.debug("Skipping push to registry during deployment finalization", {
+          deployment,
+        });
+      }
+
+      await this.#createTemplateIfNeeded(deployment, id, authenticatedEnv, writer);
+      return finalizeService.call(authenticatedEnv, id, body);
     }
 
     const externalBuildData = deployment.externalBuildData
@@ -143,9 +142,29 @@ export class FinalizeDeploymentV2Service extends BaseService {
       pushedImage: pushResult.image,
     });
 
-    const finalizedDeployment = await finalizeService.call(authenticatedEnv, id, body);
+    await this.#createTemplateIfNeeded(deployment, id, authenticatedEnv, writer);
+    return finalizeService.call(authenticatedEnv, id, body);
+  }
 
-    return finalizedDeployment;
+  async #createTemplateIfNeeded(
+    deployment: { imageReference: string | null; worker: { project: { id: string } } | null },
+    deploymentFriendlyId: string,
+    authenticatedEnv: AuthenticatedEnvironment,
+    writer?: WritableStreamDefaultWriter
+  ): Promise<void> {
+    if (!deployment.imageReference || !deployment.worker) {
+      return;
+    }
+
+    const templateService = new ComputeTemplateCreationService();
+    await templateService.handleDeployTemplate({
+      projectId: deployment.worker.project.id,
+      imageReference: deployment.imageReference,
+      deploymentFriendlyId,
+      authenticatedEnv,
+      prisma: this._prisma,
+      writer,
+    });
   }
 }
 
diff --git a/apps/webapp/app/v3/services/initializeDeployment.server.ts b/apps/webapp/app/v3/services/initializeDeployment.server.ts
index 52a968792c5..987925aa709 100644
--- a/apps/webapp/app/v3/services/initializeDeployment.server.ts
+++ b/apps/webapp/app/v3/services/initializeDeployment.server.ts
@@ -1,4 +1,8 @@
-import { BuildServerMetadata, type InitializeDeploymentRequestBody } from "@trigger.dev/core/v3";
+import {
+  BuildServerMetadata,
+  type InitializeDeploymentRequestBody,
+  type ExternalBuildData,
+} from "@trigger.dev/core/v3";
 import { customAlphabet } from "nanoid";
 import { env } from "~/env.server";
 import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
@@ -89,12 +93,18 @@ export class InitializeDeploymentService extends BaseService {
         );
       }
 
-      // For the `PENDING` initial status, defer the creation of the Depot build until the deployment is started.
-      // This helps avoid Depot token expiration issues.
-      const externalBuildData =
-        payload.initialStatus === "PENDING" || payload.isNativeBuild
-          ? undefined
-          : await createRemoteImageBuild(environment.project);
+      // For the `PENDING` initial status, defer the creation of the Depot build until the deployment is started to avoid token expiration issues.
+      // For local and native builds we don't need to generate the Depot tokens. We still need to create an empty object sadly due to a bug in older CLI versions.
+      const generateExternalBuildToken =
+        payload.initialStatus === "PENDING" || payload.isNativeBuild || payload.isLocalBuild;
+
+      const externalBuildData = generateExternalBuildToken
+        ? ({
+            projectId: "-",
+            buildToken: "-",
+            buildId: "-",
+          } satisfies ExternalBuildData)
+        : await createRemoteImageBuild(environment.project);
 
       const triggeredBy = payload.userId
         ? await this._prisma.user.findFirst({
@@ -200,6 +210,7 @@ export class InitializeDeploymentService extends BaseService {
                     artifactKey: payload.artifactKey,
                     skipPromotion: payload.skipPromotion,
                     configFilePath: payload.configFilePath,
+                    skipEnqueue: payload.skipEnqueue,
                   }
                 : {}),
             }
@@ -221,6 +232,7 @@ export class InitializeDeploymentService extends BaseService {
           imageReference: imageRef,
           imagePlatform: env.DEPLOY_IMAGE_PLATFORM,
           git: payload.gitMeta ?? undefined,
+          commitSHA: payload.gitMeta?.commitSha ?? undefined,
           runtime: payload.runtime ?? undefined,
           triggeredVia: payload.triggeredVia ?? undefined,
           startedAt: initialStatus === "BUILDING" ? new Date() : undefined,
@@ -237,7 +249,8 @@ export class InitializeDeploymentService extends BaseService {
         new Date(Date.now() + timeoutMs)
       );
 
-      if (payload.isNativeBuild) {
+      // For github integration there is no artifactKey, hence we skip it here
+      if (payload.isNativeBuild && payload.artifactKey && !payload.skipEnqueue) {
         const result = await deploymentService
           .enqueueBuild(environment, deployment, payload.artifactKey, {
             skipPromotion: payload.skipPromotion,
diff --git a/apps/webapp/app/v3/services/promptService.server.ts b/apps/webapp/app/v3/services/promptService.server.ts
new file mode 100644
index 00000000000..ab2729fc235
--- /dev/null
+++ b/apps/webapp/app/v3/services/promptService.server.ts
@@ -0,0 +1,162 @@
+import { createHash } from "crypto";
+import { prisma } from "~/db.server";
+import { BaseService, ServiceValidationError } from "./baseService.server";
+
+export class PromptService extends BaseService {
+  async promoteVersion(promptId: string, versionId: string, options?: { sourceGuard?: boolean }) {
+    const target = await this._prisma.promptVersion.findUnique({
+      where: { id: versionId },
+    });
+
+    if (!target) {
+      throw new ServiceValidationError("Version not found", 404);
+    }
+
+    if (target.promptId !== promptId) {
+      throw new ServiceValidationError("Version does not belong to this prompt", 400);
+    }
+
+    if (options?.sourceGuard && target.source !== "code") {
+      throw new ServiceValidationError(
+        "Only code-sourced versions can be promoted. Use the override API instead.",
+        400
+      );
+    }
+
+    await prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`
+        UPDATE "prompt_versions"
+        SET "labels" = array_remove("labels", 'current')
+        WHERE "promptId" = ${promptId} AND 'current' = ANY("labels")
+      `;
+      await tx.$executeRaw`
+        UPDATE "prompt_versions"
+        SET "labels" = array_append("labels", 'current')
+        WHERE "id" = ${versionId} AND NOT ('current' = ANY("labels"))
+      `;
+    });
+  }
+
+  async createOverride(
+    promptId: string,
+    data: {
+      textContent: string;
+      model?: string;
+      commitMessage?: string;
+      source?: string;
+      createdBy?: string;
+    }
+  ) {
+    const contentHash = createHash("sha256").update(data.textContent).digest("hex").slice(0, 16);
+
+    const result = await prisma.$transaction(async (tx) => {
+      const latest = await tx.promptVersion.findFirst({
+        where: { promptId },
+        orderBy: { version: "desc" },
+      });
+      const nextVersion = (latest?.version ?? 0) + 1;
+
+      await tx.$executeRaw`
+        UPDATE "prompt_versions"
+        SET "labels" = array_remove("labels", 'override')
+        WHERE "promptId" = ${promptId} AND 'override' = ANY("labels")
+      `;
+
+      await tx.promptVersion.create({
+        data: {
+          promptId,
+          version: nextVersion,
+          textContent: data.textContent,
+          model: data.model || null,
+          source: data.source || "dashboard",
+          commitMessage: data.commitMessage || null,
+          contentHash,
+          labels: ["override"],
+          createdBy: data.createdBy,
+        },
+      });
+
+      return { version: nextVersion };
+    });
+
+    return result;
+  }
+
+  async updateOverride(
+    promptId: string,
+    data: {
+      textContent?: string;
+      model?: string;
+      commitMessage?: string;
+    }
+  ) {
+    const overrideVer = await this._prisma.promptVersion.findFirst({
+      where: { promptId, labels: { has: "override" } },
+      orderBy: { version: "desc" },
+    });
+
+    if (!overrideVer) {
+      throw new ServiceValidationError("No active override to update", 400);
+    }
+
+    const contentString = data.textContent ?? overrideVer.textContent ?? "";
+    const contentHash = createHash("sha256").update(contentString).digest("hex").slice(0, 16);
+
+    await this._prisma.promptVersion.update({
+      where: { id: overrideVer.id },
+      data: {
+        textContent: contentString,
+        model: data.model ?? overrideVer.model,
+        commitMessage: data.commitMessage ?? overrideVer.commitMessage,
+        contentHash,
+      },
+    });
+  }
+
+  async removeOverride(promptId: string) {
+    await this.#removeLabel(promptId, "override");
+  }
+
+  async reactivateOverride(promptId: string, versionId: string) {
+    const target = await this._prisma.promptVersion.findUnique({
+      where: { id: versionId },
+    });
+
+    if (!target) {
+      throw new ServiceValidationError("Version not found", 404);
+    }
+
+    if (target.promptId !== promptId) {
+      throw new ServiceValidationError("Version does not belong to this prompt", 400);
+    }
+
+    if (target.source === "code") {
+      throw new ServiceValidationError(
+        "Code-sourced versions cannot be reactivated as overrides",
+        400
+      );
+    }
+
+    await prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`
+        UPDATE "prompt_versions"
+        SET "labels" = array_remove("labels", 'override')
+        WHERE "promptId" = ${promptId} AND 'override' = ANY("labels")
+      `;
+      await tx.$executeRaw`
+        UPDATE "prompt_versions"
+        SET "labels" = array_append("labels", 'override')
+        WHERE "id" = ${versionId} AND NOT ('override' = ANY("labels"))
+      `;
+    });
+  }
+
+  async #removeLabel(promptId: string, label: string) {
+    await this._prisma.$executeRaw`
+      UPDATE "prompt_versions"
+      SET "labels" = array_remove("labels", ${label})
+      WHERE "promptId" = ${promptId} AND ${label} = ANY("labels")
+    `;
+  }
+
+}
diff --git a/apps/webapp/app/v3/services/replayTaskRun.server.ts b/apps/webapp/app/v3/services/replayTaskRun.server.ts
index 2345d209dd1..836611b3610 100644
--- a/apps/webapp/app/v3/services/replayTaskRun.server.ts
+++ b/apps/webapp/app/v3/services/replayTaskRun.server.ts
@@ -18,6 +18,7 @@ type OverrideOptions = {
   payload?: string;
   metadata?: unknown;
   bulkActionId?: string;
+  triggerSource?: string;
 } & RunOptionsData;
 
 export class ReplayTaskRunService extends BaseService {
@@ -64,7 +65,7 @@ export class ReplayTaskRunService extends BaseService {
       existingTaskRun.engine === "V1" ||
       existingEnvironment.type === "DEVELOPMENT" ||
       authenticatedEnvironment.type === "DEVELOPMENT";
-    const region = ignoreRegion ? undefined : existingTaskRun.workerQueue;
+    const region = ignoreRegion ? undefined : overrideOptions.region ?? existingTaskRun.workerQueue;
 
     try {
       const taskQueue = await this._prisma.taskQueue.findFirst({
@@ -110,6 +111,7 @@ export class ReplayTaskRunService extends BaseService {
               overrideOptions.version === "latest" ? undefined : overrideOptions.version,
             bulkActionId: overrideOptions?.bulkActionId,
             region,
+            priority: overrideOptions.prioritySeconds,
           },
         },
         {
@@ -122,6 +124,8 @@ export class ReplayTaskRunService extends BaseService {
           realtimeStreamsVersion: determineRealtimeStreamsVersion(
             existingTaskRun.realtimeStreamsVersion
           ),
+          triggerSource: overrideOptions.triggerSource ?? "api",
+          triggerAction: "replay",
         }
       );
 
diff --git a/apps/webapp/app/v3/services/setBranchesAddOn.server.ts b/apps/webapp/app/v3/services/setBranchesAddOn.server.ts
new file mode 100644
index 00000000000..55f4f5817d8
--- /dev/null
+++ b/apps/webapp/app/v3/services/setBranchesAddOn.server.ts
@@ -0,0 +1,100 @@
+import { BaseService } from "./baseService.server";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { setBranchesAddOn } from "~/services/platform.v3.server";
+import assertNever from "assert-never";
+import { sendToPlain } from "~/utils/plain.server";
+import { uiComponent } from "@team-plain/typescript-sdk";
+
+type Input = {
+  userId: string;
+  organizationId: string;
+  action: "purchase" | "quota-increase";
+  amount: number;
+};
+
+type Result =
+  | {
+      success: true;
+    }
+  | {
+      success: false;
+      error: string;
+    };
+
+export class SetBranchesAddOnService extends BaseService {
+  async call({ userId, organizationId, action, amount }: Input): Promise<Result> {
+    switch (action) {
+      case "purchase": {
+        const result = await setBranchesAddOn(organizationId, amount);
+        if (!result) {
+          return {
+            success: false,
+            error: "Failed to update preview branches",
+          };
+        }
+
+        switch (result.result) {
+          case "success": {
+            return { success: true };
+          }
+          case "error": {
+            return { success: false, error: result.error };
+          }
+          case "max_quota_reached": {
+            return {
+              success: false,
+              error: `You can't purchase more than ${result.maxQuota} preview branches without requesting an increase.`,
+            };
+          }
+          default: {
+            return {
+              success: false,
+              error: "Failed to update preview branches, unknown result.",
+            };
+          }
+        }
+      }
+      case "quota-increase": {
+        const user = await this._replica.user.findFirst({
+          where: { id: userId },
+        });
+
+        if (!user) {
+          return { success: false, error: "No matching user found." };
+        }
+
+        const organization = await this._replica.organization.findFirst({
+          select: { title: true },
+          where: { id: organizationId },
+        });
+
+        const [error] = await tryCatch(
+          sendToPlain({
+            userId,
+            email: user.email,
+            name: user.name ?? user.displayName ?? user.email,
+            title: `Preview branches quota request: ${amount}`,
+            components: [
+              uiComponent.text({
+                text: `Org: ${organization?.title} (${organizationId})`,
+              }),
+              uiComponent.divider({ spacingSize: "M" }),
+              uiComponent.text({
+                text: `Total preview branches requested: ${amount}`,
+              }),
+            ],
+          })
+        );
+
+        if (error) {
+          return { success: false, error: error.message };
+        }
+
+        return { success: true };
+      }
+      default: {
+        assertNever(action);
+      }
+    }
+  }
+}
diff --git a/apps/webapp/app/v3/services/setSeatsAddOn.server.ts b/apps/webapp/app/v3/services/setSeatsAddOn.server.ts
new file mode 100644
index 00000000000..b9159c2ee7c
--- /dev/null
+++ b/apps/webapp/app/v3/services/setSeatsAddOn.server.ts
@@ -0,0 +1,100 @@
+import { BaseService } from "./baseService.server";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { setSeatsAddOn } from "~/services/platform.v3.server";
+import assertNever from "assert-never";
+import { sendToPlain } from "~/utils/plain.server";
+import { uiComponent } from "@team-plain/typescript-sdk";
+
+type Input = {
+  userId: string;
+  organizationId: string;
+  action: "purchase" | "quota-increase";
+  amount: number;
+};
+
+type Result =
+  | {
+      success: true;
+    }
+  | {
+      success: false;
+      error: string;
+    };
+
+export class SetSeatsAddOnService extends BaseService {
+  async call({ userId, organizationId, action, amount }: Input): Promise<Result> {
+    switch (action) {
+      case "purchase": {
+        const result = await setSeatsAddOn(organizationId, amount);
+        if (!result) {
+          return {
+            success: false,
+            error: "Failed to update seats",
+          };
+        }
+
+        switch (result.result) {
+          case "success": {
+            return { success: true };
+          }
+          case "error": {
+            return { success: false, error: result.error };
+          }
+          case "max_quota_reached": {
+            return {
+              success: false,
+              error: `You can't purchase more than ${result.maxQuota} seats without requesting an increase.`,
+            };
+          }
+          default: {
+            return {
+              success: false,
+              error: "Failed to update seats, unknown result.",
+            };
+          }
+        }
+      }
+      case "quota-increase": {
+        const user = await this._replica.user.findFirst({
+          where: { id: userId },
+        });
+
+        if (!user) {
+          return { success: false, error: "No matching user found." };
+        }
+
+        const organization = await this._replica.organization.findFirst({
+          select: { title: true },
+          where: { id: organizationId },
+        });
+
+        const [error] = await tryCatch(
+          sendToPlain({
+            userId,
+            email: user.email,
+            name: user.name ?? user.displayName ?? user.email,
+            title: `Seats quota request: ${amount}`,
+            components: [
+              uiComponent.text({
+                text: `Org: ${organization?.title} (${organizationId})`,
+              }),
+              uiComponent.divider({ spacingSize: "M" }),
+              uiComponent.text({
+                text: `Total seats requested: ${amount}`,
+              }),
+            ],
+          })
+        );
+
+        if (error) {
+          return { success: false, error: error.message };
+        }
+
+        return { success: true };
+      }
+      default: {
+        assertNever(action);
+      }
+    }
+  }
+}
diff --git a/apps/webapp/app/v3/services/testTask.server.ts b/apps/webapp/app/v3/services/testTask.server.ts
index e2e52078b4e..3ad2af22e51 100644
--- a/apps/webapp/app/v3/services/testTask.server.ts
+++ b/apps/webapp/app/v3/services/testTask.server.ts
@@ -11,26 +11,35 @@ export class TestTaskService extends BaseService {
 
     switch (triggerSource) {
       case "STANDARD": {
-        const result = await triggerTaskService.call(data.taskIdentifier, environment, {
-          payload: data.payload,
-          options: {
-            test: true,
-            metadata: data.metadata,
-            delay: data.delaySeconds ? new Date(Date.now() + data.delaySeconds * 1000) : undefined,
-            ttl: data.ttlSeconds,
-            idempotencyKey: data.idempotencyKey,
-            idempotencyKeyTTL: data.idempotencyKeyTTLSeconds
-              ? `${data.idempotencyKeyTTLSeconds}s`
-              : undefined,
-            queue: data.queue ? { name: data.queue } : undefined,
-            concurrencyKey: data.concurrencyKey,
-            maxAttempts: data.maxAttempts,
-            maxDuration: data.maxDurationSeconds,
-            tags: data.tags,
-            machine: data.machine,
-            lockToVersion: data.version === "latest" ? undefined : data.version,
+        const result = await triggerTaskService.call(
+          data.taskIdentifier,
+          environment,
+          {
+            payload: data.payload,
+            options: {
+              test: true,
+              metadata: data.metadata,
+              delay: data.delaySeconds
+                ? new Date(Date.now() + data.delaySeconds * 1000)
+                : undefined,
+              ttl: data.ttlSeconds,
+              idempotencyKey: data.idempotencyKey,
+              idempotencyKeyTTL: data.idempotencyKeyTTLSeconds
+                ? `${data.idempotencyKeyTTLSeconds}s`
+                : undefined,
+              queue: data.queue ? { name: data.queue } : undefined,
+              concurrencyKey: data.concurrencyKey,
+              maxAttempts: data.maxAttempts,
+              maxDuration: data.maxDurationSeconds,
+              tags: data.tags,
+              machine: data.machine,
+              region: data.region,
+              lockToVersion: data.version === "latest" ? undefined : data.version,
+              priority: data.prioritySeconds,
+            },
           },
-        });
+          { triggerSource: "dashboard", triggerAction: "test" }
+        );
 
         return result?.run;
       }
@@ -65,10 +74,12 @@ export class TestTaskService extends BaseService {
               maxDuration: data.maxDurationSeconds,
               tags: data.tags,
               machine: data.machine,
+              region: data.region,
               lockToVersion: data.version === "latest" ? undefined : data.version,
+              priority: data.prioritySeconds,
             },
           },
-          { customIcon: "scheduled" }
+          { customIcon: "scheduled", triggerSource: "dashboard", triggerAction: "test" }
         );
 
         return result?.run;
diff --git a/apps/webapp/app/v3/services/tracePubSub.server.ts b/apps/webapp/app/v3/services/tracePubSub.server.ts
index f94967d6b9d..2b6082f86f9 100644
--- a/apps/webapp/app/v3/services/tracePubSub.server.ts
+++ b/apps/webapp/app/v3/services/tracePubSub.server.ts
@@ -2,6 +2,8 @@ import { createRedisClient, RedisClient, RedisWithClusterOptions } from "~/redis
 import { EventEmitter } from "node:events";
 import { env } from "~/env.server";
 import { singleton } from "~/utils/singleton";
+import { Gauge } from "prom-client";
+import { metricsRegister } from "~/metrics.server";
 
 export type TracePubSubOptions = {
   redis: RedisWithClusterOptions;
@@ -15,7 +17,10 @@ export class TracePubSub {
     this._publisher = createRedisClient("trigger:eventRepoPublisher", this._options.redis);
   }
 
-  // TODO: do this more efficiently
+  get subscriberCount() {
+    return this._subscriberCount;
+  }
+
   async publish(traceIds: string[]) {
     if (traceIds.length === 0) return;
     const uniqueTraces = new Set(traceIds.map((e) => `events:${e}`));
@@ -40,15 +45,18 @@ export class TracePubSub {
 
     const eventEmitter = new EventEmitter();
 
-    // Define the message handler.
-    redis.on("message", (_, message) => {
+    // Define the message handler - store reference so we can remove it later.
+    const messageHandler = (_: string, message: string) => {
       eventEmitter.emit("message", message);
-    });
+    };
+    redis.on("message", messageHandler);
 
     // Return a function that can be used to unsubscribe.
     const unsubscribe = async () => {
+      // Remove the message listener before closing the connection
+      redis.off("message", messageHandler);
       await redis.unsubscribe(channel);
-      redis.quit();
+      await redis.quit();
       this._subscriberCount--;
     };
 
@@ -62,7 +70,7 @@ export class TracePubSub {
 export const tracePubSub = singleton("tracePubSub", initializeTracePubSub);
 
 function initializeTracePubSub() {
-  return new TracePubSub({
+  const pubSub = new TracePubSub({
     redis: {
       port: env.PUBSUB_REDIS_PORT,
       host: env.PUBSUB_REDIS_HOST,
@@ -72,4 +80,15 @@ function initializeTracePubSub() {
       clusterMode: env.PUBSUB_REDIS_CLUSTER_MODE_ENABLED === "1",
     },
   });
+
+  new Gauge({
+    name: "trace_pub_sub_subscribers",
+    help: "Number of trace pub sub subscribers",
+    collect() {
+      this.set(pubSub.subscriberCount);
+    },
+    registers: [metricsRegister],
+  });
+
+  return pubSub;
 }
diff --git a/apps/webapp/app/v3/services/triggerTask.server.ts b/apps/webapp/app/v3/services/triggerTask.server.ts
index 2ed34f0342c..000633fb73f 100644
--- a/apps/webapp/app/v3/services/triggerTask.server.ts
+++ b/apps/webapp/app/v3/services/triggerTask.server.ts
@@ -33,6 +33,8 @@ export type TriggerTaskServiceOptions = {
   replayedFromTaskRunFriendlyId?: string;
   planType?: string;
   realtimeStreamsVersion?: "v1" | "v2";
+  triggerSource?: string;
+  triggerAction?: string;
 };
 
 export class OutOfEntitlementError extends Error {
diff --git a/apps/webapp/app/v3/services/triggerTaskV1.server.ts b/apps/webapp/app/v3/services/triggerTaskV1.server.ts
index efc6510ef3c..e9e1f291e2d 100644
--- a/apps/webapp/app/v3/services/triggerTaskV1.server.ts
+++ b/apps/webapp/app/v3/services/triggerTaskV1.server.ts
@@ -26,7 +26,7 @@ import { getV3EventRepository } from "../eventRepository/index.server";
 import { generateFriendlyId } from "../friendlyIdentifiers";
 import { findCurrentWorkerFromEnvironment } from "../models/workerDeployment.server";
 import { guardQueueSizeLimitsForEnv } from "../queueSizeLimits.server";
-import { uploadPacketToObjectStore } from "../r2.server";
+import { uploadPacketToObjectStore } from "../objectStore.server";
 import { removeQueueConcurrencyLimits, updateQueueConcurrencyLimits } from "../runQueue.server";
 import { isFinalAttemptStatus, isFinalRunStatus } from "../taskStatus";
 import { startActiveSpan } from "../tracer.server";
@@ -134,7 +134,9 @@ export class TriggerTaskServiceV1 extends BaseService {
 
         if (!queueSizeGuard.isWithinLimits) {
           throw new ServiceValidationError(
-            `Cannot trigger ${taskId} as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`
+            `Cannot trigger ${taskId} as the queue size limit for this environment has been reached. The maximum size is ${queueSizeGuard.maximumSize}`,
+            undefined,
+            "warn"
           );
         }
       }
@@ -754,10 +756,10 @@ export class TriggerTaskServiceV1 extends BaseService {
 
       const filename = `${pathPrefix}/payload.json`;
 
-      await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
+      const uploadedFilename = await uploadPacketToObjectStore(filename, packet.data, packet.dataType, environment);
 
       return {
-        data: filename,
+        data: uploadedFilename,
         dataType: "application/store",
       };
     });
diff --git a/apps/webapp/app/v3/services/upsertTaskSchedule.server.ts b/apps/webapp/app/v3/services/upsertTaskSchedule.server.ts
index f7fa8f4d184..d9d8b6c0a46 100644
--- a/apps/webapp/app/v3/services/upsertTaskSchedule.server.ts
+++ b/apps/webapp/app/v3/services/upsertTaskSchedule.server.ts
@@ -109,6 +109,7 @@ export class UpsertTaskScheduleService extends BaseService {
         data: {
           taskScheduleId: scheduleRecord.id,
           environmentId,
+          projectId,
         },
         include: {
           environment: {
@@ -183,6 +184,7 @@ export class UpsertTaskScheduleService extends BaseService {
           data: {
             taskScheduleId: scheduleRecord.id,
             environmentId,
+            projectId: existingSchedule.projectId,
           },
           include: {
             environment: {
diff --git a/apps/webapp/app/v3/services/worker/workerGroupService.server.ts b/apps/webapp/app/v3/services/worker/workerGroupService.server.ts
index f05c8783ecd..6a900a16fd7 100644
--- a/apps/webapp/app/v3/services/worker/workerGroupService.server.ts
+++ b/apps/webapp/app/v3/services/worker/workerGroupService.server.ts
@@ -2,7 +2,8 @@ import { WorkerInstanceGroup, WorkerInstanceGroupType } from "@trigger.dev/datab
 import { WithRunEngine } from "../baseService.server";
 import { WorkerGroupTokenService } from "./workerGroupTokenService.server";
 import { logger } from "~/services/logger.server";
-import { FEATURE_FLAG, makeFlags, makeSetFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG } from "~/v3/featureFlags";
+import { makeFlag, makeSetFlag } from "~/v3/featureFlags.server";
 
 export class WorkerGroupService extends WithRunEngine {
   private readonly defaultNamePrefix = "worker_group";
@@ -47,14 +48,14 @@ export class WorkerGroupService extends WithRunEngine {
         },
       });
 
-      const getFlag = makeFlags(this._prisma);
+      const getFlag = makeFlag(this._prisma);
       const defaultWorkerInstanceGroupId = await getFlag({
         key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
       });
 
       // If there's no global default yet we should set it to the new worker group
       if (!defaultWorkerInstanceGroupId) {
-        const setFlag = makeSetFlags(this._prisma);
+        const setFlag = makeSetFlag(this._prisma);
         await setFlag({
           key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
           value: workerGroup.id,
@@ -166,7 +167,7 @@ export class WorkerGroupService extends WithRunEngine {
   }
 
   async getGlobalDefaultWorkerGroup() {
-    const flags = makeFlags(this._prisma);
+    const flags = makeFlag(this._prisma);
 
     const defaultWorkerInstanceGroupId = await flags({
       key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
diff --git a/apps/webapp/app/v3/services/worker/workerGroupTokenService.server.ts b/apps/webapp/app/v3/services/worker/workerGroupTokenService.server.ts
index befe2a0a892..b29056c6244 100644
--- a/apps/webapp/app/v3/services/worker/workerGroupTokenService.server.ts
+++ b/apps/webapp/app/v3/services/worker/workerGroupTokenService.server.ts
@@ -1,4 +1,4 @@
-import { createCache, createMemoryStore, DefaultStatefulContext, Namespace } from "@internal/cache";
+import { createCache, createLRUMemoryStore, DefaultStatefulContext, Namespace } from "@internal/cache";
 import {
   CheckpointInput,
   CompleteRunAttemptResult,
@@ -39,7 +39,7 @@ function createAuthenticatedWorkerInstanceCache() {
     authenticatedWorkerInstance: new Namespace<AuthenticatedWorkerInstance>(
       new DefaultStatefulContext(),
       {
-        stores: [createMemoryStore(1000, 0.001)],
+        stores: [createLRUMemoryStore(1000)],
         fresh: 60_000 * 10, // 10 minutes
         stale: 60_000 * 11, // 11 minutes
       }
diff --git a/apps/webapp/app/v3/testTask.ts b/apps/webapp/app/v3/testTask.ts
index 79d9e97ec3d..54db301cdef 100644
--- a/apps/webapp/app/v3/testTask.ts
+++ b/apps/webapp/app/v3/testTask.ts
@@ -22,6 +22,7 @@ export const RunOptionsData = z.object({
   concurrencyKey: z.string().optional(),
   maxAttempts: z.number().min(1).optional(),
   machine: MachinePresetName.optional(),
+  region: z.string().optional(),
   maxDurationSeconds: z
     .number()
     .min(0)
@@ -46,6 +47,11 @@ export const RunOptionsData = z.object({
       message: "Each tag must be at most 128 characters long",
     }),
   version: z.string().optional(),
+  prioritySeconds: z
+    .number()
+    .min(0)
+    .optional()
+    .transform((val) => (val === 0 ? undefined : val)),
 });
 
 export type RunOptionsData = z.infer<typeof RunOptionsData>;
diff --git a/apps/webapp/app/v3/utils/enrichCreatableEvents.server.ts b/apps/webapp/app/v3/utils/enrichCreatableEvents.server.ts
index f718c13d2dd..64382010496 100644
--- a/apps/webapp/app/v3/utils/enrichCreatableEvents.server.ts
+++ b/apps/webapp/app/v3/utils/enrichCreatableEvents.server.ts
@@ -1,4 +1,31 @@
-import type { CreateEventInput } from "../eventRepository/eventRepository.types";
+import { modelCatalog } from "@internal/llm-model-catalog";
+import type { CreateEventInput, LlmMetricsData } from "../eventRepository/eventRepository.types";
+
+// Registry interface — matches ModelPricingRegistry from @internal/llm-model-catalog
+type CostRegistry = {
+  isLoaded: boolean;
+  calculateCost(
+    responseModel: string,
+    usageDetails: Record<string, number>
+  ): {
+    matchedModelId: string;
+    matchedModelName: string;
+    pricingTierId: string;
+    pricingTierName: string;
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    costDetails: Record<string, number>;
+  } | null;
+};
+
+let _registry: CostRegistry | undefined;
+
+const ENRICHABLE_KINDS = new Set(["INTERNAL", "SERVER", "CLIENT", "CONSUMER", "PRODUCER"]);
+
+export function setLlmPricingRegistry(registry: CostRegistry): void {
+  _registry = registry;
+}
 
 export function enrichCreatableEvents(events: CreateEventInput[]) {
   return events.map((event) => {
@@ -12,9 +39,209 @@ function enrichCreatableEvent(event: CreateEventInput): CreateEventInput {
   event.message = message;
   event.style = enrichStyle(event);
 
+  enrichLlmMetrics(event);
+  enrichPromptResolve(event);
+
   return event;
 }
 
+function enrichLlmMetrics(event: CreateEventInput): void {
+  const props = event.properties;
+  if (!props) return;
+
+  // Only enrich span-like events (INTERNAL, SERVER, CLIENT, CONSUMER, PRODUCER — not LOG, UNSPECIFIED)
+  if (!ENRICHABLE_KINDS.has(event.kind as string)) return;
+
+  // Skip partial spans (they don't have final token counts)
+  if (event.isPartial) return;
+
+  // Only use gen_ai.* attributes for model resolution to avoid double-counting.
+  // The Vercel AI SDK emits both a parent span (ai.streamText with ai.usage.*)
+  // and a child span (ai.streamText.doStream with gen_ai.*). We only enrich the
+  // child span that has the canonical gen_ai.response.model attribute.
+  const responseModel =
+    typeof props["gen_ai.response.model"] === "string"
+      ? props["gen_ai.response.model"]
+      : typeof props["gen_ai.request.model"] === "string"
+        ? props["gen_ai.request.model"]
+        : null;
+
+  if (!responseModel) {
+    return;
+  }
+
+  // Extract usage details, normalizing attribute names
+  const usageDetails = extractUsageDetails(props);
+
+  // Need at least some token usage
+  const hasTokens = Object.values(usageDetails).some((v) => v > 0);
+  if (!hasTokens) {
+    return;
+  }
+
+  // Add style accessories for model and tokens (even without cost data)
+  const inputTokens = usageDetails["input"] ?? 0;
+  const outputTokens = usageDetails["output"] ?? 0;
+  const totalTokens = usageDetails["total"] ?? inputTokens + outputTokens;
+
+  const pillItems: Array<{ text: string; icon: string }> = [
+    { text: responseModel, icon: "tabler-cube" },
+    { text: formatTokenCount(totalTokens), icon: "tabler-hash" },
+  ];
+
+  // Try cost enrichment if the registry is loaded.
+  // The registry handles prefix stripping (e.g. "mistral/mistral-large-3" → "mistral-large-3")
+  // for gateway/openrouter models automatically in its match() method.
+  let cost: ReturnType<NonNullable<typeof _registry>["calculateCost"]> | null = null;
+  if (_registry?.isLoaded) {
+    cost = _registry.calculateCost(responseModel, usageDetails);
+  }
+
+  // Fallback: extract cost from provider metadata (gateway/openrouter report per-request cost)
+  let providerCost: { totalCost: number; source: string } | null = null;
+  if (!cost) {
+    providerCost = extractProviderCost(props);
+  }
+
+  if (cost) {
+    // Add trigger.llm.* attributes to the span from our pricing registry
+    event.properties = {
+      ...props,
+      "trigger.llm.input_cost": cost.inputCost,
+      "trigger.llm.output_cost": cost.outputCost,
+      "trigger.llm.total_cost": cost.totalCost,
+      "trigger.llm.matched_model": cost.matchedModelName,
+      "trigger.llm.matched_model_id": cost.matchedModelId,
+      "trigger.llm.pricing_tier": cost.pricingTierName,
+      "trigger.llm.pricing_tier_id": cost.pricingTierId,
+    };
+
+    pillItems.push({ text: formatCost(cost.totalCost), icon: "tabler-currency-dollar" });
+  } else if (providerCost) {
+    // Use provider-reported cost as fallback (no input/output breakdown available)
+    event.properties = {
+      ...props,
+      "trigger.llm.total_cost": providerCost.totalCost,
+      "trigger.llm.cost_source": providerCost.source,
+    };
+
+    pillItems.push({ text: formatCost(providerCost.totalCost), icon: "tabler-currency-dollar" });
+  }
+
+  event.style = {
+    ...(event.style as Record<string, unknown> | undefined),
+    accessory: {
+      style: "pills",
+      items: pillItems,
+    },
+  } as unknown as typeof event.style;
+
+  // Only write llm_metrics when cost data is available
+  if (!cost && !providerCost) return;
+
+  // Build metadata map from run tags and ai.telemetry.metadata.*
+  const metadata: Record<string, string> = {};
+
+  if (event.runTags) {
+    for (const tag of event.runTags) {
+      const colonIdx = tag.indexOf(":");
+      if (colonIdx > 0) {
+        metadata[tag.substring(0, colonIdx)] = tag.substring(colonIdx + 1);
+      }
+    }
+  }
+
+  for (const [key, value] of Object.entries(props)) {
+    if (key.startsWith("ai.telemetry.metadata.") && typeof value === "string") {
+      metadata[key.slice("ai.telemetry.metadata.".length)] = value;
+    }
+  }
+
+  // Extract new performance/behavioral fields
+  const finishReason = typeof props["ai.response.finishReason"] === "string"
+    ? props["ai.response.finishReason"]
+    : typeof props["gen_ai.response.finish_reasons"] === "string"
+      ? props["gen_ai.response.finish_reasons"]
+      : "";
+  const operationId = typeof props["ai.operationId"] === "string"
+    ? props["ai.operationId"]
+    : typeof props["gen_ai.operation.name"] === "string"
+      ? props["gen_ai.operation.name"]
+      : typeof props["operation.name"] === "string"
+        ? props["operation.name"]
+        : "";
+  const msToFirstChunk = typeof props["ai.response.msToFirstChunk"] === "number"
+    ? props["ai.response.msToFirstChunk"]
+    : 0;
+  const avgTokensPerSec = typeof props["ai.response.avgOutputTokensPerSecond"] === "number"
+    ? props["ai.response.avgOutputTokensPerSecond"]
+    : 0;
+  const costSource = cost ? "registry" : providerCost ? providerCost.source : "";
+  const providerCostValue = providerCost?.totalCost ?? 0;
+
+  // Set _llmMetrics side-channel for dual-write to llm_metrics_v1
+  const llmMetrics: LlmMetricsData = {
+    genAiSystem: typeof props["gen_ai.system"] === "string" ? props["gen_ai.system"] : "unknown",
+    requestModel: typeof props["gen_ai.request.model"] === "string" ? props["gen_ai.request.model"] : responseModel,
+    responseModel,
+    baseResponseModel: modelCatalog[responseModel]?.baseModelName ?? responseModel,
+    matchedModelId: cost?.matchedModelId ?? "",
+    operationId,
+    finishReason,
+    costSource,
+    pricingTierId: cost?.pricingTierId ?? (providerCost ? `provider:${providerCost.source}` : ""),
+    pricingTierName: cost?.pricingTierName ?? (providerCost ? `${providerCost.source} reported` : ""),
+    inputTokens: usageDetails["input"] ?? 0,
+    outputTokens: usageDetails["output"] ?? 0,
+    totalTokens: usageDetails["total"] ?? (usageDetails["input"] ?? 0) + (usageDetails["output"] ?? 0),
+    usageDetails,
+    inputCost: cost?.inputCost ?? 0,
+    outputCost: cost?.outputCost ?? 0,
+    totalCost: cost?.totalCost ?? providerCost?.totalCost ?? 0,
+    costDetails: cost?.costDetails ?? {},
+    providerCost: providerCostValue,
+    msToFirstChunk,
+    tokensPerSecond: avgTokensPerSec,
+    metadata,
+    promptSlug: metadata["prompt.slug"] ?? "",
+    promptVersion: parseInt(metadata["prompt.version"] ?? "0", 10) || 0,
+  };
+
+  event._llmMetrics = llmMetrics;
+}
+
+function extractUsageDetails(props: Record<string, unknown>): Record<string, number> {
+  const details: Record<string, number> = {};
+
+  // Only map gen_ai.usage.* attributes — NOT ai.usage.* from parent spans.
+  // This prevents double-counting when both parent (ai.streamText) and child
+  // (ai.streamText.doStream) spans carry token counts.
+  const mappings: Record<string, string> = {
+    "gen_ai.usage.input_tokens": "input",
+    "gen_ai.usage.output_tokens": "output",
+    "gen_ai.usage.prompt_tokens": "input",
+    "gen_ai.usage.completion_tokens": "output",
+    "gen_ai.usage.total_tokens": "total",
+    "gen_ai.usage.cache_read_input_tokens": "input_cached_tokens",
+    "gen_ai.usage.input_tokens_cache_read": "input_cached_tokens",
+    "gen_ai.usage.cache_creation_input_tokens": "cache_creation_input_tokens",
+    "gen_ai.usage.input_tokens_cache_write": "cache_creation_input_tokens",
+    "gen_ai.usage.reasoning_tokens": "reasoning_tokens",
+  };
+
+  for (const [attrKey, usageKey] of Object.entries(mappings)) {
+    const value = props[attrKey];
+    if (typeof value === "number" && value > 0) {
+      // Don't overwrite if already set (first mapping wins)
+      if (details[usageKey] === undefined) {
+        details[usageKey] = value;
+      }
+    }
+  }
+
+  return details;
+}
+
 function enrichStyle(event: CreateEventInput) {
   const baseStyle = event.style ?? {};
   const props = event.properties;
@@ -23,11 +250,16 @@ function enrichStyle(event: CreateEventInput) {
     return baseStyle;
   }
 
-  // Direct property access and early returns
-  // GenAI System check
   const system = props["gen_ai.system"];
-  if (typeof system === "string") {
-    return { ...baseStyle, icon: `tabler-brand-${system.split(".")[0]}` };
+  const modelId = props["gen_ai.request.model"] ?? props["ai.model.id"];
+
+  const provider = resolveAiProvider(
+    typeof system === "string" ? system : undefined,
+    typeof modelId === "string" ? modelId : undefined
+  );
+
+  if (provider) {
+    return { ...baseStyle, icon: `ai-provider-${provider}` };
   }
 
   // Agent workflow check
@@ -39,16 +271,69 @@ function enrichStyle(event: CreateEventInput) {
   const message = event.message;
 
   if (typeof message === "string" && message === "ai.toolCall") {
-    return { ...baseStyle, icon: "tabler-tool" };
+    return { ...baseStyle, icon: "hero-wrench" };
   }
 
   if (typeof message === "string" && message.startsWith("ai.")) {
-    return { ...baseStyle, icon: "tabler-sparkles" };
+    return { ...baseStyle, icon: "hero-sparkles" };
   }
 
   return baseStyle;
 }
 
+function formatTokenCount(tokens: number): string {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;
+  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
+  return tokens.toString();
+}
+
+/**
+ * Extract provider-reported cost from ai.response.providerMetadata.
+ * Gateway and OpenRouter include per-request cost in their metadata.
+ */
+function extractProviderCost(
+  props: Record<string, unknown>
+): { totalCost: number; source: string } | null {
+  const rawMeta = props["ai.response.providerMetadata"];
+  if (typeof rawMeta !== "string") return null;
+
+  let meta: Record<string, unknown>;
+  try {
+    meta = JSON.parse(rawMeta) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+
+  if (!meta || typeof meta !== "object") return null;
+
+  // Gateway: { gateway: { cost: "0.0006615" } }
+  const gateway = meta.gateway;
+  if (gateway && typeof gateway === "object") {
+    const gw = gateway as Record<string, unknown>;
+    const cost = parseFloat(String(gw.cost ?? "0"));
+    if (cost > 0) return { totalCost: cost, source: "gateway" };
+  }
+
+  // OpenRouter: { openrouter: { usage: { cost: 0.000135 } } }
+  const openrouter = meta.openrouter;
+  if (openrouter && typeof openrouter === "object") {
+    const or = openrouter as Record<string, unknown>;
+    const usage = or.usage;
+    if (usage && typeof usage === "object") {
+      const cost = Number((usage as Record<string, unknown>).cost ?? 0);
+      if (cost > 0) return { totalCost: cost, source: "openrouter" };
+    }
+  }
+
+  return null;
+}
+
+function formatCost(cost: number): string {
+  if (cost >= 1) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(6)}`;
+}
+
 function repr(value: any): string {
   if (typeof value === "string") {
     return `'${value}'`;
@@ -79,3 +364,96 @@ function formatPythonStyle(template: string, values: Record<string, any>): strin
     return hasRepr ? repr(value) : String(value);
   });
 }
+
+type AiProvider =
+  | "anthropic"
+  | "openai"
+  | "gemini"
+  | "llama"
+  | "deepseek"
+  | "xai"
+  | "perplexity"
+  | "cerebras"
+  | "azure"
+  | "mistral";
+
+const systemToProvider: Record<string, AiProvider> = {
+  anthropic: "anthropic",
+  openai: "openai",
+  azure: "azure",
+  "google.generative-ai": "gemini",
+  google: "gemini",
+  xai: "xai",
+  deepseek: "deepseek",
+  cerebras: "cerebras",
+  perplexity: "perplexity",
+  "meta-llama": "llama",
+  mistral: "mistral",
+};
+
+const modelPatterns: [RegExp, AiProvider][] = [
+  [/\banthropic\b|claude/i, "anthropic"],
+  [/\bopenai\b|gpt-|o[134]-|chatgpt/i, "openai"],
+  [/gemini/i, "gemini"],
+  [/llama/i, "llama"],
+  [/deepseek/i, "deepseek"],
+  [/grok/i, "xai"],
+  [/sonar/i, "perplexity"],
+  [/cerebras/i, "cerebras"],
+  [/mistral|mixtral|codestral|pixtral/i, "mistral"],
+];
+
+function resolveAiProvider(
+  system: string | undefined,
+  modelId: string | undefined
+): AiProvider | undefined {
+  if (modelId) {
+    if (modelId.includes("/")) {
+      const prefix = modelId.split("/")[0].toLowerCase();
+      const fromPrefix = systemToProvider[prefix];
+      if (fromPrefix) return fromPrefix;
+    }
+
+    for (const [pattern, provider] of modelPatterns) {
+      if (pattern.test(modelId)) return provider;
+    }
+  }
+
+  if (system) {
+    const normalized = system.toLowerCase().split(".")[0];
+    return systemToProvider[system] ?? systemToProvider[normalized];
+  }
+
+  return undefined;
+}
+
+function enrichPromptResolve(event: CreateEventInput): void {
+  const props = event.properties;
+  if (!props) return;
+
+  const slug = props["prompt.slug"];
+  const version = props["prompt.version"];
+
+  if (typeof slug !== "string") return;
+
+  const style = (event.style ?? {}) as Record<string, unknown>;
+  const accessory = style.accessory as Record<string, unknown> | undefined;
+  const existingItems =
+    accessory && "items" in accessory
+      ? (accessory.items as Array<{ text: string; icon?: string; variant?: string }>)
+      : [];
+
+  const items = [
+    ...existingItems,
+    {
+      text: `${slug}${typeof version === "number" ? ` v${version}` : ""}`,
+      icon: "tabler-file-text-ai",
+    },
+  ];
+
+  event.style = {
+    ...style,
+    icon: style.icon ?? "tabler-file-text-ai",
+    accessory: { style: "pills" as const, items },
+  } as unknown as typeof event.style;
+}
diff --git a/apps/webapp/app/v3/utils/queueLimits.server.ts b/apps/webapp/app/v3/utils/queueLimits.server.ts
new file mode 100644
index 00000000000..5cefc7e0a65
--- /dev/null
+++ b/apps/webapp/app/v3/utils/queueLimits.server.ts
@@ -0,0 +1,51 @@
+import { RuntimeEnvironmentType } from "@trigger.dev/database";
+import { env } from "~/env.server";
+
+/**
+ * Organization fields needed for queue limit calculation.
+ */
+export type QueueLimitOrganization = {
+  maximumDevQueueSize: number | null;
+  maximumDeployedQueueSize: number | null;
+};
+
+/**
+ * Calculates the queue size limit for an environment based on its type and organization settings.
+ *
+ * Resolution order:
+ * 1. Organization-level override (set by billing sync or admin)
+ * 2. Environment variable fallback
+ * 3. null if neither is set
+ *
+ * @param environmentType - The type of the runtime environment
+ * @param organization - Organization with queue limit fields
+ * @returns The queue size limit, or null if unlimited
+ */
+export function getQueueSizeLimit(
+  environmentType: RuntimeEnvironmentType,
+  organization: QueueLimitOrganization
+): number | null {
+  if (environmentType === "DEVELOPMENT") {
+    return organization.maximumDevQueueSize ?? env.MAXIMUM_DEV_QUEUE_SIZE ?? null;
+  }
+
+  return organization.maximumDeployedQueueSize ?? env.MAXIMUM_DEPLOYED_QUEUE_SIZE ?? null;
+}
+
+/**
+ * Determines the source of the queue size limit for display purposes.
+ *
+ * @param environmentType - The type of the runtime environment
+ * @param organization - Organization with queue limit fields
+ * @returns "plan" if org has a value (typically set by billing), "default" if using env var fallback
+ */
+export function getQueueSizeLimitSource(
+  environmentType: RuntimeEnvironmentType,
+  organization: QueueLimitOrganization
+): "plan" | "default" {
+  if (environmentType === "DEVELOPMENT") {
+    return organization.maximumDevQueueSize !== null ? "plan" : "default";
+  }
+
+  return organization.maximumDeployedQueueSize !== null ? "plan" : "default";
+}
diff --git a/apps/webapp/app/v3/vercel/index.ts b/apps/webapp/app/v3/vercel/index.ts
new file mode 100644
index 00000000000..f34f0b64c6b
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/index.ts
@@ -0,0 +1,17 @@
+export * from "./vercelProjectIntegrationSchema";
+
+export function getVercelInstallParams(request: Request) {
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const configurationId = url.searchParams.get("configurationId");
+  const integration = url.searchParams.get("integration");
+  const next = url.searchParams.get("next");
+
+  if (code && configurationId && (integration === "vercel" || !integration)) {
+    return { code, configurationId, next };
+  }
+
+  return null;
+}
+
+
diff --git a/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts b/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts
new file mode 100644
index 00000000000..31f42acc879
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/vercelOAuthState.server.ts
@@ -0,0 +1,40 @@
+import { generateJWT, validateJWT } from "@trigger.dev/core/v3/jwt";
+import { z } from "zod";
+import { env } from "~/env.server";
+
+export const VercelOAuthStateSchema = z.object({
+  organizationId: z.string(),
+  projectId: z.string(),
+  environmentSlug: z.string(),
+  organizationSlug: z.string(),
+  projectSlug: z.string(),
+});
+
+export type VercelOAuthState = z.infer<typeof VercelOAuthStateSchema>;
+
+export async function generateVercelOAuthState(
+  params: VercelOAuthState
+): Promise<string> {
+  return generateJWT({
+    secretKey: env.ENCRYPTION_KEY,
+    payload: params,
+    expirationTime: "15m",
+  });
+}
+
+export async function validateVercelOAuthState(
+  token: string
+): Promise<{ ok: true; state: VercelOAuthState } | { ok: false; error: string }> {
+  const result = await validateJWT(token, env.ENCRYPTION_KEY);
+
+  if (!result.ok) {
+    return { ok: false, error: result.error };
+  }
+
+  const parseResult = VercelOAuthStateSchema.safeParse(result.payload);
+  if (!parseResult.success) {
+    return { ok: false, error: "Invalid state payload" };
+  }
+
+  return { ok: true, state: parseResult.data };
+}
diff --git a/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts b/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts
new file mode 100644
index 00000000000..9e39febe0ab
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts
@@ -0,0 +1,235 @@
+import { Result } from "neverthrow";
+import { z } from "zod";
+
+export const EnvSlugSchema = z.enum(["dev", "stg", "prod", "preview"]);
+export type EnvSlug = z.infer<typeof EnvSlugSchema>;
+
+export const ALL_ENV_SLUGS: EnvSlug[] = ["dev", "stg", "prod", "preview"];
+
+const safeJsonParse = Result.fromThrowable(
+  (val: string) => JSON.parse(val) as unknown,
+  () => null
+);
+
+/**
+ * Zod transform for form fields that submit JSON-encoded arrays.
+ * Parses the string as JSON and returns the array, or null if invalid.
+ */
+export const jsonArrayField = z.string().optional().transform((val) => {
+  if (!val) return null;
+  return safeJsonParse(val).match(
+    (parsed) => (Array.isArray(parsed) ? parsed : null),
+    () => null
+  );
+});
+
+/**
+ * Zod transform for form fields that submit JSON-encoded EnvSlug arrays.
+ * Parses the string as JSON and validates each element is a valid EnvSlug.
+ * Invalid elements are filtered out rather than rejecting the whole array.
+ */
+export const envSlugArrayField = z.string().optional().transform((val): EnvSlug[] | null => {
+  if (!val) return null;
+  return safeJsonParse(val).match(
+    (parsed) => {
+      if (!Array.isArray(parsed)) return null;
+      return parsed.filter((item): item is EnvSlug => EnvSlugSchema.safeParse(item).success);
+    },
+    () => null
+  );
+});
+
+export const VercelIntegrationConfigSchema = z.object({
+  atomicBuilds: z.array(EnvSlugSchema).nullable().optional(),
+  pullEnvVarsBeforeBuild: z.array(EnvSlugSchema).nullable().optional(),
+  /** Maps a custom Vercel environment to Trigger.dev's staging environment. */
+  vercelStagingEnvironment: z.object({
+    environmentId: z.string(),
+    displayName: z.string(),
+  }).nullable().optional(),
+  discoverEnvVars: z.array(EnvSlugSchema).nullable().optional(),
+});
+
+export type VercelIntegrationConfig = z.infer<typeof VercelIntegrationConfigSchema>;
+
+export const TriggerEnvironmentType = z.enum(["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"]);
+export type TriggerEnvironmentType = z.infer<typeof TriggerEnvironmentType>;
+
+/**
+ * Per-environment, per-variable sync settings.
+ * Missing env slug = sync all vars. Missing var in env = sync by default.
+ * Only explicitly `false` entries disable sync.
+ */
+export const SyncEnvVarsMappingSchema = z.record(EnvSlugSchema, z.record(z.string(), z.boolean())).default({});
+
+export type SyncEnvVarsMapping = z.infer<typeof SyncEnvVarsMappingSchema>;
+
+export const VercelProjectIntegrationDataSchema = z.object({
+  config: VercelIntegrationConfigSchema,
+  syncEnvVarsMapping: SyncEnvVarsMappingSchema,
+  vercelProjectName: z.string(),
+  vercelTeamId: z.string().nullable(),
+  vercelTeamSlug: z.string().optional(),
+  vercelProjectId: z.string(),
+  onboardingCompleted: z.boolean().optional(),
+  onboardingOrigin: z.enum(["marketplace", "dashboard"]).optional(),
+});
+
+export type VercelProjectIntegrationData = z.infer<typeof VercelProjectIntegrationDataSchema>;
+
+export function createDefaultVercelIntegrationData(
+  vercelProjectId: string,
+  vercelProjectName: string,
+  vercelTeamId: string | null,
+  vercelTeamSlug?: string
+): VercelProjectIntegrationData {
+  return {
+    config: {
+      atomicBuilds: ["prod"],
+      pullEnvVarsBeforeBuild: ["prod", "preview"],
+      discoverEnvVars: ["prod", "preview"],
+      vercelStagingEnvironment: null,
+    },
+    syncEnvVarsMapping: {},
+    vercelProjectId,
+    vercelProjectName,
+    vercelTeamId,
+    vercelTeamSlug,
+  };
+}
+
+/**
+ * Maps a Trigger.dev environment type to its Vercel target identifier(s).
+ * Returns null for STAGING when no custom environment is configured.
+ */
+export function envTypeToVercelTarget(
+  envType: TriggerEnvironmentType,
+  stagingEnvironmentId?: string | null
+): string[] | null {
+  switch (envType) {
+    case "PRODUCTION":
+      return ["production"];
+    case "STAGING":
+      return stagingEnvironmentId ? [stagingEnvironmentId] : null;
+    case "PREVIEW":
+      return ["preview"];
+    case "DEVELOPMENT":
+      return ["development"];
+  }
+}
+
+export function getAvailableEnvSlugs(
+  hasStagingEnvironment: boolean,
+  hasPreviewEnvironment: boolean
+): EnvSlug[] {
+  return ALL_ENV_SLUGS.filter((s) => {
+    if (s === "stg" && !hasStagingEnvironment) return false;
+    if (s === "preview" && !hasPreviewEnvironment) return false;
+    return true;
+  });
+}
+
+export function getAvailableEnvSlugsForBuildSettings(
+  hasStagingEnvironment: boolean,
+  hasPreviewEnvironment: boolean
+): EnvSlug[] {
+  return getAvailableEnvSlugs(hasStagingEnvironment, hasPreviewEnvironment).filter((s) => s !== "dev");
+}
+
+export function isDiscoverEnvVarsEnabledForEnvironment(
+  discoverEnvVars: EnvSlug[] | null | undefined,
+  environmentType: TriggerEnvironmentType
+): boolean {
+  if (!discoverEnvVars || discoverEnvVars.length === 0) {
+    return false;
+  }
+  const envSlug = envTypeToSlug(environmentType);
+  return discoverEnvVars.includes(envSlug);
+}
+
+export function envTypeToSlug(environmentType: TriggerEnvironmentType): EnvSlug {
+  switch (environmentType) {
+    case "DEVELOPMENT":
+      return "dev";
+    case "STAGING":
+      return "stg";
+    case "PRODUCTION":
+      return "prod";
+    case "PREVIEW":
+      return "preview";
+  }
+}
+
+export function envSlugToType(slug: EnvSlug): TriggerEnvironmentType {
+  switch (slug) {
+    case "dev":
+      return "DEVELOPMENT";
+    case "stg":
+      return "STAGING";
+    case "prod":
+      return "PRODUCTION";
+    case "preview":
+      return "PREVIEW";
+  }
+}
+
+export function shouldSyncEnvVar(
+  mapping: SyncEnvVarsMapping,
+  envVarName: string,
+  environmentType: TriggerEnvironmentType
+): boolean {
+  const envSlug = envTypeToSlug(environmentType);
+  const envSettings = mapping[envSlug];
+  if (!envSettings) {
+    return true;
+  }
+  return envSettings[envVarName] !== false;
+}
+
+export function shouldSyncEnvVarForAnyEnvironment(
+  mapping: SyncEnvVarsMapping,
+  envVarName: string
+): boolean {
+  for (const slug of ALL_ENV_SLUGS) {
+    const envSettings = mapping[slug];
+    if (!envSettings) {
+      return true;
+    }
+    if (envSettings[envVarName] !== false) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function buildVercelDeploymentUrl(
+  vercelTeamSlug: string,
+  vercelProjectName: string,
+  integrationDeploymentId: string
+): string {
+  const vercelId = integrationDeploymentId.replace(/^dpl_/, "");
+  return `https://vercel.com/${vercelTeamSlug}/${vercelProjectName}/${vercelId}`;
+}
+
+export function isPullEnvVarsEnabledForEnvironment(
+  pullEnvVarsBeforeBuild: EnvSlug[] | null | undefined,
+  environmentType: TriggerEnvironmentType
+): boolean {
+  if (!pullEnvVarsBeforeBuild || pullEnvVarsBeforeBuild.length === 0) {
+    return false;
+  }
+  const envSlug = envTypeToSlug(environmentType);
+  return pullEnvVarsBeforeBuild.includes(envSlug);
+}
+
+export function isAtomicBuildsEnabledForEnvironment(
+  atomicBuilds: EnvSlug[] | null | undefined,
+  environmentType: TriggerEnvironmentType
+): boolean {
+  if (!atomicBuilds || atomicBuilds.length === 0) {
+    return false;
+  }
+  const envSlug = envTypeToSlug(environmentType);
+  return atomicBuilds.includes(envSlug);
+}
diff --git a/apps/webapp/app/v3/vercel/vercelUrls.server.ts b/apps/webapp/app/v3/vercel/vercelUrls.server.ts
new file mode 100644
index 00000000000..957e0d2907b
--- /dev/null
+++ b/apps/webapp/app/v3/vercel/vercelUrls.server.ts
@@ -0,0 +1,26 @@
+/**
+ * Validates `next` parameter from Vercel callbacks.
+ * Only allows vercel.com subdomains (the expected source) and same-origin relative paths.
+ */
+export function sanitizeVercelNextUrl(url: string | undefined | null): string | undefined {
+  if (!url) return undefined;
+
+  // Allow relative paths (same-origin) but reject protocol-relative URLs
+  if (url.startsWith("/") && !url.startsWith("//")) {
+    return url;
+  }
+
+  try {
+    const parsed = new URL(url);
+    if (
+      parsed.protocol === "https:" &&
+      /^([a-z0-9-]+\.)*vercel\.com$/i.test(parsed.hostname)
+    ) {
+      return parsed.toString();
+    }
+  } catch {
+    // Invalid URL
+  }
+
+  return undefined;
+}
diff --git a/apps/webapp/evals/aiQuery.eval.ts b/apps/webapp/evals/aiQuery.eval.ts
new file mode 100644
index 00000000000..b65cf076ddc
--- /dev/null
+++ b/apps/webapp/evals/aiQuery.eval.ts
@@ -0,0 +1,374 @@
+import { evalite } from "evalite";
+import { Levenshtein } from "autoevals";
+import { AIQueryService } from "~/v3/services/aiQueryService.server";
+import { runsSchema } from "~/v3/querySchemas";
+import dotenv from "dotenv";
+import { traceAISDKModel } from "evalite/ai-sdk";
+import { openai } from "@ai-sdk/openai";
+
+dotenv.config({ path: "../../.env" });
+
+// Helper to normalize queries for comparison
+function normalizeQuery(query: string): string {
+  return query
+    .replace(/\s+/g, " ")
+    .replace(/\(\s+/g, "(")
+    .replace(/\s+\)/g, ")")
+    .trim()
+    .toLowerCase();
+}
+
+// Type for parsed query results
+interface ParsedQueryResult {
+  success: boolean;
+  query?: string;
+  error?: string;
+}
+
+// Custom scorer that checks if the generated query is semantically similar
+// and also syntactically valid
+const QuerySimilarity = {
+  name: "QuerySimilarity",
+  scorer: async ({
+    input,
+    output,
+    expected,
+  }: {
+    input: string;
+    output: string;
+    expected?: string;
+  }) => {
+    if (!expected) {
+      return 0;
+    }
+
+    // Parse the output to extract the query
+    const outputParsed = JSON.parse(output) as ParsedQueryResult;
+    const expectedParsed = JSON.parse(expected) as ParsedQueryResult;
+
+    // Check success status first
+    if (outputParsed.success !== expectedParsed.success) {
+      return 0;
+    }
+
+    // If both failed, check if error messages are similar
+    if (!outputParsed.success && !expectedParsed.success) {
+      // Give partial credit for correctly identifying an error case
+      return 0.5;
+    }
+
+    // If both succeeded, compare the queries
+    if (outputParsed.success && expectedParsed.success) {
+      const normalizedOutput = normalizeQuery(outputParsed.query ?? "");
+      const normalizedExpected = normalizeQuery(expectedParsed.query ?? "");
+
+      // Key patterns to check
+      const patterns = [
+        // Table name
+        /from\s+runs/i,
+        // Status filter patterns
+        /status\s*=\s*'[^']+'/i,
+        /status\s+in\s*\([^)]+\)/i,
+        // Time patterns
+        /interval\s+\d+\s+(day|hour|minute|week|month)/i,
+        /triggered_at\s*>/i,
+        // Aggregation patterns
+        /count\(\)/i,
+        /sum\(/i,
+        /avg\(/i,
+        /group\s+by/i,
+        // Ordering
+        /order\s+by/i,
+        // Limit
+        /limit\s+\d+/i,
+      ];
+
+      let matchScore = 0;
+      let totalPatterns = 0;
+
+      for (const pattern of patterns) {
+        const outputMatch = pattern.test(normalizedOutput);
+        const expectedMatch = pattern.test(normalizedExpected);
+
+        if (expectedMatch) {
+          totalPatterns++;
+          if (outputMatch) {
+            matchScore++;
+          }
+        }
+      }
+
+      // Base score from pattern matching
+      const patternScore = totalPatterns > 0 ? matchScore / totalPatterns : 0.5;
+
+      // Use Levenshtein for overall similarity
+      const levenshteinResult = await Levenshtein({
+        output: normalizedOutput,
+        expected: normalizedExpected,
+      });
+      const levenshteinScore = levenshteinResult?.score ?? 0;
+
+      // Weighted combination
+      return 0.6 * patternScore + 0.4 * levenshteinScore;
+    }
+
+    return 0;
+  },
+};
+
+evalite("AI Query Generator", {
+  data: async () => {
+    return [
+      // Basic SELECT queries
+      {
+        input: "Show me all runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Get the 10 most recent runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+ORDER BY triggered_at DESC
+LIMIT 10`,
+        }),
+      },
+
+      // Status filtering
+      {
+        input: "Show failed runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE status = 'Failed'
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Get all completed runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE status = 'Completed'
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Find runs that crashed or timed out",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE status IN ('Crashed', 'Timed out')
+LIMIT 100`,
+        }),
+      },
+
+      // Time-based filtering
+      {
+        input: "Runs from the last 7 days",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE triggered_at > now() - INTERVAL 7 DAY
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Show runs from the past hour",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE triggered_at > now() - INTERVAL 1 HOUR
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Failed runs in the last 24 hours",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE status = 'Failed'
+  AND triggered_at > now() - INTERVAL 1 DAY
+ORDER BY triggered_at DESC
+LIMIT 100`,
+        }),
+      },
+
+      // Aggregations
+      {
+        input: "Count of runs by status",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT status, count() AS count
+FROM runs
+GROUP BY status
+ORDER BY count DESC`,
+        }),
+      },
+      {
+        input: "How many runs per task?",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT task_identifier, count() AS run_count
+FROM runs
+GROUP BY task_identifier
+ORDER BY run_count DESC
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Average execution duration by task",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT task_identifier, avg(execution_duration) AS avg_duration
+FROM runs
+GROUP BY task_identifier
+ORDER BY avg_duration DESC
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Total cost by task in the last 30 days",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT task_identifier, sum(total_cost) AS total_cost
+FROM runs
+WHERE triggered_at > now() - INTERVAL 30 DAY
+GROUP BY task_identifier
+ORDER BY total_cost DESC
+LIMIT 100`,
+        }),
+      },
+
+      // Complex queries
+      {
+        input: "Top 10 most expensive failed runs from last week",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT run_id, task_identifier, status, total_cost, triggered_at
+FROM runs
+WHERE status = 'Failed'
+  AND triggered_at > now() - INTERVAL 7 DAY
+ORDER BY total_cost DESC
+LIMIT 10`,
+        }),
+      },
+      {
+        input: "Runs using large machines that took more than 5 minutes",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE machine IN ('large-1x', 'large-2x')
+  AND usage_duration > 300000
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Show p95 execution duration by task for completed runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT task_identifier, quantile(0.95)(execution_duration) AS p95_duration
+FROM runs
+WHERE status = 'Completed'
+  AND execution_duration IS NOT NULL
+GROUP BY task_identifier
+ORDER BY p95_duration DESC
+LIMIT 100`,
+        }),
+      },
+
+      // Specific columns
+      {
+        input: "Just show run IDs and their statuses",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT run_id, status
+FROM runs
+LIMIT 100`,
+        }),
+      },
+      {
+        input: "Get run_id, task, status and cost for recent runs",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT run_id, task_identifier, status, total_cost
+FROM runs
+ORDER BY triggered_at DESC
+LIMIT 100`,
+        }),
+      },
+
+      // Root runs
+      {
+        input: "Show only root runs (not child runs)",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE is_root_run = 1
+LIMIT 100`,
+        }),
+      },
+
+      // Queue filtering
+      {
+        input: "Runs in the shared queue",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE queue LIKE '%shared%'
+LIMIT 100`,
+        }),
+      },
+
+      // Tags
+      {
+        input: "Find runs with tag 'important'",
+        expected: JSON.stringify({
+          success: true,
+          query: `SELECT *
+FROM runs
+WHERE has(tags, 'important')
+LIMIT 100`,
+        }),
+      },
+
+      // Error cases
+      {
+        input: "Do something",
+        expected: JSON.stringify({
+          success: false,
+          error: "Please be more specific about what data you want to query",
+        }),
+      },
+      {
+        input: "Show me the weather",
+        expected: JSON.stringify({
+          success: false,
+          error: "I can only generate queries for task run data",
+        }),
+      },
+    ];
+  },
+  task: async (input) => {
+    const service = new AIQueryService([runsSchema], traceAISDKModel(openai("gpt-4o-mini")));
+
+    const result = await service.call(input);
+    return JSON.stringify(result);
+  },
+  scorers: [QuerySimilarity, Levenshtein],
+});
diff --git a/apps/webapp/package.json b/apps/webapp/package.json
index 45de003c8d6..451d2785097 100644
--- a/apps/webapp/package.json
+++ b/apps/webapp/package.json
@@ -16,6 +16,7 @@
     "start:local": "cross-env node --max-old-space-size=8192 ./build/server.js",
     "typecheck": "cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" tsc --noEmit -p ./tsconfig.check.json",
     "db:seed": "tsx seed.mts",
+    "db:seed:ai-spans": "tsx seed-ai-spans.mts",
     "upload:sourcemaps": "bash ./upload-sourcemaps.sh",
     "test": "vitest --no-file-parallelism",
     "eval:dev": "evalite watch"
@@ -37,15 +38,16 @@
     "@aws-sdk/s3-presigned-post": "^3.936.0",
     "@aws-sdk/s3-request-presigner": "^3.936.0",
     "@better-auth/utils": "^0.2.6",
-    "@codemirror/autocomplete": "^6.3.1",
-    "@codemirror/commands": "^6.1.2",
-    "@codemirror/lang-javascript": "^6.1.1",
-    "@codemirror/lang-json": "^6.0.1",
-    "@codemirror/language": "^6.3.1",
-    "@codemirror/lint": "^6.4.2",
-    "@codemirror/search": "^6.2.3",
-    "@codemirror/state": "^6.1.3",
-    "@codemirror/view": "^6.5.0",
+    "@codemirror/autocomplete": "6.4.0",
+    "@codemirror/commands": "6.1.3",
+    "@codemirror/lang-javascript": "6.1.2",
+    "@codemirror/lang-json": "6.0.1",
+    "@codemirror/lang-sql": "6.5.5",
+    "@codemirror/language": "6.3.2",
+    "@codemirror/lint": "6.4.2",
+    "@codemirror/search": "6.2.3",
+    "@codemirror/state": "6.2.0",
+    "@codemirror/view": "6.7.2",
     "@conform-to/react": "0.9.2",
     "@conform-to/zod": "0.9.2",
     "@depot/cli": "0.0.1-cli.2.80.0",
@@ -53,11 +55,15 @@
     "@electric-sql/react": "^0.3.5",
     "@headlessui/react": "^1.7.8",
     "@heroicons/react": "^2.0.12",
+    "@jsonhero/schema-infer": "^0.1.5",
     "@internal/cache": "workspace:*",
+    "@internal/compute": "workspace:*",
+    "@internal/llm-model-catalog": "workspace:*",
     "@internal/redis": "workspace:*",
     "@internal/run-engine": "workspace:*",
     "@internal/schedule-engine": "workspace:*",
     "@internal/tracing": "workspace:*",
+    "@internal/tsql": "workspace:*",
     "@internal/zod-worker": "workspace:*",
     "@internationalized/date": "^3.5.1",
     "@kapaai/react-sdk": "^0.1.3",
@@ -68,7 +74,7 @@
     "@opentelemetry/exporter-logs-otlp-http": "0.203.0",
     "@opentelemetry/exporter-metrics-otlp-proto": "0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
-    "@opentelemetry/host-metrics": "^0.36.0",
+    "@opentelemetry/host-metrics": "^0.37.0",
     "@opentelemetry/instrumentation": "0.203.0",
     "@opentelemetry/instrumentation-aws-sdk": "^0.57.0",
     "@opentelemetry/instrumentation-express": "^0.52.0",
@@ -105,20 +111,21 @@
     "@remix-run/serve": "2.1.0",
     "@remix-run/server-runtime": "2.1.0",
     "@remix-run/v1-meta": "^0.1.3",
-    "@s2-dev/streamstore": "^0.17.2",
+    "@s2-dev/streamstore": "^0.22.5",
     "@sentry/remix": "9.46.0",
     "@slack/web-api": "7.9.1",
     "@socket.io/redis-adapter": "^8.3.0",
-    "@splinetool/react-spline": "^2.2.6",
-    "@tabler/icons-react": "^2.39.0",
+    "@tabler/icons-react": "^3.36.1",
     "@tailwindcss/container-queries": "^0.1.1",
+    "@tanstack/match-sorter-utils": "^8.19.4",
+    "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.0.4",
     "@team-plain/typescript-sdk": "^3.5.0",
     "@trigger.dev/companyicons": "^1.5.35",
     "@trigger.dev/core": "workspace:*",
     "@trigger.dev/database": "workspace:*",
     "@trigger.dev/otlp-importer": "workspace:*",
-    "@trigger.dev/platform": "1.0.21",
+    "@trigger.dev/platform": "1.0.27",
     "@trigger.dev/redis-worker": "workspace:*",
     "@trigger.dev/sdk": "workspace:*",
     "@types/pg": "8.6.6",
@@ -126,6 +133,7 @@
     "@unkey/cache": "^1.5.0",
     "@unkey/error": "^0.2.0",
     "@upstash/ratelimit": "^1.1.3",
+    "@vercel/sdk": "^1.19.1",
     "@whatwg-node/fetch": "^0.9.14",
     "ai": "^4.3.19",
     "assert-never": "^1.2.1",
@@ -138,6 +146,7 @@
     "cronstrue": "^2.21.0",
     "cross-env": "^7.0.3",
     "cuid": "^2.1.8",
+    "date-fns": "^4.1.0",
     "dompurify": "^3.2.6",
     "dotenv": "^16.4.5",
     "effect": "^3.11.7",
@@ -153,6 +162,7 @@
     "ioredis": "^5.3.2",
     "isbot": "^3.6.5",
     "jose": "^5.4.0",
+    "json-stable-stringify": "^1.3.0",
     "jsonpointer": "^5.0.1",
     "lodash.omit": "^4.5.0",
     "lucide-react": "^0.229.0",
@@ -179,14 +189,18 @@
     "react": "^18.2.0",
     "react-aria": "^3.31.1",
     "react-collapse": "^5.1.1",
+    "react-day-picker": "^9.13.0",
     "react-dom": "^18.2.0",
+    "react-grid-layout": "^2.2.2",
     "react-hotkeys-hook": "^4.4.1",
+    "react-markdown": "^10.1.0",
     "react-popper": "^2.3.0",
+    "react-resizable": "^3.1.3",
     "react-resizable-panels": "^2.0.9",
     "react-stately": "^3.29.1",
     "react-use": "17.5.1",
     "react-window-splitter": "^0.4.1",
-    "recharts": "^2.12.6",
+    "recharts": "^2.15.2",
     "regression": "^2.0.1",
     "remix-auth": "^3.6.0",
     "remix-auth-email-link": "2.0.2",
@@ -202,7 +216,9 @@
     "socket.io": "4.7.4",
     "socket.io-adapter": "^2.5.4",
     "sonner": "^1.0.3",
+    "sql-formatter": "^15.4.10",
     "sqs-consumer": "^7.4.0",
+    "streamdown": "^1.4.0",
     "superjson": "^2.2.1",
     "tailwind-merge": "^1.12.0",
     "tailwind-scrollbar-hide": "^1.1.7",
@@ -288,4 +304,4 @@
   "engines": {
     "node": ">=18.19.0 || >=20.6.0"
   }
-}
\ No newline at end of file
+}
diff --git a/apps/webapp/remix.config.js b/apps/webapp/remix.config.js
index 68110dc2256..ae2f18cd72e 100644
--- a/apps/webapp/remix.config.js
+++ b/apps/webapp/remix.config.js
@@ -12,6 +12,7 @@ module.exports = {
     /^@internal\//, // Bundle all internal packages
     /^@trigger\.dev\//, // Bundle all trigger packages
     "marked",
+    "agentcrumbs",
     "axios",
     "p-limit",
     "p-map",
@@ -36,6 +37,8 @@ module.exports = {
       os: true,
       crypto: true,
       http2: true,
+      assert: true,
+      util: true,
     },
   },
 };
diff --git a/apps/webapp/seed-ai-spans.mts b/apps/webapp/seed-ai-spans.mts
new file mode 100644
index 00000000000..6ada9fb3285
--- /dev/null
+++ b/apps/webapp/seed-ai-spans.mts
@@ -0,0 +1,1800 @@
+import { prisma } from "./app/db.server";
+import { createOrganization } from "./app/models/organization.server";
+import { createProject } from "./app/models/project.server";
+import { ClickHouse } from "@internal/clickhouse";
+import type { TaskEventV2Input, LlmMetricsV1Input } from "@internal/clickhouse";
+import {
+  generateTraceId,
+  generateSpanId,
+} from "./app/v3/eventRepository/common.server";
+import {
+  enrichCreatableEvents,
+  setLlmPricingRegistry,
+} from "./app/v3/utils/enrichCreatableEvents.server";
+import { ModelPricingRegistry, seedLlmPricing } from "@internal/llm-model-catalog";
+import { nanoid } from "nanoid";
+import { unflattenAttributes } from "@trigger.dev/core/v3/utils/flattenAttributes";
+import type { Attributes } from "@opentelemetry/api";
+import type { CreateEventInput } from "./app/v3/eventRepository/eventRepository.types";
+
+const ORG_TITLE = "AI Spans Dev";
+const PROJECT_NAME = "ai-chat-demo";
+const TASK_SLUG = "ai-chat";
+const QUEUE_NAME = "task/ai-chat";
+const WORKER_VERSION = "seed-ai-spans-v1";
+
+const SEED_USER_IDS = [
+  "user_alice", "user_bob", "user_carol", "user_dave",
+  "user_eve", "user_frank", "user_grace", "user_heidi",
+  "user_ivan", "user_judy", "user_karl", "user_liam",
+];
+
+function randomUserId(): string {
+  return SEED_USER_IDS[Math.floor(Math.random() * SEED_USER_IDS.length)];
+}
+
+// ---------------------------------------------------------------------------
+// ClickHouse formatting helpers (replicated from clickhouseEventRepository)
+// ---------------------------------------------------------------------------
+
+function formatStartTime(startTimeNs: bigint): string {
+  const str = startTimeNs.toString();
+  if (str.length !== 19) return str;
+  return str.substring(0, 10) + "." + str.substring(10);
+}
+
+function formatDuration(value: number | bigint): string {
+  if (value < 0) return "0";
+  if (typeof value === "bigint") return value.toString();
+  return Math.floor(value).toString();
+}
+
+function formatClickhouseDateTime(date: Date): string {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+
+function removePrivateProperties(attributes: Attributes): Attributes | undefined {
+  const result: Attributes = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (key.startsWith("$") || key.startsWith("ctx.")) continue;
+    result[key] = value;
+  }
+  return Object.keys(result).length === 0 ? undefined : result;
+}
+
+function eventToClickhouseRow(event: CreateEventInput): TaskEventV2Input {
+  // kind
+  let kind: string;
+  if (event.kind === "UNSPECIFIED") kind = "ANCESTOR_OVERRIDE";
+  else if (event.level === "TRACE") kind = "SPAN";
+  else if (event.isDebug) kind = "DEBUG_EVENT";
+  else kind = `LOG_${(event.level ?? "LOG").toString().toUpperCase()}`;
+
+  // status
+  let status: string;
+  if (event.isPartial) status = "PARTIAL";
+  else if (event.isError) status = "ERROR";
+  else if (event.isCancelled) status = "CANCELLED";
+  else status = "OK";
+
+  // attributes
+  const publicAttrs = removePrivateProperties(event.properties as Attributes);
+  const unflattened = publicAttrs ? unflattenAttributes(publicAttrs) : {};
+  const attributes =
+    unflattened && typeof unflattened === "object" ? { ...unflattened } : {};
+
+  // metadata — mirrors createEventToTaskEventV1InputMetadata
+  const metadataObj: Record<string, unknown> = {};
+  if (event.style) {
+    metadataObj.style = unflattenAttributes(event.style as Attributes);
+  }
+  if (event.attemptNumber) {
+    metadataObj.attemptNumber = event.attemptNumber;
+  }
+  // Extract entity from properties (SemanticInternalAttributes)
+  const entityType = event.properties?.["$entity.type"];
+  if (typeof entityType === "string") {
+    metadataObj.entity = {
+      entityType,
+      entityId: event.properties?.["$entity.id"] as string | undefined,
+      entityMetadata: event.properties?.["$entity.metadata"] as string | undefined,
+    };
+  }
+  const metadata = JSON.stringify(metadataObj);
+
+  return {
+    environment_id: event.environmentId,
+    organization_id: event.organizationId,
+    project_id: event.projectId,
+    task_identifier: event.taskSlug,
+    run_id: event.runId,
+    start_time: formatStartTime(BigInt(event.startTime)),
+    duration: formatDuration(event.duration ?? 0),
+    trace_id: event.traceId,
+    span_id: event.spanId,
+    parent_span_id: event.parentId ?? "",
+    message: event.message,
+    kind,
+    status,
+    attributes,
+    metadata,
+    expires_at: formatClickhouseDateTime(
+      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000)
+    ),
+    machine_id: "",
+  };
+}
+
+function eventToLlmMetricsRow(event: CreateEventInput): LlmMetricsV1Input {
+  const llm = event._llmMetrics!;
+  return {
+    organization_id: event.organizationId,
+    project_id: event.projectId,
+    environment_id: event.environmentId,
+    run_id: event.runId,
+    task_identifier: event.taskSlug,
+    trace_id: event.traceId,
+    span_id: event.spanId,
+    gen_ai_system: llm.genAiSystem,
+    request_model: llm.requestModel,
+    response_model: llm.responseModel,
+    base_response_model: llm.baseResponseModel,
+    matched_model_id: llm.matchedModelId,
+    operation_id: llm.operationId,
+    finish_reason: llm.finishReason,
+    cost_source: llm.costSource,
+    pricing_tier_id: llm.pricingTierId,
+    pricing_tier_name: llm.pricingTierName,
+    input_tokens: llm.inputTokens,
+    output_tokens: llm.outputTokens,
+    total_tokens: llm.totalTokens,
+    usage_details: llm.usageDetails,
+    input_cost: llm.inputCost,
+    output_cost: llm.outputCost,
+    total_cost: llm.totalCost,
+    cost_details: llm.costDetails,
+    provider_cost: llm.providerCost,
+    ms_to_first_chunk: llm.msToFirstChunk,
+    tokens_per_second: llm.tokensPerSecond,
+    metadata: llm.metadata,
+    prompt_slug: llm.promptSlug,
+    prompt_version: llm.promptVersion,
+    start_time: formatStartTime(BigInt(event.startTime)),
+    duration: formatDuration(event.duration ?? 0),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function seedAiSpans() {
+  const seedUserId = randomUserId();
+  console.log(`Starting AI span seed (userId: ${seedUserId})...\n`);
+
+  // 1. Find user
+  const user = await prisma.user.findUnique({
+    where: { email: "local@trigger.dev" },
+  });
+  if (!user) {
+    console.error("User local@trigger.dev not found. Run `pnpm run db:seed` first.");
+    process.exit(1);
+  }
+
+  // 2. Find or create org
+  let org = await prisma.organization.findFirst({
+    where: { title: ORG_TITLE, members: { some: { userId: user.id } } },
+  });
+  if (!org) {
+    org = await createOrganization({ title: ORG_TITLE, userId: user.id, companySize: "1-10" });
+    console.log(`Created org: ${org.title} (${org.slug})`);
+  } else {
+    console.log(`Org exists: ${org.title} (${org.slug})`);
+  }
+
+  // 3. Find or create project
+  let project = await prisma.project.findFirst({
+    where: { name: PROJECT_NAME, organizationId: org.id },
+  });
+  if (!project) {
+    project = await createProject({
+      organizationSlug: org.slug,
+      name: PROJECT_NAME,
+      userId: user.id,
+      version: "v3",
+    });
+    console.log(`Created project: ${project.name} (${project.externalRef})`);
+  } else {
+    console.log(`Project exists: ${project.name} (${project.externalRef})`);
+  }
+
+  // 4. Get DEVELOPMENT environment
+  const runtimeEnv = await prisma.runtimeEnvironment.findFirst({
+    where: { projectId: project.id, type: "DEVELOPMENT" },
+  });
+  if (!runtimeEnv) {
+    console.error("No DEVELOPMENT environment found for project.");
+    process.exit(1);
+  }
+
+  // 5. Upsert background worker
+  const worker = await prisma.backgroundWorker.upsert({
+    where: {
+      projectId_runtimeEnvironmentId_version: {
+        projectId: project.id,
+        runtimeEnvironmentId: runtimeEnv.id,
+        version: WORKER_VERSION,
+      },
+    },
+    update: {},
+    create: {
+      friendlyId: `worker_${nanoid()}`,
+      engine: "V2",
+      contentHash: `seed-ai-spans-${Date.now()}`,
+      sdkVersion: "3.0.0",
+      cliVersion: "3.0.0",
+      projectId: project.id,
+      runtimeEnvironmentId: runtimeEnv.id,
+      version: WORKER_VERSION,
+      metadata: {},
+    },
+  });
+
+  // 6. Upsert task
+  await prisma.backgroundWorkerTask.upsert({
+    where: { workerId_slug: { workerId: worker.id, slug: TASK_SLUG } },
+    update: {},
+    create: {
+      friendlyId: `task_${nanoid()}`,
+      slug: TASK_SLUG,
+      filePath: "src/trigger/ai-chat.ts",
+      exportName: "aiChat",
+      workerId: worker.id,
+      projectId: project.id,
+      runtimeEnvironmentId: runtimeEnv.id,
+    },
+  });
+
+  // 7. Upsert queue
+  await prisma.taskQueue.upsert({
+    where: {
+      runtimeEnvironmentId_name: {
+        runtimeEnvironmentId: runtimeEnv.id,
+        name: QUEUE_NAME,
+      },
+    },
+    update: {},
+    create: {
+      friendlyId: `queue_${nanoid()}`,
+      name: QUEUE_NAME,
+      projectId: project.id,
+      runtimeEnvironmentId: runtimeEnv.id,
+    },
+  });
+
+  // 8. Create the TaskRun
+  const traceId = generateTraceId();
+  const rootSpanId = generateSpanId();
+  const now = Date.now();
+  // Spans start at `now` and extend into the future. completedAt must cover
+  // the full span tree so getSpan's start_time <= completedAt filter works.
+  const startedAt = new Date(now);
+  const completedAt = new Date(now + 150_000); // 2.5 min to cover all spans
+
+  const run = await prisma.taskRun.create({
+    data: {
+      friendlyId: `run_${nanoid()}`,
+      engine: "V2",
+      status: "COMPLETED_SUCCESSFULLY",
+      taskIdentifier: TASK_SLUG,
+      payload: JSON.stringify({
+        message: `I need a comprehensive analysis of the current Federal Reserve interest rate policy and its broader economic implications. Please cover all of the following areas in detail:
+
+## 1. Current Rate Policy
+
+- What is the **current federal funds target rate** range?
+- When was it last changed, and by how much?
+- What was the FOMC vote breakdown — were there any dissents?
+- What key language changes appeared in the most recent FOMC statement compared to the prior meeting?
+
+## 2. Rate History & Trajectory
+
+- Provide a complete timeline of rate decisions over the past **18 months**, including the size of each move
+- How does the current rate compare to the **pre-pandemic neutral rate** estimate?
+- What does the latest **dot plot** (Summary of Economic Projections) show for 2025, 2026, and the longer-run rate?
+- How has the **median longer-run rate estimate** shifted over the past year?
+
+## 3. Inflation & Economic Data Context
+
+- What are the latest readings for **Core PCE**, **headline CPI**, and **trimmed mean CPI**?
+- How does current inflation compare to the Fed's 2% symmetric target?
+- What does the **breakeven inflation rate** (5-year and 10-year TIPS spreads) suggest about market inflation expectations?
+- Are there any notable divergences between goods inflation and services inflation?
+
+## 4. Labor Market Assessment
+
+- What is the current **unemployment rate**, and how has it trended over the past 6 months?
+- What do **nonfarm payrolls**, **JOLTs job openings**, and **initial jobless claims** indicate about labor market health?
+- Is wage growth (via the **Employment Cost Index** and **Average Hourly Earnings**) still running above levels consistent with 2% inflation?
+- How does the Fed view the balance between its **maximum employment** and **price stability** mandates right now?
+
+## 5. Forward Guidance & Market Expectations
+
+- What are the upcoming **FOMC meeting dates** for the next 6 months?
+- What does the **CME FedWatch Tool** show for the probability of rate changes at each upcoming meeting?
+- How do **fed funds futures** and **OIS swaps** price the terminal rate for this cycle?
+- Are there any notable divergences between Fed guidance and market pricing?
+
+## 6. Global Context & Risk Factors
+
+- How do US rates compare to the **ECB**, **Bank of England**, and **Bank of Japan** policy rates?
+- What role are **tariff and trade policy** uncertainties playing in Fed deliberations?
+- How might **fiscal policy** changes (tax cuts, spending proposals) impact the rate outlook?
+- What are the key **upside and downside risks** to the current rate path?
+
+## 7. Financial Conditions
+
+- What is the current reading of the **Goldman Sachs Financial Conditions Index** and the **Chicago Fed National Financial Conditions Index**?
+- How have **10-year Treasury yields**, **corporate credit spreads**, and **equity valuations** responded to recent policy signals?
+- Is the **yield curve** currently inverted, and what does that historically signal?
+
+Please structure your response with clear headings, use tables for comparative data, include specific numbers and dates, and cite your sources. Flag any data points that may be stale or subject to revision.`,
+      }),
+      payloadType: "application/json",
+      traceId,
+      spanId: rootSpanId,
+      runtimeEnvironmentId: runtimeEnv.id,
+      projectId: project.id,
+      organizationId: org.id,
+      queue: QUEUE_NAME,
+      lockedToVersionId: worker.id,
+      startedAt,
+      completedAt,
+      runTags: [`user:${seedUserId}`, "chat:seed_session"],
+      taskEventStore: "clickhouse_v2",
+    },
+  });
+
+  console.log(`Created TaskRun: ${run.friendlyId}`);
+
+  // 9. Build span tree
+  const events = buildAiSpanTree({
+    traceId,
+    rootSpanId,
+    runId: run.friendlyId,
+    environmentId: runtimeEnv.id,
+    projectId: project.id,
+    organizationId: org.id,
+    taskSlug: TASK_SLUG,
+    baseTimeMs: now,
+    seedUserId,
+  });
+
+  console.log(`Built ${events.length} spans`);
+
+  // 10. Seed LLM pricing and enrich
+  const seedResult = await seedLlmPricing(prisma);
+  console.log(
+    `LLM pricing: ${seedResult.modelsCreated} created, ${seedResult.modelsSkipped} skipped`
+  );
+
+  const registry = new ModelPricingRegistry(prisma);
+  setLlmPricingRegistry(registry);
+  await registry.loadFromDatabase();
+
+  const enriched = enrichCreatableEvents(events);
+
+  const enrichedCount = enriched.filter((e) => e._llmMetrics != null).length;
+  const totalCost = enriched.reduce((sum, e) => sum + (e._llmMetrics?.totalCost ?? 0), 0);
+  console.log(
+    `Enriched ${enrichedCount} spans with LLM cost (total: $${totalCost.toFixed(6)})`
+  );
+
+  // 11. Insert into ClickHouse
+  const clickhouseUrl = process.env.CLICKHOUSE_URL ?? process.env.EVENTS_CLICKHOUSE_URL;
+  if (!clickhouseUrl) {
+    console.error("CLICKHOUSE_URL or EVENTS_CLICKHOUSE_URL not set");
+    process.exit(1);
+  }
+
+  const url = new URL(clickhouseUrl);
+  url.searchParams.delete("secure");
+  const clickhouse = new ClickHouse({ url: url.toString() });
+
+  // Convert to ClickHouse rows and insert
+  const chRows = enriched.map(eventToClickhouseRow);
+  await clickhouse.taskEventsV2.insert(chRows);
+
+  // Insert LLM usage rows
+  const llmRows = enriched.filter((e) => e._llmMetrics != null).map(eventToLlmMetricsRow);
+  if (llmRows.length > 0) {
+    await clickhouse.llmMetrics.insert(llmRows);
+  }
+
+  // 12. Output
+  console.log("\nDone!\n");
+  console.log(
+    `Run URL: http://localhost:3030/orgs/${org.slug}/projects/${project.slug}/env/dev/runs/${run.friendlyId}`
+  );
+  console.log(`Spans: ${events.length}`);
+  console.log(`LLM cost enriched: ${enrichedCount}`);
+  console.log(`Total cost: $${totalCost.toFixed(6)}`);
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Span tree builder
+// ---------------------------------------------------------------------------
+
+type SpanTreeParams = {
+  traceId: string;
+  rootSpanId: string;
+  runId: string;
+  environmentId: string;
+  projectId: string;
+  organizationId: string;
+  taskSlug: string;
+  baseTimeMs: number;
+  seedUserId: string;
+};
+
+function buildAiSpanTree(params: SpanTreeParams): CreateEventInput[] {
+  const {
+    traceId,
+    rootSpanId,
+    runId,
+    environmentId,
+    projectId,
+    organizationId,
+    taskSlug,
+    baseTimeMs,
+    seedUserId,
+  } = params;
+
+  const events: CreateEventInput[] = [];
+  const runTags = [`user:${seedUserId}`, "chat:seed_session"];
+
+  // Timing cursor — each span advances this
+  let cursor = baseTimeMs;
+  function next(durationMs: number) {
+    const start = cursor;
+    cursor += durationMs + 50; // 50ms gap between spans
+    return { startMs: start, durationMs };
+  }
+
+  function makeEvent(opts: {
+    message: string;
+    spanId: string;
+    parentId: string | undefined;
+    startMs: number;
+    durationMs: number;
+    properties: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    attemptNumber?: number;
+  }): CreateEventInput {
+    const startNs = BigInt(opts.startMs) * BigInt(1_000_000);
+    const durationNs = opts.durationMs * 1_000_000;
+    return {
+      traceId,
+      spanId: opts.spanId,
+      parentId: opts.parentId,
+      message: opts.message,
+      kind: "INTERNAL" as any,
+      status: "OK" as any,
+      level: "TRACE" as any,
+      startTime: startNs,
+      duration: durationNs,
+      isError: false,
+      isPartial: false,
+      isCancelled: false,
+      isDebug: false,
+      runId,
+      environmentId,
+      projectId,
+      organizationId,
+      taskSlug,
+      properties: opts.properties,
+      metadata: undefined,
+      style: opts.style as any,
+      events: undefined,
+      runTags,
+      attemptNumber: opts.attemptNumber,
+    };
+  }
+
+  // --- Shared prompt content ---
+  const userMessage = `I need a detailed analysis of the current Federal Reserve interest rate policy, including:
+
+1. The **current target rate** range
+2. How it compares to rates over the past 12 months
+3. Any upcoming FOMC meetings and market expectations
+
+Please include relevant data points and sources where possible.`;
+
+  const systemPrompt = `You are a senior financial analyst AI assistant with expertise in monetary policy, macroeconomics, and Federal Reserve operations.
+
+## Your Capabilities
+- Access to real-time web search for current financial data
+- Deep knowledge of FOMC meeting schedules, dot plots, and forward guidance
+- Ability to interpret economic indicators (CPI, PCE, employment data)
+
+## Response Guidelines
+- Always cite specific dates and data sources
+- Use tables for comparative data when appropriate
+- Flag any uncertainty or conflicting signals in the data
+- Present information in a structured, scannable format
+
+## Important Notes
+> Never provide investment advice. Present factual analysis only.
+> When data is older than 48 hours, note the timestamp explicitly.`;
+
+  const assistantResponse = `## Current Federal Reserve Interest Rate
+
+The Federal Open Market Committee (FOMC) has set the **federal funds target rate** at a range of **4.25% to 4.50%**, effective since the December 18, 2024 meeting.
+
+### Rate Trajectory (Past 12 Months)
+
+| Meeting Date | Decision | Target Range |
+|:---|:---|:---|
+| Dec 18, 2024 | -25 bps | 4.25% – 4.50% |
+| Nov 7, 2024 | -25 bps | 4.50% – 4.75% |
+| Sep 18, 2024 | -50 bps | 4.75% – 5.00% |
+| Jul 31, 2024 | Hold | 5.25% – 5.50% |
+| Jun 12, 2024 | Hold | 5.25% – 5.50% |
+| May 1, 2024 | Hold | 5.25% – 5.50% |
+| Mar 20, 2024 | Hold | 5.25% – 5.50% |
+
+### Key Observations
+
+1. **Easing Cycle Began**: The Fed started cutting rates in September 2024 with an aggressive 50 bps cut, followed by two 25 bps cuts
+2. **Cumulative Reduction**: Rates have been lowered by **100 basis points** total from the cycle peak of 5.25%–5.50%
+3. **Pause Signals**: Recent FOMC language suggests a *cautious approach* to further cuts, citing:
+   - Persistent core inflation above the 2% target
+   - Strong labor market conditions
+   - Uncertainty around fiscal policy changes
+
+### Upcoming FOMC Schedule
+
+The next scheduled meeting is **January 28–29, 2025**. Market expectations via CME FedWatch:
+
+\`\`\`
+Hold (no change):  89.3%
+Cut (-25 bps):     10.7%
+\`\`\`
+
+> **Note**: Market pricing strongly favors a hold at the January meeting, with the first expected cut pushed to mid-2025.
+
+### Sources
+- [Federal Reserve Board – Policy Actions](https://federalreserve.gov)
+- CME FedWatch Tool (as of Jan 15, 2025)
+- FOMC Statement, December 18, 2024`;
+  const toolCallResult = JSON.stringify({
+    status: 200,
+    contentType: "text/html",
+    body: "<html>...Federal Reserve maintains the target range for the federal funds rate at 4-1/4 to 4-1/2 percent...</html>",
+    truncated: true,
+  });
+  const promptMessages = JSON.stringify([
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage },
+  ]);
+  const toolDefs = JSON.stringify([
+    JSON.stringify({
+      type: "function",
+      name: "webSearch",
+      description: "Search the web for information",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string" },
+          num: { type: "number" },
+        },
+        required: ["query"],
+      },
+    }),
+  ]);
+  const toolCallsJson = JSON.stringify([
+    {
+      id: "call_seed_001",
+      type: "function",
+      function: {
+        name: "webSearch",
+        arguments: '{"query":"federal reserve interest rate 2024","num":5}',
+      },
+    },
+  ]);
+
+  // --- Span IDs ---
+  const attemptId = generateSpanId();
+  const runFnId = generateSpanId();
+
+  // streamText sub-tree IDs
+  const streamWrapId = generateSpanId();
+  const stream1Id = generateSpanId();
+  const toolCall1Id = generateSpanId();
+  const stream2Id = generateSpanId();
+
+  // generateText sub-tree IDs (Anthropic with cache)
+  const genTextWrapId = generateSpanId();
+  const genTextDoId = generateSpanId();
+  const toolCall2Id = generateSpanId();
+
+  // generateObject sub-tree IDs (gateway → xAI)
+  const genObjWrapId = generateSpanId();
+  const genObjDoId = generateSpanId();
+
+  // generateObject sub-tree IDs (Google Gemini)
+  const genObjGeminiWrapId = generateSpanId();
+  const genObjGeminiDoId = generateSpanId();
+
+  // =====================================================================
+  // Structural spans: root → attempt → run()
+  // =====================================================================
+  const rootStart = baseTimeMs;
+  const totalDuration = 120_000; // 2 minutes to cover all ~18 scenarios
+
+  events.push(
+    makeEvent({
+      message: taskSlug,
+      spanId: rootSpanId,
+      parentId: undefined,
+      startMs: rootStart,
+      durationMs: totalDuration,
+      properties: {},
+    })
+  );
+
+  events.push(
+    makeEvent({
+      message: "Attempt 1",
+      spanId: attemptId,
+      parentId: rootSpanId,
+      startMs: rootStart + 30,
+      durationMs: totalDuration - 60,
+      properties: { "$entity.type": "attempt" },
+      style: { icon: "attempt", variant: "cold" },
+      attemptNumber: 1,
+    })
+  );
+
+  events.push(
+    makeEvent({
+      message: "run()",
+      spanId: runFnId,
+      parentId: attemptId,
+      startMs: rootStart + 60,
+      durationMs: totalDuration - 120,
+      properties: {},
+      style: { icon: "task-fn-run" },
+      attemptNumber: 1,
+    })
+  );
+
+  // =====================================================================
+  // 1) ai.streamText — OpenAI gpt-4o-mini with tool use (2 LLM calls)
+  // =====================================================================
+  cursor = rootStart + 100;
+  const stWrap = next(9_500);
+
+  events.push(
+    makeEvent({
+      message: "ai.streamText",
+      spanId: streamWrapId,
+      parentId: runFnId,
+      ...stWrap,
+      properties: {
+        "ai.operationId": "ai.streamText",
+        "ai.model.id": "gpt-4o-mini",
+        "ai.model.provider": "openai.responses",
+        "ai.response.finishReason": "stop",
+        "ai.response.text": assistantResponse,
+        "ai.usage.inputTokens": 807,
+        "ai.usage.outputTokens": 242,
+        "ai.usage.totalTokens": 1049,
+        "ai.telemetry.metadata.userId": seedUserId,
+        "ai.telemetry.functionId": "ai-chat",
+        "operation.name": "ai.streamText",
+      },
+    })
+  );
+
+  cursor = stWrap.startMs + 50;
+  const st1 = next(2_500);
+  events.push(
+    makeEvent({
+      message: "ai.streamText.doStream",
+      spanId: stream1Id,
+      parentId: streamWrapId,
+      ...st1,
+      properties: {
+        "gen_ai.system": "openai.responses",
+        "gen_ai.request.model": "gpt-4o-mini",
+        "gen_ai.response.model": "gpt-4o-mini-2024-07-18",
+        "gen_ai.usage.input_tokens": 284,
+        "gen_ai.usage.output_tokens": 55,
+        "ai.model.id": "gpt-4o-mini",
+        "ai.model.provider": "openai.responses",
+        "ai.operationId": "ai.streamText.doStream",
+        "ai.prompt.messages": promptMessages,
+        "ai.prompt.tools": toolDefs,
+        "ai.prompt.toolChoice": '{"type":"auto"}',
+        "ai.settings.maxRetries": 2,
+        "ai.response.finishReason": "tool-calls",
+        "ai.response.toolCalls": toolCallsJson,
+        "ai.response.text": "",
+        "ai.response.id": "resp_seed_001",
+        "ai.response.model": "gpt-4o-mini-2024-07-18",
+        "ai.response.msToFirstChunk": 891.37,
+        "ai.response.msToFinish": 2321.12,
+        "ai.response.timestamp": new Date(st1.startMs + st1.durationMs).toISOString(),
+        "ai.usage.inputTokens": 284,
+        "ai.usage.outputTokens": 55,
+        "ai.usage.totalTokens": 339,
+        "ai.telemetry.metadata.userId": seedUserId,
+        "ai.telemetry.functionId": "ai-chat",
+        "operation.name": "ai.streamText.doStream",
+      },
+    })
+  );
+
+  const tc1 = next(3_000);
+  events.push(
+    makeEvent({
+      message: "ai.toolCall",
+      spanId: toolCall1Id,
+      parentId: streamWrapId,
+      ...tc1,
+      properties: {
+        "ai.operationId": "ai.toolCall",
+        "ai.toolCall.name": "webSearch",
+        "ai.toolCall.id": "call_seed_001",
+        "ai.toolCall.args": '{"query":"federal reserve interest rate 2024","num":5}',
+        "ai.toolCall.result": toolCallResult,
+        "operation.name": "ai.toolCall",
+      },
+    })
+  );
+
+  const st2 = next(3_500);
+  events.push(
+    makeEvent({
+      message: "ai.streamText.doStream",
+      spanId: stream2Id,
+      parentId: streamWrapId,
+      ...st2,
+      properties: {
+        "gen_ai.system": "openai.responses",
+        "gen_ai.request.model": "gpt-4o-mini",
+        "gen_ai.response.model": "gpt-4o-mini-2024-07-18",
+        "gen_ai.usage.input_tokens": 523,
+        "gen_ai.usage.output_tokens": 187,
+        "ai.model.id": "gpt-4o-mini",
+        "ai.model.provider": "openai.responses",
+        "ai.operationId": "ai.streamText.doStream",
+        "ai.prompt.messages": promptMessages,
+        "ai.settings.maxRetries": 2,
+        "ai.response.finishReason": "stop",
+        "ai.response.text": assistantResponse,
+        "ai.response.reasoning":
+          "Let me analyze the Federal Reserve data to provide the current rate.",
+        "ai.response.id": "resp_seed_002",
+        "ai.response.model": "gpt-4o-mini-2024-07-18",
+        "ai.response.msToFirstChunk": 672.45,
+        "ai.response.msToFinish": 3412.89,
+        "ai.response.timestamp": new Date(st2.startMs + st2.durationMs).toISOString(),
+        "ai.usage.inputTokens": 523,
+        "ai.usage.outputTokens": 187,
+        "ai.usage.totalTokens": 710,
+        "ai.usage.reasoningTokens": 42,
+        "ai.telemetry.metadata.userId": seedUserId,
+        "ai.telemetry.functionId": "ai-chat",
+        "operation.name": "ai.streamText.doStream",
+      },
+    })
+  );
+
+  // =====================================================================
+  // 2) ai.generateText — Anthropic claude-haiku-4-5 with tool call + cache
+  // =====================================================================
+  const gtWrap = next(4_200);
+
+  events.push(
+    makeEvent({
+      message: "ai.generateText",
+      spanId: genTextWrapId,
+      parentId: runFnId,
+      ...gtWrap,
+      properties: {
+        "ai.operationId": "ai.generateText",
+        "ai.model.id": "claude-haiku-4-5",
+        "ai.model.provider": "anthropic.messages",
+        "ai.response.finishReason": "stop",
+        "ai.response.text": "Based on the search results, the current rate is 4.25%-4.50%.",
+        "ai.usage.promptTokens": 9951,
+        "ai.usage.completionTokens": 803,
+        "ai.telemetry.metadata.agentName": "research-agent",
+        "ai.telemetry.functionId": "ai-chat",
+        "operation.name": "ai.generateText",
+      },
+    })
+  );
+
+  cursor = gtWrap.startMs + 50;
+  const gtDo = next(3_200);
+  events.push(
+    makeEvent({
+      message: "ai.generateText.doGenerate",
+      spanId: genTextDoId,
+      parentId: genTextWrapId,
+      ...gtDo,
+      properties: {
+        "gen_ai.system": "anthropic.messages",
+        "gen_ai.request.model": "claude-haiku-4-5",
+        "gen_ai.response.model": "claude-haiku-4-5-20251001",
+        "gen_ai.usage.input_tokens": 9951,
+        "gen_ai.usage.output_tokens": 803,
+        "gen_ai.usage.cache_read_input_tokens": 8200,
+        "gen_ai.usage.cache_creation_input_tokens": 1751,
+        "ai.model.id": "claude-haiku-4-5",
+        "ai.model.provider": "anthropic.messages",
+        "ai.operationId": "ai.generateText.doGenerate",
+        "ai.prompt.messages": promptMessages,
+        "ai.prompt.toolChoice": '{"type":"auto"}',
+        "ai.settings.maxRetries": 2,
+        "ai.response.finishReason": "tool-calls",
+        "ai.response.id": "msg_seed_003",
+        "ai.response.model": "claude-haiku-4-5-20251001",
+        "ai.response.text":
+          "I'll search for the latest Federal Reserve interest rate information.",
+        "ai.response.toolCalls": JSON.stringify([
+          {
+            toolCallId: "toolu_seed_001",
+            toolName: "webSearch",
+            input: '{"query":"federal reserve interest rate current"}',
+          },
+        ]),
+        "ai.response.providerMetadata": JSON.stringify({
+          anthropic: {
+            usage: {
+              input_tokens: 9951,
+              output_tokens: 803,
+              cache_creation_input_tokens: 1751,
+              cache_read_input_tokens: 8200,
+              service_tier: "standard",
+            },
+          },
+        }),
+        "ai.response.timestamp": new Date(gtDo.startMs + gtDo.durationMs).toISOString(),
+        "ai.usage.promptTokens": 9951,
+        "ai.usage.completionTokens": 803,
+        "ai.telemetry.metadata.agentName": "research-agent",
+        "ai.telemetry.functionId": "ai-chat",
+        "operation.name": "ai.generateText.doGenerate",
+      },
+    })
+  );
+
+  const tc2 = next(500);
+  events.push(
+    makeEvent({
+      message: "ai.toolCall",
+      spanId: toolCall2Id,
+      parentId: genTextWrapId,
+      ...tc2,
+      properties: {
+        "ai.operationId": "ai.toolCall",
+        "ai.toolCall.name": "webSearch",
+        "ai.toolCall.id": "toolu_seed_001",
+        "ai.toolCall.args": '{"query":"federal reserve interest rate current"}',
+        "ai.toolCall.result":
+          '[{"title":"Federal Reserve Board - Policy Rate","link":"https://federalreserve.gov/rates","snippet":"The target range is 4.25% to 4.50%"}]',
+        "operation.name": "ai.toolCall",
+        "resource.name": "ai-chat",
+      },
+    })
+  );
+
+  // =====================================================================
+  // 3) ai.generateObject — Gateway → xAI/grok with structured output
+  // =====================================================================
+  const goWrap = next(1_800);
+
+  events.push(
+    makeEvent({
+      message: "ai.generateObject",
+      spanId: genObjWrapId,
+      parentId: runFnId,
+      ...goWrap,
+      properties: {
+        "ai.operationId": "ai.generateObject",
+        "ai.model.id": "xai/grok-4.1-fast-non-reasoning",
+        "ai.model.provider": "gateway",
+        "ai.response.finishReason": "stop",
+        "ai.response.object": JSON.stringify({
+          summary: "Fed rate at 4.25%-4.50%",
+          confidence: 0.95,
+          sources: ["federalreserve.gov"],
+        }),
+        "ai.telemetry.metadata.model": "xai/grok-4.1-fast-non-reasoning",
+        "ai.telemetry.metadata.schemaType": "schema",
+        "ai.telemetry.functionId": "generateObject",
+        "operation.name": "ai.generateObject",
+      },
+    })
+  );
+
+  cursor = goWrap.startMs + 50;
+  const goDo = next(1_600);
+  events.push(
+    makeEvent({
+      message: "ai.generateObject.doGenerate",
+      spanId: genObjDoId,
+      parentId: genObjWrapId,
+      ...goDo,
+      properties: {
+        "gen_ai.system": "gateway",
+        "gen_ai.request.model": "xai/grok-4.1-fast-non-reasoning",
+        "gen_ai.response.model": "xai/grok-4.1-fast-non-reasoning",
+        "gen_ai.usage.input_tokens": 1629,
+        "gen_ai.usage.output_tokens": 158,
+        "ai.model.id": "xai/grok-4.1-fast-non-reasoning",
+        "ai.model.provider": "gateway",
+        "ai.operationId": "ai.generateObject.doGenerate",
+        "ai.prompt.messages": promptMessages,
+        "ai.settings.maxRetries": 3,
+        "ai.response.finishReason": "stop",
+        "ai.response.id": "aiobj_seed_001",
+        "ai.response.model": "xai/grok-4.1-fast-non-reasoning",
+        "ai.response.object": JSON.stringify({
+          summary: "Fed rate at 4.25%-4.50%",
+          confidence: 0.95,
+          sources: ["federalreserve.gov"],
+        }),
+        "ai.response.providerMetadata": JSON.stringify({
+          gateway: {
+            routing: {
+              originalModelId: "xai/grok-4.1-fast-non-reasoning",
+              resolvedProvider: "xai",
+              canonicalSlug: "xai/grok-4.1-fast-non-reasoning",
+              finalProvider: "xai",
+              modelAttemptCount: 1,
+            },
+            cost: "0.0002905",
+            generationId: "gen_seed_001",
+          },
+        }),
+        "ai.response.timestamp": new Date(goDo.startMs + goDo.durationMs).toISOString(),
+        "ai.usage.completionTokens": 158,
+        "ai.usage.promptTokens": 1629,
+        "ai.request.headers.user-agent": "ai/5.0.60",
+        "operation.name": "ai.generateObject.doGenerate",
+      },
+    })
+  );
+
+  // =====================================================================
+  // 4) ai.generateObject — Google Gemini (generative-ai) with thinking tokens
+  // =====================================================================
+  const goGemWrap = next(2_200);
+
+  events.push(
+    makeEvent({
+      message: "ai.generateObject",
+      spanId: genObjGeminiWrapId,
+      parentId: runFnId,
+      ...goGemWrap,
+      properties: {
+        "ai.operationId": "ai.generateObject",
+        "ai.model.id": "gemini-2.5-flash",
+        "ai.model.provider": "google.generative-ai",
+        "ai.response.finishReason": "stop",
+        "ai.response.object": JSON.stringify({
+          category: "financial_data",
+          label: "interest_rate",
+        }),
+        "ai.telemetry.functionId": "classify-content",
+        "operation.name": "ai.generateObject",
+      },
+    })
+  );
+
+  cursor = goGemWrap.startMs + 50;
+  const goGemDo = next(2_000);
+  events.push(
+    makeEvent({
+      message: "ai.generateObject.doGenerate",
+      spanId: genObjGeminiDoId,
+      parentId: genObjGeminiWrapId,
+      ...goGemDo,
+      properties: {
+        "gen_ai.system": "google.generative-ai",
+        "gen_ai.request.model": "gemini-2.5-flash",
+        "gen_ai.response.model": "gemini-2.5-flash",
+        "gen_ai.usage.input_tokens": 898,
+        "gen_ai.usage.output_tokens": 521,
+        "ai.model.id": "gemini-2.5-flash",
+        "ai.model.provider": "google.generative-ai",
+        "ai.operationId": "ai.generateObject.doGenerate",
+        "ai.prompt.messages": JSON.stringify([
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "Classify this content: Federal Reserve interest rate analysis",
+              },
+            ],
+          },
+        ]),
+        "ai.settings.maxRetries": 3,
+        "ai.response.finishReason": "stop",
+        "ai.response.id": "aiobj_seed_gemini",
+        "ai.response.model": "gemini-2.5-flash",
+        "ai.response.object": JSON.stringify({
+          category: "financial_data",
+          label: "interest_rate",
+        }),
+        "ai.response.providerMetadata": JSON.stringify({
+          google: {
+            usageMetadata: {
+              thoughtsTokenCount: 510,
+              promptTokenCount: 898,
+              candidatesTokenCount: 11,
+              totalTokenCount: 1419,
+            },
+          },
+        }),
+        "ai.response.timestamp": new Date(goGemDo.startMs + goGemDo.durationMs).toISOString(),
+        "ai.usage.completionTokens": 521,
+        "ai.usage.promptTokens": 898,
+        "operation.name": "ai.generateObject.doGenerate",
+      },
+    })
+  );
+
+  // =====================================================================
+  // Helper: add a wrapper + doGenerate/doStream pair
+  // =====================================================================
+  function addLlmPair(opts: {
+    wrapperMsg: string; // e.g. "ai.generateText"
+    doMsg: string; // e.g. "ai.generateText.doGenerate"
+    system: string;
+    reqModel: string;
+    respModel: string;
+    inputTokens: number;
+    outputTokens: number;
+    finishReason: string;
+    wrapperDurationMs: number;
+    doDurationMs: number;
+    responseText?: string;
+    responseObject?: string;
+    responseReasoning?: string;
+    toolCallsJson?: string;
+    providerMetadata?: Record<string, unknown>;
+    telemetryMetadata?: Record<string, string>;
+    settings?: Record<string, unknown>;
+    /** Use completionTokens/promptTokens instead of inputTokens/outputTokens */
+    useCompletionStyle?: boolean;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    reasoningTokens?: number;
+    extraDoProps?: Record<string, unknown>;
+  }) {
+    const wId = generateSpanId();
+    const dId = generateSpanId();
+
+    const wrap = next(opts.wrapperDurationMs);
+    const wrapperProps: Record<string, unknown> = {
+      "ai.operationId": opts.wrapperMsg,
+      "ai.model.id": opts.reqModel,
+      "ai.model.provider": opts.system,
+      "ai.response.finishReason": opts.finishReason,
+      "operation.name": opts.wrapperMsg,
+    };
+    if (opts.responseText) wrapperProps["ai.response.text"] = opts.responseText;
+    if (opts.responseObject) wrapperProps["ai.response.object"] = opts.responseObject;
+    if (opts.telemetryMetadata) {
+      for (const [k, v] of Object.entries(opts.telemetryMetadata)) {
+        wrapperProps[`ai.telemetry.metadata.${k}`] = v;
+      }
+    }
+
+    events.push(makeEvent({ message: opts.wrapperMsg, spanId: wId, parentId: runFnId, ...wrap, properties: wrapperProps }));
+
+    cursor = wrap.startMs + 50;
+    const doTiming = next(opts.doDurationMs);
+
+    const doProps: Record<string, unknown> = {
+      "gen_ai.system": opts.system,
+      "gen_ai.request.model": opts.reqModel,
+      "gen_ai.response.model": opts.respModel,
+      "gen_ai.usage.input_tokens": opts.inputTokens,
+      "gen_ai.usage.output_tokens": opts.outputTokens,
+      "ai.model.id": opts.reqModel,
+      "ai.model.provider": opts.system,
+      "ai.operationId": opts.doMsg,
+      "ai.prompt.messages": promptMessages,
+      "ai.response.finishReason": opts.finishReason,
+      "ai.response.id": `resp_seed_${generateSpanId().slice(0, 8)}`,
+      "ai.response.model": opts.respModel,
+      "ai.response.timestamp": new Date(doTiming.startMs + doTiming.durationMs).toISOString(),
+      "operation.name": opts.doMsg,
+    };
+
+    // Token style
+    if (opts.useCompletionStyle) {
+      doProps["ai.usage.completionTokens"] = opts.outputTokens;
+      doProps["ai.usage.promptTokens"] = opts.inputTokens;
+    } else {
+      doProps["ai.usage.inputTokens"] = opts.inputTokens;
+      doProps["ai.usage.outputTokens"] = opts.outputTokens;
+      doProps["ai.usage.totalTokens"] = opts.inputTokens + opts.outputTokens;
+    }
+
+    if (opts.responseText) doProps["ai.response.text"] = opts.responseText;
+    if (opts.responseObject) doProps["ai.response.object"] = opts.responseObject;
+    if (opts.responseReasoning) doProps["ai.response.reasoning"] = opts.responseReasoning;
+    if (opts.toolCallsJson) doProps["ai.response.toolCalls"] = opts.toolCallsJson;
+    if (opts.cacheReadTokens) {
+      doProps["gen_ai.usage.cache_read_input_tokens"] = opts.cacheReadTokens;
+    }
+    if (opts.cacheCreationTokens) {
+      doProps["gen_ai.usage.cache_creation_input_tokens"] = opts.cacheCreationTokens;
+    }
+    if (opts.reasoningTokens) {
+      doProps["ai.usage.reasoningTokens"] = opts.reasoningTokens;
+    }
+    if (opts.providerMetadata) {
+      doProps["ai.response.providerMetadata"] = JSON.stringify(opts.providerMetadata);
+    }
+    if (opts.settings) {
+      for (const [k, v] of Object.entries(opts.settings)) {
+        doProps[`ai.settings.${k}`] = v;
+      }
+    }
+    if (opts.telemetryMetadata) {
+      for (const [k, v] of Object.entries(opts.telemetryMetadata)) {
+        doProps[`ai.telemetry.metadata.${k}`] = v;
+      }
+    }
+    if (opts.extraDoProps) Object.assign(doProps, opts.extraDoProps);
+
+    events.push(makeEvent({ message: opts.doMsg, spanId: dId, parentId: wId, ...doTiming, properties: doProps }));
+
+    return { wrapperId: wId, doId: dId };
+  }
+
+  // Helper: add a tool call span
+  function addToolCall(parentId: string, name: string, args: string, result: string, durationMs = 500) {
+    const id = generateSpanId();
+    const timing = next(durationMs);
+    events.push(makeEvent({
+      message: "ai.toolCall",
+      spanId: id,
+      parentId,
+      ...timing,
+      properties: {
+        "ai.operationId": "ai.toolCall",
+        "ai.toolCall.name": name,
+        "ai.toolCall.id": `call_${generateSpanId().slice(0, 8)}`,
+        "ai.toolCall.args": args,
+        "ai.toolCall.result": result,
+        "operation.name": "ai.toolCall",
+      },
+    }));
+    return id;
+  }
+
+  // =====================================================================
+  // 5) Gateway → Mistral mistral-large-3
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "gateway",
+    reqModel: "mistral/mistral-large-3",
+    respModel: "mistral/mistral-large-3",
+    inputTokens: 1179,
+    outputTokens: 48,
+    finishReason: "stop",
+    wrapperDurationMs: 1_400,
+    doDurationMs: 1_200,
+    responseText: `### Document Analysis
+
+The document primarily discusses **quarterly earnings guidance** for the technology sector, with the following key themes:
+
+- Revenue growth projections of *12–15%* YoY
+- Margin compression due to increased R&D spending
+- Forward guidance citing \`macroeconomic headwinds\`
+
+**Confidence**: High (0.92)`,
+    useCompletionStyle: true,
+    providerMetadata: {
+      gateway: {
+        routing: {
+          originalModelId: "mistral/mistral-large-3",
+          resolvedProvider: "mistral",
+          resolvedProviderApiModelId: "mistral-large-latest",
+          canonicalSlug: "mistral/mistral-large-3",
+          finalProvider: "mistral",
+          modelAttemptCount: 1,
+        },
+        cost: "0.0006615",
+        marketCost: "0.0006615",
+        generationId: "gen_seed_mistral_001",
+      },
+    },
+    extraDoProps: { "ai.request.headers.user-agent": "ai/5.0.60" },
+  });
+
+  // =====================================================================
+  // 6) Gateway → OpenAI gpt-5-mini (with fallback metadata)
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "gateway",
+    reqModel: "openai/gpt-5-mini",
+    respModel: "openai/gpt-5-mini",
+    inputTokens: 2450,
+    outputTokens: 312,
+    finishReason: "stop",
+    wrapperDurationMs: 5_000,
+    doDurationMs: 4_800,
+    responseText: "NO",
+    useCompletionStyle: true,
+    providerMetadata: {
+      openai: { responseId: "resp_seed_gw_openai", serviceTier: "default" },
+      gateway: {
+        routing: {
+          originalModelId: "openai/gpt-5-mini",
+          resolvedProvider: "openai",
+          resolvedProviderApiModelId: "gpt-5-mini-2025-08-07",
+          canonicalSlug: "openai/gpt-5-mini",
+          finalProvider: "openai",
+          fallbacksAvailable: ["azure"],
+          planningReasoning: "System credentials planned for: openai, azure. Total execution order: openai(system) → azure(system)",
+          modelAttemptCount: 1,
+        },
+        cost: "0.000482",
+        generationId: "gen_seed_gpt5mini_001",
+      },
+    },
+    extraDoProps: { "ai.request.headers.user-agent": "ai/6.0.49" },
+  });
+
+  // =====================================================================
+  // 7) Gateway → DeepSeek deepseek-v3.2 (tool-calls)
+  // =====================================================================
+  const ds = addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "gateway",
+    reqModel: "deepseek/deepseek-v3.2",
+    respModel: "deepseek/deepseek-v3.2",
+    inputTokens: 3200,
+    outputTokens: 420,
+    finishReason: "tool-calls",
+    wrapperDurationMs: 2_800,
+    doDurationMs: 2_500,
+    responseObject: JSON.stringify({ action: "search", query: "fed rate history" }),
+    useCompletionStyle: true,
+    providerMetadata: {
+      gateway: {
+        routing: {
+          originalModelId: "deepseek/deepseek-v3.2",
+          resolvedProvider: "deepseek",
+          canonicalSlug: "deepseek/deepseek-v3.2",
+          finalProvider: "deepseek",
+          modelAttemptCount: 1,
+        },
+        cost: "0.000156",
+        generationId: "gen_seed_deepseek_001",
+      },
+    },
+  });
+  addToolCall(ds.wrapperId, "classifyContent", '{"text":"Federal Reserve rate analysis"}', '{"category":"finance","confidence":0.98}');
+
+  // =====================================================================
+  // 8) Gateway → Anthropic claude-haiku via gateway prefix
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "gateway",
+    reqModel: "anthropic/claude-haiku-4-5-20251001",
+    respModel: "anthropic/claude-haiku-4-5-20251001",
+    inputTokens: 5400,
+    outputTokens: 220,
+    finishReason: "stop",
+    wrapperDurationMs: 1_800,
+    doDurationMs: 1_500,
+    responseText: `## Content Classification Report
+
+**Category**: Financial News Article
+**Risk Level**: SAFE ✓
+
+### Analysis Breakdown
+
+| Criteria | Result | Score |
+|:---|:---|---:|
+| Factual accuracy | Verified | 0.94 |
+| Bias detection | Minimal | 0.12 |
+| Misinformation risk | Low | 0.08 |
+| Regulatory sensitivity | None detected | 0.02 |
+
+> This content follows standard financial journalism conventions and references official Federal Reserve communications directly.`,
+    useCompletionStyle: true,
+    providerMetadata: {
+      gateway: {
+        routing: {
+          originalModelId: "anthropic/claude-haiku-4-5-20251001",
+          resolvedProvider: "anthropic",
+          canonicalSlug: "anthropic/claude-haiku-4-5-20251001",
+          finalProvider: "anthropic",
+          modelAttemptCount: 1,
+        },
+        cost: "0.00312",
+        generationId: "gen_seed_gw_anthropic_001",
+      },
+    },
+  });
+
+  // =====================================================================
+  // 9) Gateway → Google gemini-3-flash-preview (structured output)
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "gateway",
+    reqModel: "google/gemini-3-flash-preview",
+    respModel: "google/gemini-3-flash-preview",
+    inputTokens: 720,
+    outputTokens: 85,
+    finishReason: "stop",
+    wrapperDurationMs: 1_200,
+    doDurationMs: 1_000,
+    responseObject: JSON.stringify({ sentiment: "neutral", topics: ["monetary_policy", "interest_rates"] }),
+    useCompletionStyle: true,
+    providerMetadata: {
+      gateway: {
+        routing: {
+          originalModelId: "google/gemini-3-flash-preview",
+          resolvedProvider: "google",
+          canonicalSlug: "google/gemini-3-flash-preview",
+          finalProvider: "google",
+          modelAttemptCount: 1,
+        },
+        cost: "0.0000803",
+        generationId: "gen_seed_gw_gemini_001",
+      },
+    },
+  });
+
+  // =====================================================================
+  // 10) OpenRouter → x-ai/grok-4-fast (with reasoning_details)
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "openrouter",
+    reqModel: "x-ai/grok-4-fast",
+    respModel: "x-ai/grok-4-fast",
+    inputTokens: 375,
+    outputTokens: 226,
+    finishReason: "stop",
+    wrapperDurationMs: 1_600,
+    doDurationMs: 1_400,
+    responseObject: JSON.stringify({ hook: "Breaking: Fed holds rates steady", isValidHook: true }),
+    useCompletionStyle: true,
+    telemetryMetadata: { model: "x-ai/grok-4-fast", schemaType: "schema", temperature: "1" },
+    settings: { maxRetries: 2, temperature: 1 },
+    providerMetadata: {
+      openrouter: {
+        provider: "xAI",
+        reasoning_details: [{ type: "reasoning.encrypted", data: "encrypted_seed_data..." }],
+        usage: {
+          promptTokens: 375,
+          promptTokensDetails: { cachedTokens: 343 },
+          completionTokens: 226,
+          completionTokensDetails: { reasoningTokens: 210 },
+          totalTokens: 601,
+          cost: 0.0001351845,
+          costDetails: { upstreamInferenceCost: 0.00013655 },
+        },
+      },
+    },
+  });
+
+  // =====================================================================
+  // 11) OpenRouter → google/gemini-2.5-flash
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "openrouter",
+    reqModel: "google/gemini-2.5-flash",
+    respModel: "google/gemini-2.5-flash",
+    inputTokens: 1840,
+    outputTokens: 320,
+    finishReason: "stop",
+    wrapperDurationMs: 2_000,
+    doDurationMs: 1_800,
+    responseText: `Based on the latest FOMC minutes, the committee voted **unanimously** to maintain rates at the current target range.
+
+### Key Takeaways from the Minutes
+
+1. **Labor Market**: Participants noted that employment conditions remain *"solid"* but acknowledged some cooling in job openings
+2. **Inflation Outlook**: Core PCE inflation running at 2.8% — still above the 2% target
+3. **Forward Guidance**: Several participants emphasized the need for \`patience\` before additional rate adjustments
+
+#### Notable Quotes
+
+> "The Committee judges that the risks to achieving its employment and inflation goals are roughly in balance." — *FOMC Statement*
+
+The next decision point will hinge on incoming data, particularly:
+- January CPI release (Feb 12)
+- January employment report (Feb 7)
+- Q4 GDP second estimate (Feb 27)`,
+    useCompletionStyle: true,
+    providerMetadata: {
+      openrouter: {
+        provider: "Google AI Studio",
+        usage: {
+          promptTokens: 1840,
+          completionTokens: 320,
+          totalTokens: 2160,
+          cost: 0.000264,
+          costDetails: { upstreamInferenceCost: 0.000232 },
+        },
+      },
+    },
+  });
+
+  // =====================================================================
+  // 12) OpenRouter → openai/gpt-4.1-mini (req ≠ resp model name)
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "openrouter",
+    reqModel: "openai/gpt-4.1-mini",
+    respModel: "openai/gpt-4.1-mini-2025-04-14",
+    inputTokens: 890,
+    outputTokens: 145,
+    finishReason: "stop",
+    wrapperDurationMs: 1_400,
+    doDurationMs: 1_200,
+    responseObject: JSON.stringify({ summary: "Rate unchanged at 4.25-4.50%", date: "2024-12-18" }),
+    useCompletionStyle: true,
+    providerMetadata: {
+      openrouter: {
+        provider: "OpenAI",
+        usage: {
+          promptTokens: 890,
+          completionTokens: 145,
+          totalTokens: 1035,
+          cost: 0.0000518,
+        },
+      },
+    },
+  });
+
+  // =====================================================================
+  // 13) Azure → gpt-5 with tool-calls
+  // =====================================================================
+  const az = addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "azure.responses",
+    reqModel: "gpt-5-2025-08-07",
+    respModel: "gpt-5-2025-08-07",
+    inputTokens: 2038,
+    outputTokens: 239,
+    finishReason: "tool-calls",
+    wrapperDurationMs: 3_500,
+    doDurationMs: 3_000,
+    responseText: "Let me look up the latest rate decision.",
+    toolCallsJson: JSON.stringify([{
+      toolCallId: "call_azure_001",
+      toolName: "lookupRate",
+      input: '{"source":"federal_reserve","metric":"funds_rate"}',
+    }]),
+    providerMetadata: {
+      azure: { responseId: "resp_seed_azure_001", serviceTier: "default" },
+    },
+  });
+  addToolCall(az.wrapperId, "lookupRate", '{"source":"federal_reserve","metric":"funds_rate"}', '{"rate":"4.25-4.50%","effectiveDate":"2024-12-18"}');
+
+  // =====================================================================
+  // 14) Perplexity → sonar-pro
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "perplexity",
+    reqModel: "sonar-pro",
+    respModel: "sonar-pro",
+    inputTokens: 151,
+    outputTokens: 428,
+    finishReason: "stop",
+    wrapperDurationMs: 4_500,
+    doDurationMs: 4_200,
+    responseText: `According to the Federal Reserve's most recent announcement on **December 18, 2024**, the federal funds rate target range was maintained at **4.25% to 4.50%**.
+
+### Context
+
+This decision was made during the December FOMC meeting, where the committee:
+
+- Acknowledged *"solid"* economic activity and a labor market that has *"generally eased"*
+- Noted inflation remains *"somewhat elevated"* relative to the 2% target
+- Projected only **two rate cuts** in 2025 (down from four projected in September)
+
+### Market Impact
+
+The announcement triggered a sharp market reaction:
+
+\`\`\`
+S&P 500:    -2.95%  (largest FOMC-day drop since 2001)
+10Y Yield:  +11 bps to 4.52%
+DXY Index:  +1.2% to 108.3
+\`\`\`
+
+> **Sources**: Federal Reserve Board press release, CME FedWatch, Bloomberg Terminal`,
+  });
+
+  // =====================================================================
+  // 15) openai.chat → gpt-4o-mini (legacy chat completions, mode: "tool")
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "openai.chat",
+    reqModel: "gpt-4o-mini",
+    respModel: "gpt-4o-mini-2024-07-18",
+    inputTokens: 573,
+    outputTokens: 11,
+    finishReason: "stop",
+    wrapperDurationMs: 800,
+    doDurationMs: 600,
+    responseObject: JSON.stringify({ title: "Fed Rate Hold", emoji: "🏦" }),
+    settings: { maxRetries: 2, mode: "tool", temperature: 0.3 },
+    providerMetadata: {
+      openai: { reasoningTokens: 0, cachedPromptTokens: 0 },
+    },
+  });
+
+  // =====================================================================
+  // 16) Anthropic claude-sonnet-4-5 → streamText with reasoning
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.streamText",
+    doMsg: "ai.streamText.doStream",
+    system: "anthropic.messages",
+    reqModel: "claude-sonnet-4-5-20250929",
+    respModel: "claude-sonnet-4-5-20250929",
+    inputTokens: 15200,
+    outputTokens: 2840,
+    finishReason: "stop",
+    wrapperDurationMs: 12_000,
+    doDurationMs: 11_500,
+    responseText: `The Federal Reserve has maintained its target range for the federal funds rate at **4.25% to 4.50%** since December 2024.
+
+## Rate Cycle Overview
+
+This represents a **pause** in the rate-cutting cycle that began in September 2024:
+
+| Phase | Period | Action |
+|:---|:---|:---|
+| Peak hold | Jul 2023 – Sep 2024 | Held at 5.25%–5.50% |
+| Easing begins | Sep 2024 | Cut 50 bps |
+| Continued easing | Nov 2024 | Cut 25 bps |
+| Final cut (so far) | Dec 2024 | Cut 25 bps |
+| Current pause | Jan 2025 – present | Hold |
+
+### What's Driving the Pause?
+
+The FOMC has cited three primary factors:
+
+1. **Sticky inflation**: Core PCE at 2.8% remains above the 2% symmetric target
+2. **Resilient growth**: GDP growth of 3.1% in Q3 2024 exceeded expectations
+3. **Policy uncertainty**: New administration trade and fiscal policies create *"unusually elevated"* uncertainty
+
+> The Committee has indicated it will continue to assess incoming data, the evolving outlook, and the balance of risks when considering further adjustments to the target range.
+
+### Technical Note
+
+The effective federal funds rate (\`EFFR\`) currently sits at **4.33%**, near the midpoint of the target range. The overnight reverse repo facility (ON RRP) rate is set at **4.25%**.`,
+    responseReasoning: "The user is asking about the current Federal Reserve interest rate. Let me provide a comprehensive answer based on the most recent FOMC decision. I should include context about the rate trajectory and forward guidance. I'll structure this with a table showing the recent rate changes and explain the pause rationale.",
+    cacheReadTokens: 12400,
+    cacheCreationTokens: 2800,
+    providerMetadata: {
+      anthropic: {
+        usage: {
+          input_tokens: 15200,
+          output_tokens: 2840,
+          cache_creation_input_tokens: 2800,
+          cache_read_input_tokens: 12400,
+          service_tier: "standard",
+          inference_geo: "us-east-1",
+        },
+      },
+    },
+  });
+
+  // =====================================================================
+  // 17) google.vertex.chat → gemini-3.1-pro-preview with tool-calls
+  // =====================================================================
+  const vt = addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "google.vertex.chat",
+    reqModel: "gemini-3.1-pro-preview",
+    respModel: "gemini-3.1-pro-preview",
+    inputTokens: 4200,
+    outputTokens: 680,
+    finishReason: "tool-calls",
+    wrapperDurationMs: 6_000,
+    doDurationMs: 5_500,
+    responseText: "I'll search for the latest FOMC decision and rate information.",
+    toolCallsJson: JSON.stringify([{
+      toolCallId: "call_vertex_001",
+      toolName: "searchFOMC",
+      input: '{"query":"latest FOMC decision december 2024"}',
+    }]),
+    providerMetadata: {
+      google: {
+        usageMetadata: {
+          thoughtsTokenCount: 320,
+          promptTokenCount: 4200,
+          candidatesTokenCount: 680,
+          totalTokenCount: 5200,
+        },
+      },
+    },
+  });
+  addToolCall(vt.wrapperId, "searchFOMC", '{"query":"latest FOMC decision december 2024"}', '{"decision":"hold","rate":"4.25-4.50%","date":"2024-12-18","vote":"unanimous"}', 800);
+
+  // =====================================================================
+  // 18) openai.responses → gpt-5.4 with reasoning tokens
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.streamText",
+    doMsg: "ai.streamText.doStream",
+    system: "openai.responses",
+    reqModel: "gpt-5.4",
+    respModel: "gpt-5.4-2026-03-05",
+    inputTokens: 8900,
+    outputTokens: 1250,
+    finishReason: "stop",
+    wrapperDurationMs: 8_000,
+    doDurationMs: 7_500,
+    responseText: `## Federal Funds Rate — Current Status
+
+The Federal Reserve's current target range is **4.25% to 4.50%**, established at the **December 18, 2024** FOMC meeting.
+
+### Policy Stance
+
+The committee has signaled a *cautious approach* to further rate cuts. Key considerations include:
+
+- **Inflation**: Core PCE remains at 2.8%, above the 2% target
+- **Employment**: Unemployment rate stable at 4.2%, with 256K jobs added in December
+- **Growth**: Real GDP tracking at ~2.5% annualized
+
+### Dot Plot Summary (Dec 2024 SEP)
+
+The median dot plot projections:
+
+\`\`\`python
+# Median FOMC projections
+rates = {
+    "2025": 3.75,  # implies 2 cuts of 25bps
+    "2026": 3.25,  # implies 2 additional cuts
+    "longer_run": 3.00  # neutral rate estimate (up from 2.5%)
+}
+\`\`\`
+
+### Risk Assessment
+
+| Risk Factor | Direction | Magnitude |
+|:---|:---:|:---:|
+| Tariff-driven inflation | ↑ Upside | Medium |
+| Labor market softening | ↓ Downside | Low |
+| Fiscal expansion | ↑ Upside | High |
+| Global growth slowdown | ↓ Downside | Medium |
+
+> *"The committee remains attentive to the risks to both sides of its dual mandate."* — Chair Powell, Dec 18 press conference`,
+    responseReasoning: "I need to provide accurate, up-to-date information about the Federal Reserve interest rate. The last FOMC meeting was in December 2024 where they cut rates by 25 bps after two previous cuts. Let me include the dot plot projections and a risk assessment table for a comprehensive view.",
+    reasoningTokens: 516,
+    providerMetadata: {
+      openai: {
+        responseId: "resp_seed_gpt54_001",
+        serviceTier: "default",
+      },
+    },
+    extraDoProps: {
+      "ai.response.msToFirstChunk": 1842.5,
+      "ai.response.msToFinish": 7234.8,
+      "ai.response.avgOutputTokensPerSecond": 172.8,
+    },
+  });
+
+  // =====================================================================
+  // 19) Cerebras cerebras-gpt-13b — no pricing, no provider cost
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "cerebras.chat",
+    reqModel: "cerebras-gpt-13b",
+    respModel: "cerebras-gpt-13b",
+    inputTokens: 450,
+    outputTokens: 120,
+    finishReason: "stop",
+    wrapperDurationMs: 600,
+    doDurationMs: 400,
+    responseText: `The Federal Reserve rate is currently at **4.25–4.50%**.
+
+Key details:
+- *Effective date*: December 18, 2024
+- *Next meeting*: January 28–29, 2025
+- *Market expectation*: Hold (\`89.3%\` probability per CME FedWatch)`,
+  });
+
+  // =====================================================================
+  // 20) Amazon Bedrock — no pricing in registry
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateText",
+    doMsg: "ai.generateText.doGenerate",
+    system: "amazon-bedrock",
+    reqModel: "us.anthropic.claude-sonnet-4-20250514-v1:0",
+    respModel: "us.anthropic.claude-sonnet-4-20250514-v1:0",
+    inputTokens: 3200,
+    outputTokens: 890,
+    finishReason: "stop",
+    wrapperDurationMs: 4_000,
+    doDurationMs: 3_500,
+    responseText: `Based on the latest FOMC statement, the target rate range remains at **4.25% to 4.50%**.
+
+### Additional Context
+
+The committee's statement included notable language changes:
+- Removed reference to *"gaining greater confidence"* on inflation
+- Added emphasis on monitoring \`both sides\` of the dual mandate
+- Acknowledged *"uncertainty around the economic outlook has increased"*
+
+Governor Bowman dissented, preferring a **hold** rather than the 25 bps cut — the first governor dissent since 2005.`,
+  });
+
+  // =====================================================================
+  // 21) Groq — fast inference, no pricing
+  // =====================================================================
+  addLlmPair({
+    wrapperMsg: "ai.generateObject",
+    doMsg: "ai.generateObject.doGenerate",
+    system: "groq.chat",
+    reqModel: "llama-4-scout-17b-16e-instruct",
+    respModel: "llama-4-scout-17b-16e-instruct",
+    inputTokens: 820,
+    outputTokens: 95,
+    finishReason: "stop",
+    wrapperDurationMs: 300,
+    doDurationMs: 200,
+    responseObject: JSON.stringify({ rate: "4.25-4.50%", source: "FOMC", date: "2024-12-18" }),
+  });
+
+  return events;
+}
+
+// ---------------------------------------------------------------------------
+
+seedAiSpans()
+  .catch((e) => {
+    console.error("Seed failed:");
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });
diff --git a/apps/webapp/seed.mts b/apps/webapp/seed.mts
index aa08eaaeec0..9eb30cd2503 100644
--- a/apps/webapp/seed.mts
+++ b/apps/webapp/seed.mts
@@ -75,6 +75,7 @@ async function seed() {
   }
 
   await createBatchLimitOrgs(user);
+  await ensureDefaultWorkerGroup();
 
   console.log("\n🎉 Seed complete!\n");
   console.log("Summary:");
@@ -249,3 +250,62 @@ async function findOrCreateProject(
 
   return { project, environments };
 }
+
+async function ensureDefaultWorkerGroup() {
+  // Check if the feature flag already exists
+  const existingFlag = await prisma.featureFlag.findUnique({
+    where: { key: "defaultWorkerInstanceGroupId" },
+  });
+
+  if (existingFlag) {
+    console.log(`✅ Default worker instance group already configured`);
+    return;
+  }
+
+  // Check if a managed worker group already exists
+  let workerGroup = await prisma.workerInstanceGroup.findFirst({
+    where: { type: "MANAGED" },
+  });
+
+  if (!workerGroup) {
+    console.log("Creating default worker instance group...");
+
+    const { createHash, randomBytes } = await import("crypto");
+    const tokenValue = `tr_wgt_${randomBytes(20).toString("hex")}`;
+    const tokenHash = createHash("sha256").update(tokenValue).digest("hex");
+
+    const token = await prisma.workerGroupToken.create({
+      data: { tokenHash },
+    });
+
+    workerGroup = await prisma.workerInstanceGroup.create({
+      data: {
+        type: "MANAGED",
+        name: "local-dev",
+        masterQueue: "local-dev",
+        description: "Local development worker group",
+        tokenId: token.id,
+      },
+    });
+
+    console.log(`✅ Created worker instance group: ${workerGroup.name} (${workerGroup.id})`);
+  } else {
+    console.log(
+      `✅ Worker instance group already exists: ${workerGroup.name} (${workerGroup.id})`
+    );
+  }
+
+  // Set the feature flag
+  await prisma.featureFlag.upsert({
+    where: { key: "defaultWorkerInstanceGroupId" },
+    create: {
+      key: "defaultWorkerInstanceGroupId",
+      value: workerGroup.id,
+    },
+    update: {
+      value: workerGroup.id,
+    },
+  });
+
+  console.log(`✅ Set defaultWorkerInstanceGroupId feature flag`);
+}
diff --git a/apps/webapp/tailwind.config.js b/apps/webapp/tailwind.config.js
index 7ca81fd8eea..d598ae83d20 100644
--- a/apps/webapp/tailwind.config.js
+++ b/apps/webapp/tailwind.config.js
@@ -159,7 +159,14 @@ const runs = colors.indigo[500];
 const batches = colors.pink[500];
 const schedules = colors.yellow[500];
 const queues = colors.purple[500];
+const query = colors.blue[500];
+const metrics = colors.green[500];
+const customDashboards = charcoal[400];
 const deployments = colors.green[500];
+const concurrency = colors.amber[500];
+const limits = colors.purple[500];
+const regions = colors.green[500];
+const logs = colors.pink[500];
 const tests = colors.lime[500];
 const apiKeys = colors.amber[500];
 const environmentVariables = colors.pink[500];
@@ -168,6 +175,9 @@ const projectSettings = colors.blue[500];
 const orgSettings = colors.blue[500];
 const docs = colors.blue[500];
 const bulkActions = colors.emerald[500];
+const aiPrompts = colors.blue[500];
+const aiMetrics = colors.green[500];
+const errors = colors.amber[500];
 
 /** Other variables */
 const radius = "0.5rem";
@@ -234,8 +244,13 @@ module.exports = {
         runs,
         batches,
         schedules,
+        concurrency,
         queues,
+        query,
+        regions,
+        limits,
         deployments,
+        logs,
         tests,
         apiKeys,
         environmentVariables,
@@ -244,6 +259,11 @@ module.exports = {
         orgSettings,
         docs,
         bulkActions,
+        metrics,
+        customDashboards,
+        aiPrompts,
+        aiMetrics,
+        errors,
       },
       focusStyles: {
         outline: "1px solid",
diff --git a/apps/webapp/test/authorization.test.ts b/apps/webapp/test/authorization.test.ts
index c2c782f8dce..1dc574966f5 100644
--- a/apps/webapp/test/authorization.test.ts
+++ b/apps/webapp/test/authorization.test.ts
@@ -310,6 +310,84 @@ describe("checkAuthorization", () => {
     });
   });
 
+  describe("Query resource type", () => {
+    it("should grant access with read:query super scope", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query"],
+      };
+      const result = checkAuthorization(
+        entity,
+        "read",
+        { query: "runs" },
+        ["read:query", "read:all", "admin"]
+      );
+      expect(result.authorized).toBe(true);
+    });
+
+    it("should grant access with table-specific query scope", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query:runs"],
+      };
+      const result = checkAuthorization(entity, "read", { query: "runs" });
+      expect(result.authorized).toBe(true);
+    });
+
+    it("should deny access to different table with table-specific scope", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query:runs"],
+      };
+      const result = checkAuthorization(entity, "read", { query: "llm_metrics" });
+      expect(result.authorized).toBe(false);
+    });
+
+    it("should grant access with general read:query scope to any table", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query"],
+      };
+
+      const runsResult = checkAuthorization(entity, "read", { query: "runs" });
+      expect(runsResult.authorized).toBe(true);
+
+      const metricsResult = checkAuthorization(entity, "read", { query: "metrics" });
+      expect(metricsResult.authorized).toBe(true);
+
+      const llmResult = checkAuthorization(entity, "read", { query: "llm_metrics" });
+      expect(llmResult.authorized).toBe(true);
+    });
+
+    it("should grant access to multiple tables when querying with super scope", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query"],
+      };
+      const result = checkAuthorization(
+        entity,
+        "read",
+        { query: ["runs", "llm_metrics"] },
+        ["read:query", "read:all", "admin"]
+      );
+      expect(result.authorized).toBe(true);
+    });
+
+    it("should grant access to schema with read:query scope", () => {
+      const entity: AuthorizationEntity = {
+        type: "PUBLIC_JWT",
+        scopes: ["read:query"],
+      };
+      const result = checkAuthorization(
+        entity,
+        "read",
+        { query: "schema" },
+        ["read:query", "read:all", "admin"]
+      );
+      expect(result.authorized).toBe(true);
+    });
+  });
+
   describe("Without super scope", () => {
     const entityWithoutSuperPermissions: AuthorizationEntity = {
       type: "PUBLIC_JWT",
diff --git a/apps/webapp/test/components/code/tsql/tsqlCompletion.test.ts b/apps/webapp/test/components/code/tsql/tsqlCompletion.test.ts
new file mode 100644
index 00000000000..f5e56fb6e24
--- /dev/null
+++ b/apps/webapp/test/components/code/tsql/tsqlCompletion.test.ts
@@ -0,0 +1,328 @@
+import { describe, it, expect } from "vitest";
+import { createTSQLCompletion } from "~/components/code/tsql/tsqlCompletion";
+import type { TableSchema } from "@internal/tsql";
+
+// Helper to create a mock completion context
+function createMockContext(doc: string, pos: number, explicit = false) {
+  return {
+    state: {
+      doc: {
+        toString: () => doc,
+        sliceString: (from: number, to: number) => doc.slice(from, to),
+      },
+    },
+    pos,
+    explicit,
+    matchBefore: (regex: RegExp) => {
+      const beforePos = doc.slice(0, pos);
+      const match = beforePos.match(new RegExp(regex.source + "$"));
+      if (match) {
+        return {
+          from: pos - match[0].length,
+          to: pos,
+          text: match[0],
+        };
+      }
+      return null;
+    },
+  } as any;
+}
+
+// Test schema with enum columns
+const testSchema: TableSchema[] = [
+  {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+    description: "Task runs table",
+    columns: {
+      id: { name: "id", type: "String", description: "Run ID" },
+      status: {
+        name: "status",
+        type: "LowCardinality(String)",
+        description: "Run status",
+        allowedValues: ["Completed", "Failed", "Queued", "Executing"],
+      },
+      machine: {
+        name: "machine",
+        type: "LowCardinality(String)",
+        description: "Machine preset",
+        allowedValues: ["micro", "small-1x", "small-2x", "medium-1x"],
+      },
+      environment_type: {
+        name: "environment_type",
+        type: "LowCardinality(String)",
+        description: "Environment type",
+        allowedValues: ["PRODUCTION", "STAGING", "DEVELOPMENT", "PREVIEW"],
+      },
+      created_at: { name: "created_at", type: "DateTime64", description: "Creation time" },
+      organization_id: { name: "organization_id", type: "String" },
+      project_id: { name: "project_id", type: "String" },
+      environment_id: { name: "environment_id", type: "String" },
+    },
+  },
+  {
+    name: "logs",
+    clickhouseName: "trigger_dev.task_events_v2",
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+    description: "Task logs table",
+    columns: {
+      id: { name: "id", type: "String" },
+      run_id: { name: "run_id", type: "String" },
+      message: { name: "message", type: "String" },
+      level: { name: "level", type: "String" },
+      timestamp: { name: "timestamp", type: "DateTime64" },
+      organization_id: { name: "organization_id", type: "String" },
+      project_id: { name: "project_id", type: "String" },
+      environment_id: { name: "environment_id", type: "String" },
+    },
+  },
+];
+
+describe("createTSQLCompletion", () => {
+  const completionSource = createTSQLCompletion(testSchema);
+
+  it("should return null for empty input without explicit trigger", () => {
+    const context = createMockContext("", 0, false);
+    const result = completionSource(context);
+    expect(result).toBeNull();
+  });
+
+  it("should return completions when explicitly triggered", () => {
+    const context = createMockContext("", 0, true);
+    const result = completionSource(context);
+    expect(result).not.toBeNull();
+    expect(result?.options.length).toBeGreaterThan(0);
+  });
+
+  it("should include tables in completions", () => {
+    // When typing after FROM, tables should be available
+    const doc = "SELECT * FROM r";
+    const context = createMockContext(doc, doc.length, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    const tableLabels = result?.options.map((o) => o.label);
+    // Tables should always be available in completions
+    expect(tableLabels).toContain("runs");
+    expect(tableLabels).toContain("logs");
+  });
+
+  it("should suggest columns after SELECT keyword", () => {
+    const doc = "SELECT FROM runs";
+    // Position cursor right after SELECT
+    const pos = 7;
+    const context = createMockContext(doc, pos, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    // Should include functions
+    const labels = result?.options.map((o) => o.label) || [];
+    expect(labels.some((l) => l === "count")).toBe(true);
+    expect(labels.some((l) => l === "sum")).toBe(true);
+  });
+
+  it("should suggest columns with table prefix for qualified references", () => {
+    const doc = "SELECT runs. FROM runs";
+    // Position cursor right after "runs."
+    const pos = 12;
+    const context = createMockContext(doc, pos, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    const columnLabels = result?.options.map((o) => o.label);
+    expect(columnLabels).toContain("id");
+    expect(columnLabels).toContain("status");
+    expect(columnLabels).toContain("created_at");
+  });
+
+  it("should include SQL keywords in general context", () => {
+    const doc = "S";
+    const context = createMockContext(doc, doc.length, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    const labels = result?.options.map((o) => o.label);
+    expect(labels).toContain("SELECT");
+  });
+
+  it("should include aggregate functions", () => {
+    const doc = "SELECT ";
+    const context = createMockContext(doc, doc.length, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    const labels = result?.options.map((o) => o.label);
+    expect(labels).toContain("count");
+    expect(labels).toContain("sum");
+    expect(labels).toContain("avg");
+    expect(labels).toContain("min");
+    expect(labels).toContain("max");
+  });
+
+  it("should handle WHERE clause context", () => {
+    const doc = "SELECT * FROM runs WHERE ";
+    const context = createMockContext(doc, doc.length, true);
+    const result = completionSource(context);
+
+    expect(result).not.toBeNull();
+
+    // Should suggest columns
+    const labels = result?.options.map((o) => o.label) || [];
+    expect(labels).toContain("status");
+
+    // Should include conditional keywords
+    expect(labels).toContain("AND");
+    expect(labels).toContain("OR");
+  });
+
+  describe("enum value completions", () => {
+    it("should suggest enum values after = operator", () => {
+      const doc = "SELECT * FROM runs WHERE status = ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Completed'");
+      expect(labels).toContain("'Failed'");
+      expect(labels).toContain("'Queued'");
+      expect(labels).toContain("'Executing'");
+    });
+
+    it("should suggest enum values after = with opening quote", () => {
+      const doc = "SELECT * FROM runs WHERE status = '";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Completed'");
+      expect(labels).toContain("'Failed'");
+    });
+
+    it("should suggest enum values with partial input", () => {
+      const doc = "SELECT * FROM runs WHERE status = 'Comp";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Completed'");
+    });
+
+    it("should suggest enum values for machine column", () => {
+      const doc = "SELECT * FROM runs WHERE machine = ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'micro'");
+      expect(labels).toContain("'small-1x'");
+      expect(labels).toContain("'medium-1x'");
+    });
+
+    it("should suggest enum values for environment_type column", () => {
+      const doc = "SELECT * FROM runs WHERE environment_type = ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'PRODUCTION'");
+      expect(labels).toContain("'STAGING'");
+      expect(labels).toContain("'DEVELOPMENT'");
+    });
+
+    it("should suggest enum values after != operator", () => {
+      const doc = "SELECT * FROM runs WHERE status != ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Completed'");
+      expect(labels).toContain("'Failed'");
+    });
+
+    it("should suggest enum values after IN (", () => {
+      const doc = "SELECT * FROM runs WHERE status IN (";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Completed'");
+      expect(labels).toContain("'Failed'");
+    });
+
+    it("should suggest enum values after comma in IN clause", () => {
+      const doc = "SELECT * FROM runs WHERE status IN ('Completed', ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).toContain("'Failed'");
+      expect(labels).toContain("'Queued'");
+    });
+
+    it("should include closing quote in replacement range when auto-paired", () => {
+      // Simulate cursor between auto-paired quotes: status = '|'
+      const doc = "SELECT * FROM runs WHERE status = ''";
+      const pos = doc.length - 1; // Cursor is between the quotes
+      const context = createMockContext(doc, pos, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+      // The 'to' should extend past the cursor to include the closing quote
+      expect(result?.to).toBe(pos + 1);
+    });
+
+    it("should not extend 'to' when no closing quote present", () => {
+      const doc = "SELECT * FROM runs WHERE status = '";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+      // 'to' should be undefined (or not set) since there's no closing quote
+      expect(result?.to).toBeUndefined();
+    });
+
+    it("should not suggest enum values for columns without allowedValues", () => {
+      const doc = "SELECT * FROM runs WHERE id = ";
+      const context = createMockContext(doc, doc.length, true);
+      const result = completionSource(context);
+
+      expect(result).not.toBeNull();
+
+      // Should return empty options for value context with non-enum column
+      const labels = result?.options.map((o) => o.label) || [];
+      expect(labels).not.toContain("'Completed'");
+      expect(labels.length).toBe(0);
+    });
+  });
+});
+
diff --git a/apps/webapp/test/components/code/tsql/tsqlLinter.test.ts b/apps/webapp/test/components/code/tsql/tsqlLinter.test.ts
new file mode 100644
index 00000000000..a669c1209df
--- /dev/null
+++ b/apps/webapp/test/components/code/tsql/tsqlLinter.test.ts
@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { isValidTSQLQuery, getTSQLError } from "~/components/code/tsql/tsqlLinter";
+
+describe("tsqlLinter", () => {
+  describe("isValidTSQLQuery", () => {
+    it("should return true for empty queries", () => {
+      expect(isValidTSQLQuery("")).toBe(true);
+      expect(isValidTSQLQuery("   ")).toBe(true);
+    });
+
+    it("should return true for valid SELECT queries", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users")).toBe(true);
+      expect(isValidTSQLQuery("SELECT id, name FROM users WHERE status = 'active'")).toBe(true);
+      expect(isValidTSQLQuery("SELECT count(*) FROM users GROUP BY status")).toBe(true);
+    });
+
+    it("should return true for queries with ORDER BY", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users ORDER BY created_at DESC")).toBe(true);
+    });
+
+    it("should return true for queries with LIMIT", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10")).toBe(true);
+      expect(isValidTSQLQuery("SELECT * FROM users LIMIT 10 OFFSET 20")).toBe(true);
+    });
+
+    it("should return true for queries with JOINs", () => {
+      expect(isValidTSQLQuery("SELECT * FROM users JOIN orders ON users.id = orders.user_id")).toBe(
+        true
+      );
+      expect(
+        isValidTSQLQuery(
+          "SELECT * FROM users LEFT JOIN orders ON users.id = orders.user_id"
+        )
+      ).toBe(true);
+    });
+
+    it("should return false for invalid syntax", () => {
+      expect(isValidTSQLQuery("SELEC * FROM users")).toBe(false);
+      expect(isValidTSQLQuery("SELECT * FORM users")).toBe(false);
+      expect(isValidTSQLQuery("SELECT FROM users")).toBe(false);
+    });
+
+    it("should return false for incomplete queries", () => {
+      expect(isValidTSQLQuery("SELECT * FROM")).toBe(false);
+      expect(isValidTSQLQuery("SELECT")).toBe(false);
+    });
+  });
+
+  describe("getTSQLError", () => {
+    it("should return null for empty queries", () => {
+      expect(getTSQLError("")).toBeNull();
+      expect(getTSQLError("   ")).toBeNull();
+    });
+
+    it("should return null for valid queries", () => {
+      expect(getTSQLError("SELECT * FROM users")).toBeNull();
+      expect(getTSQLError("SELECT id, name FROM users WHERE id = 1")).toBeNull();
+    });
+
+    it("should return error message for invalid queries", () => {
+      const error = getTSQLError("SELEC * FROM users");
+      expect(error).not.toBeNull();
+      expect(typeof error).toBe("string");
+    });
+
+    it("should include position information in error", () => {
+      const error = getTSQLError("SELECT * FORM users");
+      expect(error).not.toBeNull();
+      // Error message should contain line/column info
+      expect(error).toContain("line");
+    });
+
+    it("should handle unclosed string literals", () => {
+      const error = getTSQLError("SELECT * FROM users WHERE name = 'test");
+      expect(error).not.toBeNull();
+    });
+  });
+});
+
diff --git a/apps/webapp/test/concurrentFlushScheduler.test.ts b/apps/webapp/test/concurrentFlushScheduler.test.ts
new file mode 100644
index 00000000000..9ab7954033e
--- /dev/null
+++ b/apps/webapp/test/concurrentFlushScheduler.test.ts
@@ -0,0 +1,161 @@
+import { ConcurrentFlushScheduler } from "~/services/runsReplicationService.server";
+
+vi.setConfig({ testTimeout: 10_000 });
+
+type TestItem = {
+  id: string;
+  event: "insert" | "update";
+  version: number;
+};
+
+describe("ConcurrentFlushScheduler", () => {
+  it("should deduplicate items by key, keeping the latest version", async () => {
+    const flushedBatches: TestItem[][] = [];
+
+    const scheduler = new ConcurrentFlushScheduler<TestItem>({
+      batchSize: 100,
+      flushInterval: 50,
+      maxConcurrency: 1,
+      callback: async (_flushId, batch) => {
+        flushedBatches.push([...batch]);
+      },
+      getKey: (item) => `${item.event}_${item.id}`,
+      shouldReplace: (existing, incoming) => incoming.version >= existing.version,
+    });
+
+    scheduler.start();
+
+    // Add items with duplicate keys but different versions
+    scheduler.addToBatch([
+      { id: "run_1", event: "insert", version: 1 },
+      { id: "run_1", event: "update", version: 2 },
+      { id: "run_2", event: "insert", version: 1 },
+    ]);
+
+    // Add more items - should merge with existing
+    scheduler.addToBatch([
+      { id: "run_1", event: "insert", version: 3 }, // Higher version, should replace
+      { id: "run_1", event: "update", version: 1 }, // Lower version, should NOT replace
+      { id: "run_2", event: "update", version: 4 },
+    ]);
+
+    // Wait for flush
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    scheduler.shutdown();
+
+    // Should have flushed once with deduplicated items
+    expect(flushedBatches.length).toBeGreaterThanOrEqual(1);
+
+    const allFlushed = flushedBatches.flat();
+
+    // Find items by their key
+    const insertRun1 = allFlushed.find((i) => i.id === "run_1" && i.event === "insert");
+    const updateRun1 = allFlushed.find((i) => i.id === "run_1" && i.event === "update");
+    const insertRun2 = allFlushed.find((i) => i.id === "run_2" && i.event === "insert");
+    const updateRun2 = allFlushed.find((i) => i.id === "run_2" && i.event === "update");
+
+    // Verify correct versions were kept
+    expect(insertRun1?.version).toBe(3); // Latest version for insert_run_1
+    expect(updateRun1?.version).toBe(2); // Original update_run_1 (v1 didn't replace v2)
+    expect(insertRun2?.version).toBe(1); // Only version for insert_run_2
+    expect(updateRun2?.version).toBe(4); // Only version for update_run_2
+  });
+
+  it("should skip items where getKey returns null", async () => {
+    const flushedBatches: TestItem[][] = [];
+
+    const scheduler = new ConcurrentFlushScheduler<TestItem>({
+      batchSize: 100,
+      flushInterval: 50,
+      maxConcurrency: 1,
+      callback: async (_flushId, batch) => {
+        flushedBatches.push([...batch]);
+      },
+      getKey: (item) => {
+        if (!item.id) {
+          return null;
+        }
+        return `${item.event}_${item.id}`;
+      },
+      shouldReplace: (existing, incoming) => incoming.version >= existing.version,
+    });
+
+    scheduler.start();
+
+    scheduler.addToBatch([
+      { id: "run_1", event: "insert", version: 1 },
+      { id: "", event: "insert", version: 2 }, // Should be skipped (null key)
+      { id: "run_2", event: "insert", version: 1 },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    scheduler.shutdown();
+
+    const allFlushed = flushedBatches.flat();
+    expect(allFlushed).toHaveLength(2);
+    expect(allFlushed.map((i) => i.id).sort()).toEqual(["run_1", "run_2"]);
+  });
+
+  it("should flush when batch size threshold is reached", async () => {
+    const flushedBatches: TestItem[][] = [];
+
+    const scheduler = new ConcurrentFlushScheduler<TestItem>({
+      batchSize: 3,
+      flushInterval: 10000, // Long interval so timer doesn't trigger
+      maxConcurrency: 1,
+      callback: async (_flushId, batch) => {
+        flushedBatches.push([...batch]);
+      },
+      getKey: (item) => `${item.event}_${item.id}`,
+      shouldReplace: (existing, incoming) => incoming.version >= existing.version,
+    });
+
+    scheduler.start();
+
+    // Add 3 unique items - should trigger flush
+    scheduler.addToBatch([
+      { id: "run_1", event: "insert", version: 1 },
+      { id: "run_2", event: "insert", version: 1 },
+      { id: "run_3", event: "insert", version: 1 },
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(flushedBatches.length).toBe(1);
+    expect(flushedBatches[0]).toHaveLength(3);
+
+    scheduler.shutdown();
+  });
+
+  it("should respect shouldReplace returning false", async () => {
+    const flushedBatches: TestItem[][] = [];
+
+    const scheduler = new ConcurrentFlushScheduler<TestItem>({
+      batchSize: 100,
+      flushInterval: 50,
+      maxConcurrency: 1,
+      callback: async (_flushId, batch) => {
+        flushedBatches.push([...batch]);
+      },
+      getKey: (item) => `${item.event}_${item.id}`,
+      // Never replace - first item wins
+      shouldReplace: () => false,
+    });
+
+    scheduler.start();
+
+    scheduler.addToBatch([{ id: "run_1", event: "insert", version: 10 }]);
+
+    scheduler.addToBatch([{ id: "run_1", event: "insert", version: 999 }]);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    scheduler.shutdown();
+
+    const allFlushed = flushedBatches.flat();
+    const insertRun1 = allFlushed.find((i) => i.id === "run_1" && i.event === "insert");
+    expect(insertRun1?.version).toBe(10); // First one wins
+  });
+});
diff --git a/apps/webapp/test/engine/batchPayloads.test.ts b/apps/webapp/test/engine/batchPayloads.test.ts
new file mode 100644
index 00000000000..69ef6224e74
--- /dev/null
+++ b/apps/webapp/test/engine/batchPayloads.test.ts
@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// --- Module mocks (must come before imports) ---
+
+vi.mock("~/v3/objectStore.server", () => ({
+  hasObjectStoreClient: vi.fn().mockReturnValue(true),
+  uploadPacketToObjectStore: vi.fn(),
+}));
+
+// Threshold of 10 bytes so any non-trivial payload triggers offloading
+vi.mock("~/env.server", () => ({
+  env: {
+    BATCH_PAYLOAD_OFFLOAD_THRESHOLD: 10,
+    TASK_PAYLOAD_OFFLOAD_THRESHOLD: 10,
+    OBJECT_STORE_DEFAULT_PROTOCOL: undefined,
+  },
+}));
+
+// Execute the span callback synchronously without real OTel
+vi.mock("~/v3/tracer.server", () => ({
+  startActiveSpan: vi.fn(async (_name: string, fn: (span: any) => any) =>
+    fn({ setAttribute: vi.fn() })
+  ),
+}));
+
+import { BatchPayloadProcessor } from "../../app/runEngine/concerns/batchPayloads.server";
+import * as objectStore from "~/v3/objectStore.server";
+
+vi.setConfig({ testTimeout: 30_000 });
+
+// Minimal AuthenticatedEnvironment shape required by BatchPayloadProcessor
+const mockEnvironment = {
+  id: "env-test",
+  slug: "production",
+  project: { externalRef: "proj-ext-ref" },
+} as any;
+
+describe("BatchPayloadProcessor", () => {
+  let mockUpload: ReturnType<typeof vi.mocked<typeof objectStore.uploadPacketToObjectStore>>;
+
+  beforeEach(() => {
+    mockUpload = vi.mocked(objectStore.uploadPacketToObjectStore);
+    mockUpload.mockReset();
+  });
+
+  it("offloads a large payload successfully on first attempt", async () => {
+    mockUpload.mockResolvedValueOnce("batch_abc/item_0/payload.json");
+
+    const processor = new BatchPayloadProcessor();
+    const result = await processor.process(
+      '{"message":"hello world"}',
+      "application/json",
+      "batch-internal-abc",
+      0,
+      mockEnvironment
+    );
+
+    expect(result.wasOffloaded).toBe(true);
+    expect(result.payloadType).toBe("application/store");
+    expect(result.payload).toBe("batch_abc/item_0/payload.json");
+    expect(mockUpload).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries on transient fetch failure and succeeds on third attempt", async () => {
+    mockUpload
+      .mockRejectedValueOnce(new Error("fetch failed"))
+      .mockRejectedValueOnce(new Error("fetch failed"))
+      .mockResolvedValueOnce("batch_abc/item_0/payload.json");
+
+    const processor = new BatchPayloadProcessor();
+    const result = await processor.process(
+      '{"message":"hello world"}',
+      "application/json",
+      "batch-internal-abc",
+      0,
+      mockEnvironment
+    );
+
+    expect(result.wasOffloaded).toBe(true);
+    expect(mockUpload).toHaveBeenCalledTimes(3);
+  });
+
+  it("throws after exhausting all retry attempts", async () => {
+    mockUpload.mockRejectedValue(new Error("fetch failed"));
+
+    const processor = new BatchPayloadProcessor();
+
+    await expect(
+      processor.process(
+        '{"message":"hello world"}',
+        "application/json",
+        "batch-internal-abc",
+        0,
+        mockEnvironment
+      )
+    ).rejects.toThrow("Failed to upload large payload to object store: fetch failed");
+
+    // 1 initial attempt + 3 retries = 4 total calls
+    expect(mockUpload).toHaveBeenCalledTimes(4);
+  });
+
+  it("does not offload when there is no payload data", async () => {
+    const processor = new BatchPayloadProcessor();
+    const result = await processor.process(
+      undefined,
+      "application/json",
+      "batch-internal-abc",
+      0,
+      mockEnvironment
+    );
+
+    expect(result.wasOffloaded).toBe(false);
+    expect(mockUpload).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/webapp/test/engine/streamBatchItems.test.ts b/apps/webapp/test/engine/streamBatchItems.test.ts
index 9e3b3aafe8b..2dee8668762 100644
--- a/apps/webapp/test/engine/streamBatchItems.test.ts
+++ b/apps/webapp/test/engine/streamBatchItems.test.ts
@@ -24,6 +24,8 @@ import {
   StreamBatchItemsService,
   createNdjsonParserStream,
   streamToAsyncIterable,
+  extractIndexAndTask,
+  type OversizedItemMarker,
 } from "../../app/runEngine/services/streamBatchItems.server";
 import { ServiceValidationError } from "../../app/v3/services/baseService.server";
 
@@ -641,6 +643,25 @@ describe("createNdjsonParserStream", () => {
     expect(results).toEqual([{ id: 1 }, { id: 2 }]);
   });
 
+  it("should handle escaped newlines in JSON string values", async () => {
+    // JSON.stringify escapes newlines as \n (two chars: backslash + n),
+    // so they don't break NDJSON line boundaries. This is the normal case
+    // when the SDK serializes payloads containing newlines.
+    const item1 = JSON.stringify({ payload: "line1\nline2\nline3" });
+    const item2 = JSON.stringify({ payload: "no newlines" });
+    const ndjson = item1 + "\n" + item2 + "\n";
+    const encoder = new TextEncoder();
+    const stream = chunksToStream([encoder.encode(ndjson)]);
+
+    const parser = createNdjsonParserStream(1024);
+    const results = await collectStream(stream.pipeThrough(parser));
+
+    expect(results).toEqual([
+      { payload: "line1\nline2\nline3" },
+      { payload: "no newlines" },
+    ]);
+  });
+
   it("should skip empty lines", async () => {
     const ndjson = '{"a":1}\n\n{"b":2}\n   \n{"c":3}\n';
     const encoder = new TextEncoder();
@@ -705,33 +726,76 @@ describe("createNdjsonParserStream", () => {
     expect(results).toEqual([{ greeting: "こんにちは" }]);
   });
 
-  it("should reject lines exceeding maxItemBytes", async () => {
+  it("should emit OversizedItemMarker for lines exceeding maxItemBytes", async () => {
     const maxBytes = 50;
-    // Create a line that exceeds the limit
-    const largeJson = JSON.stringify({ data: "x".repeat(100) }) + "\n";
+    // Create a line that exceeds the limit with index and task fields
+    const largeJson = JSON.stringify({ index: 3, task: "my-task", data: "x".repeat(100) }) + "\n";
     const encoder = new TextEncoder();
     const stream = chunksToStream([encoder.encode(largeJson)]);
 
     const parser = createNdjsonParserStream(maxBytes);
+    const results = await collectStream(stream.pipeThrough(parser));
 
-    await expect(collectStream(stream.pipeThrough(parser))).rejects.toThrow(/exceeds maximum size/);
+    expect(results).toHaveLength(1);
+    const marker = results[0] as OversizedItemMarker;
+    expect(marker.__batchItemError).toBe("OVERSIZED");
+    expect(marker.index).toBe(3);
+    expect(marker.task).toBe("my-task");
+    expect(marker.maxSize).toBe(maxBytes);
+    expect(marker.actualSize).toBeGreaterThan(maxBytes);
   });
 
-  it("should reject unbounded accumulation without newlines", async () => {
+  it("should emit OversizedItemMarker for unbounded accumulation without newlines", async () => {
     const maxBytes = 50;
     // Send data without any newlines that exceeds the buffer limit
     const encoder = new TextEncoder();
     const chunks = [
-      encoder.encode('{"start":"'),
+      encoder.encode('{"index":7,"task":"big-task","start":"'),
       encoder.encode("x".repeat(60)), // This will push buffer over 50 bytes
     ];
     const stream = chunksToStream(chunks);
 
     const parser = createNdjsonParserStream(maxBytes);
+    const results = await collectStream(stream.pipeThrough(parser));
 
-    await expect(collectStream(stream.pipeThrough(parser))).rejects.toThrow(
-      /exceeds maximum size.*no newline found/
-    );
+    expect(results).toHaveLength(1);
+    const marker = results[0] as OversizedItemMarker;
+    expect(marker.__batchItemError).toBe("OVERSIZED");
+    expect(marker.index).toBe(7);
+    expect(marker.task).toBe("big-task");
+    expect(marker.maxSize).toBe(maxBytes);
+  });
+
+  it("should skip remaining bytes of oversized line arriving in subsequent chunks", async () => {
+    const maxBytes = 50;
+    const encoder = new TextEncoder();
+    // Simulate a normal item, then an oversized item split across many chunks,
+    // then another normal item after the newline.
+    // The oversized line is: {"index":1,"task":"t","data":"xxxx...120 x's...xxxx"}\n
+    const normalItem1 = '{"index":0,"task":"t","x":1}\n';
+    const oversizedStart = '{"index":1,"task":"t","data":"';
+    const oversizedMiddle = "x".repeat(120); // way over 50 bytes
+    const oversizedEnd = '"}\n';
+    const normalItem2 = '{"index":2,"task":"t","x":2}\n';
+
+    // Send as separate chunks to trigger Case 2 (no newline, buffer > limit)
+    const chunks = [
+      encoder.encode(normalItem1 + oversizedStart),
+      encoder.encode(oversizedMiddle.slice(0, 60)),
+      encoder.encode(oversizedMiddle.slice(60)),
+      encoder.encode(oversizedEnd + normalItem2),
+    ];
+    const stream = chunksToStream(chunks);
+
+    const parser = createNdjsonParserStream(maxBytes);
+    const results = await collectStream(stream.pipeThrough(parser));
+
+    // Should get: normal item 1, oversized marker, normal item 2
+    expect(results).toHaveLength(3);
+    expect(results[0]).toEqual({ index: 0, task: "t", x: 1 });
+    expect((results[1] as OversizedItemMarker).__batchItemError).toBe("OVERSIZED");
+    expect((results[1] as OversizedItemMarker).index).toBe(1);
+    expect(results[2]).toEqual({ index: 2, task: "t", x: 2 });
   });
 
   it("should check byte size before decoding to prevent OOM", async () => {
@@ -756,10 +820,12 @@ describe("createNdjsonParserStream", () => {
     const results1 = await collectStream(stream1.pipeThrough(parser1));
     expect(results1).toHaveLength(1);
 
-    // Large one should fail
+    // Large one should emit an OversizedItemMarker
     const stream2 = chunksToStream([largeBytes]);
     const parser2 = createNdjsonParserStream(maxBytes);
-    await expect(collectStream(stream2.pipeThrough(parser2))).rejects.toThrow(/exceeds maximum/);
+    const results2 = await collectStream(stream2.pipeThrough(parser2));
+    expect(results2).toHaveLength(1);
+    expect((results2[0] as OversizedItemMarker).__batchItemError).toBe("OVERSIZED");
   });
 
   it("should handle final line in flush without trailing newline", async () => {
@@ -837,6 +903,28 @@ describe("createNdjsonParserStream", () => {
     expect(results).toEqual([]);
   });
 
+  it("should pass normal items and emit markers for oversized items in the same stream", async () => {
+    const maxBytes = 50;
+    const encoder = new TextEncoder();
+    // Normal item, then oversized item, then another normal item
+    const normalItem1 = '{"index":0,"task":"t","x":1}\n';
+    const oversizedItem = JSON.stringify({ index: 1, task: "t", data: "x".repeat(100) }) + "\n";
+    const normalItem2 = '{"index":2,"task":"t","x":2}\n';
+    const stream = chunksToStream([encoder.encode(normalItem1 + oversizedItem + normalItem2)]);
+
+    const parser = createNdjsonParserStream(maxBytes);
+    const results = await collectStream(stream.pipeThrough(parser));
+
+    expect(results).toHaveLength(3);
+    // First: normal parsed object
+    expect(results[0]).toEqual({ index: 0, task: "t", x: 1 });
+    // Second: oversized marker
+    expect((results[1] as OversizedItemMarker).__batchItemError).toBe("OVERSIZED");
+    expect((results[1] as OversizedItemMarker).index).toBe(1);
+    // Third: normal parsed object
+    expect(results[2]).toEqual({ index: 2, task: "t", x: 2 });
+  });
+
   it("should handle stream with only whitespace", async () => {
     const encoder = new TextEncoder();
     const stream = chunksToStream([encoder.encode("   \n\n   \n")]);
@@ -847,3 +935,34 @@ describe("createNdjsonParserStream", () => {
     expect(results).toEqual([]);
   });
 });
+
+describe("extractIndexAndTask", () => {
+  const encoder = new TextEncoder();
+
+  it("should extract index and task from JSON bytes", () => {
+    const bytes = encoder.encode('{"index":42,"task":"my-task","data":"x"}');
+    const result = extractIndexAndTask(bytes);
+    expect(result.index).toBe(42);
+    expect(result.task).toBe("my-task");
+  });
+
+  it("should return defaults for empty or malformed bytes", () => {
+    const result = extractIndexAndTask(new Uint8Array(0));
+    expect(result.index).toBe(-1);
+    expect(result.task).toBe("unknown");
+  });
+
+  it("should handle keys in any order", () => {
+    const bytes = encoder.encode('{"task":"other-task","data":"y","index":99}');
+    const result = extractIndexAndTask(bytes);
+    expect(result.index).toBe(99);
+    expect(result.task).toBe("other-task");
+  });
+
+  it("should not match nested keys", () => {
+    const bytes = encoder.encode('{"nested":{"index":999,"task":"inner"},"index":5,"task":"outer"}');
+    const result = extractIndexAndTask(bytes);
+    expect(result.index).toBe(5);
+    expect(result.task).toBe("outer");
+  });
+});
diff --git a/apps/webapp/test/engine/triggerTask.test.ts b/apps/webapp/test/engine/triggerTask.test.ts
index 0306c6f235a..ddceb8754c1 100644
--- a/apps/webapp/test/engine/triggerTask.test.ts
+++ b/apps/webapp/test/engine/triggerTask.test.ts
@@ -40,7 +40,7 @@ import { RunEngineTriggerTaskService } from "../../app/runEngine/services/trigge
 import { promiseWithResolvers } from "@trigger.dev/core";
 import { setTimeout } from "node:timers/promises";
 
-vi.setConfig({ testTimeout: 30_000 }); // 30 seconds timeout
+vi.setConfig({ testTimeout: 60_000 }); // 60 seconds timeout
 
 class MockPayloadProcessor implements PayloadProcessor {
   async process(request: TriggerTaskRequest): Promise<IOPacket> {
@@ -78,9 +78,9 @@ class MockTraceEventConcern implements TraceEventConcern {
         spanId: "test",
         traceContext: {},
         traceparent: undefined,
-        setAttribute: () => {},
-        failWithError: () => {},
-        stop: () => {},
+        setAttribute: () => { },
+        failWithError: () => { },
+        stop: () => { },
       },
       "test"
     );
@@ -103,9 +103,9 @@ class MockTraceEventConcern implements TraceEventConcern {
         spanId: "test",
         traceContext: {},
         traceparent: undefined,
-        setAttribute: () => {},
-        failWithError: () => {},
-        stop: () => {},
+        setAttribute: () => { },
+        failWithError: () => { },
+        stop: () => { },
       },
       "test"
     );
@@ -128,9 +128,9 @@ class MockTraceEventConcern implements TraceEventConcern {
         spanId: "test",
         traceContext: {},
         traceparent: undefined,
-        setAttribute: () => {},
-        failWithError: () => {},
-        stop: () => {},
+        setAttribute: () => { },
+        failWithError: () => { },
+        stop: () => { },
       },
       "test"
     );
diff --git a/apps/webapp/test/errorFingerprinting.test.ts b/apps/webapp/test/errorFingerprinting.test.ts
new file mode 100644
index 00000000000..4d68fd87e85
--- /dev/null
+++ b/apps/webapp/test/errorFingerprinting.test.ts
@@ -0,0 +1,410 @@
+import { describe, it, expect } from "vitest";
+import {
+  calculateErrorFingerprint,
+  normalizeErrorMessage,
+  normalizeStackTrace,
+} from "~/utils/errorFingerprinting";
+
+describe("normalizeErrorMessage", () => {
+  it("should normalize UUIDs", () => {
+    const message = "Error processing user 550e8400-e29b-41d4-a716-446655440000";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Error processing user <uuid>");
+  });
+
+  it("should normalize run IDs", () => {
+    const message = "Failed to execute run_abcd1234xyz";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Failed to execute <run-id>");
+  });
+
+  it("should normalize task friendly IDs", () => {
+    const message = "Task task_abc12345678 failed";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Task <id> failed");
+  });
+
+  it("should normalize numeric IDs (4+ digits)", () => {
+    const message = "User 12345 not found";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("User <id> not found");
+  });
+
+  it("should not normalize short numbers", () => {
+    const message = "Retry attempt 3 of 5";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Retry attempt 3 of 5");
+  });
+
+  it("should normalize ISO 8601 timestamps", () => {
+    const message = "Event at 2024-03-01T15:30:45Z failed";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Event at <timestamp> failed");
+  });
+
+  it("should normalize ISO timestamps with milliseconds", () => {
+    const message = "Timeout at 2024-03-01T15:30:45.123Z";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Timeout at <timestamp>");
+  });
+
+  it("should normalize Unix timestamps", () => {
+    const message = "Created at 1234567890";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Created at <timestamp>");
+  });
+
+  it("should normalize Unix timestamps (milliseconds)", () => {
+    const message = "Created at 1234567890123";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Created at <timestamp>");
+  });
+
+  it("should normalize Unix file paths", () => {
+    const message = "Cannot read /home/user/project/file.ts";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Cannot read <path>");
+  });
+
+  it("should normalize Windows file paths", () => {
+    const message = "Cannot read C:\\Users\\John\\project\\file.ts";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Cannot read <path>");
+  });
+
+  it("should normalize email addresses", () => {
+    const message = "Email user@example.com already exists";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Email <email> already exists");
+  });
+
+  it("should normalize URLs", () => {
+    const message = "Failed to fetch https://api.example.com/users/123";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Failed to fetch <url>");
+  });
+
+  it("should normalize HTTP URLs", () => {
+    const message = "Request to http://localhost:3000/api failed";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Request to <url> failed");
+  });
+
+  it("should normalize memory addresses", () => {
+    const message = "Segfault at 0x7fff5fbffab0";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Segfault at <addr>");
+  });
+
+  it("should normalize long quoted strings", () => {
+    const message = 'Error: "this is a very long error message with dynamic content that changes"';
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe('Error: "<string>"');
+  });
+
+  it("should handle multiple replacements", () => {
+    const message =
+      "User 12345 at user@example.com failed to access run_abc123 at 2024-03-01T15:30:45Z";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("User <id> at <email> failed to access <run-id> at <timestamp>");
+  });
+
+  it("should return empty string for empty input", () => {
+    expect(normalizeErrorMessage("")).toBe("");
+  });
+
+  it("should handle messages with no dynamic content", () => {
+    const message = "Connection timeout";
+    const normalized = normalizeErrorMessage(message);
+    expect(normalized).toBe("Connection timeout");
+  });
+
+  describe("ordering: specific patterns before generic ones", () => {
+    it("ISO timestamp year should not be consumed by numeric ID regex", () => {
+      const message = "Deadline was 2025-12-31T23:59:59Z";
+      expect(normalizeErrorMessage(message)).toBe("Deadline was <timestamp>");
+    });
+
+    it("ISO timestamp without trailing Z should normalize correctly", () => {
+      const message = "Started at 2024-01-15T08:00:00";
+      expect(normalizeErrorMessage(message)).toBe("Started at <timestamp>");
+    });
+
+    it("Unix timestamp (10 digits) should not become <id>", () => {
+      const message = "Token expires 1700000000";
+      expect(normalizeErrorMessage(message)).toBe("Token expires <timestamp>");
+    });
+
+    it("Unix timestamp (13 digits) should not become <id>", () => {
+      const message = "Sent at 1700000000000";
+      expect(normalizeErrorMessage(message)).toBe("Sent at <timestamp>");
+    });
+
+    it("URL path should not be stripped before URL regex runs", () => {
+      const message = "Webhook failed for https://hooks.example.com/webhook/abc";
+      expect(normalizeErrorMessage(message)).toBe("Webhook failed for <url>");
+    });
+
+    it("URL with port and path should normalize to <url>", () => {
+      const message = "Cannot reach http://localhost:8080/health/ready";
+      expect(normalizeErrorMessage(message)).toBe("Cannot reach <url>");
+    });
+
+    it("URL with query string should normalize to <url>", () => {
+      const message = "GET https://api.example.com/v2/users?page=1&limit=50 returned 500";
+      expect(normalizeErrorMessage(message)).toBe("GET <url> returned 500");
+    });
+
+    it("message with both a URL and a timestamp", () => {
+      const message =
+        "Request to https://api.example.com/data failed at 2025-06-15T10:30:00Z";
+      expect(normalizeErrorMessage(message)).toBe(
+        "Request to <url> failed at <timestamp>"
+      );
+    });
+
+    it("message with a URL and a unix timestamp", () => {
+      const message = "Callback to https://example.com/hook timed out after 1700000000";
+      expect(normalizeErrorMessage(message)).toBe(
+        "Callback to <url> timed out after <timestamp>"
+      );
+    });
+
+    it("path-like string that is NOT a URL should still become <path>", () => {
+      const message = "Cannot read /var/log/app/error.log";
+      expect(normalizeErrorMessage(message)).toBe("Cannot read <path>");
+    });
+  });
+
+  describe("fingerprint stability: same error class groups together despite dynamic values", () => {
+    it("errors differing only in ISO timestamp should share a fingerprint", () => {
+      const e1 = { type: "TimeoutError", message: "Timed out at 2025-01-01T00:00:00Z" };
+      const e2 = { type: "TimeoutError", message: "Timed out at 2026-06-15T12:30:00Z" };
+      expect(calculateErrorFingerprint(e1)).toBe(calculateErrorFingerprint(e2));
+    });
+
+    it("errors differing only in URL path should share a fingerprint", () => {
+      const e1 = {
+        type: "FetchError",
+        message: "Failed to fetch https://api.example.com/users/123",
+      };
+      const e2 = {
+        type: "FetchError",
+        message: "Failed to fetch https://api.example.com/orders/456",
+      };
+      expect(calculateErrorFingerprint(e1)).toBe(calculateErrorFingerprint(e2));
+    });
+
+    it("errors differing only in unix timestamp should share a fingerprint", () => {
+      const e1 = { type: "ExpiredError", message: "Token expired at 1700000000" };
+      const e2 = { type: "ExpiredError", message: "Token expired at 1800000000" };
+      expect(calculateErrorFingerprint(e1)).toBe(calculateErrorFingerprint(e2));
+    });
+  });
+});
+
+describe("normalizeStackTrace", () => {
+  it("should normalize line and column numbers", () => {
+    const stack = `Error: Test error
+    at functionName (file.ts:123:45)
+    at anotherFunction (other.ts:67:89)`;
+    const normalized = normalizeStackTrace(stack);
+    expect(normalized).toContain(":_:_");
+    expect(normalized).not.toContain(":123:45");
+  });
+
+  it("should remove standalone numbers", () => {
+    const stack = `Error: Test
+    at Object.<anonymous> (/path/to/file.ts:123:45)
+    at Module._compile (node:internal/modules/cjs/loader:456:78)`;
+    const normalized = normalizeStackTrace(stack);
+    expect(normalized).not.toMatch(/\b\d+\b/);
+  });
+
+  it("should keep only first 5 frames", () => {
+    const stack = `Error: Test
+    at frame1 (file1.ts:1:1)
+    at frame2 (file2.ts:2:2)
+    at frame3 (file3.ts:3:3)
+    at frame4 (file4.ts:4:4)
+    at frame5 (file5.ts:5:5)
+    at frame6 (file6.ts:6:6)
+    at frame7 (file7.ts:7:7)`;
+    const normalized = normalizeStackTrace(stack);
+    const frames = normalized.split("|");
+    expect(frames.length).toBeLessThanOrEqual(5);
+  });
+
+  it("should remove file paths but keep filenames", () => {
+    const stack = `Error: Test
+    at functionName (/home/user/project/src/file.ts:123:45)`;
+    const normalized = normalizeStackTrace(stack);
+    expect(normalized).toContain("file.ts");
+    expect(normalized).not.toContain("/home/user/project/src/");
+  });
+
+  it("should filter out empty lines", () => {
+    const stack = `Error: Test
+
+    at functionName (file.ts:123:45)
+
+    at anotherFunction (other.ts:67:89)`;
+    const normalized = normalizeStackTrace(stack);
+    const frames = normalized.split("|").filter((f) => f.length > 0);
+    expect(frames.length).toBeLessThanOrEqual(3);
+  });
+
+  it("should return empty string for empty stack", () => {
+    expect(normalizeStackTrace("")).toBe("");
+  });
+
+  it("should join frames with pipe delimiter", () => {
+    const stack = `Error: Test
+    at frame1 (file1.ts:1:1)
+    at frame2 (file2.ts:2:2)`;
+    const normalized = normalizeStackTrace(stack);
+    expect(normalized).toContain("|");
+  });
+});
+
+describe("calculateErrorFingerprint", () => {
+  it("should generate consistent fingerprints for same error", () => {
+    const error = {
+      type: "DatabaseError",
+      message: "Connection timeout",
+      stack: "at db.connect (db.ts:123:45)",
+    };
+    const fp1 = calculateErrorFingerprint(error);
+    const fp2 = calculateErrorFingerprint(error);
+    expect(fp1).toBe(fp2);
+    expect(fp1.length).toBe(16);
+  });
+
+  it("should generate same fingerprint for errors with different IDs", () => {
+    const error1 = {
+      type: "NotFoundError",
+      message: "User 12345 not found",
+      stack: "at findUser (user.ts:50:10)",
+    };
+    const error2 = {
+      type: "NotFoundError",
+      message: "User 67890 not found",
+      stack: "at findUser (user.ts:50:10)",
+    };
+    const fp1 = calculateErrorFingerprint(error1);
+    const fp2 = calculateErrorFingerprint(error2);
+    expect(fp1).toBe(fp2);
+  });
+
+  it("should generate same fingerprint for errors with different UUIDs", () => {
+    const error1 = {
+      type: "ValidationError",
+      message: "Invalid token 550e8400-e29b-41d4-a716-446655440000",
+    };
+    const error2 = {
+      type: "ValidationError",
+      message: "Invalid token 123e4567-e89b-12d3-a456-426614174000",
+    };
+    expect(calculateErrorFingerprint(error1)).toBe(calculateErrorFingerprint(error2));
+  });
+
+  it("should generate same fingerprint for errors with different run IDs", () => {
+    const error1 = {
+      type: "TaskError",
+      message: "Failed to execute run_abc123",
+    };
+    const error2 = {
+      type: "TaskError",
+      message: "Failed to execute run_xyz789",
+    };
+    expect(calculateErrorFingerprint(error1)).toBe(calculateErrorFingerprint(error2));
+  });
+
+  it("should generate different fingerprints for different error types", () => {
+    const error1 = {
+      type: "DatabaseError",
+      message: "Connection failed",
+    };
+    const error2 = {
+      type: "NetworkError",
+      message: "Connection failed",
+    };
+    expect(calculateErrorFingerprint(error1)).not.toBe(calculateErrorFingerprint(error2));
+  });
+
+  it("should generate different fingerprints for different error messages", () => {
+    const error1 = {
+      type: "Error",
+      message: "Connection timeout",
+    };
+    const error2 = {
+      type: "Error",
+      message: "Connection refused",
+    };
+    expect(calculateErrorFingerprint(error1)).not.toBe(calculateErrorFingerprint(error2));
+  });
+
+  it("should handle error with name instead of type", () => {
+    const error = {
+      name: "TypeError",
+      message: "Cannot read property 'foo' of undefined",
+    };
+    const fp = calculateErrorFingerprint(error);
+    expect(fp).toBeTruthy();
+    expect(fp.length).toBe(16);
+  });
+
+  it("should handle error with stacktrace instead of stack", () => {
+    const error = {
+      type: "Error",
+      message: "Test error",
+      stacktrace: "at test (file.ts:1:1)",
+    };
+    const fp = calculateErrorFingerprint(error);
+    expect(fp).toBeTruthy();
+  });
+
+  it("should return empty string for non-object error", () => {
+    expect(calculateErrorFingerprint(null)).toBe("");
+    expect(calculateErrorFingerprint(undefined)).toBe("");
+    expect(calculateErrorFingerprint("error string")).toBe("");
+    expect(calculateErrorFingerprint(123)).toBe("");
+  });
+
+  it("should handle errors with no message or stack", () => {
+    const error = {
+      type: "Error",
+    };
+    const fp = calculateErrorFingerprint(error);
+    expect(fp).toBeTruthy();
+    expect(fp.length).toBe(16);
+  });
+
+  it("should generate fingerprints using stack trace when available", () => {
+    const error1 = {
+      type: "Error",
+      message: "Test",
+      stack: "at funcA (a.ts:1:1)\nat funcB (b.ts:2:2)",
+    };
+    const error2 = {
+      type: "Error",
+      message: "Test",
+      stack: "at funcX (x.ts:1:1)\nat funcY (y.ts:2:2)",
+    };
+    expect(calculateErrorFingerprint(error1)).not.toBe(calculateErrorFingerprint(error2));
+  });
+
+  it("should normalize line numbers in stack traces for same code location", () => {
+    const error1 = {
+      type: "Error",
+      message: "Test",
+      stack: "at func (file.ts:123:45)",
+    };
+    const error2 = {
+      type: "Error",
+      message: "Test",
+      stack: "at func (file.ts:456:78)",
+    };
+    expect(calculateErrorFingerprint(error1)).toBe(calculateErrorFingerprint(error2));
+  });
+});
diff --git a/apps/webapp/test/errorGroupWebhook.test.ts b/apps/webapp/test/errorGroupWebhook.test.ts
new file mode 100644
index 00000000000..a7e797685ae
--- /dev/null
+++ b/apps/webapp/test/errorGroupWebhook.test.ts
@@ -0,0 +1,248 @@
+import { describe, test, expect } from "vitest";
+import { Webhook } from "@trigger.dev/core/v3/schemas";
+import {
+  generateErrorGroupWebhookPayload,
+  type ErrorGroupAlertData,
+} from "~/v3/services/alerts/errorGroupWebhook.server";
+
+function createMockAlertData(overrides: Partial<ErrorGroupAlertData> = {}): ErrorGroupAlertData {
+  const now = Date.now();
+  const earlier = now - 3600000; // 1 hour ago
+
+  return {
+    classification: "new_issue",
+    error: {
+      fingerprint: "fp_test_12345",
+      environmentId: "env_abc123",
+      environmentName: "Production",
+      taskIdentifier: "process-payment",
+      errorType: "TypeError",
+      errorMessage: "Cannot read property 'id' of undefined",
+      sampleStackTrace: `TypeError: Cannot read property 'id' of undefined
+    at processPayment (src/tasks/payment.ts:42:15)
+    at Object.run (src/tasks/payment.ts:15:20)`,
+      firstSeen: String(earlier),
+      lastSeen: String(now),
+      occurrenceCount: 5,
+    },
+    organization: {
+      id: "org_xyz789",
+      slug: "acme-corp",
+      name: "Acme Corp",
+    },
+    project: {
+      id: "proj_123",
+      externalRef: "proj_abc",
+      slug: "my-project",
+      name: "My Project",
+    },
+    dashboardUrl:
+      "https://cloud.trigger.dev/orgs/acme-corp/projects/my-project/errors/fp_test_12345",
+    ...overrides,
+  };
+}
+
+describe("generateErrorGroupWebhookPayload", () => {
+  test("generates a valid webhook payload", () => {
+    const alertData = createMockAlertData();
+    const payload = generateErrorGroupWebhookPayload(alertData);
+
+    expect(payload).toMatchObject({
+      type: "alert.error",
+      object: {
+        classification: "new_issue",
+        error: {
+          fingerprint: "fp_test_12345",
+          type: "TypeError",
+          message: "Cannot read property 'id' of undefined",
+          taskIdentifier: "process-payment",
+          occurrenceCount: 5,
+        },
+        environment: {
+          id: "env_abc123",
+          name: "Production",
+        },
+        organization: {
+          id: "org_xyz789",
+          slug: "acme-corp",
+          name: "Acme Corp",
+        },
+        project: {
+          id: "proj_123",
+          ref: "proj_abc",
+          slug: "my-project",
+          name: "My Project",
+        },
+        dashboardUrl:
+          "https://cloud.trigger.dev/orgs/acme-corp/projects/my-project/errors/fp_test_12345",
+      },
+    });
+
+    expect(payload.id).toBeDefined();
+    expect(payload.created).toBeInstanceOf(Date);
+    expect(payload.webhookVersion).toBe("2025-01-01");
+  });
+
+  test("payload is valid according to Webhook schema", () => {
+    const alertData = createMockAlertData();
+    const payload = generateErrorGroupWebhookPayload(alertData);
+
+    const parsed = Webhook.parse(payload);
+    expect(parsed.type).toBe("alert.error");
+  });
+
+  test("payload can be serialized and deserialized", () => {
+    const alertData = createMockAlertData();
+    const payload = generateErrorGroupWebhookPayload(alertData);
+
+    // Serialize to JSON (simulating sending over HTTP)
+    const serialized = JSON.stringify(payload);
+    const deserialized = JSON.parse(serialized);
+
+    // Verify it can still be parsed by the schema
+    const parsed = Webhook.parse(deserialized);
+    expect(parsed.type).toBe("alert.error");
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("new_issue");
+      expect(parsed.object.error.fingerprint).toBe("fp_test_12345");
+    }
+  });
+
+  test("handles new_issue classification", () => {
+    const alertData = createMockAlertData({ classification: "new_issue" });
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("new_issue");
+    }
+  });
+
+  test("handles regression classification", () => {
+    const alertData = createMockAlertData({ classification: "regression" });
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("regression");
+    }
+  });
+
+  test("handles unignored classification", () => {
+    const alertData = createMockAlertData({ classification: "unignored" });
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("unignored");
+    }
+  });
+
+  test("handles empty stack trace", () => {
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        sampleStackTrace: "",
+      },
+    });
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.stackTrace).toBeUndefined();
+    }
+  });
+
+  test("includes stack trace when present", () => {
+    const stackTrace = "Error at line 42";
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        sampleStackTrace: stackTrace,
+      },
+    });
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.stackTrace).toBe(stackTrace);
+    }
+  });
+
+  test("preserves date fields correctly", () => {
+    const firstSeen = new Date("2024-01-01T00:00:00Z");
+    const lastSeen = new Date("2024-01-02T12:00:00Z");
+
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        firstSeen: String(firstSeen.getTime()),
+        lastSeen: String(lastSeen.getTime()),
+      },
+    });
+
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.firstSeen).toEqual(firstSeen);
+      expect(parsed.object.error.lastSeen).toEqual(lastSeen);
+    }
+  });
+
+  test("handles special characters in error messages", () => {
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        errorMessage: "Unexpected token `<` in JSON at position 0",
+        sampleStackTrace: `SyntaxError: Unexpected token \`<\` in JSON
+    at JSON.parse (<anonymous>)
+    at fetch("https://api.example.com/data?query=test&limit=10")`,
+      },
+    });
+
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const serialized = JSON.stringify(payload);
+    const deserialized = JSON.parse(serialized);
+    const parsed = Webhook.parse(deserialized);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.message).toBe("Unexpected token `<` in JSON at position 0");
+    }
+  });
+
+  test("handles unicode and emoji in error messages", () => {
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        errorMessage: "Failed to process emoji 🔥 in message: Hello 世界",
+      },
+    });
+
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const serialized = JSON.stringify(payload);
+    const deserialized = JSON.parse(serialized);
+    const parsed = Webhook.parse(deserialized);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.message).toBe("Failed to process emoji 🔥 in message: Hello 世界");
+    }
+  });
+
+  test("handles large occurrence counts", () => {
+    const alertData = createMockAlertData({
+      error: {
+        ...createMockAlertData().error,
+        occurrenceCount: 999999,
+      },
+    });
+
+    const payload = generateErrorGroupWebhookPayload(alertData);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.occurrenceCount).toBe(999999);
+    }
+  });
+});
diff --git a/apps/webapp/test/objectStore.test.ts b/apps/webapp/test/objectStore.test.ts
new file mode 100644
index 00000000000..bbd12d23124
--- /dev/null
+++ b/apps/webapp/test/objectStore.test.ts
@@ -0,0 +1,649 @@
+import { postgresAndMinioTest } from "@internal/testcontainers";
+import { type IOPacket } from "@trigger.dev/core/v3";
+import { type PrismaClient } from "@trigger.dev/database";
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { env } from "~/env.server";
+import { processWaitpointCompletionPacket } from "~/runEngine/concerns/waitpointCompletionPacket.server";
+import {
+  downloadPacketFromObjectStore,
+  formatStorageUri,
+  generatePresignedRequest,
+  generatePresignedUrl,
+  hasObjectStoreClient,
+  parseStorageUri,
+  resolveStoreProtocolForPacketPresign,
+  uploadPacketToObjectStore,
+} from "~/v3/objectStore.server";
+
+// Extend the timeout for container tests
+vi.setConfig({ testTimeout: 60_000 });
+
+// Helper to create a test environment
+async function createTestEnvironment(prisma: PrismaClient) {
+  const suffix = Date.now().toString(36);
+
+  const org = await prisma.organization.create({
+    data: {
+      title: `Test Org ${suffix}`,
+      slug: `test-org-${suffix}`,
+    },
+  });
+
+  const project = await prisma.project.create({
+    data: {
+      name: `Test Project ${suffix}`,
+      slug: `test-project-${suffix}`,
+      externalRef: `proj_test${suffix}`,
+      organizationId: org.id,
+    },
+  });
+
+  const environment = await prisma.runtimeEnvironment.create({
+    data: {
+      slug: "dev",
+      type: "DEVELOPMENT",
+      organizationId: org.id,
+      projectId: project.id,
+      apiKey: `test_key_${suffix}`,
+      pkApiKey: `test_pk_key_${suffix}`,
+      shortcode: suffix.slice(0, 4),
+    },
+    include: {
+      project: true,
+      organization: true,
+    },
+  });
+
+  return environment;
+}
+
+// Save original env values for restoration in afterAll
+const originalEnv = process.env;
+const originalEnvObj = {
+  OBJECT_STORE_BASE_URL: env.OBJECT_STORE_BASE_URL,
+  OBJECT_STORE_BUCKET: env.OBJECT_STORE_BUCKET,
+  OBJECT_STORE_ACCESS_KEY_ID: env.OBJECT_STORE_ACCESS_KEY_ID,
+  OBJECT_STORE_SECRET_ACCESS_KEY: env.OBJECT_STORE_SECRET_ACCESS_KEY,
+  OBJECT_STORE_REGION: env.OBJECT_STORE_REGION,
+  OBJECT_STORE_DEFAULT_PROTOCOL: env.OBJECT_STORE_DEFAULT_PROTOCOL,
+  TASK_PAYLOAD_OFFLOAD_THRESHOLD: env.TASK_PAYLOAD_OFFLOAD_THRESHOLD,
+};
+
+describe("Object Storage", () => {
+  describe("URI parsing functions", () => {
+    it("should parse URI with protocol", () => {
+      const result = parseStorageUri("s3://run_abc123/payload.json");
+      expect(result).toEqual({
+        protocol: "s3",
+        path: "run_abc123/payload.json",
+      });
+    });
+
+    it("should parse URI with R2 protocol", () => {
+      const result = parseStorageUri("r2://batch_xyz/item_0/payload.json");
+      expect(result).toEqual({
+        protocol: "r2",
+        path: "batch_xyz/item_0/payload.json",
+      });
+    });
+
+    it("should parse legacy URI without protocol", () => {
+      const result = parseStorageUri("run_abc123/payload.json");
+      expect(result).toEqual({
+        protocol: undefined,
+        path: "run_abc123/payload.json",
+      });
+    });
+
+    it("should format URI with protocol", () => {
+      const result = formatStorageUri("run_abc123/payload.json", "s3");
+      expect(result).toBe("s3://run_abc123/payload.json");
+    });
+
+    it("should format URI without protocol", () => {
+      const result = formatStorageUri("run_abc123/payload.json");
+      expect(result).toBe("run_abc123/payload.json");
+    });
+  });
+
+  describe("resolveStoreProtocolForPacketPresign", () => {
+    afterEach(() => {
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = originalEnvObj.OBJECT_STORE_DEFAULT_PROTOCOL;
+    });
+
+    it("GET uses legacy default for unprefixed keys even when OBJECT_STORE_DEFAULT_PROTOCOL is set", () => {
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+      expect(resolveStoreProtocolForPacketPresign("a/b.json", "GET").storeProtocol).toBeUndefined();
+    });
+
+    it("PUT without forceNoPrefix uses OBJECT_STORE_DEFAULT_PROTOCOL for unprefixed keys", () => {
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+      expect(resolveStoreProtocolForPacketPresign("a/b.json", "PUT", false).storeProtocol).toBe(
+        "s3"
+      );
+    });
+
+    it("PUT with forceNoPrefix skips OBJECT_STORE_DEFAULT_PROTOCOL for unprefixed keys", () => {
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+      expect(resolveStoreProtocolForPacketPresign("a/b.json", "PUT", true).storeProtocol).toBeUndefined();
+    });
+
+    it("explicit protocol in key wins for PUT with forceNoPrefix", () => {
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "r2";
+      expect(resolveStoreProtocolForPacketPresign("s3://x/y.json", "PUT", true).storeProtocol).toBe(
+        "s3"
+      );
+    });
+  });
+
+  postgresAndMinioTest(
+    "should upload and download data without protocol (legacy)",
+    async ({ minioConfig, prisma }) => {
+      // Override env directly for the default provider
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      const environment = await createTestEnvironment(prisma);
+
+      const testData = JSON.stringify({ test: "data", value: 123 });
+      const filename = "test_run/payload.json";
+
+      // Upload
+      const uploadedFilename = await uploadPacketToObjectStore(
+        filename,
+        testData,
+        "application/json",
+        environment as any
+      );
+
+      // Should return filename without protocol (legacy)
+      expect(uploadedFilename).toBe(filename);
+
+      // Download
+      const packet: IOPacket = {
+        data: uploadedFilename,
+        dataType: "application/store",
+      };
+
+      const downloadedPacket = await downloadPacketFromObjectStore(packet, environment as any);
+
+      expect(downloadedPacket.dataType).toBe("application/json");
+      expect(downloadedPacket.data).toBe(testData);
+
+      // Cleanup
+      await prisma.runtimeEnvironment.delete({ where: { id: environment.id } });
+      await prisma.project.delete({ where: { id: environment.projectId } });
+      await prisma.organization.delete({ where: { id: environment.organizationId } });
+    }
+  );
+
+  postgresAndMinioTest(
+    "should upload and download data with protocol prefix",
+    async ({ minioConfig, prisma }) => {
+      // Named provider — controlled via process.env (read dynamically)
+      process.env.OBJECT_STORE_S3_BASE_URL = minioConfig.baseUrl;
+      process.env.OBJECT_STORE_S3_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.OBJECT_STORE_S3_REGION = minioConfig.region;
+      process.env.OBJECT_STORE_S3_SERVICE = "s3";
+
+      const environment = await createTestEnvironment(prisma);
+
+      const testData = JSON.stringify({ test: "protocol-data", value: 456 });
+      const filename = "test_run2/payload.json";
+
+      // Upload with explicit protocol — bypasses env.OBJECT_STORE_DEFAULT_PROTOCOL
+      const uploadedFilename = await uploadPacketToObjectStore(
+        filename,
+        testData,
+        "application/json",
+        environment as any,
+        "s3"
+      );
+
+      // Should return filename with s3:// protocol
+      expect(uploadedFilename).toBe("s3://test_run2/payload.json");
+
+      // Download
+      const packet: IOPacket = {
+        data: uploadedFilename,
+        dataType: "application/store",
+      };
+
+      const downloadedPacket = await downloadPacketFromObjectStore(packet, environment as any);
+
+      expect(downloadedPacket.dataType).toBe("application/json");
+      expect(downloadedPacket.data).toBe(testData);
+
+      // Cleanup
+      await prisma.runtimeEnvironment.delete({ where: { id: environment.id } });
+      await prisma.project.delete({ where: { id: environment.projectId } });
+      await prisma.organization.delete({ where: { id: environment.organizationId } });
+    }
+  );
+
+  postgresAndMinioTest(
+    "should support migration from default provider to named provider",
+    async ({ minioConfig, prisma }) => {
+      const environment = await createTestEnvironment(prisma);
+
+      // Step 1: Upload old data without protocol (using default provider)
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      const oldData = JSON.stringify({ legacy: true });
+      const oldFilename = "old_run/payload.json";
+
+      const uploadedOldFilename = await uploadPacketToObjectStore(
+        oldFilename,
+        oldData,
+        "application/json",
+        environment as any
+      );
+
+      expect(uploadedOldFilename).toBe(oldFilename); // No protocol
+
+      // Step 2: Configure new provider (S3) and set default protocol
+      process.env.OBJECT_STORE_S3_BASE_URL = minioConfig.baseUrl; // Same MinIO for testing
+      process.env.OBJECT_STORE_S3_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.OBJECT_STORE_S3_REGION = minioConfig.region;
+      process.env.OBJECT_STORE_S3_SERVICE = "s3";
+
+      // Step 3: Upload new data with explicit protocol
+      const newData = JSON.stringify({ new: true });
+      const newFilename = "new_run/payload.json";
+
+      const uploadedNewFilename = await uploadPacketToObjectStore(
+        newFilename,
+        newData,
+        "application/json",
+        environment as any,
+        "s3"
+      );
+
+      expect(uploadedNewFilename).toBe("s3://new_run/payload.json"); // Has protocol
+
+      // Step 4: Verify both can be downloaded
+      // Old data (no protocol, uses default provider)
+      const oldPacket: IOPacket = {
+        data: uploadedOldFilename,
+        dataType: "application/store",
+      };
+      const downloadedOld = await downloadPacketFromObjectStore(oldPacket, environment as any);
+      expect(downloadedOld.data).toBe(oldData);
+
+      // New data (with protocol, uses named provider)
+      const newPacket: IOPacket = {
+        data: uploadedNewFilename,
+        dataType: "application/store",
+      };
+      const downloadedNew = await downloadPacketFromObjectStore(newPacket, environment as any);
+      expect(downloadedNew.data).toBe(newData);
+
+      // Cleanup
+      await prisma.runtimeEnvironment.delete({ where: { id: environment.id } });
+      await prisma.project.delete({ where: { id: environment.projectId } });
+      await prisma.organization.delete({ where: { id: environment.organizationId } });
+    }
+  );
+
+  postgresAndMinioTest(
+    "should upload and download using IAM credential chain (AWS SDK path)",
+    async ({ minioConfig, prisma }) => {
+      // IAM mode: override env with bucket but no access keys.
+      // We put the credentials in AWS_* env vars so the S3Client credential
+      // chain picks them up (same as it would from an ECS task role in production).
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_BUCKET = "packets";
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_ACCESS_KEY_ID = undefined;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = undefined;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      process.env.AWS_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.AWS_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.AWS_REGION = minioConfig.region;
+
+      const environment = await createTestEnvironment(prisma);
+
+      const testData = JSON.stringify({ iam: true, value: 789 });
+      const filename = "iam_test_run/payload.json";
+
+      const uploadedFilename = await uploadPacketToObjectStore(
+        filename,
+        testData,
+        "application/json",
+        environment as any
+      );
+
+      expect(uploadedFilename).toBe(filename);
+
+      const packet: IOPacket = {
+        data: uploadedFilename,
+        dataType: "application/store",
+      };
+
+      const downloadedPacket = await downloadPacketFromObjectStore(packet, environment as any);
+
+      expect(downloadedPacket.dataType).toBe("application/json");
+      expect(downloadedPacket.data).toBe(testData);
+
+      // Cleanup
+      delete process.env.AWS_ACCESS_KEY_ID;
+      delete process.env.AWS_SECRET_ACCESS_KEY;
+      delete process.env.AWS_REGION;
+
+      await prisma.runtimeEnvironment.delete({ where: { id: environment.id } });
+      await prisma.project.delete({ where: { id: environment.projectId } });
+      await prisma.organization.delete({ where: { id: environment.organizationId } });
+    }
+  );
+
+  postgresAndMinioTest(
+    "processWaitpointCompletionPacket offloads above threshold and round-trips download",
+    async ({ minioConfig, prisma }) => {
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      const savedThreshold = env.TASK_PAYLOAD_OFFLOAD_THRESHOLD;
+      env.TASK_PAYLOAD_OFFLOAD_THRESHOLD = 256;
+
+      const environment = await createTestEnvironment(prisma);
+      const pathPrefix = `waitpoint_completiontest/token`;
+
+      try {
+        const smallPacket: IOPacket = {
+          data: JSON.stringify({ ok: true }),
+          dataType: "application/json",
+        };
+        const smallResult = await processWaitpointCompletionPacket(
+          smallPacket,
+          environment as any,
+          pathPrefix
+        );
+        expect(smallResult).toEqual(smallPacket);
+
+        const largeBody = "x".repeat(400);
+        const largePacket: IOPacket = {
+          data: largeBody,
+          dataType: "text/plain",
+        };
+        const largeResult = await processWaitpointCompletionPacket(
+          largePacket,
+          environment as any,
+          pathPrefix
+        );
+
+        expect(largeResult.dataType).toBe("application/store");
+        expect(largeResult.data).toBe(`${pathPrefix}.txt`);
+
+        const downloadedPacket = await downloadPacketFromObjectStore(
+          {
+            data: largeResult.data,
+            dataType: "application/store",
+          },
+          environment as any
+        );
+
+        expect(downloadedPacket.data).toBe(largeBody);
+      } finally {
+        env.TASK_PAYLOAD_OFFLOAD_THRESHOLD = savedThreshold;
+
+        await prisma.runtimeEnvironment.delete({ where: { id: environment.id } });
+        await prisma.project.delete({ where: { id: environment.projectId } });
+        await prisma.organization.delete({ where: { id: environment.organizationId } });
+      }
+    }
+  );
+
+  describe("hasObjectStoreClient", () => {
+    it("returns false when no store is configured", () => {
+      env.OBJECT_STORE_BASE_URL = undefined;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+      delete process.env.OBJECT_STORE_NOTCONFIGURED_BASE_URL;
+      expect(hasObjectStoreClient()).toBe(false);
+    });
+
+    it("returns true when default provider base URL is set", () => {
+      env.OBJECT_STORE_BASE_URL = "http://localhost:9000";
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+      expect(hasObjectStoreClient()).toBe(true);
+      env.OBJECT_STORE_BASE_URL = undefined;
+    });
+
+    it("returns true when named protocol base URL is set", () => {
+      env.OBJECT_STORE_BASE_URL = undefined;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+      process.env.OBJECT_STORE_S3_BASE_URL = "http://localhost:9000";
+      expect(hasObjectStoreClient()).toBe(true);
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+      delete process.env.OBJECT_STORE_S3_BASE_URL;
+    });
+  });
+
+  postgresAndMinioTest(
+    "generatePresignedUrl - PUT then GET round-trip (static credentials / aws4fetch path)",
+    async ({ minioConfig }) => {
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      const projectRef = "proj_presign_test";
+      const envSlug = "dev";
+      const filename = "presigned-static/payload.json";
+      const data = JSON.stringify({ presigned: "static" });
+
+      // Upload via presigned PUT
+      const putResult = await generatePresignedUrl(projectRef, envSlug, filename, "PUT");
+      expect(putResult.success).toBe(true);
+      if (!putResult.success) throw new Error(putResult.error);
+      expect(putResult.storagePath).toBe(filename);
+
+      const putResponse = await fetch(putResult.url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: data,
+      });
+      expect(putResponse.ok).toBe(true);
+
+      // Download via presigned GET
+      const getResult = await generatePresignedUrl(projectRef, envSlug, filename, "GET");
+      expect(getResult.success).toBe(true);
+      if (!getResult.success) throw new Error(getResult.error);
+      expect(getResult.storagePath).toBeUndefined();
+
+      const getResponse = await fetch(getResult.url);
+      expect(getResponse.ok).toBe(true);
+      expect(await getResponse.text()).toBe(data);
+    }
+  );
+
+  postgresAndMinioTest(
+    "generatePresignedUrl - PUT unprefixed with OBJECT_STORE_DEFAULT_PROTOCOL returns s3 storagePath",
+    async ({ minioConfig }) => {
+      env.OBJECT_STORE_BASE_URL = undefined;
+      env.OBJECT_STORE_ACCESS_KEY_ID = undefined;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = undefined;
+      env.OBJECT_STORE_REGION = undefined;
+
+      process.env.OBJECT_STORE_S3_BASE_URL = minioConfig.baseUrl;
+      process.env.OBJECT_STORE_S3_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.OBJECT_STORE_S3_REGION = minioConfig.region;
+      process.env.OBJECT_STORE_S3_SERVICE = "s3";
+
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+
+      const projectRef = "proj_presign_v2_style";
+      const envSlug = "dev";
+      const filename = "v2-style/payload.json";
+      const data = JSON.stringify({ v2: true });
+
+      const putResult = await generatePresignedUrl(projectRef, envSlug, filename, "PUT");
+      expect(putResult.success).toBe(true);
+      if (!putResult.success) throw new Error(putResult.error);
+      expect(putResult.storagePath).toBe(`s3://${filename}`);
+
+      const putResponse = await fetch(putResult.url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: data,
+      });
+      expect(putResponse.ok).toBe(true);
+
+      const getResult = await generatePresignedUrl(projectRef, envSlug, putResult.storagePath!, "GET");
+      expect(getResult.success).toBe(true);
+      if (!getResult.success) throw new Error(getResult.error);
+
+      const getResponse = await fetch(getResult.url);
+      expect(getResponse.ok).toBe(true);
+      expect(await getResponse.text()).toBe(data);
+
+      delete process.env.OBJECT_STORE_S3_BASE_URL;
+      delete process.env.OBJECT_STORE_S3_ACCESS_KEY_ID;
+      delete process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY;
+      delete process.env.OBJECT_STORE_S3_REGION;
+      delete process.env.OBJECT_STORE_S3_SERVICE;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+    }
+  );
+
+  postgresAndMinioTest(
+    "generatePresignedUrl - forceNoPrefix PUT fails without legacy default when only S3 named",
+    async ({ minioConfig }) => {
+      env.OBJECT_STORE_BASE_URL = undefined;
+      env.OBJECT_STORE_ACCESS_KEY_ID = undefined;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = undefined;
+      env.OBJECT_STORE_REGION = undefined;
+
+      process.env.OBJECT_STORE_S3_BASE_URL = minioConfig.baseUrl;
+      process.env.OBJECT_STORE_S3_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.OBJECT_STORE_S3_REGION = minioConfig.region;
+      process.env.OBJECT_STORE_S3_SERVICE = "s3";
+
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = "s3";
+
+      const putLegacy = await generatePresignedUrl(
+        "proj_force_noprefix",
+        "dev",
+        "only-legacy/payload.json",
+        "PUT",
+        { forceNoPrefix: true }
+      );
+      expect(putLegacy.success).toBe(false);
+
+      const getUnprefixed = await generatePresignedUrl(
+        "proj_force_noprefix",
+        "dev",
+        "any.json",
+        "GET"
+      );
+      expect(getUnprefixed.success).toBe(false);
+
+      delete process.env.OBJECT_STORE_S3_BASE_URL;
+      delete process.env.OBJECT_STORE_S3_ACCESS_KEY_ID;
+      delete process.env.OBJECT_STORE_S3_SECRET_ACCESS_KEY;
+      delete process.env.OBJECT_STORE_S3_REGION;
+      delete process.env.OBJECT_STORE_S3_SERVICE;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+    }
+  );
+
+  postgresAndMinioTest(
+    "generatePresignedUrl - PUT then GET round-trip (IAM credential chain / AWS SDK path)",
+    async ({ minioConfig }) => {
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_BUCKET = "packets";
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_ACCESS_KEY_ID = undefined;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = undefined;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      process.env.AWS_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      process.env.AWS_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      process.env.AWS_REGION = minioConfig.region;
+
+      const projectRef = "proj_presign_iam";
+      const envSlug = "dev";
+      const filename = "presigned-iam/payload.json";
+      const data = JSON.stringify({ presigned: "iam" });
+
+      // Upload via presigned PUT
+      const putResult = await generatePresignedUrl(projectRef, envSlug, filename, "PUT");
+      expect(putResult.success).toBe(true);
+      if (!putResult.success) throw new Error(putResult.error);
+      expect(putResult.storagePath).toBe(filename);
+
+      const putResponse = await fetch(putResult.url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: data,
+      });
+      expect(putResponse.ok).toBe(true);
+
+      // Download via presigned GET
+      const getResult = await generatePresignedUrl(projectRef, envSlug, filename, "GET");
+      expect(getResult.success).toBe(true);
+      if (!getResult.success) throw new Error(getResult.error);
+
+      const getResponse = await fetch(getResult.url);
+      expect(getResponse.ok).toBe(true);
+      expect(await getResponse.text()).toBe(data);
+
+      delete process.env.AWS_ACCESS_KEY_ID;
+      delete process.env.AWS_SECRET_ACCESS_KEY;
+      delete process.env.AWS_REGION;
+    }
+  );
+
+  postgresAndMinioTest(
+    "generatePresignedRequest - returns a signed Request object",
+    async ({ minioConfig }) => {
+      env.OBJECT_STORE_BASE_URL = minioConfig.baseUrl;
+      env.OBJECT_STORE_ACCESS_KEY_ID = minioConfig.accessKeyId;
+      env.OBJECT_STORE_SECRET_ACCESS_KEY = minioConfig.secretAccessKey;
+      env.OBJECT_STORE_REGION = minioConfig.region;
+      env.OBJECT_STORE_DEFAULT_PROTOCOL = undefined;
+
+      const result = await generatePresignedRequest(
+        "proj_req_test",
+        "dev",
+        "req-test/file.json",
+        "GET"
+      );
+
+      expect(result.success).toBe(true);
+      if (!result.success) throw new Error(result.error);
+
+      // URL should point at the right key and contain SigV4 query params
+      expect(result.request.url).toContain("packets/proj_req_test/dev/req-test/file.json");
+      expect(result.request.url).toContain("X-Amz-");
+      expect(result.request.method).toBe("GET");
+    }
+  );
+
+  // Restore env after all tests
+  afterAll(() => {
+    process.env = originalEnv;
+    env.OBJECT_STORE_BASE_URL = originalEnvObj.OBJECT_STORE_BASE_URL;
+    env.OBJECT_STORE_BUCKET = originalEnvObj.OBJECT_STORE_BUCKET;
+    env.OBJECT_STORE_ACCESS_KEY_ID = originalEnvObj.OBJECT_STORE_ACCESS_KEY_ID;
+    env.OBJECT_STORE_SECRET_ACCESS_KEY = originalEnvObj.OBJECT_STORE_SECRET_ACCESS_KEY;
+    env.OBJECT_STORE_REGION = originalEnvObj.OBJECT_STORE_REGION;
+    env.OBJECT_STORE_DEFAULT_PROTOCOL = originalEnvObj.OBJECT_STORE_DEFAULT_PROTOCOL;
+    env.TASK_PAYLOAD_OFFLOAD_THRESHOLD = originalEnvObj.TASK_PAYLOAD_OFFLOAD_THRESHOLD;
+  });
+});
diff --git a/apps/webapp/test/otlpExporter.test.ts b/apps/webapp/test/otlpExporter.test.ts
index 98380f2a596..f07019b4a25 100644
--- a/apps/webapp/test/otlpExporter.test.ts
+++ b/apps/webapp/test/otlpExporter.test.ts
@@ -1,5 +1,8 @@
-import { describe, it, expect } from "vitest";
-import { enrichCreatableEvents } from "../app/v3/utils/enrichCreatableEvents.server.js";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  enrichCreatableEvents,
+  setLlmPricingRegistry,
+} from "../app/v3/utils/enrichCreatableEvents.server.js";
 import {
   RuntimeEnvironmentType,
   TaskEventKind,
@@ -83,8 +86,8 @@ describe("OTLPExporter", () => {
 
       const event = $events[0];
       expect(event.message).toBe("Responses API with 'gpt-4o'");
-      expect(event.style).toEqual({
-        icon: "tabler-brand-openai",
+      expect(event.style).toMatchObject({
+        icon: "ai-provider-openai",
       });
     });
 
@@ -161,8 +164,17 @@ describe("OTLPExporter", () => {
 
       const event = $events[0];
       expect(event.message).toBe("Responses API with gpt-4o");
-      expect(event.style).toEqual({
-        icon: "tabler-brand-openai",
+      expect(event.style).toMatchObject({
+        icon: "ai-provider-openai",
+      });
+      // Enrichment also adds model/token pills as accessories
+      const style = event.style as Record<string, unknown>;
+      expect(style.accessory).toMatchObject({
+        style: "pills",
+        items: expect.arrayContaining([
+          expect.objectContaining({ text: "gpt-4o-2024-08-06" }),
+          expect.objectContaining({ text: "724" }),
+        ]),
       });
     });
 
@@ -218,7 +230,7 @@ describe("OTLPExporter", () => {
       const $events = enrichCreatableEvents(events);
       expect($events[0].message).toBe("Using 'gpt-4' with temperature 0.7");
       expect($events[0].style).toEqual({
-        icon: "tabler-brand-openai",
+        icon: "ai-provider-openai",
       });
     });
 
@@ -249,7 +261,7 @@ describe("OTLPExporter", () => {
       const $events = enrichCreatableEvents(events);
       expect($events[0].message).toBe("Count is 42 and enabled is true");
       expect($events[0].style).toEqual({
-        icon: "tabler-brand-anthropic",
+        icon: "ai-provider-anthropic",
       });
     });
 
@@ -278,7 +290,7 @@ describe("OTLPExporter", () => {
       const $events = enrichCreatableEvents(events);
       expect($events[0].message).toBe("Plain message without variables");
       expect($events[0].style).toEqual({
-        icon: "tabler-brand-openai",
+        icon: "ai-provider-openai",
       });
     });
 
@@ -334,7 +346,7 @@ describe("OTLPExporter", () => {
       const $events = enrichCreatableEvents(events);
       expect($events[0].style).toEqual({
         existingStyle: "value",
-        icon: "tabler-brand-openai", // GenAI enricher wins because it's first
+        icon: "ai-provider-openai", // GenAI enricher wins because it's first
       });
     });
 
@@ -394,4 +406,301 @@ describe("OTLPExporter", () => {
       });
     });
   });
+
+  describe("LLM cost enrichment", () => {
+    const mockRegistry = {
+      isLoaded: true,
+      calculateCost: (responseModel: string, usageDetails: Record<string, number>) => {
+        if (responseModel.startsWith("gpt-4o")) {
+          const inputCost = (usageDetails["input"] ?? 0) * 0.0000025;
+          const outputCost = (usageDetails["output"] ?? 0) * 0.00001;
+          return {
+            matchedModelId: "llm_model_gpt4o",
+            matchedModelName: "gpt-4o",
+            pricingTierId: "tier-standard",
+            pricingTierName: "Standard",
+            inputCost,
+            outputCost,
+            totalCost: inputCost + outputCost,
+            costDetails: { input: inputCost, output: outputCost },
+          };
+        }
+        return null;
+      },
+    };
+
+    beforeEach(() => {
+      setLlmPricingRegistry(mockRegistry);
+    });
+
+    afterEach(() => {
+      setLlmPricingRegistry(undefined as any);
+    });
+
+    function makeGenAiEvent(overrides: Record<string, unknown> = {}) {
+      return {
+        message: "ai.streamText.doStream",
+        traceId: "test-trace",
+        spanId: "test-span",
+        parentId: "test-parent",
+        isPartial: false,
+        isError: false,
+        kind: TaskEventKind.INTERNAL,
+        level: TaskEventLevel.TRACE,
+        status: TaskEventStatus.UNSET,
+        startTime: BigInt(1),
+        duration: 5000000000,
+        style: {},
+        serviceName: "test",
+        environmentId: "env-1",
+        environmentType: RuntimeEnvironmentType.DEVELOPMENT,
+        organizationId: "org-1",
+        projectId: "proj-1",
+        projectRef: "proj_test",
+        runId: "run_test",
+        runIsTest: false,
+        taskSlug: "my-task",
+        metadata: undefined,
+        properties: {
+          "gen_ai.system": "openai",
+          "gen_ai.request.model": "gpt-4o",
+          "gen_ai.response.model": "gpt-4o-2024-08-06",
+          "gen_ai.usage.input_tokens": 702,
+          "gen_ai.usage.output_tokens": 22,
+          "operation.name": "ai.streamText.doStream",
+          ...overrides,
+        },
+      };
+    }
+
+    it("should enrich spans with cost attributes and accessories", () => {
+      const events = [makeGenAiEvent()];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      const event = $events[0];
+
+      // Cost attributes
+      expect(event.properties["trigger.llm.total_cost"]).toBeCloseTo(0.001975);
+      expect(event.properties["trigger.llm.input_cost"]).toBeCloseTo(0.001755);
+      expect(event.properties["trigger.llm.output_cost"]).toBeCloseTo(0.00022);
+      expect(event.properties["trigger.llm.matched_model"]).toBe("gpt-4o");
+      expect(event.properties["trigger.llm.pricing_tier"]).toBe("Standard");
+
+      // Accessories (pills style)
+      expect(event.style.accessory).toBeDefined();
+      expect(event.style.accessory.style).toBe("pills");
+      expect(event.style.accessory.items).toHaveLength(3);
+      expect(event.style.accessory.items[0]).toEqual({
+        text: "gpt-4o-2024-08-06",
+        icon: "tabler-cube",
+      });
+      expect(event.style.accessory.items[1]).toEqual({
+        text: "724",
+        icon: "tabler-hash",
+      });
+      expect(event.style.accessory.items[2]).toEqual({
+        text: "$0.001975",
+        icon: "tabler-currency-dollar",
+      });
+    });
+
+    it("should set _llmMetrics side-channel for dual-write", () => {
+      const events = [makeGenAiEvent()];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      const event = $events[0];
+
+      expect(event._llmMetrics).toBeDefined();
+      expect(event._llmMetrics.genAiSystem).toBe("openai");
+      expect(event._llmMetrics.responseModel).toBe("gpt-4o-2024-08-06");
+      expect(event._llmMetrics.inputTokens).toBe(702);
+      expect(event._llmMetrics.outputTokens).toBe(22);
+      expect(event._llmMetrics.totalCost).toBeCloseTo(0.001975);
+      expect(event._llmMetrics.operationId).toBe("ai.streamText.doStream");
+    });
+
+    it("should skip partial spans", () => {
+      const events = [makeGenAiEvent()];
+      events[0].isPartial = true;
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+      expect($events[0]._llmMetrics).toBeUndefined();
+    });
+
+    it("should skip spans without gen_ai.response.model or gen_ai.request.model", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.response.model": undefined,
+          "gen_ai.request.model": undefined,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+    });
+
+    it("should fall back to gen_ai.request.model when response.model is missing", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.response.model": undefined,
+          "gen_ai.request.model": "gpt-4o",
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.matched_model"]).toBe("gpt-4o");
+    });
+
+    it("should skip spans with no token usage", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": 0,
+          "gen_ai.usage.output_tokens": 0,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+    });
+
+    it("should skip spans with unknown models", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.response.model": "unknown-model-xyz",
+          "gen_ai.request.model": "unknown-model-xyz",
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+    });
+
+    it("should not enrich non-span kinds like SPAN_EVENT or LOG", () => {
+      const events = [makeGenAiEvent()];
+      events[0].kind = "SPAN_EVENT" as any;
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+    });
+
+    it("should enrich SERVER kind events", () => {
+      const events = [makeGenAiEvent()];
+      events[0].kind = TaskEventKind.SERVER;
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeCloseTo(0.001975);
+    });
+
+    it("should not enrich when registry is not loaded", () => {
+      setLlmPricingRegistry({ isLoaded: false, calculateCost: () => null });
+      const events = [makeGenAiEvent()];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].properties["trigger.llm.total_cost"]).toBeUndefined();
+    });
+
+    it("should format token counts with k/M suffixes in accessories", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": 150000,
+          "gen_ai.usage.output_tokens": 2000,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0].style.accessory.items[1].text).toBe("152.0k");
+    });
+
+    it("should normalize alternate token attribute names", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": undefined,
+          "gen_ai.usage.output_tokens": undefined,
+          "gen_ai.usage.prompt_tokens": 500,
+          "gen_ai.usage.completion_tokens": 100,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      expect($events[0]._llmMetrics.inputTokens).toBe(500);
+      expect($events[0]._llmMetrics.outputTokens).toBe(100);
+    });
+
+    it("should prefer gen_ai.usage.total_tokens over input+output sum", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": 100,
+          "gen_ai.usage.output_tokens": 50,
+          "gen_ai.usage.total_tokens": 200, // higher than 100+50 (e.g. includes cached/reasoning)
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      const event = $events[0];
+
+      // Pills should show the explicit total, not input+output
+      expect(event.style.accessory.items[1]).toEqual({
+        text: "200",
+        icon: "tabler-hash",
+      });
+
+      // LLM usage should also use the explicit total
+      expect(event._llmMetrics.totalTokens).toBe(200);
+      expect(event._llmMetrics.inputTokens).toBe(100);
+      expect(event._llmMetrics.outputTokens).toBe(50);
+    });
+
+    it("should fall back to input+output when total_tokens is absent", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": 300,
+          "gen_ai.usage.output_tokens": 75,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      const event = $events[0];
+
+      expect(event.style.accessory.items[1]).toEqual({
+        text: "375",
+        icon: "tabler-hash",
+      });
+      expect(event._llmMetrics.totalTokens).toBe(375);
+    });
+
+    it("should use total_tokens when only total is present without input/output breakdown", () => {
+      const events = [
+        makeGenAiEvent({
+          "gen_ai.usage.input_tokens": undefined,
+          "gen_ai.usage.output_tokens": undefined,
+          "gen_ai.usage.total_tokens": 500,
+        }),
+      ];
+
+      // @ts-expect-error
+      const $events = enrichCreatableEvents(events);
+      const event = $events[0];
+
+      // Pills should show 500, not 0
+      expect(event.style.accessory.items[1]).toEqual({
+        text: "500",
+        icon: "tabler-hash",
+      });
+    });
+  });
 });
diff --git a/apps/webapp/test/runsReplicationBenchmark.README.md b/apps/webapp/test/runsReplicationBenchmark.README.md
new file mode 100644
index 00000000000..359d4b8f906
--- /dev/null
+++ b/apps/webapp/test/runsReplicationBenchmark.README.md
@@ -0,0 +1,282 @@
+# RunsReplicationService Error Fingerprinting Benchmark
+
+This benchmark measures the performance impact of error fingerprinting in the RunsReplicationService.
+
+## Overview
+
+The benchmark:
+1. Creates a realistic dataset of TaskRuns (7% with errors by default)
+2. Runs the producer in a **separate process** to simulate real-world load
+3. Measures replication throughput and Event Loop Utilization (ELU)
+4. Compares performance with fingerprinting **enabled** vs **disabled**
+
+## Architecture
+
+```
+┌─────────────────┐         ┌──────────────────────┐
+│  Producer       │         │  Benchmark Test      │
+│  (Child Process)│─────────│  (Main Process)      │
+│                 │  IPC    │                      │
+│  - Inserts      │         │  - RunsReplication   │
+│    TaskRuns     │         │    Service           │
+│    to Postgres  │         │  - ELU Monitor       │
+│                 │         │  - Metrics           │
+└─────────────────┘         └──────────────────────┘
+         │                           │
+         │                           │
+         ▼                           ▼
+    ┌──────────┐              ┌──────────────┐
+    │ Postgres │              │  ClickHouse  │
+    └──────────┘              └──────────────┘
+```
+
+## Files
+
+- `runsReplicationBenchmark.test.ts` - Main benchmark test
+- `runsReplicationBenchmark.producer.ts` - Producer script (runs in child process)
+- `runsReplicationBenchmark.README.md` - This file
+
+## Configuration
+
+The benchmark can be configured via environment variables or by editing `BENCHMARK_CONFIG` in the test file:
+
+```typescript
+const BENCHMARK_CONFIG = {
+  // Number of runs to create
+  NUM_RUNS: parseInt(process.env.BENCHMARK_NUM_RUNS || "5000", 10),
+
+  // Error rate (0.07 = 7%)
+  ERROR_RATE: 0.07,
+
+  // Producer batch size
+  PRODUCER_BATCH_SIZE: 100,
+
+  // Replication service settings
+  FLUSH_BATCH_SIZE: 50,
+  FLUSH_INTERVAL_MS: 100,
+  MAX_FLUSH_CONCURRENCY: 4,
+
+  // Timeout
+  REPLICATION_TIMEOUT_MS: 120_000, // 2 minutes
+};
+```
+
+## Running the Benchmark
+
+### Quick Test (Small Dataset)
+
+```bash
+cd apps/webapp
+BENCHMARK_NUM_RUNS=1000 pnpm run test ./test/runsReplicationBenchmark.test.ts --run
+```
+
+### Realistic Benchmark (Larger Dataset)
+
+```bash
+cd apps/webapp
+BENCHMARK_NUM_RUNS=10000 pnpm run test ./test/runsReplicationBenchmark.test.ts --run
+```
+
+### High Volume Benchmark
+
+```bash
+cd apps/webapp
+BENCHMARK_NUM_RUNS=50000 pnpm run test ./test/runsReplicationBenchmark.test.ts --run
+```
+
+**Note:** The benchmark is gated by the `BENCHMARKS_ENABLED` environment variable
+(via `containerTest.skipIf`), so you don't need to edit the test file. Set
+`BENCHMARKS_ENABLED=1` (and optionally `BENCHMARK_NUM_RUNS`) then run:
+
+```bash
+cd apps/webapp
+BENCHMARKS_ENABLED=1 pnpm run test ./test/runsReplicationBenchmark.test.ts --run
+```
+
+## What Gets Measured
+
+### 1. Producer Metrics
+- Total runs created
+- Runs with errors (should be ~7%)
+- Duration
+- Throughput (runs/sec)
+
+### 2. Replication Metrics
+- Total runs replicated to ClickHouse
+- Replication duration
+- Replication throughput (runs/sec)
+
+### 3. Event Loop Utilization (ELU)
+- Mean utilization (%)
+- P50 (median) utilization (%)
+- P95 utilization (%)
+- P99 utilization (%)
+- All samples for detailed analysis
+
+### 4. OpenTelemetry Metrics
+- Batches flushed
+- Task runs inserted
+- Payloads inserted
+- Events processed
+
+## Output
+
+The benchmark produces detailed output including:
+
+```
+================================================================================
+BENCHMARK: baseline-no-fingerprinting
+Error Fingerprinting: DISABLED
+Runs: 5000, Error Rate: 7.0%
+================================================================================
+
+[Producer] Starting - will create 5000 runs (7.0% with errors)
+[Producer] Progress: 1000/5000 runs (2500 runs/sec)
+...
+[Producer] Completed:
+  - Total runs: 5000
+  - With errors: 352 (7.0%)
+  - Duration: 2145ms
+  - Throughput: 2331 runs/sec
+
+[Benchmark] Waiting for replication to complete...
+
+================================================================================
+RESULTS: baseline-no-fingerprinting
+================================================================================
+
+Producer:
+  Created: 5000 runs
+  With errors: 352 (7.0%)
+  Duration: 2145ms
+  Throughput: 2331 runs/sec
+
+Replication:
+  Replicated: 5000 runs
+  Duration: 3456ms
+  Throughput: 1447 runs/sec
+
+Event Loop Utilization:
+  Mean: 23.45%
+  P50: 22.10%
+  P95: 34.20%
+  P99: 41.30%
+  Samples: 346
+
+Metrics:
+  Batches flushed: 102
+  Task runs inserted: 5000
+  Payloads inserted: 5000
+  Events processed: 5000
+================================================================================
+
+[... Similar output for "with-fingerprinting" benchmark ...]
+
+================================================================================
+COMPARISON
+Baseline: baseline-no-fingerprinting (fingerprinting OFF)
+Comparison: with-fingerprinting (fingerprinting ON)
+================================================================================
+
+Replication Duration:
+  3456ms → 3512ms (+1.62%)
+
+Throughput:
+  1447 → 1424 runs/sec (-1.59%)
+
+Event Loop Utilization (Mean):
+  23.45% → 24.12% (+2.86%)
+
+Event Loop Utilization (P99):
+  41.30% → 43.20% (+4.60%)
+
+================================================================================
+
+BENCHMARK COMPLETE
+Fingerprinting impact on replication duration: +1.62%
+Fingerprinting impact on throughput: -1.59%
+Fingerprinting impact on ELU (mean): +2.86%
+Fingerprinting impact on ELU (P99): +4.60%
+```
+
+## Interpreting Results
+
+### What to Look For
+
+1. **Replication Duration Delta** - How much longer replication takes with fingerprinting
+2. **Throughput Delta** - Change in runs processed per second
+3. **ELU Delta** - Change in event loop utilization (higher = more CPU bound)
+
+### Expected Results
+
+With a 7% error rate and SHA-256 hashing:
+- **Small impact** (<5% overhead): Fingerprinting is well optimized
+- **Moderate impact** (5-15% overhead): May want to consider optimizations
+- **Large impact** (>15% overhead): Fingerprinting needs optimization
+
+### Performance Optimization Ideas
+
+If the benchmark shows significant overhead, consider:
+
+1. **Faster hashing algorithm** - Replace SHA-256 with xxHash or MurmurHash3
+2. **Worker threads** - Move fingerprinting to worker threads
+3. **Caching** - Cache fingerprints for identical errors
+4. **Lazy computation** - Only compute fingerprints when needed
+5. **Batch processing** - Group similar errors before hashing
+
+## Dataset Characteristics
+
+The producer generates realistic error variety:
+
+- TypeError (undefined property access)
+- Error (API fetch failures)
+- ValidationError (input validation)
+- TimeoutError (operation timeouts)
+- DatabaseError (connection failures)
+- ReferenceError (undefined variables)
+
+Each error template includes:
+- Realistic stack traces
+- Variable IDs and timestamps
+- Line/column numbers
+- File paths
+
+This ensures the fingerprinting algorithm is tested with realistic data.
+
+## Troubleshooting
+
+### Benchmark Times Out
+
+Increase the timeout:
+```typescript
+REPLICATION_TIMEOUT_MS: 300_000, // 5 minutes
+```
+
+### Producer Fails
+
+Check Postgres connection and ensure:
+- Docker services are running (`pnpm run docker`)
+- Database is accessible
+- Sufficient disk space
+
+### Different Results Each Run
+
+This is normal! Factors affecting variance:
+- System load
+- Docker container overhead
+- Database I/O
+- Network latency (even localhost)
+
+Run multiple times and look at trends.
+
+## Future Enhancements
+
+Potential improvements to the benchmark:
+
+1. **Multiple error rates** - Test 0%, 5%, 10%, 25%, 50% error rates
+2. **Different hash algorithms** - Compare SHA-256 vs xxHash vs MurmurHash3
+3. **Worker thread comparison** - Test main thread vs worker threads
+4. **Concurrent producers** - Multiple producer processes
+5. **Memory profiling** - Track memory usage over time
+6. **Flame graphs** - Generate CPU flame graphs for analysis
+7. **Historical tracking** - Store results over time to track regressions
diff --git a/apps/webapp/test/runsReplicationBenchmark.producer.ts b/apps/webapp/test/runsReplicationBenchmark.producer.ts
new file mode 100644
index 00000000000..547d1318c46
--- /dev/null
+++ b/apps/webapp/test/runsReplicationBenchmark.producer.ts
@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * Producer script that runs in a separate process to insert TaskRuns into PostgreSQL.
+ * This simulates realistic production load for benchmarking RunsReplicationService.
+ */
+
+import { PrismaClient } from "@trigger.dev/database";
+import { performance } from "node:perf_hooks";
+
+interface ProducerConfig {
+  postgresUrl: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  numRuns: number;
+  errorRate: number; // 0.07 = 7%
+  batchSize: number;
+}
+
+// Error templates for realistic variety
+const ERROR_TEMPLATES = [
+  {
+    type: "TypeError",
+    message: "Cannot read property 'foo' of undefined",
+    stack: `TypeError: Cannot read property 'foo' of undefined
+    at processData (/app/src/handler.ts:42:15)
+    at runTask (/app/src/runtime.ts:128:20)
+    at executeRun (/app/src/executor.ts:89:12)
+    at async Runner.execute (/app/src/runner.ts:56:5)`,
+  },
+  {
+    type: "Error",
+    message: "Failed to fetch data from API endpoint https://api.example.com/data/12345",
+    stack: `Error: Failed to fetch data from API endpoint https://api.example.com/data/12345
+    at fetchData (/app/src/api.ts:78:11)
+    at getData (/app/src/service.ts:34:18)
+    at processTask (/app/src/handler.ts:23:15)
+    at runTask (/app/src/runtime.ts:128:20)`,
+  },
+  {
+    type: "ValidationError",
+    message: "Invalid input: expected string for field 'email', got number: 1234567890",
+    stack: `ValidationError: Invalid input: expected string for field 'email', got number: 1234567890
+    at validateInput (/app/src/validator.ts:156:9)
+    at processRequest (/app/src/handler.ts:67:23)
+    at runTask (/app/src/runtime.ts:128:20)`,
+  },
+  {
+    type: "TimeoutError",
+    message: "Operation timed out after 30000ms",
+    stack: `TimeoutError: Operation timed out after 30000ms
+    at Timeout._onTimeout (/app/src/timeout.ts:45:15)
+    at processTask (/app/src/handler.ts:89:12)
+    at runTask (/app/src/runtime.ts:128:20)`,
+  },
+  {
+    type: "DatabaseError",
+    message: "Connection to database 'prod_db' failed: timeout of 5000ms exceeded",
+    stack: `DatabaseError: Connection to database 'prod_db' failed: timeout of 5000ms exceeded
+    at connect (/app/node_modules/pg/lib/client.js:234:11)
+    at query (/app/src/db.ts:89:18)
+    at getData (/app/src/service.ts:45:22)`,
+  },
+  {
+    type: "ReferenceError",
+    message: "userId is not defined",
+    stack: `ReferenceError: userId is not defined
+    at validateUser (/app/src/auth.ts:123:9)
+    at processTask (/app/src/handler.ts:34:15)
+    at runTask (/app/src/runtime.ts:128:20)`,
+  },
+];
+
+function generateError() {
+  const template = ERROR_TEMPLATES[Math.floor(Math.random() * ERROR_TEMPLATES.length)];
+
+  // Add variation to make errors slightly different
+  const randomId = Math.floor(Math.random() * 100000);
+  const randomTimestamp = Date.now() + Math.floor(Math.random() * 10000);
+
+  return {
+    type: template.type,
+    name: template.type,
+    message: template.message
+      .replace(/\d{4,}/g, String(randomId))
+      .replace(/\d{13}/g, String(randomTimestamp)),
+    stack: template.stack
+      .replace(/:\d+:\d+/g, `:${Math.floor(Math.random() * 500)}:${Math.floor(Math.random() * 50)}`)
+      .replace(/\d{4,}/g, String(randomId)),
+  };
+}
+
+async function runProducer(config: ProducerConfig) {
+  const prisma = new PrismaClient({
+    datasources: {
+      db: {
+        url: config.postgresUrl,
+      },
+    },
+  });
+
+  try {
+    console.log(
+      `[Producer] Starting - will create ${config.numRuns} runs (${(config.errorRate * 100).toFixed(
+        1
+      )}% with errors)`
+    );
+    const startTime = performance.now();
+    let created = 0;
+    let withErrors = 0;
+
+    // Process in batches to avoid overwhelming the database
+    for (let batch = 0; batch < Math.ceil(config.numRuns / config.batchSize); batch++) {
+      const batchStart = batch * config.batchSize;
+      const batchEnd = Math.min(batchStart + config.batchSize, config.numRuns);
+      const batchSize = batchEnd - batchStart;
+
+      const runs = [];
+      for (let i = batchStart; i < batchEnd; i++) {
+        const hasError = Math.random() < config.errorRate;
+        const status = hasError ? "COMPLETED_WITH_ERRORS" : "COMPLETED_SUCCESSFULLY";
+
+        const runData: any = {
+          friendlyId: `run_bench_${Date.now()}_${i}`,
+          taskIdentifier: `benchmark-task-${i % 10}`, // Vary task identifiers
+          payload: JSON.stringify({ index: i, timestamp: Date.now() }),
+          traceId: `trace_${i}`,
+          spanId: `span_${i}`,
+          queue: `queue-${i % 5}`, // Vary queues
+          runtimeEnvironmentId: config.environmentId,
+          projectId: config.projectId,
+          organizationId: config.organizationId,
+          environmentType: "DEVELOPMENT",
+          engine: "V2",
+          status,
+          createdAt: new Date(Date.now() - Math.floor(Math.random() * 1000)),
+          updatedAt: new Date(),
+        };
+
+        if (hasError) {
+          runData.error = generateError();
+          withErrors++;
+        }
+
+        runs.push(runData);
+      }
+
+      // Insert batch
+      await prisma.taskRun.createMany({
+        data: runs,
+      });
+
+      created += batchSize;
+
+      if (batch % 10 === 0 || batch === Math.ceil(config.numRuns / config.batchSize) - 1) {
+        const elapsed = performance.now() - startTime;
+        const rate = (created / elapsed) * 1000;
+        console.log(
+          `[Producer] Progress: ${created}/${config.numRuns} runs (${rate.toFixed(0)} runs/sec)`
+        );
+      }
+    }
+
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+    const throughput = (created / duration) * 1000;
+
+    console.log(`[Producer] Completed:`);
+    console.log(`  - Total runs: ${created}`);
+    console.log(`  - With errors: ${withErrors} (${((withErrors / created) * 100).toFixed(1)}%)`);
+    console.log(`  - Duration: ${duration.toFixed(0)}ms`);
+    console.log(`  - Throughput: ${throughput.toFixed(0)} runs/sec`);
+
+    // Send results to parent process
+    if (process.send) {
+      process.send({
+        type: "complete",
+        stats: {
+          created,
+          withErrors,
+          duration,
+          throughput,
+        },
+      });
+    }
+  } catch (error) {
+    console.error("[Producer] Error:", error);
+    if (process.send) {
+      process.send({
+        type: "error",
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+    process.exit(1);
+  } finally {
+    await prisma.$disconnect();
+  }
+}
+
+// Parse config from command line args
+const configArg = process.argv[2];
+if (!configArg) {
+  console.error("Usage: runsReplicationBenchmark.producer.ts <config-json>");
+  process.exit(1);
+}
+
+// This is ok for a benchmark script, but not for production code.
+const config = JSON.parse(configArg) as ProducerConfig;
+runProducer(config).catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
diff --git a/apps/webapp/test/runsReplicationBenchmark.test.ts b/apps/webapp/test/runsReplicationBenchmark.test.ts
new file mode 100644
index 00000000000..5c04ef55cc8
--- /dev/null
+++ b/apps/webapp/test/runsReplicationBenchmark.test.ts
@@ -0,0 +1,570 @@
+import { ClickHouse } from "@internal/clickhouse";
+import { containerTest } from "@internal/testcontainers";
+import { fork, type ChildProcess } from "node:child_process";
+import { performance, PerformanceObserver } from "node:perf_hooks";
+import { setTimeout } from "node:timers/promises";
+import path from "node:path";
+import { z } from "zod";
+import { RunsReplicationService } from "~/services/runsReplicationService.server";
+import { createInMemoryTracing, createInMemoryMetrics } from "./utils/tracing";
+
+// Extend test timeout for benchmarks
+vi.setConfig({ testTimeout: 300_000 }); // 5 minutes
+
+/**
+ * Benchmark configuration
+ */
+const BENCHMARK_CONFIG = {
+  // Number of runs to create - adjust this to test different volumes
+  // Start with smaller numbers (1000) for quick tests, increase to 10000+ for realistic benchmarks
+  NUM_RUNS: parseInt(process.env.BENCHMARK_NUM_RUNS || "5000", 10),
+
+  // Error rate (7% = realistic production load with some failures)
+  ERROR_RATE: 0.07,
+
+  // Batch size for producer
+  PRODUCER_BATCH_SIZE: 100,
+
+  // Replication service settings
+  FLUSH_BATCH_SIZE: 50,
+  FLUSH_INTERVAL_MS: 100,
+  MAX_FLUSH_CONCURRENCY: 4,
+
+  // How long to wait for replication to complete (in ms)
+  REPLICATION_TIMEOUT_MS: 120_000, // 2 minutes
+};
+
+interface BenchmarkResult {
+  name: string;
+  fingerprintingEnabled: boolean;
+  producerStats: {
+    created: number;
+    withErrors: number;
+    duration: number;
+    throughput: number;
+  };
+  replicationStats: {
+    duration: number;
+    throughput: number;
+    replicatedRuns: number;
+  };
+  eluStats: {
+    mean: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    samples: number[];
+  };
+  metricsStats: {
+    batchesFlushed: number;
+    taskRunsInserted: number;
+    payloadsInserted: number;
+    eventsProcessed: number;
+  };
+}
+
+/**
+ * Measure Event Loop Utilization during benchmark
+ */
+class ELUMonitor {
+  private samples: number[] = [];
+  private interval: NodeJS.Timeout | null = null;
+  private startELU: { idle: number; active: number } | null = null;
+
+  start(intervalMs: number = 100) {
+    this.samples = [];
+    this.startELU = performance.eventLoopUtilization();
+
+    this.interval = setInterval(() => {
+      const elu = performance.eventLoopUtilization();
+      const utilization = elu.utilization * 100; // Convert to percentage
+      this.samples.push(utilization);
+    }, intervalMs);
+  }
+
+  stop(): { mean: number; p50: number; p95: number; p99: number; samples: number[] } {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+
+    if (this.samples.length === 0) {
+      return { mean: 0, p50: 0, p95: 0, p99: 0, samples: [] };
+    }
+
+    const sorted = [...this.samples].sort((a, b) => a - b);
+    const mean = sorted.reduce((sum, val) => sum + val, 0) / sorted.length;
+    const p50 = sorted[Math.floor(sorted.length * 0.5)];
+    const p95 = sorted[Math.floor(sorted.length * 0.95)];
+    const p99 = sorted[Math.floor(sorted.length * 0.99)];
+
+    return { mean, p50, p95, p99, samples: sorted };
+  }
+}
+
+/**
+ * Run the producer script in a separate process
+ */
+async function runProducer(config: {
+  postgresUrl: string;
+  organizationId: string;
+  projectId: string;
+  environmentId: string;
+  numRuns: number;
+  errorRate: number;
+  batchSize: number;
+}): Promise<{ created: number; withErrors: number; duration: number; throughput: number }> {
+  return new Promise((resolve, reject) => {
+    const producerPath = path.join(__dirname, "runsReplicationBenchmark.producer.ts");
+
+    // Use tsx to run the TypeScript file directly
+    const child = fork(producerPath, [JSON.stringify(config)], {
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      execArgv: ["-r", "tsx/cjs"],
+    });
+
+    let output = "";
+
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      output += text;
+      console.log(text.trim());
+    });
+
+    child.stderr?.on("data", (data) => {
+      console.error(data.toString().trim());
+    });
+
+    child.on("message", (message: any) => {
+      if (message.type === "complete") {
+        resolve(message.stats);
+      } else if (message.type === "error") {
+        reject(new Error(message.error));
+      }
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Producer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+/**
+ * Wait for all runs to be replicated to ClickHouse
+ */
+async function waitForReplication(
+  clickhouse: ClickHouse,
+  organizationId: string,
+  expectedCount: number,
+  timeoutMs: number
+): Promise<{ duration: number; replicatedRuns: number }> {
+  const startTime = performance.now();
+  const deadline = startTime + timeoutMs;
+
+  const queryRuns = clickhouse.reader.query({
+    name: "benchmark-count",
+    query:
+      "SELECT count(*) as count FROM trigger_dev.task_runs_v2 WHERE organization_id = {org_id:String}",
+    schema: z.object({ count: z.number() }),
+    params: z.object({ org_id: z.string() }),
+  });
+
+  while (performance.now() < deadline) {
+    const [error, result] = await queryRuns({ org_id: organizationId });
+
+    if (error) {
+      throw new Error(`Failed to query ClickHouse: ${error.message}`);
+    }
+
+    const count = result?.[0]?.count || 0;
+
+    if (count >= expectedCount) {
+      const duration = performance.now() - startTime;
+      return { duration, replicatedRuns: count };
+    }
+
+    // Wait a bit before checking again
+    await setTimeout(500);
+  }
+
+  throw new Error(
+    `Replication timeout: expected ${expectedCount} runs, but only found ${await getRunCount(
+      clickhouse
+    )} after ${timeoutMs}ms`
+  );
+}
+
+async function getRunCount(clickhouse: ClickHouse): Promise<number> {
+  const queryRuns = clickhouse.reader.query({
+    name: "benchmark-count",
+    query: "SELECT count(*) as count FROM trigger_dev.task_runs_v2",
+    schema: z.object({ count: z.number() }),
+  });
+
+  const [error, result] = await queryRuns({});
+  if (error) return 0;
+  return result?.[0]?.count || 0;
+}
+
+/**
+ * Extract metrics from OpenTelemetry metrics
+ */
+function extractMetrics(metrics: any[]): {
+  batchesFlushed: number;
+  taskRunsInserted: number;
+  payloadsInserted: number;
+  eventsProcessed: number;
+} {
+  function getMetricData(name: string) {
+    for (const resourceMetrics of metrics) {
+      for (const scopeMetrics of resourceMetrics.scopeMetrics) {
+        for (const metric of scopeMetrics.metrics) {
+          if (metric.descriptor.name === name) {
+            return metric;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  function sumCounterValues(metric: any): number {
+    if (!metric?.dataPoints) return 0;
+    return metric.dataPoints.reduce((sum: number, dp: any) => sum + (dp.value || 0), 0);
+  }
+
+  return {
+    batchesFlushed: sumCounterValues(getMetricData("runs_replication.batches_flushed")),
+    taskRunsInserted: sumCounterValues(getMetricData("runs_replication.task_runs_inserted")),
+    payloadsInserted: sumCounterValues(getMetricData("runs_replication.payloads_inserted")),
+    eventsProcessed: sumCounterValues(getMetricData("runs_replication.events_processed")),
+  };
+}
+
+/**
+ * Run a single benchmark test
+ */
+async function runBenchmark(
+  name: string,
+  fingerprintingEnabled: boolean,
+  {
+    clickhouseContainer,
+    redisOptions,
+    postgresContainer,
+    prisma,
+  }: {
+    clickhouseContainer: any;
+    redisOptions: any;
+    postgresContainer: any;
+    prisma: any;
+  }
+): Promise<BenchmarkResult> {
+  console.log(`\n${"=".repeat(80)}`);
+  console.log(`BENCHMARK: ${name}`);
+  console.log(`Error Fingerprinting: ${fingerprintingEnabled ? "ENABLED" : "DISABLED"}`);
+  console.log(
+    `Runs: ${BENCHMARK_CONFIG.NUM_RUNS}, Error Rate: ${(BENCHMARK_CONFIG.ERROR_RATE * 100).toFixed(
+      1
+    )}%`
+  );
+  console.log(`${"=".repeat(80)}\n`);
+
+  // Setup
+  const organization = await prisma.organization.create({
+    data: {
+      title: `benchmark-${name}`,
+      slug: `benchmark-${name}`,
+    },
+  });
+
+  const project = await prisma.project.create({
+    data: {
+      name: `benchmark-${name}`,
+      slug: `benchmark-${name}`,
+      organizationId: organization.id,
+      externalRef: `benchmark-${name}`,
+    },
+  });
+
+  const runtimeEnvironment = await prisma.runtimeEnvironment.create({
+    data: {
+      slug: `benchmark-${name}`,
+      type: "DEVELOPMENT",
+      projectId: project.id,
+      organizationId: organization.id,
+      apiKey: `benchmark-${name}`,
+      pkApiKey: `benchmark-${name}`,
+      shortcode: `benchmark-${name}`,
+    },
+  });
+
+  // Setup ClickHouse
+  const clickhouse = new ClickHouse({
+    url: clickhouseContainer.getConnectionUrl(),
+    name: `benchmark-${name}`,
+    compression: {
+      request: true,
+    },
+    logLevel: "warn",
+  });
+
+  // Setup tracing and metrics
+  const { tracer } = createInMemoryTracing();
+  const metricsHelper = createInMemoryMetrics();
+
+  // Create and start replication service
+  const runsReplicationService = new RunsReplicationService({
+    clickhouse,
+    pgConnectionUrl: postgresContainer.getConnectionUri(),
+    serviceName: `benchmark-${name}`,
+    slotName: `benchmark_${name.replace(/-/g, "_")}`,
+    publicationName: `benchmark_${name.replace(/-/g, "_")}_pub`,
+    redisOptions,
+    maxFlushConcurrency: BENCHMARK_CONFIG.MAX_FLUSH_CONCURRENCY,
+    flushIntervalMs: BENCHMARK_CONFIG.FLUSH_INTERVAL_MS,
+    flushBatchSize: BENCHMARK_CONFIG.FLUSH_BATCH_SIZE,
+    leaderLockTimeoutMs: 10000,
+    leaderLockExtendIntervalMs: 2000,
+    ackIntervalSeconds: 10,
+    tracer,
+    meter: metricsHelper.meter,
+    logLevel: "warn",
+    disableErrorFingerprinting: !fingerprintingEnabled,
+  });
+
+  await runsReplicationService.start();
+
+  // Start ELU monitoring
+  const eluMonitor = new ELUMonitor();
+  eluMonitor.start(100);
+
+  let producerStats!: BenchmarkResult["producerStats"];
+  let replicationResult!: { duration: number; replicatedRuns: number };
+  let metricsStats!: BenchmarkResult["metricsStats"];
+  let eluStats!: BenchmarkResult["eluStats"];
+
+  try {
+    // Run producer in separate process
+    console.log("\n[Benchmark] Starting producer...");
+    producerStats = await runProducer({
+      postgresUrl: postgresContainer.getConnectionUri(),
+      organizationId: organization.id,
+      projectId: project.id,
+      environmentId: runtimeEnvironment.id,
+      numRuns: BENCHMARK_CONFIG.NUM_RUNS,
+      errorRate: BENCHMARK_CONFIG.ERROR_RATE,
+      batchSize: BENCHMARK_CONFIG.PRODUCER_BATCH_SIZE,
+    });
+
+    console.log("\n[Benchmark] Waiting for replication to complete...");
+    replicationResult = await waitForReplication(
+      clickhouse,
+      organization.id,
+      producerStats.created,
+      BENCHMARK_CONFIG.REPLICATION_TIMEOUT_MS
+    );
+
+    const metrics = await metricsHelper.getMetrics();
+    metricsStats = extractMetrics(metrics);
+  } finally {
+    eluStats = eluMonitor.stop();
+    await runsReplicationService.stop();
+    await metricsHelper.shutdown();
+  }
+
+  const throughput = (replicationResult.replicatedRuns / replicationResult.duration) * 1000;
+
+  const result: BenchmarkResult = {
+    name,
+    fingerprintingEnabled,
+    producerStats,
+    replicationStats: {
+      duration: replicationResult.duration,
+      throughput,
+      replicatedRuns: replicationResult.replicatedRuns,
+    },
+    eluStats,
+    metricsStats,
+  };
+
+  // Print results
+  console.log(`\n${"=".repeat(80)}`);
+  console.log(`RESULTS: ${name}`);
+  console.log(`${"=".repeat(80)}`);
+  console.log("\nProducer:");
+  console.log(`  Created: ${producerStats.created} runs`);
+  console.log(
+    `  With errors: ${producerStats.withErrors} (${(
+      (producerStats.withErrors / producerStats.created) *
+      100
+    ).toFixed(1)}%)`
+  );
+  console.log(`  Duration: ${producerStats.duration.toFixed(0)}ms`);
+  console.log(`  Throughput: ${producerStats.throughput.toFixed(0)} runs/sec`);
+  console.log("\nReplication:");
+  console.log(`  Replicated: ${replicationResult.replicatedRuns} runs`);
+  console.log(`  Duration: ${replicationResult.duration.toFixed(0)}ms`);
+  console.log(`  Throughput: ${throughput.toFixed(0)} runs/sec`);
+  console.log("\nEvent Loop Utilization:");
+  console.log(`  Mean: ${eluStats.mean.toFixed(2)}%`);
+  console.log(`  P50: ${eluStats.p50.toFixed(2)}%`);
+  console.log(`  P95: ${eluStats.p95.toFixed(2)}%`);
+  console.log(`  P99: ${eluStats.p99.toFixed(2)}%`);
+  console.log(`  Samples: ${eluStats.samples.length}`);
+  console.log("\nMetrics:");
+  console.log(`  Batches flushed: ${metricsStats.batchesFlushed}`);
+  console.log(`  Task runs inserted: ${metricsStats.taskRunsInserted}`);
+  console.log(`  Payloads inserted: ${metricsStats.payloadsInserted}`);
+  console.log(`  Events processed: ${metricsStats.eventsProcessed}`);
+  console.log(`${"=".repeat(80)}\n`);
+
+  return result;
+}
+
+/**
+ * Compare two benchmark results and print delta
+ */
+function compareBenchmarks(baseline: BenchmarkResult, comparison: BenchmarkResult) {
+  console.log(`\n${"=".repeat(80)}`);
+  console.log("COMPARISON");
+  console.log(
+    `Baseline: ${baseline.name} (fingerprinting ${baseline.fingerprintingEnabled ? "ON" : "OFF"})`
+  );
+  console.log(
+    `Comparison: ${comparison.name} (fingerprinting ${
+      comparison.fingerprintingEnabled ? "ON" : "OFF"
+    })`
+  );
+  console.log(`${"=".repeat(80)}`);
+
+  const replicationDurationDelta =
+    ((comparison.replicationStats.duration - baseline.replicationStats.duration) /
+      baseline.replicationStats.duration) *
+    100;
+  const throughputDelta =
+    ((comparison.replicationStats.throughput - baseline.replicationStats.throughput) /
+      baseline.replicationStats.throughput) *
+    100;
+  const eluMeanDelta =
+    ((comparison.eluStats.mean - baseline.eluStats.mean) / baseline.eluStats.mean) * 100;
+  const eluP99Delta =
+    ((comparison.eluStats.p99 - baseline.eluStats.p99) / baseline.eluStats.p99) * 100;
+
+  console.log("\nReplication Duration:");
+  console.log(
+    `  ${baseline.replicationStats.duration.toFixed(
+      0
+    )}ms → ${comparison.replicationStats.duration.toFixed(0)}ms (${
+      replicationDurationDelta > 0 ? "+" : ""
+    }${replicationDurationDelta.toFixed(2)}%)`
+  );
+
+  console.log("\nThroughput:");
+  console.log(
+    `  ${baseline.replicationStats.throughput.toFixed(
+      0
+    )} → ${comparison.replicationStats.throughput.toFixed(0)} runs/sec (${
+      throughputDelta > 0 ? "+" : ""
+    }${throughputDelta.toFixed(2)}%)`
+  );
+
+  console.log("\nEvent Loop Utilization (Mean):");
+  console.log(
+    `  ${baseline.eluStats.mean.toFixed(2)}% → ${comparison.eluStats.mean.toFixed(2)}% (${
+      eluMeanDelta > 0 ? "+" : ""
+    }${eluMeanDelta.toFixed(2)}%)`
+  );
+
+  console.log("\nEvent Loop Utilization (P99):");
+  console.log(
+    `  ${baseline.eluStats.p99.toFixed(2)}% → ${comparison.eluStats.p99.toFixed(2)}% (${
+      eluP99Delta > 0 ? "+" : ""
+    }${eluP99Delta.toFixed(2)}%)`
+  );
+
+  console.log(`\n${"=".repeat(80)}\n`);
+
+  // Return deltas for assertions if needed
+  return {
+    replicationDurationDelta,
+    throughputDelta,
+    eluMeanDelta,
+    eluP99Delta,
+  };
+}
+
+describe("RunsReplicationService Benchmark", () => {
+  containerTest.skipIf(process.env.BENCHMARKS_ENABLED !== "1")(
+    "should benchmark error fingerprinting performance impact",
+    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
+      // Enable replica identity for TaskRun table
+      await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
+
+      console.log("\n" + "=".repeat(80));
+      console.log("RUNS REPLICATION SERVICE - ERROR FINGERPRINTING BENCHMARK");
+      console.log("=".repeat(80));
+      console.log(`Configuration:`);
+      console.log(`  Total runs: ${BENCHMARK_CONFIG.NUM_RUNS}`);
+      console.log(`  Error rate: ${(BENCHMARK_CONFIG.ERROR_RATE * 100).toFixed(1)}%`);
+      console.log(
+        `  Expected errors: ~${Math.floor(BENCHMARK_CONFIG.NUM_RUNS * BENCHMARK_CONFIG.ERROR_RATE)}`
+      );
+      console.log(`  Producer batch size: ${BENCHMARK_CONFIG.PRODUCER_BATCH_SIZE}`);
+      console.log(`  Replication batch size: ${BENCHMARK_CONFIG.FLUSH_BATCH_SIZE}`);
+      console.log(`  Max flush concurrency: ${BENCHMARK_CONFIG.MAX_FLUSH_CONCURRENCY}`);
+      console.log("=".repeat(80) + "\n");
+
+      // Run benchmark WITHOUT error fingerprinting (baseline)
+      const baselineResult = await runBenchmark("baseline-no-fingerprinting", false, {
+        clickhouseContainer,
+        redisOptions,
+        postgresContainer,
+        prisma,
+      });
+
+      // Run benchmark WITH error fingerprinting
+      const fingerprintingResult = await runBenchmark("with-fingerprinting", true, {
+        clickhouseContainer,
+        redisOptions,
+        postgresContainer,
+        prisma,
+      });
+
+      // Compare results
+      const deltas = compareBenchmarks(baselineResult, fingerprintingResult);
+
+      // Basic assertions - just to ensure benchmarks completed successfully
+      expect(baselineResult.replicationStats.replicatedRuns).toBe(BENCHMARK_CONFIG.NUM_RUNS);
+      expect(fingerprintingResult.replicationStats.replicatedRuns).toBe(BENCHMARK_CONFIG.NUM_RUNS);
+
+      // Log final summary
+      console.log("BENCHMARK COMPLETE");
+      console.log(
+        `Fingerprinting impact on replication duration: ${
+          deltas.replicationDurationDelta > 0 ? "+" : ""
+        }${deltas.replicationDurationDelta.toFixed(2)}%`
+      );
+      console.log(
+        `Fingerprinting impact on throughput: ${
+          deltas.throughputDelta > 0 ? "+" : ""
+        }${deltas.throughputDelta.toFixed(2)}%`
+      );
+      console.log(
+        `Fingerprinting impact on ELU (mean): ${
+          deltas.eluMeanDelta > 0 ? "+" : ""
+        }${deltas.eluMeanDelta.toFixed(2)}%`
+      );
+      console.log(
+        `Fingerprinting impact on ELU (P99): ${
+          deltas.eluP99Delta > 0 ? "+" : ""
+        }${deltas.eluP99Delta.toFixed(2)}%`
+      );
+    }
+  );
+});
diff --git a/apps/webapp/test/runsReplicationService.part1.test.ts b/apps/webapp/test/runsReplicationService.part1.test.ts
index aaaa9dd1b8f..715d4583dc2 100644
--- a/apps/webapp/test/runsReplicationService.part1.test.ts
+++ b/apps/webapp/test/runsReplicationService.part1.test.ts
@@ -1,11 +1,10 @@
 import { ClickHouse } from "@internal/clickhouse";
 import { containerTest } from "@internal/testcontainers";
-import { Logger } from "@trigger.dev/core/logger";
 import { setTimeout } from "node:timers/promises";
 import { z } from "zod";
 import { TaskRunStatus } from "~/database-types";
 import { RunsReplicationService } from "~/services/runsReplicationService.server";
-import { createInMemoryTracing } from "./utils/tracing";
+import { createInMemoryTracing, createInMemoryMetrics } from "./utils/tracing";
 import superjson from "superjson";
 
 vi.setConfig({ testTimeout: 60_000 });
@@ -22,6 +21,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         compression: {
           request: true,
         },
+        logLevel: "warn",
       });
 
       const { tracer, exporter } = createInMemoryTracing();
@@ -40,6 +40,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
         tracer,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -72,7 +73,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Now we insert a row into the table
       const taskRun = await prisma.taskRun.create({
         data: {
           friendlyId: "run_1234",
@@ -86,12 +86,17 @@ describe("RunsReplicationService (part 1/2)", () => {
           organizationId: organization.id,
           environmentType: "DEVELOPMENT",
           engine: "V2",
+          annotations: {
+            triggerSource: "api",
+            triggerAction: "trigger",
+            rootTriggerSource: "dashboard",
+          },
+          isWarmStart: true,
         },
       });
 
       await setTimeout(1000);
 
-      // Check that the row was replicated to clickhouse
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication",
         query: "SELECT * FROM trigger_dev.task_runs_v2",
@@ -112,6 +117,9 @@ describe("RunsReplicationService (part 1/2)", () => {
           organization_id: organization.id,
           environment_type: "DEVELOPMENT",
           engine: "V2",
+          trigger_source: "api",
+          root_trigger_source: "dashboard",
+          is_warm_start: 1,
         })
       );
 
@@ -119,16 +127,8 @@ describe("RunsReplicationService (part 1/2)", () => {
 
       expect(spans.length).toBeGreaterThan(0);
 
-      const transactionSpan = spans.find(
-        (span) =>
-          span.name === "handle_transaction" &&
-          typeof span.attributes["transaction.events"] === "number" &&
-          span.attributes["transaction.events"] > 0
-      );
-
-      expect(transactionSpan).not.toBeNull();
-      expect(transactionSpan?.attributes["transaction.parse_duration_ms"]).toBeGreaterThan(0);
-      expect(transactionSpan?.attributes["transaction.parse_duration_ms"]).toBeLessThan(5);
+      const flushBatchSpan = spans.find((span) => span.name === "flushBatch");
+      expect(flushBatchSpan).toBeDefined();
 
       await runsReplicationService.stop();
     }
@@ -145,6 +145,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         compression: {
           request: true,
         },
+        logLevel: "warn",
       });
 
       const { tracer, exporter } = createInMemoryTracing();
@@ -163,6 +164,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
         tracer,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -197,7 +199,6 @@ describe("RunsReplicationService (part 1/2)", () => {
 
       const date = new Date();
 
-      // Now we insert a row into the table
       const taskRun = await prisma.taskRun.create({
         data: {
           friendlyId: "run_1234",
@@ -222,7 +223,6 @@ describe("RunsReplicationService (part 1/2)", () => {
 
       await setTimeout(1000);
 
-      // Check that the row was replicated to clickhouse
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication",
         query: "SELECT * FROM trigger_dev.task_runs_v2",
@@ -276,13 +276,14 @@ describe("RunsReplicationService (part 1/2)", () => {
   );
 
   containerTest(
-    "should not produce any handle_transaction spans when no TaskRun events are produced",
+    "should not produce any flush spans when no TaskRun events are produced",
     async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
       await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
 
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication",
+        logLevel: "warn",
       });
 
       const { tracer, exporter } = createInMemoryTracing();
@@ -301,6 +302,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
         tracer,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -337,9 +339,9 @@ describe("RunsReplicationService (part 1/2)", () => {
 
       const spans = exporter.getFinishedSpans();
 
-      const handleTransactionSpans = spans.filter((span) => span.name === "handle_transaction");
+      const flushBatchSpans = spans.filter((span) => span.name === "flushBatch");
 
-      expect(handleTransactionSpans.length).toBe(0);
+      expect(flushBatchSpans.length).toBe(0);
 
       await runsReplicationService.stop();
     }
@@ -353,6 +355,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-batching",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -368,6 +371,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -400,7 +404,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert a row into the table with a unique friendlyId
       const uniqueFriendlyId = `run_batching_${Date.now()}`;
       const taskRun = await prisma.taskRun.create({
         data: {
@@ -418,10 +421,8 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for replication
       await setTimeout(1000);
 
-      // Query ClickHouse for the replicated run
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication-batching",
         query: "SELECT * FROM trigger_dev.task_runs_v2 WHERE run_id = {run_id:String}",
@@ -458,6 +459,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-payload",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -473,6 +475,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -505,7 +508,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert a row into the table with a unique payload
       const uniquePayload = { foo: "payload-test", bar: Date.now() };
       const taskRun = await prisma.taskRun.create({
         data: {
@@ -524,10 +526,8 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for replication
       await setTimeout(1000);
 
-      // Query ClickHouse for the replicated payload
       const queryPayloads = clickhouse.reader.query({
         name: "runs-replication-payload",
         query: "SELECT * FROM trigger_dev.raw_task_runs_payload_v1 WHERE run_id = {run_id:String}",
@@ -560,6 +560,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-payload",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -575,6 +576,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -607,7 +609,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert a row into the table with a unique payload
       const largePayload = {
         foo: Array.from({ length: 100 }, () => "foo").join(""),
         bar: Array.from({ length: 100 }, () => "bar").join(""),
@@ -631,10 +632,8 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for replication
       await setTimeout(1000);
 
-      // Query ClickHouse for the replicated payload
       const queryPayloads = clickhouse.reader.query({
         name: "runs-replication-payload",
         query: "SELECT * FROM trigger_dev.raw_task_runs_payload_v1 WHERE run_id = {run_id:String}",
@@ -667,6 +666,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-update",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -682,6 +682,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -714,7 +715,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert a row into the table
       const uniqueFriendlyId = `run_update_${Date.now()}`;
       const taskRun = await prisma.taskRun.create({
         data: {
@@ -734,19 +734,15 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for initial replication
       await setTimeout(1000);
 
-      // Update the status field
       await prisma.taskRun.update({
         where: { id: taskRun.id },
         data: { status: TaskRunStatus.COMPLETED_SUCCESSFULLY },
       });
 
-      // Wait for replication
       await setTimeout(1000);
 
-      // Query ClickHouse for the replicated run
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication-update",
         query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL WHERE run_id = {run_id:String}",
@@ -777,6 +773,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-delete",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -792,6 +789,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -824,7 +822,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert a row into the table
       const uniqueFriendlyId = `run_delete_${Date.now()}`;
       const taskRun = await prisma.taskRun.create({
         data: {
@@ -844,18 +841,14 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for initial replication
       await setTimeout(1000);
 
-      // Delete the TaskRun
       await prisma.taskRun.delete({
         where: { id: taskRun.id },
       });
 
-      // Wait for replication
       await setTimeout(1000);
 
-      // Query ClickHouse for the replicated run using FINAL
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication-delete",
         query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL WHERE run_id = {run_id:String}",
@@ -880,6 +873,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-shutdown-handover",
+        logLevel: "warn",
       });
 
       // Service A
@@ -896,6 +890,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationServiceA.start();
@@ -928,13 +923,10 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert Run 1
       const run1Id = `run_shutdown_handover_1_${Date.now()}`;
 
-      // Initiate shutdown when the first insert message is received
       runsReplicationServiceA.events.on("message", async ({ message, service }) => {
         if (message.tag === "insert") {
-          // Initiate shutdown
           await service.shutdown();
         }
       });
@@ -957,7 +949,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert Run 2 after shutdown is initiated
       const run2Id = `run_shutdown_handover_2_${Date.now()}`;
       const taskRun2 = await prisma.taskRun.create({
         data: {
@@ -977,17 +968,13 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for flush to complete
       await setTimeout(1000);
 
-      // Query ClickHouse for both runs using FINAL
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication-shutdown-handover",
         query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL ORDER BY created_at ASC",
         schema: z.any(),
       });
-
-      // Make sure only the first run is in ClickHouse
       const [queryError, result] = await queryRuns({});
       expect(queryError).toBeNull();
       expect(result?.length).toBe(1);
@@ -1007,11 +994,11 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationServiceB.start();
 
-      // Wait for replication
       await setTimeout(1000);
 
       const [queryErrorB, resultB] = await queryRuns({});
@@ -1037,6 +1024,7 @@ describe("RunsReplicationService (part 1/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-shutdown-after-processed",
+        logLevel: "warn",
       });
 
       // Service A
@@ -1053,6 +1041,7 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationServiceA.start();
@@ -1085,7 +1074,6 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Insert Run 1
       const run1Id = `run_shutdown_after_processed_${Date.now()}`;
       const taskRun1 = await prisma.taskRun.create({
         data: {
@@ -1105,10 +1093,8 @@ describe("RunsReplicationService (part 1/2)", () => {
         },
       });
 
-      // Wait for replication to ensure transaction is processed
       await setTimeout(1000);
 
-      // Query ClickHouse for the run using FINAL
       const queryRuns = clickhouse.reader.query({
         name: "runs-replication-shutdown-after-processed",
         query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL WHERE run_id = {run_id:String}",
@@ -1121,12 +1107,10 @@ describe("RunsReplicationService (part 1/2)", () => {
       expect(resultA?.length).toBe(1);
       expect(resultA?.[0]).toEqual(expect.objectContaining({ run_id: taskRun1.id }));
 
-      // Shutdown after all transactions are processed
       await runsReplicationServiceA.shutdown();
 
-      await setTimeout(500); // Give a moment for shutdown
+      await setTimeout(500);
 
-      // Insert another run
       const taskRun2 = await prisma.taskRun.create({
         data: {
           friendlyId: `run_shutdown_after_processed_${Date.now()}`,
@@ -1159,13 +1143,13 @@ describe("RunsReplicationService (part 1/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationServiceB.start();
 
       await setTimeout(1000);
 
-      // Query ClickHouse for the second run
       const [queryErrorB, resultB] = await queryRuns({ run_id: taskRun2.id });
       expect(queryErrorB).toBeNull();
       expect(resultB?.length).toBe(1);
@@ -1174,4 +1158,200 @@ describe("RunsReplicationService (part 1/2)", () => {
       await runsReplicationServiceB.stop();
     }
   );
+
+  containerTest(
+    "should record metrics with correct values when replicating runs",
+    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
+      await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
+
+      const clickhouse = new ClickHouse({
+        url: clickhouseContainer.getConnectionUrl(),
+        name: "runs-replication-metrics",
+        logLevel: "warn",
+      });
+
+      const { tracer } = createInMemoryTracing();
+      const metricsHelper = createInMemoryMetrics();
+
+      const runsReplicationService = new RunsReplicationService({
+        clickhouse,
+        pgConnectionUrl: postgresContainer.getConnectionUri(),
+        serviceName: "runs-replication-metrics",
+        slotName: "task_runs_to_clickhouse_v1",
+        publicationName: "task_runs_to_clickhouse_v1_publication",
+        redisOptions,
+        maxFlushConcurrency: 2,
+        flushIntervalMs: 100,
+        flushBatchSize: 5,
+        leaderLockTimeoutMs: 5000,
+        leaderLockExtendIntervalMs: 1000,
+        ackIntervalSeconds: 5,
+        tracer,
+        meter: metricsHelper.meter,
+        logLevel: "warn",
+      });
+
+      await runsReplicationService.start();
+
+      const organization = await prisma.organization.create({
+        data: {
+          title: "test-metrics",
+          slug: "test-metrics",
+        },
+      });
+
+      const project = await prisma.project.create({
+        data: {
+          name: "test-metrics",
+          slug: "test-metrics",
+          organizationId: organization.id,
+          externalRef: "test-metrics",
+        },
+      });
+
+      const runtimeEnvironment = await prisma.runtimeEnvironment.create({
+        data: {
+          slug: "test-metrics",
+          type: "DEVELOPMENT",
+          projectId: project.id,
+          organizationId: organization.id,
+          apiKey: "test-metrics",
+          pkApiKey: "test-metrics",
+          shortcode: "test-metrics",
+        },
+      });
+
+      const now = Date.now();
+      const createdRuns: string[] = [];
+
+      for (let i = 0; i < 5; i++) {
+        const run = await prisma.taskRun.create({
+          data: {
+            friendlyId: `run_metrics_${now}_${i}`,
+            taskIdentifier: "my-task-metrics",
+            payload: JSON.stringify({ index: i }),
+            payloadType: "application/json",
+            traceId: `metrics-${now}-${i}`,
+            spanId: `metrics-${now}-${i}`,
+            queue: "test-metrics",
+            runtimeEnvironmentId: runtimeEnvironment.id,
+            projectId: project.id,
+            organizationId: organization.id,
+            environmentType: "DEVELOPMENT",
+            engine: "V2",
+            status: "PENDING",
+          },
+        });
+        createdRuns.push(run.id);
+      }
+
+      await setTimeout(1000);
+
+      for (let i = 0; i < 3; i++) {
+        await prisma.taskRun.update({
+          where: { id: createdRuns[i] },
+          data: { status: "EXECUTING" },
+        });
+      }
+
+      await setTimeout(1000);
+
+      for (let i = 0; i < 2; i++) {
+        await prisma.taskRun.update({
+          where: { id: createdRuns[i] },
+          data: {
+            status: "COMPLETED_SUCCESSFULLY",
+            completedAt: new Date(),
+            output: JSON.stringify({ result: "success" }),
+            outputType: "application/json",
+          },
+        });
+      }
+
+      await setTimeout(1000);
+
+      const metrics = await metricsHelper.getMetrics();
+
+      function getMetricData(name: string) {
+        for (const resourceMetrics of metrics) {
+          for (const scopeMetrics of resourceMetrics.scopeMetrics) {
+            for (const metric of scopeMetrics.metrics) {
+              if (metric.descriptor.name === name) {
+                return metric;
+              }
+            }
+          }
+        }
+        return null;
+      }
+
+      function sumCounterValues(metric: any): number {
+        if (!metric?.dataPoints) return 0;
+        return metric.dataPoints.reduce((sum: number, dp: any) => sum + (dp.value || 0), 0);
+      }
+
+      function histogramHasData(metric: any): boolean {
+        if (!metric?.dataPoints || metric.dataPoints.length === 0) return false;
+        return metric.dataPoints.some((dp: any) => {
+          return (
+            (typeof dp.count === "number" && dp.count > 0) ||
+            (typeof dp.value?.count === "number" && dp.value.count > 0) ||
+            (Array.isArray(dp.buckets?.counts) && dp.buckets.counts.some((c: number) => c > 0)) ||
+            (typeof dp.sum === "number" && dp.sum > 0) ||
+            typeof dp.min === "number" ||
+            typeof dp.max === "number"
+          );
+        });
+      }
+
+      function getCounterAttributeValues(metric: any, attributeName: string): unknown[] {
+        if (!metric?.dataPoints) return [];
+        return metric.dataPoints
+          .filter((dp: any) => dp.attributes?.[attributeName] !== undefined)
+          .map((dp: any) => dp.attributes[attributeName]);
+      }
+
+      const batchesFlushed = getMetricData("runs_replication.batches_flushed");
+      expect(batchesFlushed).not.toBeNull();
+      const totalBatchesFlushed = sumCounterValues(batchesFlushed);
+      expect(totalBatchesFlushed).toBeGreaterThanOrEqual(1);
+
+      const successAttributeValues = getCounterAttributeValues(batchesFlushed, "success");
+      expect(successAttributeValues.length).toBeGreaterThanOrEqual(1);
+
+      const taskRunsInserted = getMetricData("runs_replication.task_runs_inserted");
+      expect(taskRunsInserted).not.toBeNull();
+      const totalTaskRunsInserted = sumCounterValues(taskRunsInserted);
+      expect(totalTaskRunsInserted).toBeGreaterThanOrEqual(5);
+
+      const payloadsInserted = getMetricData("runs_replication.payloads_inserted");
+      expect(payloadsInserted).not.toBeNull();
+      const totalPayloadsInserted = sumCounterValues(payloadsInserted);
+      expect(totalPayloadsInserted).toBeGreaterThanOrEqual(1);
+
+      const eventsProcessed = getMetricData("runs_replication.events_processed");
+      expect(eventsProcessed).not.toBeNull();
+      const totalEventsProcessed = sumCounterValues(eventsProcessed);
+      expect(totalEventsProcessed).toBeGreaterThanOrEqual(1);
+
+      const eventTypes = getCounterAttributeValues(eventsProcessed, "event_type");
+      expect(eventTypes.length).toBeGreaterThanOrEqual(1);
+      expect(eventTypes).toContain("insert");
+
+      const batchSize = getMetricData("runs_replication.batch_size");
+      expect(batchSize).not.toBeNull();
+      expect(histogramHasData(batchSize)).toBe(true);
+
+      const replicationLag = getMetricData("runs_replication.replication_lag_ms");
+      expect(replicationLag).not.toBeNull();
+      expect(histogramHasData(replicationLag)).toBe(true);
+
+      const flushDuration = getMetricData("runs_replication.flush_duration_ms");
+      expect(flushDuration).not.toBeNull();
+      expect(histogramHasData(flushDuration)).toBe(true);
+
+      await runsReplicationService.stop();
+      await metricsHelper.shutdown();
+    }
+  );
 });
diff --git a/apps/webapp/test/runsReplicationService.part2.test.ts b/apps/webapp/test/runsReplicationService.part2.test.ts
index e08b579738a..a93f99f246b 100644
--- a/apps/webapp/test/runsReplicationService.part2.test.ts
+++ b/apps/webapp/test/runsReplicationService.part2.test.ts
@@ -1,4 +1,4 @@
-import { ClickHouse } from "@internal/clickhouse";
+import { ClickHouse, getTaskRunField, getPayloadField } from "@internal/clickhouse";
 import { containerTest } from "@internal/testcontainers";
 import { Logger } from "@trigger.dev/core/logger";
 import { readFile } from "node:fs/promises";
@@ -18,6 +18,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-shutdown-handover",
+        logLevel: "warn",
       });
 
       // Service A
@@ -35,7 +36,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockExtendIntervalMs: 1000,
         leaderLockAcquireAdditionalTimeMs: 10_000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-shutdown-handover-a", "debug"),
+        logger: new Logger("runs-replication-shutdown-handover-a", "warn"),
       });
 
       await runsReplicationServiceA.start();
@@ -55,7 +56,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockExtendIntervalMs: 1000,
         leaderLockAcquireAdditionalTimeMs: 10_000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-shutdown-handover-b", "debug"),
+        logger: new Logger("runs-replication-shutdown-handover-b", "warn"),
       });
 
       // Now we need to initiate starting the second service, and after 6 seconds, we need to shutdown the first service
@@ -147,6 +148,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-stress-bulk-insert",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -162,7 +164,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-stress-bulk-insert", "info"),
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -261,6 +263,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-stress-bulk-insert",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -276,7 +279,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-stress-bulk-insert", "info"),
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -381,6 +384,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-multi-event-tx",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -396,6 +400,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -513,6 +518,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-long-tx",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -528,7 +534,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-long-tx", "info"),
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -619,6 +625,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-stress-bulk-insert",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -634,7 +641,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-stress-bulk-insert", "info"),
+        logLevel: "warn",
       });
 
       await runsReplicationService.start();
@@ -787,6 +794,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-merge-batch",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -802,7 +810,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-merge-batch", "info"),
+        logLevel: "warn",
       });
 
       // Listen to batchFlushed events to verify merging
@@ -889,17 +897,14 @@ describe("RunsReplicationService (part 2/2)", () => {
       await setTimeout(1000);
 
       expect(batchFlushedEvents?.[0].taskRunInserts).toHaveLength(2);
-      expect(batchFlushedEvents?.[0].taskRunInserts[0]).toEqual(
-        expect.objectContaining({
-          run_id: run.id,
-          status: "PENDING_VERSION",
-        })
+      // Use getTaskRunField for type-safe array access
+      expect(getTaskRunField(batchFlushedEvents![0].taskRunInserts[0], "run_id")).toEqual(run.id);
+      expect(getTaskRunField(batchFlushedEvents![0].taskRunInserts[0], "status")).toEqual(
+        "PENDING_VERSION"
       );
-      expect(batchFlushedEvents?.[0].taskRunInserts[1]).toEqual(
-        expect.objectContaining({
-          run_id: run.id,
-          status: "COMPLETED_SUCCESSFULLY",
-        })
+      expect(getTaskRunField(batchFlushedEvents![0].taskRunInserts[1], "run_id")).toEqual(run.id);
+      expect(getTaskRunField(batchFlushedEvents![0].taskRunInserts[1], "status")).toEqual(
+        "COMPLETED_SUCCESSFULLY"
       );
 
       await runsReplicationService.stop();
@@ -914,6 +919,7 @@ describe("RunsReplicationService (part 2/2)", () => {
       const clickhouse = new ClickHouse({
         url: clickhouseContainer.getConnectionUrl(),
         name: "runs-replication-sorting",
+        logLevel: "warn",
       });
 
       const runsReplicationService = new RunsReplicationService({
@@ -929,7 +935,7 @@ describe("RunsReplicationService (part 2/2)", () => {
         leaderLockTimeoutMs: 5000,
         leaderLockExtendIntervalMs: 1000,
         ackIntervalSeconds: 5,
-        logger: new Logger("runs-replication-sorting", "info"),
+        logLevel: "warn",
       });
 
       // Listen to batchFlushed events to verify sorting
@@ -1066,22 +1072,22 @@ describe("RunsReplicationService (part 2/2)", () => {
 
       // Verify sorting order: organization_id, project_id, environment_id, created_at, run_id
       for (let i = 1; i < batchFlushedEvents[0]?.taskRunInserts.length; i++) {
-        const prev = batchFlushedEvents[0]?.taskRunInserts[i - 1];
-        const curr = batchFlushedEvents[0]?.taskRunInserts[i];
+        const prev = batchFlushedEvents[0]!.taskRunInserts[i - 1];
+        const curr = batchFlushedEvents[0]!.taskRunInserts[i];
 
         const prevKey = [
-          prev.organization_id,
-          prev.project_id,
-          prev.environment_id,
-          prev.created_at,
-          prev.run_id,
+          getTaskRunField(prev, "organization_id"),
+          getTaskRunField(prev, "project_id"),
+          getTaskRunField(prev, "environment_id"),
+          getTaskRunField(prev, "created_at"),
+          getTaskRunField(prev, "run_id"),
         ];
         const currKey = [
-          curr.organization_id,
-          curr.project_id,
-          curr.environment_id,
-          curr.created_at,
-          curr.run_id,
+          getTaskRunField(curr, "organization_id"),
+          getTaskRunField(curr, "project_id"),
+          getTaskRunField(curr, "environment_id"),
+          getTaskRunField(curr, "created_at"),
+          getTaskRunField(curr, "run_id"),
         ];
 
         const keysAreEqual = prevKey.every((val, idx) => val === currKey[idx]);
@@ -1109,12 +1115,322 @@ describe("RunsReplicationService (part 2/2)", () => {
 
       // Verify payloadInserts are also sorted by run_id
       for (let i = 1; i < batchFlushedEvents[0]?.payloadInserts.length; i++) {
-        const prev = batchFlushedEvents[0]?.payloadInserts[i - 1];
-        const curr = batchFlushedEvents[0]?.payloadInserts[i];
-        expect(prev.run_id <= curr.run_id).toBeTruthy();
+        const prev = batchFlushedEvents[0]!.payloadInserts[i - 1];
+        const curr = batchFlushedEvents[0]!.payloadInserts[i];
+        expect(getPayloadField(prev, "run_id") <= getPayloadField(curr, "run_id")).toBeTruthy();
       }
 
       await runsReplicationService.stop();
     }
   );
+
+  containerTest(
+    "should exhaustively replicate all TaskRun columns to ClickHouse",
+    async ({ clickhouseContainer, redisOptions, postgresContainer, prisma }) => {
+      await prisma.$executeRawUnsafe(`ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;`);
+
+      const clickhouse = new ClickHouse({
+        url: clickhouseContainer.getConnectionUrl(),
+        name: "runs-replication-exhaustive",
+        logLevel: "warn",
+      });
+
+      const runsReplicationService = new RunsReplicationService({
+        clickhouse,
+        pgConnectionUrl: postgresContainer.getConnectionUri(),
+        serviceName: "runs-replication-exhaustive",
+        slotName: "task_runs_to_clickhouse_v1",
+        publicationName: "task_runs_to_clickhouse_v1_publication",
+        redisOptions,
+        maxFlushConcurrency: 1,
+        flushIntervalMs: 100,
+        flushBatchSize: 1,
+        leaderLockTimeoutMs: 5000,
+        leaderLockExtendIntervalMs: 1000,
+        ackIntervalSeconds: 5,
+        logLevel: "warn",
+      });
+
+      await runsReplicationService.start();
+
+      const organization = await prisma.organization.create({
+        data: {
+          title: "test-exhaustive",
+          slug: "test-exhaustive",
+        },
+      });
+
+      const project = await prisma.project.create({
+        data: {
+          name: "test-exhaustive",
+          slug: "test-exhaustive",
+          organizationId: organization.id,
+          externalRef: "test-exhaustive",
+        },
+      });
+
+      const runtimeEnvironment = await prisma.runtimeEnvironment.create({
+        data: {
+          slug: "test-exhaustive",
+          type: "PRODUCTION",
+          projectId: project.id,
+          organizationId: organization.id,
+          apiKey: "test-exhaustive",
+          pkApiKey: "test-exhaustive",
+          shortcode: "test-exhaustive",
+        },
+      });
+
+      // Create a batch for the batchId field
+      const batch = await prisma.batchTaskRun.create({
+        data: {
+          friendlyId: "batch_exhaustive",
+          runtimeEnvironmentId: runtimeEnvironment.id,
+          status: "PENDING",
+        },
+      });
+
+      // Create a root run for the rootTaskRunId field
+      const rootRun = await prisma.taskRun.create({
+        data: {
+          friendlyId: "run_root_exhaustive",
+          taskIdentifier: "root-task",
+          payload: JSON.stringify({ root: true }),
+          traceId: "root-trace-id",
+          spanId: "root-span-id",
+          queue: "root-queue",
+          runtimeEnvironmentId: runtimeEnvironment.id,
+          projectId: project.id,
+          organizationId: organization.id,
+          environmentType: "PRODUCTION",
+          engine: "V2",
+        },
+      });
+
+      // Create a parent run for the parentTaskRunId field
+      const parentRun = await prisma.taskRun.create({
+        data: {
+          friendlyId: "run_parent_exhaustive",
+          taskIdentifier: "parent-task",
+          payload: JSON.stringify({ parent: true }),
+          traceId: "parent-trace-id",
+          spanId: "parent-span-id",
+          queue: "parent-queue",
+          runtimeEnvironmentId: runtimeEnvironment.id,
+          projectId: project.id,
+          organizationId: organization.id,
+          environmentType: "PRODUCTION",
+          engine: "V2",
+          rootTaskRunId: rootRun.id,
+          depth: 1,
+        },
+      });
+
+      // Set up all the dates we'll use
+      const now = new Date();
+      const createdAt = new Date(now.getTime() - 10000);
+      const updatedAt = new Date(now.getTime() - 5000);
+      const startedAt = new Date(now.getTime() - 8000);
+      const executedAt = new Date(now.getTime() - 7500);
+      const completedAt = new Date(now.getTime() - 6000);
+      const delayUntil = new Date(now.getTime() - 9000);
+      const queuedAt = new Date(now.getTime() - 9500);
+      const expiredAt = null; // Not expired
+
+      // Create the main task run with ALL fields populated
+      const taskRun = await prisma.taskRun.create({
+        data: {
+          // Core identifiers
+          friendlyId: "run_exhaustive_test",
+          taskIdentifier: "exhaustive-task",
+
+          // Environment/project/org
+          runtimeEnvironmentId: runtimeEnvironment.id,
+          projectId: project.id,
+          organizationId: organization.id,
+          environmentType: "PRODUCTION",
+
+          // Engine and execution
+          engine: "V2",
+          status: "COMPLETED_SUCCESSFULLY",
+          attemptNumber: 3,
+          queue: "exhaustive-queue",
+          workerQueue: "exhaustive-worker-queue",
+
+          // Relationships
+          // Note: scheduleId is not set to test empty string handling
+          batchId: batch.id,
+          rootTaskRunId: rootRun.id,
+          parentTaskRunId: parentRun.id,
+          depth: 2,
+
+          // Timestamps
+          createdAt,
+          updatedAt,
+          startedAt,
+          executedAt,
+          completedAt,
+          delayUntil,
+          queuedAt,
+          expiredAt,
+
+          // Payload and output
+          payload: JSON.stringify({ input: "test-payload" }),
+          payloadType: "application/json",
+          output: JSON.stringify({ result: "test-output" }),
+          outputType: "application/json",
+          error: { message: "test error", name: "TestError" },
+
+          // Tracing
+          traceId: "exhaustive-trace-id-12345",
+          spanId: "exhaustive-span-id-67890",
+
+          // Versioning
+          taskVersion: "1.2.3",
+          sdkVersion: "3.0.0",
+          cliVersion: "2.5.1",
+
+          // Execution settings
+          machinePreset: "large-1x",
+          idempotencyKey: "exhaustive-idempotency-key-hashed",
+          idempotencyKeyOptions: {
+            key: "exhaustive-idempotency-key",
+            scope: "run",
+          },
+          ttl: "1h",
+          isTest: true,
+          concurrencyKey: "exhaustive-concurrency-key",
+          maxDurationInSeconds: 3600,
+
+          // Tags and bulk actions
+          runTags: ["tag1", "tag2", "exhaustive-tag"],
+          bulkActionGroupIds: ["bulk-group-1", "bulk-group-2"],
+
+          // Usage metrics
+          usageDurationMs: 12345,
+          costInCents: 50,
+          baseCostInCents: 25,
+        },
+      });
+
+      // Wait for replication
+      await setTimeout(1500);
+
+      // Query ClickHouse directly to get all columns
+      const queryRuns = clickhouse.reader.query({
+        name: "exhaustive-replication-test",
+        query: "SELECT * FROM trigger_dev.task_runs_v2 FINAL WHERE run_id = {run_id:String}",
+        schema: z.any(),
+        params: z.object({ run_id: z.string() }),
+      });
+
+      const [queryError, result] = await queryRuns({ run_id: taskRun.id });
+
+      expect(queryError).toBeNull();
+      expect(result).toHaveLength(1);
+
+      const clickhouseRun = result![0];
+
+      // Exhaustively verify each column
+      // Core identifiers
+      expect(clickhouseRun.run_id).toBe(taskRun.id);
+      expect(clickhouseRun.friendly_id).toBe("run_exhaustive_test");
+      expect(clickhouseRun.task_identifier).toBe("exhaustive-task");
+
+      // Environment/project/org
+      expect(clickhouseRun.environment_id).toBe(runtimeEnvironment.id);
+      expect(clickhouseRun.project_id).toBe(project.id);
+      expect(clickhouseRun.organization_id).toBe(organization.id);
+      expect(clickhouseRun.environment_type).toBe("PRODUCTION");
+
+      // Engine and execution
+      expect(clickhouseRun.engine).toBe("V2");
+      expect(clickhouseRun.status).toBe("COMPLETED_SUCCESSFULLY");
+      expect(clickhouseRun.attempt).toBe(3);
+      expect(clickhouseRun.queue).toBe("exhaustive-queue");
+      expect(clickhouseRun.worker_queue).toBe("exhaustive-worker-queue");
+
+      // Relationships
+      expect(clickhouseRun.schedule_id).toBe(""); // Empty when not set
+      expect(clickhouseRun.batch_id).toBe(batch.id);
+      expect(clickhouseRun.root_run_id).toBe(rootRun.id);
+      expect(clickhouseRun.parent_run_id).toBe(parentRun.id);
+      expect(clickhouseRun.depth).toBe(2);
+
+      // Timestamps (ClickHouse returns DateTime64 as strings in UTC without 'Z' suffix)
+      // Helper to parse ClickHouse timestamp strings to milliseconds
+      function parseClickhouseTimestamp(ts: string | null): number | null {
+        if (ts === null || ts === "1970-01-01 00:00:00.000") return null;
+        return new Date(ts + "Z").getTime();
+      }
+
+      expect(parseClickhouseTimestamp(clickhouseRun.created_at)).toBe(createdAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.updated_at)).toBe(updatedAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.started_at)).toBe(startedAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.executed_at)).toBe(executedAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.completed_at)).toBe(completedAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.delay_until)).toBe(delayUntil.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.queued_at)).toBe(queuedAt.getTime());
+      expect(parseClickhouseTimestamp(clickhouseRun.expired_at)).toBeNull();
+
+      // Output (parsed JSON)
+      expect(clickhouseRun.output).toEqual({ data: { result: "test-output" } });
+
+      // Error
+      expect(clickhouseRun.error).toEqual({
+        data: { message: "test error", name: "TestError" },
+      });
+
+      // Tracing
+      expect(clickhouseRun.trace_id).toBe("exhaustive-trace-id-12345");
+      expect(clickhouseRun.span_id).toBe("exhaustive-span-id-67890");
+
+      // Versioning
+      expect(clickhouseRun.task_version).toBe("1.2.3");
+      expect(clickhouseRun.sdk_version).toBe("3.0.0");
+      expect(clickhouseRun.cli_version).toBe("2.5.1");
+
+      // Execution settings
+      expect(clickhouseRun.machine_preset).toBe("large-1x");
+      expect(clickhouseRun.idempotency_key).toBe("exhaustive-idempotency-key-hashed");
+      expect(clickhouseRun.idempotency_key_user).toBe("exhaustive-idempotency-key");
+      expect(clickhouseRun.idempotency_key_scope).toBe("run");
+      expect(clickhouseRun.expiration_ttl).toBe("1h");
+      expect(clickhouseRun.is_test).toBe(1); // ClickHouse returns booleans as integers
+      expect(clickhouseRun.concurrency_key).toBe("exhaustive-concurrency-key");
+      expect(clickhouseRun.max_duration_in_seconds).toBe(3600);
+
+      // Tags and bulk actions
+      expect(clickhouseRun.tags).toEqual(["tag1", "tag2", "exhaustive-tag"]);
+      expect(clickhouseRun.bulk_action_group_ids).toEqual(["bulk-group-1", "bulk-group-2"]);
+
+      // Usage metrics
+      expect(clickhouseRun.usage_duration_ms).toBe(12345);
+      expect(clickhouseRun.cost_in_cents).toBe(50);
+      expect(clickhouseRun.base_cost_in_cents).toBe(25);
+
+      // Internal ClickHouse columns
+      expect(clickhouseRun._is_deleted).toBe(0);
+      expect(clickhouseRun._version).toBeDefined();
+      expect(typeof clickhouseRun._version).toBe("number"); // ClickHouse returns UInt64 as number
+
+      // Also verify the payload was inserted into the payloads table
+      const queryPayloads = clickhouse.reader.query({
+        name: "exhaustive-payload-test",
+        query: "SELECT * FROM trigger_dev.raw_task_runs_payload_v1 WHERE run_id = {run_id:String}",
+        schema: z.any(),
+        params: z.object({ run_id: z.string() }),
+      });
+
+      const [payloadError, payloadResult] = await queryPayloads({ run_id: taskRun.id });
+
+      expect(payloadError).toBeNull();
+      expect(payloadResult).toHaveLength(1);
+      expect(payloadResult![0].run_id).toBe(taskRun.id);
+      expect(parseClickhouseTimestamp(payloadResult![0].created_at)).toBe(createdAt.getTime());
+      expect(payloadResult![0].payload).toEqual({ data: { input: "test-payload" } });
+
+      await runsReplicationService.stop();
+    }
+  );
 });
diff --git a/apps/webapp/test/slackErrorAlerts.test.ts b/apps/webapp/test/slackErrorAlerts.test.ts
new file mode 100644
index 00000000000..b86856adc4c
--- /dev/null
+++ b/apps/webapp/test/slackErrorAlerts.test.ts
@@ -0,0 +1,403 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import type { PrismaClient } from "@trigger.dev/database";
+
+let DeliverErrorGroupAlertService: typeof import("../app/v3/services/alerts/deliverErrorGroupAlert.server.js").DeliverErrorGroupAlertService;
+let prisma: PrismaClient;
+let getSecretStore: typeof import("../app/services/secrets/secretStore.server.js").getSecretStore;
+
+type ErrorAlertPayload = {
+  channelId: string;
+  projectId: string;
+  classification: "new_issue" | "regression" | "unignored";
+  error: {
+    fingerprint: string;
+    environmentId: string;
+    environmentSlug: string;
+    environmentName: string;
+    taskIdentifier: string;
+    errorType: string;
+    errorMessage: string;
+    sampleStackTrace: string;
+    firstSeen: string;
+    lastSeen: string;
+    occurrenceCount: number;
+  };
+};
+
+let testChannelId: string;
+let testProjectId: string;
+let testOrganizationId: string;
+let testSecretKey: string;
+let testSecretReferenceId: string;
+
+// Helper to create mock error payloads
+function createMockErrorPayload(
+  overrides: Partial<Omit<ErrorAlertPayload, "error">> & {
+    error?: Partial<ErrorAlertPayload["error"]>;
+  } = {}
+): ErrorAlertPayload {
+  const { error: errorOverrides, ...payloadOverrides } = overrides;
+
+  const defaultError: ErrorAlertPayload["error"] = {
+    fingerprint: "fp_test_" + Date.now(),
+    environmentId: "env_test_dev",
+    environmentSlug: "dev",
+    environmentName: "Development",
+    taskIdentifier: "process-payment",
+    errorType: "TypeError",
+    errorMessage: "Cannot read property 'id' of undefined",
+    sampleStackTrace: `TypeError: Cannot read property 'id' of undefined
+    at processPayment (src/tasks/payment.ts:42:15)
+    at Object.run (src/tasks/payment.ts:15:20)
+    at TaskExecutor.execute (node_modules/@trigger.dev/core/dist/index.js:234:18)`,
+    firstSeen: Date.now().toString(),
+    lastSeen: Date.now().toString(),
+    occurrenceCount: 42,
+    ...errorOverrides,
+  };
+
+  return {
+    channelId: testChannelId,
+    projectId: testProjectId,
+    classification: "new_issue",
+    ...payloadOverrides,
+    error: defaultError,
+  };
+}
+
+// Skip tests if Slack credentials not configured
+const hasSlackCredentials =
+  !!process.env.TEST_SLACK_CHANNEL_ID &&
+  !!process.env.TEST_SLACK_BOT_TOKEN;
+
+describe.skipIf(!hasSlackCredentials)("Slack Error Alert Visual Tests", () => {
+  beforeAll(async () => {
+    const dbModule = await import("../app/db.server.js");
+    prisma = dbModule.prisma;
+    const secretModule = await import("../app/services/secrets/secretStore.server.js");
+    getSecretStore = secretModule.getSecretStore;
+    const alertModule = await import(
+      "../app/v3/services/alerts/deliverErrorGroupAlert.server.js"
+    );
+    DeliverErrorGroupAlertService = alertModule.DeliverErrorGroupAlertService;
+
+    const organization = await prisma.organization.create({
+      data: {
+        title: "Slack Test Org",
+        slug: "slack-test-org-" + Date.now(),
+      },
+    });
+    testOrganizationId = organization.id;
+
+    // Create test project
+    const project = await prisma.project.create({
+      data: {
+        name: "Slack Test Project",
+        slug: "slack-test-project-" + Date.now(),
+        externalRef: "proj_slack_test_" + Date.now(),
+        organizationId: organization.id,
+      },
+    });
+    testProjectId = project.id;
+
+    const secretStore = getSecretStore("DATABASE");
+    testSecretKey = `slack-test-token-${Date.now()}`;
+
+    await secretStore.setSecret(testSecretKey, {
+      botAccessToken: process.env.TEST_SLACK_BOT_TOKEN!,
+    });
+
+    const secretReference = await prisma.secretReference.create({
+      data: {
+        key: testSecretKey,
+        provider: "DATABASE",
+      },
+    });
+    testSecretReferenceId = secretReference.id;
+
+    // Create Slack organization integration
+    const integration = await prisma.organizationIntegration.create({
+      data: {
+        friendlyId: "integration_test_" + Date.now(),
+        organizationId: organization.id,
+        service: "SLACK",
+        integrationData: {},
+        tokenReferenceId: secretReference.id,
+      },
+    });
+
+    // Create alert channel
+    const channel = await prisma.projectAlertChannel.create({
+      data: {
+        friendlyId: "channel_test_" + Date.now(),
+        name: "Test Slack Channel",
+        type: "SLACK",
+        enabled: true,
+        projectId: project.id,
+        integrationId: integration.id,
+        properties: {
+          channelId: process.env.TEST_SLACK_CHANNEL_ID!,
+          channelName: "test-slack-alerts",
+          integrationId: integration.id,
+        },
+      },
+    });
+    testChannelId = channel.id;
+  });
+
+  afterAll(async () => {
+    if (testChannelId) {
+      await prisma.projectAlertChannel.deleteMany({
+        where: { id: testChannelId },
+      });
+    }
+    if (testOrganizationId) {
+      await prisma.organizationIntegration.deleteMany({
+        where: { organizationId: testOrganizationId },
+      });
+    }
+    if (testSecretReferenceId) {
+      await prisma.secretReference.deleteMany({
+        where: { id: testSecretReferenceId },
+      });
+    }
+    if (testSecretKey) {
+      const secretStore = getSecretStore("DATABASE");
+      await secretStore.deleteSecret(testSecretKey);
+    }
+    if (testProjectId) {
+      await prisma.project.deleteMany({
+        where: { id: testProjectId },
+      });
+    }
+    if (testOrganizationId) {
+      await prisma.organization.deleteMany({
+        where: { id: testOrganizationId },
+      });
+    }
+  });
+
+  test("new_issue classification", async () => {
+    const payload = createMockErrorPayload({
+      classification: "new_issue",
+      error: {
+        taskIdentifier: "process-order",
+        errorMessage: "Failed to process order due to invalid payment method",
+        errorType: "PaymentError",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    // Message sent - check Slack channel visually
+    expect(true).toBe(true);
+  });
+
+  test("regression classification", async () => {
+    const payload = createMockErrorPayload({
+      classification: "regression",
+      error: {
+        taskIdentifier: "send-email",
+        errorMessage: "SMTP connection timeout after 30 seconds",
+        errorType: "TimeoutError",
+        occurrenceCount: 156,
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("unignored (resurfaced) classification", async () => {
+    const payload = createMockErrorPayload({
+      classification: "unignored",
+      error: {
+        taskIdentifier: "sync-database",
+        errorMessage: "Connection pool exhausted",
+        errorType: "DatabaseError",
+        occurrenceCount: 99,
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("short error message", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorMessage: "Not found",
+        errorType: "NotFoundError",
+        sampleStackTrace: "NotFoundError: Not found\n    at findUser (src/db.ts:10:5)",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("long stack trace", async () => {
+    const longStackTrace = `ReferenceError: processData is not defined
+    at handler (src/tasks/data-processor.ts:125:15)
+    at async TaskRunner.execute (node_modules/@trigger.dev/sdk/dist/runner.js:89:12)
+    at async WorkerThread.processTask (node_modules/@trigger.dev/sdk/dist/worker.js:234:18)
+    at async WorkerPool.run (src/lib/worker-pool.ts:56:10)
+    at async TaskQueue.dequeue (src/lib/queue.ts:142:8)
+    at async Orchestrator.processNextTask (src/orchestrator.ts:98:5)
+    at async Orchestrator.start (src/orchestrator.ts:45:7)
+    at async main (src/index.ts:12:3)
+    at Object.<anonymous> (src/index.ts:20:1)
+    at Module._compile (node:internal/modules/cjs/loader:1376:14)
+    at Module._extensions..js (node:internal/modules/cjs/loader:1435:10)
+    at Module.load (node:internal/modules/cjs/loader:1207:32)
+    at Module._load (node:internal/modules/cjs/loader:1023:12)
+    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:135:12)
+    at node:internal/main/run_main_module:28:49`;
+
+    const payload = createMockErrorPayload({
+      error: {
+        errorType: "ReferenceError",
+        errorMessage: "processData is not defined",
+        sampleStackTrace: longStackTrace,
+        taskIdentifier: "data-processor",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("very long error message (triggers truncation)", async () => {
+    // Create a message that's over 3000 characters
+    const longMessage = "x".repeat(3500);
+    const longStackTrace = `Error: ${longMessage}
+    at verylongfunctionname (src/tasks/long-task.ts:1:1)
+    ${"    at stackframe (file.ts:1:1)\n".repeat(100)}`;
+
+    const payload = createMockErrorPayload({
+      error: {
+        errorMessage: longMessage,
+        sampleStackTrace: longStackTrace,
+        taskIdentifier: "long-error-task",
+        errorType: "Error",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    // Should see truncation message in Slack
+    expect(true).toBe(true);
+  });
+
+  test("special characters in error", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorMessage: "Unexpected token `<` in JSON at position 0",
+        errorType: "SyntaxError",
+        sampleStackTrace: `SyntaxError: Unexpected token \`<\` in JSON at position 0
+    at JSON.parse (<anonymous>)
+    at parseResponse (src/api/client.ts:42:15)
+    at fetch("https://api.example.com/data?query=test&limit=10")`,
+        taskIdentifier: "api-fetch-task",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("unicode and emoji in error", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorMessage: "Failed to process emoji 🔥 in message: Hello 世界",
+        errorType: "EncodingError",
+        sampleStackTrace: `EncodingError: Failed to process emoji 🔥 in message: Hello 世界
+    at encodeMessage (src/utils/encoding.ts:15:10)
+    at sendMessage (src/tasks/messaging.ts:42:8)`,
+        taskIdentifier: "messaging-task",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("different error types - TypeError", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorType: "TypeError",
+        errorMessage: "Cannot call method 'map' on undefined",
+        sampleStackTrace: `TypeError: Cannot call method 'map' on undefined
+    at transformData (src/transformers/data.ts:18:25)`,
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("different error types - ReferenceError", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorType: "ReferenceError",
+        errorMessage: "userConfig is not defined",
+        sampleStackTrace: `ReferenceError: userConfig is not defined
+    at initializeApp (src/app.ts:32:10)`,
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("different error types - Custom Error", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorType: "InvalidConfigurationError",
+        errorMessage: "API key is missing or invalid",
+        sampleStackTrace: `InvalidConfigurationError: API key is missing or invalid
+    at validateConfig (src/config/validator.ts:45:11)
+    at loadConfig (src/config/loader.ts:23:5)`,
+        taskIdentifier: "config-loader",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+
+  test("error with no stack trace", async () => {
+    const payload = createMockErrorPayload({
+      error: {
+        errorMessage: "An unknown error occurred",
+        errorType: "Error",
+        sampleStackTrace: "",
+      },
+    });
+
+    const service = new DeliverErrorGroupAlertService();
+    await service.call(payload);
+
+    expect(true).toBe(true);
+  });
+});
diff --git a/apps/webapp/test/timeGranularity.test.ts b/apps/webapp/test/timeGranularity.test.ts
new file mode 100644
index 00000000000..dbe41c37718
--- /dev/null
+++ b/apps/webapp/test/timeGranularity.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { TimeGranularity } from "~/utils/timeGranularity";
+
+const SECOND = 1_000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+
+function makeRange(durationMs: number): [Date, Date] {
+  const from = new Date("2025-01-01T00:00:00Z");
+  const to = new Date(from.getTime() + durationMs);
+  return [from, to];
+}
+
+describe("TimeGranularity", () => {
+  const granularity = new TimeGranularity([
+    { max: "1h", granularity: "10s" },
+    { max: "6h", granularity: "1m" },
+    { max: "Infinity", granularity: "10m" },
+  ]);
+
+  it("returns the first bracket when range is within its max", () => {
+    const [from, to] = makeRange(30 * MINUTE);
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(10 * SECOND);
+  });
+
+  it("returns a middle bracket when range exceeds the first but not the second", () => {
+    const [from, to] = makeRange(2 * HOUR);
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(1 * MINUTE);
+  });
+
+  it("returns the last bracket when range exceeds all non-Infinity maxes", () => {
+    const [from, to] = makeRange(24 * HOUR);
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(10 * MINUTE);
+  });
+
+  it("matches a bracket when range exactly equals its max", () => {
+    const [from, to] = makeRange(1 * HOUR);
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(10 * SECOND);
+  });
+
+  it("moves to the next bracket when range exceeds a boundary by 1ms", () => {
+    const [from, to] = makeRange(1 * HOUR + 1);
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(1 * MINUTE);
+  });
+
+  it("returns the first bracket's granularity for a zero-length range", () => {
+    const date = new Date("2025-01-01T00:00:00Z");
+    expect(granularity.getTimeGranularityMs(date, date)).toBe(10 * SECOND);
+  });
+
+  it("returns the broadest granularity for an inverted range (from > to)", () => {
+    const from = new Date("2025-01-01T01:00:00Z");
+    const to = new Date("2025-01-01T00:00:00Z");
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(10 * MINUTE);
+  });
+
+  it("throws when constructed with an empty array", () => {
+    expect(() => new TimeGranularity([])).toThrow("at least one bracket");
+  });
+});
diff --git a/apps/webapp/test/utils/tracing.ts b/apps/webapp/test/utils/tracing.ts
index 33b821abe71..09500a6c354 100644
--- a/apps/webapp/test/utils/tracing.ts
+++ b/apps/webapp/test/utils/tracing.ts
@@ -1,6 +1,12 @@
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { trace } from "@opentelemetry/api";
+import {
+  MeterProvider,
+  InMemoryMetricExporter,
+  PeriodicExportingMetricReader,
+  AggregationTemporality,
+} from "@opentelemetry/sdk-metrics";
 
 export function createInMemoryTracing() {
   // Initialize the tracer provider and exporter
@@ -18,3 +24,42 @@ export function createInMemoryTracing() {
     tracer,
   };
 }
+
+export function createInMemoryMetrics() {
+  // Initialize the metric exporter with cumulative temporality for easier testing
+  const metricExporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+
+  // Create a metric reader that exports frequently for testing
+  const metricReader = new PeriodicExportingMetricReader({
+    exporter: metricExporter,
+    exportIntervalMillis: 100, // Export frequently for tests
+  });
+
+  // Initialize the meter provider
+  const meterProvider = new MeterProvider({
+    readers: [metricReader],
+  });
+
+  // Retrieve a meter
+  const meter = meterProvider.getMeter("test-meter");
+
+  return {
+    metricExporter,
+    metricReader,
+    meterProvider,
+    meter,
+    // Helper to force collection and get metrics
+    async getMetrics() {
+      await metricReader.forceFlush();
+      return metricExporter.getMetrics();
+    },
+    // Helper to reset metrics between tests
+    reset() {
+      metricExporter.reset();
+    },
+    // Helper to shutdown the meter provider
+    async shutdown() {
+      await meterProvider.shutdown();
+    },
+  };
+}
diff --git a/apps/webapp/test/vercelUrls.test.ts b/apps/webapp/test/vercelUrls.test.ts
new file mode 100644
index 00000000000..9e3d81630f1
--- /dev/null
+++ b/apps/webapp/test/vercelUrls.test.ts
@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { sanitizeVercelNextUrl } from "../app/v3/vercel/vercelUrls.server";
+
+describe("sanitizeVercelNextUrl", () => {
+  it("returns undefined for null/undefined/empty", () => {
+    expect(sanitizeVercelNextUrl(null)).toBeUndefined();
+    expect(sanitizeVercelNextUrl(undefined)).toBeUndefined();
+    expect(sanitizeVercelNextUrl("")).toBeUndefined();
+  });
+
+  it("allows relative paths", () => {
+    expect(sanitizeVercelNextUrl("/dashboard")).toBe("/dashboard");
+    expect(sanitizeVercelNextUrl("/some/path?query=1")).toBe("/some/path?query=1");
+  });
+
+  it("rejects protocol-relative URLs", () => {
+    expect(sanitizeVercelNextUrl("//evil.com/path")).toBeUndefined();
+  });
+
+  it("allows vercel.com URLs", () => {
+    expect(sanitizeVercelNextUrl("https://vercel.com/dashboard")).toBe(
+      "https://vercel.com/dashboard"
+    );
+    expect(sanitizeVercelNextUrl("https://app.vercel.com/settings")).toBe(
+      "https://app.vercel.com/settings"
+    );
+  });
+
+  it("allows vercel.com subdomains", () => {
+    expect(sanitizeVercelNextUrl("https://my-team.vercel.com/project")).toBe(
+      "https://my-team.vercel.com/project"
+    );
+  });
+
+  it("rejects non-vercel HTTPS URLs", () => {
+    expect(sanitizeVercelNextUrl("https://evil.com/path")).toBeUndefined();
+    expect(sanitizeVercelNextUrl("https://not-vercel.com")).toBeUndefined();
+    expect(sanitizeVercelNextUrl("https://vercel.com.evil.com")).toBeUndefined();
+  });
+
+  it("rejects HTTP vercel.com URLs", () => {
+    expect(sanitizeVercelNextUrl("http://vercel.com/dashboard")).toBeUndefined();
+  });
+
+  it("rejects javascript: URLs", () => {
+    expect(sanitizeVercelNextUrl("javascript:alert(1)")).toBeUndefined();
+  });
+
+  it("rejects data: URLs", () => {
+    expect(sanitizeVercelNextUrl("data:text/html,<script>alert(1)</script>")).toBeUndefined();
+  });
+
+  it("rejects invalid URLs", () => {
+    expect(sanitizeVercelNextUrl("not a url at all")).toBeUndefined();
+  });
+});
diff --git a/apps/webapp/test/webhookErrorAlerts.test.ts b/apps/webapp/test/webhookErrorAlerts.test.ts
new file mode 100644
index 00000000000..d0e3e9e1a89
--- /dev/null
+++ b/apps/webapp/test/webhookErrorAlerts.test.ts
@@ -0,0 +1,128 @@
+import { describe, test, expect } from "vitest";
+import { Webhook } from "@trigger.dev/core/v3/schemas";
+import { generateErrorGroupWebhookPayload } from "~/v3/services/alerts/errorGroupWebhook.server";
+
+type ErrorData = {
+  fingerprint: string;
+  environmentId: string;
+  environmentName: string;
+  taskIdentifier: string;
+  errorType: string;
+  errorMessage: string;
+  sampleStackTrace: string;
+  firstSeen: string;
+  lastSeen: string;
+  occurrenceCount: number;
+};
+
+const TEST_ORG = { id: "org_test_123", slug: "webhook-test-org", name: "Webhook Test Org" };
+const TEST_PROJECT = {
+  id: "proj_test_456",
+  externalRef: "proj_webhook_test",
+  slug: "webhook-test-project",
+  name: "Webhook Test Project",
+};
+const DASHBOARD_URL = "https://cloud.trigger.dev/test";
+
+function createMockError(overrides: Partial<ErrorData> = {}): ErrorData {
+  return {
+    fingerprint: "fp_test_default",
+    environmentId: "env_test_dev",
+    environmentName: "Development",
+    taskIdentifier: "process-payment",
+    errorType: "TypeError",
+    errorMessage: "Cannot read property 'id' of undefined",
+    sampleStackTrace: `TypeError: Cannot read property 'id' of undefined
+    at processPayment (src/tasks/payment.ts:42:15)
+    at Object.run (src/tasks/payment.ts:15:20)
+    at TaskExecutor.execute (node_modules/@trigger.dev/core/dist/index.js:234:18)`,
+    firstSeen: Date.now().toString(),
+    lastSeen: Date.now().toString(),
+    occurrenceCount: 42,
+    ...overrides,
+  };
+}
+
+function buildPayload(classification: "new_issue" | "regression" | "unignored", error: ErrorData) {
+  return generateErrorGroupWebhookPayload({
+    classification,
+    error,
+    organization: TEST_ORG,
+    project: TEST_PROJECT,
+    dashboardUrl: DASHBOARD_URL,
+  });
+}
+
+describe("Webhook Error Alert Payload", () => {
+  test("payload structure is valid and parseable", () => {
+    const payload = buildPayload("new_issue", createMockError());
+    const parsed = Webhook.parse(payload);
+
+    expect(parsed.type).toBe("alert.error");
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("new_issue");
+      expect(parsed.object.error.type).toBe("TypeError");
+      expect(parsed.object.organization.slug).toBe("webhook-test-org");
+      expect(parsed.object.project.ref).toBe("proj_webhook_test");
+    }
+  });
+
+  test("payload survives JSON round-trip", () => {
+    const error = createMockError();
+    const payload = buildPayload("regression", error);
+
+    const deserialized = JSON.parse(JSON.stringify(payload));
+    const parsed = Webhook.parse(deserialized);
+
+    expect(parsed.type).toBe("alert.error");
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.classification).toBe("regression");
+      expect(parsed.object.error.fingerprint).toBe(error.fingerprint);
+    }
+  });
+
+  test("all classifications are valid", () => {
+    const classifications = ["new_issue", "regression", "unignored"] as const;
+
+    for (const classification of classifications) {
+      const payload = buildPayload(classification, createMockError());
+      const parsed = Webhook.parse(payload);
+      if (parsed.type === "alert.error") {
+        expect(parsed.object.classification).toBe(classification);
+      }
+    }
+  });
+
+  test("error details are preserved", () => {
+    const error = createMockError({
+      fingerprint: "fp_custom_123",
+      errorType: "CustomError",
+      errorMessage: "Custom error message",
+      sampleStackTrace: "CustomError: at line 42",
+      taskIdentifier: "my-custom-task",
+      occurrenceCount: 999,
+    });
+
+    const payload = buildPayload("new_issue", error);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.fingerprint).toBe("fp_custom_123");
+      expect(parsed.object.error.type).toBe("CustomError");
+      expect(parsed.object.error.message).toBe("Custom error message");
+      expect(parsed.object.error.stackTrace).toBe("CustomError: at line 42");
+      expect(parsed.object.error.taskIdentifier).toBe("my-custom-task");
+      expect(parsed.object.error.occurrenceCount).toBe(999);
+    }
+  });
+
+  test("empty stack trace becomes undefined", () => {
+    const error = createMockError({ sampleStackTrace: "" });
+    const payload = buildPayload("new_issue", error);
+    const parsed = Webhook.parse(payload);
+
+    if (parsed.type === "alert.error") {
+      expect(parsed.object.error.stackTrace).toBeUndefined();
+    }
+  });
+});
diff --git a/apps/webapp/tsconfig.json b/apps/webapp/tsconfig.json
index a10eda99cfb..36944e395b6 100644
--- a/apps/webapp/tsconfig.json
+++ b/apps/webapp/tsconfig.json
@@ -2,7 +2,7 @@
   "exclude": ["./cypress", "./cypress.config.ts"],
   "include": ["remix.env.d.ts", "global.d.ts", "**/*.ts", "**/*.tsx"],
   "compilerOptions": {
-    "types": ["vitest/globals"],
+    "types": ["vitest/globals", "node"],
     "lib": ["DOM", "DOM.Iterable", "DOM.AsyncIterable", "ES2020"],
     "isolatedModules": true,
     "esModuleInterop": true,
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 57cd1412bae..49b14bcc54a 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,7 +1,7 @@
-ARG NODE_IMAGE=node:20.11.1-bullseye-slim@sha256:5a5a92b3a8d392691c983719dbdc65d9f30085d6dcd65376e7a32e6fe9bf4cbe
+ARG NODE_IMAGE=node:20.20-bullseye-slim@sha256:d6c3903e556d4161f63af4550e76244908b6668e1a7d2983eff4873a0c2b0413
 
 FROM golang:1.23-alpine AS goose_builder
-RUN go install github.com/pressly/goose/v3/cmd/goose@latest
+RUN go install github.com/pressly/goose/v3/cmd/goose@v3.26.0
 
 FROM ${NODE_IMAGE} AS pruner
 
diff --git a/docker/config/grafana/provisioning/dashboards/runs-replication.json b/docker/config/grafana/provisioning/dashboards/runs-replication.json
new file mode 100644
index 00000000000..680f260daa0
--- /dev/null
+++ b/docker/config/grafana/provisioning/dashboards/runs-replication.json
@@ -0,0 +1,546 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 1,
+  "links": [],
+  "panels": [
+    {
+      "collapsed": false,
+      "gridPos": { "h": 1, "w": 24, "x": 0, "y": 0 },
+      "id": 1,
+      "panels": [],
+      "title": "Throughput",
+      "type": "row"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 6, "w": 6, "x": 0, "y": 1 },
+      "id": 2,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": { "calcs": ["lastNotNull"], "fields": "", "values": false },
+        "textMode": "auto"
+      },
+      "pluginVersion": "11.3.0",
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_task_runs_inserted_inserts_total[5m]))",
+          "legendFormat": "Runs/sec",
+          "refId": "A"
+        }
+      ],
+      "title": "Task Runs Inserted Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 6, "w": 6, "x": 6, "y": 1 },
+      "id": 3,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": { "calcs": ["lastNotNull"], "fields": "", "values": false },
+        "textMode": "auto"
+      },
+      "pluginVersion": "11.3.0",
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_payloads_inserted_inserts_total[5m]))",
+          "legendFormat": "Payloads/sec",
+          "refId": "A"
+        }
+      ],
+      "title": "Payloads Inserted Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 6, "w": 6, "x": 12, "y": 1 },
+      "id": 4,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": { "calcs": ["lastNotNull"], "fields": "", "values": false },
+        "textMode": "auto"
+      },
+      "pluginVersion": "11.3.0",
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_batches_flushed_total[5m]))",
+          "legendFormat": "Batches/sec",
+          "refId": "A"
+        }
+      ],
+      "title": "Batches Flushed Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "thresholds" },
+          "mappings": [],
+          "max": 1,
+          "min": 0,
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              { "color": "red", "value": null },
+              { "color": "yellow", "value": 0.9 },
+              { "color": "green", "value": 0.99 }
+            ]
+          },
+          "unit": "percentunit"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 6, "w": 6, "x": 18, "y": 1 },
+      "id": 5,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "none",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": { "calcs": ["lastNotNull"], "fields": "", "values": false },
+        "textMode": "auto"
+      },
+      "pluginVersion": "11.3.0",
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_batches_flushed_total{success=\"true\"}[5m])) / sum(rate(triggerdotdev_runs_replication_batches_flushed_total[5m]))",
+          "legendFormat": "Success Rate",
+          "refId": "A"
+        }
+      ],
+      "title": "Flush Success Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 7 },
+      "id": 6,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_events_processed_total[5m])) by (event_type)",
+          "legendFormat": "{{event_type}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Events Processed by Type",
+      "type": "timeseries"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 7 },
+      "id": 7,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_task_runs_inserted_inserts_total[5m]))",
+          "legendFormat": "Task Runs",
+          "refId": "A"
+        },
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_payloads_inserted_inserts_total[5m]))",
+          "legendFormat": "Payloads",
+          "refId": "B"
+        }
+      ],
+      "title": "Insert Rate Over Time",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "gridPos": { "h": 1, "w": 24, "x": 0, "y": 15 },
+      "id": 8,
+      "panels": [],
+      "title": "Latency & Lag",
+      "type": "row"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "ms"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 16 },
+      "id": 9,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.50, sum(rate(triggerdotdev_runs_replication_replication_lag_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p50",
+          "refId": "A"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(triggerdotdev_runs_replication_replication_lag_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p95",
+          "refId": "B"
+        },
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(triggerdotdev_runs_replication_replication_lag_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p99",
+          "refId": "C"
+        }
+      ],
+      "title": "Replication Lag (Postgres → ClickHouse)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "ms"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 16 },
+      "id": 10,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.50, sum(rate(triggerdotdev_runs_replication_flush_duration_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p50",
+          "refId": "A"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(triggerdotdev_runs_replication_flush_duration_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p95",
+          "refId": "B"
+        },
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(triggerdotdev_runs_replication_flush_duration_ms_milliseconds_bucket[5m])) by (le))",
+          "legendFormat": "p99",
+          "refId": "C"
+        }
+      ],
+      "title": "Flush Duration",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "gridPos": { "h": 1, "w": 24, "x": 0, "y": 24 },
+      "id": 11,
+      "panels": [],
+      "title": "Batching & Queue",
+      "type": "row"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 25 },
+      "id": 13,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.50, sum(rate(triggerdotdev_runs_replication_batch_size_items_bucket[5m])) by (le))",
+          "legendFormat": "p50",
+          "refId": "A"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(triggerdotdev_runs_replication_batch_size_items_bucket[5m])) by (le))",
+          "legendFormat": "p95",
+          "refId": "B"
+        },
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(triggerdotdev_runs_replication_batch_size_items_bucket[5m])) by (le))",
+          "legendFormat": "p99",
+          "refId": "C"
+        }
+      ],
+      "title": "Batch Size Distribution",
+      "type": "timeseries"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "thresholds" },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              { "color": "green", "value": null },
+              { "color": "yellow", "value": 1 },
+              { "color": "red", "value": 10 }
+            ]
+          },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 25 },
+      "id": 14,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": { "calcs": ["lastNotNull"], "fields": "", "values": false },
+        "textMode": "auto"
+      },
+      "pluginVersion": "11.3.0",
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_insert_retries_total[5m]))",
+          "legendFormat": "Retries/sec",
+          "refId": "A"
+        }
+      ],
+      "title": "Insert Retries (should be low)",
+      "type": "stat"
+    },
+    {
+      "collapsed": false,
+      "gridPos": { "h": 1, "w": 24, "x": 0, "y": 33 },
+      "id": 15,
+      "panels": [],
+      "title": "Retries by Operation",
+      "type": "row"
+    },
+    {
+      "datasource": { "type": "prometheus", "uid": "prometheus" },
+      "fieldConfig": {
+        "defaults": {
+          "color": { "mode": "palette-classic" },
+          "custom": {
+            "axisBorderShow": false,
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": { "legend": false, "tooltip": false, "viz": false },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": { "type": "linear" },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": { "group": "A", "mode": "none" },
+            "thresholdsStyle": { "mode": "off" }
+          },
+          "mappings": [],
+          "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] },
+          "unit": "short"
+        },
+        "overrides": []
+      },
+      "gridPos": { "h": 8, "w": 24, "x": 0, "y": 34 },
+      "id": 16,
+      "options": {
+        "legend": { "calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom", "showLegend": true },
+        "tooltip": { "mode": "multi", "sort": "desc" }
+      },
+      "targets": [
+        {
+          "expr": "sum(rate(triggerdotdev_runs_replication_insert_retries_total[5m])) by (operation)",
+          "legendFormat": "{{operation}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Insert Retries by Operation",
+      "type": "timeseries"
+    }
+  ],
+  "refresh": "10s",
+  "schemaVersion": 39,
+  "tags": ["trigger.dev", "runs-replication", "clickhouse"],
+  "templating": { "list": [] },
+  "time": { "from": "now-15m", "to": "now" },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "Runs Replication Service",
+  "uid": "runs-replication-metrics",
+  "version": 1
+}
diff --git a/docker/config/s2-spec.json b/docker/config/s2-spec.json
new file mode 100644
index 00000000000..6c3e610bf05
--- /dev/null
+++ b/docker/config/s2-spec.json
@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/s2-streamstore/s2/main/cli/schema.json",
+  "basins": [
+    {
+      "name": "trigger-local",
+      "config": {
+        "create_stream_on_append": true,
+        "create_stream_on_read": true
+      }
+    }
+  ]
+}
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index c80648d710c..6b64e901bd0 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -4,6 +4,7 @@ volumes:
   database-data:
   database-data-alt:
   redis-data:
+  minio-data:
   clickhouse-data:
   clickhouse-logs:
   prometheus-data:
@@ -49,6 +50,45 @@ services:
     ports:
       - 6379:6379
 
+  # S3-compatible API for local object store (large payloads / packet offload).
+  # Host :9005 = S3 API, :9006 = web console (ClickHouse uses host :9000).
+  minio:
+    container_name: minio
+    image: minio/minio:latest
+    restart: always
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    volumes:
+      - minio-data:/data
+    ports:
+      - "9005:9000"
+      - "9006:9001"
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 5s
+
+  minio-init:
+    image: minio/mc:latest
+    depends_on:
+      minio:
+        condition: service_healthy
+    networks:
+      - app_network
+    entrypoint: /bin/sh
+    command:
+      - -c
+      - |
+        mc alias set local http://minio:9000 minioadmin minioadmin
+        mc mb -p local/packets || true
+    restart: "no"
+
   electric:
     container_name: electric
     image: electricsql/electric:1.2.4@sha256:20da3d0b0e74926c5623392db67fd56698b9e374c4aeb6cb5cadeb8fea171c36
@@ -143,6 +183,22 @@ services:
     networks:
       - app_network
 
+  s2:
+    image: ghcr.io/s2-streamstore/s2
+    command: ["lite", "--init-file", "/s2-spec.json"]
+    volumes:
+      - ./config/s2-spec.json:/s2-spec.json:ro
+    ports:
+      - "4566:80"
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD-SHELL", "wget -qO- http://localhost:80/v1/basins?limit=1 || exit 1"]
+      interval: 2s
+      timeout: 3s
+      retries: 5
+      start_period: 3s
+
   toxiproxy:
     container_name: toxiproxy
     image: ghcr.io/shopify/toxiproxy:latest
diff --git a/docker/scripts/entrypoint.sh b/docker/scripts/entrypoint.sh
index 39046e0b6f6..a6bc7dd15b9 100755
--- a/docker/scripts/entrypoint.sh
+++ b/docker/scripts/entrypoint.sh
@@ -5,10 +5,13 @@ if [ -n "$DATABASE_HOST" ]; then
   scripts/wait-for-it.sh ${DATABASE_HOST} -- echo "database is up"
 fi
 
-# Run migrations
-echo "Running prisma migrations"
-pnpm --filter @trigger.dev/database db:migrate:deploy
-echo "Prisma migrations done"
+if [ "$SKIP_POSTGRES_MIGRATIONS" != "1" ]; then
+  echo "Running prisma migrations"
+  pnpm --filter @trigger.dev/database db:migrate:deploy
+  echo "Prisma migrations done"
+else
+  echo "SKIP_POSTGRES_MIGRATIONS=1, skipping Postgres migrations."
+fi
 
 if [ -n "$CLICKHOUSE_URL" ] && [ "$SKIP_CLICKHOUSE_MIGRATIONS" != "1" ]; then
   # Run ClickHouse migrations
diff --git a/docs/CLAUDE.md b/docs/CLAUDE.md
new file mode 100644
index 00000000000..25c39fe07cc
--- /dev/null
+++ b/docs/CLAUDE.md
@@ -0,0 +1,55 @@
+# Documentation
+
+Mintlify-based documentation site for Trigger.dev.
+
+## Configuration
+
+- Main config: `docs.json` - defines navigation, theme, metadata
+- Navigation structure: `docs.json` -> `navigation.dropdowns` -> groups -> pages
+
+## Writing Docs
+
+Pages are MDX files. Frontmatter format:
+
+```yaml
+---
+title: "Page Title"
+description: "Brief description for SEO and previews"
+sidebarTitle: "Short Title"  # Optional, shown in sidebar if different from title
+---
+```
+
+## Adding a New Page
+
+1. Create the MDX file in the appropriate directory
+2. Add the page path to `docs.json` navigation (under the correct group)
+
+## Mintlify Components
+
+Use these components for structured content:
+
+- `<Note>` - General notes
+- `<Warning>` - Important warnings
+- `<Info>` - Informational callouts
+- `<Tip>` - Helpful tips
+- `<CodeGroup>` - Multi-language/multi-file code examples
+- `<Expandable>` - Collapsible content sections
+- `<Steps>` / `<Step>` - Step-by-step instructions
+- `<Card>` / `<CardGroup>` - Card layouts for navigation
+
+## Code Examples
+
+- Always import from `@trigger.dev/sdk` (never `@trigger.dev/sdk/v3`)
+- Make code examples complete and runnable where possible
+- Use language tags in code fences: `typescript`, `bash`, `json`
+
+## Directory Structure
+
+- `documentation/` - Core conceptual docs
+- `guides/` - How-to guides
+- `config/` - Configuration reference
+- `deployment/` - Deployment guides
+- `tasks/` - Task documentation
+- `realtime/` - Real-time features
+- `runs/` - Run management
+- `images/` - Image assets
diff --git a/docs/batch-queue-stress-test-plan.md b/docs/batch-queue-stress-test-plan.md
new file mode 100644
index 00000000000..0a8c6399606
--- /dev/null
+++ b/docs/batch-queue-stress-test-plan.md
@@ -0,0 +1,5011 @@
+# Batch Queue Stress Test Plan
+
+This document outlines a systematic approach to testing the new Batch Queue with Deficit Round Robin (DRR) scheduling.
+
+## Test Environment
+
+**Setup:**
+
+- Single local machine running one webapp instance (single BatchQueue consumer process)
+- 3 organizations, each with 3 projects = **9 tenants total**
+- All tenants using the same task ID: `stress-test-task`
+
+**Note:** In production, multiple webapp instances will run BatchQueue consumers in parallel. This single-instance testing focuses on algorithm behavior rather than horizontal scaling.
+
+## Configuration Options Under Test
+
+| Variable                                | Default | Description                                            |
+| --------------------------------------- | ------- | ------------------------------------------------------ |
+| `BATCH_QUEUE_DRR_QUANTUM`               | 5       | Credits allocated per environment per scheduling round |
+| `BATCH_QUEUE_MAX_DEFICIT`               | 50      | Maximum accumulated deficit (prevents starvation)      |
+| `BATCH_QUEUE_CONSUMER_COUNT`            | 1       | Number of concurrent consumer loops                    |
+| `BATCH_QUEUE_CONSUMER_INTERVAL_MS`      | 100     | Polling interval between consumer iterations           |
+| `BATCH_CONCURRENCY_DEFAULT_CONCURRENCY` | 10      | Default concurrent batch items per environment         |
+| `BATCH_QUEUE_GLOBAL_RATE_LIMIT`         | none    | Optional global items/sec limit                        |
+
+**Per-Org Settings (via database):**
+
+- `batchQueueConcurrencyConfig` - Override concurrency per org
+- `batchRateLimitConfig` - Rate limit per org
+
+---
+
+## Test Series Overview
+
+| Series | Focus               | Objective                                              |
+| ------ | ------------------- | ------------------------------------------------------ |
+| A      | Baseline            | Establish reference metrics with defaults              |
+| B      | DRR Quantum         | Understand how quantum affects fairness and throughput |
+| C      | Max Deficit         | Understand starvation prevention and catch-up behavior |
+| D      | Consumer Count      | Test parallelism within single process                 |
+| E      | Consumer Interval   | Test polling frequency impact                          |
+| F      | Concurrency Limits  | Test per-environment processing limits                 |
+| G      | Global Rate Limiter | Test global throughput caps                            |
+| H      | Asymmetric Load     | Test fairness under uneven workloads                   |
+| I      | Combined Tuning     | Test optimized configurations                          |
+
+---
+
+## Series A: Baseline (Default Configuration)
+
+**Objective:** Establish baseline metrics with all default settings.
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+# BATCH_QUEUE_CONSUMER_COUNT not set (default: 1)
+# BATCH_QUEUE_CONSUMER_INTERVAL_MS not set (default: 100)
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+# BATCH_QUEUE_GLOBAL_RATE_LIMIT not set
+```
+
+### Test A1: Fairness Baseline (All 9 Tenants)
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Baseline fairness test"
+```
+
+**Expected:** All tenants should complete in roughly similar timeframes.
+
+<details>
+<summary>Results A1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Baseline fairness test",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 54.51792024230187,
+    "overallDuration": 49525,
+    "fairnessIndex": 0.9999098436641237,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49323,
+        "avgItemsPerSecond": 6.082355087890031,
+        "avgBatchDuration": 49238,
+        "minBatchDuration": 49196,
+        "maxBatchDuration": 49322,
+        "p50Duration": 49196,
+        "p95Duration": 49322,
+        "p99Duration": 49322
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49460,
+        "avgItemsPerSecond": 6.06550748079256,
+        "avgBatchDuration": 49290.666666666664,
+        "minBatchDuration": 49187,
+        "maxBatchDuration": 49429,
+        "p50Duration": 49256,
+        "p95Duration": 49429,
+        "p99Duration": 49429
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49484,
+        "avgItemsPerSecond": 6.062565677794843,
+        "avgBatchDuration": 36861.666666666664,
+        "minBatchDuration": 15041,
+        "maxBatchDuration": 49472,
+        "p50Duration": 46072,
+        "p95Duration": 49472,
+        "p99Duration": 49472
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 48442,
+        "avgItemsPerSecond": 6.192973039924033,
+        "avgBatchDuration": 48347,
+        "minBatchDuration": 48223,
+        "maxBatchDuration": 48442,
+        "p50Duration": 48376,
+        "p95Duration": 48442,
+        "p99Duration": 48442
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 48446,
+        "avgItemsPerSecond": 6.192461709945094,
+        "avgBatchDuration": 48102.333333333336,
+        "minBatchDuration": 47417,
+        "maxBatchDuration": 48446,
+        "p50Duration": 48444,
+        "p95Duration": 48446,
+        "p99Duration": 48446
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 48288,
+        "avgItemsPerSecond": 6.21272365805169,
+        "avgBatchDuration": 36139.333333333336,
+        "minBatchDuration": 16087,
+        "maxBatchDuration": 48218,
+        "p50Duration": 44113,
+        "p95Duration": 48218,
+        "p99Duration": 48218
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49148,
+        "avgItemsPerSecond": 6.104012370798404,
+        "avgBatchDuration": 49074.666666666664,
+        "minBatchDuration": 49061,
+        "maxBatchDuration": 49099,
+        "p50Duration": 49064,
+        "p95Duration": 49099,
+        "p99Duration": 49099
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49178,
+        "avgItemsPerSecond": 6.1002887470006915,
+        "avgBatchDuration": 48484.333333333336,
+        "minBatchDuration": 47154,
+        "maxBatchDuration": 49176,
+        "p50Duration": 49123,
+        "p95Duration": 49176,
+        "p99Duration": 49176
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49454,
+        "avgItemsPerSecond": 6.066243377684312,
+        "avgBatchDuration": 49372.666666666664,
+        "minBatchDuration": 49251,
+        "maxBatchDuration": 49454,
+        "p50Duration": 49413,
+        "p95Duration": 49454,
+        "p99Duration": 49454
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T14:23:40.510Z",
+    "end": "2025-12-15T14:24:30.035Z"
+  }
+}
+```
+
+**Observations:**
+
+- Overall throughput: **54.52 items/sec** with 9 tenants competing
+- Fairness index: **0.9999** (nearly perfect fairness)
+- Notable patterns: All tenants completed within 1-2 seconds of each other (48-50s range). Per-tenant throughput ~6 items/sec each. **DRR is working excellently for symmetric load.**
+
+</details>
+
+### Test A2: Throughput Baseline (Single Tenant)
+
+**Command:**
+
+```bash
+pnpm stress throughput --batch-sizes 100,500,1000 --batch-count 3
+```
+
+**Expected:** Establish throughput ceiling for single tenant.
+
+<details>
+<summary>Results A2 (click to expand)</summary>
+
+```json
+[
+  {
+    "scenario": "throughput-100",
+    "config": {
+      "tenantCount": 1,
+      "batchSize": 100,
+      "batchCount": 3
+    },
+    "results": {
+      "totalItemsProcessed": 300,
+      "totalBatches": 3,
+      "overallThroughput": 82.57638315441784,
+      "overallDuration": 3633,
+      "fairnessIndex": 1,
+      "perTenant": [
+        {
+          "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+          "totalItems": 300,
+          "totalBatches": 3,
+          "totalDuration": 3570,
+          "avgItemsPerSecond": 84.03361344537815,
+          "avgBatchDuration": 3558.6666666666665,
+          "minBatchDuration": 3538,
+          "maxBatchDuration": 3570,
+          "p50Duration": 3568,
+          "p95Duration": 3570,
+          "p99Duration": 3570
+        }
+      ]
+    },
+    "timestamps": {
+      "start": "2025-12-15T14:41:19.119Z",
+      "end": "2025-12-15T14:41:22.752Z"
+    }
+  },
+  {
+    "scenario": "throughput-500",
+    "config": {
+      "tenantCount": 1,
+      "batchSize": 500,
+      "batchCount": 3
+    },
+    "results": {
+      "totalItemsProcessed": 1500,
+      "totalBatches": 3,
+      "overallThroughput": 97.48488984207448,
+      "overallDuration": 15387,
+      "fairnessIndex": 1,
+      "perTenant": [
+        {
+          "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+          "totalItems": 1500,
+          "totalBatches": 3,
+          "totalDuration": 15384,
+          "avgItemsPerSecond": 97.50390015600624,
+          "avgBatchDuration": 15369,
+          "minBatchDuration": 15356,
+          "maxBatchDuration": 15384,
+          "p50Duration": 15367,
+          "p95Duration": 15384,
+          "p99Duration": 15384
+        }
+      ]
+    },
+    "timestamps": {
+      "start": "2025-12-15T14:41:23.069Z",
+      "end": "2025-12-15T14:41:38.456Z"
+    }
+  },
+  {
+    "scenario": "throughput-1000",
+    "config": {
+      "tenantCount": 1,
+      "batchSize": 1000,
+      "batchCount": 3
+    },
+    "results": {
+      "totalItemsProcessed": 3000,
+      "totalBatches": 3,
+      "overallThroughput": 88.60796880999499,
+      "overallDuration": 33857,
+      "fairnessIndex": 1,
+      "perTenant": [
+        {
+          "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+          "totalItems": 3000,
+          "totalBatches": 3,
+          "totalDuration": 33839,
+          "avgItemsPerSecond": 88.65510210112592,
+          "avgBatchDuration": 33109,
+          "minBatchDuration": 32731,
+          "maxBatchDuration": 33827,
+          "p50Duration": 32769,
+          "p95Duration": 33827,
+          "p99Duration": 33827
+        }
+      ]
+    },
+    "timestamps": {
+      "start": "2025-12-15T14:41:38.860Z",
+      "end": "2025-12-15T14:42:12.717Z"
+    }
+  }
+]
+```
+
+**Observations:**
+
+- Max throughput achieved: **97.48 items/sec** (at batch size 500)
+- Scaling behavior: **Non-linear.** 100 items → 82.58/sec, 500 items → 97.48/sec (peak), 1000 items → 88.61/sec. Sweet spot around 500 items per batch. Larger batches may introduce overhead or hit concurrency limits.
+
+</details>
+
+---
+
+## Series B: DRR Quantum Variations
+
+**Objective:** Understand how quantum size affects fairness vs. throughput tradeoff.
+
+**Theory:**
+
+- Lower quantum = more frequent tenant switching = better fairness, possibly lower throughput
+- Higher quantum = longer bursts per tenant = potentially higher throughput, worse fairness
+
+### Test B1: Very Low Quantum (quantum=1)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=1
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Low quantum=1"
+```
+
+<details>
+<summary>Results B1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Low quantum=1",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 66.08899985313556,
+    "overallDuration": 40854,
+    "fairnessIndex": 0.9997008998554137,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40769,
+        "avgItemsPerSecond": 7.358532218106895,
+        "avgBatchDuration": 36850.333333333336,
+        "minBatchDuration": 29016,
+        "maxBatchDuration": 40769,
+        "p50Duration": 40766,
+        "p95Duration": 40769,
+        "p99Duration": 40769
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40771,
+        "avgItemsPerSecond": 7.358171249172206,
+        "avgBatchDuration": 40408.333333333336,
+        "minBatchDuration": 39684,
+        "maxBatchDuration": 40771,
+        "p50Duration": 40770,
+        "p95Duration": 40771,
+        "p99Duration": 40771
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40754,
+        "avgItemsPerSecond": 7.361240614418216,
+        "avgBatchDuration": 40106,
+        "minBatchDuration": 39076,
+        "maxBatchDuration": 40753,
+        "p50Duration": 40489,
+        "p95Duration": 40753,
+        "p99Duration": 40753
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40770,
+        "avgItemsPerSecond": 7.358351729212656,
+        "avgBatchDuration": 40717.333333333336,
+        "minBatchDuration": 40616,
+        "maxBatchDuration": 40769,
+        "p50Duration": 40767,
+        "p95Duration": 40769,
+        "p99Duration": 40769
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40767,
+        "avgItemsPerSecond": 7.358893222459342,
+        "avgBatchDuration": 40610,
+        "minBatchDuration": 40299,
+        "maxBatchDuration": 40766,
+        "p50Duration": 40765,
+        "p95Duration": 40766,
+        "p99Duration": 40766
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40780,
+        "avgItemsPerSecond": 7.356547327121138,
+        "avgBatchDuration": 40681.666666666664,
+        "minBatchDuration": 40497,
+        "maxBatchDuration": 40778,
+        "p50Duration": 40770,
+        "p95Duration": 40778,
+        "p99Duration": 40778
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40771,
+        "avgItemsPerSecond": 7.358171249172206,
+        "avgBatchDuration": 40766.333333333336,
+        "minBatchDuration": 40764,
+        "maxBatchDuration": 40769,
+        "p50Duration": 40766,
+        "p95Duration": 40769,
+        "p99Duration": 40769
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38628,
+        "avgItemsPerSecond": 7.766387076731904,
+        "avgBatchDuration": 34753,
+        "minBatchDuration": 28057,
+        "maxBatchDuration": 38627,
+        "p50Duration": 37575,
+        "p95Duration": 38627,
+        "p99Duration": 38627
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40754,
+        "avgItemsPerSecond": 7.361240614418216,
+        "avgBatchDuration": 40018.333333333336,
+        "minBatchDuration": 39630,
+        "maxBatchDuration": 40754,
+        "p50Duration": 39671,
+        "p95Duration": 40754,
+        "p99Duration": 40754
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T14:48:32.814Z",
+    "end": "2025-12-15T14:49:13.668Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9997** (vs baseline: **0.9999**) - nearly identical
+- Throughput: **66.09 items/sec** (vs baseline: **54.52**) - +21% improvement!
+- Context switching overhead visible?: **Not significantly.** Despite switching tenants every 1 item, throughput actually improved. The tighter scheduling may have better utilized concurrency slots.
+
+</details>
+
+### Test B2: Medium Quantum (quantum=10)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=10
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Medium quantum=10"
+```
+
+<details>
+<summary>Results B2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Medium quantum=10",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 64.68615237182559,
+    "overallDuration": 41740,
+    "fairnessIndex": 0.9998055065601579,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40743,
+        "avgItemsPerSecond": 7.363228039172373,
+        "avgBatchDuration": 37656,
+        "minBatchDuration": 31484,
+        "maxBatchDuration": 40743,
+        "p50Duration": 40741,
+        "p95Duration": 40743,
+        "p99Duration": 40743
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40745,
+        "avgItemsPerSecond": 7.362866609399926,
+        "avgBatchDuration": 36601.666666666664,
+        "minBatchDuration": 28318,
+        "maxBatchDuration": 40745,
+        "p50Duration": 40742,
+        "p95Duration": 40745,
+        "p99Duration": 40745
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41664,
+        "avgItemsPerSecond": 7.200460829493087,
+        "avgBatchDuration": 38524.333333333336,
+        "minBatchDuration": 32253,
+        "maxBatchDuration": 41660,
+        "p50Duration": 41660,
+        "p95Duration": 41660,
+        "p99Duration": 41660
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41443,
+        "avgItemsPerSecond": 7.238858190768043,
+        "avgBatchDuration": 36661.333333333336,
+        "minBatchDuration": 32251,
+        "maxBatchDuration": 41443,
+        "p50Duration": 36290,
+        "p95Duration": 41443,
+        "p99Duration": 41443
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40436,
+        "avgItemsPerSecond": 7.419131467009596,
+        "avgBatchDuration": 40406,
+        "minBatchDuration": 40349,
+        "maxBatchDuration": 40436,
+        "p50Duration": 40433,
+        "p95Duration": 40436,
+        "p99Duration": 40436
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41044,
+        "avgItemsPerSecond": 7.309229119968814,
+        "avgBatchDuration": 39122,
+        "minBatchDuration": 35972,
+        "maxBatchDuration": 41040,
+        "p50Duration": 40354,
+        "p95Duration": 41040,
+        "p99Duration": 41040
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41683,
+        "avgItemsPerSecond": 7.197178705947269,
+        "avgBatchDuration": 41325,
+        "minBatchDuration": 40636,
+        "maxBatchDuration": 41683,
+        "p50Duration": 41656,
+        "p95Duration": 41683,
+        "p99Duration": 41683
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41412,
+        "avgItemsPerSecond": 7.244277021153288,
+        "avgBatchDuration": 40959.666666666664,
+        "minBatchDuration": 40735,
+        "maxBatchDuration": 41406,
+        "p50Duration": 40738,
+        "p95Duration": 41406,
+        "p99Duration": 41406
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 39914,
+        "avgItemsPerSecond": 7.516159743448415,
+        "avgBatchDuration": 36645,
+        "minBatchDuration": 32034,
+        "maxBatchDuration": 39914,
+        "p50Duration": 37987,
+        "p95Duration": 39914,
+        "p99Duration": 39914
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T14:51:13.796Z",
+    "end": "2025-12-15T14:51:55.536Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9998** (excellent)
+- Throughput: **64.69 items/sec** (vs quantum=1: 66.09, slightly lower)
+- Comparison to baseline: **+18% throughput vs baseline.** Higher quantum didn't provide expected gains; the overhead theory is not supported by evidence.
+
+</details>
+
+### Test B3: High Quantum (quantum=25)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=25
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "High quantum=25"
+```
+
+<details>
+<summary>Results B3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "High quantum=25",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 84.3644544431946,
+    "overallDuration": 32004,
+    "fairnessIndex": 0.9999195340273302,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31137,
+        "avgItemsPerSecond": 9.634839579920994,
+        "avgBatchDuration": 31135.333333333332,
+        "minBatchDuration": 31134,
+        "maxBatchDuration": 31137,
+        "p50Duration": 31135,
+        "p95Duration": 31137,
+        "p99Duration": 31137
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31135,
+        "avgItemsPerSecond": 9.635458487233016,
+        "avgBatchDuration": 30287.333333333332,
+        "minBatchDuration": 29792,
+        "maxBatchDuration": 31133,
+        "p50Duration": 29937,
+        "p95Duration": 31133,
+        "p99Duration": 31133
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31197,
+        "avgItemsPerSecond": 9.616309260505819,
+        "avgBatchDuration": 24641,
+        "minBatchDuration": 18973,
+        "maxBatchDuration": 31197,
+        "p50Duration": 23753,
+        "p95Duration": 31197,
+        "p99Duration": 31197
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31105,
+        "avgItemsPerSecond": 9.644751647645073,
+        "avgBatchDuration": 29303,
+        "minBatchDuration": 25964,
+        "maxBatchDuration": 31105,
+        "p50Duration": 30840,
+        "p95Duration": 31105,
+        "p99Duration": 31105
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31120,
+        "avgItemsPerSecond": 9.640102827763496,
+        "avgBatchDuration": 31006.333333333332,
+        "minBatchDuration": 30835,
+        "maxBatchDuration": 31120,
+        "p50Duration": 31064,
+        "p95Duration": 31120,
+        "p99Duration": 31120
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31075,
+        "avgItemsPerSecond": 9.654062751407883,
+        "avgBatchDuration": 24953.333333333332,
+        "minBatchDuration": 21079,
+        "maxBatchDuration": 31073,
+        "p50Duration": 22708,
+        "p95Duration": 31073,
+        "p99Duration": 31073
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31965,
+        "avgItemsPerSecond": 9.385265133740027,
+        "avgBatchDuration": 25924.666666666668,
+        "minBatchDuration": 22904,
+        "maxBatchDuration": 31964,
+        "p50Duration": 22906,
+        "p95Duration": 31964,
+        "p99Duration": 31964
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31106,
+        "avgItemsPerSecond": 9.644441586832123,
+        "avgBatchDuration": 26298.333333333332,
+        "minBatchDuration": 16867,
+        "maxBatchDuration": 31106,
+        "p50Duration": 30922,
+        "p95Duration": 31106,
+        "p99Duration": 31106
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30886,
+        "avgItemsPerSecond": 9.713138638865505,
+        "avgBatchDuration": 30883,
+        "minBatchDuration": 30881,
+        "maxBatchDuration": 30884,
+        "p50Duration": 30884,
+        "p95Duration": 30884,
+        "p99Duration": 30884
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T14:54:10.280Z",
+    "end": "2025-12-15T14:54:42.284Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9999** (best in B series!)
+- Throughput: **84.36 items/sec** (**BEST in B series**, +55% vs baseline)
+- Evidence of tenant starvation?: **None.** All tenants completed in 30-32s range. Higher quantum=25 actually provided better throughput AND fairness!
+
+</details>
+
+### Test B4: Very High Quantum (quantum=50)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=50
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Very high quantum=50"
+```
+
+<details>
+<summary>Results B4 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Very high quantum=50",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 51.97605251506343,
+    "overallDuration": 51947,
+    "fairnessIndex": 0.9997441540697334,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51416,
+        "avgItemsPerSecond": 5.834759607904155,
+        "avgBatchDuration": 51002,
+        "minBatchDuration": 50774,
+        "maxBatchDuration": 51416,
+        "p50Duration": 50816,
+        "p95Duration": 51416,
+        "p99Duration": 51416
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51847,
+        "avgItemsPerSecond": 5.786255713927518,
+        "avgBatchDuration": 51840.666666666664,
+        "minBatchDuration": 51838,
+        "maxBatchDuration": 51843,
+        "p50Duration": 51841,
+        "p95Duration": 51843,
+        "p99Duration": 51843
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51252,
+        "avgItemsPerSecond": 5.853430110044486,
+        "avgBatchDuration": 51034.333333333336,
+        "minBatchDuration": 50778,
+        "maxBatchDuration": 51250,
+        "p50Duration": 51075,
+        "p95Duration": 51250,
+        "p99Duration": 51250
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 50778,
+        "avgItemsPerSecond": 5.908070424199456,
+        "avgBatchDuration": 50768.666666666664,
+        "minBatchDuration": 50765,
+        "maxBatchDuration": 50776,
+        "p50Duration": 50765,
+        "p95Duration": 50776,
+        "p99Duration": 50776
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49692,
+        "avgItemsPerSecond": 6.037189084762135,
+        "avgBatchDuration": 49689.666666666664,
+        "minBatchDuration": 49687,
+        "maxBatchDuration": 49692,
+        "p50Duration": 49690,
+        "p95Duration": 49692,
+        "p99Duration": 49692
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51843,
+        "avgItemsPerSecond": 5.786702158439905,
+        "avgBatchDuration": 51842,
+        "minBatchDuration": 51841,
+        "maxBatchDuration": 51843,
+        "p50Duration": 51842,
+        "p95Duration": 51843,
+        "p99Duration": 51843
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 50821,
+        "avgItemsPerSecond": 5.9030715649042715,
+        "avgBatchDuration": 50794.666666666664,
+        "minBatchDuration": 50779,
+        "maxBatchDuration": 50821,
+        "p50Duration": 50784,
+        "p95Duration": 50821,
+        "p99Duration": 50821
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49689,
+        "avgItemsPerSecond": 6.037553583288052,
+        "avgBatchDuration": 49682,
+        "minBatchDuration": 49678,
+        "maxBatchDuration": 49689,
+        "p50Duration": 49679,
+        "p95Duration": 49689,
+        "p99Duration": 49689
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51838,
+        "avgItemsPerSecond": 5.787260310968787,
+        "avgBatchDuration": 51483.333333333336,
+        "minBatchDuration": 50775,
+        "maxBatchDuration": 51838,
+        "p50Duration": 51837,
+        "p95Duration": 51838,
+        "p99Duration": 51838
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T14:58:47.844Z",
+    "end": "2025-12-15T14:59:39.791Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9997** (still excellent)
+- Throughput: **51.98 items/sec** (**WORST in B series**, -5% vs baseline)
+- Notable patterns: **Diminishing returns / counterproductive.** Very high quantum=50 actually hurt throughput. With 9 tenants each getting 50-item bursts, tenants wait too long for their turn. **Sweet spot appears to be quantum=25.**
+
+</details>
+
+---
+
+## Series C: Max Deficit Variations
+
+**Objective:** Understand how max deficit cap affects catch-up behavior for starved tenants.
+
+**Theory:**
+
+- Lower max deficit = limits how much a starved tenant can "catch up"
+- Higher max deficit = allows more aggressive catch-up, but could starve other tenants
+
+### Test C1: Low Max Deficit (maxDeficit=10)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=10
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Low maxDeficit=10"
+```
+
+<details>
+<summary>Results C1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Low maxDeficit=10",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 52.51385782359234,
+    "overallDuration": 51415,
+    "fairnessIndex": 0.9997739979483051,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49624,
+        "avgItemsPerSecond": 6.0454618732871195,
+        "avgBatchDuration": 49357.333333333336,
+        "minBatchDuration": 48832,
+        "maxBatchDuration": 49624,
+        "p50Duration": 49616,
+        "p95Duration": 49624,
+        "p99Duration": 49624
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51230,
+        "avgItemsPerSecond": 5.8559437829396845,
+        "avgBatchDuration": 50431,
+        "minBatchDuration": 49201,
+        "maxBatchDuration": 51230,
+        "p50Duration": 50862,
+        "p95Duration": 51230,
+        "p99Duration": 51230
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51410,
+        "avgItemsPerSecond": 5.83544057576347,
+        "avgBatchDuration": 49448.333333333336,
+        "minBatchDuration": 45734,
+        "maxBatchDuration": 51410,
+        "p50Duration": 51201,
+        "p95Duration": 51410,
+        "p99Duration": 51410
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49206,
+        "avgItemsPerSecond": 6.096817461285209,
+        "avgBatchDuration": 46922.333333333336,
+        "minBatchDuration": 42366,
+        "maxBatchDuration": 49201,
+        "p50Duration": 49200,
+        "p95Duration": 49201,
+        "p99Duration": 49201
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 50661,
+        "avgItemsPerSecond": 5.921714928643334,
+        "avgBatchDuration": 48617.666666666664,
+        "minBatchDuration": 46575,
+        "maxBatchDuration": 50661,
+        "p50Duration": 48617,
+        "p95Duration": 50661,
+        "p99Duration": 50661
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 50189,
+        "avgItemsPerSecond": 5.977405407559425,
+        "avgBatchDuration": 49945.666666666664,
+        "minBatchDuration": 49823,
+        "maxBatchDuration": 50189,
+        "p50Duration": 49825,
+        "p95Duration": 50189,
+        "p99Duration": 50189
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 51232,
+        "avgItemsPerSecond": 5.8557151780137415,
+        "avgBatchDuration": 50892.333333333336,
+        "minBatchDuration": 50636,
+        "maxBatchDuration": 51229,
+        "p50Duration": 50812,
+        "p95Duration": 51229,
+        "p99Duration": 51229
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 49639,
+        "avgItemsPerSecond": 6.0436350450250815,
+        "avgBatchDuration": 44099,
+        "minBatchDuration": 41326,
+        "maxBatchDuration": 49638,
+        "p50Duration": 41333,
+        "p95Duration": 49638,
+        "p99Duration": 49638
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 50193,
+        "avgItemsPerSecond": 5.976929053852131,
+        "avgBatchDuration": 49979.666666666664,
+        "minBatchDuration": 49623,
+        "maxBatchDuration": 50193,
+        "p50Duration": 50123,
+        "p95Duration": 50193,
+        "p99Duration": 50193
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:01:17.027Z",
+    "end": "2025-12-15T15:02:08.442Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9998** (excellent)
+- Throughput: **52.51 items/sec** (similar to baseline)
+- Recovery behavior: **Constrained.** Low max deficit limits catch-up ability. Total duration 51.4s, consistent with limited burst capacity.
+
+</details>
+
+### Test C2: Medium Max Deficit (maxDeficit=25)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=25
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Medium maxDeficit=25"
+```
+
+<details>
+<summary>Results C2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Medium maxDeficit=25",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 66.32928806564142,
+    "overallDuration": 40706,
+    "fairnessIndex": 0.9992454865624668,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 39801,
+        "avgItemsPerSecond": 7.537499057812618,
+        "avgBatchDuration": 35339.333333333336,
+        "minBatchDuration": 28824,
+        "maxBatchDuration": 39800,
+        "p50Duration": 37394,
+        "p95Duration": 39800,
+        "p99Duration": 39800
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 39487,
+        "avgItemsPerSecond": 7.597437131207739,
+        "avgBatchDuration": 36988.666666666664,
+        "minBatchDuration": 34055,
+        "maxBatchDuration": 39486,
+        "p50Duration": 37425,
+        "p95Duration": 39486,
+        "p99Duration": 39486
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37449,
+        "avgItemsPerSecond": 8.010894816951053,
+        "avgBatchDuration": 36409.333333333336,
+        "minBatchDuration": 34337,
+        "maxBatchDuration": 37447,
+        "p50Duration": 37444,
+        "p95Duration": 37447,
+        "p99Duration": 37447
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40648,
+        "avgItemsPerSecond": 7.380436921865774,
+        "avgBatchDuration": 39841.666666666664,
+        "minBatchDuration": 39419,
+        "maxBatchDuration": 40647,
+        "p50Duration": 39459,
+        "p95Duration": 40647,
+        "p99Duration": 40647
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38760,
+        "avgItemsPerSecond": 7.739938080495356,
+        "avgBatchDuration": 36378.333333333336,
+        "minBatchDuration": 33012,
+        "maxBatchDuration": 38750,
+        "p50Duration": 37373,
+        "p95Duration": 38750,
+        "p99Duration": 38750
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37706,
+        "avgItemsPerSecond": 7.956293428101628,
+        "avgBatchDuration": 37609.333333333336,
+        "minBatchDuration": 37424,
+        "maxBatchDuration": 37706,
+        "p50Duration": 37698,
+        "p95Duration": 37706,
+        "p99Duration": 37706
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40621,
+        "avgItemsPerSecond": 7.385342556805593,
+        "avgBatchDuration": 38921,
+        "minBatchDuration": 36642,
+        "maxBatchDuration": 40621,
+        "p50Duration": 39500,
+        "p95Duration": 40621,
+        "p99Duration": 40621
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38757,
+        "avgItemsPerSecond": 7.740537193281214,
+        "avgBatchDuration": 38744,
+        "minBatchDuration": 38730,
+        "maxBatchDuration": 38757,
+        "p50Duration": 38745,
+        "p95Duration": 38757,
+        "p99Duration": 38757
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38751,
+        "avgItemsPerSecond": 7.741735697143299,
+        "avgBatchDuration": 37674.666666666664,
+        "minBatchDuration": 35558,
+        "maxBatchDuration": 38740,
+        "p50Duration": 38726,
+        "p95Duration": 38740,
+        "p99Duration": 38740
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:03:24.382Z",
+    "end": "2025-12-15T15:04:05.088Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9992** (slightly lower but still very good)
+- Throughput: **66.33 items/sec** (+22% vs baseline)
+- Recovery behavior: **Better.** More headroom for catch-up. Duration dropped from 51.4s (C1) to 40.7s.
+
+</details>
+
+### Test C3: High Max Deficit (maxDeficit=100)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=100
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "High maxDeficit=100"
+```
+
+<details>
+<summary>Results C3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "High maxDeficit=100",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 73.73624272878718,
+    "overallDuration": 36617,
+    "fairnessIndex": 0.9988716605255289,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 32809,
+        "avgItemsPerSecond": 9.143832484988875,
+        "avgBatchDuration": 30391.666666666668,
+        "minBatchDuration": 28722,
+        "maxBatchDuration": 32751,
+        "p50Duration": 29702,
+        "p95Duration": 32751,
+        "p99Duration": 32751
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 36540,
+        "avgItemsPerSecond": 8.210180623973727,
+        "avgBatchDuration": 28375.666666666668,
+        "minBatchDuration": 13115,
+        "maxBatchDuration": 36537,
+        "p50Duration": 35475,
+        "p95Duration": 36537,
+        "p99Duration": 36537
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 36337,
+        "avgItemsPerSecond": 8.256047554833916,
+        "avgBatchDuration": 28524.666666666668,
+        "minBatchDuration": 13114,
+        "maxBatchDuration": 36322,
+        "p50Duration": 36138,
+        "p95Duration": 36322,
+        "p99Duration": 36322
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 35478,
+        "avgItemsPerSecond": 8.45594452900389,
+        "avgBatchDuration": 27529.333333333332,
+        "minBatchDuration": 23556,
+        "maxBatchDuration": 35475,
+        "p50Duration": 23557,
+        "p95Duration": 35475,
+        "p99Duration": 35475
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 35453,
+        "avgItemsPerSecond": 8.461907313908554,
+        "avgBatchDuration": 35291,
+        "minBatchDuration": 35039,
+        "maxBatchDuration": 35438,
+        "p50Duration": 35396,
+        "p95Duration": 35438,
+        "p99Duration": 35438
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 36430,
+        "avgItemsPerSecond": 8.23497117760088,
+        "avgBatchDuration": 34851.333333333336,
+        "minBatchDuration": 31705,
+        "maxBatchDuration": 36425,
+        "p50Duration": 36424,
+        "p95Duration": 36425,
+        "p99Duration": 36425
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 36500,
+        "avgItemsPerSecond": 8.21917808219178,
+        "avgBatchDuration": 31197,
+        "minBatchDuration": 27638,
+        "maxBatchDuration": 36495,
+        "p50Duration": 29458,
+        "p95Duration": 36495,
+        "p99Duration": 36495
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 36573,
+        "avgItemsPerSecond": 8.202772537117545,
+        "avgBatchDuration": 27671.666666666668,
+        "minBatchDuration": 23222,
+        "maxBatchDuration": 36570,
+        "p50Duration": 23223,
+        "p95Duration": 36570,
+        "p99Duration": 36570
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 35514,
+        "avgItemsPerSecond": 8.44737286703835,
+        "avgBatchDuration": 35127.666666666664,
+        "minBatchDuration": 34370,
+        "maxBatchDuration": 35511,
+        "p50Duration": 35502,
+        "p95Duration": 35511,
+        "p99Duration": 35511
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:06:48.615Z",
+    "end": "2025-12-15T15:07:25.232Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness index: **0.9989** (slightly lower due to more aggressive catch-up)
+- Throughput: **73.74 items/sec** (**+35% vs baseline**, best in C series)
+- Any evidence of new tenant starvation during catch-up?: **Minor variance.** Some tenants took 13-37s for batches (wider spread) but all finished within reasonable bounds. **Higher max deficit = better throughput but slightly more variance.**
+
+</details>
+
+---
+
+## Series D: Consumer Count Variations
+
+**Objective:** Test parallelism within a single process.
+
+**Theory:**
+
+- More consumers = higher potential throughput (limited by concurrency limits)
+- Diminishing returns expected as consumers contend for the same work
+
+### Test D1: Single Consumer (baseline)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=1
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Single consumer"
+```
+
+<details>
+<summary>Results D1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Single consumer",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 41.326108917255944,
+    "overallDuration": 65334,
+    "fairnessIndex": 0.9996736075271871,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 62086,
+        "avgItemsPerSecond": 4.832007215797443,
+        "avgBatchDuration": 60490.333333333336,
+        "minBatchDuration": 59021,
+        "maxBatchDuration": 62084,
+        "p50Duration": 60366,
+        "p95Duration": 62084,
+        "p99Duration": 62084
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 65000,
+        "avgItemsPerSecond": 4.615384615384616,
+        "avgBatchDuration": 63631.333333333336,
+        "minBatchDuration": 61952,
+        "maxBatchDuration": 64991,
+        "p50Duration": 63951,
+        "p95Duration": 64991,
+        "p99Duration": 64991
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 62539,
+        "avgItemsPerSecond": 4.797006667839269,
+        "avgBatchDuration": 60631,
+        "minBatchDuration": 58991,
+        "maxBatchDuration": 62536,
+        "p50Duration": 60366,
+        "p95Duration": 62536,
+        "p99Duration": 62536
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 64125,
+        "avgItemsPerSecond": 4.678362573099415,
+        "avgBatchDuration": 61768.666666666664,
+        "minBatchDuration": 58220,
+        "maxBatchDuration": 64118,
+        "p50Duration": 62968,
+        "p95Duration": 64118,
+        "p99Duration": 64118
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 62536,
+        "avgItemsPerSecond": 4.797236791608034,
+        "avgBatchDuration": 55644,
+        "minBatchDuration": 48107,
+        "maxBatchDuration": 62516,
+        "p50Duration": 56309,
+        "p95Duration": 62516,
+        "p99Duration": 62516
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 65257,
+        "avgItemsPerSecond": 4.597207962364191,
+        "avgBatchDuration": 62698.666666666664,
+        "minBatchDuration": 60933,
+        "maxBatchDuration": 65257,
+        "p50Duration": 61906,
+        "p95Duration": 65257,
+        "p99Duration": 65257
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 62654,
+        "avgItemsPerSecond": 4.788201870590864,
+        "avgBatchDuration": 60963.666666666664,
+        "minBatchDuration": 59342,
+        "maxBatchDuration": 62654,
+        "p50Duration": 60895,
+        "p95Duration": 62654,
+        "p99Duration": 62654
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 62966,
+        "avgItemsPerSecond": 4.76447606644856,
+        "avgBatchDuration": 61417.333333333336,
+        "minBatchDuration": 60031,
+        "maxBatchDuration": 62961,
+        "p50Duration": 61260,
+        "p95Duration": 62961,
+        "p99Duration": 62961
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 64690,
+        "avgItemsPerSecond": 4.637501932292472,
+        "avgBatchDuration": 59325,
+        "minBatchDuration": 51023,
+        "maxBatchDuration": 64686,
+        "p50Duration": 62266,
+        "p95Duration": 64686,
+        "p99Duration": 64686
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:09:10.445Z",
+    "end": "2025-12-15T15:10:15.779Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **41.33 items/sec** (lowest in D series, -24% vs baseline)
+- Fairness: **0.9997** (excellent)
+- **Single consumer is a bottleneck.** Total duration 65.3s. Each tenant averaging only ~4.6 items/sec.
+
+</details>
+
+### Test D2: Multiple Consumers (count=3)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "3 consumers"
+```
+
+<details>
+<summary>Results D2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "3 consumers",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 57.55211663895639,
+    "overallDuration": 46914,
+    "fairnessIndex": 0.9992021047885379,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46746,
+        "avgItemsPerSecond": 6.417661404184315,
+        "avgBatchDuration": 46353,
+        "minBatchDuration": 45585,
+        "maxBatchDuration": 46746,
+        "p50Duration": 46728,
+        "p95Duration": 46746,
+        "p99Duration": 46746
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46812,
+        "avgItemsPerSecond": 6.40861317610869,
+        "avgBatchDuration": 46805,
+        "minBatchDuration": 46794,
+        "maxBatchDuration": 46812,
+        "p50Duration": 46809,
+        "p95Duration": 46812,
+        "p99Duration": 46812
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46606,
+        "avgItemsPerSecond": 6.436939449856242,
+        "avgBatchDuration": 38880,
+        "minBatchDuration": 33105,
+        "maxBatchDuration": 46604,
+        "p50Duration": 36931,
+        "p95Duration": 46604,
+        "p99Duration": 46604
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46821,
+        "avgItemsPerSecond": 6.407381303261357,
+        "avgBatchDuration": 46059,
+        "minBatchDuration": 45679,
+        "maxBatchDuration": 46810,
+        "p50Duration": 45688,
+        "p95Duration": 46810,
+        "p99Duration": 46810
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 43729,
+        "avgItemsPerSecond": 6.860435866358709,
+        "avgBatchDuration": 42251,
+        "minBatchDuration": 39304,
+        "maxBatchDuration": 43729,
+        "p50Duration": 43720,
+        "p95Duration": 43729,
+        "p99Duration": 43729
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46597,
+        "avgItemsPerSecond": 6.438182715625469,
+        "avgBatchDuration": 45484.333333333336,
+        "minBatchDuration": 44415,
+        "maxBatchDuration": 46567,
+        "p50Duration": 45471,
+        "p95Duration": 46567,
+        "p99Duration": 46567
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46808,
+        "avgItemsPerSecond": 6.409160827209024,
+        "avgBatchDuration": 45405,
+        "minBatchDuration": 43679,
+        "maxBatchDuration": 46761,
+        "p50Duration": 45775,
+        "p95Duration": 46761,
+        "p99Duration": 46761
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46811,
+        "avgItemsPerSecond": 6.408750080109376,
+        "avgBatchDuration": 45293,
+        "minBatchDuration": 44526,
+        "maxBatchDuration": 46784,
+        "p50Duration": 44569,
+        "p95Duration": 46784,
+        "p99Duration": 46784
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 43732,
+        "avgItemsPerSecond": 6.859965242842769,
+        "avgBatchDuration": 41508,
+        "minBatchDuration": 39455,
+        "maxBatchDuration": 43581,
+        "p50Duration": 41488,
+        "p95Duration": 43581,
+        "p99Duration": 43581
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:11:42.929Z",
+    "end": "2025-12-15T15:12:29.843Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **57.55 items/sec** (vs single: **1.39x** improvement)
+- Fairness impact: **0.9992** (very minor degradation)
+- Duration dropped from 65.3s to 46.9s. **3 consumers is a good balance.**
+
+</details>
+
+### Test D3: Many Consumers (count=5)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=5
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "5 consumers"
+```
+
+<details>
+<summary>Results D3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "5 consumers",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 63.80263717566993,
+    "overallDuration": 42318,
+    "fairnessIndex": 0.9999000645903268,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41203,
+        "avgItemsPerSecond": 7.281023226464092,
+        "avgBatchDuration": 40931,
+        "minBatchDuration": 40810,
+        "maxBatchDuration": 41167,
+        "p50Duration": 40816,
+        "p95Duration": 41167,
+        "p99Duration": 41167
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41814,
+        "avgItemsPerSecond": 7.1746305065289135,
+        "avgBatchDuration": 37657.333333333336,
+        "minBatchDuration": 35575,
+        "maxBatchDuration": 41814,
+        "p50Duration": 35583,
+        "p95Duration": 41814,
+        "p99Duration": 41814
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41795,
+        "avgItemsPerSecond": 7.177892092355545,
+        "avgBatchDuration": 37201.666666666664,
+        "minBatchDuration": 34298,
+        "maxBatchDuration": 41795,
+        "p50Duration": 35512,
+        "p95Duration": 41795,
+        "p99Duration": 41795
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41837,
+        "avgItemsPerSecond": 7.170686234672658,
+        "avgBatchDuration": 40580.333333333336,
+        "minBatchDuration": 38694,
+        "maxBatchDuration": 41833,
+        "p50Duration": 41214,
+        "p95Duration": 41833,
+        "p99Duration": 41833
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41829,
+        "avgItemsPerSecond": 7.1720576633436135,
+        "avgBatchDuration": 39891.666666666664,
+        "minBatchDuration": 37128,
+        "maxBatchDuration": 41786,
+        "p50Duration": 40761,
+        "p95Duration": 41786,
+        "p99Duration": 41786
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 42246,
+        "avgItemsPerSecond": 7.10126402499645,
+        "avgBatchDuration": 34807.333333333336,
+        "minBatchDuration": 28353,
+        "maxBatchDuration": 42154,
+        "p50Duration": 33915,
+        "p95Duration": 42154,
+        "p99Duration": 42154
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41654,
+        "avgItemsPerSecond": 7.202189465597542,
+        "avgBatchDuration": 40819.333333333336,
+        "minBatchDuration": 40181,
+        "maxBatchDuration": 41653,
+        "p50Duration": 40624,
+        "p95Duration": 41653,
+        "p99Duration": 41653
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 41210,
+        "avgItemsPerSecond": 7.279786459597185,
+        "avgBatchDuration": 40886.333333333336,
+        "minBatchDuration": 40630,
+        "maxBatchDuration": 41210,
+        "p50Duration": 40819,
+        "p95Duration": 41210,
+        "p99Duration": 41210
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 40813,
+        "avgItemsPerSecond": 7.350599073824517,
+        "avgBatchDuration": 37843.666666666664,
+        "minBatchDuration": 31921,
+        "maxBatchDuration": 40810,
+        "p50Duration": 40800,
+        "p95Duration": 40810,
+        "p99Duration": 40810
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:13:47.964Z",
+    "end": "2025-12-15T15:14:30.282Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **63.80 items/sec** (vs 3 consumers: **1.11x** improvement)
+- Fairness: **0.9999** (nearly perfect!)
+- Diminishing returns?: **Yes, starting to see it.** Going from 3→5 consumers added ~11% throughput. Still beneficial but less dramatic.
+
+</details>
+
+### Test D4: High Consumer Count (count=10)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=10
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "10 consumers"
+```
+
+<details>
+<summary>Results D4 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "10 consumers",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 114.94252873563218,
+    "overallDuration": 23490,
+    "fairnessIndex": 0.9887990604258773,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 23004,
+        "avgItemsPerSecond": 13.041210224308816,
+        "avgBatchDuration": 21971,
+        "minBatchDuration": 19947,
+        "maxBatchDuration": 23004,
+        "p50Duration": 22962,
+        "p95Duration": 23004,
+        "p99Duration": 23004
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 22777,
+        "avgItemsPerSecond": 13.171181454976512,
+        "avgBatchDuration": 21004.666666666668,
+        "minBatchDuration": 18477,
+        "maxBatchDuration": 22775,
+        "p50Duration": 21762,
+        "p95Duration": 22775,
+        "p99Duration": 22775
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 21772,
+        "avgItemsPerSecond": 13.77916590115745,
+        "avgBatchDuration": 21014.666666666668,
+        "minBatchDuration": 19505,
+        "maxBatchDuration": 21772,
+        "p50Duration": 21767,
+        "p95Duration": 21772,
+        "p99Duration": 21772
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 22339,
+        "avgItemsPerSecond": 13.42942835399973,
+        "avgBatchDuration": 21297.333333333332,
+        "minBatchDuration": 20240,
+        "maxBatchDuration": 22339,
+        "p50Duration": 21313,
+        "p95Duration": 22339,
+        "p99Duration": 22339
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 22597,
+        "avgItemsPerSecond": 13.276098597158914,
+        "avgBatchDuration": 20592.333333333332,
+        "minBatchDuration": 17413,
+        "maxBatchDuration": 22597,
+        "p50Duration": 21767,
+        "p95Duration": 22597,
+        "p99Duration": 22597
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 21762,
+        "avgItemsPerSecond": 13.785497656465399,
+        "avgBatchDuration": 21700,
+        "minBatchDuration": 21578,
+        "maxBatchDuration": 21762,
+        "p50Duration": 21760,
+        "p95Duration": 21762,
+        "p99Duration": 21762
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 22275,
+        "avgItemsPerSecond": 13.468013468013467,
+        "avgBatchDuration": 22239.333333333332,
+        "minBatchDuration": 22218,
+        "maxBatchDuration": 22275,
+        "p50Duration": 22225,
+        "p95Duration": 22275,
+        "p99Duration": 22275
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 16719,
+        "avgItemsPerSecond": 17.94365691727974,
+        "avgBatchDuration": 15697,
+        "minBatchDuration": 13656,
+        "maxBatchDuration": 16719,
+        "p50Duration": 16716,
+        "p95Duration": 16719,
+        "p99Duration": 16719
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 23387,
+        "avgItemsPerSecond": 12.827639286783254,
+        "avgBatchDuration": 23160.333333333332,
+        "minBatchDuration": 22770,
+        "maxBatchDuration": 23387,
+        "p50Duration": 23324,
+        "p95Duration": 23387,
+        "p99Duration": 23387
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:16:28.939Z",
+    "end": "2025-12-15T15:16:52.429Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **114.94 items/sec** (**BEST IN ALL TESTS SO FAR!** 2.78x vs single consumer)
+- Fairness: **0.9888** (noticeably lower - some tenants got 17s while others got 23s)
+- CPU impact: **Not measured, but likely higher.**
+- Contention visible?: **Yes, fairness degradation suggests some contention/scheduling variance.** One tenant (org-3:efaelbvnogkhjnrdfsmi) finished in 16.7s while others took 21-23s. **10 consumers is great for throughput but comes at fairness cost.**
+
+</details>
+
+---
+
+## Series E: Consumer Interval Variations
+
+**Objective:** Test polling frequency impact on throughput and latency.
+
+**Theory:**
+
+- Lower interval = more responsive, higher CPU usage
+- Higher interval = lower CPU, higher latency for new work
+
+### Test E1: Fast Polling (interval=20ms)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=20
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Fast polling 20ms"
+```
+
+<details>
+<summary>Results E1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Fast polling 20ms",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 70.23019898556379,
+    "overallDuration": 38445,
+    "fairnessIndex": 0.9979118686098942,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38383,
+        "avgItemsPerSecond": 7.815960190709429,
+        "avgBatchDuration": 32665.333333333332,
+        "minBatchDuration": 28219,
+        "maxBatchDuration": 38381,
+        "p50Duration": 31396,
+        "p95Duration": 38381,
+        "p99Duration": 38381
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37376,
+        "avgItemsPerSecond": 8.026541095890412,
+        "avgBatchDuration": 37178.333333333336,
+        "minBatchDuration": 36801,
+        "maxBatchDuration": 37376,
+        "p50Duration": 37358,
+        "p95Duration": 37376,
+        "p99Duration": 37376
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37361,
+        "avgItemsPerSecond": 8.029763657289687,
+        "avgBatchDuration": 29490.666666666668,
+        "minBatchDuration": 23952,
+        "maxBatchDuration": 37361,
+        "p50Duration": 27159,
+        "p95Duration": 37361,
+        "p99Duration": 37361
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37997,
+        "avgItemsPerSecond": 7.895360160012633,
+        "avgBatchDuration": 36532,
+        "minBatchDuration": 34226,
+        "maxBatchDuration": 37994,
+        "p50Duration": 37376,
+        "p95Duration": 37994,
+        "p99Duration": 37994
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37889,
+        "avgItemsPerSecond": 7.917865343503392,
+        "avgBatchDuration": 36989,
+        "minBatchDuration": 35364,
+        "maxBatchDuration": 37867,
+        "p50Duration": 37736,
+        "p95Duration": 37867,
+        "p99Duration": 37867
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 37359,
+        "avgItemsPerSecond": 8.030193527664016,
+        "avgBatchDuration": 36533.666666666664,
+        "minBatchDuration": 35927,
+        "maxBatchDuration": 37357,
+        "p50Duration": 36317,
+        "p95Duration": 37357,
+        "p99Duration": 37357
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38245,
+        "avgItemsPerSecond": 7.844162635638646,
+        "avgBatchDuration": 34851.333333333336,
+        "minBatchDuration": 28081,
+        "maxBatchDuration": 38237,
+        "p50Duration": 38236,
+        "p95Duration": 38237,
+        "p99Duration": 38237
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 38090,
+        "avgItemsPerSecond": 7.876082961407193,
+        "avgBatchDuration": 36777.666666666664,
+        "minBatchDuration": 34984,
+        "maxBatchDuration": 38019,
+        "p50Duration": 37330,
+        "p95Duration": 38019,
+        "p99Duration": 38019
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 33054,
+        "avgItemsPerSecond": 9.076057360682519,
+        "avgBatchDuration": 24749.666666666668,
+        "minBatchDuration": 17350,
+        "maxBatchDuration": 33048,
+        "p50Duration": 23851,
+        "p95Duration": 33048,
+        "p99Duration": 33048
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:18:51.094Z",
+    "end": "2025-12-15T15:19:29.539Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **70.23 items/sec** (good improvement over baseline)
+- Fairness: **0.9979** (slightly lower)
+- CPU usage (if observed): **Expected higher due to more frequent polling.** Faster polling didn't dramatically improve throughput - suggests bottleneck is elsewhere (processing time, not poll latency).
+
+</details>
+
+### Test E2: Medium Polling (interval=50ms)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Medium polling 50ms"
+```
+
+<details>
+<summary>Results E2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Medium polling 50ms",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 93.56806210146937,
+    "overallDuration": 28856,
+    "fairnessIndex": 0.9994094367115308,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28584,
+        "avgItemsPerSecond": 10.495382031905962,
+        "avgBatchDuration": 26949,
+        "minBatchDuration": 25606,
+        "maxBatchDuration": 28582,
+        "p50Duration": 26659,
+        "p95Duration": 28582,
+        "p99Duration": 28582
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28733,
+        "avgItemsPerSecond": 10.440956391605472,
+        "avgBatchDuration": 28390,
+        "minBatchDuration": 27709,
+        "maxBatchDuration": 28732,
+        "p50Duration": 28729,
+        "p95Duration": 28732,
+        "p99Duration": 28732
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 26660,
+        "avgItemsPerSecond": 11.252813203300825,
+        "avgBatchDuration": 24539,
+        "minBatchDuration": 20303,
+        "maxBatchDuration": 26660,
+        "p50Duration": 26654,
+        "p95Duration": 26660,
+        "p99Duration": 26660
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28729,
+        "avgItemsPerSecond": 10.442410108252986,
+        "avgBatchDuration": 28355.333333333332,
+        "minBatchDuration": 27708,
+        "maxBatchDuration": 28727,
+        "p50Duration": 28631,
+        "p95Duration": 28727,
+        "p99Duration": 28727
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28732,
+        "avgItemsPerSecond": 10.44131978282055,
+        "avgBatchDuration": 23195.666666666668,
+        "minBatchDuration": 13149,
+        "maxBatchDuration": 28729,
+        "p50Duration": 27709,
+        "p95Duration": 28729,
+        "p99Duration": 28729
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28683,
+        "avgItemsPerSecond": 10.459156991946449,
+        "avgBatchDuration": 28325,
+        "minBatchDuration": 27667,
+        "maxBatchDuration": 28680,
+        "p50Duration": 28628,
+        "p95Duration": 28680,
+        "p99Duration": 28680
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28728,
+        "avgItemsPerSecond": 10.442773600668337,
+        "avgBatchDuration": 28049,
+        "minBatchDuration": 26791,
+        "maxBatchDuration": 28728,
+        "p50Duration": 28628,
+        "p95Duration": 28728,
+        "p99Duration": 28728
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28829,
+        "avgItemsPerSecond": 10.406188213257483,
+        "avgBatchDuration": 28452.666666666668,
+        "minBatchDuration": 27805,
+        "maxBatchDuration": 28829,
+        "p50Duration": 28724,
+        "p95Duration": 28829,
+        "p99Duration": 28829
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28824,
+        "avgItemsPerSecond": 10.407993338884264,
+        "avgBatchDuration": 28786.666666666668,
+        "minBatchDuration": 28727,
+        "maxBatchDuration": 28817,
+        "p50Duration": 28816,
+        "p95Duration": 28817,
+        "p99Duration": 28817
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:20:41.913Z",
+    "end": "2025-12-15T15:21:10.769Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **93.57 items/sec** (**BEST in E series!** +72% vs baseline)
+- Fairness: **0.9994** (excellent)
+- **50ms polling with 3 consumers is a sweet spot.** Much better than 20ms (70.23) - suggests 20ms introduced contention overhead.
+
+</details>
+
+### Test E3: Default Polling (interval=100ms)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=100
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Default polling 100ms"
+```
+
+<details>
+<summary>Results E3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Default polling 100ms",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 86.52182272639877,
+    "overallDuration": 31206,
+    "fairnessIndex": 0.9996560386487722,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31119,
+        "avgItemsPerSecond": 9.640412609659693,
+        "avgBatchDuration": 24846,
+        "minBatchDuration": 12442,
+        "maxBatchDuration": 31116,
+        "p50Duration": 30980,
+        "p95Duration": 31116,
+        "p99Duration": 31116
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30083,
+        "avgItemsPerSecond": 9.972409666589103,
+        "avgBatchDuration": 28193.666666666668,
+        "minBatchDuration": 24794,
+        "maxBatchDuration": 30082,
+        "p50Duration": 29705,
+        "p95Duration": 30082,
+        "p99Duration": 30082
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30774,
+        "avgItemsPerSecond": 9.748488984207448,
+        "avgBatchDuration": 28711.333333333332,
+        "minBatchDuration": 26655,
+        "maxBatchDuration": 30774,
+        "p50Duration": 28705,
+        "p95Duration": 30774,
+        "p99Duration": 30774
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29722,
+        "avgItemsPerSecond": 10.093533409595585,
+        "avgBatchDuration": 29380.666666666668,
+        "minBatchDuration": 28699,
+        "maxBatchDuration": 29722,
+        "p50Duration": 29721,
+        "p95Duration": 29722,
+        "p99Duration": 29722
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30761,
+        "avgItemsPerSecond": 9.752608822860115,
+        "avgBatchDuration": 28703,
+        "minBatchDuration": 27637,
+        "maxBatchDuration": 30759,
+        "p50Duration": 27713,
+        "p95Duration": 30759,
+        "p99Duration": 30759
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29721,
+        "avgItemsPerSecond": 10.093873019077419,
+        "avgBatchDuration": 29032.333333333332,
+        "minBatchDuration": 27674,
+        "maxBatchDuration": 29719,
+        "p50Duration": 29704,
+        "p95Duration": 29719,
+        "p99Duration": 29719
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30089,
+        "avgItemsPerSecond": 9.97042108411712,
+        "avgBatchDuration": 23863.666666666668,
+        "minBatchDuration": 12440,
+        "maxBatchDuration": 30087,
+        "p50Duration": 29064,
+        "p95Duration": 30087,
+        "p99Duration": 30087
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29704,
+        "avgItemsPerSecond": 10.099649878804202,
+        "avgBatchDuration": 23475,
+        "minBatchDuration": 20361,
+        "maxBatchDuration": 29701,
+        "p50Duration": 20363,
+        "p95Duration": 29701,
+        "p99Duration": 29701
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31114,
+        "avgItemsPerSecond": 9.641961817831202,
+        "avgBatchDuration": 30969.333333333332,
+        "minBatchDuration": 30943,
+        "maxBatchDuration": 30984,
+        "p50Duration": 30981,
+        "p95Duration": 30984,
+        "p99Duration": 30984
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:22:27.627Z",
+    "end": "2025-12-15T15:22:58.833Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **86.52 items/sec** (+59% vs baseline)
+- Fairness: **0.9997** (excellent)
+- 100ms default is solid but slightly lower than 50ms (93.57). **100ms is a good default for balance.**
+
+</details>
+
+### Test E4: Slow Polling (interval=250ms)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=250
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Slow polling 250ms"
+```
+
+<details>
+<summary>Results E4 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Slow polling 250ms",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 47.45583970471922,
+    "overallDuration": 56895,
+    "fairnessIndex": 0.9993684226112225,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 56835,
+        "avgItemsPerSecond": 5.278437582475587,
+        "avgBatchDuration": 56487.666666666664,
+        "minBatchDuration": 56107,
+        "maxBatchDuration": 56835,
+        "p50Duration": 56521,
+        "p95Duration": 56835,
+        "p99Duration": 56835
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 56711,
+        "avgItemsPerSecond": 5.289979016416568,
+        "avgBatchDuration": 48760.666666666664,
+        "minBatchDuration": 34046,
+        "maxBatchDuration": 56710,
+        "p50Duration": 55526,
+        "p95Duration": 56710,
+        "p99Duration": 56710
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 55715,
+        "avgItemsPerSecond": 5.384546351969847,
+        "avgBatchDuration": 55026.666666666664,
+        "minBatchDuration": 54680,
+        "maxBatchDuration": 55715,
+        "p50Duration": 54685,
+        "p95Duration": 55715,
+        "p99Duration": 55715
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 56114,
+        "avgItemsPerSecond": 5.346259400506113,
+        "avgBatchDuration": 47434,
+        "minBatchDuration": 42815,
+        "maxBatchDuration": 56109,
+        "p50Duration": 43378,
+        "p95Duration": 56109,
+        "p99Duration": 56109
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 52049,
+        "avgItemsPerSecond": 5.763799496628177,
+        "avgBatchDuration": 51173,
+        "minBatchDuration": 49551,
+        "maxBatchDuration": 52046,
+        "p50Duration": 51922,
+        "p95Duration": 52046,
+        "p99Duration": 52046
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 55787,
+        "avgItemsPerSecond": 5.377596931184685,
+        "avgBatchDuration": 55069.666666666664,
+        "minBatchDuration": 53713,
+        "maxBatchDuration": 55787,
+        "p50Duration": 55709,
+        "p95Duration": 55787,
+        "p99Duration": 55787
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 55790,
+        "avgItemsPerSecond": 5.377307761247535,
+        "avgBatchDuration": 47576,
+        "minBatchDuration": 31153,
+        "maxBatchDuration": 55788,
+        "p50Duration": 55787,
+        "p95Duration": 55788,
+        "p99Duration": 55788
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 56010,
+        "avgItemsPerSecond": 5.356186395286556,
+        "avgBatchDuration": 47534.333333333336,
+        "minBatchDuration": 30885,
+        "maxBatchDuration": 56010,
+        "p50Duration": 55708,
+        "p95Duration": 56010,
+        "p99Duration": 56010
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 55784,
+        "avgItemsPerSecond": 5.377886132224293,
+        "avgBatchDuration": 55374.333333333336,
+        "minBatchDuration": 54732,
+        "maxBatchDuration": 55784,
+        "p50Duration": 55607,
+        "p95Duration": 55784,
+        "p99Duration": 55784
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:24:13.441Z",
+    "end": "2025-12-15T15:25:10.336Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **47.46 items/sec** (-13% vs baseline, worst in E series)
+- Fairness: **0.9994** (good)
+- Latency impact: **Significant.** Duration 56.9s vs 28.9s for 50ms. **250ms is too slow - introduces unnecessary latency between scheduling rounds.**
+
+</details>
+
+---
+
+## Series F: Concurrency Limit Variations
+
+**Objective:** Test per-environment processing concurrency limits.
+
+**Theory:**
+
+- Lower concurrency = throttled processing per env, better resource control
+- Higher concurrency = faster per-env processing, potentially starving smaller tenants
+
+### Test F1: Low Concurrency (concurrency=2)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=2
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Low concurrency=2"
+```
+
+<details>
+<summary>Results F1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Low concurrency=2",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 90.7288551362613,
+    "overallDuration": 29759,
+    "fairnessIndex": 0.9931064638844554,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28794,
+        "avgItemsPerSecond": 10.418837257762034,
+        "avgBatchDuration": 27016,
+        "minBatchDuration": 23890,
+        "maxBatchDuration": 28794,
+        "p50Duration": 28364,
+        "p95Duration": 28794,
+        "p99Duration": 28794
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29532,
+        "avgItemsPerSecond": 10.158472165786264,
+        "avgBatchDuration": 27720,
+        "minBatchDuration": 26284,
+        "maxBatchDuration": 29529,
+        "p50Duration": 27347,
+        "p95Duration": 29529,
+        "p99Duration": 29529
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29439,
+        "avgItemsPerSecond": 10.19056353816366,
+        "avgBatchDuration": 22083.333333333332,
+        "minBatchDuration": 10765,
+        "maxBatchDuration": 29423,
+        "p50Duration": 26062,
+        "p95Duration": 29423,
+        "p99Duration": 29423
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29529,
+        "avgItemsPerSecond": 10.15950421619425,
+        "avgBatchDuration": 22252.666666666668,
+        "minBatchDuration": 17683,
+        "maxBatchDuration": 29396,
+        "p50Duration": 19679,
+        "p95Duration": 29396,
+        "p99Duration": 29396
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28474,
+        "avgItemsPerSecond": 10.535927512818711,
+        "avgBatchDuration": 26113.666666666668,
+        "minBatchDuration": 24815,
+        "maxBatchDuration": 28474,
+        "p50Duration": 25052,
+        "p95Duration": 28474,
+        "p99Duration": 28474
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 22890,
+        "avgItemsPerSecond": 13.10615989515072,
+        "avgBatchDuration": 22201.666666666668,
+        "minBatchDuration": 20834,
+        "maxBatchDuration": 22887,
+        "p50Duration": 22884,
+        "p95Duration": 22887,
+        "p99Duration": 22887
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 27952,
+        "avgItemsPerSecond": 10.732684602175159,
+        "avgBatchDuration": 21568.333333333332,
+        "minBatchDuration": 18289,
+        "maxBatchDuration": 27826,
+        "p50Duration": 18590,
+        "p95Duration": 27826,
+        "p99Duration": 27826
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28473,
+        "avgItemsPerSecond": 10.536297545042672,
+        "avgBatchDuration": 26193.333333333332,
+        "minBatchDuration": 25054,
+        "maxBatchDuration": 28470,
+        "p50Duration": 25056,
+        "p95Duration": 28470,
+        "p99Duration": 28470
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29668,
+        "avgItemsPerSecond": 10.111905082917621,
+        "avgBatchDuration": 28195.666666666668,
+        "minBatchDuration": 25936,
+        "maxBatchDuration": 29562,
+        "p50Duration": 29089,
+        "p95Duration": 29562,
+        "p99Duration": 29562
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:27:02.038Z",
+    "end": "2025-12-15T15:27:31.797Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **90.73 items/sec** (+66% vs baseline)
+- Fairness index: **0.9931** (slightly degraded)
+- Processing time variance: **Higher.** One tenant (org-2:giomqjmqmqbcngusxqfo) finished in 22.9s while others took 28-30s. **Low concurrency=2 paradoxically gave high throughput but with fairness cost.** The system may be "batching up" work more efficiently but creating uneven distribution.
+
+</details>
+
+### Test F2: Medium Concurrency (concurrency=5)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=5
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Medium concurrency=5"
+```
+
+<details>
+<summary>Results F2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Medium concurrency=5",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 58.25368400612742,
+    "overallDuration": 46349,
+    "fairnessIndex": 0.9998661349420435,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46278,
+        "avgItemsPerSecond": 6.482561908466226,
+        "avgBatchDuration": 45090,
+        "minBatchDuration": 43007,
+        "maxBatchDuration": 46275,
+        "p50Duration": 45988,
+        "p95Duration": 46275,
+        "p99Duration": 46275
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 45205,
+        "avgItemsPerSecond": 6.63643402278509,
+        "avgBatchDuration": 44818,
+        "minBatchDuration": 44147,
+        "maxBatchDuration": 45164,
+        "p50Duration": 45143,
+        "p95Duration": 45164,
+        "p99Duration": 45164
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 45206,
+        "avgItemsPerSecond": 6.636287218510818,
+        "avgBatchDuration": 44442,
+        "minBatchDuration": 43086,
+        "maxBatchDuration": 45206,
+        "p50Duration": 45034,
+        "p95Duration": 45206,
+        "p99Duration": 45206
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 45210,
+        "avgItemsPerSecond": 6.635700066357001,
+        "avgBatchDuration": 44481.666666666664,
+        "minBatchDuration": 43090,
+        "maxBatchDuration": 45210,
+        "p50Duration": 45145,
+        "p95Duration": 45210,
+        "p99Duration": 45210
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 45209,
+        "avgItemsPerSecond": 6.635846844654825,
+        "avgBatchDuration": 45130.333333333336,
+        "minBatchDuration": 44982,
+        "maxBatchDuration": 45207,
+        "p50Duration": 45202,
+        "p95Duration": 45207,
+        "p99Duration": 45207
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46279,
+        "avgItemsPerSecond": 6.482421832796733,
+        "avgBatchDuration": 45474,
+        "minBatchDuration": 44160,
+        "maxBatchDuration": 46277,
+        "p50Duration": 45985,
+        "p95Duration": 46277,
+        "p99Duration": 46277
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 45209,
+        "avgItemsPerSecond": 6.635846844654825,
+        "avgBatchDuration": 44499.333333333336,
+        "minBatchDuration": 43086,
+        "maxBatchDuration": 45206,
+        "p50Duration": 45206,
+        "p95Duration": 45206,
+        "p99Duration": 45206
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46278,
+        "avgItemsPerSecond": 6.482561908466226,
+        "avgBatchDuration": 45212,
+        "minBatchDuration": 44153,
+        "maxBatchDuration": 46276,
+        "p50Duration": 45207,
+        "p95Duration": 46276,
+        "p99Duration": 46276
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 46262,
+        "avgItemsPerSecond": 6.484803942760797,
+        "avgBatchDuration": 44808,
+        "minBatchDuration": 42006,
+        "maxBatchDuration": 46209,
+        "p50Duration": 46209,
+        "p95Duration": 46209,
+        "p99Duration": 46209
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:28:48.965Z",
+    "end": "2025-12-15T15:29:35.314Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **58.25 items/sec** (+7% vs baseline)
+- Fairness index: **0.9999** (nearly perfect!)
+- **Concurrency=5 gives best fairness but modest throughput.** All tenants completed in 45-46s range (very tight clustering).
+
+</details>
+
+### Test F3: Default Concurrency (concurrency=10)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Default concurrency=10"
+```
+
+<details>
+<summary>Results F3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Default concurrency=10",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 88.71073728479432,
+    "overallDuration": 30436,
+    "fairnessIndex": 0.9986319639223729,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29265,
+        "avgItemsPerSecond": 10.251153254741158,
+        "avgBatchDuration": 22707.666666666668,
+        "minBatchDuration": 12771,
+        "maxBatchDuration": 29256,
+        "p50Duration": 26096,
+        "p95Duration": 29256,
+        "p99Duration": 29256
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30322,
+        "avgItemsPerSecond": 9.893806477145308,
+        "avgBatchDuration": 23069,
+        "minBatchDuration": 12719,
+        "maxBatchDuration": 30322,
+        "p50Duration": 26166,
+        "p95Duration": 30322,
+        "p99Duration": 30322
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29049,
+        "avgItemsPerSecond": 10.327377878756584,
+        "avgBatchDuration": 26282.333333333332,
+        "minBatchDuration": 21766,
+        "maxBatchDuration": 29041,
+        "p50Duration": 28040,
+        "p95Duration": 29041,
+        "p99Duration": 29041
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29051,
+        "avgItemsPerSecond": 10.326666896148154,
+        "avgBatchDuration": 22590.333333333332,
+        "minBatchDuration": 11757,
+        "maxBatchDuration": 29043,
+        "p50Duration": 26971,
+        "p95Duration": 29043,
+        "p99Duration": 29043
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30247,
+        "avgItemsPerSecond": 9.918339008827322,
+        "avgBatchDuration": 22704.333333333332,
+        "minBatchDuration": 12811,
+        "maxBatchDuration": 30217,
+        "p50Duration": 25085,
+        "p95Duration": 30217,
+        "p99Duration": 30217
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30216,
+        "avgItemsPerSecond": 9.928514694201748,
+        "avgBatchDuration": 23965.333333333332,
+        "minBatchDuration": 12747,
+        "maxBatchDuration": 30216,
+        "p50Duration": 28933,
+        "p95Duration": 30216,
+        "p99Duration": 30216
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29163,
+        "avgItemsPerSecond": 10.287007509515483,
+        "avgBatchDuration": 29106,
+        "minBatchDuration": 29005,
+        "maxBatchDuration": 29163,
+        "p50Duration": 29150,
+        "p95Duration": 29163,
+        "p99Duration": 29163
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 26728,
+        "avgItemsPerSecond": 11.224184375935348,
+        "avgBatchDuration": 24337.666666666668,
+        "minBatchDuration": 21607,
+        "maxBatchDuration": 26726,
+        "p50Duration": 24680,
+        "p95Duration": 26726,
+        "p99Duration": 26726
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29268,
+        "avgItemsPerSecond": 10.25010250102501,
+        "avgBatchDuration": 28511.333333333332,
+        "minBatchDuration": 27111,
+        "maxBatchDuration": 29268,
+        "p50Duration": 29155,
+        "p95Duration": 29268,
+        "p99Duration": 29268
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:31:05.764Z",
+    "end": "2025-12-15T15:31:36.200Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **88.71 items/sec** (+63% vs baseline)
+- Fairness index: **0.9986** (very good)
+- **Default concurrency=10 is solid.** Good balance of throughput and fairness. Duration 30.4s.
+
+</details>
+
+### Test F4: High Concurrency (concurrency=25)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=25
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "High concurrency=25"
+```
+
+<details>
+<summary>Results F4 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "High concurrency=25",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 92.11873080859776,
+    "overallDuration": 29310,
+    "fairnessIndex": 0.9985800387045317,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28196,
+        "avgItemsPerSecond": 10.63980706483189,
+        "avgBatchDuration": 21146.333333333332,
+        "minBatchDuration": 9134,
+        "maxBatchDuration": 28193,
+        "p50Duration": 26112,
+        "p95Duration": 28193,
+        "p99Duration": 28193
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 26122,
+        "avgItemsPerSecond": 11.484572391087971,
+        "avgBatchDuration": 24917.333333333332,
+        "minBatchDuration": 22512,
+        "maxBatchDuration": 26122,
+        "p50Duration": 26118,
+        "p95Duration": 26122,
+        "p99Duration": 26122
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 27157,
+        "avgItemsPerSecond": 11.046875575358102,
+        "avgBatchDuration": 20760.333333333332,
+        "minBatchDuration": 17529,
+        "maxBatchDuration": 27154,
+        "p50Duration": 17598,
+        "p95Duration": 27154,
+        "p99Duration": 27154
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29234,
+        "avgItemsPerSecond": 10.262023671067935,
+        "avgBatchDuration": 27852.666666666668,
+        "minBatchDuration": 27155,
+        "maxBatchDuration": 29232,
+        "p50Duration": 27171,
+        "p95Duration": 29232,
+        "p99Duration": 29232
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29230,
+        "avgItemsPerSecond": 10.263427984946972,
+        "avgBatchDuration": 28536,
+        "minBatchDuration": 27154,
+        "maxBatchDuration": 29230,
+        "p50Duration": 29224,
+        "p95Duration": 29230,
+        "p99Duration": 29230
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28199,
+        "avgItemsPerSecond": 10.63867513032377,
+        "avgBatchDuration": 28189.666666666668,
+        "minBatchDuration": 28179,
+        "maxBatchDuration": 28195,
+        "p50Duration": 28195,
+        "p95Duration": 28195,
+        "p99Duration": 28195
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29231,
+        "avgItemsPerSecond": 10.26307687044576,
+        "avgBatchDuration": 27848.333333333332,
+        "minBatchDuration": 27149,
+        "maxBatchDuration": 29231,
+        "p50Duration": 27165,
+        "p95Duration": 29231,
+        "p99Duration": 29231
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 28194,
+        "avgItemsPerSecond": 10.640561821664184,
+        "avgBatchDuration": 27132.666666666668,
+        "minBatchDuration": 26095,
+        "maxBatchDuration": 28190,
+        "p50Duration": 27113,
+        "p95Duration": 28190,
+        "p99Duration": 28190
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 29234,
+        "avgItemsPerSecond": 10.262023671067935,
+        "avgBatchDuration": 28871,
+        "minBatchDuration": 28201,
+        "maxBatchDuration": 29232,
+        "p50Duration": 29180,
+        "p95Duration": 29232,
+        "p99Duration": 29232
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:32:57.803Z",
+    "end": "2025-12-15T15:33:27.113Z"
+  }
+}
+```
+
+**Observations:**
+
+- Throughput: **92.12 items/sec** (+69% vs baseline, best in F series)
+- Fairness index: **0.9986** (very good)
+- Resource contention?: **Minimal.** Duration 29.3s, only marginally better than concurrency=10 (30.4s). **Diminishing returns above concurrency=10.** Higher concurrency helps but gains are flattening.
+
+</details>
+
+---
+
+## Series G: Global Rate Limiter
+
+**Objective:** Test global throughput caps across all consumers.
+
+**Theory:**
+
+- Rate limiting provides predictable resource consumption
+- Should not affect fairness, only overall throughput
+
+### Test G1: Moderate Rate Limit (50 items/sec)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+BATCH_QUEUE_GLOBAL_RATE_LIMIT=50
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Rate limit 50/sec"
+```
+
+<details>
+<summary>Results G1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Rate limit 50/sec",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 45.432364670447086,
+    "overallDuration": 59429,
+    "fairnessIndex": 0.9985621839167762,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 54093,
+        "avgItemsPerSecond": 5.546004104043037,
+        "avgBatchDuration": 54091,
+        "minBatchDuration": 54089,
+        "maxBatchDuration": 54093,
+        "p50Duration": 54091,
+        "p95Duration": 54093,
+        "p99Duration": 54093
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 54109,
+        "avgItemsPerSecond": 5.544364153837624,
+        "avgBatchDuration": 53601,
+        "minBatchDuration": 52695,
+        "maxBatchDuration": 54109,
+        "p50Duration": 53999,
+        "p95Duration": 54109,
+        "p99Duration": 54109
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 59343,
+        "avgItemsPerSecond": 5.055356149840756,
+        "avgBatchDuration": 57304.333333333336,
+        "minBatchDuration": 55866,
+        "maxBatchDuration": 59029,
+        "p50Duration": 57018,
+        "p95Duration": 59029,
+        "p99Duration": 59029
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 58371,
+        "avgItemsPerSecond": 5.139538469445443,
+        "avgBatchDuration": 57164.333333333336,
+        "minBatchDuration": 56262,
+        "maxBatchDuration": 58093,
+        "p50Duration": 57138,
+        "p95Duration": 58093,
+        "p99Duration": 58093
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 58285,
+        "avgItemsPerSecond": 5.147121901003689,
+        "avgBatchDuration": 55634.333333333336,
+        "minBatchDuration": 50470,
+        "maxBatchDuration": 58284,
+        "p50Duration": 58149,
+        "p95Duration": 58284,
+        "p99Duration": 58284
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 55174,
+        "avgItemsPerSecond": 5.437343676369304,
+        "avgBatchDuration": 41686.333333333336,
+        "minBatchDuration": 28166,
+        "maxBatchDuration": 55157,
+        "p50Duration": 41736,
+        "p95Duration": 55157,
+        "p99Duration": 55157
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 58284,
+        "avgItemsPerSecond": 5.147210212065061,
+        "avgBatchDuration": 57015.666666666664,
+        "minBatchDuration": 54788,
+        "maxBatchDuration": 58246,
+        "p50Duration": 58013,
+        "p95Duration": 58246,
+        "p99Duration": 58246
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 59296,
+        "avgItemsPerSecond": 5.059363194819212,
+        "avgBatchDuration": 58258.666666666664,
+        "minBatchDuration": 57226,
+        "maxBatchDuration": 59291,
+        "p50Duration": 58259,
+        "p95Duration": 59291,
+        "p99Duration": 59291
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 59408,
+        "avgItemsPerSecond": 5.049824939402101,
+        "avgBatchDuration": 58836.333333333336,
+        "minBatchDuration": 58371,
+        "maxBatchDuration": 59107,
+        "p50Duration": 59031,
+        "p95Duration": 59107,
+        "p99Duration": 59107
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:35:48.593Z",
+    "end": "2025-12-15T15:36:48.022Z"
+  }
+}
+```
+
+**Observations:**
+
+- Actual throughput: **45.43 items/sec** (target: 50) - ~91% of limit
+- Fairness preserved?: **Yes, 0.9986** (excellent)
+- **Rate limiter is working correctly.** Duration 59.4s shows throttling is effective. Some overhead explains why we don't hit exactly 50/sec.
+
+</details>
+
+### Test G2: Higher Rate Limit (100 items/sec)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+BATCH_QUEUE_GLOBAL_RATE_LIMIT=100
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Rate limit 100/sec"
+```
+
+<details>
+<summary>Results G2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Rate limit 100/sec",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 81.93487694595333,
+    "overallDuration": 32953,
+    "fairnessIndex": 0.9994851661042276,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31984,
+        "avgItemsPerSecond": 9.379689844922462,
+        "avgBatchDuration": 30240.333333333332,
+        "minBatchDuration": 28799,
+        "maxBatchDuration": 31980,
+        "p50Duration": 29942,
+        "p95Duration": 31980,
+        "p99Duration": 31980
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31947,
+        "avgItemsPerSecond": 9.3905531035778,
+        "avgBatchDuration": 26446,
+        "minBatchDuration": 23696,
+        "maxBatchDuration": 31945,
+        "p50Duration": 23697,
+        "p95Duration": 31945,
+        "p99Duration": 31945
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 32914,
+        "avgItemsPerSecond": 9.114662453667133,
+        "avgBatchDuration": 31870.666666666668,
+        "minBatchDuration": 29821,
+        "maxBatchDuration": 32912,
+        "p50Duration": 32879,
+        "p95Duration": 32912,
+        "p99Duration": 32912
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30770,
+        "avgItemsPerSecond": 9.749756256093598,
+        "avgBatchDuration": 26862,
+        "minBatchDuration": 22381,
+        "maxBatchDuration": 30768,
+        "p50Duration": 27437,
+        "p95Duration": 30768,
+        "p99Duration": 30768
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30770,
+        "avgItemsPerSecond": 9.749756256093598,
+        "avgBatchDuration": 29516.666666666668,
+        "minBatchDuration": 27853,
+        "maxBatchDuration": 30769,
+        "p50Duration": 29928,
+        "p95Duration": 30769,
+        "p99Duration": 30769
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30771,
+        "avgItemsPerSecond": 9.749439407234084,
+        "avgBatchDuration": 28237.333333333332,
+        "minBatchDuration": 25781,
+        "maxBatchDuration": 30769,
+        "p50Duration": 28162,
+        "p95Duration": 30769,
+        "p99Duration": 30769
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31890,
+        "avgItemsPerSecond": 9.40733772342427,
+        "avgBatchDuration": 23515.666666666668,
+        "minBatchDuration": 18184,
+        "maxBatchDuration": 31888,
+        "p50Duration": 20475,
+        "p95Duration": 31888,
+        "p99Duration": 31888
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 30956,
+        "avgItemsPerSecond": 9.691174570357928,
+        "avgBatchDuration": 28886,
+        "minBatchDuration": 25781,
+        "maxBatchDuration": 30947,
+        "p50Duration": 29930,
+        "p95Duration": 30947,
+        "p99Duration": 30947
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 31976,
+        "avgItemsPerSecond": 9.382036527395547,
+        "avgBatchDuration": 29608.666666666668,
+        "minBatchDuration": 26943,
+        "maxBatchDuration": 31974,
+        "p50Duration": 29909,
+        "p95Duration": 31974,
+        "p99Duration": 31974
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:37:49.150Z",
+    "end": "2025-12-15T15:38:22.103Z"
+  }
+}
+```
+
+**Observations:**
+
+- Actual throughput: **81.93 items/sec** (limit was 100)
+- Is this limit binding or above natural throughput?: **Above natural throughput.** Without rate limiting (E2 with same settings), throughput was 93.57/sec. The 100/sec limit is barely constraining. **Use rate limits below ~90/sec to have meaningful impact.**
+
+</details>
+
+### Test G3: Low Rate Limit (20 items/sec)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+BATCH_QUEUE_GLOBAL_RATE_LIMIT=20
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Rate limit 20/sec"
+```
+
+<details>
+<summary>Results G3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "fairness-9t",
+  "description": "Rate limit 20/sec",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 100,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 2700,
+    "totalBatches": 27,
+    "overallThroughput": 21.692671090900326,
+    "overallDuration": 124466,
+    "fairnessIndex": 0.997793763355806,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 108861,
+        "avgItemsPerSecond": 2.755807865075647,
+        "avgBatchDuration": 99844,
+        "minBatchDuration": 93281,
+        "maxBatchDuration": 108850,
+        "p50Duration": 97401,
+        "p95Duration": 108850,
+        "p99Duration": 108850
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 111633,
+        "avgItemsPerSecond": 2.687377388406654,
+        "avgBatchDuration": 85438,
+        "minBatchDuration": 71861,
+        "maxBatchDuration": 111516,
+        "p50Duration": 72937,
+        "p95Duration": 111516,
+        "p99Duration": 111516
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 123298,
+        "avgItemsPerSecond": 2.433129491151519,
+        "avgBatchDuration": 96355,
+        "minBatchDuration": 43494,
+        "maxBatchDuration": 123297,
+        "p50Duration": 122274,
+        "p95Duration": 123297,
+        "p99Duration": 123297
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 121568,
+        "avgItemsPerSecond": 2.4677546722821795,
+        "avgBatchDuration": 92002,
+        "minBatchDuration": 53253,
+        "maxBatchDuration": 121568,
+        "p50Duration": 101185,
+        "p95Duration": 121568,
+        "p99Duration": 121568
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 123851,
+        "avgItemsPerSecond": 2.422265464146434,
+        "avgBatchDuration": 118623.66666666667,
+        "minBatchDuration": 111599,
+        "maxBatchDuration": 123784,
+        "p50Duration": 120488,
+        "p95Duration": 123784,
+        "p99Duration": 123784
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 120270,
+        "avgItemsPerSecond": 2.4943876278373662,
+        "avgBatchDuration": 113171.33333333333,
+        "minBatchDuration": 109360,
+        "maxBatchDuration": 120269,
+        "p50Duration": 109885,
+        "p95Duration": 120269,
+        "p99Duration": 120269
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 123169,
+        "avgItemsPerSecond": 2.4356778085394866,
+        "avgBatchDuration": 118514,
+        "minBatchDuration": 113405,
+        "maxBatchDuration": 123164,
+        "p50Duration": 118973,
+        "p95Duration": 123164,
+        "p99Duration": 123164
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 124246,
+        "avgItemsPerSecond": 2.414564653992885,
+        "avgBatchDuration": 119631.33333333333,
+        "minBatchDuration": 114504,
+        "maxBatchDuration": 124241,
+        "p50Duration": 120149,
+        "p95Duration": 124241,
+        "p99Duration": 124241
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 300,
+        "totalBatches": 3,
+        "totalDuration": 122197,
+        "avgItemsPerSecond": 2.4550520880218007,
+        "avgBatchDuration": 120645.33333333333,
+        "minBatchDuration": 118022,
+        "maxBatchDuration": 122197,
+        "p50Duration": 121717,
+        "p95Duration": 122197,
+        "p99Duration": 122197
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:39:42.414Z",
+    "end": "2025-12-15T15:41:46.880Z"
+  }
+}
+```
+
+**Observations:**
+
+- Actual throughput: **21.69 items/sec** (target: 20) - slightly above limit
+- Fairness index: **0.9978** (good but slight variance)
+- Duration 124.5s (2+ minutes) - shows throttling working hard. **Strict rate limiting works but creates fairness variance** - some tenants saw 72-124s batch durations (wide spread).
+
+</details>
+
+---
+
+## Series H: Asymmetric Load Testing
+
+**Objective:** Test fairness when tenants have dramatically different workloads.
+
+### Test H1: Asymmetric with Default Config
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress asymmetric --small-size 50 --large-size 800 --batch-count 3 -d "Asymmetric baseline"
+```
+
+<details>
+<summary>Results H1 (click to expand)</summary>
+
+```json
+{
+  "scenario": "asymmetric-combined",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 0,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 10350,
+    "totalBatches": 27,
+    "overallThroughput": 67.60816590394816,
+    "overallDuration": 107281,
+    "fairnessIndex": 0.9978993490004432,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16361,
+        "avgItemsPerSecond": 9.168143756494102,
+        "avgBatchDuration": 14312.666666666666,
+        "minBatchDuration": 12271,
+        "maxBatchDuration": 16360,
+        "p50Duration": 14307,
+        "p95Duration": 16360,
+        "p99Duration": 16360
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16361,
+        "avgItemsPerSecond": 9.168143756494102,
+        "avgBatchDuration": 13968.333333333334,
+        "minBatchDuration": 11240,
+        "maxBatchDuration": 16358,
+        "p50Duration": 14307,
+        "p95Duration": 16358,
+        "p99Duration": 16358
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16361,
+        "avgItemsPerSecond": 9.168143756494102,
+        "avgBatchDuration": 12117.333333333334,
+        "minBatchDuration": 8977,
+        "maxBatchDuration": 16359,
+        "p50Duration": 11016,
+        "p95Duration": 16359,
+        "p99Duration": 16359
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 13966,
+        "avgItemsPerSecond": 10.740369468709723,
+        "avgBatchDuration": 13624.333333333334,
+        "minBatchDuration": 12945,
+        "maxBatchDuration": 13964,
+        "p50Duration": 13964,
+        "p95Duration": 13964,
+        "p99Duration": 13964
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16116,
+        "avgItemsPerSecond": 9.307520476545047,
+        "avgBatchDuration": 14416.666666666666,
+        "minBatchDuration": 11021,
+        "maxBatchDuration": 16116,
+        "p50Duration": 16113,
+        "p95Duration": 16116,
+        "p99Duration": 16116
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 107273,
+        "avgItemsPerSecond": 22.37282447586998,
+        "avgBatchDuration": 106213,
+        "minBatchDuration": 105126,
+        "maxBatchDuration": 107273,
+        "p50Duration": 106240,
+        "p95Duration": 107273,
+        "p99Duration": 107273
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 106584,
+        "avgItemsPerSecond": 22.51745102454402,
+        "avgBatchDuration": 105934,
+        "minBatchDuration": 105097,
+        "maxBatchDuration": 106574,
+        "p50Duration": 106131,
+        "p95Duration": 106574,
+        "p99Duration": 106574
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 107116,
+        "avgItemsPerSecond": 22.40561634116285,
+        "avgBatchDuration": 106374.33333333333,
+        "minBatchDuration": 105308,
+        "maxBatchDuration": 107100,
+        "p50Duration": 106715,
+        "p95Duration": 107100,
+        "p99Duration": 107100
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 107046,
+        "avgItemsPerSecond": 22.42026792220167,
+        "avgBatchDuration": 104503.66666666667,
+        "minBatchDuration": 102401,
+        "maxBatchDuration": 106989,
+        "p50Duration": 104121,
+        "p95Duration": 106989,
+        "p99Duration": 106989
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:44:50.480Z",
+    "end": "2025-12-15T15:46:37.770Z"
+  }
+}
+```
+
+**Observations:**
+
+- Small batch completion times: **14-17s** (150 items × 5 tenants)
+- Large batch completion times: **105-107s** (2400 items × 4 tenants)
+- Were small batches starved?: **NO!** Small batches finished ~6x faster than large batches, exactly as expected. **DRR correctly prioritizes smaller workloads and doesn't let large batches monopolize.** Fairness index 0.9979 is excellent given asymmetric load.
+
+</details>
+
+### Test H2: Asymmetric with Low Quantum (better fairness?)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=2
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress asymmetric --small-size 50 --large-size 800 --batch-count 3 -d "Asymmetric low quantum"
+```
+
+<details>
+<summary>Results H2 (click to expand)</summary>
+
+```json
+{
+  "scenario": "asymmetric-combined",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 0,
+    "batchCount": 3
+  },
+  "results": {
+    "totalItemsProcessed": 10350,
+    "totalBatches": 27,
+    "overallThroughput": 58.418499446364066,
+    "overallDuration": 127189,
+    "fairnessIndex": 0.9991864215649569,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16648,
+        "avgItemsPerSecond": 9.01009130225853,
+        "avgBatchDuration": 15360,
+        "minBatchDuration": 14080,
+        "maxBatchDuration": 16647,
+        "p50Duration": 15353,
+        "p95Duration": 16647,
+        "p99Duration": 16647
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 18118,
+        "avgItemsPerSecond": 8.279059498840931,
+        "avgBatchDuration": 16403.333333333332,
+        "minBatchDuration": 15020,
+        "maxBatchDuration": 18115,
+        "p50Duration": 16075,
+        "p95Duration": 18115,
+        "p99Duration": 18115
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16307,
+        "avgItemsPerSecond": 9.198503710063163,
+        "avgBatchDuration": 15531.333333333334,
+        "minBatchDuration": 14206,
+        "maxBatchDuration": 16305,
+        "p50Duration": 16083,
+        "p95Duration": 16305,
+        "p99Duration": 16305
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 16646,
+        "avgItemsPerSecond": 9.011173855580921,
+        "avgBatchDuration": 14090,
+        "minBatchDuration": 11256,
+        "maxBatchDuration": 16645,
+        "p50Duration": 14369,
+        "p95Duration": 16645,
+        "p99Duration": 16645
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 150,
+        "totalBatches": 3,
+        "totalDuration": 17696,
+        "avgItemsPerSecond": 8.476491862567812,
+        "avgBatchDuration": 16322,
+        "minBatchDuration": 14600,
+        "maxBatchDuration": 17694,
+        "p50Duration": 16672,
+        "p95Duration": 17694,
+        "p99Duration": 17694
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 125841,
+        "avgItemsPerSecond": 19.07168569861969,
+        "avgBatchDuration": 125238.66666666667,
+        "minBatchDuration": 124354,
+        "maxBatchDuration": 125800,
+        "p50Duration": 125562,
+        "p95Duration": 125800,
+        "p99Duration": 125800
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 127140,
+        "avgItemsPerSecond": 18.876828692779615,
+        "avgBatchDuration": 126407.66666666667,
+        "minBatchDuration": 125398,
+        "maxBatchDuration": 127140,
+        "p50Duration": 126685,
+        "p95Duration": 127140,
+        "p99Duration": 127140
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 125854,
+        "avgItemsPerSecond": 19.069715702321737,
+        "avgBatchDuration": 125322.66666666667,
+        "minBatchDuration": 124426,
+        "maxBatchDuration": 125849,
+        "p50Duration": 125693,
+        "p95Duration": 125849,
+        "p99Duration": 125849
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 2400,
+        "totalBatches": 3,
+        "totalDuration": 126467,
+        "avgItemsPerSecond": 18.977282611274088,
+        "avgBatchDuration": 124552.33333333333,
+        "minBatchDuration": 123402,
+        "maxBatchDuration": 126202,
+        "p50Duration": 124053,
+        "p95Duration": 126202,
+        "p99Duration": 126202
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:50:21.351Z",
+    "end": "2025-12-15T15:52:28.745Z"
+  }
+}
+```
+
+**Observations:**
+
+- Small batch completion times: **14-18s** (slightly slower than H1's 14-17s)
+- Large batch completion times: **123-127s** (slower than H1's 105-107s)
+- Improvement over H1?: **Mixed.** Fairness improved (0.9992 vs 0.9979) but overall throughput dropped (58.42 vs 67.61 items/sec). **Low quantum=2 improves fairness but at throughput cost.** For asymmetric loads, default quantum=5 is better balance.
+
+</details>
+
+### Test H3: Burst Test (All Tenants Simultaneous)
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress burst --batch-size 500 -d "Burst test baseline"
+```
+
+<details>
+<summary>Results H3 (click to expand)</summary>
+
+```json
+{
+  "scenario": "burst-9t-500i",
+  "config": {
+    "tenantCount": 9,
+    "batchSize": 500,
+    "batchCount": 1
+  },
+  "results": {
+    "totalItemsProcessed": 4500,
+    "totalBatches": 9,
+    "overallThroughput": 68.83786388459714,
+    "overallDuration": 65371,
+    "fairnessIndex": 0.9999479889573228,
+    "perTenant": [
+      {
+        "tenantId": "org-1:proj_czimyjnqtbskjmvimpwh",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64508,
+        "avgItemsPerSecond": 7.750976623054505,
+        "avgBatchDuration": 64508,
+        "minBatchDuration": 64508,
+        "maxBatchDuration": 64508,
+        "p50Duration": 64508,
+        "p95Duration": 64508,
+        "p99Duration": 64508
+      },
+      {
+        "tenantId": "org-1:proj_lvfvbfatttkmiocyaojf",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64504,
+        "avgItemsPerSecond": 7.751457273967506,
+        "avgBatchDuration": 64504,
+        "minBatchDuration": 64504,
+        "maxBatchDuration": 64504,
+        "p50Duration": 64504,
+        "p95Duration": 64504,
+        "p99Duration": 64504
+      },
+      {
+        "tenantId": "org-1:proj_pogdfmagzpxpjggpwrlj",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64404,
+        "avgItemsPerSecond": 7.7634929507484,
+        "avgBatchDuration": 64404,
+        "minBatchDuration": 64404,
+        "maxBatchDuration": 64404,
+        "p50Duration": 64404,
+        "p95Duration": 64404,
+        "p99Duration": 64404
+      },
+      {
+        "tenantId": "org-2:proj_prxnkqpzdapktltqmxhb",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64504,
+        "avgItemsPerSecond": 7.751457273967506,
+        "avgBatchDuration": 64504,
+        "minBatchDuration": 64504,
+        "maxBatchDuration": 64504,
+        "p50Duration": 64504,
+        "p95Duration": 64504,
+        "p99Duration": 64504
+      },
+      {
+        "tenantId": "org-2:proj_zgysghtkiezoakvjscin",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64507,
+        "avgItemsPerSecond": 7.7510967801943975,
+        "avgBatchDuration": 64507,
+        "minBatchDuration": 64507,
+        "maxBatchDuration": 64507,
+        "p50Duration": 64507,
+        "p95Duration": 64507,
+        "p99Duration": 64507
+      },
+      {
+        "tenantId": "org-2:proj_giomqjmqmqbcngusxqfo",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64391,
+        "avgItemsPerSecond": 7.7650603345187985,
+        "avgBatchDuration": 64391,
+        "minBatchDuration": 64391,
+        "maxBatchDuration": 64391,
+        "p50Duration": 64391,
+        "p95Duration": 64391,
+        "p99Duration": 64391
+      },
+      {
+        "tenantId": "org-3:proj_qopvqsgghjbtrrfcwlqs",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 63375,
+        "avgItemsPerSecond": 7.889546351084813,
+        "avgBatchDuration": 63375,
+        "minBatchDuration": 63375,
+        "maxBatchDuration": 63375,
+        "p50Duration": 63375,
+        "p95Duration": 63375,
+        "p99Duration": 63375
+      },
+      {
+        "tenantId": "org-3:proj_efaelbvnogkhjnrdfsmi",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 64497,
+        "avgItemsPerSecond": 7.752298556522009,
+        "avgBatchDuration": 64497,
+        "minBatchDuration": 64497,
+        "maxBatchDuration": 64497,
+        "p50Duration": 64497,
+        "p95Duration": 64497,
+        "p99Duration": 64497
+      },
+      {
+        "tenantId": "org-3:proj_ytivyoceocenyxuprmga",
+        "totalItems": 500,
+        "totalBatches": 1,
+        "totalDuration": 65316,
+        "avgItemsPerSecond": 7.655092167309695,
+        "avgBatchDuration": 65316,
+        "minBatchDuration": 65316,
+        "maxBatchDuration": 65316,
+        "p50Duration": 65316,
+        "p95Duration": 65316,
+        "p99Duration": 65316
+      }
+    ]
+  },
+  "timestamps": {
+    "start": "2025-12-15T15:53:49.834Z",
+    "end": "2025-12-15T15:54:55.205Z"
+  }
+}
+```
+
+**Observations:**
+
+- Fairness under burst: **0.9999** (nearly perfect!)
+- Throughput: **68.84 items/sec**
+- Any tenant significantly slower?: **All tenants finished within 2s of each other (63-65s range).** **Excellent burst handling!** Even under simultaneous 4500-item burst from 9 tenants, DRR maintained perfect fairness. This is the ideal scenario for DRR.
+
+</details>
+
+---
+
+## Series I: Combined/Optimized Configurations
+
+**Objective:** Test promising combinations based on earlier results.
+
+### Test I1: Throughput-Optimized
+
+Based on Series B-F results, configure for maximum throughput.
+
+**Configuration (adjust based on findings):**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=10
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=5
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=25
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 5 --tenants all -d "Throughput optimized"
+```
+
+<details>
+<summary>Results I1 (click to expand)</summary>
+
+```json
+// Paste results here
+```
+
+**Observations:**
+
+- Throughput: **\_** items/sec
+- Fairness tradeoff: **\_**
+
+</details>
+
+### Test I2: Fairness-Optimized
+
+Based on Series B-F results, configure for best fairness.
+
+**Configuration (adjust based on findings):**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=2
+BATCH_QUEUE_MAX_DEFICIT=25
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=5
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 5 --tenants all -d "Fairness optimized"
+```
+
+<details>
+<summary>Results I2 (click to expand)</summary>
+
+```json
+// Paste results here
+```
+
+**Observations:**
+
+- Fairness index: **\_**
+- Throughput cost: **\_**
+
+</details>
+
+### Test I3: Balanced Configuration
+
+Best balance of throughput and fairness.
+
+**Configuration (adjust based on findings):**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 5 --tenants all -d "Balanced configuration"
+```
+
+<details>
+<summary>Results I3 (click to expand)</summary>
+
+```json
+// Paste results here
+```
+
+**Observations:**
+
+- Throughput: **\_** items/sec
+- Fairness index: **\_**
+- Recommended for production?: **\_**
+
+</details>
+
+---
+
+## Per-Org Concurrency Testing (Optional Series J)
+
+If time permits, test different concurrency limits per organization by updating the database.
+
+### Setting Per-Org Concurrency
+
+```sql
+-- Set org-1 to high concurrency (50)
+UPDATE "Organization"
+SET "batchQueueConcurrencyConfig" = '{"default": 50}'
+WHERE slug = 'org-1';
+
+-- Set org-2 to medium concurrency (10)
+UPDATE "Organization"
+SET "batchQueueConcurrencyConfig" = '{"default": 10}'
+WHERE slug = 'org-2';
+
+-- Set org-3 to low concurrency (2)
+UPDATE "Organization"
+SET "batchQueueConcurrencyConfig" = '{"default": 2}'
+WHERE slug = 'org-3';
+```
+
+### Test J1: Mixed Org Concurrency Limits
+
+**Configuration:**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=50
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10  # fallback
+```
+
+**Command:**
+
+```bash
+pnpm stress fairness --batch-size 100 --batch-count 3 --tenants all -d "Mixed org concurrency"
+```
+
+<details>
+<summary>Results J1 (click to expand)</summary>
+
+```json
+// Paste results here
+```
+
+**Observations:**
+
+- Org-1 (high concurrency) throughput: **\_**
+- Org-2 (medium concurrency) throughput: **\_**
+- Org-3 (low concurrency) throughput: **\_**
+- Does DRR still maintain fairness?: **\_**
+
+</details>
+
+---
+
+## Results Summary Table
+
+| Test | Config Summary         | Throughput (items/sec) | Fairness Index | Notes                              |
+| ---- | ---------------------- | ---------------------- | -------------- | ---------------------------------- |
+| A1   | Baseline               | 54.52                  | 0.9999         | Reference point                    |
+| A2   | Throughput baseline    | 97.48 (peak @ 500)     | 1.0000         | Single tenant max                  |
+| B1   | quantum=1              | 66.09                  | 0.9997         | +21% vs baseline                   |
+| B2   | quantum=10             | 64.69                  | 0.9998         | +18%                               |
+| B3   | quantum=25             | **84.36**              | **0.9999**     | **Best B series**                  |
+| B4   | quantum=50             | 51.98                  | 0.9997         | Too high, hurts perf               |
+| C1   | maxDeficit=10          | 52.51                  | 0.9998         | Limited catch-up                   |
+| C2   | maxDeficit=25          | 66.33                  | 0.9992         | +22%                               |
+| C3   | maxDeficit=100         | **73.74**              | 0.9989         | **Best C**, slight fairness cost   |
+| D1   | consumers=1            | 41.33                  | 0.9997         | Bottleneck                         |
+| D2   | consumers=3            | 57.55                  | 0.9992         | 1.39x vs D1                        |
+| D3   | consumers=5            | 63.80                  | 0.9999         | Good balance                       |
+| D4   | consumers=10           | **114.94**             | 0.9888         | **Best throughput**, fairness cost |
+| E1   | interval=20ms          | 70.23                  | 0.9979         | Contention overhead                |
+| E2   | interval=50ms          | **93.57**              | **0.9994**     | **Best E series**                  |
+| E3   | interval=100ms         | 86.52                  | 0.9997         | Good default                       |
+| E4   | interval=250ms         | 47.46                  | 0.9994         | Too slow                           |
+| F1   | concurrency=2          | 90.73                  | 0.9931         | High but unfair                    |
+| F2   | concurrency=5          | 58.25                  | **0.9999**     | **Best fairness**                  |
+| F3   | concurrency=10         | 88.71                  | 0.9986         | Good balance                       |
+| F4   | concurrency=25         | **92.12**              | 0.9986         | **Best F series**                  |
+| F5   | concurrency=50         | _not tested_           | _not tested_   |                                    |
+| G1   | rateLimit=50           | 45.43                  | 0.9986         | Effective throttle                 |
+| G2   | rateLimit=100          | 81.93                  | 0.9995         | Not binding                        |
+| G3   | rateLimit=20           | 21.69                  | 0.9978         | Strict throttle                    |
+| H1   | asymmetric baseline    | 67.61                  | 0.9979         | Small batches not starved          |
+| H2   | asymmetric low quantum | 58.42                  | 0.9992         | Better fairness, lower throughput  |
+| H3   | burst test             | 68.84                  | **0.9999**     | **Perfect burst fairness**         |
+| I1   | throughput optimized   | _pending_              | _pending_      |                                    |
+| I2   | fairness optimized     | _pending_              | _pending_      |                                    |
+| I3   | balanced               | _pending_              | _pending_      |                                    |
+
+---
+
+## Recommended Execution Order
+
+1. **Series A** (Baseline) - Establish reference point
+2. **Series B** (DRR Quantum) - Understand core fairness mechanism
+3. **Series C** (Max Deficit) - Understand starvation prevention
+4. **Series D** (Consumer Count) - Find optimal parallelism
+5. **Series E** (Consumer Interval) - Find optimal polling frequency
+6. **Series F** (Concurrency) - Find optimal per-env limits
+7. **Series G** (Global Rate Limit) - Test throttling mechanism
+8. **Series H** (Asymmetric) - Validate fairness under realistic conditions
+9. **Series I** (Combined) - Test optimized configurations
+
+## Between Tests
+
+After each configuration change:
+
+1. Restart the webapp to pick up new env vars
+2. Wait ~5 seconds for BatchQueue to initialize
+3. Consider clearing Redis state between tests if needed: `redis-cli FLUSHDB`
+
+---
+
+## Key Metrics to Watch
+
+1. **Throughput** (`overallThroughput`) - Higher is better, all else equal
+2. **Fairness Index** (`fairnessIndex`) - Closer to 1.0 is better
+3. **Per-Tenant Variance** - Look at min/max batch durations across tenants
+4. **P95/P99 Latencies** - Watch for tail latencies indicating starvation
+
+## Notes and Observations
+
+### Key Findings from Series A-H
+
+#### 1. DRR Fairness is Excellent
+
+- **Fairness Index consistently 0.99+** across all tests
+- Burst scenario (H3) achieved **0.9999 fairness** with 9 tenants competing simultaneously
+- Asymmetric load (H1) showed small batches complete quickly without being starved by large batches
+
+#### 2. Throughput vs Fairness Tradeoffs
+
+| Configuration         | Effect on Throughput | Effect on Fairness |
+| --------------------- | -------------------- | ------------------ |
+| Higher quantum (25)   | ↑ Significant        | → Neutral          |
+| Higher quantum (50)   | ↓ Hurts              | → Neutral          |
+| Higher maxDeficit     | ↑ Moderate           | ↓ Slight           |
+| More consumers        | ↑↑ Major             | ↓ Moderate (at 10) |
+| Faster polling (50ms) | ↑ Best               | → Neutral          |
+| Higher concurrency    | ↑ Moderate           | → Neutral          |
+
+#### 3. Recommended Default Configuration
+
+Based on test results, the optimal balanced configuration is:
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=25          # Sweet spot from B series
+BATCH_QUEUE_MAX_DEFICIT=50          # Default is fine (100 gains throughput but costs fairness)
+BATCH_QUEUE_CONSUMER_COUNT=3        # Good balance (10 is faster but less fair)
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50 # Best from E series
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=10  # Good balance from F series
+```
+
+**Expected performance:** ~90-100 items/sec with 0.999+ fairness
+
+#### 4. Configuration Recommendations by Use Case
+
+**High-throughput priority (fairness acceptable at 0.98+):**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=25
+BATCH_QUEUE_MAX_DEFICIT=100
+BATCH_QUEUE_CONSUMER_COUNT=10
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=50
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=25
+```
+
+**Strict fairness priority (throughput can be lower):**
+
+```env
+BATCH_QUEUE_DRR_QUANTUM=5
+BATCH_QUEUE_MAX_DEFICIT=25
+BATCH_QUEUE_CONSUMER_COUNT=3
+BATCH_QUEUE_CONSUMER_INTERVAL_MS=100
+BATCH_CONCURRENCY_DEFAULT_CONCURRENCY=5
+```
+
+#### 5. Surprising Results
+
+1. **quantum=1 outperformed quantum=10**: Lower quantum didn't add expected overhead. May be due to better slot utilization.
+
+2. **quantum=50 was worst**: Too much time between tenant switches caused overall slowdown.
+
+3. **concurrency=2 had high throughput but poor fairness**: Some tenants finished much faster than others.
+
+4. **20ms polling was worse than 50ms**: Too-fast polling created contention.
+
+#### 6. Rate Limiter Behavior
+
+- Rate limiter effectively caps throughput
+- At 50/sec limit, achieved ~45/sec (91% efficiency)
+- At 20/sec limit, achieved ~22/sec (108% - slight overshoot)
+- Rate limiting preserved fairness well (0.997-0.999)
+
+#### 7. Asymmetric Load Handling
+
+- **Excellent!** Small batches (150 items) completed in 14-17s
+- Large batches (2400 items) completed in 105-127s
+- DRR prevented large batches from starving small ones
+- Lower quantum (2) improved fairness but hurt overall throughput by ~13%
+
+### Scaling Observations
+
+- Single consumer: ~41 items/sec
+- 3 consumers: ~58 items/sec (1.4x)
+- 5 consumers: ~64 items/sec (1.5x)
+- 10 consumers: ~115 items/sec (2.8x)
+
+**Diminishing returns start around 5 consumers, with fairness degradation at 10.**
+
+### Production Recommendations
+
+1. **Start with defaults** - They're well-tuned for most cases
+2. **Consider quantum=25** for throughput boost without fairness cost
+3. **Use 3-5 consumers** for good parallelism without contention
+4. **50ms polling** is optimal for most workloads
+5. **Monitor fairness index** in production metrics
+6. **Use global rate limiter** if you need to cap resource usage
+
+---
+
+**Document created:** $(date)
+**Last updated:**
diff --git a/docs/building-with-ai.mdx b/docs/building-with-ai.mdx
new file mode 100644
index 00000000000..e551324cadf
--- /dev/null
+++ b/docs/building-with-ai.mdx
@@ -0,0 +1,275 @@
+---
+title: "Overview"
+sidebarTitle: "Overview"
+description: "Tools and resources for building Trigger.dev projects with AI coding assistants."
+---
+
+## Quick setup
+
+We provide multiple tools to help AI coding assistants write correct Trigger.dev code. Use one or all of them for the best developer experience.
+
+
+<Steps>
+
+<Step title="Install the MCP Server">
+  Give your AI assistant direct access to Trigger.dev tools — search docs, trigger tasks, deploy projects, and monitor runs. Works with Claude Code, Cursor, Windsurf, VS Code (Copilot), and Zed.
+
+  ```bash
+  npx trigger.dev@latest install-mcp
+  ```
+
+  [Learn more →](/mcp-introduction)
+</Step>
+
+<Step title="Install Skills">
+  Portable instruction sets that teach any AI coding assistant Trigger.dev best practices. Works with Claude Code, Cursor, Windsurf, VS Code (Copilot), and any tool that supports the [Agent Skills standard](https://agentskills.io).
+
+  ```bash
+  npx skills add triggerdotdev/skills
+  ```
+
+  [Learn more →](/skills)
+</Step>
+
+<Step title="Install Agent Rules">
+  Comprehensive rule sets installed directly into your AI client's config files. Works with Cursor, Claude Code, VS Code (Copilot), Windsurf, Gemini CLI, Cline, and more. Claude Code also gets a dedicated subagent for hands-on help.
+
+  ```bash
+  npx trigger.dev@latest install-rules
+  ```
+
+  [Learn more →](/mcp-agent-rules)
+</Step>
+
+</Steps>
+
+## Skills vs Agent Rules vs MCP
+
+Not sure which tool to use? Here's how they compare:
+
+| | **Skills** | **Agent Rules** | **MCP Server** |
+|:--|:-----------|:----------------|:---------------|
+| **What it does** | Drops skill files into your project | Installs rule sets into client config | Runs a live server your AI connects to |
+| **Installs to** | `.claude/skills/`, `.cursor/skills/`, etc. | `.cursor/rules/`, `CLAUDE.md`, `AGENTS.md`, etc. | `mcp.json`, `~/.claude.json`, etc. |
+| **Updates** | Re-run `npx skills add` | Re-run `npx trigger.dev@latest install-rules` or auto-prompted on `trigger dev` | Always latest (uses `@latest`) |
+| **Best for** | Teaching patterns and best practices | Comprehensive code generation guidance | Live project interaction (deploy, trigger, monitor) |
+| **Works offline** | Yes | Yes | No (calls Trigger.dev API) |
+
+**Our recommendation:** Install all three. Skills and Agent Rules teach your AI *how* to write code. The MCP Server lets it *do things* in your project.
+
+## Project-level context snippet
+
+If you prefer a lightweight/passive approach, paste the snippet below into a context file at the root of your project. Different AI tools read different files:
+
+| File | Read by |
+|:-----|:--------|
+| `CLAUDE.md` | Claude Code |
+| `AGENTS.md` | OpenAI Codex, Jules, OpenCode |
+| `.cursor/rules/*.md` | Cursor |
+| `.github/copilot-instructions.md` | GitHub Copilot |
+| `CONVENTIONS.md` | Windsurf, Cline, and others |
+
+Create the file that matches your AI tool (or multiple files if your team uses different tools) and paste the snippet below. This gives the AI essential Trigger.dev context without installing anything.
+
+<Accordion title="Copy the snippet">
+
+````markdown
+# Trigger.dev rules
+
+## Imports
+
+Always import from `@trigger.dev/sdk` — never from `@trigger.dev/sdk/v3` or use the deprecated `client.defineJob` pattern.
+
+## Task pattern
+
+Every task must be exported. Use `task()` from `@trigger.dev/sdk`:
+
+```ts
+import { task } from "@trigger.dev/sdk";
+
+export const myTask = task({
+  id: "my-task",
+  retry: {
+    maxAttempts: 3,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+  },
+  run: async (payload: { url: string }) => {
+    // No timeouts — runs can take as long as needed
+    return { success: true };
+  },
+});
+```
+
+## Triggering tasks
+
+From your backend (Next.js route, Express handler, etc.):
+
+```ts
+import type { myTask } from "./trigger/my-task";
+import { tasks } from "@trigger.dev/sdk";
+
+// Fire and forget
+const handle = await tasks.trigger<typeof myTask>("my-task", { url: "https://example.com" });
+
+// Batch trigger (up to 1,000 items)
+const batchHandle = await tasks.batchTrigger<typeof myTask>("my-task", [
+  { payload: { url: "https://example.com/1" } },
+  { payload: { url: "https://example.com/2" } },
+]);
+```
+
+### From inside other tasks
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Fire and forget
+    await childTask.trigger({ data: "value" });
+
+    // Wait for result — returns a Result object, NOT the output directly
+    const result = await childTask.triggerAndWait({ data: "value" });
+    if (result.ok) {
+      console.log(result.output); // The actual return value
+    } else {
+      console.error(result.error);
+    }
+
+    // Or use .unwrap() to get output directly (throws on failure)
+    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
+  },
+});
+```
+
+> Never wrap `triggerAndWait` or `batchTriggerAndWait` in `Promise.all` — this is not supported.
+
+## Error handling
+
+```ts
+import { task, retry, AbortTaskRunError } from "@trigger.dev/sdk";
+
+export const resilientTask = task({
+  id: "resilient-task",
+  retry: { maxAttempts: 5 },
+  run: async (payload) => {
+    // Permanent error — skip retrying
+    if (!payload.isValid) {
+      throw new AbortTaskRunError("Invalid payload, will not retry");
+    }
+
+    // Retry a specific block (not the whole task)
+    const data = await retry.onThrow(
+      async () => await fetchExternalApi(payload),
+      { maxAttempts: 3 }
+    );
+
+    return data;
+  },
+});
+```
+
+## Schema validation
+
+Use `schemaTask` with Zod for payload validation:
+
+```ts
+import { schemaTask } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const processVideo = schemaTask({
+  id: "process-video",
+  schema: z.object({ videoUrl: z.string().url() }),
+  run: async (payload) => {
+    // payload is typed and validated
+  },
+});
+```
+
+## Waits
+
+Use `wait.for` for delays, `wait.until` for dates, and `wait.forToken` for external callbacks:
+
+```ts
+import { wait } from "@trigger.dev/sdk";
+await wait.for({ seconds: 30 });
+await wait.until({ date: new Date("2025-01-01") });
+```
+
+## Configuration
+
+`trigger.config.ts` lives at the project root:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk/build";
+
+export default defineConfig({
+  project: "<your-project-ref>",
+  dirs: ["./trigger"],
+});
+```
+
+## Common mistakes
+
+1. **Forgetting to export tasks** — every task must be a named export
+2. **Importing from `@trigger.dev/sdk/v3`** — this is the old v3 path; always use `@trigger.dev/sdk`
+3. **Using `client.defineJob()`** — this is the deprecated v2 API
+4. **Calling `task.trigger()` directly** — use `tasks.trigger<typeof myTask>("task-id", payload)` from your backend
+5. **Using `triggerAndWait` result as output** — it returns a `Result` object; check `result.ok` then access `result.output`, or use `.unwrap()`
+6. **Wrapping waits/triggerAndWait in `Promise.all`** — not supported in Trigger.dev tasks
+7. **Adding timeouts to tasks** — tasks have no built-in timeout; use `maxDuration` in config if needed
+````
+
+</Accordion>
+
+## llms.txt
+
+We also publish machine-readable documentation for LLM consumption:
+
+- [trigger.dev/docs/llms.txt](https://trigger.dev/docs/llms.txt) — concise overview
+- [trigger.dev/docs/llms-full.txt](https://trigger.dev/docs/llms-full.txt) — full documentation
+
+These follow the [llms.txt standard](https://llmstxt.org) and can be fed directly into any LLM context window.
+
+
+## Troubleshooting
+
+<AccordionGroup>
+
+<Accordion title="AI keeps generating old v2/v3 code">
+  Install [Agent Rules](/mcp-agent-rules) or [Skills](/skills) — they override the outdated patterns in the AI's training data. The [context snippet](#project-level-context-snippet) above is a quick alternative.
+</Accordion>
+
+<Accordion title="MCP server won't connect">
+  1. Make sure you've restarted your AI client after adding the config
+  2. Run `npx trigger.dev@latest install-mcp` again — it will detect and fix common issues
+  3. Check that `npx trigger.dev@latest mcp` runs without errors in your terminal
+  4. See the [MCP introduction](/mcp-introduction) for client-specific config details
+</Accordion>
+
+<Accordion title="Which tool should I install?">
+  All three if possible. If you can only pick one:
+  - **Agent Rules** if you want the broadest code generation improvement
+  - **Skills** if you use multiple AI tools and want a single install
+  - **MCP Server** if you need to trigger tasks, deploy, and search docs from your AI
+</Accordion>
+
+</AccordionGroup>
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="MCP Server" icon="sparkles" href="/mcp-introduction">
+    Install and configure the MCP Server for live project interaction.
+  </Card>
+  <Card title="Skills" icon="wand-magic-sparkles" href="/skills">
+    Portable instruction sets for any AI coding assistant.
+  </Card>
+  <Card title="Agent Rules" icon="scroll" href="/mcp-agent-rules">
+    Comprehensive rule sets installed into your AI client.
+  </Card>
+  <Card title="Writing tasks" icon="code" href="/tasks/overview">
+    Learn the task patterns your AI assistant will follow.
+  </Card>
+</CardGroup>
diff --git a/docs/config/config-file.mdx b/docs/config/config-file.mdx
index ef79bc86200..8d34270433d 100644
--- a/docs/config/config-file.mdx
+++ b/docs/config/config-file.mdx
@@ -154,21 +154,30 @@ Some ones we recommend:
 
 ### Telemetry Exporters
 
-You can also configure custom telemetry exporters to send your traces and logs to other external services. For example, you can send your logs to [Axiom](https://axiom.co/docs/guides/opentelemetry-nodejs#exporter-instrumentation-ts). First, add the opentelemetry exporter packages to your package.json file:
+You can also configure custom telemetry exporters to send your traces, logs, and metrics to other external services. For example, you can send your logs to [Axiom](https://axiom.co/docs/guides/opentelemetry-nodejs#exporter-instrumentation-ts). First, add the opentelemetry exporter packages to your package.json file:
 
 ```json package.json
 "dependencies": {
   "@opentelemetry/exporter-logs-otlp-http": "0.52.1",
-  "@opentelemetry/exporter-trace-otlp-http": "0.52.1"
+  "@opentelemetry/exporter-trace-otlp-http": "0.52.1",
+  "@opentelemetry/exporter-metrics-otlp-proto": "0.52.1"
 }
 ```
 
+<Note>
+  Axiom's `/v1/metrics` endpoint only supports protobuf (`application/x-protobuf`), not JSON. Use
+  `@opentelemetry/exporter-metrics-otlp-proto` instead of
+  `@opentelemetry/exporter-metrics-otlp-http` for metrics. Traces and logs work fine with the
+  `-http` (JSON) exporters.
+</Note>
+
 Then, configure the exporters in your `trigger.config.ts` file:
 
 ```ts trigger.config.ts
 import { defineConfig } from "@trigger.dev/sdk";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
 
 // Initialize OTLP trace exporter with the endpoint URL and headers;
 export default defineConfig({
@@ -196,18 +205,28 @@ export default defineConfig({
         },
       }),
     ],
+    metricExporters: [
+      new OTLPMetricExporter({
+        url: "https://api.axiom.co/v1/metrics",
+        headers: {
+          Authorization: `Bearer ${process.env.AXIOM_API_TOKEN}`,
+          "x-axiom-metrics-dataset": process.env.AXIOM_METRICS_DATASET,
+        },
+      }),
+    ],
   },
 });
 ```
 
-Make sure to set the `AXIOM_API_TOKEN` and `AXIOM_DATASET` environment variables in your project.
+Make sure to set the `AXIOM_API_TOKEN`, `AXIOM_DATASET`, and `AXIOM_METRICS_DATASET` environment variables in your project. Axiom requires a separate, dedicated dataset for metrics — you cannot reuse the same dataset for traces/logs and metrics.
 
-It's important to note that you cannot configure exporters using `OTEL_*` environment variables, as they would conflict with our internal telemetry. Instead you should configure the exporters via passing in arguments to the `OTLPTraceExporter` and `OTLPLogExporter` constructors. For example, here is how you can configure exporting to Honeycomb:
+It's important to note that you cannot configure exporters using `OTEL_*` environment variables, as they would conflict with our internal telemetry. Instead you should configure the exporters via passing in arguments to the `OTLPTraceExporter`, `OTLPLogExporter`, and `OTLPMetricExporter` constructors. For example, here is how you can configure exporting to Honeycomb:
 
 ```ts trigger.config.ts
 import { defineConfig } from "@trigger.dev/sdk";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 
 // Initialize OTLP trace exporter with the endpoint URL and headers;
 export default defineConfig({
@@ -235,6 +254,15 @@ export default defineConfig({
         },
       }),
     ],
+    metricExporters: [
+      new OTLPMetricExporter({
+        url: "https://api.honeycomb.io/v1/metrics",
+        headers: {
+          "x-honeycomb-team": process.env.HONEYCOMB_API_KEY,
+          "x-honeycomb-dataset": process.env.HONEYCOMB_DATASET,
+        },
+      }),
+    ],
   },
 });
 ```
@@ -448,9 +476,26 @@ export default defineConfig({
 });
 ```
 
+#### WebAssembly (WASM) packages
+
+Packages that use WebAssembly (WASM) must be added to the `external` array. WASM files are binary modules that need to be loaded at runtime and cannot be bundled into JavaScript code. When you add a WASM package to `external`, the package will be installed as a dependency in the runtime environment, ensuring the WASM files are available at their expected paths.
+
+```ts trigger.config.ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    external: ["your-wasm-package-name"],
+  },
+});
+```
+
 <Note>
-  Any packages that install or build a native binary should be added to external, as native binaries
-  cannot be bundled. For example, `re2`, `sharp`, and `sqlite3` should be added to external.
+  Any packages that install or build a native binary or use WebAssembly (WASM) should be added to
+  external, as they cannot be bundled. For example, `re2`, `sharp`, `sqlite3`, and WASM packages
+  should be added to external.
 </Note>
 
 ### JSX
diff --git a/docs/config/extensions/overview.mdx b/docs/config/extensions/overview.mdx
index c60083ba882..7e967cbd896 100644
--- a/docs/config/extensions/overview.mdx
+++ b/docs/config/extensions/overview.mdx
@@ -57,6 +57,7 @@ Trigger.dev provides a set of built-in extensions that you can use to customize
 | [additionalPackages](/config/extensions/additionalPackages)           | Install additional npm packages in your build image                            |
 | [syncEnvVars](/config/extensions/syncEnvVars)                         | Automatically sync environment variables from external services to Trigger.dev |
 | [syncVercelEnvVars](/config/extensions/syncEnvVars#syncVercelEnvVars) | Automatically sync environment variables from Vercel to Trigger.dev            |
+| [syncSupabaseEnvVars](/config/extensions/syncEnvVars#syncSupabaseEnvVars) | Automatically sync environment variables from Supabase to Trigger.dev          |
 | [esbuildPlugin](/config/extensions/esbuildPlugin)                     | Add existing or custom esbuild extensions to customize your build process      |
 | [emitDecoratorMetadata](/config/extensions/emitDecoratorMetadata)     | Enable `emitDecoratorMetadata` in your TypeScript build                        |
 | [audioWaveform](/config/extensions/audioWaveform)                     | Add Audio Waveform to your build image                                         |
diff --git a/docs/config/extensions/playwright.mdx b/docs/config/extensions/playwright.mdx
index db9ad342573..ea8461301e6 100644
--- a/docs/config/extensions/playwright.mdx
+++ b/docs/config/extensions/playwright.mdx
@@ -91,6 +91,32 @@ The extension sets the following environment variables during the build:
 - `PLAYWRIGHT_SKIP_BROWSER_VALIDATION`: Set to `1` to skip browser validation at runtime
 - `DISPLAY`: Set to `:99` if `headless: false` (for Xvfb)
 
+## Troubleshooting
+
+### Browser download failures
+
+If you encounter errors during the build process related to browser downloads (e.g., "failed to solve: process did not complete successfully: exit code: 9"), this is a known issue with certain Playwright versions.
+
+**Workaround:** Revert Playwright to version `1.40.0` in your project dependencies. You can specify this version explicitly in your config:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { playwright } from "@trigger.dev/build/extensions/playwright";
+
+export default defineConfig({
+  project: "<project ref>",
+  build: {
+    extensions: [
+      playwright({
+        version: "1.40.0",
+      }),
+    ],
+  },
+});
+```
+
+For more details, see [GitHub issue #2440](https://github.com/triggerdotdev/trigger.dev/issues/2440#issuecomment-3815104376).
+
 ## Managing browser instances
 
 To prevent issues with waits and resumes, you can use middleware and locals to manage the browser instance. This will ensure the browser is available for the whole run, and is properly cleaned up on waits, resumes, and after the run completes.
diff --git a/docs/config/extensions/syncEnvVars.mdx b/docs/config/extensions/syncEnvVars.mdx
index f8947268e22..039c5a5ec22 100644
--- a/docs/config/extensions/syncEnvVars.mdx
+++ b/docs/config/extensions/syncEnvVars.mdx
@@ -71,33 +71,40 @@ export default defineConfig({
 
 The `syncVercelEnvVars` build extension syncs environment variables from your Vercel project to Trigger.dev.
 
-<Note>
-  You need to set the `VERCEL_ACCESS_TOKEN` and `VERCEL_PROJECT_ID` environment variables, or pass
-  in the token and project ID as arguments to the `syncVercelEnvVars` build extension. If you're
-  working with a team project, you'll also need to set `VERCEL_TEAM_ID`, which can be found in your
-  team settings. You can find / generate the `VERCEL_ACCESS_TOKEN` in your Vercel
-  [dashboard](https://vercel.com/account/settings/tokens). Make sure the scope of the token covers
-  the project with the environment variables you want to sync.
-</Note>
-
-<Note>
-  When running the build from a Vercel build environment (e.g., during a Vercel deployment), the
-  environment variable values will be read from `process.env` instead of fetching them from the
-  Vercel API. This is determined by checking if the `VERCEL` environment variable is present. The
-  API is still used to determine which environment variables are configured for your project, but
-  the actual values come from the local environment. Reading values from `process.env` allows the
-  extension to use values that Vercel integrations (such as the Neon integration) set per preview
-  deployment in the "Provisioning Integrations" phase that happens just before the Vercel build
-  starts.
-</Note>
-
-<Note>
-  If you have the Neon database Vercel integration installed and are running builds outside of the
-  Vercel environment, we recommend using `syncNeonEnvVars` in addition to `syncVercelEnvVars` for your
-  database environment variables. This ensures that the correct database connection strings are used for your 
-  selected environment and current branch, as `syncVercelEnvVars` may not accurately reflect
-  branch-specific database credentials when run locally.
-</Note>
+<AccordionGroup>
+<Accordion title="Setting up authentication including team projects">
+You need to set the `VERCEL_ACCESS_TOKEN` and `VERCEL_PROJECT_ID` environment variables, or pass
+in the token and project ID as arguments to the `syncVercelEnvVars` build extension. If you're
+working with a team project, you'll also need to set `VERCEL_TEAM_ID`, which can be found in your
+team settings.
+
+You can find / generate the `VERCEL_ACCESS_TOKEN` in your Vercel
+[dashboard](https://vercel.com/account/settings/tokens). Make sure the scope of the token covers
+the project with the environment variables you want to sync.
+</Accordion>
+
+<Accordion title="Running in Vercel build environment">
+When running the build from a Vercel build environment (e.g., during a Vercel deployment), the
+environment variable values will be read from `process.env` instead of fetching them from the
+Vercel API. This is determined by checking if the `VERCEL` environment variable is present.
+
+The API is still used to determine which environment variables are configured for your project, but
+the actual values come from the local environment. Reading values from `process.env` allows the
+extension to use values that Vercel integrations (such as the Neon integration) set per preview
+deployment in the "Provisioning Integrations" phase that happens just before the Vercel build
+starts.
+</Accordion>
+
+<Accordion title="Using with Neon database Vercel integration">
+If you have the Neon database Vercel integration installed and are running builds outside of the
+Vercel environment, we recommend using `syncNeonEnvVars` in addition to `syncVercelEnvVars` for your
+database environment variables.
+
+This ensures that the correct database connection strings are used for your 
+selected environment and current branch, as `syncVercelEnvVars` may not accurately reflect
+branch-specific database credentials when run locally.
+</Accordion>
+</AccordionGroup>
 
 ```ts
 import { defineConfig } from "@trigger.dev/sdk";
@@ -138,25 +145,29 @@ export default defineConfig({
 
 The `syncNeonEnvVars` build extension syncs environment variables from your Neon database project to Trigger.dev. It automatically detects branches and builds the appropriate database connection strings for your environment.
 
-<Note>
-  You need to set the `NEON_ACCESS_TOKEN` and `NEON_PROJECT_ID` environment variables, or pass them
-  as arguments to the `syncNeonEnvVars` build extension. You can generate a `NEON_ACCESS_TOKEN` in
-  your Neon [dashboard](https://console.neon.tech/app/settings/api-keys).
-</Note>
+<AccordionGroup>
+<Accordion title="Setting up authentication">
+You need to set the `NEON_ACCESS_TOKEN` and `NEON_PROJECT_ID` environment variables, or pass them
+as arguments to the `syncNeonEnvVars` build extension.
 
-<Note>
-  When running the build from a Vercel environment (determined by checking if the `VERCEL`
-  environment variable is present), this extension is skipped entirely. This is because Neon's
-  Vercel integration already handles environment variable synchronization in Vercel environments.
-</Note>
+You can generate a `NEON_ACCESS_TOKEN` in your Neon [dashboard](https://console.neon.tech/app/settings/api-keys).
+</Accordion>
 
-<Note>
-  If you have the Neon database Vercel integration installed and are running builds outside of the
-  Vercel environment, we recommend using `syncNeonEnvVars` in addition to `syncVercelEnvVars` for your
-  database environment variables. This ensures that the correct database connection strings are used for your 
-  selected environment and current branch, as `syncVercelEnvVars` may not accurately reflect
-  branch-specific database credentials when run locally.
-</Note>
+<Accordion title="Running in Vercel environment">
+When running the build from a Vercel environment (determined by checking if the `VERCEL`
+environment variable is present), this extension is skipped entirely.
+
+This is because Neon's Vercel integration already handles environment variable synchronization in Vercel environments.
+</Accordion>
+
+<Accordion title="Using with Neon database Vercel integration">
+If you have the Neon database Vercel integration installed and are running builds outside of the
+Vercel environment, we recommend using `syncNeonEnvVars` in addition to `syncVercelEnvVars` for your
+database environment variables.
+
+This ensures that the correct database connection strings are used for your selected environment and current branch, as `syncVercelEnvVars` may not accurately reflect branch-specific database credentials when run locally.
+</Accordion>
+</AccordionGroup>
 
 <Note>
   This extension is skipped for `prod` environments. It is designed to sync branch-specific
@@ -209,3 +220,72 @@ The extension syncs the following environment variables (with optional prefix):
 - `POSTGRES_PRISMA_URL` - Connection string optimized for Prisma
 - `POSTGRES_HOST`, `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DATABASE`
 - `PGHOST`, `PGHOST_UNPOOLED`, `PGUSER`, `PGPASSWORD`, `PGDATABASE`
+
+### syncSupabaseEnvVars
+
+The `syncSupabaseEnvVars` build extension syncs environment variables from your Supabase project to Trigger.dev. It uses [Supabase Branching](https://supabase.com/docs/guides/deployment/branching) to automatically detect branches and build the appropriate database connection strings and API keys for your environment.
+
+<AccordionGroup>
+<Accordion title="Setting up authentication">
+You need to set the `SUPABASE_ACCESS_TOKEN` and `SUPABASE_PROJECT_ID` environment variables, or pass them
+as arguments to the `syncSupabaseEnvVars` build extension.
+
+You can generate a `SUPABASE_ACCESS_TOKEN` in your Supabase [dashboard](https://supabase.com/dashboard/account/tokens).
+</Accordion>
+
+<Accordion title="Running in Vercel environment">
+When running the build from a Vercel environment (determined by checking if the `VERCEL`
+environment variable is present), this extension is skipped entirely.
+</Accordion>
+</AccordionGroup>
+
+<Note>
+  For `prod` environments, this extension uses credentials from your default Supabase
+  branch. For `preview` and `staging` environments, it matches the git branch name to a Supabase
+  branch and syncs the corresponding database connection strings and API keys. `dev` environments are skipped.
+</Note>
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { syncSupabaseEnvVars } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    // This will automatically use the SUPABASE_ACCESS_TOKEN and SUPABASE_PROJECT_ID environment variables
+    extensions: [syncSupabaseEnvVars()],
+  },
+});
+```
+
+Or you can pass in the token, project ID, and other options as arguments:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { syncSupabaseEnvVars } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [
+      syncSupabaseEnvVars({
+        projectId: "your-supabase-project-id",
+        supabaseAccessToken: "your-supabase-access-token", // optional, we recommend to keep it as env variable
+        branch: "your-branch-name", // optional, defaults to ctx.branch
+        envVarPrefix: "MY_PREFIX_", // optional, prefix for all synced env vars
+      }),
+    ],
+  },
+});
+```
+
+The extension syncs the following environment variables (with optional prefix):
+
+- `DATABASE_URL`, `POSTGRES_URL`, `SUPABASE_DB_URL` — PostgreSQL connection strings
+- `PGHOST`, `PGPORT`, `PGUSER`, `PGPASSWORD`, `PGDATABASE` — Individual connection parameters
+- `SUPABASE_URL` — Supabase API URL
+- `SUPABASE_ANON_KEY` — Anonymous API key
+- `SUPABASE_SERVICE_ROLE_KEY` — Service role API key
+- `SUPABASE_JWT_SECRET` — JWT secret
diff --git a/docs/deploy-environment-variables.mdx b/docs/deploy-environment-variables.mdx
index e123f341705..a4c3b75daf4 100644
--- a/docs/deploy-environment-variables.mdx
+++ b/docs/deploy-environment-variables.mdx
@@ -66,6 +66,18 @@ You can edit an environment variable's values. You cannot edit the key name, you
 
 </Steps>
 
+## Local development
+
+When running `npx trigger.dev dev`, the CLI automatically loads environment variables from these files in order (later files override any duplicate keys from earlier ones):
+
+- `.env`
+- `.env.development`
+- `.env.local`
+- `.env.development.local`
+- `dev.vars`
+
+These variables are available to your tasks via `process.env`. You don't need to use the `--env-file` flag for this automatic loading.
+
 ## In your code
 
 You can use our SDK to get and manipulate environment variables. You can also easily sync environment variables from another service into Trigger.dev.
@@ -360,4 +372,55 @@ This will read your .env.production file using dotenvx and sync the variables to
 
 - Trigger.dev does not automatically detect .env.production or dotenvx files
 - You can paste them manually into the dashboard
-- Or sync them automatically using a build extension
\ No newline at end of file
+- Or sync them automatically using a build extension
+
+## Multi-tenant applications
+
+If you're building a multi-tenant application where each tenant needs different environment variables (like tenant-specific API keys or database credentials), you don't need a separate project for each tenant. Instead, use a single project and load tenant-specific secrets at runtime.
+
+<Note>
+  This is different from [syncing environment variables at deploy time](#sync-env-vars-from-another-service). 
+  Here, secrets are loaded dynamically during task execution, not synced to Trigger.dev's environment variables.
+</Note>
+
+### Recommended approach
+
+Use a secrets service (Infisical, AWS Secrets Manager, HashiCorp Vault, etc.) to store tenant-specific secrets, then retrieve them at the start of each task run based on the tenant identifier in your payload or context.
+
+**Important:** Never pass secrets in the task payload, as payloads are logged and visible in the dashboard.
+
+### Example implementation
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager";
+
+export const processTenantData = task({
+  id: "process-tenant-data",
+  run: async (payload: { tenantId: string; data: unknown }) => {
+    // Retrieve tenant-specific secret at runtime
+    const client = new SecretsManagerClient({ region: "us-east-1" });
+    const response = await client.send(
+      new GetSecretValueCommand({
+        SecretId: `tenants/${payload.tenantId}/supabase-key`,
+      })
+    );
+
+    const supabaseKey = JSON.parse(response.SecretString!).SUPABASE_SERVICE_KEY;
+
+    // Your task logic using the tenant-specific secret
+    // ...
+  },
+});
+```
+
+You can use any secrets service - see the [sync env vars section](#sync-env-vars-from-another-service) for an example with Infisical.
+
+### Benefits
+
+- **Single codebase** - Deploy once, works for all tenants
+- **Secure** - Secrets never appear in payloads or logs
+- **Scalable** - No project limit constraints
+- **Flexible** - Easy to add new tenants without redeploying
+
+This approach allows you to support unlimited tenants with a single Trigger.dev project, avoiding the [project limit](/limits#projects) while maintaining security and separation of tenant data.
\ No newline at end of file
diff --git a/docs/deployment/overview.mdx b/docs/deployment/overview.mdx
index 72baa9ec2a3..8c15954cba8 100644
--- a/docs/deployment/overview.mdx
+++ b/docs/deployment/overview.mdx
@@ -180,7 +180,7 @@ Now you can trigger tasks against the staging environment by setting the `TRIGGE
 TRIGGER_SECRET_KEY="tr_stg_abcd123"
 ```
 
-Currently, we only support two environments: `prod` and `staging`. Multiple environments are on our roadmap which you can track [here](https://feedback.trigger.dev/p/more-environments).
+For additional environments beyond `prod` and `staging`, you can use [preview branches](/deployment/preview-branches), which allow you to create isolated environments for each branch of your code.
 
 ## Local builds
 
diff --git a/docs/deployment/preview-branches.mdx b/docs/deployment/preview-branches.mdx
index 7e98e512876..f2a354e2e9d 100644
--- a/docs/deployment/preview-branches.mdx
+++ b/docs/deployment/preview-branches.mdx
@@ -72,7 +72,7 @@ This GitHub Action will:
 
 1. Automatically create a preview branch for your Pull Request (if the branch doesn't already exist).
 2. Deploy the preview branch.
-3. Archive the preview branch when the Pull Request is merged/closed.
+3. Archive the preview branch when the Pull Request is merged/closed. This only works if your workflow runs on **closed** PRs (`types: [opened, synchronize, reopened, closed]`). If you omit `closed`, branches won't be archived automatically.
 
 ```yml .github/workflows/trigger-preview-branches.yml
 name: Deploy to Trigger.dev (preview branches)
diff --git a/docs/docs.json b/docs/docs.json
index fa0536713c1..f8d00c604d6 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -43,6 +43,18 @@
               "apikeys"
             ]
           },
+          {
+            "group": "Building with AI",
+            "pages": [
+              "building-with-ai",
+              {
+                "group": "MCP Server",
+                "pages": ["mcp-introduction", "mcp-tools"]
+              },
+              "skills",
+              "mcp-agent-rules"
+            ]
+          },
           {
             "group": "Writing tasks",
             "pages": [
@@ -58,6 +70,7 @@
               "machines",
               "idempotency",
               "runs/max-duration",
+              "runs/heartbeats",
               "tags",
               "runs/metadata",
               "tasks/streams",
@@ -124,7 +137,7 @@
               "realtime/run-object",
               "realtime/auth",
               {
-                "group": "React hooks (frontend)",
+                "group": "React hooks",
                 "pages": [
                   "realtime/react-hooks/overview",
                   "realtime/react-hooks/triggering",
@@ -167,8 +180,8 @@
             ]
           },
           {
-            "group": "MCP Server",
-            "pages": ["mcp-introduction", "mcp-tools", "mcp-agent-rules"]
+            "group": "Observability",
+            "pages": ["observability/query", "observability/dashboards"]
           },
           {
             "group": "Using the Dashboard",
@@ -226,7 +239,20 @@
           },
           {
             "group": "Tasks API",
-            "pages": ["management/tasks/trigger", "management/tasks/batch-trigger"]
+            "pages": [
+              "management/tasks/trigger",
+              "management/tasks/batch-trigger",
+              "management/tasks/trigger-batch"
+            ]
+          },
+          {
+            "group": "Batches API",
+            "pages": [
+              "management/batches/create",
+              "management/batches/retrieve",
+              "management/batches/retrieve-results",
+              "management/batches/stream-items"
+            ]
           },
           {
             "group": "Runs API",
@@ -236,7 +262,21 @@
               "management/runs/replay",
               "management/runs/cancel",
               "management/runs/reschedule",
-              "management/runs/update-metadata"
+              "management/runs/update-metadata",
+              "management/runs/add-tags",
+              "management/runs/retrieve-events",
+              "management/runs/retrieve-trace",
+              "management/runs/retrieve-result"
+            ]
+          },
+          {
+            "group": "Queues API",
+            "pages": [
+              "management/queues/list",
+              "management/queues/retrieve",
+              "management/queues/pause",
+              "management/queues/concurrency-override",
+              "management/queues/concurrency-reset"
             ]
           },
           {
@@ -262,6 +302,28 @@
               "management/envvars/update",
               "management/envvars/delete"
             ]
+          },
+          {
+            "group": "Deployments API",
+            "pages": [
+              "management/deployments/retrieve",
+              "management/deployments/get-latest",
+              "management/deployments/promote"
+            ]
+          },
+          {
+            "group": "Waitpoints API",
+            "pages": [
+              "management/waitpoints/create",
+              "management/waitpoints/list",
+              "management/waitpoints/retrieve",
+              "management/waitpoints/complete",
+              "management/waitpoints/complete-callback"
+            ]
+          },
+          {
+            "group": "Query API",
+            "pages": ["management/query/execute"]
           }
         ]
       },
@@ -330,11 +392,16 @@
                   "guides/frameworks/webhooks-guides-overview",
                   "guides/frameworks/nextjs-webhooks",
                   "guides/frameworks/remix-webhooks",
-                  "guides/examples/stripe-webhook"
+                  "guides/examples/stripe-webhook",
+                  "guides/examples/hookdeck-webhook"
                 ]
               }
             ]
           },
+          {
+            "group": "Migration guides",
+            "pages": ["migration-mergent", "migration-n8n"]
+          },
           {
             "group": "Use cases",
             "pages": [
@@ -353,6 +420,7 @@
               "guides/example-projects/claude-changelog-generator",
               "guides/example-projects/claude-github-wiki",
               "guides/example-projects/claude-thinking-chatbot",
+              "guides/example-projects/cursor-background-agent",
               "guides/example-projects/human-in-the-loop-workflow",
               "guides/example-projects/mastra-agents-with-memory",
               "guides/example-projects/meme-generator-human-in-the-loop",
@@ -360,6 +428,7 @@
               "guides/example-projects/product-image-generator",
               "guides/example-projects/realtime-csv-importer",
               "guides/example-projects/realtime-fal-ai",
+              "guides/example-projects/smart-spreadsheet",
               "guides/example-projects/turborepo-monorepo-prisma",
               "guides/example-projects/vercel-ai-sdk-deep-research",
               "guides/example-projects/vercel-ai-sdk-image-generator"
@@ -403,10 +472,6 @@
               "guides/examples/vercel-sync-env-vars"
             ]
           },
-          {
-            "group": "Migration guides",
-            "pages": ["migration-mergent"]
-          },
           {
             "group": "Community packages",
             "pages": [
@@ -431,6 +496,11 @@
       "display": "simple"
     }
   },
+  "styling": {
+    "codeblocks": {
+      "theme": "css-variables"
+    }
+  },
   "appearance": {
     "default": "dark",
     "strict": true
@@ -572,6 +642,10 @@
       "source": "/trigger-config",
       "destination": "/config/config-file"
     },
+    {
+      "source": "/guides/frameworks",
+      "destination": "/guides/frameworks/nextjs"
+    },
     {
       "source": "/guides/frameworks/introduction",
       "destination": "/guides/introduction"
@@ -651,6 +725,14 @@
     {
       "source": "/upgrade-to-v4",
       "destination": "/migrating-from-v3"
+    },
+    {
+      "source": "/insights/query",
+      "destination": "/observability/query"
+    },
+    {
+      "source": "/insights/metrics",
+      "destination": "/observability/dashboards"
     }
   ]
 }
diff --git a/docs/errors-retrying.mdx b/docs/errors-retrying.mdx
index 246db2b82af..ae6c4403f4d 100644
--- a/docs/errors-retrying.mdx
+++ b/docs/errors-retrying.mdx
@@ -12,6 +12,8 @@ You can configure retrying in two ways:
 1. In your [trigger.config file](/config/config-file) you can set the default retrying behavior for all tasks.
 2. On each task you can set the retrying behavior.
 
+<Note>Task-level retry settings override the defaults in your `trigger.config` file.</Note>
+
 <Note>
   By default when you create your project using the CLI init command we disabled retrying in the DEV
   environment. You can enable it in your [trigger.config file](/config/config-file).
diff --git a/docs/github-actions.mdx b/docs/github-actions.mdx
index 897ac5cac6c..3f1c145926f 100644
--- a/docs/github-actions.mdx
+++ b/docs/github-actions.mdx
@@ -83,6 +83,41 @@ jobs:
 
 If you already have a GitHub action file, you can just add the final step "🚀 Deploy Trigger.dev" to your existing file.
 
+## Preview branches
+
+To deploy to preview branches from Pull Requests and have them archived when PRs are merged or closed, use a workflow that runs on `pull_request` with **all four types** including `closed`:
+
+```yaml .github/workflows/trigger-preview-branches.yml
+name: Deploy to Trigger.dev (preview branches)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, closed]
+
+jobs:
+  deploy-preview:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20.x"
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Deploy preview branch
+        run: npx trigger.dev@latest deploy --env preview
+        env:
+          TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
+```
+
+<Note>
+  **Include `closed`** in the `pull_request.types` list. Without it, preview branches won't be archived when PRs are merged or closed, and you may hit the limit on active preview branches. See [Preview branches](/deployment/preview-branches#preview-branches-with-github-actions-recommended) for more details.
+</Note>
+
 ## Creating a Personal Access Token
 
 <Steps>
@@ -134,16 +169,11 @@ You should use the version you run locally during dev and manual deploy. The cur
 
 ## Self-hosting
 
-When self-hosting, you will have to take a few additional steps:
+When self-hosting, you need to:
 
-- Specify the `TRIGGER_API_URL` environment variable. You can add it to the GitHub secrets the same way as the access token. This should point at your webapp domain, for example: `https://trigger.example.com`
-- Setup docker as you will need to build and push the image to your registry. On [Trigger.dev Cloud](https://cloud.trigger.dev) this is all done remotely.
+- Set up Docker Buildx in your CI environment for building images locally.
 - Add your registry credentials to the GitHub secrets.
-- Use the `--self-hosted` and `--push` flags when deploying.
-
-<Tip>If you're self-hosting v4, the `--self-hosted` and `--push` flags are **NOT** needed.</Tip>
-
-Other than that, your GitHub action file will look very similar to the one above:
+- Specify the `TRIGGER_API_URL` environment variable pointing to your webapp domain, for example: `https://trigger.example.com`
 
 <CodeGroup>
 
@@ -170,13 +200,11 @@ jobs:
       - name: Install dependencies
         run: npm install
 
-      # docker setup - part 1
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
         with:
           version: latest
 
-      # docker setup - part 2
       - name: Login to DockerHub
         uses: docker/login-action@v3
         with:
@@ -186,11 +214,9 @@ jobs:
       - name: 🚀 Deploy Trigger.dev
         env:
           TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
-          # required when self-hosting
           TRIGGER_API_URL: ${{ secrets.TRIGGER_API_URL }}
-        # deploy with additional flags
         run: |
-          npx trigger.dev@latest deploy --self-hosted --push
+          npx trigger.dev@latest deploy
 ```
 
 </CodeGroup>
diff --git a/docs/guides/ai-agents/overview.mdx b/docs/guides/ai-agents/overview.mdx
index 3c3da8b2ddd..0c27982a450 100644
--- a/docs/guides/ai-agents/overview.mdx
+++ b/docs/guides/ai-agents/overview.mdx
@@ -59,6 +59,13 @@ description: "Real world AI agent example tasks using Trigger.dev"
   >
     Use the Vercel AI SDK to generate comprehensive PDF reports using a deep research agent.
   </Card>
+  <Card
+    title="Smart Spreadsheet"
+    icon="table"
+    href="/guides/example-projects/smart-spreadsheet"
+  >
+    Enrich company data using Exa search and Claude with real-time streaming results.
+  </Card>
 </CardGroup>
 
 ## Agent fundamentals
diff --git a/docs/guides/example-projects/cursor-background-agent.mdx b/docs/guides/example-projects/cursor-background-agent.mdx
new file mode 100644
index 00000000000..b05ffa0df9d
--- /dev/null
+++ b/docs/guides/example-projects/cursor-background-agent.mdx
@@ -0,0 +1,111 @@
+---
+title: "Background Cursor agent using the Cursor CLI"
+sidebarTitle: "Cursor background agent"
+description: "Run Cursor's headless CLI agent in a Trigger.dev task and stream the live output to the frontend using Trigger.dev Realtime Streams."
+---
+
+import RealtimeLearnMore from "/snippets/realtime-learn-more.mdx";
+
+## Overview
+
+This example runs [Cursor's headless CLI](https://cursor.com/cli) in a Trigger.dev task. The agent spawns as a child process, and its NDJSON stdout is parsed and piped to the browser in real-time using [Realtime Streams](/realtime/react-hooks/streams). The result is a live terminal UI that renders each Cursor event (system messages, assistant responses, tool calls, results) as it happens.
+
+**Tech stack:**
+
+- **[Next.js](https://nextjs.org/)** for the web app (App Router with server actions)
+- **[Cursor CLI](https://cursor.com/cli)** for the headless AI coding agent
+- **[Trigger.dev](https://trigger.dev)** for task orchestration, real-time streaming, and deployment
+
+## Video
+
+<video
+  controls
+  className="w-full aspect-video"
+  src="https://github.com/user-attachments/assets/459aa160-6659-478e-868f-32e74f79d21a"
+></video>
+
+**Features:**
+
+- **Build extensions**: Installs the `cursor-agent` binary into the task container image using `addLayer`, demonstrating how to ship system binaries with your tasks
+- **Realtime Streams v2**: NDJSON from a child process stdout is parsed and piped directly to the browser using `streams.define()` and `.pipe()`
+- **Live terminal rendering**: Each Cursor event renders as a distinct row with auto-scroll
+- **Long-running tasks**: Cursor agent runs for minutes; Trigger.dev handles lifecycle, timeouts, and retries automatically
+- **Machine selection**: Uses the `medium-2x` preset for resource-intensive CLI tools
+- **LLM model picker**: Switch between models from the UI before triggering a run
+
+## GitHub repo
+
+<Card
+  title="View the Cursor background agent repo"
+  icon="GitHub"
+  href="https://github.com/triggerdotdev/examples/tree/main/cursor-cli-demo"
+>
+  Click here to view the full code for this project in our examples repository on GitHub. You can
+  fork it and use it as a starting point for your own project.
+</Card>
+
+## How it works
+
+### Task orchestration
+
+The task spawns the Cursor CLI as a child process and streams its output to the frontend:
+
+1. A Next.js server action triggers the `cursor-agent` task with the user's prompt and selected model
+2. The task spawns the Cursor CLI binary using a helper that returns a typed NDJSON stream and a `waitUntilExit()` promise
+3. Each line of NDJSON stdout is parsed into typed Cursor events and piped to a Realtime Stream
+4. The frontend subscribes to the stream using `useRealtimeRunWithStreams` and renders each event in a terminal UI
+5. The task waits for the CLI process to exit and returns the result
+
+### Build extension for system binaries
+
+The example includes a custom build extension that installs `cursor-agent` into the container image using `addLayer`. The official install script is run at build time, then the resolved entry point and its dependencies are copied to a fixed path so the task can invoke them at runtime with the bundled Node binary.
+
+```ts extensions/cursor-cli.ts
+const CURSOR_AGENT_DIR = "/usr/local/lib/cursor-agent";
+
+export const cursorCli = (): BuildExtension => ({
+  name: "cursor-cli",
+  onBuildComplete(context) {
+    if (context.target === "dev") return;
+
+    context.addLayer({
+      id: "cursor-cli",
+      image: {
+        instructions: [
+          "RUN apt-get update && apt-get install -y curl ca-certificates && rm -rf /var/lib/apt/lists/*",
+          'ENV PATH="/root/.local/bin:$PATH"',
+          "RUN curl -fsSL https://cursor.com/install | bash",
+          `RUN cp -r $(dirname $(readlink -f /root/.local/bin/cursor-agent)) ${CURSOR_AGENT_DIR}`,
+        ],
+      },
+    });
+  },
+});
+```
+
+### Streaming with Realtime Streams v2
+
+The stream is defined with a typed schema and piped from the child process:
+
+```ts trigger/cursor-stream.ts
+export const cursorStream = streams.define("cursor", cursorEventSchema);
+```
+
+```ts trigger/cursor-agent.ts
+const { stream, waitUntilExit } = spawnCursorAgent({ prompt, model });
+cursorStream.pipe(stream);
+await waitUntilExit();
+```
+
+On the frontend, the `useRealtimeRunWithStreams` hook subscribes to these events and renders them as they arrive.
+
+## Relevant code
+
+- **Build extension + spawn helper**: [extensions/cursor-cli.ts](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/extensions/cursor-cli.ts): installs the binary and provides a typed NDJSON stream with `waitUntilExit()`
+- **Task definition**: [trigger/cursor-agent.ts](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/trigger/cursor-agent.ts): spawns the CLI, pipes the stream, waits for exit
+- **Stream definition**: [trigger/cursor-stream.ts](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/trigger/cursor-stream.ts): Realtime Streams v2 stream with typed schema
+- **Terminal UI**: [components/terminal.tsx](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/components/terminal.tsx): renders live events using `useRealtimeRunWithStreams`
+- **Event types**: [lib/cursor-events.ts](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/lib/cursor-events.ts): TypeScript types and parsers for Cursor NDJSON events
+- **Trigger config**: [trigger.config.ts](https://github.com/triggerdotdev/examples/blob/main/cursor-cli-demo/trigger.config.ts): project config with the cursor CLI build extension
+
+<RealtimeLearnMore />
diff --git a/docs/guides/example-projects/smart-spreadsheet.mdx b/docs/guides/example-projects/smart-spreadsheet.mdx
new file mode 100644
index 00000000000..ab1cc48a45e
--- /dev/null
+++ b/docs/guides/example-projects/smart-spreadsheet.mdx
@@ -0,0 +1,92 @@
+---
+title: "Smart Spreadsheet"
+sidebarTitle: "Smart Spreadsheet"
+description: "An AI-powered company enrichment tool that uses Exa search and Claude to extract verified company data with source attribution."
+---
+
+import RealtimeLearnMore from "/snippets/realtime-learn-more.mdx";
+
+## Overview
+
+Smart Spreadsheet is an AI-powered tool that enriches company data on demand. Input a company name or website URL and get verified information including industry, headcount, and funding details; each with source attribution. Results appear in the frontend in real-time as each task completes.
+
+- A [Next.js](https://nextjs.org/) app with [Trigger.dev](https://trigger.dev/) for background tasks
+- [Exa](https://exa.ai/) – an AI-native search engine that returns clean, structured content ready for LLM extraction
+- [Claude](https://anthropic.com/) via the [Vercel AI SDK](https://sdk.vercel.ai/) for data extraction
+- [Supabase](https://supabase.com/) PostgreSQL database for persistence
+- Trigger.dev [Realtime](/realtime/overview) for live updates to the frontend
+
+## Video
+
+<video
+  controls
+  className="w-full aspect-video"
+  src="https://content.trigger.dev/smart-spreadsheet.mp4"
+></video>
+
+## GitHub repo
+
+<Card
+  title="View the Smart Spreadsheet repo"
+  icon="github"
+  href="https://github.com/triggerdotdev/examples/tree/main/smart-spreadsheet"
+>
+  Click here to view the full code for this project in our examples repository on GitHub. You can
+  fork it and use it as a starting point for your own project.
+</Card>
+
+## How it works
+
+The enrichment workflow:
+
+1. **Trigger enrichment** – User enters a company name or URL in the spreadsheet UI
+2. **Parallel data gathering** – Four subtasks run concurrently to fetch basic info, industry, employee count, and funding details
+3. **AI extraction** – Each subtask uses Exa search + Claude to extract structured data with source URLs
+4. **Real-time updates** – Results appear in the frontend as each subtask completes
+5. **Persist results** – Enriched data is saved to Supabase with source attribution
+
+## Features
+
+- **Parallel processing** – All four enrichment categories run simultaneously using [batch.triggerByTaskAndWait](/triggering#batch-trigger-by-task-and-wait)
+- **Source attribution** – Every data point includes the URL it was extracted from
+- **Live updates** – Results appear in the UI as each task completes using [Realtime](/realtime/overview)
+- **Structured extraction** – Zod schemas ensure consistent data output from Claude
+
+## Key code patterns
+
+### Parallel task execution
+
+The main task triggers all four enrichment subtasks simultaneously using `batch.triggerByTaskAndWait`:
+
+```ts src/trigger/enrich-company.ts
+const { runs } = await batch.triggerByTaskAndWait([
+  { task: getBasicInfo, payload: { companyName, companyUrl } },
+  { task: getIndustry, payload: { companyName, companyUrl } },
+  { task: getEmployeeCount, payload: { companyName, companyUrl } },
+  { task: getFundingRound, payload: { companyName, companyUrl } },
+]);
+```
+
+### Live updates from child tasks
+
+Each subtask uses `metadata.parent.set()` to update the parent's metadata as soon as data is extracted:
+
+```ts src/trigger/get-basic-info.ts
+// After Claude extracts the data, update the parent task's metadata
+metadata.parent.set("website", object.website);
+metadata.parent.set("description", object.description);
+```
+
+The frontend subscribes to these metadata updates using [Realtime](/realtime/overview), so users see each field populate as it's discovered.
+
+## Relevant code
+
+| File                                                                                                                                           | Description                                                            |
+| ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| [`src/trigger/enrich-company.ts`](https://github.com/triggerdotdev/examples/blob/main/smart-spreadsheet/src/trigger/enrich-company.ts)         | Main orchestrator that triggers parallel subtasks and persists results |
+| [`src/trigger/get-basic-info.ts`](https://github.com/triggerdotdev/examples/blob/main/smart-spreadsheet/src/trigger/get-basic-info.ts)         | Extracts company website and description                               |
+| [`src/trigger/get-industry.ts`](https://github.com/triggerdotdev/examples/blob/main/smart-spreadsheet/src/trigger/get-industry.ts)             | Classifies company industry                                            |
+| [`src/trigger/get-employee-count.ts`](https://github.com/triggerdotdev/examples/blob/main/smart-spreadsheet/src/trigger/get-employee-count.ts) | Finds employee headcount                                               |
+| [`src/trigger/get-funding-round.ts`](https://github.com/triggerdotdev/examples/blob/main/smart-spreadsheet/src/trigger/get-funding-round.ts)   | Discovers latest funding information                                   |
+
+<RealtimeLearnMore />
diff --git a/docs/guides/examples/hookdeck-webhook.mdx b/docs/guides/examples/hookdeck-webhook.mdx
new file mode 100644
index 00000000000..a28949fca94
--- /dev/null
+++ b/docs/guides/examples/hookdeck-webhook.mdx
@@ -0,0 +1,71 @@
+---
+title: "Trigger tasks from Hookdeck webhooks"
+sidebarTitle: "Hookdeck webhooks"
+description: "This example demonstrates how to use Hookdeck to receive webhooks and trigger Trigger.dev tasks."
+---
+
+## Overview
+
+This example shows how to use [Hookdeck](https://hookdeck.com) as your webhook infrastructure to trigger Trigger.dev tasks. Hookdeck receives webhooks from external services, and forwards them directly to the Trigger.dev API. This gives you the best of both worlds: Hookdeck's webhook management, logging, and replay capabilities, combined with Trigger.dev's reliable task execution.
+
+## Key features
+
+- Use Hookdeck as your webhook endpoint for external services
+- Hookdeck forwards webhooks directly to Trigger.dev tasks via the API
+- All webhooks are logged and replayable in Hookdeck
+
+## Setting up Hookdeck
+
+You'll configure everything in the [Hookdeck dashboard](https://dashboard.hookdeck.com). No code changes needed in your app.
+
+### 1. Create a destination
+
+In Hookdeck, create a new [destination](https://hookdeck.com/docs/destinations) with the following settings:
+
+- **URL**: `https://api.trigger.dev/api/v1/tasks/<task-id>/trigger` (replace `<task-id>` with your task ID)
+- **Method**: POST
+- **Authentication**: Bearer token (use your `TRIGGER_SECRET_KEY` from Trigger.dev)
+
+### 2. Add a transformation
+
+Create a [transformation](https://hookdeck.com/docs/transformations) to wrap the webhook body in the `payload` field that Trigger.dev expects:
+
+```javascript
+addHandler("transform", (request, context) => {
+  request.body = { payload: { ...request.body } };
+  return request;
+});
+```
+
+### 3. Create a connection
+
+Create a [connection](https://hookdeck.com/docs/connections) that links your source (where webhooks come from) to the destination and transformation you created above.
+
+## Task code
+
+This task will be triggered when Hookdeck forwards a webhook to the Trigger.dev API.
+
+```ts trigger/webhook-handler.ts
+import { task } from "@trigger.dev/sdk";
+
+export const webhookHandler = task({
+  id: "webhook-handler",
+  run: async (payload: Record<string, unknown>) => {
+    // The payload contains the original webhook data from the external service
+    console.log("Received webhook:", payload);
+
+    // Add your custom logic here
+  },
+});
+```
+
+## Testing your setup
+
+To test everything is working:
+
+1. Set up your destination, transformation, and connection in [Hookdeck](https://dashboard.hookdeck.com)
+2. Send a test webhook to your Hookdeck source URL (use the Hookdeck Console or cURL)
+3. Check the Hookdeck dashboard to verify the webhook was received and forwarded
+4. Check the [Trigger.dev dashboard](https://cloud.trigger.dev) to see the successful run of your task
+
+For more information on setting up Hookdeck, refer to the [Hookdeck Documentation](https://hookdeck.com/docs).
diff --git a/docs/guides/examples/puppeteer.mdx b/docs/guides/examples/puppeteer.mdx
index da1874476c5..9a6f91f018d 100644
--- a/docs/guides/examples/puppeteer.mdx
+++ b/docs/guides/examples/puppeteer.mdx
@@ -153,6 +153,7 @@ In this example we use [Puppeteer](https://pptr.dev/) with a [BrowserBase](https
 <Warning>
   When web scraping, you MUST use the technique below which uses a proxy with Puppeteer. Direct
   scraping without using `browserWSEndpoint` is prohibited and will result in account suspension.
+  Screenshots are also prohibited when scraping.
 </Warning>
 
 ### Task code
diff --git a/docs/guides/examples/vercel-sync-env-vars.mdx b/docs/guides/examples/vercel-sync-env-vars.mdx
index bcdb7d30cb7..f6c9a063e3d 100644
--- a/docs/guides/examples/vercel-sync-env-vars.mdx
+++ b/docs/guides/examples/vercel-sync-env-vars.mdx
@@ -6,9 +6,18 @@ description: "This example demonstrates how to sync environment variables from y
 
 import VercelDocsCards from "/snippets/vercel-docs-cards.mdx";
 
+<Warning>
+  **Deprecated when using the Vercel integration.** If you are using the [Vercel
+  integration](/vercel-integration), do not use `syncVercelEnvVars` — the integration handles env
+  var syncing natively and using both together can cause env vars to be incorrectly populated.
+
+  If you are **not** using the Vercel integration, `syncVercelEnvVars` is still supported. Continue
+  with the configuration below.
+</Warning>
+
 ## Build configuration
 
-To sync environment variables, you just need to add our build extension to your `trigger.config.ts` file. This extension will then automatically run every time you deploy your Trigger.dev project.
+If you are not using the [Vercel integration](/vercel-integration), you can sync environment variables manually by adding the `syncVercelEnvVars` build extension to your `trigger.config.ts` file. This extension will run automatically every time you deploy your Trigger.dev project.
 
 <Note>
   You need to set the `VERCEL_ACCESS_TOKEN` and `VERCEL_PROJECT_ID` environment variables, or pass
diff --git a/docs/guides/frameworks/bun.mdx b/docs/guides/frameworks/bun.mdx
index e5f4ab1cd0d..3b9f7ccce23 100644
--- a/docs/guides/frameworks/bun.mdx
+++ b/docs/guides/frameworks/bun.mdx
@@ -14,11 +14,19 @@ import CliViewRunStep from "/snippets/step-view-run.mdx";
   Bun will still be used to execute your tasks, even in the `dev` environment.
 </Warning>
 
+<Note>
+  **Supported Bun version:** Deployed tasks run on Bun 1.3.3. For local development, use Bun 1.3.x for compatibility.
+</Note>
+
 <Prerequisites framework="Bun" />
 
 ## Known issues
 
 - Certain OpenTelemetry instrumentation will not work with Bun, because Bun does not support Node's `register` hook. This means that some libraries that rely on this hook will not work with Bun.
+- If Bun is installed via Homebrew (e.g. `/opt/homebrew/bin/bun`), you may see an `ENOENT: spawn /Users/<you>/.bun/bin/bun` error because the CLI expects Bun at the default install path. **Workaround:** create a symlink:
+  ```bash
+  mkdir -p ~/.bun/bin && ln -s $(which bun) ~/.bun/bin/bun
+  ```
 
 ## Initial setup
 
diff --git a/docs/guides/frameworks/nextjs.mdx b/docs/guides/frameworks/nextjs.mdx
index d8b35cbe649..5b91a85bea9 100644
--- a/docs/guides/frameworks/nextjs.mdx
+++ b/docs/guides/frameworks/nextjs.mdx
@@ -45,7 +45,7 @@ For more information on authenticating with Trigger.dev, see the [API keys page]
 
 ## Triggering your task in Next.js
 
-Here are the steps to trigger your task in the Next.js App and Pages router and Server Actions. Alternatively, check out this repo for a [full working example](https://github.com/triggerdotdev/example-projects/tree/main/nextjs/server-actions/my-app) of a Next.js app with a Trigger.dev task triggered using a Server Action.
+Here are the steps to trigger your task in the Next.js App and Pages router and Server Actions.
 
 <Tabs>
 
@@ -432,5 +432,18 @@ You can test your revalidation task in the Trigger.dev dashboard on the testing
     <NextjsTroubleshootingMissingApiKey/>
     <NextjsTroubleshootingButtonSyntax/>
 
+## Realtime updates with React hooks
+
+The `@trigger.dev/react-hooks` package lets you subscribe to task runs from your React components. Show progress bars, stream AI responses, or display run status in real time.
+
+<CardGroup cols={2}>
+  <Card title="React hooks" icon="react" href="/realtime/react-hooks/overview">
+    Hooks for subscribing to runs, streaming data, and triggering tasks from the frontend.
+  </Card>
+  <Card title="Streams" icon="wave-pulse" href="/tasks/streams">
+    Pipe continuous data (like AI completions) from your tasks to the client while they run.
+  </Card>
+</CardGroup>
+
 <VercelDocsCards />
 <UsefulNextSteps />
diff --git a/docs/guides/frameworks/remix.mdx b/docs/guides/frameworks/remix.mdx
index d8fdb3450af..fdab31524c5 100644
--- a/docs/guides/frameworks/remix.mdx
+++ b/docs/guides/frameworks/remix.mdx
@@ -197,6 +197,19 @@ The `vercel-build` script in `package.json` is specific to Remix projects on Ver
 
 The `runtime: "edge"` configuration in the API route allows for better performance on Vercel's Edge Network.
 
+## Realtime updates with React hooks
+
+The `@trigger.dev/react-hooks` package lets you subscribe to task runs from your React components. Show progress bars, stream AI responses, or display run status in real time.
+
+<CardGroup cols={2}>
+  <Card title="React hooks" icon="react" href="/realtime/react-hooks/overview">
+    Hooks for subscribing to runs, streaming data, and triggering tasks from the frontend.
+  </Card>
+  <Card title="Streams" icon="wave-pulse" href="/tasks/streams">
+    Pipe continuous data (like AI completions) from your tasks to the client while they run.
+  </Card>
+</CardGroup>
+
 ## Additional resources for Remix
 
 <Card
diff --git a/docs/guides/frameworks/supabase-edge-functions-basic.mdx b/docs/guides/frameworks/supabase-edge-functions-basic.mdx
index 26087401607..c3372c41e94 100644
--- a/docs/guides/frameworks/supabase-edge-functions-basic.mdx
+++ b/docs/guides/frameworks/supabase-edge-functions-basic.mdx
@@ -192,4 +192,24 @@ Check your [cloud.trigger.dev](http://cloud.trigger.dev) dashboard and you shoul
 </Step>
 </Steps>
 
+### If you see a runtime error when calling tasks.trigger()
+
+If you see `TypeError: Cannot read properties of undefined (reading 'toString')` when calling `tasks.trigger()` from your edge function, the SDK is hitting a dependency that expects Node-style APIs not available in the Supabase Edge (Deno) runtime. Use the [Tasks API](/management/tasks/trigger) with `fetch` instead of the SDK—that avoids loading the SDK in Deno:
+
+```ts
+const response = await fetch(
+  `https://api.trigger.dev/api/v1/tasks/your-task-id/trigger`,
+  {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${Deno.env.get("TRIGGER_SECRET_KEY")}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ payload: { your: "payload" } }),
+  }
+);
+```
+
+See [Trigger task via API](/management/tasks/trigger) for full request/response details and optional fields (e.g. `delay`, `idempotencyKey`).
+
 <SupabaseDocsCards />
diff --git a/docs/guides/frameworks/webhooks-guides-overview.mdx b/docs/guides/frameworks/webhooks-guides-overview.mdx
index 5e9703b53ef..4c0a4404276 100644
--- a/docs/guides/frameworks/webhooks-guides-overview.mdx
+++ b/docs/guides/frameworks/webhooks-guides-overview.mdx
@@ -31,6 +31,10 @@ A webhook handler is code that executes in response to an event. They can be end
     How to create a Stripe webhook handler and trigger a task when a 'checkout session completed'
     event is received.
   </Card>
+  <Card title="Hookdeck webhooks" icon="webhook" href="/guides/examples/hookdeck-webhook">
+    Use Hookdeck to receive webhooks and forward them to Trigger.dev tasks with logging and replay
+    capabilities.
+  </Card>
   <Card
     title="Supabase database webhooks guide"
     icon="webhook"
diff --git a/docs/guides/introduction.mdx b/docs/guides/introduction.mdx
index 3671a0dfb01..116c8539b0d 100644
--- a/docs/guides/introduction.mdx
+++ b/docs/guides/introduction.mdx
@@ -37,6 +37,7 @@ Get set up fast using our detailed walk-through guides.
 | [Python web crawler](/guides/python/python-crawl4ai)                                       | Use Python, Crawl4AI and Playwright to create a headless web crawler |
 | [Sequin database triggers](/guides/frameworks/sequin)                                      | Trigger tasks from database changes using Sequin                     |
 | [Stripe webhooks](/guides/examples/stripe-webhook)                                         | Trigger tasks from incoming Stripe webhook events                    |
+| [Hookdeck webhooks](/guides/examples/hookdeck-webhook)                                     | Use Hookdeck to receive webhooks and forward them to Trigger.dev tasks |
 | [Supabase database webhooks](/guides/frameworks/supabase-edge-functions-database-webhooks) | Trigger tasks using Supabase database webhooks                       |
 | [Supabase edge function hello world](/guides/frameworks/supabase-edge-functions-basic)     | Trigger tasks from Supabase edge function                            |
 | [Using webhooks in Next.js](/guides/frameworks/nextjs-webhooks)                            | Trigger tasks from a webhook in Next.js                              |
@@ -55,6 +56,7 @@ Example projects are full projects with example repos you can fork and use. Thes
 | [Claude changelog generator](/guides/example-projects/claude-changelog-generator)                               | Automatically generate professional changelogs from git commits using Claude.                                                          | —         | [View the repo](https://github.com/triggerdotdev/examples/tree/main/changelog-generator)                       |
 | [Claude GitHub wiki agent](/guides/example-projects/claude-github-wiki)                                         | Generate and maintain GitHub wiki documentation with Claude-powered analysis.                                                          | —         | [View the repo](https://github.com/triggerdotdev/examples/tree/main/claude-agent-github-wiki)                  |
 | [Claude thinking chatbot](/guides/example-projects/claude-thinking-chatbot)                                     | Use Vercel's AI SDK and Anthropic's Claude 3.7 model to create a thinking chatbot.                                                     | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/claude-thinking-chatbot)                   |
+| [Cursor background agent](/guides/example-projects/cursor-background-agent)                                     | Run Cursor's headless CLI agent as a background task, streaming live output to the browser.                                            | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/cursor-cli-demo)                           |
 | [Human-in-the-loop workflow](/guides/example-projects/human-in-the-loop-workflow)                               | Create audio summaries of newspaper articles using a human-in-the-loop workflow built with ReactFlow and Trigger.dev waitpoint tokens. | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/article-summary-workflow)                  |
 | [Mastra agents with memory](/guides/example-projects/mastra-agents-with-memory)                                 | Use Mastra to create a weather agent that can collect live weather data and generate clothing recommendations.                         | —         | [View the repo](https://github.com/triggerdotdev/examples/tree/main/mastra-agents)                             |
 | [OpenAI Agents SDK for Python guardrails](/guides/example-projects/openai-agent-sdk-guardrails)                 | Use the OpenAI Agents SDK for Python to create a guardrails system for your AI agents.                                                 | —         | [View the repo](https://github.com/triggerdotdev/examples/tree/main/openai-agent-sdk-guardrails-examples)      |
@@ -63,6 +65,7 @@ Example projects are full projects with example repos you can fork and use. Thes
 | [Python web crawler](/guides/python/python-crawl4ai)                                                            | Use Python, Crawl4AI and Playwright to create a headless web crawler with Trigger.dev.                                                 | —         | [View the repo](https://github.com/triggerdotdev/examples/tree/main/python-crawl4ai)                           |
 | [Realtime CSV Importer](/guides/example-projects/realtime-csv-importer)                                         | Upload a CSV file and see the progress of the task streamed to the frontend.                                                           | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/realtime-csv-importer)                     |
 | [Realtime Fal.ai image generation](/guides/example-projects/realtime-fal-ai)                                    | Generate an image from a prompt using Fal.ai and show the progress of the task on the frontend using Realtime.                         | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/realtime-fal-ai-image-generation)          |
+| [Smart Spreadsheet](/guides/example-projects/smart-spreadsheet)                                                 | Enrich company data using Exa search and Claude with real-time streaming results.                                                      | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/smart-spreadsheet)                         |
 | [Turborepo monorepo with Prisma](/guides/example-projects/turborepo-monorepo-prisma)                            | Use Prisma in a Turborepo monorepo with Trigger.dev.                                                                                   | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/monorepos/turborepo-prisma-tasks-package)  |
 | [Vercel AI SDK image generator](/guides/example-projects/vercel-ai-sdk-image-generator)                         | Use the Vercel AI SDK to generate images from a prompt.                                                                                | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/vercel-ai-sdk-image-generator)             |
 | [Vercel AI SDK deep research agent](/guides/example-projects/vercel-ai-sdk-deep-research)                       | Use the Vercel AI SDK to generate comprehensive PDF reports using a deep research agent.                                               | Next.js   | [View the repo](https://github.com/triggerdotdev/examples/tree/main/vercel-ai-sdk-deep-research-agent)         |
diff --git a/docs/how-it-works.mdx b/docs/how-it-works.mdx
index 3e2857f1572..88bb4c07036 100644
--- a/docs/how-it-works.mdx
+++ b/docs/how-it-works.mdx
@@ -430,7 +430,9 @@ When you run `npx trigger.dev@latest dev`, we run your task code locally on your
 
 ## Staging and production environments
 
-Trigger.dev supports deploying to multiple "deployed" environments, such as staging and production. This allows you to test your tasks in a staging environment before deploying them to production. You can deploy to a new environment by running `npx trigger.dev@latest deploy --env <env>`, where `<env>` is the name of the environment you want to deploy to. Each environment has its own API Key, which you can use to trigger tasks in that environment.
+Trigger.dev supports deploying to `prod` and `staging` environments. This allows you to test your tasks in a staging environment before deploying them to production. You can deploy to a different environment by running `npx trigger.dev@latest deploy --env <env>`, where `<env>` is either `prod` or `staging`. Each environment has its own API Key, which you can use to trigger tasks in that environment.
+
+For additional isolated environments, you can use [preview branches](/deployment/preview-branches), which allow you to create separate environments for each branch of your code.
 
 ## OpenTelemetry
 
diff --git a/docs/how-to-reduce-your-spend.mdx b/docs/how-to-reduce-your-spend.mdx
index 0fc8949fe90..c070745d433 100644
--- a/docs/how-to-reduce-your-spend.mdx
+++ b/docs/how-to-reduce-your-spend.mdx
@@ -23,6 +23,11 @@ Configure billing alerts in your dashboard to get notified when you approach spe
 - Catch unexpected cost increases early
 - Identify runaway tasks before they become expensive
 
+The billing alerts page includes two types of alerts:
+
+- **Standard alerts**: Get notified at 75%, 90%, 100%, 200%, and 500% of your monthly budget
+- **Spike alerts**: Catch runaway usage from bugs or errors with alerts at 10x (1000%), 20x (2000%), 50x (5000%), and 100x (10000%) of your monthly budget. We recommend keeping these enabled as a safety net.
+
 ![Billing alerts](./images/billing-alerts-ui.png)
 
 You can view your billing alerts page by clicking the "Organization" menu in the top left of the dashboard and then clicking "Settings".
@@ -168,3 +173,45 @@ export const boundedTask = task({
   },
 });
 ```
+
+## Use waitpoints instead of polling
+
+Waits longer than 5 seconds automatically checkpoint your task, meaning you don't pay for compute while waiting. Use `wait.for()`, `wait.until()`, or `triggerAndWait()` instead of polling loops.
+
+```ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const waitpointTask = task({
+  id: "waitpoint-task",
+  run: async (payload) => {
+    // This wait is free - your task is checkpointed
+    await wait.for({ minutes: 5 });
+
+    // Parent is also checkpointed while waiting for child tasks
+    const result = await childTask.triggerAndWait({ data: payload });
+    return result;
+  },
+});
+```
+
+[Read more about waitpoints](/wait-for).
+
+## Use debounce to consolidate multiple triggers
+
+When a task might be triggered multiple times in quick succession, use debounce to consolidate them into a single run. This is useful for document indexing, webhook aggregation, cache invalidation, and real-time sync scenarios.
+
+```ts
+// Multiple rapid triggers consolidate into 1 run
+await updateIndex.trigger(
+  { docId: "doc-123" },
+  { debounce: { key: "doc-123", delay: "5s" } }
+);
+
+// Use trailing mode to process the most recent payload
+await processUpdate.trigger(
+  { version: 2 },
+  { debounce: { key: "update-123", delay: "10s", mode: "trailing" } }
+);
+```
+
+[Read more about debounce](/triggering#debounce).
diff --git a/docs/idempotency.mdx b/docs/idempotency.mdx
index 4e8fa587435..034246eafbf 100644
--- a/docs/idempotency.mdx
+++ b/docs/idempotency.mdx
@@ -1,14 +1,44 @@
 ---
 title: "Idempotency"
-description: "An API call or operation is “idempotent” if it has the same result when called more than once."
+description: "An API call or operation is idempotent if it has the same result when called more than once."
 ---
 
-We currently support idempotency at the task level, meaning that if you trigger a task with the same `idempotencyKey` twice, the second request will not create a new task run.
+We currently support idempotency at the task level, meaning that if you trigger a task with the same `idempotencyKey` twice, the second request will not create a new task run. Instead, the original run's handle is returned, allowing you to track the existing run's progress.
 
+## Why use idempotency keys?
+
+The most common use case is **preventing duplicate child tasks when a parent task retries**. Without idempotency keys, each retry of the parent would trigger a new child task run:
+
+```mermaid
+sequenceDiagram
+    participant Parent as Parent Task
+    participant SDK as Trigger.dev
+    participant Child as Child Task
+
+    Note over Parent: Attempt 1
+    Parent->>SDK: trigger(childTask, {idempotencyKey})
+    SDK->>Child: Creates child run
+    Child-->>SDK: Running...
+    Parent->>Parent: Fails, will retry
+
+    Note over Parent: Attempt 2 (retry)
+    Parent->>SDK: trigger(childTask, {idempotencyKey})
+    Note over SDK: Same key, returns existing run
+    SDK-->>Parent: Returns original child run
+    
+    Note over Child: Child task only runs once
+```
+
+Other common use cases include:
+
+- **Preventing duplicate emails** - Ensure a confirmation email is only sent once, even if the parent task retries
+- **Avoiding double-charging customers** - Prevent duplicate payment processing during retries
+- **One-time setup tasks** - Ensure initialization or migration tasks only run once
+- **Deduplicating webhook processing** - Handle the same webhook event only once, even if it's delivered multiple times
 
 ## `idempotencyKey` option
 
-You can provide an `idempotencyKey` to ensure that a task is only triggered once with the same key. This is useful if you are triggering a task within another task that might be retried:
+You can provide an `idempotencyKey` when triggering a task:
 
 ```ts
 import { idempotencyKeys, task } from "@trigger.dev/sdk";
@@ -72,6 +102,10 @@ import { myTask } from "./trigger/myTasks";
 await myTask.trigger({ some: "data" }, { idempotencyKey: myUser.id });
 ```
 
+<Note>
+When you pass a raw string, it defaults to `"run"` scope (scoped to the parent run). See [Default behavior](#default-behavior) for details on how scopes work and how to use global scope instead.
+</Note>
+
 <Note>Make sure you provide sufficiently unique keys to avoid collisions.</Note>
 
 You can pass the `idempotencyKey` when calling `batchTrigger` as well:
@@ -87,6 +121,149 @@ await tasks.batchTrigger("my-task", [
 ]);
 ```
 
+## Understanding scopes
+
+The `scope` option determines how your idempotency key is processed. When you provide a key, it gets hashed together with additional context based on the scope. This means the same key string can produce different idempotency behaviors depending on the scope you choose.
+
+### Available scopes
+
+| Scope | What gets hashed | Description | Use case |
+| --- | --- | --- | --- |
+| `"run"` | `key + parentRunId` | Key is combined with the parent run ID | Prevent duplicates within a single parent run (default) |
+| `"attempt"` | `key + parentRunId + attemptNumber` | Key is combined with the parent run ID and attempt number | Allow child tasks to re-run on each retry of the parent |
+| `"global"` | `key` | Key is used as-is, no context added | Ensure a task only runs once ever, regardless of parent |
+
+### `run` scope (default)
+
+The `run` scope makes the idempotency key unique to the current parent task run. This is the default behavior for both raw strings and `idempotencyKeys.create()`.
+
+```ts
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
+
+export const processOrder = task({
+  id: "process-order",
+  retry: { maxAttempts: 3 },
+  run: async (payload: { orderId: string; email: string }) => {
+    // This key is scoped to this specific run of processOrder
+    // If processOrder retries, the same key still refers to the same child run
+    const idempotencyKey = await idempotencyKeys.create(`send-confirmation-${payload.orderId}`);
+
+    // sendEmail will only be triggered once, even if processOrder retries multiple times
+    await sendEmail.trigger(
+      { to: payload.email, subject: "Order confirmed" },
+      { idempotencyKey }
+    );
+
+    // ... more processing that might fail and cause a retry
+  },
+});
+```
+
+With `run` scope, if you trigger `processOrder` twice with different run IDs, both will send emails because the idempotency keys are different (they include different parent run IDs).
+
+### `attempt` scope
+
+The `attempt` scope makes the idempotency key unique to each attempt of the parent task. Use this when you want child tasks to re-execute on each retry.
+
+```ts
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
+
+export const syncData = task({
+  id: "sync-data",
+  retry: { maxAttempts: 3 },
+  run: async (payload: { userId: string }) => {
+    // This key changes on each retry attempt
+    const idempotencyKey = await idempotencyKeys.create(`fetch-${payload.userId}`, {
+      scope: "attempt",
+    });
+
+    // fetchLatestData will run again on each retry, getting fresh data
+    const result = await fetchLatestData.triggerAndWait(
+      { userId: payload.userId },
+      { idempotencyKey }
+    );
+
+    // Process the fresh data...
+  },
+});
+```
+
+### `global` scope
+
+The `global` scope makes the idempotency key truly global across all runs. Use this when you want to ensure a task only runs once ever (until the TTL expires), regardless of which parent task triggered it.
+
+```ts
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
+
+export const onboardUser = task({
+  id: "onboard-user",
+  run: async (payload: { userId: string; email: string }) => {
+    // This key is global - the welcome email will only be sent once per user,
+    // even if onboardUser is triggered multiple times from different places
+    const idempotencyKey = await idempotencyKeys.create(`welcome-email-${payload.userId}`, {
+      scope: "global",
+    });
+
+    await sendWelcomeEmail.trigger(
+      { to: payload.email },
+      { idempotencyKey, idempotencyKeyTTL: "7d" }
+    );
+  },
+});
+```
+
+<Note>
+Even with `global` scope, idempotency keys are still isolated to the specific task and environment. Using the same key to trigger *different* tasks will not deduplicate - both tasks will run. See [Environment and task scoping](#environment-and-task-scoping) for more details.
+</Note>
+
+## Default behavior
+
+Understanding the default behavior is important to avoid unexpected results:
+
+### Passing a raw string
+
+When you pass a raw string directly to the `idempotencyKey` option, it is automatically processed with `run` scope:
+
+```ts
+// These two are equivalent when called inside a task:
+await childTask.trigger(payload, { idempotencyKey: "my-key" });
+await childTask.trigger(payload, { idempotencyKey: await idempotencyKeys.create("my-key") });
+```
+
+<Warning>
+**Breaking change in v4.3.1:** In v4.3.0 and earlier, raw strings defaulted to `global` scope. Starting in v4.3.1, raw strings now default to `run` scope. If you're upgrading and relied on the previous global behavior, you must now explicitly use `idempotencyKeys.create("key", { scope: "global" })`.
+</Warning>
+
+This means raw strings are scoped to the parent run by default. If you want global behavior, you must explicitly create the key with `scope: "global"`:
+
+```ts
+// For global idempotency, you must use idempotencyKeys.create with scope: "global"
+const idempotencyKey = await idempotencyKeys.create("my-key", { scope: "global" });
+await childTask.trigger(payload, { idempotencyKey });
+```
+
+### Triggering from backend code
+
+When triggering tasks from your backend code (outside of a task), there is no parent run context. In this case, `run` and `attempt` scopes behave the same as `global` since there's no run ID or attempt number to inject:
+
+```ts
+// In your backend code (e.g., an API route)
+import { idempotencyKeys, tasks } from "@trigger.dev/sdk";
+
+// All three of these behave the same when called outside a task:
+await tasks.trigger("my-task", payload, { idempotencyKey: "my-key" });
+await tasks.trigger("my-task", payload, {
+  idempotencyKey: await idempotencyKeys.create("my-key", { scope: "run" }),
+});
+await tasks.trigger("my-task", payload, {
+  idempotencyKey: await idempotencyKeys.create("my-key", { scope: "global" }),
+});
+```
+
+<Note>
+When triggering from backend code, the scope doesn't matter since there's no task context. All scopes effectively behave as global.
+</Note>
+
 ## `idempotencyKeyTTL` option
 
 The `idempotencyKeyTTL` option defines a time window during which a task with the same idempotency key will only run once. Here's how it works:
@@ -131,6 +308,32 @@ You can use the following units for the `idempotencyKeyTTL` option:
 - `h` for hours (e.g. `2h`)
 - `d` for days (e.g. `3d`)
 
+## Failed runs and idempotency
+
+When a run with an idempotency key **fails**, the key is automatically cleared. This means triggering the same task with the same idempotency key will create a new run. However, **successful** and **canceled** runs keep their idempotency key. If you need to re-trigger after a successful or canceled run, you can:
+
+1. **Reset the idempotency key** using `idempotencyKeys.reset()`:
+
+```ts
+import { idempotencyKeys } from "@trigger.dev/sdk";
+
+// Clear the idempotency key to allow re-triggering
+await idempotencyKeys.reset("my-task", "my-idempotency-key");
+
+// Now you can trigger the task again
+await myTask.trigger(payload, { idempotencyKey: "my-idempotency-key" });
+```
+
+2. **Use a shorter TTL** so the key expires automatically:
+
+```ts
+// Key expires after 5 minutes
+await myTask.trigger(payload, { 
+  idempotencyKey: "my-key", 
+  idempotencyKeyTTL: "5m" 
+});
+```
+
 ## Payload-based idempotency
 
 We don't currently support payload-based idempotency, but you can implement it yourself by hashing the payload and using the hash as the idempotency key.
@@ -159,18 +362,118 @@ You can reset an idempotency key to clear it from all associated runs. This is u
 
 When you reset an idempotency key, it will be cleared for all runs that match both the task identifier and the idempotency key in the current environment. This allows you to trigger the task again with the same key.
 
+### API signature
+
+```ts
+idempotencyKeys.reset(
+  taskIdentifier: string,
+  idempotencyKey: string,
+  requestOptions?: ZodFetchOptions
+): Promise<{ id: string }>
+```
+
+| Parameter | Description |
+| --- | --- |
+| `taskIdentifier` | The identifier of the task (e.g., `"my-task"`) |
+| `idempotencyKey` | The idempotency key hash to reset (the 64-character hash string) |
+| `requestOptions` | Optional fetch options for the API request |
+
+### Resetting keys created with `idempotencyKeys.create()`
+
+When you pass an `IdempotencyKey` created with `idempotencyKeys.create()`, the scope and original key are automatically extracted, making it easy to reset:
+
+```ts
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
+
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    const key = await idempotencyKeys.create("my-key", { scope: "global" });
+    await childTask.trigger(payload, { idempotencyKey: key });
+
+    // Later in the same task, reset it - options extracted automatically
+    await idempotencyKeys.reset("child-task", key);
+  },
+});
+```
+
+### Resetting global keys
+
+Global keys are the simplest to reset since they don't require any run context:
+
 ```ts
 import { idempotencyKeys } from "@trigger.dev/sdk";
 
-// Reset an idempotency key for a specific task
-await idempotencyKeys.reset("my-task", "my-idempotency-key");
+// From anywhere - inside a task or from your backend code
+await idempotencyKeys.reset("my-task", "my-key", { scope: "global" });
+```
+
+### Resetting run-scoped keys
+
+Keys created with `"run"` scope (the default) include the parent run ID in the hash. When resetting from inside the same task, the run ID is automatically available:
+
+```ts
+import { idempotencyKeys, task } from "@trigger.dev/sdk";
+
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Create a run-scoped key (default)
+    const key = await idempotencyKeys.create("my-key");
+    await childTask.trigger(payload, { idempotencyKey: key });
+
+    // Reset works automatically inside the task - run ID is available from context
+    await idempotencyKeys.reset("child-task", key);
+  },
+});
 ```
 
-The `reset` function requires both parameters:
-- `taskIdentifier`: The identifier of the task (e.g., `"my-task"`)
-- `idempotencyKey`: The idempotency key to reset
+When resetting from outside a task, you must provide the `parentRunId` if the key was created within a task context:
+
+```ts
+import { idempotencyKeys } from "@trigger.dev/sdk";
 
-After resetting, any subsequent triggers with the same idempotency key will create new task runs instead of returning the existing ones.
+// If the key was created within a task, you need the parent run ID
+await idempotencyKeys.reset("my-task", "my-key", {
+  scope: "run",
+  parentRunId: "run_abc123"
+});
+```
+
+<Note>
+If you triggered the task from backend code, all scopes behave as global (see [Triggering from backend code](#triggering-from-backend-code)). Use `scope: "global"` when resetting.
+</Note>
+
+### Resetting attempt-scoped keys
+
+Keys created with `"attempt"` scope include both the parent run ID and attempt number. When resetting from outside a task, you must provide both:
+
+```ts
+import { idempotencyKeys } from "@trigger.dev/sdk";
+
+// From your backend code
+await idempotencyKeys.reset("my-task", "my-key", {
+  scope: "attempt",
+  parentRunId: "run_abc123",
+  attemptNumber: 1
+});
+```
+
+<Warning>
+If you try to reset a `"run"` or `"attempt"` scoped key from outside a task without providing the required `parentRunId` (and `attemptNumber` for attempt scope), it will throw an error.
+</Warning>
+
+### Resetting from the dashboard
+
+You can also reset idempotency keys directly from the Trigger.dev dashboard:
+
+1. Navigate to the run that has the idempotency key you want to reset
+2. In the run details panel, find the "Idempotency key" section
+3. Click the "Reset" button
+
+This is useful when you need to manually allow a task to be re-triggered without writing code.
+
+![Idempotency section in the run details pane showing the key, scope, and expiration time](/images/idempotency-key-dashboard.png)
 
 <Note>
 Resetting an idempotency key only affects runs in the current environment. The reset is scoped to the specific task identifier and idempotency key combination.
@@ -178,6 +481,20 @@ Resetting an idempotency key only affects runs in the current environment. The r
 
 ## Important notes
 
+### Environment and task scoping
+
 Idempotency keys, even the ones scoped globally, are actually scoped to the task and the environment. This means that you cannot collide with keys from other environments (e.g. dev will never collide with prod), or to other projects and orgs.
 
 If you use the same idempotency key for triggering different tasks, the tasks will not be idempotent, and both tasks will be triggered. There's currently no way to make multiple tasks idempotent with the same key.
+
+### How scopes affect the key
+
+The scope determines what gets hashed alongside your key:
+
+- Same key + `"run"` scope in different parent runs = different hashes = both tasks run
+- Same key + `"global"` scope in different parent runs = same hash = only first task runs
+- Same key + different scopes = different hashes = both tasks run
+
+This is why understanding scopes is crucial: the same string key can produce different idempotency behavior depending on the scope and context.
+
+
diff --git a/docs/images/idempotency-key-dashboard.png b/docs/images/idempotency-key-dashboard.png
new file mode 100644
index 00000000000..575f9682e86
Binary files /dev/null and b/docs/images/idempotency-key-dashboard.png differ
diff --git a/docs/images/intro-ai.jpg b/docs/images/intro-ai.jpg
new file mode 100644
index 00000000000..9905922a22b
Binary files /dev/null and b/docs/images/intro-ai.jpg differ
diff --git a/docs/images/metrics-built-in.png b/docs/images/metrics-built-in.png
new file mode 100644
index 00000000000..7104a16c4a3
Binary files /dev/null and b/docs/images/metrics-built-in.png differ
diff --git a/docs/images/query-chart-usage-percentiles.png b/docs/images/query-chart-usage-percentiles.png
new file mode 100644
index 00000000000..43142ea28ad
Binary files /dev/null and b/docs/images/query-chart-usage-percentiles.png differ
diff --git a/docs/introduction.mdx b/docs/introduction.mdx
index fa57a458608..383040de145 100644
--- a/docs/introduction.mdx
+++ b/docs/introduction.mdx
@@ -16,8 +16,8 @@ mode: "center"
   >
     Browse our wide range of guides, frameworks and example projects
   </Card>
-  <Card title="MCP Server" img="/images/intro-mcp.jpg" href="/mcp-introduction">
-    Learn how to install and configure the Trigger.dev MCP Server
+  <Card title="Building with AI" img="/images/intro-ai.jpg" href="/building-with-ai">
+    Learn how to build Trigger.dev projects using AI coding assistants
   </Card>
   <Card title="Video walkthrough" img="/images/intro-video.jpg" href="/video-walkthrough">
     Watch an end-to-end demo of Trigger.dev in 10 minutes
diff --git a/docs/limits.mdx b/docs/limits.mdx
index db2a18ae6dd..575e2a553f8 100644
--- a/docs/limits.mdx
+++ b/docs/limits.mdx
@@ -5,6 +5,8 @@ description: "There are some hard and soft limits that you might hit."
 
 import RateLimitHitUseBatchTrigger from "/snippets/rate-limit-hit-use-batchtrigger.mdx";
 
+You can view your current limits, quotas, and rate limit usage in real-time by visiting the **Limits** page in the dashboard (accessible from the left sidebar). This page shows current rate limit token availability, quota usage, and plan features for your organization.
+
 ## Concurrency limits
 
 | Pricing tier | Limit                |
@@ -13,7 +15,7 @@ import RateLimitHitUseBatchTrigger from "/snippets/rate-limit-hit-use-batchtrigg
 | Hobby        | 25 concurrent runs   |
 | Pro          | 100+ concurrent runs |
 
-Additional bundles above the Pro tier are available for $50/month per 50 concurrent runs. Contact us via [email](https://trigger.dev/contact) or [Discord](https://trigger.dev/discord) to request more.
+Extra concurrency above the Pro tier limit is available via the dashboard. Click the "Concurrency" page from the left sidebar when on the Pro plan to purchase more.
 
 ## Rate limits
 
@@ -29,13 +31,21 @@ You can request a higher rate limit from us if you're on a paid plan.
 
 ## Queued tasks
 
-The number of queued tasks by environment.
+The maximum number of runs that can be queued **per queue** (not across all queues in the environment). Each queue can hold up to its limit independently. When a queue hits its limit, new triggers to that queue are rejected.
+
+<Note>
+  The limits below apply to [Trigger.dev Cloud](https://trigger.dev). If you self-host Trigger.dev, queue size limits are configurable via the `MAXIMUM_DEV_QUEUE_SIZE` and `MAXIMUM_DEPLOYED_QUEUE_SIZE` environment variables — see [Self-hosting environment variables](/self-hosting/env/webapp#run-engine).
+</Note>
+
+| Pricing tier | Development (per queue) | Staging / Production (per queue) |
+| :----------- | :---------------------- | :-------------------------------- |
+| Free         | 500                     | 10,000                            |
+| Hobby        | 500                     | 250,000                           |
+| Pro          | 5,000                   | 1,000,000                         |
+
+## Maximum run TTL
 
-| Limit   | Details            |
-| :------ | :----------------- |
-| Dev     | At most 500        |
-| Staging | At most 10 million |
-| Prod    | At most 10 million |
+On Trigger.dev Cloud, all runs have an enforced maximum TTL of 14 days. Runs without an explicit TTL automatically receive the 14-day TTL; runs with a TTL longer than 14 days are clamped to 14 days. This prevents queued runs from accumulating indefinitely. If you self-host, you can configure a maximum TTL via the `RUN_ENGINE_DEFAULT_MAX_TTL` environment variable — see [Self-hosting environment variables](/self-hosting/env/webapp#run-engine).
 
 ## Schedules
 
@@ -53,6 +63,14 @@ If you add them [dynamically using code](/management/schedules/create) make sure
 
 If you're creating schedules for your user you will definitely need to request more schedules from us.
 
+## Projects
+
+| Pricing tier | Limit               |
+| :----------- | :------------------ |
+| All tiers    | 10 per organization |
+
+Each project receives its own concurrency allocation. If you need to support multiple tenants with the same codebase but different environment variables, see the [Multi-tenant applications](/deploy-environment-variables#multi-tenant-applications) section for a recommended workaround.
+
 ## Preview branches
 
 | Pricing tier | Limit                |
@@ -75,20 +93,48 @@ Additional bundles are available for $10/month per 100 concurrent connections. C
 
 ## Task payloads and outputs
 
-| Limit                  | Details                                       |
-| :--------------------- | :-------------------------------------------- |
-| Single trigger payload | Must not exceed 3MB                           |
-| Batch trigger payload  | The total of all payloads must not exceed 5MB |
-| Task outputs           | Must not exceed 10MB                          |
+| Limit                  | Details                                                            |
+| :--------------------- | :----------------------------------------------------------------- |
+| Single trigger payload | Must not exceed 3MB                                                |
+| Batch trigger payload  | Each item can be up to 3MB (SDK 4.3.1+). Prior: 1MB total combined |
+| Task outputs           | Must not exceed 10MB                                               |
 
 Payloads and outputs that exceed 512KB will be offloaded to object storage and a presigned URL will be provided to download the data when calling `runs.retrieve`. You don't need to do anything to handle this in your tasks however, as we will transparently upload/download these during operation.
 
 ## Batch size
 
-A single batch can have a maximum of 500 items.
+A single batch can have a maximum of 1,000 items with SDK 4.3.1+. Prior versions are limited to 500 items.
 
 <SoftLimit />
 
+## Batch trigger rate limits
+
+Batch triggering uses a token bucket algorithm to rate limit the number of runs you can trigger per environment. Each run in a batch consumes one token.
+
+| Pricing tier | Bucket size | Refill rate           |
+| :----------- | :---------- | :-------------------- |
+| Free         | 1,200 runs  | 100 runs every 10 sec |
+| Hobby        | 5,000 runs  | 500 runs every 5 sec  |
+| Pro          | 5,000 runs  | 500 runs every 5 sec  |
+
+**How it works**: You can burst up to your bucket size, then tokens refill at the specified rate. For example, a Free user can trigger 1,200 runs immediately, then must wait for tokens to refill (100 runs become available every 10 seconds).
+
+<Note>
+  When you hit batch rate limits, the SDK throws a `BatchTriggerError` with `isRateLimited: true`.
+  See [Handling batch trigger errors](/triggering#handling-batch-trigger-errors) for how to detect
+  and react to rate limits in your code.
+</Note>
+
+## Batch trigger processing concurrency
+
+When you send a batch trigger, we convert it into individual runs. This limit controls the maximum number of batches being converted into runs simultaneously per environment. It is not a limit on how many batch runs can be executing at once.
+
+| Pricing tier | Limit                 |
+| :----------- | :-------------------- |
+| Free         | 5 concurrent batches  |
+| Hobby        | 10 concurrent batches |
+| Pro          | 50 concurrent batches |
+
 ## Log retention
 
 | Pricing tier | Limit   |
@@ -148,6 +194,36 @@ An alert destination is a single email address, Slack channel, or webhook URL th
 
 If you're on the Pro plan and need more than the plan limit, you can request more by contacting us via [email](https://trigger.dev/contact) or [Discord](https://trigger.dev/discord).
 
+## Query
+
+Query execution is subject to the following limits:
+
+| Limit              | Details               |
+| :----------------- | :-------------------- |
+| Max execution time | 10 seconds per query  |
+| Max result rows    | 10,000 rows per query |
+| Concurrent queries | 3 per project         |
+
+### Query lookback period
+
+The maximum time range a query can look back is based on your plan:
+
+| Pricing tier | Limit   |
+| :----------- | :------ |
+| Free         | 1 day   |
+| Hobby        | 7 days  |
+| Pro          | 30 days |
+
+If your query's time range exceeds your plan's lookback limit, it will be automatically clipped to the maximum allowed period.
+
+## Metric widget concurrency
+
+The number of metric widgets that can be queried concurrently per project.
+
+| Limit                     | Details        |
+| :------------------------ | :------------- |
+| Concurrent widget queries | 30 per project |
+
 ## Machines
 
 The default machine is `small-1x` which has 0.5 vCPU and 0.5 GB of RAM. You can optionally configure a higher spec machine which will increase the cost of running the task but can also improve the performance of the task if it is CPU or memory bound.
diff --git a/docs/logging.mdx b/docs/logging.mdx
index dfc8b0750e2..dfa7d7086e5 100644
--- a/docs/logging.mdx
+++ b/docs/logging.mdx
@@ -1,6 +1,6 @@
 ---
-title: "Logging and tracing"
-description: "How to use the built-in logging and tracing system."
+title: "Logging, tracing & metrics"
+description: "How to use the built-in logging, tracing, and metrics system."
 ---
 
 ![The run log](/images/run-log.png)
@@ -77,3 +77,119 @@ export const customTrace = task({
   },
 });
 ```
+
+## Metrics
+
+Trigger.dev collects system and runtime metrics automatically for deployed tasks, and provides an API for recording custom metrics using OpenTelemetry.
+
+You can view metrics in the [Dashboards](/observability/dashboards), query them with [TRQL](/observability/query), and export them to external services via [telemetry exporters](/config/config-file#telemetry-exporters).
+
+### Custom metrics API
+
+Import `otel` from `@trigger.dev/sdk` and use the standard OpenTelemetry Metrics API to create custom instruments.
+
+Create instruments **at module level** (outside the task `run` function) so they are reused across runs:
+
+```ts /trigger/metrics.ts
+import { task, logger, otel } from "@trigger.dev/sdk";
+
+// Create a meter — instruments are created once at module level
+const meter = otel.metrics.getMeter("my-app");
+
+const itemsProcessed = meter.createCounter("items.processed", {
+  description: "Total number of items processed",
+  unit: "items",
+});
+
+const itemDuration = meter.createHistogram("item.duration", {
+  description: "Time spent processing each item",
+  unit: "ms",
+});
+
+const queueDepth = meter.createUpDownCounter("queue.depth", {
+  description: "Current queue depth",
+  unit: "items",
+});
+
+export const processQueue = task({
+  id: "process-queue",
+  run: async (payload: { items: string[] }) => {
+    queueDepth.add(payload.items.length);
+
+    for (const item of payload.items) {
+      const start = performance.now();
+
+      // ... process item ...
+
+      const elapsed = performance.now() - start;
+
+      itemsProcessed.add(1, { "item.type": "order" });
+      itemDuration.record(elapsed, { "item.type": "order" });
+      queueDepth.add(-1);
+    }
+
+    logger.info("Queue processed", { count: payload.items.length });
+  },
+});
+```
+
+#### Available instrument types
+
+| Instrument | Method | Use case |
+| :--- | :--- | :--- |
+| Counter | `meter.createCounter()` | Monotonically increasing values (items processed, requests sent) |
+| Histogram | `meter.createHistogram()` | Distributions of values (durations, sizes) |
+| UpDownCounter | `meter.createUpDownCounter()` | Values that go up and down (queue depth, active connections) |
+
+All instruments accept optional attributes when recording values. Attributes let you break down metrics by dimension (e.g., by item type, status, or region).
+
+### Automatic system and runtime metrics
+
+Trigger.dev automatically collects the following metrics for deployed tasks. No configuration is needed. Requires SDK version **4.4.1 or later**.
+
+| Metric name | Type | Unit | Description |
+| :--- | :--- | :--- | :--- |
+| `process.cpu.utilization` | gauge | ratio | Process CPU usage (0-1) |
+| `process.cpu.time` | counter | seconds | CPU time consumed |
+| `process.memory.usage` | gauge | bytes | Process memory usage |
+| `nodejs.event_loop.utilization` | gauge | ratio | Event loop utilization (0-1) |
+| `nodejs.event_loop.delay.p95` | gauge | seconds | Event loop delay p95 |
+| `nodejs.event_loop.delay.max` | gauge | seconds | Event loop delay max |
+| `nodejs.heap.used` | gauge | bytes | V8 heap used |
+| `nodejs.heap.total` | gauge | bytes | V8 heap total |
+
+<Note>
+In dev mode (`trigger dev`), only `process.*` and custom metrics are available.
+</Note>
+
+### Context attributes
+
+All metrics (both automatic and custom) are tagged with run context so you can filter and group them:
+
+- `run_id` — the run that produced the metric
+- `task_identifier` — the task slug
+- `attempt_number` — the attempt number
+- `machine_name` — the machine preset (e.g., `small-1x`)
+- `worker_version` — the deployed worker version
+- `environment_type` — `PRODUCTION`, `STAGING`, `DEVELOPMENT`, or `PREVIEW`
+
+### Querying metrics
+
+Use [TRQL](/observability/query) to query metrics data. For example, to see average CPU utilization over time:
+
+```sql
+SELECT
+  timeBucket(),
+  avg(value) AS avg_cpu
+FROM metrics
+WHERE metric_name = 'process.cpu.utilization'
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000
+```
+
+See the [Query page](/observability/query#metrics-table-columns) for the full `metrics` table schema.
+
+### Exporting metrics
+
+You can send metrics to external observability services (Axiom, Honeycomb, Datadog, etc.) by configuring [telemetry exporters](/config/config-file#telemetry-exporters) in your `trigger.config.ts`.
diff --git a/docs/management/batches/create.mdx b/docs/management/batches/create.mdx
new file mode 100644
index 00000000000..f9a11cb2e44
--- /dev/null
+++ b/docs/management/batches/create.mdx
@@ -0,0 +1,5 @@
+---
+title: "Create batch"
+openapi: "openapi POST /api/v3/batches"
+---
+
diff --git a/docs/management/batches/retrieve-results.mdx b/docs/management/batches/retrieve-results.mdx
new file mode 100644
index 00000000000..809ebfcfb30
--- /dev/null
+++ b/docs/management/batches/retrieve-results.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve batch results"
+openapi: "v3-openapi GET /api/v1/batches/{batchId}/results"
+---
diff --git a/docs/management/batches/retrieve.mdx b/docs/management/batches/retrieve.mdx
new file mode 100644
index 00000000000..f1f9630ec2b
--- /dev/null
+++ b/docs/management/batches/retrieve.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve a batch"
+openapi: "v3-openapi GET /api/v1/batches/{batchId}"
+---
diff --git a/docs/management/batches/stream-items.mdx b/docs/management/batches/stream-items.mdx
new file mode 100644
index 00000000000..66f074bc42e
--- /dev/null
+++ b/docs/management/batches/stream-items.mdx
@@ -0,0 +1,5 @@
+---
+title: "Stream batch items"
+openapi: "openapi POST /api/v3/batches/{batchId}/items"
+---
+
diff --git a/docs/management/deployments/get-latest.mdx b/docs/management/deployments/get-latest.mdx
new file mode 100644
index 00000000000..78be92be293
--- /dev/null
+++ b/docs/management/deployments/get-latest.mdx
@@ -0,0 +1,4 @@
+---
+title: "Get latest deployment"
+openapi: "v3-openapi GET /api/v1/deployments/latest"
+---
diff --git a/docs/management/deployments/promote.mdx b/docs/management/deployments/promote.mdx
new file mode 100644
index 00000000000..e1e885c0d75
--- /dev/null
+++ b/docs/management/deployments/promote.mdx
@@ -0,0 +1,4 @@
+---
+title: "Promote deployment"
+openapi: "v3-openapi POST /api/v1/deployments/{version}/promote"
+---
diff --git a/docs/management/deployments/retrieve.mdx b/docs/management/deployments/retrieve.mdx
new file mode 100644
index 00000000000..8a7eb215572
--- /dev/null
+++ b/docs/management/deployments/retrieve.mdx
@@ -0,0 +1,4 @@
+---
+title: "Get deployment"
+openapi: "v3-openapi GET /api/v1/deployments/{deploymentId}"
+---
diff --git a/docs/management/query/execute.mdx b/docs/management/query/execute.mdx
new file mode 100644
index 00000000000..1e6f0719302
--- /dev/null
+++ b/docs/management/query/execute.mdx
@@ -0,0 +1,11 @@
+---
+title: "Execute a query"
+openapi: "v3-openapi POST /api/v1/query"
+---
+
+See the [Query documentation](/observability/query#example-queries) for comprehensive examples including:
+
+- Failed runs analysis
+- Task success rates over time
+- Cost tracking and optimization
+- Performance metrics and percentiles
diff --git a/docs/management/queues/concurrency-override.mdx b/docs/management/queues/concurrency-override.mdx
new file mode 100644
index 00000000000..de62d91c950
--- /dev/null
+++ b/docs/management/queues/concurrency-override.mdx
@@ -0,0 +1,4 @@
+---
+title: "Override Concurrency Limit"
+openapi: "v3-openapi POST /api/v1/queues/{queueParam}/concurrency/override"
+---
diff --git a/docs/management/queues/concurrency-reset.mdx b/docs/management/queues/concurrency-reset.mdx
new file mode 100644
index 00000000000..7e790e21e45
--- /dev/null
+++ b/docs/management/queues/concurrency-reset.mdx
@@ -0,0 +1,4 @@
+---
+title: "Reset Concurrency Limit"
+openapi: "v3-openapi POST /api/v1/queues/{queueParam}/concurrency/reset"
+---
diff --git a/docs/management/queues/list.mdx b/docs/management/queues/list.mdx
new file mode 100644
index 00000000000..e74b9dfe1e6
--- /dev/null
+++ b/docs/management/queues/list.mdx
@@ -0,0 +1,4 @@
+---
+title: "List Queues"
+openapi: "v3-openapi GET /api/v1/queues"
+---
diff --git a/docs/management/queues/pause.mdx b/docs/management/queues/pause.mdx
new file mode 100644
index 00000000000..2f684459b17
--- /dev/null
+++ b/docs/management/queues/pause.mdx
@@ -0,0 +1,4 @@
+---
+title: "Pause or Resume Queue"
+openapi: "v3-openapi POST /api/v1/queues/{queueParam}/pause"
+---
diff --git a/docs/management/queues/retrieve.mdx b/docs/management/queues/retrieve.mdx
new file mode 100644
index 00000000000..3410e6d89d1
--- /dev/null
+++ b/docs/management/queues/retrieve.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve Queue"
+openapi: "v3-openapi GET /api/v1/queues/{queueParam}"
+---
diff --git a/docs/management/runs/add-tags.mdx b/docs/management/runs/add-tags.mdx
new file mode 100644
index 00000000000..6e8cdf02919
--- /dev/null
+++ b/docs/management/runs/add-tags.mdx
@@ -0,0 +1,4 @@
+---
+title: "Add tags to a run"
+openapi: "v3-openapi POST /api/v1/runs/{runId}/tags"
+---
diff --git a/docs/management/runs/retrieve-events.mdx b/docs/management/runs/retrieve-events.mdx
new file mode 100644
index 00000000000..7d47b3f9e40
--- /dev/null
+++ b/docs/management/runs/retrieve-events.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve run events"
+openapi: "v3-openapi GET /api/v1/runs/{runId}/events"
+---
diff --git a/docs/management/runs/retrieve-result.mdx b/docs/management/runs/retrieve-result.mdx
new file mode 100644
index 00000000000..2bc5ed09308
--- /dev/null
+++ b/docs/management/runs/retrieve-result.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve run result"
+openapi: "v3-openapi GET /api/v1/runs/{runId}/result"
+---
diff --git a/docs/management/runs/retrieve-trace.mdx b/docs/management/runs/retrieve-trace.mdx
new file mode 100644
index 00000000000..668718cf76a
--- /dev/null
+++ b/docs/management/runs/retrieve-trace.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve run trace"
+openapi: "v3-openapi GET /api/v1/runs/{runId}/trace"
+---
diff --git a/docs/management/tasks/trigger-batch.mdx b/docs/management/tasks/trigger-batch.mdx
new file mode 100644
index 00000000000..a9f5cf0f5e2
--- /dev/null
+++ b/docs/management/tasks/trigger-batch.mdx
@@ -0,0 +1,4 @@
+---
+title: "Trigger task batch"
+openapi: "v3-openapi POST /api/v1/tasks/{taskIdentifier}/batch"
+---
diff --git a/docs/management/waitpoints/complete-callback.mdx b/docs/management/waitpoints/complete-callback.mdx
new file mode 100644
index 00000000000..1ae64a2262c
--- /dev/null
+++ b/docs/management/waitpoints/complete-callback.mdx
@@ -0,0 +1,4 @@
+---
+title: "Complete a waitpoint token via HTTP callback"
+openapi: "v3-openapi POST /api/v1/waitpoints/tokens/{waitpointId}/callback/{callbackHash}"
+---
diff --git a/docs/management/waitpoints/complete.mdx b/docs/management/waitpoints/complete.mdx
new file mode 100644
index 00000000000..0eea6a4a69c
--- /dev/null
+++ b/docs/management/waitpoints/complete.mdx
@@ -0,0 +1,4 @@
+---
+title: "Complete a waitpoint token"
+openapi: "v3-openapi POST /api/v1/waitpoints/tokens/{waitpointId}/complete"
+---
diff --git a/docs/management/waitpoints/create.mdx b/docs/management/waitpoints/create.mdx
new file mode 100644
index 00000000000..d41e452277b
--- /dev/null
+++ b/docs/management/waitpoints/create.mdx
@@ -0,0 +1,4 @@
+---
+title: "Create a waitpoint token"
+openapi: "v3-openapi POST /api/v1/waitpoints/tokens"
+---
diff --git a/docs/management/waitpoints/list.mdx b/docs/management/waitpoints/list.mdx
new file mode 100644
index 00000000000..e7d45c7bb18
--- /dev/null
+++ b/docs/management/waitpoints/list.mdx
@@ -0,0 +1,4 @@
+---
+title: "List waitpoint tokens"
+openapi: "v3-openapi GET /api/v1/waitpoints/tokens"
+---
diff --git a/docs/management/waitpoints/retrieve.mdx b/docs/management/waitpoints/retrieve.mdx
new file mode 100644
index 00000000000..125cbd8614a
--- /dev/null
+++ b/docs/management/waitpoints/retrieve.mdx
@@ -0,0 +1,4 @@
+---
+title: "Retrieve a waitpoint token"
+openapi: "v3-openapi GET /api/v1/waitpoints/tokens/{waitpointId}"
+---
diff --git a/docs/mcp-agent-rules.mdx b/docs/mcp-agent-rules.mdx
index 664d8bcf299..d9ba021b891 100644
--- a/docs/mcp-agent-rules.mdx
+++ b/docs/mcp-agent-rules.mdx
@@ -1,14 +1,17 @@
 ---
 title: "Agent rules"
 sidebarTitle: "Agent rules"
-description: "Learn how to use the Trigger.dev agent rules with the MCP server"
-tag: "new"
+description: "Install Trigger.dev agent rules to guide AI assistants toward correct, up-to-date code patterns."
 ---
 
 ## What are Trigger.dev agent rules?
 
 Trigger.dev agent rules are comprehensive instruction sets that guide AI assistants to write optimal Trigger.dev code. These rules ensure your AI assistant understands best practices, current APIs, and recommended patterns when working with Trigger.dev projects.
 
+<Note>
+  Agent Rules are one of three AI tools we provide. You can also install [Skills](/skills) for portable cross-editor instruction sets or the [MCP Server](/mcp-introduction) for live project interaction. See the [comparison table](/building-with-ai#skills-vs-agent-rules-vs-mcp) for details.
+</Note>
+
 ## Installation
 
 Install the agent rules with the following command:
@@ -113,6 +116,17 @@ npx trigger.dev@latest install-rules
 
 ## Next steps
 
-- [Install the MCP server](/mcp-introduction) for complete Trigger.dev integration
-- [Explore MCP tools](/mcp-tools) for project management and task execution
-
+<CardGroup cols={2}>
+  <Card title="Skills" icon="wand-magic-sparkles" href="/skills">
+    Portable instruction sets that work across all AI coding assistants.
+  </Card>
+  <Card title="MCP Server" icon="sparkles" href="/mcp-introduction">
+    Give your AI assistant direct access to Trigger.dev tools and APIs.
+  </Card>
+  <Card title="Complete AI setup" icon="layer-group" href="/building-with-ai">
+    See all AI tools and how they compare.
+  </Card>
+  <Card title="Writing tasks" icon="code" href="/tasks/overview">
+    Learn the task patterns that agent rules teach your AI assistant.
+  </Card>
+</CardGroup>
diff --git a/docs/mcp-introduction.mdx b/docs/mcp-introduction.mdx
index d9dc3474e17..a00f3dda896 100644
--- a/docs/mcp-introduction.mdx
+++ b/docs/mcp-introduction.mdx
@@ -2,7 +2,6 @@
 title: "MCP Introduction"
 sidebarTitle: "Introduction"
 description: "Learn how to install and configure the Trigger.dev MCP Server"
-tag: "new"
 ---
 
 ## What is the Trigger.dev MCP Server?
@@ -18,44 +17,306 @@ The Trigger.dev MCP (Model Context Protocol) Server enables AI assistants to int
 
 ## Installation
 
-### Automatic Installation (Recommended)
-
-The easiest way to install the Trigger.dev MCP Server is using the interactive installation wizard:
+The quickest way to get set up is the interactive installer:
 
 ```bash
 npx trigger.dev@latest install-mcp
 ```
 
-This command will guide you through:
+It will detect your installed clients and configure them automatically. You can also copy-paste the config for your client below.
 
-1. Selecting which MCP clients to configure
-2. Choosing installation scope (user, project, or local)
-3. Automatically configuring the selected clients
+## Client Configuration
 
-## Command Line Options
+Each client has a slightly different config format. Copy the snippet for your client into the appropriate file.
 
-The `install-mcp` command supports the following options:
+<Tabs>
+  <Tab title="Claude Code">
+    Install using the command line:
 
-### Core Options
+    ```bash
+    npx trigger.dev@latest install-mcp --client claude-code
+    ```
 
-- `-p, --project-ref <project ref>` - Scope the MCP server to a specific Trigger.dev project by providing its project ref
-- `-t, --tag <package tag>` - The version of the trigger.dev CLI package to use for the MCP server (default: latest or v4-beta)
-- `--dev-only` - Restrict the MCP server to the dev environment only
-- `--yolo` - Install the MCP server into all supported clients automatically
-- `--scope <scope>` - Choose the scope of the MCP server: `user`, `project`, or `local`
-- `--client <clients...>` - Choose specific client(s) to install into
+    Or add this configuration to `~/.claude.json` (user) or `.mcp.json` (project):
 
-### Configuration Options
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Claude Code MCP docs ↗](https://code.claude.com/docs/en/mcp)
+  </Tab>
+  <Tab title="Cursor">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client cursor
+    ```
+
+    Or add this configuration to `~/.cursor/mcp.json` (user) or `.cursor/mcp.json` (project):
+
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Cursor MCP docs ↗](https://cursor.com/docs/context/mcp)
+  </Tab>
+  <Tab title="Windsurf">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client windsurf
+    ```
+
+    Or add this configuration to `~/.codeium/windsurf/mcp_config.json`:
+
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Windsurf MCP docs ↗](https://docs.windsurf.com/windsurf/cascade/mcp)
+  </Tab>
+  <Tab title="VS Code">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client vscode
+    ```
+
+    Or add this configuration to `.vscode/mcp.json` (project) or `~/Library/Application Support/Code/User/mcp.json` (user, macOS):
+
+    ```json
+    {
+      "servers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    <Note>VS Code uses `servers` instead of `mcpServers`.</Note>
+
+    [View VS Code MCP docs ↗](https://code.visualstudio.com/docs/copilot/chat/mcp-servers)
+  </Tab>
+  <Tab title="Zed">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client zed
+    ```
+
+    Or add this configuration to `~/.config/zed/settings.json`:
+
+    ```json
+    {
+      "context_servers": {
+        "trigger": {
+          "source": "custom",
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Zed context servers docs ↗](https://zed.dev/docs/ai/mcp)
+  </Tab>
+  <Tab title="Cline">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client cline
+    ```
+
+    Or add this configuration to `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`:
+
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Cline MCP docs ↗](https://docs.cline.bot/mcp/configuring-mcp-servers)
+  </Tab>
+  <Tab title="Gemini CLI">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client gemini-cli
+    ```
+
+    Or add this configuration to `~/.gemini/settings.json` (user) or `.gemini/settings.json` (project):
+
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+  </Tab>
+  <Tab title="AMP">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client amp
+    ```
+
+    Or add this configuration to `~/.config/amp/settings.json`:
+
+    ```json
+    {
+      "amp.mcpServers": {
+        "trigger": {
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Sourcegraph AMP MCP docs ↗](https://ampcode.com/manual#mcp)
+  </Tab>
+  <Tab title="Codex CLI">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client openai-codex
+    ```
+
+    Or add this configuration to `~/.codex/config.toml`:
+
+    ```toml
+    [mcp_servers.trigger]
+    command = "npx"
+    args = ["trigger.dev@latest", "mcp"]
+    ```
+  </Tab>
+  <Tab title="Crush">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client crush
+    ```
+
+    Or add this configuration to `.crush.json` (project), `crush.json`, or `~/.config/crush/crush.json` (user). Files are loaded in priority order: `.crush.json` → `crush.json` → `$HOME/.config/crush/crush.json`.
+
+    ```json
+    {
+      "mcp": {
+        "trigger": {
+          "type": "stdio",
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+
+    [View Charm MCP docs ↗](https://github.com/charmbracelet/crush)
+  </Tab>
+  <Tab title="opencode">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client opencode
+    ```
+
+    Or add this configuration to `~/.config/opencode/opencode.json` (user) or `./opencode.json` (project):
+
+    ```json
+    {
+      "mcp": {
+        "trigger": {
+          "type": "local",
+          "command": ["npx", "trigger.dev@latest", "mcp"],
+          "enabled": true
+        }
+      }
+    }
+    ```
+
+    [View opencode MCP docs ↗](https://opencode.ai/docs/mcp-servers/)
+  </Tab>
+  <Tab title="Ruler">
+    Install using the command line:
+
+    ```bash
+    npx trigger.dev@latest install-mcp --client ruler
+    ```
+
+    Or add this configuration to `.ruler/mcp.json`:
+
+    ```json
+    {
+      "mcpServers": {
+        "trigger": {
+          "type": "stdio",
+          "command": "npx",
+          "args": ["trigger.dev@latest", "mcp"]
+        }
+      }
+    }
+    ```
+  </Tab>
+</Tabs>
 
-- `--log-file <log file>` - Configure the MCP server to write logs to a file
-- `-a, --api-url <value>` - Configure a custom Trigger.dev API URL
-- `-l, --log-level <level>` - Set CLI log level (debug, info, log, warn, error, none)
+After adding the config, restart your client. You should see a server named **trigger** connect automatically.
 
 ## Authentication
 
-You can use the MCP server without authentication with the `search_docs` tool, but for any other tool call you will need to authenticate the MCP server via the same method as the [Trigger.dev CLI](/cli-login-commands).The first time you attempt to use a tool that requires authentication, you will be prompted to authenticate the MCP server via the MCP client.
+The `search_docs` tool works without authentication. All other tools require you to be logged in via the [Trigger.dev CLI](/cli-login-commands). The first time you use an authenticated tool, your MCP client will prompt you to log in.
+
+<Accordion title="CLI Options">
 
-### Examples
+The `install-mcp` command supports these options:
+
+**Core Options**
+
+- `-p, --project-ref <project ref>` — Scope the MCP server to a specific project
+- `-t, --tag <package tag>` — CLI package version to use (default: latest)
+- `--dev-only` — Restrict to the dev environment only
+- `--yolo` — Install into all supported clients automatically
+- `--scope <scope>` — `user`, `project`, or `local`
+- `--client <clients...>` — Install into specific client(s)
+
+**Configuration Options**
+
+- `--log-file <log file>` — Write logs to a file
+- `-a, --api-url <value>` — Custom Trigger.dev API URL
+- `-l, --log-level <level>` — Log level (debug, info, log, warn, error, none)
+
+**Examples**
 
 Install for all supported clients:
 
@@ -69,105 +330,21 @@ Install for specific clients:
 npx trigger.dev@latest install-mcp --client claude-code cursor --scope user
 ```
 
-Install with development environment restriction:
+Restrict to dev environment for a specific project:
 
 ```bash
 npx trigger.dev@latest install-mcp --dev-only --project-ref proj_abc123
 ```
 
-## Supported MCP Clients
-
-The Trigger.dev MCP Server supports the following clients:
-
-| Client               | Scope Options        | Configuration File                                                                                              | Documentation                                                                                                                                    |
-| -------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **Claude Code**      | user, project, local | `~/.claude.json` or `./.mcp.json` (project/local scope)                                                         | [Claude Code MCP Docs](https://docs.anthropic.com/en/docs/claude-code/mcp)                                                                       |
-| **Cursor**           | user, project        | `~/.cursor/mcp.json` (user) or `./.cursor/mcp.json` (project)                                                   | [Cursor MCP Docs](https://docs.cursor.com/features/mcp)                                                                                          |
-| **VSCode**           | user, project        | `~/Library/Application Support/Code/User/mcp.json` (user) or `./.vscode/mcp.json` (project)                     | [VSCode MCP Docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers)                                                                   |
-| **Zed**              | user                 | `~/.config/zed/settings.json`                                                                                   | [Zed Context Servers Docs](https://zed.dev/docs/context-servers)                                                                                 |
-| **Windsurf**         | user                 | `~/.codeium/windsurf/mcp_config.json`                                                                           | [Windsurf MCP Docs](https://docs.codeium.com/windsurf/mcp)                                                                                       |
-| **Gemini CLI**       | user, project        | `~/.gemini/settings.json` (user) or `./.gemini/settings.json` (project)                                         | [Gemini CLI MCP Tutorial](https://medium.com/@joe.njenga/gemini-cli-mcp-tutorial-setup-commands-practical-use-step-by-step-example-b57f55db5f4a) |
-| **Charm Crush**      | user, project, local | `~/.config/crush/crush.json` (user), `./crush.json` (project), or `./.crush.json` (local)                       | [Charm MCP Docs](https://github.com/charmbracelet/mcp)                                                                                           |
-| **Cline**            | user                 | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` | [Cline MCP Docs](https://github.com/saoudrizwan/claude-dev#mcp)                                                                                  |
-| **OpenAI Codex CLI** | user                 | `~/.codex/config.toml`                                                                                          | See OpenAI Codex CLI documentation for MCP configuration                                                                                         |
-| **Sourcegraph AMP**  | user                 | `~/.config/amp/settings.json`                                                                                   | [Sourcegraph AMP MCP Docs](https://docs.sourcegraph.com/amp/mcp)                                                                                 |
-| **opencode**         | user, project        | `~/.config/opencode/opencode.json` (user) or `./opencode.json` (project)                                        | [opencode MCP Docs](https://opencode.ai/docs/mcp-servers/)                                                                                       |
-
-## Manual Configuration
-
-If your client isn't directly supported by the installer, you can configure it manually. The MCP server uses the following configuration:
-
-**Server Name:** `trigger`
-
-**Command:** `npx`
-
-**Arguments:** `["trigger.dev@latest", "mcp"]`
-
-### Example JSON Configuration
+To add these options to a manual config, append them to the `args` array:
 
 ```json
 {
-  "mcpServers": {
-    "trigger": {
-      "command": "npx",
-      "args": ["trigger.dev@latest", "mcp"]
-    }
-  }
+  "args": ["trigger.dev@latest", "mcp", "--dev-only", "--project-ref", "proj_abc123"]
 }
 ```
 
-### Example TOML Configuration (for Codex CLI)
-
-```toml
-[mcp_servers.trigger]
-command = "npx"
-args = ["trigger.dev@latest", "mcp"]
-```
-
-### Additional Options
-
-You can add these optional arguments to customize the server behavior:
-
-- `--log-file <path>` - Log to a specific file
-- `--api-url <url>` - Use a custom Trigger.dev API URL
-- `--dev-only` - Restrict to dev environment only
-- `--project-ref <ref>` - Scope to a specific project
-
-## Environment-Specific Configuration
-
-### Development Only
-
-To restrict the MCP server to only work with the development environment:
-
-```json
-{
-  "mcpServers": {
-    "trigger": {
-      "command": "npx",
-      "args": ["trigger.dev@latest", "mcp", "--dev-only"]
-    }
-  }
-}
-```
-
-### Project-Scoped
-
-To scope the server to a specific project:
-
-```json
-{
-  "mcpServers": {
-    "trigger": {
-      "command": "npx",
-      "args": ["trigger.dev@latest", "mcp", "--project-ref", "proj_your_project_ref"]
-    }
-  }
-}
-```
-
-## Verification
-
-After installation, restart your MCP client and look for a server named "trigger". The server should connect automatically and provide access to all Trigger.dev tools.
+</Accordion>
 
 ## Getting Started
 
@@ -184,4 +361,14 @@ Once installed, you can start using the MCP server by asking your AI assistant q
 
 ## Next Steps
 
-- [Explore available MCP tools](/mcp-tools)
+<CardGroup cols={2}>
+  <Card title="MCP Tools" icon="wrench" href="/mcp-tools">
+    Explore all available MCP tools for managing your projects.
+  </Card>
+  <Card title="Skills" icon="wand-magic-sparkles" href="/skills">
+    Portable instruction sets that teach AI assistants Trigger.dev patterns.
+  </Card>
+  <Card title="Agent Rules" icon="scroll" href="/mcp-agent-rules">
+    Install comprehensive rule sets directly into your AI client.
+  </Card>
+</CardGroup>
diff --git a/docs/mcp-tools.mdx b/docs/mcp-tools.mdx
index 0163de97a47..fdcdb56f3d6 100644
--- a/docs/mcp-tools.mdx
+++ b/docs/mcp-tools.mdx
@@ -1,527 +1,133 @@
 ---
 title: "MCP Tools"
 sidebarTitle: "Tools"
-description: "Learn about the tools available in the Trigger.dev MCP Server"
-tag: "new"
+description: "Learn about how to use the tools available in the Trigger.dev MCP Server"
 ---
 
-The Trigger.dev MCP Server provides a comprehensive set of tools that enable AI assistants to interact with your Trigger.dev projects. These tools cover everything from project management to task execution and monitoring.
-
 ## Documentation and Search Tools
 
 ### search_docs
 
-Search across the Trigger.dev documentation to find relevant information, code examples, API references, and guides.
+Search the Trigger.dev documentation for guides, examples, and API references.
 
-<ParamField query="query" type="string" required>
-  The search query to find information in the Trigger.dev documentation
-</ParamField>
+**Example usage:**
+- `"How do I create a scheduled task?"`
+- `"Show me webhook examples"`
+- `"What are the deployment options?"`
 
-**Usage Examples:**
+## Project Management Tools
 
-- "How do I create a scheduled task?"
-- "webhook examples"
-- "deployment configuration"
-- "error handling patterns"
+### list_orgs
 
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "search_docs",
-  "arguments": {
-    "query": "webhook examples"
-  }
-}
-```
-</CodeGroup>
+List all organizations you have access to.
 
-## Project Management Tools
+**Example usage:**
+- `"What organizations do I have?"`
+- `"Show me my orgs"`
 
 ### list_projects
 
 List all projects in your Trigger.dev account.
 
-**No parameters required**
-
-<ResponseField name="projects" type="array">
-  Array of project objects containing project details, IDs, and metadata
-</ResponseField>
-
-<CodeGroup>
-```json Example Response
-{
-  "projects": [
-    {
-      "id": "proj_abc123",
-      "name": "My App",
-      "slug": "my-app",
-      "organizationId": "org_xyz789"
-    }
-  ]
-}
-```
-</CodeGroup>
-
-### list_orgs
-
-List all organizations you have access to.
-
-**No parameters required**
-
-<ResponseField name="orgs" type="array">
-  Array of organization objects containing organization details and metadata
-</ResponseField>
+**Example usage:**
+- `"What projects do I have?"`
+- `"List my Trigger.dev projects"`
 
 ### create_project_in_org
 
 Create a new project in an organization.
 
-<ParamField query="orgParam" type="string" required>
-  The organization to create the project in, can either be the organization slug or the ID. Use the
-  `list_orgs` tool to get a list of organizations and ask the user to select one.
-</ParamField>
-
-<ParamField query="name" type="string" required>
-  The name of the project to create
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "create_project_in_org",
-  "arguments": {
-    "orgParam": "my-org",
-    "name": "New Project"
-  }
-}
-```
-</CodeGroup>
+**Example usage:**
+- `"Create a new project called 'my-app'"`
+- `"Set up a new Trigger.dev project"`
 
 ### initialize_project
 
 Initialize Trigger.dev in your project with automatic setup and configuration.
 
-<ParamField query="orgParam" type="string" required>
-  The organization to create the project in, can either be the organization slug or the ID. Use the
-  `list_orgs` tool to get a list of organizations and ask the user to select one.
-</ParamField>
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
+**Example usage:**
+- `"Set up Trigger.dev in this project"`
+- `"Add Trigger.dev to my app"`
 
-<ParamField query="projectName" type="string" required>
-  The name of the project to create. If projectRef is not provided, we will use this name to create
-  a new project in the organization you select.
-</ParamField>
+## Task Management Tools
 
-<ParamField query="cwd" type="string" required>
-  The current working directory of the project
-</ParamField>
+### get_current_worker
 
-## Task Management Tools
+Get the current worker for a project, including the worker version, SDK version, and registered tasks with their payload schemas.
 
-### get_tasks
-
-Get all tasks in a project.
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup). If not provided, we will try to find the config file in the
-  current working directory.
-</ParamField>
-
-<ParamField query="environment" type="string" default="dev">
-  The environment to get tasks for. Options: `dev`, `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to get tasks for, only used for preview environments
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "get_tasks",
-  "arguments": {
-    "projectRef": "proj_abc123",
-    "environment": "dev"
-  }
-}
-```
-</CodeGroup>
+**Example usage:**
+- `"What tasks are available?"`
+- `"Show me the tasks in dev"`
 
 ### trigger_task
 
-Trigger a task to run.
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
-
-<ParamField query="environment" type="string" default="dev">
-  The environment to trigger the task in. Options: `dev`, `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to trigger the task in, only used for preview environments
-</ParamField>
-
-<ParamField query="taskId" type="string" required>
-  The ID/slug of the task to trigger. Use the `get_tasks` tool to get a list of tasks and ask the
-  user to select one if it's not clear which one to use.
-</ParamField>
-
-<ParamField query="payload" type="string" required>
-  The payload to trigger the task with, must be a valid JSON string
-</ParamField>
-
-<ParamField query="options" type="object" optional>
-  Additional options for the task run
-  <Expandable title="options properties">
-    <ParamField query="queue.name" type="string" optional>
-      The name of the queue to trigger the task in, by default will use the queue configured in the
-      task
-    </ParamField>
-    <ParamField query="delay" type="string | datetime" optional>
-      The delay before the task run is executed
-    </ParamField>
-    <ParamField query="idempotencyKey" type="string" optional>
-      The idempotency key to use for the task run
-    </ParamField>
-    <ParamField query="machine" type="string" optional>
-      The machine preset to use for the task run. Options: `micro`, `small-1x`, `small-2x`,
-      `medium-1x`, `medium-2x`, `large-1x`, `large-2x`
-    </ParamField>
-    <ParamField query="maxAttempts" type="integer" optional>
-      The maximum number of attempts to retry the task run
-    </ParamField>
-    <ParamField query="maxDuration" type="number" optional>
-      The maximum duration in seconds of the task run
-    </ParamField>
-    <ParamField query="tags" type="array" optional>
-      Tags to add to the task run. Must be less than 128 characters and cannot have more than 5
-    </ParamField>
-    <ParamField query="ttl" type="string | integer" default="10m">
-      The time to live of the task run. If the run doesn't start executing within this time, it will
-      be automatically cancelled.
-    </ParamField>
-  </Expandable>
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "trigger_task",
-  "arguments": {
-    "projectRef": "proj_abc123",
-    "taskId": "email-notification",
-    "payload": "{\"email\": \"user@example.com\", \"subject\": \"Hello World\"}",
-    "options": {
-      "tags": ["urgent"],
-      "maxAttempts": 3
-    }
-  }
-}
-```
-</CodeGroup>
+Trigger a task to run with a specific payload. You can add a delay, set tags, configure retries, choose a machine size, set a TTL, or use an idempotency key.
+
+**Example usage:**
+- `"Run the email-notification task"`
+- `"Trigger my-task with userId 123"`
+- `"Execute the sync task in production"`
 
 ## Run Monitoring Tools
 
 ### get_run_details
 
-Get the details of a specific task run.
+Get detailed information about a specific task run, including logs and status. Enable debug mode to get the full trace with all logs and spans.
 
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
+**Example usage:**
+- `"Show me details for run run_abc123"`
+- `"Why did this run fail?"`
 
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
+### list_runs
+
+List runs for a project. Filter by status, task, tags, version, machine size, or time period.
 
-<ParamField query="environment" type="string" default="dev">
-  The environment to get the run details from. Options: `dev`, `staging`, `prod`, `preview`
-</ParamField>
+**Example usage:**
+- `"Show me recent runs"`
+- `"List failed runs from the last 7 days"`
+- `"What runs are currently executing?"`
 
-<ParamField query="branch" type="string" optional>
-  The branch to get the run details from, only used for preview environments
-</ParamField>
+### wait_for_run_to_complete
 
-<ParamField query="runId" type="string" required>
-  The ID of the run to get the details of, starts with `run_`
-</ParamField>
+Wait for a specific run to finish and return the result.
 
-<ParamField query="debugMode" type="boolean" optional>
-  Enable debug mode to get more detailed information about the run, including the entire trace (all logs and spans for the run and any child run). Set this to true if prompted to debug a run.
-</ParamField>
+**Example usage:**
+- `"Wait for run run_abc123 to complete"`
 
 ### cancel_run
 
-Cancel a running task.
-
-<ParamField query="runId" type="string" required>
-  The ID of the run to cancel, starts with `run_`
-</ParamField>
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
-
-<ParamField query="environment" type="string" default="dev">
-  The environment to cancel the run in. Options: `dev`, `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to cancel the run in, only used for preview environments
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "cancel_run",
-  "arguments": {
-    "runId": "run_abc123",
-    "projectRef": "proj_abc123"
-  }
-}
-```
-</CodeGroup>
+Cancel a running or queued run.
 
-### list_runs
-
-List all runs for a project with comprehensive filtering options.
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
-
-<ParamField query="environment" type="string" default="dev">
-  The environment to list runs from. Options: `dev`, `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to list runs from, only used for preview environments
-</ParamField>
-
-<ParamField query="cursor" type="string" optional>
-  The cursor to use for pagination, starts with `run_`
-</ParamField>
-
-<ParamField query="limit" type="integer" optional>
-  The number of runs to list in a single page. Up to 100
-</ParamField>
-
-<ParamField query="status" type="string" optional>
-  Filter for runs with this run status. Options: `PENDING_VERSION`, `QUEUED`, `DEQUEUED`,
-  `EXECUTING`, `WAITING`, `COMPLETED`, `CANCELED`, `FAILED`, `CRASHED`, `SYSTEM_FAILURE`, `DELAYED`,
-  `EXPIRED`, `TIMED_OUT`
-</ParamField>
-
-<ParamField query="taskIdentifier" type="string" optional>
-  Filter for runs that match this task identifier
-</ParamField>
-
-<ParamField query="version" type="string" optional>
-  Filter for runs that match this version, e.g. `20250808.3`
-</ParamField>
-
-<ParamField query="tag" type="string" optional>
-  Filter for runs that include this tag
-</ParamField>
-
-<ParamField query="from" type="string" optional>
-  Filter for runs created after this ISO 8601 timestamp
-</ParamField>
-
-<ParamField query="to" type="string" optional>
-  Filter for runs created before this ISO 8601 timestamp
-</ParamField>
-
-<ParamField query="period" type="string" optional>
-  Filter for runs created in the last N time period. Examples: `7d`, `30d`, `365d`
-</ParamField>
-
-<ParamField query="machine" type="string" optional>
-  Filter for runs that match this machine preset. Options: `micro`, `small-1x`, `small-2x`,
-  `medium-1x`, `medium-2x`, `large-1x`, `large-2x`
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "list_runs",
-  "arguments": {
-    "projectRef": "proj_abc123",
-    "status": "COMPLETED",
-    "limit": 10,
-    "period": "7d"
-  }
-}
-```
-</CodeGroup>
+**Example usage:**
+- `"Cancel run run_abc123"`
+- `"Stop that task"`
 
 ## Deployment Tools
 
 ### deploy
 
-Deploy a project to staging or production environments.
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
-
-<ParamField query="environment" type="string" default="prod">
-  The environment to deploy to. Options: `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to deploy, only used for preview environments
-</ParamField>
-
-<ParamField query="skipPromotion" type="boolean" optional>
-  Skip promoting the deployment to the current deployment for the environment
-</ParamField>
-
-<ParamField query="skipSyncEnvVars" type="boolean" optional>
-  Skip syncing environment variables when using the syncEnvVars extension
-</ParamField>
-
-<ParamField query="skipUpdateCheck" type="boolean" optional>
-  Skip checking for @trigger.dev package updates
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "deploy",
-  "arguments": {
-    "projectRef": "proj_abc123",
-    "environment": "prod",
-    "skipUpdateCheck": true
-  }
-}
-```
-</CodeGroup>
-
-### list_deployments
-
-List deployments for a project with comprehensive filtering options.
-
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup).
-</ParamField>
-
-<ParamField query="environment" type="string" default="prod">
-  The environment to list deployments for. Options: `staging`, `prod`, `preview`
-</ParamField>
-
-<ParamField query="branch" type="string" optional>
-  The branch to list deployments from, only used for preview environments
-</ParamField>
-
-<ParamField query="cursor" type="string" optional>
-  The deployment ID to start the search from, to get the next page
-</ParamField>
-
-<ParamField query="limit" type="number" optional>
-  The number of deployments to return, defaults to 20 (max 100)
-</ParamField>
-
-<ParamField query="status" type="string" optional>
-  Filter deployments that are in this status. Options: `PENDING`, `BUILDING`, `DEPLOYING`, `DEPLOYED`, `FAILED`, `CANCELED`, `TIMED_OUT`
-</ParamField>
-
-<ParamField query="from" type="string" optional>
-  The date to start the search from, in ISO 8601 format
-</ParamField>
-
-<ParamField query="to" type="string" optional>
-  The date to end the search, in ISO 8601 format
-</ParamField>
-
-<ParamField query="period" type="string" optional>
-  The period to search within. Examples: `1d`, `7d`, `3h`
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "list_deployments",
-  "arguments": {
-    "projectRef": "proj_abc123",
-    "environment": "prod",
-    "status": "DEPLOYED",
-    "limit": 10
-  }
-}
-```
-</CodeGroup>
+Deploy your project to staging or production.
+
+**Example usage:**
+- `"Deploy to production"`
+- `"Deploy to staging"`
+
+### list_deploys
+
+List deployments for a project. Filter by status or time period.
+
+**Example usage:**
+- `"Show me recent deployments"`
+- `"What's deployed to production?"`
 
 ### list_preview_branches
 
 List all preview branches in the project.
 
-<ParamField query="projectRef" type="string" optional>
-  The trigger.dev project ref, starts with `proj_`. We will attempt to automatically detect the
-  project ref if running inside a directory that includes a trigger.config.ts file.
-</ParamField>
-
-<ParamField query="configPath" type="string" optional>
-  The path to the trigger.config.ts file. Only used when the trigger.config.ts file is not at the
-  root dir (like in a monorepo setup). If not provided, we will try to find the config file in the
-  current working directory.
-</ParamField>
-
-<CodeGroup>
-```json Example Usage
-{
-  "tool": "list_preview_branches",
-  "arguments": {
-    "projectRef": "proj_abc123"
-  }
-}
-```
-</CodeGroup>
+**Example usage:**
+- `"What preview branches exist?"`
+- `"Show me preview deployments"`
 
 <Callout type="warning">
-  The deploy tool and list_preview_branches tool are not available when the MCP server is running with the `--dev-only` flag.
+  The deploy and list_preview_branches tools are not available when the MCP server is running with the `--dev-only` flag.
 </Callout>
diff --git a/docs/migrating-from-v3.mdx b/docs/migrating-from-v3.mdx
index 03f0cae5776..5530d66b62d 100644
--- a/docs/migrating-from-v3.mdx
+++ b/docs/migrating-from-v3.mdx
@@ -6,6 +6,20 @@ description: "What's new in v4, how to migrate, and breaking changes."
 import NodeVersions from "/snippets/node-versions.mdx";
 import MigrateV4UsingAi from "/snippets/migrate-v4-using-ai.mdx";
 
+<Warning>
+  **Action required: Trigger.dev v3 deprecation**
+
+We're retiring Trigger.dev v3. **New v3 deploys will stop working from 1 April 2026.** Trigger.dev v4 is stable, fully supported, and recommended for all users.
+
+**Key dates:**
+
+- **1 April 2026** — New v3 deploys will no longer work. Existing v3 runs will continue to execute.
+- **1 July 2026** — v3 will be fully shut down. All v3 runs will stop executing.
+
+**What you need to do:** Migrate to v4 before April to avoid disruption to your task executions. The migration takes about 2 minutes — follow the steps on this page below. If you have questions or need help, [contact us](https://trigger.dev/contact) or reach out in our [Discord](https://trigger.dev/discord).
+
+</Warning>
+
 ## What's new in v4?
 
 | Feature                                                              | Description                                                                                                                                                                                                |
@@ -48,6 +62,10 @@ Note that between steps 4 and 5, runs triggered with the v4 package will continu
   concurrency will return to normal.
 </Warning>
 
+<Note>
+  When migrating from v3 to v4, our infrastructure IPs may change. If you use IP allowlisting (e.g. for databases or APIs), [update your allowlists](https://trigger.dev/changelog/static-ips) with the current static IPs before or immediately after switching to v4 to avoid connectivity issues or downtime.
+</Note>
+
 ## Migrate using AI
 
 Use the prompt in the accordion below to help you migrate your v3 tasks to v4. The prompt gives good results when using Claude 4 Sonnet. You’ll need a relatively large token limit.
diff --git a/docs/migration-n8n.mdx b/docs/migration-n8n.mdx
new file mode 100644
index 00000000000..18564c31cc5
--- /dev/null
+++ b/docs/migration-n8n.mdx
@@ -0,0 +1,342 @@
+---
+title: "Migrating from n8n"
+description: "A practical guide for moving your n8n workflows to Trigger.dev"
+sidebarTitle: "Migrating from n8n"
+---
+
+If you've been building with n8n and are ready to move to code-first workflows, this guide is for you. This page maps them to their Trigger.dev equivalents and walks through common patterns side by side.
+
+Your task code runs on Trigger.dev's managed infrastructure, so there are no servers for you to provision or maintain.
+
+## Concept map
+
+| n8n                                               | Trigger.dev                                                                                                        |
+| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| Workflow                                          | [task](/tasks/overview) plus its config (queue, retry, onFailure)                                                  |
+| Schedule Trigger                                  | [schedules.task](/tasks/scheduled)                                                                                 |
+| Webhook node                                      | Route handler + [task.trigger()](/triggering)                                                                      |
+| Node                                              | A step or library call inside `run()`                                                                              |
+| Execute Sub-workflow node (wait for completion)   | [tasks.triggerAndWait()](/triggering#yourtask-triggerandwait)                                                      |
+| Execute Sub-workflow node (execute in background) | [tasks.trigger()](/triggering)                                                                                     |
+| Loop over N items → Execute Sub-workflow → Merge  | [tasks.batchTriggerAndWait()](/tasks#yourtask-batchtriggerandwait)                                                 |
+| Loop Over Items (Split in Batches)                | `for` loop or `.map()`                                                                                             |
+| IF / Switch node                                  | `if` / `switch` statements                                                                                         |
+| Wait node (time interval or specific time)        | [wait.for()](/wait-for) or [wait.until()](/wait-until)                                                             |
+| Error Trigger node / Error Workflow               | [onFailure](/tasks/overview#onfailure-function) hook (both collapse into one concept in Trigger.dev)               |
+| Continue On Fail                                  | `try/catch` around an individual step                                                                              |
+| Stop And Error                                    | `throw new Error(...)`                                                                                             |
+| Code node                                         | A function or step within `run()`                                                                                  |
+| Credentials                                       | [Environment variable secret](/deploy-environment-variables)                                                       |
+| Execution                                         | Run (visible in the dashboard with full logs)                                                                      |
+| Retry on Fail (per-node setting)                  | [retry.maxAttempts](/tasks/overview#retry) (retries the whole `run()`, not a single step)                          |
+| AI Agent node                                     | Any AI SDK called inside `run()` (Vercel AI SDK, Claude SDK, OpenAI SDK, etc.)                                     |
+| Respond to Webhook node                           | Route handler + [task.triggerAndWait()](/triggering#yourtask-triggerandwait) returning the result as HTTP response |
+
+---
+
+## Setup
+
+<Steps>
+
+<Step title="Create an account">
+
+Go to [Trigger.dev Cloud](https://cloud.trigger.dev), create an account, and create a project.
+
+</Step>
+
+<Step title="Install the CLI and initialize">
+
+```bash
+npx trigger.dev@latest init
+```
+
+This adds Trigger.dev to your project and creates a `trigger/` directory for your tasks.
+
+</Step>
+
+<Step title="Run the local dev server">
+
+```bash
+npx trigger.dev@latest dev
+```
+
+You'll get a local server that behaves like production. Your runs appear in the dashboard as you test.
+
+</Step>
+
+</Steps>
+
+---
+
+## Common patterns
+
+### Webhook trigger
+
+In n8n you use a **Webhook** trigger node, which registers a URL that starts the workflow.
+
+In Trigger.dev, your existing route handler receives the webhook and triggers the task:
+
+<CodeGroup>
+
+```ts app/api/webhook/route.ts
+import { processWebhook } from "@/trigger/process-webhook";
+
+export async function POST(request: Request) {
+  const body = await request.json();
+
+  await processWebhook.trigger({
+    event: body.event,
+    data: body.data,
+  });
+
+  return Response.json({ received: true });
+}
+```
+
+```ts trigger/process-webhook.ts
+import { task } from "@trigger.dev/sdk";
+
+export const processWebhook = task({
+  id: "process-webhook",
+  run: async (payload: { event: string; data: Record<string, unknown> }) => {
+    // handle the webhook payload
+    await handleEvent(payload.event, payload.data);
+  },
+});
+```
+
+</CodeGroup>
+
+---
+
+### Chaining steps (Sub-workflows)
+
+In n8n you use the **Execute Sub-workflow** node to call another workflow and wait for the result.
+
+In Trigger.dev you use `triggerAndWait()`:
+
+<CodeGroup>
+
+```ts trigger/process-order.ts
+import { task } from "@trigger.dev/sdk";
+import { sendConfirmationEmail } from "./send-confirmation-email";
+
+export const processOrder = task({
+  id: "process-order",
+  run: async (payload: { orderId: string; email: string }) => {
+    const result = await processPayment(payload.orderId);
+
+    // trigger a subtask and wait for it to complete
+    await sendConfirmationEmail.triggerAndWait({
+      email: payload.email,
+      orderId: payload.orderId,
+      amount: result.amount,
+    });
+
+    return { processed: true };
+  },
+});
+```
+
+```ts trigger/send-confirmation-email.ts
+import { task } from "@trigger.dev/sdk";
+
+export const sendConfirmationEmail = task({
+  id: "send-confirmation-email",
+  run: async (payload: { email: string; orderId: string; amount: number }) => {
+    await sendEmail({
+      to: payload.email,
+      subject: `Order ${payload.orderId} confirmed`,
+      body: `Your order for $${payload.amount} has been confirmed.`,
+    });
+  },
+});
+```
+
+</CodeGroup>
+
+To trigger multiple subtasks in parallel and wait for all of them (like the **Merge** node in n8n):
+
+```ts trigger/process-batch.ts
+import { task } from "@trigger.dev/sdk";
+import { processItem } from "./process-item";
+
+export const processBatch = task({
+  id: "process-batch",
+  run: async (payload: { items: { id: string }[] }) => {
+    // fan out to subtasks, collect all results
+    const results = await processItem.batchTriggerAndWait(
+      payload.items.map((item) => ({ payload: { id: item.id } }))
+    );
+
+    return { processed: results.runs.length };
+  },
+});
+```
+
+---
+
+### Error handling
+
+In n8n you use **Continue On Fail** on individual nodes and a separate **Error Workflow** for workflow-level failures.
+
+In Trigger.dev:
+
+- Use `try/catch` for recoverable errors at a specific step
+- Use the `onFailure` hook for workflow-level failure handling
+- Configure `retry` for automatic retries with backoff
+
+```ts trigger/import-data.ts
+import { task } from "@trigger.dev/sdk";
+
+export const importData = task({
+  id: "import-data",
+  // automatic retries with exponential backoff
+  retry: {
+    maxAttempts: 3,
+  },
+  // runs if this task fails after all retries
+  onFailure: async ({ payload, error }) => {
+    await sendAlertToSlack(`import-data failed: ${(error as Error).message}`);
+  },
+  run: async (payload: { source: string }) => {
+    let records;
+
+    // continue on fail equivalent: catch the error and handle locally
+    try {
+      records = await fetchFromSource(payload.source);
+    } catch (error) {
+      records = await fetchFromFallback(payload.source);
+    }
+
+    await saveRecords(records);
+  },
+});
+```
+
+---
+
+### Waiting and delays
+
+In n8n you use the **Wait** node to pause a workflow for a fixed time or until a webhook is called.
+
+In Trigger.dev:
+
+```ts trigger/send-followup.ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const sendFollowup = task({
+  id: "send-followup",
+  run: async (payload: { userId: string; email: string }) => {
+    await sendWelcomeEmail(payload.email);
+
+    // wait for a fixed duration, execution is frozen, you don't pay while waiting
+    await wait.for({ days: 3 });
+
+    const hasActivated = await checkUserActivation(payload.userId);
+    if (!hasActivated) {
+      await sendFollowupEmail(payload.email);
+    }
+  },
+});
+```
+
+To wait for an external event (like n8n's "On Webhook Call" resume mode), use `wait.createToken()` to generate a URL, send that URL to the external system, then pause with `wait.forToken()` until the external system POSTs to that URL to resume the run.
+
+```ts trigger/approval-flow.ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const approvalFlow = task({
+  id: "approval-flow",
+  run: async (payload: { requestId: string; approverEmail: string }) => {
+    // create a token, this generates a URL the external system can POST to
+    const token = await wait.createToken({
+      timeout: "48h",
+      tags: [`request-${payload.requestId}`],
+    });
+
+    // send the token URL to whoever needs to resume this run
+    await sendApprovalRequest(payload.approverEmail, payload.requestId, token.url);
+
+    // pause until the external system POSTs to token.url
+    const result = await wait.forToken<{ approved: boolean }>(token).unwrap();
+
+    if (result.approved) {
+      await executeApprovedAction(payload.requestId);
+    } else {
+      await notifyRejection(payload.requestId);
+    }
+  },
+});
+```
+
+---
+
+## Full example: customer onboarding workflow
+
+Here's how a typical back office onboarding workflow translates from n8n to Trigger.dev.
+
+**The n8n setup:** Webhook Trigger → HTTP Request (provision account) → HTTP Request (send welcome email) → HTTP Request (notify Slack) → Wait node (3 days) → HTTP Request (check activation) → IF node → HTTP Request (send follow-up).
+
+**In Trigger.dev**, the same workflow is plain TypeScript:
+
+```ts trigger/onboard-customer.ts
+import { task, wait } from "@trigger.dev/sdk";
+import { provisionAccount } from "./provision-account";
+import { sendWelcomeEmail } from "./send-welcome-email";
+
+export const onboardCustomer = task({
+  id: "onboard-customer",
+  retry: {
+    maxAttempts: 3,
+  },
+  run: async (payload: {
+    customerId: string;
+    email: string;
+    plan: "starter" | "pro" | "enterprise";
+  }) => {
+    // provision their account, throws if the subtask fails
+    await provisionAccount
+      .triggerAndWait({
+        customerId: payload.customerId,
+        plan: payload.plan,
+      })
+      .unwrap();
+
+    // send welcome email
+    await sendWelcomeEmail
+      .triggerAndWait({
+        customerId: payload.customerId,
+        email: payload.email,
+      })
+      .unwrap();
+
+    // notify the team
+    await notifySlack(`New customer: ${payload.email} on ${payload.plan}`);
+
+    // wait 3 days, then check if they've activated
+    await wait.for({ days: 3 });
+
+    const activated = await checkActivation(payload.customerId);
+    if (!activated) {
+      await sendActivationNudge(payload.email);
+    }
+
+    return { customerId: payload.customerId, activated };
+  },
+});
+```
+
+Trigger the workflow from your app when a new customer signs up:
+
+```ts
+import { onboardCustomer } from "@/trigger/onboard-customer";
+
+await onboardCustomer.trigger({
+  customerId: customer.id,
+  email: customer.email,
+  plan: customer.plan,
+});
+```
+
+Every run is visible in the Trigger.dev dashboard with full logs, retry history, and the ability to replay any run.
diff --git a/docs/observability/dashboards.mdx b/docs/observability/dashboards.mdx
new file mode 100644
index 00000000000..57aa26d9d13
--- /dev/null
+++ b/docs/observability/dashboards.mdx
@@ -0,0 +1,102 @@
+---
+title: "Dashboards"
+description: "Create custom dashboards with real-time metrics powered by TRQL queries."
+---
+
+## Overview
+
+In the Trigger.dev dashboard we have built-in dashboards and you can create your own.
+
+Dashboards are powered by [TRQL queries](/observability/query) with widgets that can be displayed as charts, tables, or single values. They automatically refresh to show the latest data.
+
+### Available metrics data
+
+Trigger.dev automatically collects process metrics (CPU, memory) and Node.js runtime metrics (event loop, heap) for all deployed tasks -- no configuration needed. Requires SDK version **4.4.1 or later**. You can also create custom metrics using the `otel.metrics` API from the SDK.
+
+All of this data is available in the `metrics` table for use in dashboard widgets. See [Logging, tracing & metrics](/logging#metrics) for the full list of automatic metrics and how to create custom ones, or the [Query page](/observability/query#metrics-table-columns) for the `metrics` table schema.
+
+![The built-in Metrics dashboard](/images/metrics-built-in.png)
+
+### Visualization types
+
+- **Line chart** - Show trends over time
+- **Bar chart** - Compare values across categories
+- **Area chart** - Display cumulative trends
+- **Table** - Show detailed data in rows
+- **Single value** - Display a single metric (count, sum, average, etc.)
+
+You can also add Titles to your dashboard.
+
+## Filtering and time ranges
+
+All widgets on a dashboard use the time range filter applied to the dashboard.
+
+You can also filter the data by:
+
+- Scope: Environment, Project, Organization
+- Tasks
+- Queues
+
+## Creating custom dashboards
+
+1. In the sidebar click the + icon next to "Dashboards".
+2. Name your custom dashboard.
+3. From the top-right you can "Add chart" or "Add title".
+4. For charts you write [TRQL queries](/observability/query) and choose a visualization type.
+5. You can resize and reposition widgets on your dashboards.
+
+## Performance considerations
+
+### Optimize queries for metrics
+
+1. **Use time bucketing** - `timeBucket()` automatically groups by appropriate intervals
+2. **Limit result size** - Add `LIMIT` clauses, especially for table widgets
+3. **Use approximate functions** - `uniq()` instead of `uniqExact()` for faster approximate counts
+
+## Exporting metric data
+
+Export data from any metric widget:
+
+1. Click the widget menu (three dots)
+2. Select "Copy JSON" or "Copy CSV"
+
+## Best practices
+
+1. **Start simple** - Begin with basic metrics and iterate based on insights
+2. **Use meaningful names** - Give widgets clear, descriptive titles
+3. **Group related metrics** - Organize dashboards by theme (performance, costs, errors)
+4. **Test queries first** - Use the Query page to develop and test before adding to dashboards
+
+## Troubleshooting
+
+### Widget shows "No data"
+
+- Check that your query returns results in the Query page
+- Verify time filters include the period with data
+- Ensure task/queue filters match existing runs
+
+### Widget is slow to load
+
+- Add time range filters to your query
+- Use `LIMIT` clauses
+- Simplify aggregations
+- Check query execution time in Query page
+
+### Chart displays incorrectly
+
+- Verify column names match visualization config
+- Check data types (numbers for charts, dates for time series)
+- Ensure `timeBucket()` is used for time-series charts
+- Review that series columns exist in query results
+
+## Limits
+
+Dashboards are powered by Query so have [the same limits](/observability/query#limits) as Query.
+
+There is a separate concurrency limits for metric widgets.
+
+| Limit                     | Details        |
+| :------------------------ | :------------- |
+| Concurrent widget queries | 30 per project |
+
+See [Limits](/limits) for details.
diff --git a/docs/observability/query.mdx b/docs/observability/query.mdx
new file mode 100644
index 00000000000..01a3bcd4db9
--- /dev/null
+++ b/docs/observability/query.mdx
@@ -0,0 +1,584 @@
+---
+title: "Query"
+description: "Query allows you to write custom queries against your data using TRQL (Trigger.dev Query Language), a SQL-style language based on ClickHouse SQL. You can query your data through the dashboard, SDK, or REST API."
+---
+
+### Available tables
+
+- `runs`: contains all task run data including status, timing, costs, and task output. Run metadata (key-value set in your task) is not available on the Query page.
+- `metrics`: contains metrics data for your runs including CPU, memory, and your custom metrics
+
+### `metrics` table columns
+
+| Column | Type | Description |
+| :--- | :--- | :--- |
+| `metric_name` | string | Metric identifier (e.g., `process.cpu.utilization`) |
+| `metric_type` | string | `gauge`, `sum`, or `histogram` |
+| `value` | number | The observed value |
+| `bucket_start` | datetime | 10-second aggregation bucket start time |
+| `run_id` | string | Associated run ID |
+| `task_identifier` | string | Task slug |
+| `attempt_number` | number | Attempt number |
+| `machine_id` | string | Machine that produced the metric |
+| `machine_name` | string | Machine preset (e.g., `small-1x`) |
+| `worker_version` | string | Worker version |
+| `environment_type` | string | `PRODUCTION`, `STAGING`, `DEVELOPMENT`, `PREVIEW` |
+| `attributes` | json | Raw JSON attributes for custom data |
+
+See [Logging, tracing & metrics](/logging#automatic-system-and-runtime-metrics) for the full list of automatically collected metrics and how to create custom metrics. You can visualize this data on [Dashboards](/observability/dashboards).
+
+### `prettyFormat()`
+
+Use `prettyFormat()` to format metric values for display:
+
+```sql
+SELECT
+  timeBucket(),
+  prettyFormat(avg(value), 'bytes') AS avg_memory
+FROM metrics
+WHERE metric_name = 'process.memory.usage'
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000
+```
+
+Available format types: `bytes`, `percent`, `duration`, `durationSeconds`, `quantity`, `costInDollars`.
+
+## Using the Query dashboard
+
+Navigate to the Query page to write and execute queries. The dashboard provides:
+
+- **AI-powered query generation** - Describe what you want in natural language
+- **Syntax highlighting** - SQL syntax highlighting for better readability
+- **Query history** - Access your previous queries
+- **Interactive help** - Built-in documentation for TRQL syntax and functions
+- **Export options** - Download results as JSON or CSV
+
+![The Query dashboard](/images/query-chart-usage-percentiles.png)
+
+## Querying from the SDK
+
+Use `query.execute()` to run TRQL queries programmatically from your backend code:
+
+```typescript
+import { query } from "@trigger.dev/sdk";
+
+// Basic query with defaults (environment scope, json format)
+const result = await query.execute("SELECT run_id, status FROM runs LIMIT 10");
+console.log(result.results); // Array<Record<string, any>>
+```
+
+### Type-safe queries
+
+Use the `QueryTable` type for nice inferred types in your query results:
+
+```typescript
+import { query, type QueryTable } from "@trigger.dev/sdk";
+
+// Type-safe query using QueryTable with specific columns
+const typedResult = await query.execute<QueryTable<"runs", "run_id" | "status" | "triggered_at">>(
+  "SELECT run_id, status, triggered_at FROM runs LIMIT 10"
+);
+
+typedResult.results.forEach((row) => {
+  console.log(row.run_id, row.status); // Fully typed!
+});
+```
+
+### Query options
+
+```typescript
+import { query } from "@trigger.dev/sdk";
+
+const result = await query.execute("SELECT COUNT(*) as count FROM runs", {
+  // Scope: "environment" (default), "project", or "organization"
+  scope: "project",
+  // Time period using shorthand (e.g., "7d", "30d", "1h")
+  period: "7d",
+  // Or use explicit time range
+  // from: new Date("2024-01-01"),
+  // to: new Date("2024-01-31"),
+
+  // Response format: "json" (default) or "csv"
+  format: "json",
+});
+```
+
+### CSV export
+
+Export query results as CSV by setting `format: "csv"`:
+
+```typescript
+const csvResult = await query.execute("SELECT run_id, status, triggered_at FROM runs", {
+  format: "csv",
+  period: "7d",
+});
+
+const lines = csvResult.results.split("\n");
+console.log(lines[0]); // CSV header row
+```
+
+## Querying from the REST API
+
+Execute queries via HTTP POST to `/api/v1/query`:
+
+```sh
+curl -X POST https://api.trigger.dev/api/v1/query \
+  -H "Authorization: Bearer YOUR_SECRET_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "SELECT run_id, status FROM runs LIMIT 10",
+    "scope": "environment",
+    "period": "7d",
+    "format": "json"
+  }'
+```
+
+See the [API reference](/management/query/execute) for full details.
+
+## TRQL syntax guide
+
+### Basic queries
+
+Select columns from a table:
+
+```sql
+SELECT run_id, task_identifier, status
+FROM runs
+LIMIT 10
+```
+
+Alias columns with `AS`:
+
+```sql
+SELECT task_identifier AS task, count() AS total
+FROM runs
+GROUP BY task
+```
+
+### Using \*
+
+Note that when you use `SELECT *` we don't return all the columns, we only return the core columns. This is for performance reasons (the underlying ClickHouse database is columnar and selecting lots of columns isn't efficient).
+
+You should specify the columns you want to return.
+
+### Filtering with WHERE
+
+Use comparison operators:
+
+```sql
+SELECT run_id, task_identifier FROM runs
+WHERE status = 'Failed'
+```
+
+Available operators:
+
+```sql
+-- Comparison operators
+WHERE status = 'Failed'           -- Equal
+WHERE status != 'Completed'       -- Not equal
+WHERE attempt_count > 3           -- Greater than
+WHERE attempt_count >= 3          -- Greater than or equal
+WHERE attempt_count < 5           -- Less than
+WHERE attempt_count <= 5          -- Less than or equal
+
+-- IN for multiple values
+WHERE status IN ('Failed', 'Crashed')
+
+-- LIKE for pattern matching (% = wildcard)
+WHERE task_identifier LIKE 'email%'
+
+-- ILIKE for case-insensitive matching
+WHERE task_identifier ILIKE '%send%'
+
+-- BETWEEN for ranges
+WHERE triggered_at BETWEEN '2024-01-01' AND '2024-01-31'
+
+-- NULL checks
+WHERE completed_at IS NOT NULL
+WHERE completed_at IS NULL
+
+-- Array column checks
+WHERE has(tags, 'user_12345')
+WHERE notEmpty(tags)
+WHERE hasAny(tags, array('user_12345', 'user_67890'))
+WHERE hasAll(tags, array('user_12345', 'user_67890'))
+WHERE indexOf(tags, 'user_12345') > 0
+WHERE arrayElement(tags, 1) = 'user_12345'
+```
+
+### Sorting and limiting
+
+Sort results with `ORDER BY`:
+
+```sql
+SELECT run_id, compute_cost, triggered_at
+FROM runs
+ORDER BY compute_cost DESC, triggered_at ASC
+LIMIT 50
+```
+
+### Grouping and aggregation
+
+Use `GROUP BY` with aggregate functions:
+
+```sql
+SELECT
+  task_identifier,
+  avg(value) AS avg_memory
+FROM metrics
+WHERE metric_name = 'process.memory.usage'
+GROUP BY task_identifier
+ORDER BY avg_memory DESC
+LIMIT 20
+```
+
+## Available functions
+
+TRQL provides a rich set of functions for data analysis.
+
+### Aggregate functions
+
+- `count()` - Count rows
+- `countIf(col, cond)` - Count rows matching condition
+- `countDistinct(col)` - Count unique values
+- `sum(col)` - Sum of values
+- `sumIf(col, cond)` - Sum values matching condition
+- `avg(col)` - Average of values
+- `min(col)` - Minimum value
+- `max(col)` - Maximum value
+- `median(col)` - Median value (50th percentile)
+- `quantile(p)(col)` - Value at percentile p (0-1)
+- `stddevPop(col)` - Population standard deviation
+- `stddevSamp(col)` - Sample standard deviation
+
+Example:
+
+```sql
+SELECT
+  task_identifier,
+  count() AS total_runs,
+  avg(usage_duration) AS avg_duration_ms,
+  median(usage_duration) AS median_duration_ms,
+  quantile(0.95)(usage_duration) AS p95_duration_ms
+FROM runs
+GROUP BY task_identifier
+```
+
+### Date/time functions
+
+**Time bucketing:**
+
+```sql
+-- Auto-bucket by time period based on query's time range
+SELECT timeBucket(), count() AS runs
+FROM runs
+GROUP BY timeBucket()
+```
+
+**Date extraction:**
+
+```sql
+SELECT
+  toYear(triggered_at) AS year,
+  toMonth(triggered_at) AS month,
+  toDayOfWeek(triggered_at) AS day_of_week,
+  toHour(triggered_at) AS hour
+FROM runs
+```
+
+**Date truncation:**
+
+```sql
+SELECT
+  toStartOfDay(triggered_at) AS day,
+  count() AS runs_per_day
+FROM runs
+GROUP BY day
+ORDER BY day DESC
+```
+
+**Date arithmetic:**
+
+```sql
+-- Add/subtract time
+SELECT dateAdd('day', 7, triggered_at) AS week_later
+FROM runs
+
+-- Calculate differences
+SELECT dateDiff('minute', executed_at, completed_at) AS duration_minutes
+FROM runs
+WHERE completed_at IS NOT NULL
+```
+
+Common date functions:
+
+- `now()` - Current date and time
+- `today()` - Current date
+- `toDate(dt)` - Convert to date
+- `toStartOfDay(dt)`, `toStartOfHour(dt)`, `toStartOfMonth(dt)` - Truncate to start of period
+- `formatDateTime(dt, format)` - Format datetime as string
+
+### String functions
+
+```sql
+SELECT
+  lower(status) AS status_lower,
+  upper(status) AS status_upper,
+  concat(task_identifier, '-', status) AS combined,
+  substring(run_id, 1, 8) AS short_id,
+  length(task_identifier) AS name_length
+FROM runs
+```
+
+Common string functions:
+
+- `length(s)` - String length
+- `lower(s)`, `upper(s)` - Case conversion
+- `concat(s1, s2, ...)` - Concatenate strings
+- `substring(s, offset, len)` - Extract substring
+- `trim(s)` - Remove whitespace
+- `replace(s, from, to)` - Replace occurrences
+- `startsWith(s, prefix)`, `endsWith(s, suffix)` - Check prefixes/suffixes
+
+### Conditional functions
+
+```sql
+SELECT
+  run_id,
+  if(status = 'Failed', 1, 0) AS is_failed,
+  multiIf(
+    status = 'Completed', 'ok',
+    status = 'Failed', 'bad',
+    'other'
+  ) AS status_category,
+  coalesce(completed_at, triggered_at) AS end_time
+FROM runs
+```
+
+- `if(cond, then, else)` - Conditional expression
+- `multiIf(c1, t1, c2, t2, ..., else)` - Multiple conditions (like CASE)
+- `coalesce(a, b, ...)` - First non-null value
+
+### Math functions
+
+```sql
+SELECT
+  round(compute_cost, 4) AS cost_rounded,
+  ceil(usage_duration / 1000) AS duration_seconds_up,
+  floor(usage_duration / 1000) AS duration_seconds_down,
+  abs(compute_cost) AS cost_abs
+FROM runs
+```
+
+### Array functions
+
+Useful for working with tags and other array columns:
+
+```sql
+SELECT
+  run_id,
+  tags,
+  length(tags) AS tag_count,
+  has(tags, 'user_12345') AS is_production,
+  arrayJoin(tags) AS individual_tag  -- Expand array to rows
+FROM runs
+WHERE notEmpty(tags)
+```
+
+### JSON functions
+
+The `output`, `error`, and `metrics.attributes` columns are already JSON, so use dot notation to read or filter on them. You don't need `JSONExtract*` for these (those are for string columns).
+
+```sql
+SELECT
+  run_id,
+  output.message AS output_message,
+  output.count AS count,
+  output.externalId AS external_id
+FROM runs
+WHERE task_identifier = 'my-task'
+  AND output.externalId = 'something'
+ORDER BY triggered_at DESC
+LIMIT 100
+```
+
+## Query scopes
+
+Control what data your query can access:
+
+- **`environment`** (default) - Query runs in the current environment only
+- **`project`** - Query runs across all environments in the project
+- **`organization`** - Query runs across all projects in the organization
+
+```typescript
+// Query across all environments in a project
+const result = await query.execute("SELECT environment, count() FROM runs GROUP BY environment", {
+  scope: "project",
+});
+```
+
+## Time ranges
+
+We recommend avoiding adding `triggered_at` in the actual TRQL query. The dashboard, API, and SDK have a time filter that is applied automatically and is easier to work with. It means the queries can be executed with multiple periods easily.
+
+### Using period shorthand
+
+```typescript
+await query.execute("SELECT count() FROM runs", {
+  period: "4d", // Last 4 days
+});
+
+// Supported periods: "1h", "6h", "12h", "1d", "7d", "30d", "90d", etc.
+```
+
+### Using explicit dates
+
+```typescript
+await query.execute("SELECT count() FROM runs", {
+  from: new Date("2024-01-01"),
+  to: new Date("2024-01-31"),
+});
+
+// Or use Unix timestamps
+await query.execute("SELECT count() FROM runs", {
+  from: Date.now() - 7 * 24 * 60 * 60 * 1000, // 7 days ago
+  to: Date.now(),
+});
+```
+
+## Example queries
+
+### Failed runs (in the last 24 hours)
+
+```sql
+SELECT
+  task_identifier,
+  run_id,
+  error,
+  triggered_at
+FROM runs
+WHERE status = 'Failed'
+ORDER BY triggered_at DESC
+```
+
+With the time filter set to 24h.
+
+### Task success rate by day
+
+```sql
+SELECT
+  toDate(triggered_at) AS day,
+  task_identifier,
+  countIf(status = 'Completed') AS completed,
+  countIf(status = 'Failed') AS failed,
+  round(completed / (completed + failed) * 100, 2) AS success_rate_pct
+FROM runs
+WHERE status IN ('Completed', 'Failed')
+GROUP BY day, task_identifier
+ORDER BY day DESC, task_identifier
+```
+
+### Top 10 most expensive runs
+
+```sql
+SELECT
+  run_id,
+  task_identifier,
+  compute_cost,
+  usage_duration,
+  triggered_at
+FROM runs
+WHERE compute_cost > 0
+ORDER BY compute_cost DESC
+LIMIT 10
+```
+
+### Average compute duration over time
+
+```sql
+SELECT
+  timeBucket() AS time,
+  task_identifier,
+  avg(usage_duration) AS avg_duration_ms,
+  count() AS run_count
+FROM runs
+WHERE usage_duration IS NOT NULL
+GROUP BY time, task_identifier
+ORDER BY time ASC
+```
+
+### Runs by queue and machine
+
+```sql
+SELECT
+  queue,
+  machine,
+  count() AS run_count,
+  countIf(status = 'Completed') AS completed,
+  countIf(status = 'Failed') AS failed
+FROM runs
+GROUP BY queue, machine
+ORDER BY queue, machine
+```
+
+### CPU utilization over time
+
+Track process CPU utilization bucketed over time.
+
+```sql
+SELECT
+  timeBucket(),
+  avg(value) AS avg_cpu
+FROM metrics
+WHERE metric_name = 'process.cpu.utilization'
+GROUP BY timeBucket
+ORDER BY timeBucket
+LIMIT 1000
+```
+
+### Memory usage by task (past 7d)
+
+Average process memory usage per task identifier over the last 7 days.
+
+```sql
+SELECT
+  task_identifier,
+  avg(value) AS avg_memory
+FROM metrics
+WHERE metric_name = 'process.memory.usage'
+GROUP BY task_identifier
+ORDER BY avg_memory DESC
+LIMIT 20
+```
+
+### Available metric names
+
+List all distinct metric names collected in your environment.
+
+```sql
+SELECT
+  metric_name,
+  count() AS sample_count
+FROM metrics
+GROUP BY metric_name
+ORDER BY sample_count DESC
+LIMIT 100
+```
+
+## Best practices
+
+1. **Use the built-in time filtering** - The dashboard, API, and SDK have a time filter that is applied automatically and is easier to work with. It means the queries can be executed with multiple periods easily.
+2. **Use LIMIT** - Add a `LIMIT` clause to reduce the rows returned if you don't need everything.
+3. **Use appropriate aggregations** - For large datasets, use `uniq()` instead of `uniqExact()` for approximate but faster counts
+
+## Limits
+
+We have several limits to prevent abuse and ensure performance:
+
+- **Concurrency limit**: We limit the number of concurrent queries per organization.
+- **Row limit**: We limit the number of rows returned to 10k.
+- **Time restrictions**: We limit the time period you can query.
+- **Time/Memory limit**: We limit the memory a query can use and the time it can run for. As well as other limits like AST complexity.
+
+See [Limits](/limits) for current quota details.
diff --git a/docs/openapi.yml b/docs/openapi.yml
index d5dd12ff467..922e8d7f287 100644
--- a/docs/openapi.yml
+++ b/docs/openapi.yml
@@ -43,6 +43,159 @@ paths:
               schema:
                 $ref: "#/components/schemas/Error"
 
+  /api/v3/batches:
+    post:
+      operationId: createBatch
+      externalDocs:
+        description: Find more info here
+        url: "https://trigger.dev/docs/triggering"
+      tags:
+        - Batches
+      summary: Create a batch (Phase 1)
+      description: |
+        Phase 1 of 2-phase batch API. Creates a batch record and optionally blocks the parent run for batchTriggerAndWait.
+        After creating a batch, stream items via POST /api/v3/batches/{batchId}/items.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateBatchRequest"
+      responses:
+        "202":
+          description: Batch successfully created
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/CreateBatchResponse"
+          headers:
+            x-trigger-jwt-claims:
+              description: JWT claims for the batch
+              schema:
+                type: string
+            x-trigger-jwt:
+              description: JWT token for browser clients
+              schema:
+                type: string
+        "400":
+          description: Invalid request (e.g., runCount <= 0 or exceeds maximum)
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "401":
+          description: Unauthorized - API key is missing or invalid
+        "422":
+          description: Validation error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "429":
+          description: Rate limit exceeded
+          headers:
+            X-RateLimit-Limit:
+              description: Maximum number of requests allowed
+              schema:
+                type: integer
+            X-RateLimit-Remaining:
+              description: Number of requests remaining
+              schema:
+                type: integer
+            X-RateLimit-Reset:
+              description: Unix timestamp when the rate limit resets
+              schema:
+                type: integer
+            Retry-After:
+              description: Seconds to wait before retrying
+              schema:
+                type: integer
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "500":
+          description: Internal server error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+
+  /api/v3/batches/{batchId}/items:
+    post:
+      operationId: streamBatchItems
+      externalDocs:
+        description: Find more info here
+        url: "https://trigger.dev/docs/triggering"
+      tags:
+        - Batches
+      summary: Stream batch items (Phase 2)
+      description: |
+        Phase 2 of 2-phase batch API. Accepts an NDJSON stream of batch items and enqueues them.
+        Each line in the body should be a valid BatchItemNDJSON object.
+        The stream is processed with backpressure - items are enqueued as they arrive.
+        The batch is sealed when the stream completes successfully.
+      parameters:
+        - name: batchId
+          in: path
+          required: true
+          description: The batch ID returned from POST /api/v3/batches
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          application/x-ndjson:
+            schema:
+              type: string
+              description: |
+                NDJSON (newline-delimited JSON) stream where each line is a BatchItemNDJSON object.
+                Example:
+                {"index":0,"task":"my-task","payload":{"key":"value1"}}
+                {"index":1,"task":"my-task","payload":{"key":"value2"}}
+          application/ndjson:
+            schema:
+              type: string
+              description: |
+                NDJSON (newline-delimited JSON) stream where each line is a BatchItemNDJSON object.
+      responses:
+        "200":
+          description: Items successfully processed
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/StreamBatchItemsResponse"
+        "400":
+          description: Invalid request (e.g., invalid JSON, item exceeds maximum size)
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "401":
+          description: Unauthorized - API key is missing or invalid
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "415":
+          description: Unsupported Media Type - Content-Type must be application/x-ndjson or application/ndjson
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "422":
+          description: Validation error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+        "500":
+          description: Internal server error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+
 components:
   schemas:
     Error:
@@ -130,6 +283,91 @@ components:
       type: object
       additionalProperties: true
       description: A JSON object that represents the deserialized payload or context.
+    CreateBatchRequest:
+      type: object
+      required:
+        - runCount
+      properties:
+        runCount:
+          type: integer
+          minimum: 1
+          description: Expected number of items in the batch. Must be a positive integer.
+        parentRunId:
+          type: string
+          description: Parent run ID (friendly ID) for batchTriggerAndWait.
+        resumeParentOnCompletion:
+          type: boolean
+          description: Whether to resume parent on completion. Set to true for batchTriggerAndWait.
+        idempotencyKey:
+          type: string
+          description: Idempotency key for the batch. If provided and a batch with this key already exists, the existing batch will be returned.
+    CreateBatchResponse:
+      type: object
+      required:
+        - id
+        - runCount
+        - isCached
+      properties:
+        id:
+          type: string
+          description: The batch ID (friendly ID). Use this to stream items via POST /api/v3/batches/{batchId}/items.
+        runCount:
+          type: integer
+          description: The expected run count.
+        isCached:
+          type: boolean
+          description: Whether this response came from a cached/idempotent batch.
+        idempotencyKey:
+          type: string
+          description: The idempotency key if provided.
+    BatchItemNDJSON:
+      type: object
+      required:
+        - index
+        - task
+      properties:
+        index:
+          type: integer
+          minimum: 0
+          description: Zero-based index of this item. Used for idempotency and ordering.
+        task:
+          type: string
+          description: The task identifier to trigger.
+        payload:
+          description: The payload for this task run. Can be any JSON value.
+        options:
+          type: object
+          additionalProperties: true
+          description: Options for this specific item.
+    StreamBatchItemsResponse:
+      type: object
+      required:
+        - id
+        - itemsAccepted
+        - itemsDeduplicated
+        - sealed
+      properties:
+        id:
+          type: string
+          description: The batch ID.
+        itemsAccepted:
+          type: integer
+          description: Number of items successfully accepted.
+        itemsDeduplicated:
+          type: integer
+          description: Number of items that were deduplicated (already enqueued).
+        sealed:
+          type: boolean
+          description: |
+            Whether the batch was sealed and is ready for processing.
+            If false, the batch needs more items before processing can start.
+            Clients should check this field and retry with missing items if needed.
+        enqueuedCount:
+          type: integer
+          description: Total items currently enqueued. Only present when sealed=false to help with retries.
+        expectedCount:
+          type: integer
+          description: Expected total item count. Only present when sealed=false to help with retries.
   securitySchemes:
     BearerAuth:
       type: http
diff --git a/docs/queue-concurrency.mdx b/docs/queue-concurrency.mdx
index fc4829757dc..24e77f4e67f 100644
--- a/docs/queue-concurrency.mdx
+++ b/docs/queue-concurrency.mdx
@@ -226,3 +226,129 @@ export const subtask = task({
 ```
 
 When the parent task reaches the `triggerAndWait` call, it checkpoints and transitions to the `WAITING` state, releasing its concurrency slot back to both its queue and the environment. Once the subtask completes, the parent task will resume and re-acquire a concurrency slot.
+
+## Managing queues with the SDK
+
+The SDK provides a `queues` namespace that allows you to manage queues programmatically. You can list, retrieve, pause, resume, and modify concurrency limits for queues.
+
+<Note>
+  Import from `@trigger.dev/sdk`:
+  ```ts
+  import { queues } from "@trigger.dev/sdk";
+  ```
+</Note>
+
+### Listing queues
+
+You can list all queues in your environment with pagination support:
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// List all queues (returns paginated results)
+const allQueues = await queues.list();
+
+// With pagination options
+const pagedQueues = await queues.list({
+  page: 1,
+  perPage: 20,
+});
+```
+
+### Retrieving a queue
+
+You can retrieve a specific queue by its ID, or by its type and name:
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// Using queue ID (starts with "queue_")
+const queueById = await queues.retrieve("queue_1234");
+
+// Using type and name for a task's default queue
+const taskQueue = await queues.retrieve({
+  type: "task",
+  name: "my-task-id",
+});
+
+// Using type and name for a custom queue
+const customQueue = await queues.retrieve({
+  type: "custom",
+  name: "my-custom-queue",
+});
+```
+
+The queue object contains useful information about the queue state:
+
+```ts
+{
+  id: "queue_1234",       // Queue ID
+  name: "my-task-id",     // Queue name
+  type: "task",           // "task" or "custom"
+  running: 5,             // Currently executing runs
+  queued: 10,             // Runs waiting to execute
+  paused: false,          // Whether the queue is paused
+  concurrencyLimit: 10,   // Current concurrency limit
+  concurrency: {
+    current: 10,          // Effective limit
+    base: 10,             // Default limit from code
+    override: null,       // Override value (if set)
+    overriddenAt: null,   // When override was applied
+    overriddenBy: null,   // Who applied the override
+  }
+}
+```
+
+### Pausing and resuming queues
+
+You can pause a queue to prevent new runs from starting. Runs that are currently executing will continue to completion.
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// Pause a queue using its ID
+await queues.pause("queue_1234");
+
+// Or using type and name
+await queues.pause({ type: "task", name: "my-task-id" });
+await queues.pause({ type: "custom", name: "my-custom-queue" });
+```
+
+To resume a paused queue and allow new runs to start:
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// Resume a queue using its ID
+await queues.resume("queue_1234");
+
+// Or using type and name
+await queues.resume({ type: "task", name: "my-task-id" });
+await queues.resume({ type: "custom", name: "my-custom-queue" });
+```
+
+### Overriding concurrency limits
+
+You can temporarily override a queue's concurrency limit. This is useful for scaling up or down based on demand:
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// Set concurrency limit to 5
+await queues.overrideConcurrencyLimit("queue_1234", 5);
+
+// Or using type and name
+await queues.overrideConcurrencyLimit({ type: "task", name: "my-task-id" }, 20);
+```
+
+To reset the concurrency limit back to the base value defined in your code:
+
+```ts
+import { queues } from "@trigger.dev/sdk";
+
+// Reset concurrency limit to the base value
+await queues.resetConcurrencyLimit("queue_1234");
+
+// Or using type and name
+await queues.resetConcurrencyLimit({ type: "task", name: "my-task-id" });
+```
diff --git a/docs/quick-start.mdx b/docs/quick-start.mdx
index d6253bc2697..8e7e7cb0c01 100644
--- a/docs/quick-start.mdx
+++ b/docs/quick-start.mdx
@@ -1,36 +1,63 @@
 ---
-title: "Quick start"
-description: "How to get started in 3 minutes using the CLI and SDK."
+title: "Quick start: add Trigger.dev to your project"
+sidebarTitle: "Quick start"
+description: "Set up Trigger.dev in your existing project in under 3 minutes. Install the SDK, create your first background task, and trigger it from your code."
 ---
 
-import CliInitStep from '/snippets/step-cli-init.mdx';
-import CliDevStep from '/snippets/step-cli-dev.mdx';
-import CliRunTestStep from '/snippets/step-run-test.mdx';
-import CliViewRunStep from '/snippets/step-view-run.mdx';
+import CliInitStep from "/snippets/step-cli-init.mdx";
+import CliDevStep from "/snippets/step-cli-dev.mdx";
+import CliRunTestStep from "/snippets/step-run-test.mdx";
+import CliViewRunStep from "/snippets/step-view-run.mdx";
 
-In this guide we will:
+## Set up with AI
 
-1. Create a `trigger.config.ts` file and a `/trigger` directory with an example task.
-2. Get you to run the task using the CLI.
-3. Show you how to view the run logs for that task.
+Using an AI coding assistant? Copy this prompt and paste it into Claude Code, Cursor, Copilot, Windsurf, or any AI tool. It'll handle the setup for you.
 
-<Steps titleSize="h3">
+<Accordion title="Copy the setup prompt">
 
-<Step title="Create a Trigger.dev account">
+```text
+Help me add Trigger.dev to this project.
 
-You can either:
+## What to do
 
-- Use the [Trigger.dev Cloud](https://cloud.trigger.dev).
-- Or [self-host](/open-source-self-hosting) the service.
+1. I need a Trigger.dev account. If I don't have one, point me to https://cloud.trigger.dev to sign up. Wait for me to confirm.
+2. Run `npx trigger.dev@latest init` in the project root.
+   - When it asks about the MCP server, recommend I install it (best DX: gives you direct access to Trigger.dev docs, deploys, and run monitoring).
+   - Install the "Hello World" example task when prompted.
+3. Run `npx trigger.dev@latest dev` to start the dev server.
+4. Once the dev server is running, test the example task from the Trigger.dev dashboard.
+5. Set TRIGGER_SECRET_KEY in my .env file (or .env.local for Next.js). I can find it on the API Keys page in the dashboard.
+6. Ask me what framework I'm using and show me how to trigger the task from my backend code.
 
-</Step>
+If I've already run init and want the MCP server, run: npx trigger.dev@latest install-mcp
+
+## Critical rules
+
+- ALWAYS import from `@trigger.dev/sdk`. NEVER import from `@trigger.dev/sdk/v3`.
+- NEVER use `client.defineJob()` — that's the deprecated v2 API.
+- Use type-only imports when triggering from backend code to avoid bundling task code:
+
+  import type { myTask } from "./trigger/example";
+  import { tasks } from "@trigger.dev/sdk";
+
+  const handle = await tasks.trigger<typeof myTask>("hello-world", { message: "Hello from my app!" });
+
+## When done, point me to
+
+- Writing tasks: https://trigger.dev/docs/tasks/overview
+- Real-time updates: https://trigger.dev/docs/realtime/overview
+- AI tooling: https://trigger.dev/docs/building-with-ai
+```
 
-<Step title="Create your first project">
+</Accordion>
 
-Once you've created an account, follow the steps in the app to:
+## Manual setup
 
-1. Complete your account details.
-2. Create your first Organization and Project.
+<Steps titleSize="h3">
+
+<Step title="Create a Trigger.dev account">
+
+Sign up at [Trigger.dev Cloud](https://cloud.trigger.dev) (or [self-host](/open-source-self-hosting)). The onboarding flow will guide you through creating your first organization and project.
 
 </Step>
 
@@ -41,13 +68,30 @@ Once you've created an account, follow the steps in the app to:
 
 </Steps>
 
+## Triggering tasks from your app
+
+The test page in the dashboard is great for verifying your task works. To trigger tasks from your own code, you'll need to set the `TRIGGER_SECRET_KEY` environment variable. Grab it from the API Keys page in the dashboard and add it to your `.env` file.
+
+```bash .env
+TRIGGER_SECRET_KEY=tr_dev_...
+```
+
+See [Triggering](/triggering) for the full guide, or jump straight to framework-specific setup for [Next.js](/guides/frameworks/nextjs), [Remix](/guides/frameworks/remix), or [Node.js](/guides/frameworks/nodejs).
+
 ## Next steps
 
-<CardGroup>
+<CardGroup cols={2}>
+<Card title="Building with AI" icon="brain" href="/building-with-ai">
+  Build Trigger.dev projects using AI coding assistants
+</Card>
   <Card title="How to trigger your tasks" icon="bolt" href="/triggering">
-    Learn how to trigger tasks from your code.
+    Trigger tasks from your backend code
   </Card>
   <Card title="Writing tasks" icon="wand-magic-sparkles" href="/tasks/overview">
-    Tasks are the core of Trigger.dev. Learn what they are and how to write them.
+    Task options, lifecycle hooks, retries, and queues
   </Card>
+  <Card title="Guides and example projects" icon="books" href="/guides/introduction">
+  Framework guides and working example repos
+</Card>
+
 </CardGroup>
diff --git a/docs/realtime/auth.mdx b/docs/realtime/auth.mdx
index 80634b82a8a..025060c688b 100644
--- a/docs/realtime/auth.mdx
+++ b/docs/realtime/auth.mdx
@@ -141,6 +141,10 @@ By default, auto-generated tokens expire after 15 minutes and have a read scope
 
 See our [triggering documentation](/triggering) for detailed examples of how to trigger tasks and get auto-generated tokens.
 
+<Note>
+**Where should I create tokens?** The standard pattern is to create tokens in your backend code (API route, server action) after triggering a task, then pass the token to your frontend. The `handle.publicAccessToken` returned by `tasks.trigger()` already does this for you. You rarely need to create tokens inside a task itself.
+</Note>
+
 ### Subscribing to runs with Public Access Tokens
 
 Once you have a Public Access Token, you can use it to authenticate requests to the Realtime API in both backend and frontend applications.
diff --git a/docs/realtime/backend/input-streams.mdx b/docs/realtime/backend/input-streams.mdx
new file mode 100644
index 00000000000..1224e24244e
--- /dev/null
+++ b/docs/realtime/backend/input-streams.mdx
@@ -0,0 +1,155 @@
+---
+title: Input Streams
+sidebarTitle: Input Streams
+description: Send data into running tasks from your backend code
+---
+
+The Input Streams API allows you to send data into running Trigger.dev tasks from your backend code. This enables bidirectional communication — while [output streams](/realtime/backend/streams) let you read data from tasks, input streams let you push data into them.
+
+<Note>
+  To learn how to receive input stream data inside your tasks, see [Input
+  Streams](/tasks/streams#input-streams) in the Streams doc.
+</Note>
+
+## Sending data to a running task
+
+### Using defined input streams (Recommended)
+
+The recommended approach is to use [defined input streams](/tasks/streams#defining-input-streams) for full type safety:
+
+```ts
+import { cancelSignal, approval } from "./trigger/streams";
+
+// Cancel a running AI stream
+await cancelSignal.send(runId, { reason: "User clicked stop" });
+
+// Approve a draft
+await approval.send(runId, { approved: true, reviewer: "alice@example.com" });
+```
+
+The `.send()` method is fully typed — the data parameter must match the generic type you defined on the input stream.
+
+<Note>
+  `.send()` works the same regardless of how the task is listening — whether it uses `.wait()`
+  (suspending), `.once()` (non-suspending), or `.on()` (continuous). The sender doesn't need to know
+  how the task is consuming the data. See [Input Streams](/tasks/streams#input-streams) for details on each
+  receiving method.
+</Note>
+
+## Practical examples
+
+### Cancel from a Next.js API route
+
+```ts app/api/cancel/route.ts
+import { cancelStream } from "@/trigger/streams";
+
+export async function POST(req: Request) {
+  const { runId } = await req.json();
+
+  await cancelStream.send(runId, { reason: "User clicked stop" });
+
+  return Response.json({ cancelled: true });
+}
+```
+
+### Approval workflow API
+
+```ts app/api/approve/route.ts
+import { approval } from "@/trigger/streams";
+
+export async function POST(req: Request) {
+  const { runId, approved, reviewer } = await req.json();
+
+  await approval.send(runId, {
+    approved,
+    reviewer,
+  });
+
+  return Response.json({ success: true });
+}
+```
+
+### Remix action handler
+
+```ts app/routes/api.approve.ts
+import { json, type ActionFunctionArgs } from "@remix-run/node";
+import { approval } from "~/trigger/streams";
+
+export async function action({ request }: ActionFunctionArgs) {
+  const formData = await request.formData();
+  const runId = formData.get("runId") as string;
+  const approved = formData.get("approved") === "true";
+  const reviewer = formData.get("reviewer") as string;
+
+  await approval.send(runId, { approved, reviewer });
+
+  return json({ success: true });
+}
+```
+
+### Express handler
+
+```ts
+import express from "express";
+import { cancelSignal } from "./trigger/streams";
+
+const app = express();
+app.use(express.json());
+
+app.post("/api/cancel", async (req, res) => {
+  const { runId, reason } = req.body;
+
+  await cancelSignal.send(runId, { reason });
+
+  res.json({ cancelled: true });
+});
+```
+
+### Sending from another task
+
+You can send input stream data from one task to another running task:
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { approval } from "./streams";
+
+export const reviewerTask = task({
+  id: "auto-reviewer",
+  run: async (payload: { targetRunId: string }) => {
+    // Perform automated review logic...
+    const isApproved = await performReview();
+
+    // Send approval to the waiting task
+    await approval.send(payload.targetRunId, {
+      approved: isApproved,
+      reviewer: "auto-reviewer",
+    });
+  },
+});
+```
+
+## Error handling
+
+The `.send()` method will throw if:
+
+- The run has already completed, failed, or been canceled
+- The payload exceeds the 1MB size limit
+- The run ID is invalid
+
+```ts
+import { cancelSignal } from "./trigger/streams";
+
+try {
+  await cancelSignal.send(runId, { reason: "User clicked stop" });
+} catch (error) {
+  console.error("Failed to send:", error);
+  // Handle the error — the run may have already completed
+}
+```
+
+## Important notes
+
+- Maximum payload size per `.send()` call is **1MB**
+- You cannot send data to a completed, failed, or canceled run
+- Data sent before a listener is registered inside the task is **buffered** and delivered when a listener attaches
+- Input streams require the current streams implementation (v2 is the default in SDK 4.1.0+). See [Streams](/tasks/streams) for details.
diff --git a/docs/realtime/backend/overview.mdx b/docs/realtime/backend/overview.mdx
index 7adb30bfa0e..6bf81a20aeb 100644
--- a/docs/realtime/backend/overview.mdx
+++ b/docs/realtime/backend/overview.mdx
@@ -1,23 +1,22 @@
 ---
-title: Backend overview
+title: "Subscribe to tasks from your backend"
 sidebarTitle: Overview
-description: Using the Trigger.dev realtime API from your backend code
+description: "Subscribe to run progress, stream AI output, and react to task status changes from your backend code or other tasks."
 ---
 
 import RealtimeExamplesCards from "/snippets/realtime-examples-cards.mdx";
 
-Use these backend functions to subscribe to runs and streams from your server-side code or other tasks.
+**Subscribe to runs from your server-side code or other tasks using async iterators.** Get status updates, metadata changes, and streamed data without polling.
 
-## Overview
+## What's available
 
-There are three main categories of functionality:
-
-- **[Subscribe functions](/realtime/backend/subscribe)** - Subscribe to run updates using async iterators
-- **[Metadata](/realtime/backend/subscribe#subscribe-to-metadata-updates-from-your-tasks)** - Update and subscribe to run metadata in real-time
-- **[Streams](/realtime/backend/streams)** - Read and consume real-time streaming data from your tasks
+| Category | What it does | Guide |
+|---|---|---|
+| **Run updates** | Subscribe to run status, metadata, and tag changes | [Run updates](/realtime/backend/subscribe) |
+| **Streaming** | Read AI output, file chunks, or any continuous data from tasks | [Streaming](/realtime/backend/streams) |
 
 <Note>
-  To learn how to emit streams from your tasks, see our [Realtime Streams](/tasks/streams) documentation.
+  To learn how to emit streams from your tasks, see [Streaming data from tasks](/tasks/streams).
 </Note>
 
 ## Authentication
diff --git a/docs/realtime/backend/streams.mdx b/docs/realtime/backend/streams.mdx
index 11c21bd2f4d..8a273ea5a9f 100644
--- a/docs/realtime/backend/streams.mdx
+++ b/docs/realtime/backend/streams.mdx
@@ -1,13 +1,13 @@
 ---
-title: Streams
-sidebarTitle: Streams
-description: Read and consume real-time streaming data from your tasks in your backend
+title: "Stream data to your backend (AI, files)"
+sidebarTitle: "Streaming"
+description: "Read AI/LLM output, file chunks, and other streaming data from your Trigger.dev tasks in backend code."
 ---
 
-The Streams API allows you to read streaming data from your Trigger.dev tasks in your backend code. This is particularly useful for consuming AI/LLM outputs, progress updates, or any other real-time data that your tasks emit.
+**Read streaming data from your tasks in backend code.** Consume AI completions as they generate, process file chunks, or handle any continuous data your tasks produce.
 
 <Note>
-  To learn how to emit streams from your tasks, see our [Realtime Streams](/tasks/streams) documentation. For frontend applications using React, see our [React hooks streams documentation](/realtime/react-hooks/streams).
+  To emit streams from your tasks, see [Streaming data from tasks](/tasks/streams). For React components, see [Streaming in React](/realtime/react-hooks/streams).
 </Note>
 
 ## Reading streams
diff --git a/docs/realtime/backend/subscribe.mdx b/docs/realtime/backend/subscribe.mdx
index ffa46532bf6..6148ffee6f8 100644
--- a/docs/realtime/backend/subscribe.mdx
+++ b/docs/realtime/backend/subscribe.mdx
@@ -1,10 +1,10 @@
 ---
-title: Subscribe functions
-sidebarTitle: Subscribe
-description: Subscribe to run updates using async iterators
+title: "Run updates (backend)"
+sidebarTitle: "Run updates"
+description: "Subscribe to run status changes, metadata updates, and tag changes from your backend code using async iterators."
 ---
 
-These functions allow you to subscribe to run updates from your backend code. Each function returns an async iterator that yields run objects as they change.
+**Subscribe to runs from your backend and get updates whenever status, metadata, or tags change.** Each function returns an async iterator that yields the run object on every change.
 
 ## runs.subscribeToRun
 
diff --git a/docs/realtime/how-it-works.mdx b/docs/realtime/how-it-works.mdx
index 04dd13dadad..c26a90f1f82 100644
--- a/docs/realtime/how-it-works.mdx
+++ b/docs/realtime/how-it-works.mdx
@@ -1,12 +1,14 @@
 ---
-title: How it works
-sidebarTitle: How it works
-description: Technical details about how the Trigger.dev Realtime API works
+title: "How Realtime works"
+sidebarTitle: "How it works"
+description: "Technical architecture behind Trigger.dev's real-time run updates, built on Electric SQL and PostgreSQL syncing."
 ---
 
+This page covers the infrastructure behind **run updates** (status, metadata, tags). [Streaming](/tasks/streams) uses a separate transport.
+
 ## Architecture
 
-The Realtime API is built on top of [Electric SQL](https://electric-sql.com/), an open-source PostgreSQL syncing engine. The Trigger.dev API wraps Electric SQL and provides a simple API to subscribe to [runs](/runs) and get real-time updates.
+The run updates system is built on top of [Electric SQL](https://electric-sql.com/), an open-source PostgreSQL syncing engine. The Trigger.dev API wraps Electric SQL and provides a simple API to subscribe to [runs](/runs) and get updates as they happen.
 
 ## Run changes
 
diff --git a/docs/realtime/overview.mdx b/docs/realtime/overview.mdx
index 8819c4003f8..94cd48c5b82 100644
--- a/docs/realtime/overview.mdx
+++ b/docs/realtime/overview.mdx
@@ -1,39 +1,63 @@
 ---
 title: Realtime overview
 sidebarTitle: Overview
-description: Using the Trigger.dev Realtime API to trigger and/or subscribe to runs in real-time.
+description: "Get live run updates and stream data from background tasks to your frontend or backend. No polling."
 ---
 
-Trigger.dev Realtime allows you to trigger, subscribe to, and get real-time updates for runs. This is useful for monitoring runs, updating UIs, and building real-time dashboards.
+**Realtime is the umbrella for everything live in Trigger.dev.** It covers two things: getting notified when a run's state changes, and streaming continuous data (like AI tokens) from a running task to your app.
 
-You can subscribe to real-time updates for different scopes of runs:
+Both use the same `@trigger.dev/react-hooks` package and the same authentication system. The difference is what they give you.
 
-- **Specific runs** - Monitor individual run progress by run ID
-- **Runs with specific tags** - Track all runs that have certain [tags](/tags) (e.g., all runs tagged with `user:123`)
-- **Batch runs** - All runs within a specific batch
-- **Trigger + subscribe combos** - Trigger a task and immediately subscribe to its run (frontend only)
+## Run updates vs Streaming
 
-Once subscribed, you'll receive the complete [run object](/realtime/run-object) with automatic real-time updates whenever the [run changes](/realtime/how-it-works#run-changes), including:
+| | Run updates | Streaming |
+|---|---|---|
+| **What you get** | Run state: status, metadata, tags | Continuous data you define (AI tokens, file chunks, progress) |
+| **When it fires** | On state changes | While the task runs, as data is produced |
+| **Use case** | Progress bars, status badges, dashboards | AI chat output, live logs, file processing |
+| **React hook** | [`useRealtimeRun`](/realtime/react-hooks/subscribe) | [`useRealtimeStream`](/realtime/react-hooks/streams) |
+| **Setup in task code?** | No, automatic | Yes, using `streams.define()` |
+| **Infrastructure** | [Electric SQL](/realtime/how-it-works) (PostgreSQL sync) | Streams transport |
 
-- **Status changes** - queued → executing → completed, etc.
-- **Metadata updates** - Custom progress tracking, status updates, user data, etc. ([React hooks](/realtime/react-hooks/subscribe#using-metadata-to-show-progress-in-your-ui) | [backend](/realtime/backend/subscribe#subscribe-to-metadata-updates-from-your-tasks))
-- **Tag changes** - When [tags](/tags) are added or removed from the run
-- **Realtime Streams** - Stream real-time data from your tasks, perfect for AI/LLM outputs and progress updates. ([Learn more](/tasks/streams) | [React hooks](/realtime/react-hooks/streams) | [Backend](/realtime/backend/streams))
+You can use both at the same time. Subscribe to a run's status (to show a progress bar) while also streaming AI output (to display tokens as they arrive).
 
-## Using Realtime in your applications
+## Run updates
 
-### Authentication
+Subscribe to a run and your code gets called whenever its status, [metadata](/runs/metadata), or [tags](/tags) change. No setup needed in your task code.
 
-All Realtime subscriptions require authentication so you can securely trigger and subscribe to runs. See our [authentication guide](/realtime/auth) for more details.
+You can subscribe to:
 
-### Frontend implementation
+- **Specific runs** by run ID
+- **Runs with specific tags** (e.g., all runs tagged with `user:123`)
+- **Batch runs** within a specific batch
+- **Trigger + subscribe combos** that trigger a task and immediately subscribe (frontend only)
 
-Use our React hooks to build real-time UIs that update as runs execute. Ideal for progress bars, status indicators, and live dashboards.
+→ [React hooks](/realtime/react-hooks/subscribe) | [Backend](/realtime/backend/subscribe)
 
-→ **[See our React hooks guide](/realtime/react-hooks/)**
+## Streaming
 
-### Backend implementation
+Define typed streams in your task, pipe data to them, and read that data from your frontend or backend as it's produced. You need to set up streams in your task code using `streams.define()`.
 
-Use our server-side SDK to subscribe to runs from your backend code, other tasks, or serverless functions. Perfect for triggering workflows, sending notifications, or updating databases based on run status changes.
+→ [How to emit streams from tasks](/tasks/streams) | [React hooks](/realtime/react-hooks/streams) | [Backend](/realtime/backend/streams)
 
-→ **[See our Backend guide](/realtime/backend)**
+## Authentication
+
+All Realtime hooks and functions require authentication. See the [authentication guide](/realtime/auth) for setup.
+
+## Frequently asked questions
+
+### How do I show a progress bar for a background task?
+
+Use [run metadata](/runs/metadata) to store progress data (like a percentage), then subscribe to the run with [`useRealtimeRun`](/realtime/react-hooks/subscribe). Your component re-renders on every metadata update.
+
+### How do I stream AI/LLM responses from a background task?
+
+Define a stream in your task with `streams.define()`, pipe your AI SDK response to it, then consume it in React with [`useRealtimeStream`](/realtime/react-hooks/streams). See [Streaming data from tasks](/tasks/streams) for the full guide.
+
+### Do I need WebSockets or polling?
+
+No. Run updates are powered by [Electric SQL](/realtime/how-it-works) (HTTP-based PostgreSQL syncing). Streams use their own transport. The hooks handle connections automatically.
+
+### Can I use both run updates and streaming together?
+
+Yes. A common pattern: subscribe to run status with `useRealtimeRun` (progress indicator) while streaming AI output with `useRealtimeStream` (token-by-token display).
diff --git a/docs/realtime/react-hooks/overview.mdx b/docs/realtime/react-hooks/overview.mdx
index 7cf84c63f04..6edf74ff46c 100644
--- a/docs/realtime/react-hooks/overview.mdx
+++ b/docs/realtime/react-hooks/overview.mdx
@@ -1,12 +1,12 @@
 ---
-title: React hooks overview
+title: "React hooks for real-time task updates"
 sidebarTitle: Overview
-description: Using the Trigger.dev Realtime API from your React applications.
+description: "Subscribe to background task progress, stream AI responses, and trigger tasks from React components using @trigger.dev/react-hooks."
 ---
 
 import RealtimeExamplesCards from "/snippets/realtime-examples-cards.mdx";
 
-Our React hooks package provides a set of hooks that make it easy to interact with the Trigger.dev Realtime API from your React applications. You can use these hooks to subscribe to real-time updates, and trigger tasks from your frontend.
+**`@trigger.dev/react-hooks` gives your React components live access to background tasks.** Subscribe to run progress, stream AI output as it generates, or trigger tasks directly from the browser.
 
 ## Installation
 
@@ -55,19 +55,19 @@ Learn more about [generating and managing tokens in our authentication guide](/r
 
 ## Available hooks
 
-We provide several categories of hooks:
-
-- **[Triggering hooks](/realtime/react-hooks/triggering)** - Trigger tasks from your frontend application
-- **[Subscribe hooks](/realtime/react-hooks/subscribe)** - Subscribe to runs, batches, metadata, and more
-- **[Streams hooks](/realtime/react-hooks/streams)** - Subscribe to real-time streams from your tasks
-- **[SWR hooks](/realtime/react-hooks/swr)** - Fetch data once and cache it using SWR
+| Hook category | What it does | Guide |
+|---|---|---|
+| **Trigger hooks** | Trigger tasks from the browser | [Triggering](/realtime/react-hooks/triggering) |
+| **Run updates** | Subscribe to run status, metadata, and tags | [Run updates](/realtime/react-hooks/subscribe) |
+| **Streaming** | Consume AI output, file chunks, or any continuous data | [Streaming](/realtime/react-hooks/streams) |
+| **SWR hooks** | One-time fetch with caching (not recommended for most cases) | [SWR](/realtime/react-hooks/swr) |
 
 ## SWR vs Realtime hooks
 
-We offer two "styles" of hooks: SWR and Realtime. The SWR hooks use the [swr](https://swr.vercel.app/) library to fetch data once and cache it. The Realtime hooks use [Trigger.dev Realtime](/realtime) to subscribe to updates in real-time.
+We offer two "styles" of hooks: SWR and Realtime. SWR hooks use the [swr](https://swr.vercel.app/) library to fetch data once and cache it. Realtime hooks use [Trigger.dev Realtime](/realtime) to subscribe to updates as they happen.
 
 <Note>
   It can be a little confusing which one to use because [swr](https://swr.vercel.app/) can also be
   configured to poll for updates. But because of rate-limits and the way the Trigger.dev API works,
-  we recommend using the Realtime hooks for most use-cases.
+  we recommend using the Realtime hooks for most use cases.
 </Note>
diff --git a/docs/realtime/react-hooks/streams.mdx b/docs/realtime/react-hooks/streams.mdx
index 670941e8997..c3c7031d44a 100644
--- a/docs/realtime/react-hooks/streams.mdx
+++ b/docs/realtime/react-hooks/streams.mdx
@@ -1,14 +1,13 @@
 ---
-title: Streams hooks
-sidebarTitle: Streams
-description: Subscribe to real-time streams from your tasks in React components
+title: "Stream data to React (AI, files, progress)"
+sidebarTitle: "Streaming"
+description: "Display AI/LLM output token by token, stream file chunks, or pipe any continuous data from a background task into your React components."
 ---
 
-These hooks allow you to consume real-time streams from your tasks. Streams are useful for displaying AI/LLM outputs as they're generated, or any other real-time data from your tasks.
+**Display AI responses as they generate, stream file processing results, or pipe any continuous data from a running task into your React components.** Unlike [progress and status hooks](/realtime/react-hooks/subscribe) (which track run state), streaming hooks give you the raw data your task produces while it runs.
 
 <Note>
-  To learn how to emit streams from your tasks, see our [Realtime Streams](/tasks/streams)
-  documentation.
+  To learn how to emit streams from your tasks, see [Streaming data from tasks](/tasks/streams).
 </Note>
 
 ## useRealtimeStream (Recommended)
@@ -151,7 +150,70 @@ const { parts, error } = useRealtimeStream<string>(runId, {
 });
 ```
 
-For more information on defining and using streams, see the [Realtime Streams v2](/tasks/streams) documentation.
+For more information on defining and using streams, see the [Streaming data from tasks](/tasks/streams) documentation.
+
+## useInputStreamSend
+
+The `useInputStreamSend` hook lets you send data from your frontend into a running task's [input stream](/tasks/streams#input-streams). Use it for cancel buttons, approval forms, or any UI that needs to push typed data into a running task.
+
+### Basic usage
+
+Pass the input stream's `id` (string), the run ID, and options such as `accessToken`. You typically get `runId` and `accessToken` from the object returned when you trigger the task (e.g. `handle.id`, `handle.publicAccessToken`). The hook returns `send`, `isLoading`, `error`, and `isReady`:
+
+```tsx
+"use client";
+
+import { useInputStreamSend } from "@trigger.dev/react-hooks";
+import { approval } from "@/trigger/streams";
+
+export function ApprovalForm({
+  runId,
+  accessToken,
+}: {
+  runId: string;
+  accessToken: string;
+}) {
+  const { send, isLoading, isReady } = useInputStreamSend(
+    approval.id,
+    runId,
+    { accessToken }
+  );
+
+  return (
+    <button
+      disabled={!isReady || isLoading}
+      onClick={() => send({ approved: true, reviewer: "alice" })}
+    >
+      Approve
+    </button>
+  );
+}
+```
+
+With a generic for type-safe payloads when not using a defined stream:
+
+```tsx
+type ApprovalPayload = { approved: boolean; reviewer: string };
+const { send } = useInputStreamSend<ApprovalPayload>("approval", runId, {
+  accessToken,
+});
+send({ approved: true, reviewer: "alice" });
+```
+
+### Options and return value
+
+- **`streamId`**: The input stream identifier (string). Use the `id` from your defined stream (e.g. `approval.id`) or the same string you used in `streams.input<T>({ id: "approval" })`.
+- **`runId`**: The run to send input to. When `runId` is undefined, `isReady` is false and `send` will not trigger.
+- **`options`**: `accessToken` (required for client usage), `baseURL` (optional). See [Realtime auth](/realtime/auth) for generating a public access token with the right scopes (e.g. input streams write for that run).
+
+Return value:
+
+- **`send(data)`**: Sends typed data to the input stream. Uses SWR mutation under the hood.
+- **`isLoading`**: True while a send is in progress.
+- **`error`**: Set if the last send failed.
+- **`isReady`**: True when both `runId` and access token are available.
+
+For receiving input stream data inside a task (`.wait()`, `.once()`, `.on()`), see [Input Streams](/tasks/streams#input-streams) in the Streams doc.
 
 ## useRealtimeRunWithStreams
 
@@ -367,3 +429,21 @@ export function MyComponent({
 All other options (accessToken, baseURL, enabled, id) work the same as the other realtime hooks.
 
 For the newer `useRealtimeStream` hook, use the `throttleInMs` option instead (see [options above](#options)).
+
+## Frequently asked questions
+
+### How do I stream AI/LLM responses from a background task to React?
+
+Define a typed stream in your task with `streams.define<string>()`, pipe your AI SDK response to it with `.pipe()`, then consume it in your component with `useRealtimeStream`. See [Streaming data from tasks](/tasks/streams) for the task-side setup.
+
+### What's the difference between streaming and run updates?
+
+[Run updates](/realtime/react-hooks/subscribe) track **run state** (status, metadata, tags). Streaming (this page) pipes **continuous data** your task produces. Use run updates for progress bars and status badges. Use streaming for AI chat output, live logs, or file processing results. You can use both at the same time.
+
+### Can I send data back into a running task from React?
+
+Yes. Use the `useInputStreamSend` hook to send data into a running task's input stream. This is useful for cancel buttons, user approvals, or any interactive flow. See [Input Streams](/tasks/streams#input-streams) for the full guide.
+
+### Do streams work with the Vercel AI SDK?
+
+Yes. You can pipe a Vercel AI SDK `streamText` response directly into a Trigger.dev stream using `.pipe()`. The [Streaming data from tasks](/tasks/streams) page has a complete AI streaming example.
diff --git a/docs/realtime/react-hooks/subscribe.mdx b/docs/realtime/react-hooks/subscribe.mdx
index 4cf0a79da35..84f0e8f6cde 100644
--- a/docs/realtime/react-hooks/subscribe.mdx
+++ b/docs/realtime/react-hooks/subscribe.mdx
@@ -1,21 +1,21 @@
 ---
-title: Subscribing to runs
-sidebarTitle: Subscribe
-description: Get live updates from runs, batches, metadata, and more in your frontend application.
+title: "Run updates in React"
+sidebarTitle: "Run updates"
+description: "Build progress bars, status indicators, and live dashboards by subscribing to background task updates from React components."
 ---
 
-These hooks allow you to subscribe to runs, batches, and streams using [Trigger.dev Realtime](/realtime). They automatically include real-time updates for run status, metadata, output, and other properties.
+**Subscribe to a run and your component re-renders whenever its status, metadata, or tags change.** Build progress bars, deployment monitors, or any UI that needs to reflect what a background task is doing right now.
 
-## Hooks
+For streaming continuous data (AI tokens, file chunks), see [Streaming](/realtime/react-hooks/streams) instead.
 
-## Triggering + Realtime hooks
+## Trigger + subscribe combo hooks
 
-For triggering tasks and immediately subscribing to their runs, we provide combo hooks, details on how to use them can be found in the [triggering](/realtime/react-hooks/triggering) section.
+Trigger a task and immediately subscribe to its run. Details in the [triggering](/realtime/react-hooks/triggering) section.
 
 - **[`useRealtimeTaskTrigger`](/realtime/react-hooks/triggering#userealtimetasktrigger)** - Trigger a task and subscribe to the run
 - **[`useRealtimeTaskTriggerWithStreams`](/realtime/react-hooks/triggering#userealtimetasktriggerwithstreams)** - Trigger a task and subscribe to both run updates and streams
 
-## Other Realtime subscription hooks
+## Subscribe hooks
 
 ### useRealtimeRun
 
@@ -93,6 +93,32 @@ export function MyComponent({
 }
 ```
 
+When you only need run status (for example, a progress bar or completion badge), you can omit large fields like `payload` and `output` by passing `skipColumns`. This reduces the data sent over the wire and avoids issues such as "Large HTTP Payload" warnings in tools like Sentry.
+
+```tsx
+import { useRealtimeRun } from "@trigger.dev/react-hooks";
+
+export function RunStatusBadge({
+  runId,
+  publicAccessToken,
+}: {
+  runId: string;
+  publicAccessToken: string;
+}) {
+  const { run, error } = useRealtimeRun(runId, {
+    accessToken: publicAccessToken,
+    skipColumns: ["payload", "output"],
+  });
+
+  if (error) return <span>Error</span>;
+  if (!run) return <span>Loading…</span>;
+
+  return <span>Status: {run.status}</span>;
+}
+```
+
+You can skip any of: `payload`, `output`, `metadata`, `startedAt`, `delayUntil`, `queuedAt`, `expiredAt`, `completedAt`, `number`, `isTest`, `usageDurationMs`, `costInCents`, `baseCostInCents`, `ttl`, `payloadType`, `outputType`, `runTags`, `error`. The `useRealtimeRunsWithTag` hook also accepts a `skipColumns` option in the same way.
+
 See our [run object reference](/realtime/run-object) for the complete schema and [How it Works documentation](/realtime/how-it-works) for more technical details.
 
 ### useRealtimeRunsWithTag
@@ -628,3 +654,21 @@ export function MyComponent({
 ```
 
 This allows you to change the ID of the subscription based on some state. Passing in a different ID will unsubscribe from the current subscription and subscribe to the new one (and remove any cached data).
+
+## Frequently asked questions
+
+### How do I show a progress bar for a background task in React?
+
+Use `metadata.set()` inside your task to update a progress value, then read it with `useRealtimeRun` in your component. The hook re-renders your component on every metadata change. See [Using metadata to show progress](#using-metadata-to-show-progress-in-your-ui) above for a complete example.
+
+### What's the difference between run updates and streaming?
+
+Run updates (this page) give you **run state**: status, metadata, and tags. They're for progress bars, status badges, and dashboards. [Streaming](/realtime/react-hooks/streams) gives you **continuous data** like AI tokens or file chunks. Use run updates for "how far along is my task?" and streaming for "show me the output as it generates."
+
+### Can I subscribe to multiple runs at once?
+
+Yes. Use `useRealtimeRunsWithTag` to subscribe to all runs with a specific tag (e.g., `user:123`), or `useRealtimeBatch` for all runs in a batch. Each yields an array of run objects that update in real time.
+
+### Do I need to set up polling or WebSockets?
+
+No. The hooks handle the connection automatically using Trigger.dev's Realtime infrastructure (built on [Electric SQL](/realtime/how-it-works)). Just pass a run ID and an access token.
diff --git a/docs/realtime/react-hooks/triggering.mdx b/docs/realtime/react-hooks/triggering.mdx
index 50320ccd48f..6801adb8e67 100644
--- a/docs/realtime/react-hooks/triggering.mdx
+++ b/docs/realtime/react-hooks/triggering.mdx
@@ -1,10 +1,10 @@
 ---
-title: Trigger hooks
+title: "Trigger tasks from React"
 sidebarTitle: Triggering
-description: Triggering tasks from your frontend application.
+description: "Trigger background tasks from React components and optionally subscribe to their progress or stream their output."
 ---
 
-We provide a set of hooks that can be used to trigger tasks from your frontend application.
+Trigger tasks directly from your React components. You can fire-and-forget, or trigger and immediately subscribe to the run's progress or streamed output.
 
 <Note>
   For triggering tasks from your frontend, you need to use “trigger” tokens. These can only be used
diff --git a/docs/run-usage.mdx b/docs/run-usage.mdx
index 0b9163db1ba..4c00423310f 100644
--- a/docs/run-usage.mdx
+++ b/docs/run-usage.mdx
@@ -8,6 +8,8 @@ description: "Get compute duration and cost from inside a run, or for a specific
 You can get the cost and duration of the current including retries of the same run.
 
 ```ts
+import { task, usage, wait } from "@trigger.dev/sdk";
+
 export const heavyTask = task({
   id: "heavy-task",
   machine: {
@@ -87,6 +89,8 @@ console.log("Total cost", totalCost);
 You can also wrap code with `usage.measure` to get the cost and duration of that block of code:
 
 ```ts
+import { usage, logger } from "@trigger.dev/sdk";
+
 // Inside a task run function, or inside a function that's called from there.
 const { result, compute } = await usage.measure(async () => {
   //...Do something for 1 second
diff --git a/docs/runs.mdx b/docs/runs.mdx
index 12f1cd50a9c..1c61b3ee937 100644
--- a/docs/runs.mdx
+++ b/docs/runs.mdx
@@ -161,7 +161,7 @@ await yourTask.trigger({ foo: "bar" }, { ttl: "10m" });
 
 If the run hasn't started within the specified TTL, it will automatically expire, returning the status `Expired`. This is useful for time-sensitive tasks where immediate execution is important. For example, when you queue many runs simultaneously and exceed your concurrency limits, some runs might be delayed - using TTL ensures they only execute if they can start within your specified timeframe.
 
-Note that dev runs automatically have a 10-minute TTL. In Staging and Production environments, no TTL is set by default.
+Dev runs automatically have a 10-minute TTL. On Trigger.dev Cloud, staging and production runs have a maximum TTL of 14 days applied automatically (runs without an explicit TTL get 14 days; longer TTLs are clamped). See [Limits — Maximum run TTL](/limits#maximum-run-ttl) for details.
 
 ![Run with TTL](/images/run-with-ttl.png)
 
diff --git a/docs/runs/heartbeats.mdx b/docs/runs/heartbeats.mdx
new file mode 100644
index 00000000000..b28f9fcbde7
--- /dev/null
+++ b/docs/runs/heartbeats.mdx
@@ -0,0 +1,38 @@
+---
+title: "Heartbeats"
+sidebarTitle: "Heartbeats"
+description: "Keep long-running or CPU-heavy tasks from being marked as stalled."
+---
+
+We send a heartbeat from your task to the platform every 30 seconds. If we don't receive a heartbeat within 5 minutes, we mark the run as stalled and stop it with a `TASK_RUN_STALLED_EXECUTING` error.
+
+Code that blocks the event loop for too long (for example, a tight loop doing synchronous work on a large dataset) can prevent heartbeats from being sent. In that case, use `heartbeats.yield()` inside the loop so the runtime can yield to the event loop and send a heartbeat. You can call it every iteration; the implementation only yields when needed.
+
+```ts
+import { task, heartbeats } from "@trigger.dev/sdk";
+
+export const processLargeDataset = task({
+  id: "process-large-dataset",
+  run: async (payload: { items: string[] }) => {
+    for (const row of payload.items) {
+      await heartbeats.yield();
+      processRow(row);
+    }
+    return { processed: payload.items.length };
+  },
+});
+
+function processRow(row: string) {
+  // synchronous CPU-heavy work
+}
+```
+
+If you see `TASK_RUN_STALLED_EXECUTING`, see [Task run stalled executing](/troubleshooting#task-run-stalled-executing) in the troubleshooting guide.
+
+## Sending progress to Trigger.dev
+
+To stream progress or status updates to the dashboard and your app, use [run metadata](/runs/metadata). Call `metadata.set()` (or `metadata.append()`) as the task runs. The dashboard and [Realtime](/realtime) (including `runs.subscribeToRun` and the React hooks) receive those updates as they happen. See [Progress monitoring](/realtime/backend/subscribe#progress-monitoring) for a full example.
+
+## Sending updates to your own system
+
+Trigger.dev doesn’t push run updates to external services. To send progress or heartbeats to your own backend (for example Supabase Realtime), call your API or client from inside the task when you want to emit an update—e.g. in the same loop where you call `heartbeats.yield()` or `metadata.set()`. Use whatever your stack supports: HTTP, the Supabase client, or another SDK.
diff --git a/docs/runs/metadata.mdx b/docs/runs/metadata.mdx
index d0dff36758c..4e6f01369c7 100644
--- a/docs/runs/metadata.mdx
+++ b/docs/runs/metadata.mdx
@@ -1,10 +1,12 @@
 ---
 title: "Run metadata"
 sidebarTitle: "Metadata"
-description: "Attach a small amount of data to a run and update it as the run progresses."
+description: "Attach structured data to a run and update it as the task progresses. Use metadata for progress tracking, user context, intermediate results, and more."
 ---
 
-You can attach up to 256KB of metadata to a run, which you can then access from inside the run function, via the API, Realtime, and in the dashboard. You can use metadata to store additional, structured information on a run. For example, you could store your user’s full name and corresponding unique identifier from your system on every task that is associated with that user. Or you could store the progress of a long-running task, or intermediate results that you want to access later.
+**Metadata lets you attach up to 256KB of structured data to a run and update it while the task runs.** Subscribers (via [React hooks](/realtime/react-hooks/subscribe) or [backend](/realtime/backend/subscribe)) get those updates in real time, making metadata the simplest way to build progress bars, status indicators, and live dashboards.
+
+You can access metadata from inside the run function, via the API, Realtime, and in the dashboard. Common uses: progress percentage, current step, user context, intermediate results.
 
 ## Usage
 
diff --git a/docs/self-hosting/docker.mdx b/docs/self-hosting/docker.mdx
index b0834d35fff..df9ae246c2d 100644
--- a/docs/self-hosting/docker.mdx
+++ b/docs/self-hosting/docker.mdx
@@ -184,6 +184,30 @@ docker compose down
 docker compose up -d
 ```
 
+### Creating additional worker groups
+
+To create additional worker groups beyond the bootstrap group, use the admin API endpoint. This requires admin privileges.
+
+**Making a user admin:**
+- **New users**: Set `ADMIN_EMAILS` environment variable (regex pattern) before user creation.
+- **Existing users**: Set `admin = true` in the `user` table in your database.
+
+**Creating a worker group:**
+
+```bash
+api_url=http://localhost:8030
+wg_name=my-worker
+admin_pat=tr_pat_...
+
+curl -X POST \
+  "$api_url/admin/api/v1/workers" \
+  -H "Authorization: Bearer $admin_pat" \
+  -H "Content-Type: application/json" \
+  -d "{\"name\": \"$wg_name\"}"
+```
+
+The response includes a `token` field if the worker group is newly created.
+
 ## Registry setup
 
 The registry is used to store and pull deployment images. When testing the stack locally, the defaults should work out of the box.
@@ -330,6 +354,14 @@ TRIGGER_IMAGE_TAG=v4.0.0
   docker compose logs -f webapp
   ```
 
+- **Deploy fails with `ERROR: schema "graphile_worker" does not exist`.** This error occurs when Graphile Worker migrations fail to run during webapp startup. Check the webapp logs for certificate-related errors like `self-signed certificate in certificate chain`. This is often caused by PostgreSQL SSL certificate issues when using an external PostgreSQL instance with SSL enabled. Ensure that both the webapp and supervisor containers have access to the same CA certificate used by your PostgreSQL instance. You can configure this by mounting the certificate file and setting the `NODE_EXTRA_CA_CERTS` environment variable to point to the certificate path. Once the certificate issue is resolved, the migrations will complete and create the required `graphile_worker` schema.
+
+- **ClickHouse migrations say "no migrations to run" but schema is missing.** The goose migration tracker is out of sync. Exec into the webapp container, set the GOOSE env vars (from webapp startup logs), and run `goose reset && goose up`.
+
+  <Warning>
+    **Data Loss Warning:** The `goose reset` command is destructive and will drop the entire schema. Make sure to backup your data and confirm you are running this in a non-production environment before executing this command.
+  </Warning>
+
 ## CLI usage
 
 This section highlights some of the CLI commands and options that are useful when self-hosting. Please check the [CLI reference](/cli-introduction) for more in-depth documentation.
diff --git a/docs/self-hosting/env/webapp.mdx b/docs/self-hosting/env/webapp.mdx
index 49e561179bd..16a54e0f9b9 100644
--- a/docs/self-hosting/env/webapp.mdx
+++ b/docs/self-hosting/env/webapp.mdx
@@ -5,140 +5,251 @@ sidebarTitle: "Webapp"
 mode: "wide"
 ---
 
-| Name                                             | Required | Default               | Description                                                                                               |
-| :----------------------------------------------- | :------- | :-------------------- | :-------------------------------------------------------------------------------------------------------- |
-| **Secrets**                                      |          |                       |                                                                                                           |
-| `SESSION_SECRET`                                 | Yes      | —                     | Session encryption secret. Run: `openssl rand -hex 16`                                                    |
-| `MAGIC_LINK_SECRET`                              | Yes      | —                     | Magic link encryption secret. Run: `openssl rand -hex 16`                                                 |
-| `ENCRYPTION_KEY`                                 | Yes      | —                     | Secret store encryption key. Run: `openssl rand -hex 16`                                                  |
-| `MANAGED_WORKER_SECRET`                          | No       | managed-secret        | Managed worker secret. Should be changed and match supervisor.                                            |
-| **Domains & ports**                              |          |                       |                                                                                                           |
-| `REMIX_APP_PORT`                                 | No       | 3030                  | Remix app port.                                                                                           |
-| `APP_ORIGIN`                                     | Yes      | http://localhost:3030 | App origin URL.                                                                                           |
-| `LOGIN_ORIGIN`                                   | Yes      | http://localhost:3030 | Login origin URL. Most likely the same as `APP_ORIGIN`.                                                   |
-| `API_ORIGIN`                                     | No       | `APP_ORIGIN`          | API origin URL.                                                                                           |
-| `STREAM_ORIGIN`                                  | No       | `APP_ORIGIN`          | Realtime stream origin URL.                                                                               |
-| `ELECTRIC_ORIGIN`                                | No       | http://localhost:3060 | Electric origin URL.                                                                                      |
-| **Postgres**                                     |          |                       |                                                                                                           |
-| `DATABASE_URL`                                   | Yes      | —                     | PostgreSQL connection string.                                                                             |
-| `DIRECT_URL`                                     | Yes      | —                     | Direct DB connection string used for migrations etc.                                                      |
-| `DATABASE_CONNECTION_LIMIT`                      | No       | 10                    | Max DB connections.                                                                                       |
-| `DATABASE_POOL_TIMEOUT`                          | No       | 60                    | DB pool timeout (s).                                                                                      |
-| `DATABASE_CONNECTION_TIMEOUT`                    | No       | 20                    | DB connect timeout (s).                                                                                   |
-| `DATABASE_READ_REPLICA_URL`                      | No       | `DATABASE_URL`        | Read-replica DB string.                                                                                   |
-| **Redis**                                        |          |                       |                                                                                                           |
-| `REDIS_HOST`                                     | Yes      | —                     | Redis host.                                                                                               |
-| `REDIS_PORT`                                     | Yes      | —                     | Redis port.                                                                                               |
-| `REDIS_READER_HOST`                              | No       | `REDIS_HOST`          | Redis reader host.                                                                                        |
-| `REDIS_READER_PORT`                              | No       | `REDIS_PORT`          | Redis reader port.                                                                                        |
-| `REDIS_USERNAME`                                 | No       | —                     | Redis username.                                                                                           |
-| `REDIS_PASSWORD`                                 | No       | —                     | Redis password.                                                                                           |
-| `REDIS_TLS_DISABLED`                             | No       | —                     | Disable Redis TLS.                                                                                        |
-| **Auth**                                         |          |                       |                                                                                                           |
-| `WHITELISTED_EMAILS`                             | No       | —                     | Whitelisted emails regex.                                                                                 |
-| `AUTH_GITHUB_CLIENT_ID`                          | No       | —                     | GitHub client ID.                                                                                         |
-| `AUTH_GITHUB_CLIENT_SECRET`                      | No       | —                     | GitHub client secret.                                                                                     |
-| **Email**                                        |          |                       |                                                                                                           |
-| `EMAIL_TRANSPORT`                                | No       | —                     | Email transport type. One of `resend`, `smtp`, `aws-ses`.                                                 |
-| `FROM_EMAIL`                                     | No       | —                     | From email address.                                                                                       |
-| `REPLY_TO_EMAIL`                                 | No       | —                     | Reply-to email address.                                                                                   |
-| `RESEND_API_KEY`                                 | No       | —                     | Resend API key.                                                                                           |
-| `SMTP_HOST`                                      | No       | —                     | SMTP host.                                                                                                |
-| `SMTP_PORT`                                      | No       | —                     | SMTP port.                                                                                                |
-| `SMTP_SECURE`                                    | No       | —                     | SMTP secure flag.                                                                                         |
-| `SMTP_USER`                                      | No       | —                     | SMTP user.                                                                                                |
-| `SMTP_PASSWORD`                                  | No       | —                     | SMTP password.                                                                                            |
-| `AWS_REGION`                                     | No       | —                     | AWS region for SES.                                                                                       |
-| `AWS_ACCESS_KEY_ID`                              | No       | —                     | AWS access key ID for SES.                                                                                |
-| `AWS_SECRET_ACCESS_KEY`                          | No       | —                     | AWS secret access key for SES.                                                                            |
-| **Graphile & Redis worker**                      |          |                       |                                                                                                           |
-| `WORKER_CONCURRENCY`                             | No       | 10                    | Redis worker concurrency.                                                                                 |
-| `WORKER_POLL_INTERVAL`                           | No       | 1000                  | Redis worker poll interval (ms).                                                                          |
-| `WORKER_SCHEMA`                                  | No       | graphile_worker       | Graphile worker schema.                                                                                   |
-| `GRACEFUL_SHUTDOWN_TIMEOUT`                      | No       | 60000 (1m)            | Graphile graceful shutdown timeout (ms). Affects shutdown time.                                           |
-| **Concurrency limits**                           |          |                       |                                                                                                           |
-| `DEFAULT_ENV_EXECUTION_CONCURRENCY_LIMIT`        | No       | 100                   | Default env execution concurrency.                                                                        |
-| `DEFAULT_ORG_EXECUTION_CONCURRENCY_LIMIT`        | No       | 300                   | Default org execution concurrency, needs to be 3x env concurrency.                                        |
-| **Dev**                                          |          |                       |                                                                                                           |
-| `DEV_MAX_CONCURRENT_RUNS`                        | No       | 25                    | Sets the max concurrency for dev runs via the CLI.                                                        |
-| `DEV_OTEL_EXPORTER_OTLP_ENDPOINT`                | No       | `APP_ORIGIN/otel`     | OTel endpoint for dev runs.                                                                               |
-| **Rate limiting**                                |          |                       |                                                                                                           |
-| `API_RATE_LIMIT_REFILL_INTERVAL`                 | No       | 10s                   | API rate limit refill interval.                                                                           |
-| `API_RATE_LIMIT_MAX`                             | No       | 750                   | API rate limit max.                                                                                       |
-| `API_RATE_LIMIT_REFILL_RATE`                     | No       | 250                   | API rate limit refill rate.                                                                               |
-| `API_RATE_LIMIT_REQUEST_LOGS_ENABLED`            | No       | 0                     | API rate limit request logs.                                                                              |
-| `API_RATE_LIMIT_REJECTION_LOGS_ENABLED`          | No       | 1                     | API rate limit rejection logs.                                                                            |
-| `API_RATE_LIMIT_LIMITER_LOGS_ENABLED`            | No       | 0                     | API rate limit limiter logs.                                                                              |
-| `API_RATE_LIMIT_JWT_WINDOW`                      | No       | 1m                    | API rate limit JWT window.                                                                                |
-| `API_RATE_LIMIT_JWT_TOKENS`                      | No       | 60                    | API rate limit JWT tokens.                                                                                |
-| **Deploy & Registry**                            |          |                       |                                                                                                           |
-| `DEPLOY_REGISTRY_HOST`                           | Yes      | —                     | Deploy registry host.                                                                                     |
-| `DEPLOY_REGISTRY_USERNAME`                       | No       | —                     | Deploy registry username.                                                                                 |
-| `DEPLOY_REGISTRY_PASSWORD`                       | No       | —                     | Deploy registry password.                                                                                 |
-| `DEPLOY_REGISTRY_NAMESPACE`                      | No       | trigger               | Deploy registry namespace.                                                                                |
-| `DEPLOY_IMAGE_PLATFORM`                          | No       | linux/amd64           | Deploy image platform, same values as docker `--platform` flag.                                           |
-| `DEPLOY_TIMEOUT_MS`                              | No       | 480000 (8m)           | Deploy timeout (ms).                                                                                      |
-| **Object store (S3)**                            |          |                       |                                                                                                           |
-| `OBJECT_STORE_BASE_URL`                          | No       | —                     | Object store base URL.                                                                                    |
-| `OBJECT_STORE_ACCESS_KEY_ID`                     | No       | —                     | Object store access key.                                                                                  |
-| `OBJECT_STORE_SECRET_ACCESS_KEY`                 | No       | —                     | Object store secret key.                                                                                  |
-| `OBJECT_STORE_REGION`                            | No       | —                     | Object store region.                                                                                      |
-| `OBJECT_STORE_SERVICE`                           | No       | s3                    | Object store service.                                                                                     |
-| **Alerts**                                       |          |                       |                                                                                                           |
-| `ORG_SLACK_INTEGRATION_CLIENT_ID`                | No       | —                     | Slack client ID. Required for Slack alerts.                                                               |
-| `ORG_SLACK_INTEGRATION_CLIENT_SECRET`            | No       | —                     | Slack client secret. Required for Slack alerts.                                                           |
-| `ALERT_EMAIL_TRANSPORT`                          | No       | —                     | Alert email transport.                                                                                    |
-| `ALERT_FROM_EMAIL`                               | No       | —                     | Alert from email.                                                                                         |
-| `ALERT_REPLY_TO_EMAIL`                           | No       | —                     | Alert reply-to email.                                                                                     |
-| `ALERT_RESEND_API_KEY`                           | No       | —                     | Alert Resend API key.                                                                                     |
-| `ALERT_SMTP_HOST`                                | No       | —                     | Alert SMTP host.                                                                                          |
-| `ALERT_SMTP_PORT`                                | No       | —                     | Alert SMTP port.                                                                                          |
-| `ALERT_SMTP_SECURE`                              | No       | —                     | Alert SMTP secure.                                                                                        |
-| `ALERT_SMTP_USER`                                | No       | —                     | Alert SMTP user.                                                                                          |
-| `ALERT_SMTP_PASSWORD`                            | No       | —                     | Alert SMTP password.                                                                                      |
-| **Limits**                                       |          |                       |                                                                                                           |
-| `TASK_PAYLOAD_OFFLOAD_THRESHOLD`                 | No       | 524288 (512KB)        | Max task payload size before offloading to S3.                                                            |
-| `TASK_PAYLOAD_MAXIMUM_SIZE`                      | No       | 3145728 (3MB)         | Max task payload size.                                                                                    |
-| `BATCH_TASK_PAYLOAD_MAXIMUM_SIZE`                | No       | 1000000 (1MB)         | Max batch payload size.                                                                                   |
-| `TASK_RUN_METADATA_MAXIMUM_SIZE`                 | No       | 262144 (256KB)        | Max metadata size.                                                                                        |
-| `MAX_BATCH_V2_TRIGGER_ITEMS`                     | No       | 500                   | Max batch size.                                                                                           |
-| `MAXIMUM_DEV_QUEUE_SIZE`                         | No       | —                     | Max dev queue size.                                                                                       |
-| `MAXIMUM_DEPLOYED_QUEUE_SIZE`                    | No       | —                     | Max deployed queue size.                                                                                  |
-| **OTel limits**                                  |          |                       |                                                                                                           |
-| `TRIGGER_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`        | No       | 1024                  | OTel span attribute count limit.                                                                          |
-| `TRIGGER_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT`         | No       | 1024                  | OTel log attribute count limit.                                                                           |
-| `TRIGGER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` | No       | 131072                | OTel span attribute value length limit.                                                                   |
-| `TRIGGER_OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT`  | No       | 131072                | OTel log attribute value length limit.                                                                    |
-| `TRIGGER_OTEL_SPAN_EVENT_COUNT_LIMIT`            | No       | 10                    | OTel span event count limit.                                                                              |
-| `TRIGGER_OTEL_LINK_COUNT_LIMIT`                  | No       | 2                     | OTel link count limit.                                                                                    |
-| `TRIGGER_OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT`    | No       | 10                    | OTel attribute per link count limit.                                                                      |
-| `TRIGGER_OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT`   | No       | 10                    | OTel attribute per event count limit.                                                                     |
-| `SERVER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT`  | No       | 8192                  | OTel span attribute value length limit.                                                                   |
-| **Realtime**                                     |          |                       |                                                                                                           |
-| `REALTIME_STREAM_MAX_LENGTH`                     | No       | 1000                  | Realtime stream max length.                                                                               |
-| `REALTIME_STREAM_TTL`                            | No       | 86400 (1d)            | Realtime stream TTL (s).                                                                                  |
-| **Bootstrap**                                    |          |                       |                                                                                                           |
-| `TRIGGER_BOOTSTRAP_ENABLED`                      | No       | 0                     | Trigger bootstrap enabled.                                                                                |
-| `TRIGGER_BOOTSTRAP_WORKER_GROUP_NAME`            | No       | —                     | Trigger bootstrap worker group name.                                                                      |
-| `TRIGGER_BOOTSTRAP_WORKER_TOKEN_PATH`            | No       | —                     | Trigger bootstrap worker token path.                                                                      |
-| **Run engine**                                   |          |                       |                                                                                                           |
-| `RUN_ENGINE_WORKER_COUNT`                        | No       | 4                     | Run engine worker count.                                                                                  |
-| `RUN_ENGINE_TASKS_PER_WORKER`                    | No       | 10                    | Run engine tasks per worker.                                                                              |
-| `RUN_ENGINE_WORKER_CONCURRENCY_LIMIT`            | No       | 10                    | Run engine worker concurrency limit.                                                                      |
-| `RUN_ENGINE_WORKER_POLL_INTERVAL`                | No       | 100                   | Run engine worker poll interval (ms).                                                                     |
-| `RUN_ENGINE_WORKER_IMMEDIATE_POLL_INTERVAL`      | No       | 100                   | Run engine worker immediate poll interval (ms).                                                           |
-| `RUN_ENGINE_WORKER_SHUTDOWN_TIMEOUT_MS`          | No       | 60000 (1m)            | Run engine worker shutdown timeout (ms).                                                                  |
-| `RUN_ENGINE_RATE_LIMIT_REFILL_INTERVAL`          | No       | 10s                   | Run engine rate limit refill interval.                                                                    |
-| `RUN_ENGINE_RATE_LIMIT_MAX`                      | No       | 1200                  | Run engine rate limit max.                                                                                |
-| `RUN_ENGINE_RATE_LIMIT_REFILL_RATE`              | No       | 400                   | Run engine rate limit refill rate.                                                                        |
-| `RUN_ENGINE_RATE_LIMIT_REQUEST_LOGS_ENABLED`     | No       | 0                     | Run engine rate limit request logs.                                                                       |
-| `RUN_ENGINE_RATE_LIMIT_REJECTION_LOGS_ENABLED`   | No       | 1                     | Run engine rate limit rejection logs.                                                                     |
-| `RUN_ENGINE_RATE_LIMIT_LIMITER_LOGS_ENABLED`     | No       | 0                     | Run engine rate limit limiter logs.                                                                       |
-| **Misc**                                         |          |                       |                                                                                                           |
-| `TRIGGER_TELEMETRY_DISABLED`                     | No       | —                     | Disable telemetry.                                                                                        |
-| `NODE_MAX_OLD_SPACE_SIZE`                        | No       | 8192                  | Maximum memory allocation for Node.js heap in MiB (e.g. "4096" for 4GB).                                  |
-| `OPENAI_API_KEY`                                 | No       | —                     | OpenAI API key.                                                                                           |
-| `MACHINE_PRESETS_OVERRIDE_PATH`                  | No       | —                     | Path to machine presets override file. See [machine overrides](/self-hosting/overview#machine-overrides). |
-| `APP_ENV`                                        | No       | `NODE_ENV`            | App environment. Used for things like the title tag.                                                      |
-| `ADMIN_EMAILS`                                   | No       | —                     | Regex of user emails to automatically promote to admin.                                                   |
-| `EVENT_LOOP_MONITOR_ENABLED`                     | No       | 1                     | Node.js event loop lag monitor.                                                                           |
\ No newline at end of file
+| Name                                             | Required | Default               | Description                                                                                                        |
+| :----------------------------------------------- | :------- | :-------------------- | :----------------------------------------------------------------------------------------------------------------- |
+| **Secrets**                                      |          |                       |                                                                                                                    |
+| `SESSION_SECRET`                                 | Yes      | —                     | Session encryption secret. Run: `openssl rand -hex 16`                                                             |
+| `MAGIC_LINK_SECRET`                              | Yes      | —                     | Magic link encryption secret. Run: `openssl rand -hex 16`                                                          |
+| `ENCRYPTION_KEY`                                 | Yes      | —                     | Secret store encryption key. Run: `openssl rand -hex 16`                                                           |
+| `MANAGED_WORKER_SECRET`                          | No       | managed-secret        | Managed worker secret. Should be changed and match supervisor.                                                     |
+| **Domains & ports**                              |          |                       |                                                                                                                    |
+| `REMIX_APP_PORT`                                 | No       | 3030                  | Remix app port.                                                                                                    |
+| `APP_ORIGIN`                                     | Yes      | http://localhost:3030 | App origin URL.                                                                                                    |
+| `LOGIN_ORIGIN`                                   | Yes      | http://localhost:3030 | Login origin URL. Most likely the same as `APP_ORIGIN`.                                                            |
+| `API_ORIGIN`                                     | No       | `APP_ORIGIN`          | API origin URL.                                                                                                    |
+| `STREAM_ORIGIN`                                  | No       | `APP_ORIGIN`          | Realtime stream origin URL.                                                                                        |
+| `ELECTRIC_ORIGIN`                                | No       | http://localhost:3060 | Electric origin URL.                                                                                               |
+| **Postgres**                                     |          |                       |                                                                                                                    |
+| `DATABASE_URL`                                   | Yes      | —                     | PostgreSQL connection string.                                                                                      |
+| `DIRECT_URL`                                     | Yes      | —                     | Direct DB connection string used for migrations etc.                                                               |
+| `DATABASE_CONNECTION_LIMIT`                      | No       | 10                    | Max DB connections.                                                                                                |
+| `DATABASE_POOL_TIMEOUT`                          | No       | 60                    | DB pool timeout (s).                                                                                               |
+| `DATABASE_CONNECTION_TIMEOUT`                    | No       | 20                    | DB connect timeout (s).                                                                                            |
+| `DATABASE_READ_REPLICA_URL`                      | No       | `DATABASE_URL`        | Read-replica DB string.                                                                                            |
+| **Redis**                                        |          |                       |                                                                                                                    |
+| `REDIS_HOST`                                     | Yes      | —                     | Redis host.                                                                                                        |
+| `REDIS_PORT`                                     | Yes      | —                     | Redis port.                                                                                                        |
+| `REDIS_READER_HOST`                              | No       | `REDIS_HOST`          | Redis reader host.                                                                                                 |
+| `REDIS_READER_PORT`                              | No       | `REDIS_PORT`          | Redis reader port.                                                                                                 |
+| `REDIS_USERNAME`                                 | No       | —                     | Redis username.                                                                                                    |
+| `REDIS_PASSWORD`                                 | No       | —                     | Redis password.                                                                                                    |
+| `REDIS_TLS_DISABLED`                             | No       | —                     | Disable Redis TLS.                                                                                                 |
+| **Auth**                                         |          |                       |                                                                                                                    |
+| `WHITELISTED_EMAILS`                             | No       | —                     | Whitelisted emails regex.                                                                                          |
+| `AUTH_GITHUB_CLIENT_ID`                          | No       | —                     | GitHub client ID.                                                                                                  |
+| `AUTH_GITHUB_CLIENT_SECRET`                      | No       | —                     | GitHub client secret.                                                                                              |
+| **Email**                                        |          |                       |                                                                                                                    |
+| `EMAIL_TRANSPORT`                                | No       | —                     | Email transport type. One of `resend`, `smtp`, `aws-ses`.                                                          |
+| `FROM_EMAIL`                                     | No       | —                     | From email address.                                                                                                |
+| `REPLY_TO_EMAIL`                                 | No       | —                     | Reply-to email address.                                                                                            |
+| `RESEND_API_KEY`                                 | No       | —                     | Resend API key.                                                                                                    |
+| `SMTP_HOST`                                      | No       | —                     | SMTP host.                                                                                                         |
+| `SMTP_PORT`                                      | No       | —                     | SMTP port.                                                                                                         |
+| `SMTP_SECURE`                                    | No       | —                     | SMTP secure flag.                                                                                                  |
+| `SMTP_USER`                                      | No       | —                     | SMTP user.                                                                                                         |
+| `SMTP_PASSWORD`                                  | No       | —                     | SMTP password.                                                                                                     |
+| `AWS_REGION`                                     | No       | —                     | AWS region for SES.                                                                                                |
+| `AWS_ACCESS_KEY_ID`                              | No       | —                     | AWS access key ID for SES.                                                                                         |
+| `AWS_SECRET_ACCESS_KEY`                          | No       | —                     | AWS secret access key for SES.                                                                                     |
+| **Graphile & Redis worker**                      |          |                       |                                                                                                                    |
+| `WORKER_CONCURRENCY`                             | No       | 10                    | Redis worker concurrency.                                                                                          |
+| `WORKER_POLL_INTERVAL`                           | No       | 1000                  | Redis worker poll interval (ms).                                                                                   |
+| `WORKER_SCHEMA`                                  | No       | graphile_worker       | Graphile worker schema.                                                                                            |
+| `GRACEFUL_SHUTDOWN_TIMEOUT`                      | No       | 60000 (1m)            | Graphile graceful shutdown timeout (ms). Affects shutdown time.                                                    |
+| **Concurrency limits**                           |          |                       |                                                                                                                    |
+| `DEFAULT_ENV_EXECUTION_CONCURRENCY_LIMIT`        | No       | 100                   | Default env execution concurrency.                                                                                 |
+| `DEFAULT_ORG_EXECUTION_CONCURRENCY_LIMIT`        | No       | 300                   | Default org execution concurrency, needs to be 3x env concurrency.                                                 |
+| **Dev**                                          |          |                       |                                                                                                                    |
+| `DEV_MAX_CONCURRENT_RUNS`                        | No       | 25                    | Sets the max concurrency for dev runs via the CLI.                                                                 |
+| `DEV_OTEL_EXPORTER_OTLP_ENDPOINT`                | No       | `APP_ORIGIN/otel`     | OTel endpoint for dev runs.                                                                                        |
+| **Rate limiting**                                |          |                       |                                                                                                                    |
+| `API_RATE_LIMIT_REFILL_INTERVAL`                 | No       | 10s                   | API rate limit refill interval.                                                                                    |
+| `API_RATE_LIMIT_MAX`                             | No       | 750                   | API rate limit max.                                                                                                |
+| `API_RATE_LIMIT_REFILL_RATE`                     | No       | 250                   | API rate limit refill rate.                                                                                        |
+| `API_RATE_LIMIT_REQUEST_LOGS_ENABLED`            | No       | 0                     | API rate limit request logs.                                                                                       |
+| `API_RATE_LIMIT_REJECTION_LOGS_ENABLED`          | No       | 1                     | API rate limit rejection logs.                                                                                     |
+| `API_RATE_LIMIT_LIMITER_LOGS_ENABLED`            | No       | 0                     | API rate limit limiter logs.                                                                                       |
+| `API_RATE_LIMIT_JWT_WINDOW`                      | No       | 1m                    | API rate limit JWT window.                                                                                         |
+| `API_RATE_LIMIT_JWT_TOKENS`                      | No       | 60                    | API rate limit JWT tokens.                                                                                         |
+| **Deploy & Registry**                            |          |                       |                                                                                                                    |
+| `DEPLOY_REGISTRY_HOST`                           | Yes      | —                     | Deploy registry host.                                                                                              |
+| `DEPLOY_REGISTRY_USERNAME`                       | No       | —                     | Deploy registry username.                                                                                          |
+| `DEPLOY_REGISTRY_PASSWORD`                       | No       | —                     | Deploy registry password.                                                                                          |
+| `DEPLOY_REGISTRY_NAMESPACE`                      | No       | trigger               | Deploy registry namespace.                                                                                         |
+| `DEPLOY_IMAGE_PLATFORM`                          | No       | linux/amd64           | Deploy image platform, same values as docker `--platform` flag.                                                    |
+| `DEPLOY_TIMEOUT_MS`                              | No       | 480000 (8m)           | Deploy timeout (ms).                                                                                               |
+| **Object store (S3)**                            |          |                       |                                                                                                                    |
+| `OBJECT_STORE_BASE_URL`                          | No       | —                     | Object store base URL (default provider).                                                                          |
+| `OBJECT_STORE_ACCESS_KEY_ID`                     | No       | —                     | Object store access key (default provider).                                                                        |
+| `OBJECT_STORE_SECRET_ACCESS_KEY`                 | No       | —                     | Object store secret key (default provider).                                                                        |
+| `OBJECT_STORE_REGION`                            | No       | —                     | Object store region (default provider).                                                                            |
+| `OBJECT_STORE_SERVICE`                           | No       | s3                    | Object store service (default provider).                                                                           |
+| `OBJECT_STORE_DEFAULT_PROTOCOL`                  | No       | —                     | Protocol to use for new uploads (e.g., `s3`, `r2`). Enables protocol-prefixed storage. See migration guide below.  |
+| `OBJECT_STORE_{PROTOCOL}_BASE_URL`               | No       | —                     | Named provider base URL (replace `{PROTOCOL}` with protocol name, e.g., `OBJECT_STORE_S3_BASE_URL`).               |
+| `OBJECT_STORE_{PROTOCOL}_ACCESS_KEY_ID`          | No       | —                     | Named provider access key.                                                                                         |
+| `OBJECT_STORE_{PROTOCOL}_SECRET_ACCESS_KEY`      | No       | —                     | Named provider secret key.                                                                                         |
+| `OBJECT_STORE_{PROTOCOL}_REGION`                 | No       | —                     | Named provider region.                                                                                             |
+| `OBJECT_STORE_{PROTOCOL}_SERVICE`                | No       | —                     | Named provider service.                                                                                            |
+| **Alerts**                                       |          |                       |                                                                                                                    |
+| `ORG_SLACK_INTEGRATION_CLIENT_ID`                | No       | —                     | Slack client ID. Required for Slack alerts.                                                                        |
+| `ORG_SLACK_INTEGRATION_CLIENT_SECRET`            | No       | —                     | Slack client secret. Required for Slack alerts.                                                                    |
+| `ALERT_EMAIL_TRANSPORT`                          | No       | —                     | Alert email transport.                                                                                             |
+| `ALERT_FROM_EMAIL`                               | No       | —                     | Alert from email.                                                                                                  |
+| `ALERT_REPLY_TO_EMAIL`                           | No       | —                     | Alert reply-to email.                                                                                              |
+| `ALERT_RESEND_API_KEY`                           | No       | —                     | Alert Resend API key.                                                                                              |
+| `ALERT_SMTP_HOST`                                | No       | —                     | Alert SMTP host.                                                                                                   |
+| `ALERT_SMTP_PORT`                                | No       | —                     | Alert SMTP port.                                                                                                   |
+| `ALERT_SMTP_SECURE`                              | No       | —                     | Alert SMTP secure.                                                                                                 |
+| `ALERT_SMTP_USER`                                | No       | —                     | Alert SMTP user.                                                                                                   |
+| `ALERT_SMTP_PASSWORD`                            | No       | —                     | Alert SMTP password.                                                                                               |
+| **Limits**                                       |          |                       |                                                                                                                    |
+| `TASK_PAYLOAD_OFFLOAD_THRESHOLD`                 | No       | 524288 (512KB)        | Max task payload size before offloading to S3.                                                                     |
+| `TASK_PAYLOAD_MAXIMUM_SIZE`                      | No       | 3145728 (3MB)         | Max task payload size.                                                                                             |
+| `BATCH_TASK_PAYLOAD_MAXIMUM_SIZE`                | No       | 1000000 (1MB)         | Max batch payload size.                                                                                            |
+| `TASK_RUN_METADATA_MAXIMUM_SIZE`                 | No       | 262144 (256KB)        | Max metadata size.                                                                                                 |
+| `MAX_BATCH_V2_TRIGGER_ITEMS`                     | No       | 500                   | Max batch size (legacy v2 API).                                                                                    |
+| `STREAMING_BATCH_MAX_ITEMS`                      | No       | 1000                  | Max items in streaming batch (v3 API, requires SDK 4.3.1+).                                                        |
+| `STREAMING_BATCH_ITEM_MAXIMUM_SIZE`              | No       | 3145728 (3MB)         | Max size per item in streaming batch.                                                                              |
+| `MAXIMUM_DEV_QUEUE_SIZE`                         | No       | —                     | Max dev queue size.                                                                                                |
+| `MAXIMUM_DEPLOYED_QUEUE_SIZE`                    | No       | —                     | Max deployed queue size.                                                                                           |
+| **OTel limits**                                  |          |                       |                                                                                                                    |
+| `TRIGGER_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`        | No       | 1024                  | OTel span attribute count limit.                                                                                   |
+| `TRIGGER_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT`         | No       | 1024                  | OTel log attribute count limit.                                                                                    |
+| `TRIGGER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` | No       | 131072                | OTel span attribute value length limit.                                                                            |
+| `TRIGGER_OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT`  | No       | 131072                | OTel log attribute value length limit.                                                                             |
+| `TRIGGER_OTEL_SPAN_EVENT_COUNT_LIMIT`            | No       | 10                    | OTel span event count limit.                                                                                       |
+| `TRIGGER_OTEL_LINK_COUNT_LIMIT`                  | No       | 2                     | OTel link count limit.                                                                                             |
+| `TRIGGER_OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT`    | No       | 10                    | OTel attribute per link count limit.                                                                               |
+| `TRIGGER_OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT`   | No       | 10                    | OTel attribute per event count limit.                                                                              |
+| `SERVER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT`  | No       | 8192                  | OTel span attribute value length limit.                                                                            |
+| **Realtime**                                     |          |                       |                                                                                                                    |
+| `REALTIME_STREAM_MAX_LENGTH`                     | No       | 1000                  | Realtime stream max length.                                                                                        |
+| `REALTIME_STREAM_TTL`                            | No       | 86400 (1d)            | Realtime stream TTL (s).                                                                                           |
+| **Bootstrap**                                    |          |                       |                                                                                                                    |
+| `TRIGGER_BOOTSTRAP_ENABLED`                      | No       | 0                     | Trigger bootstrap enabled.                                                                                         |
+| `TRIGGER_BOOTSTRAP_WORKER_GROUP_NAME`            | No       | —                     | Trigger bootstrap worker group name.                                                                               |
+| `TRIGGER_BOOTSTRAP_WORKER_TOKEN_PATH`            | No       | —                     | Trigger bootstrap worker token path.                                                                               |
+| **Run engine**                                   |          |                       |                                                                                                                    |
+| `RUN_ENGINE_WORKER_COUNT`                        | No       | 4                     | Run engine worker count.                                                                                           |
+| `RUN_ENGINE_TASKS_PER_WORKER`                    | No       | 10                    | Run engine tasks per worker.                                                                                       |
+| `RUN_ENGINE_WORKER_CONCURRENCY_LIMIT`            | No       | 10                    | Run engine worker concurrency limit.                                                                               |
+| `RUN_ENGINE_WORKER_POLL_INTERVAL`                | No       | 100                   | Run engine worker poll interval (ms).                                                                              |
+| `RUN_ENGINE_WORKER_IMMEDIATE_POLL_INTERVAL`      | No       | 100                   | Run engine worker immediate poll interval (ms).                                                                    |
+| `RUN_ENGINE_WORKER_SHUTDOWN_TIMEOUT_MS`          | No       | 60000 (1m)            | Run engine worker shutdown timeout (ms).                                                                           |
+| `RUN_ENGINE_RATE_LIMIT_REFILL_INTERVAL`          | No       | 10s                   | Run engine rate limit refill interval.                                                                             |
+| `RUN_ENGINE_RATE_LIMIT_MAX`                      | No       | 1200                  | Run engine rate limit max.                                                                                         |
+| `RUN_ENGINE_RATE_LIMIT_REFILL_RATE`              | No       | 400                   | Run engine rate limit refill rate.                                                                                 |
+| `RUN_ENGINE_RATE_LIMIT_REQUEST_LOGS_ENABLED`     | No       | 0                     | Run engine rate limit request logs.                                                                                |
+| `RUN_ENGINE_RATE_LIMIT_REJECTION_LOGS_ENABLED`   | No       | 1                     | Run engine rate limit rejection logs.                                                                              |
+| `RUN_ENGINE_RATE_LIMIT_LIMITER_LOGS_ENABLED`     | No       | 0                     | Run engine rate limit limiter logs.                                                                                |
+| `RUN_ENGINE_DEFAULT_MAX_TTL`                     | No       | —                     | Maximum TTL for all runs (e.g. "14d"). Runs without a TTL use this as default; runs with a larger TTL are clamped. |
+| `MAXIMUM_DEV_QUEUE_SIZE`                         | No       | —                     | Maximum queued runs per queue in development environments.                                                         |
+| `MAXIMUM_DEPLOYED_QUEUE_SIZE`                    | No       | —                     | Maximum queued runs per queue in deployed (staging/prod) environments.                                             |
+| **Misc**                                         |          |                       |                                                                                                                    |
+| `TRIGGER_TELEMETRY_DISABLED`                     | No       | —                     | Disable telemetry.                                                                                                 |
+| `NODE_MAX_OLD_SPACE_SIZE`                        | No       | 8192                  | Maximum memory allocation for Node.js heap in MiB (e.g. "4096" for 4GB).                                           |
+| `OPENAI_API_KEY`                                 | No       | —                     | OpenAI API key.                                                                                                    |
+| `MACHINE_PRESETS_OVERRIDE_PATH`                  | No       | —                     | Path to machine presets override file. See [machine overrides](/self-hosting/overview#machine-overrides).          |
+| `APP_ENV`                                        | No       | `NODE_ENV`            | App environment. Used for things like the title tag.                                                               |
+| `ADMIN_EMAILS`                                   | No       | —                     | Regex of user emails to automatically promote to admin on signup. Does not apply to existing users.                |
+| `EVENT_LOOP_MONITOR_ENABLED`                     | No       | 1                     | Node.js event loop lag monitor.                                                                                    |
+
+## Multi-Provider Object Storage
+
+The object storage system supports multiple S3-compatible providers (R2, S3, GCS, MinIO, etc.) using protocol prefixes. This enables migrating between providers without breaking existing runs.
+
+### How It Works
+
+When data exceeds the configured threshold (`TASK_PAYLOAD_OFFLOAD_THRESHOLD`), it's uploaded to object storage. The storage location is saved in the database with an optional protocol prefix:
+
+- **With protocol**: `s3://run_abc/payload.json` or `r2://batch_123/item_0/payload.json`
+- **Without protocol** (legacy): `batch_123/item_0/payload.json` (uses default provider)
+
+### Configuration
+
+#### Default Provider (Backward Compatible)
+
+The default provider is used for data without a protocol prefix:
+
+```bash
+# Default provider (backward compatible - no protocol prefix)
+OBJECT_STORE_BASE_URL=https://r2.example.com
+OBJECT_STORE_ACCESS_KEY_ID=...
+OBJECT_STORE_SECRET_ACCESS_KEY=...
+OBJECT_STORE_REGION=auto
+OBJECT_STORE_SERVICE=s3
+```
+
+#### Named Providers
+
+Named providers are accessed via protocol-prefixed URIs. Configure them using `OBJECT_STORE_{PROTOCOL}_*` variables:
+
+```bash
+# S3 provider (accessed via s3:// prefix)
+OBJECT_STORE_S3_BASE_URL=https://s3.amazonaws.com
+OBJECT_STORE_S3_ACCESS_KEY_ID=...
+OBJECT_STORE_S3_SECRET_ACCESS_KEY=...
+OBJECT_STORE_S3_REGION=us-east-1
+OBJECT_STORE_S3_SERVICE=s3
+
+# R2 provider (accessed via r2:// prefix)
+OBJECT_STORE_R2_BASE_URL=https://...r2.cloudflarestorage.com
+OBJECT_STORE_R2_ACCESS_KEY_ID=...
+OBJECT_STORE_R2_SECRET_ACCESS_KEY=...
+OBJECT_STORE_R2_REGION=auto
+OBJECT_STORE_R2_SERVICE=s3
+```
+
+#### Default Protocol for New Uploads
+
+Set `OBJECT_STORE_DEFAULT_PROTOCOL` to specify which provider to use for new uploads:
+
+```bash
+# Use S3 for new uploads (old data without prefix still uses default provider)
+OBJECT_STORE_DEFAULT_PROTOCOL=s3
+```
+
+### Migration Guide
+
+To migrate from R2 to S3 without breaking existing runs:
+
+<Steps>
+<Step title="Configure S3 provider">
+Add S3 credentials as a named provider:
+
+```bash
+OBJECT_STORE_S3_BASE_URL=https://s3.amazonaws.com
+OBJECT_STORE_S3_ACCESS_KEY_ID=...
+OBJECT_STORE_S3_SECRET_ACCESS_KEY=...
+OBJECT_STORE_S3_REGION=us-east-1
+```
+
+Keep your existing `OBJECT_STORE_*` variables (R2) as the default provider.
+
+</Step>
+
+<Step title="Test the configuration">
+Restart the webapp and verify both providers work:
+
+- Old runs (no prefix) should still access R2
+- New runs with `s3://` prefix should use S3
+</Step>
+
+<Step title="Switch to S3 for new uploads">
+Set the default protocol to use S3 for new uploads:
+
+```bash
+OBJECT_STORE_DEFAULT_PROTOCOL=s3
+```
+
+After this change:
+
+- New data uses `s3://` prefix and goes to S3
+- Old data (no prefix) still uses R2
+- Data with explicit protocol uses the corresponding provider
+</Step>
+
+<Step title="Optionally decommission R2">
+Once all active runs using R2 data have completed (check your data retention policies), you can remove the R2 credentials. Keep `OBJECT_STORE_DEFAULT_PROTOCOL=s3` to ensure new data continues using S3.
+</Step>
+</Steps>
diff --git a/docs/self-hosting/kubernetes.mdx b/docs/self-hosting/kubernetes.mdx
index 4506d6da9b8..eba66f4ed07 100644
--- a/docs/self-hosting/kubernetes.mdx
+++ b/docs/self-hosting/kubernetes.mdx
@@ -555,6 +555,7 @@ kubectl delete namespace trigger
 - **Deploy fails**: Verify registry access and authentication
 - **Pods stuck pending**: Describe the pod and check the events
 - **Worker token issues**: Check webapp and supervisor logs for errors
+- **Deploy fails with `ERROR: schema "graphile_worker" does not exist`**: See the [Docker troubleshooting](/self-hosting/docker#troubleshooting) section for details on resolving PostgreSQL SSL certificate issues that prevent Graphile Worker migrations.
 
 See the [Docker troubleshooting](/self-hosting/docker#troubleshooting) section for more information.
 
diff --git a/docs/skills.mdx b/docs/skills.mdx
new file mode 100644
index 00000000000..f12c5c36eb6
--- /dev/null
+++ b/docs/skills.mdx
@@ -0,0 +1,87 @@
+---
+title: "Skills"
+description: "Install Trigger.dev skills to teach any AI coding assistant best practices for writing tasks, agents, and workflows."
+sidebarTitle: "Skills"
+tag: "new"
+---
+
+## What are agent skills?
+
+Skills are portable instruction sets that teach AI coding assistants how to use Trigger.dev effectively. Unlike vendor-specific config files (`.cursor/rules`, `CLAUDE.md`), skills use an open standard that works across all major AI assistants. For example, Cursor users and Claude Code users can get the same knowledge from a single install.
+
+<Note>
+  Skills are one of three AI tools we provide. You can also install [Agent Rules](/mcp-agent-rules) for client-specific rule sets or the [MCP Server](/mcp-introduction) for live project interaction. See the [comparison table](/building-with-ai#skills-vs-agent-rules-vs-mcp) for details.
+</Note>
+
+Skills are installed as directories containing a `SKILL.md` file. Each `SKILL.md` includes YAML frontmatter (name, description) and markdown instructions with patterns, examples, and best practices that AI assistants automatically discover and follow.
+
+## Installation
+
+When you run `npx skills add triggerdotdev/skills`, the CLI detects your installed AI tools and copies the appropriate files to each tool's expected location. For example, `.claude/skills/`, `.cursor/skills/`, `.github/skills/`, etc.
+
+```bash
+npx skills add triggerdotdev/skills
+```
+
+<Note>`skills` is an open-source CLI by Vercel. Learn more at [skills.sh](https://skills.sh).</Note>
+
+The result: your AI assistant understands Trigger.dev's specific patterns for exports, schema validation, error handling, retries, and more.
+
+
+## Available skills
+
+Install all skills at once, or pick the ones relevant to your current work:
+
+```bash
+# Install all Trigger.dev skills
+npx skills add triggerdotdev/skills
+
+# Or install individual skills
+npx skills add triggerdotdev/skills --skill trigger-tasks
+npx skills add triggerdotdev/skills --skill trigger-agents
+npx skills add triggerdotdev/skills --skill trigger-config
+npx skills add triggerdotdev/skills --skill trigger-realtime
+npx skills add triggerdotdev/skills --skill trigger-setup
+```
+
+| Skill | Use for | Covers |
+|-------|---------|--------|
+| `trigger-setup` | First time setup, new projects | SDK install, `npx trigger init`, project structure |
+| `trigger-tasks` | Writing background tasks, async workflows, scheduled tasks | Triggering, waits, queues, retries, cron, metadata |
+| `trigger-agents` | LLM workflows, orchestration, multi-step AI agents | Prompt chaining, routing, parallelization, human-in-the-loop |
+| `trigger-realtime` | Live updates, progress indicators, streaming | React hooks, progress bars, streaming AI responses |
+| `trigger-config` | Project setup, build configuration | `trigger.config.ts`, extensions (Prisma, FFmpeg, Playwright) |
+
+Not sure which skill to install? Install `trigger-tasks`; it covers the most common patterns for writing Trigger.dev tasks.
+
+
+## Supported AI assistants
+
+Skills work with any AI coding assistant that supports the [Agent Skills standard](https://agentskills.io), including:
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
+- [Cursor](https://cursor.com)
+- [Windsurf](https://codeium.com/windsurf)
+- [GitHub Copilot](https://github.com/features/copilot)
+- [Cline](https://github.com/cline/cline)
+- [Codex CLI](https://github.com/openai/codex)
+- [Gemini CLI](https://github.com/google-gemini/gemini-cli)
+- [OpenCode](https://opencode.ai)
+- [View all →](https://skills.sh)
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="Agent Rules" icon="scroll" href="/mcp-agent-rules">
+    Install comprehensive rule sets directly into your AI client.
+  </Card>
+  <Card title="MCP Server" icon="sparkles" href="/mcp-introduction">
+    Give your AI assistant direct access to Trigger.dev tools and APIs.
+  </Card>
+  <Card title="Writing tasks" icon="code" href="/tasks/overview">
+    Learn the task patterns that skills teach your AI assistant.
+  </Card>
+  <Card title="skills.sh" icon="box" href="https://skills.sh">
+    Browse the full Agent Skills ecosystem.
+  </Card>
+</CardGroup>
\ No newline at end of file
diff --git a/docs/snippets/cli-commands-deploy.mdx b/docs/snippets/cli-commands-deploy.mdx
index d3ed672f2bd..cc5e6120a8a 100644
--- a/docs/snippets/cli-commands-deploy.mdx
+++ b/docs/snippets/cli-commands-deploy.mdx
@@ -77,6 +77,10 @@ npx trigger.dev@latest deploy [path]
   Turn off syncing environment variables with the Trigger.dev instance.
 </ParamField>
 
+<ParamField body="Local build" type="--local-build">
+  Force building the deployment image locally using your local Docker. This is automatic when self-hosting.
+</ParamField>
+
 ### Common options
 
 These options are available on most commands.
@@ -85,50 +89,10 @@ These options are available on most commands.
 
 ### Self-hosting
 
-These options are typically used when [self-hosting](/open-source-self-hosting) or for local development.
-
-<ParamField body="Self-hosted (builds locally)" type="--self-hosted">
-  Builds and loads the image using your local docker. Use the `--registry` option to specify the
-  registry to push the image to when using `--self-hosted`, or just use `--push` to push to the
-  default registry.
-</ParamField>
-
-<ParamField body="Skip deploying the image" type="--skip-deploy | -D">
-  Load the built image into your local docker.
-</ParamField>
-
-<ParamField body="Load image" type="--load-image">
-  Loads the image into your local docker after building it.
-</ParamField>
-
-<ParamField body="Registry" type="--registry">
-  Specify the registry to push the image to when using `--self-hosted`. Will automatically enable
-  `--push`.
-</ParamField>
-
-<ParamField body="Push image" type="--push">
-  When using the `--self-hosted` flag, push the image to the registry.
-</ParamField>
-
-<ParamField body="Namespace" type="--namespace">
-  The namespace to use when pushing the image to the registry. For example, if pushing to Docker
-  Hub, the namespace is your Docker Hub username.
-</ParamField>
-
-<ParamField body="Network" type="--network">
-  The networking mode for RUN instructions when using `--self-hosted`.
-</ParamField>
-
-## Examples
-
-### Push to Docker Hub (self-hosted)
-
-An example of deploying to Docker Hub when using a self-hosted setup:
+When [self-hosting](/self-hosting/overview), builds are performed locally by default. Once you've logged in to your self-hosted instance using the CLI, you can deploy with:
 
 ```bash
-npx trigger.dev@latest deploy \
-  --self-hosted \
-  --load-image \
-  --registry docker.io \
-  --namespace mydockerhubusername
+npx trigger.dev@latest deploy
 ```
+
+For CI/CD environments, set `TRIGGER_ACCESS_TOKEN` and `TRIGGER_API_URL` environment variables. See the [GitHub Actions guide](/github-actions#self-hosting) for more details.
diff --git a/docs/snippets/migrate-v4-using-ai.mdx b/docs/snippets/migrate-v4-using-ai.mdx
index 1681bd30fc1..fa749ed7231 100644
--- a/docs/snippets/migrate-v4-using-ai.mdx
+++ b/docs/snippets/migrate-v4-using-ai.mdx
@@ -151,7 +151,7 @@ await myTask.trigger({ foo: "bar" });
 await myTask.trigger({ foo: "bar" }, { queue: "my-queue" });
 
 
-**Lifecycle hooks**: Function signatures have changed to use a single object parameter instead of separate parameters. This is the old version:
+**Lifecycle hooks**: Function signatures have changed to use a single object parameter instead of separate parameters. Prefer `onStartAttempt` over the deprecated `onStart` when you need code to run before each attempt. This is the old version:
 
 
 // Old v3 way
@@ -171,10 +171,10 @@ This is the new version:
 // New v4 way - single object parameter for hooks
 export const myTask = task({
   id: "my-task",
-  onStart: ({ payload, ctx }) => {},
-  onSuccess: ({ payload, output, ctx }) => {},
-  onFailure: ({ payload, error, ctx }) => {},
-  catchError: ({ payload, ctx, error, retry }) => {},
+  onStartAttempt: ({ payload, ctx }) => {},  // prefer over deprecated onStart
+  onSuccess: ({ payload, ctx, task, output }) => {},
+  onFailure: ({ payload, ctx, task, error }) => {},
+  catchError: ({ payload, ctx, task, error, retry, retryAt, retryDelayInMs }) => {},
   run: async (payload, { ctx }) => {}, // run function unchanged
 });
 
@@ -204,6 +204,12 @@ const batch = await batch.retrieve(batchHandle.batchId); // Use batch.retrieve()
 console.log(batch.runs);
 
 
+**triggerAndWait / batchTriggerAndWait**: In v4 these return a Result object, not the raw output. Use `if (result.ok) { ... result.output }` or call `.unwrap()` to get the output (throws if the run failed). Do not wrap `triggerAndWait` or `batchTriggerAndWait` in `Promise.all` — this is not supported.
+
+
+**Context (ctx) changes**: `ctx.attempt.id` and `ctx.attempt.status` have been removed; use `ctx.attempt.number` where needed. `ctx.task.exportName` has been removed.
+
+
 Can you help me convert the following code from v3 to v4? Please include the full converted code in the answer, do not truncate it anywhere.
 
 ```
diff --git a/docs/snippets/rate-limit-hit-use-batchtrigger.mdx b/docs/snippets/rate-limit-hit-use-batchtrigger.mdx
index cf209d35ade..009ba46c1db 100644
--- a/docs/snippets/rate-limit-hit-use-batchtrigger.mdx
+++ b/docs/snippets/rate-limit-hit-use-batchtrigger.mdx
@@ -1 +1 @@
-The most common cause of hitting the API rate limit is if you’re calling `trigger()` on a task in a loop, instead of doing this use `batchTrigger()` which will trigger multiple tasks in a single API call. You can have up to 500 tasks in a single batch trigger call.
+The most common cause of hitting the API rate limit is if you're calling `trigger()` on a task in a loop, instead of doing this use `batchTrigger()` which will trigger multiple tasks in a single API call. You can have up to 1,000 tasks in a single batch trigger call with SDK 4.3.1+ (500 in prior versions).
diff --git a/docs/snippets/step-cli-init.mdx b/docs/snippets/step-cli-init.mdx
index 265f3d9c894..84bb340dcfe 100644
--- a/docs/snippets/step-cli-init.mdx
+++ b/docs/snippets/step-cli-init.mdx
@@ -20,12 +20,19 @@ yarn dlx trigger.dev@latest init
 
 </CodeGroup>
 
+
 It will do a few things:
 
-1. Log you into the CLI if you're not already logged in.
-2. Create a `trigger.config.ts` file in the root of your project.
-3. Ask where you'd like to create the `/trigger` directory.
-4. Create the `/trigger` directory with an example task, `/trigger/example.[ts/js]`.
+<Tip title="MCP Server">
+  Our [Trigger.dev MCP server](/mcp-introduction) gives your AI assistant direct access to Trigger.dev tools; search docs, trigger tasks, deploy projects, and monitor runs. We recommend installing it for the best developer experience.
+</Tip>
+
+1. Ask if you want to install the [Trigger.dev MCP server](/mcp-introduction) for your AI assistant.
+2. Log you into the CLI if you're not already logged in.
+3. Ask you to select your project.
+4. Install the required SDK packages.
+5. Ask where you'd like to create the `/trigger` directory and create it with an example task.
+6. Create a `trigger.config.ts` file in the root of your project.
 
 Install the "Hello World" example task when prompted. We'll use this task to test the setup.
 
diff --git a/docs/style.css b/docs/style.css
index b209952ad23..94aea582db3 100644
--- a/docs/style.css
+++ b/docs/style.css
@@ -1,3 +1,31 @@
 button~.absolute.peer-hover\:opacity-100 {
     color: #000
-}
\ No newline at end of file
+}
+
+:root {
+    /* Code block colors - Trigger.dark theme */
+    --mint-color-background: #121317;
+    --mint-color-text: #D4D4D4;
+    --mint-token-constant: #9B99FF;
+    --mint-token-string: #AFEC73;
+    --mint-token-comment: #5F6570;
+    --mint-token-keyword: #E888F8;
+    --mint-token-parameter: #CCCBFF;
+    --mint-token-function: #D9F07C;
+    --mint-token-string-expression: #AFEC73;
+    --mint-token-punctuation: #878C99;
+    --mint-token-link: #826DFF;
+
+    /* Shiki css-variables fallbacks */
+    --shiki-foreground: #D4D4D4;
+    --shiki-background: #121317;
+    --shiki-token-constant: #9B99FF;
+    --shiki-token-string: #AFEC73;
+    --shiki-token-comment: #5F6570;
+    --shiki-token-keyword: #E888F8;
+    --shiki-token-parameter: #CCCBFF;
+    --shiki-token-function: #D9F07C;
+    --shiki-token-string-expression: #AFEC73;
+    --shiki-token-punctuation: #878C99;
+    --shiki-token-link: #826DFF;
+}
diff --git a/docs/tasks/overview.mdx b/docs/tasks/overview.mdx
index fe2e7ce5c73..c7705dc4867 100644
--- a/docs/tasks/overview.mdx
+++ b/docs/tasks/overview.mdx
@@ -64,7 +64,7 @@ Anything you return from the `run` function will be the result of the task. Data
 
 ### `retry` options
 
-A task is retried if an error is thrown, by default we retry 3 times.
+A task is retried if an error is thrown. By default, we retry 3 times.
 
 You can set the number of retries and the delay between retries in the `retry` field:
 
@@ -84,6 +84,16 @@ export const taskWithRetries = task({
 });
 ```
 
+| Option | What it does |
+|---|---|
+| `maxAttempts` | Total number of attempts (including the first). Default: 3 |
+| `factor` | Exponential backoff multiplier. Each retry delay = previous delay x factor. With `factor: 1.8` and `minTimeoutInMs: 500`, retries wait 500ms, 900ms, 1620ms, etc. |
+| `minTimeoutInMs` | Delay before the first retry |
+| `maxTimeoutInMs` | Cap on the delay between retries |
+| `randomize` | Add jitter to retry delays to prevent multiple failing tasks from retrying in lockstep |
+
+<Note>Task-level retry settings override the defaults in your `trigger.config` file.</Note>
+
 For more information read [the retrying guide](/errors-retrying).
 
 It's also worth mentioning that you can [retry a block of code](/errors-retrying) inside your tasks as well.
@@ -145,7 +155,7 @@ You can register global lifecycle hooks that are executed for all runs, regardle
 ```ts
 import { tasks } from "@trigger.dev/sdk";
 
-tasks.onStart(({ ctx, payload, task }) => {
+tasks.onStartAttempt(({ ctx, payload, task }) => {
   console.log("Run started", ctx.run);
 });
 
@@ -160,12 +170,12 @@ tasks.onFailure(({ ctx, error }) => {
 
 ### `init.ts`
 
-If you create a `init.ts` file at the root of your trigger directory, it will be automatically loaded when a task is executed. This is useful if you want to register global lifecycle hooks, or initialize a database connection, etc.
+If you create an `init.ts` file at the root of your trigger directory, it will be automatically loaded when a task is executed. This is useful for registering global lifecycle hooks, initializing a database connection, etc.
 
 ```ts init.ts
 import { tasks } from "@trigger.dev/sdk";
 
-tasks.onStart(({ ctx, payload, task }) => {
+tasks.onStartAttempt(({ ctx, payload, task }) => {
   console.log("Run started", ctx.run);
 });
 ```
@@ -535,6 +545,13 @@ export const cancelExampleTask = task({
   point the process will be killed.
 </Note>
 
+<Warning>
+  `onCancel` only runs if the run is actively executing. If a run is cancelled while queued or
+  suspended (e.g. waiting for a token), no machine is spun up and `onCancel` will not be called.
+  This is a known limitation we're planning to address. Follow the progress on our [feedback
+  board](https://feedback.trigger.dev/p/call-the-onfailure-hook-for-runs-that-were-canceled-expired).
+</Warning>
+
 ### `onStart` function (deprecated)
 
 <Info>The `onStart` function was deprecated in v4.1.0. Use `onStartAttempt` instead.</Info>
diff --git a/docs/tasks/streams.mdx b/docs/tasks/streams.mdx
index 2d494977a32..c8cec9dc5a0 100644
--- a/docs/tasks/streams.mdx
+++ b/docs/tasks/streams.mdx
@@ -1,20 +1,22 @@
 ---
-title: "Realtime Streams"
+title: "Streaming data from tasks"
 sidebarTitle: "Streams"
-description: "Stream data in realtime from your Trigger.dev tasks to your frontend or backend applications."
+description: "Pipe continuous data from your Trigger.dev tasks to frontend or backend clients in real time. Stream AI completions, file chunks, progress updates, and more."
 ---
 
-Realtime Streams allow you to pipe streaming data from your Trigger.dev tasks to your frontend or backend applications in real-time. This is perfect for use cases like streaming AI completions, progress updates, or any continuous data flow.
+**Streams let you pipe data from a running task to your frontend or backend as it's produced.** Think AI completions token by token, progress updates, or file chunks. You can also **send data into** running tasks with [Input Streams](#input-streams) for bidirectional flows (cancel buttons, approvals).
+
+For subscribing to **run state changes** (status, metadata, tags) instead, see [Realtime](/realtime/overview).
 
 <Note>
-  Streams v2 requires SDK version **4.1.0 or later**. Make sure to upgrade your `@trigger.dev/sdk`
-  and `@trigger.dev/react-hooks` packages to use these features. If you're on an earlier version,
-  see the [metadata.stream()](/runs/metadata#stream) documentation.
+  Streams require SDK version **4.1.0 or later** (`@trigger.dev/sdk` and `@trigger.dev/react-hooks`).
+  This doc describes the current streams behavior (v2 is the default). For pre-4.1.0 streams, see
+  [Pre-4.1.0 streams (legacy)](#pre-410-streams-legacy) below.
 </Note>
 
 ## Overview
 
-Streams v2 is a major upgrade that provides:
+Streams provide:
 
 - **Unlimited stream length** (previously capped at 2000 chunks)
 - **Unlimited active streams per run** (previously 5)
@@ -23,47 +25,27 @@ Streams v2 is a major upgrade that provides:
 - **Multiple client streams** can pipe to a single stream
 - **Enhanced dashboard visibility** for viewing stream data in real-time
 
-## Enabling Streams v2
-
-Streams v2 is **automatically enabled** when triggering runs from the SDK using 4.1.0 or later. If you aren't triggering via the SDK, you'll need to explicitly enable v2 streams via setting the `x-trigger-realtime-streams-version=v2` header when triggering the task.
-
-If you'd like to **opt-out** of the v2 streams, you can see so in one of the following two ways:
-
-### Option 1: Configure the SDK
-
-```ts
-import { auth } from "@trigger.dev/sdk";
-
-auth.configure({
-  future: {
-    v2RealtimeStreams: false,
-  },
-});
-```
-
-### Option 2: Environment Variable
-
-Set the `TRIGGER_V2_REALTIME_STREAMS=0` environment variable in your backend code (where you trigger tasks).
+Streams v2 is the **default** when using SDK 4.1.0 or later. If you trigger tasks outside the SDK, set the `x-trigger-realtime-streams-version=v2` header. To opt out, use `auth.configure({ future: { v2RealtimeStreams: false } })` or `TRIGGER_V2_REALTIME_STREAMS=0`.
 
 ## Limits Comparison
 
-| Limit                            | Streams v1 | Streams v2 |
-| -------------------------------- | ---------- | ---------- |
-| Maximum stream length            | 2000       | Unlimited  |
-| Number of active streams per run | 5          | Unlimited  |
-| Maximum streams per run          | 10         | Unlimited  |
-| Maximum stream TTL               | 1 day      | 28 days    |
-| Maximum stream size              | 10MB       | 300 MiB    |
+| Limit                            | Legacy (pre-4.1.0) | Current   |
+| -------------------------------- | ------------------ | --------- |
+| Maximum stream length            | 2000               | Unlimited |
+| Number of active streams per run | 5                  | Unlimited |
+| Maximum streams per run          | 10                 | Unlimited |
+| Maximum stream TTL               | 1 day              | 28 days   |
+| Maximum stream size              | 10MB               | 300 MiB   |
 
 ## Quick Start
 
-The recommended workflow for using Realtime Streams v2:
+The recommended workflow for **output** streams (data from task to client):
 
 1. **Define your streams** in a shared location using `streams.define()`
 2. **Use the defined stream** in your tasks with `.pipe()`, `.append()`, or `.writer()`
 3. **Read from the stream** using `.read()` or the `useRealtimeStream` hook in React
 
-This approach gives you full type safety, better code organization, and easier maintenance as your application grows.
+This approach gives you full type safety, better code organization, and easier maintenance as your application grows. For **input** streams (sending data into a running task), see [Input Streams](#input-streams) below.
 
 ## Defining Typed Streams (Recommended)
 
@@ -517,6 +499,161 @@ const { parts, error } = useRealtimeStream(streamDef, runId, {
 });
 ```
 
+## Input Streams
+
+Input Streams let you send data **into** a running task from your backend or frontend. While output streams (above) send data out of tasks, input streams complete the loop — enabling bidirectional communication.
+
+<Note>
+  Input Streams require SDK version **4.4.2 or later** and use the same streams infrastructure (v2 is the default). If you're on an older SDK, calling `.on()` or `.once()` will throw with instructions to enable v2 streams. See [Pre-4.1.0 streams (legacy)](#pre-410-streams-legacy) for the older metadata-based API.
+</Note>
+
+### Input Streams overview
+
+Input Streams solve three common problems:
+
+- **Cancelling AI streams mid-generation.** When you use AI SDK's `streamText` inside a task, the LLM keeps generating until it's done — even if the user clicked "Stop." With input streams, your frontend sends a cancel signal and the task aborts the LLM call immediately.
+- **Human-in-the-loop workflows.** A task generates a draft, then pauses and waits for the user to approve or edit it before continuing.
+- **Interactive agents.** An AI agent running as a task needs follow-up information from the user mid-execution — clarifying a question, choosing between options, or providing additional context.
+
+### Quick Start (Input Streams)
+
+1. **Define** input streams in a shared file with `streams.input<T>({ id: "..." })`.
+2. **Receive** in your task with `.wait()`, `.once()`, `.on()`, or `.peek()`.
+3. **Send** from your backend with `.send(runId, data)` or from the frontend with the `useInputStreamSend` hook (see [Realtime React hooks](/realtime/react-hooks/streams#useinputstreamsend)).
+
+### Defining Input Streams
+
+Use `streams.input()` to define a typed input stream. The generic parameter controls the shape of data that can be sent:
+
+```ts
+import { streams } from "@trigger.dev/sdk";
+
+export const cancelSignal = streams.input<{ reason?: string }>({
+  id: "cancel",
+});
+
+export const approval = streams.input<{ approved: boolean; reviewer: string }>({
+  id: "approval",
+});
+
+export const userResponse = streams.input<{
+  action: "approve" | "reject" | "edit";
+  message?: string;
+  edits?: Record<string, string>;
+}>({
+  id: "user-response",
+});
+```
+
+Type safety is enforced through the generic — both `.send()` and the receiving methods (`.wait()`, `.once()`, `.on()`, `.peek()`) share the same type.
+
+### Receiving data inside a task
+
+| Method | Task suspended? | Compute cost while waiting | Best for |
+|--------|-----------------|----------------------------|-----------|
+| `.wait()` | **Yes** | **None** — process freed | Approval gates, human-in-the-loop, long waits |
+| `.once()` | No | Full — process stays alive | Short waits, concurrent work; returns result object with `.unwrap()` |
+| `.on(handler)` | No | Full — process stays alive | Continuous listening (cancel signals, live updates) |
+| `.peek()` | No | None | Non-blocking check for latest buffered value |
+
+#### `wait()` — Suspend until data arrives
+
+Suspends the task entirely, freeing compute resources. The task resumes when data arrives via `.send()`. Returns a [`ManualWaitpointPromise`](/wait-for-token) — the same type as `wait.forToken()`.
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { approval } from "./streams";
+
+export const publishPost = task({
+  id: "publish-post",
+  run: async (payload: { postId: string }) => {
+    const draft = await prepareDraft(payload.postId);
+    await notifyReviewer(draft);
+
+    const result = await approval.wait({ timeout: "7d" });
+
+    if (result.ok) {
+      if (result.output.approved) {
+        await publish(draft);
+        return { published: true, reviewer: result.output.reviewer };
+      }
+      return { published: false, reviewer: result.output.reviewer };
+    }
+    return { published: false, timedOut: true };
+  },
+});
+```
+
+Use `.unwrap()` to throw on timeout: `const data = await approval.wait({ timeout: "24h" }).unwrap();`
+
+**Options:** `timeout` (e.g. `"30s"`, `"5m"`, `"24h"`, `"7d"`), `idempotencyKey`, `idempotencyKeyTTL`, `tags`. Use `idempotencyKey` when your task has retries so the same waitpoint is resumed across retries.
+
+#### `once()` — Wait for the next value (non-suspending)
+
+Blocks until data arrives but keeps the task process alive. Returns a result object; use `.unwrap()` to get the data or throw on timeout.
+
+```ts
+const result = await approval.once({ timeoutMs: 300_000 });
+if (result.ok) {
+  console.log(result.output.approved);
+}
+// Or: const data = await approval.once({ timeoutMs: 300_000 }).unwrap();
+```
+
+`once()` also accepts a `signal` (e.g. `AbortController.signal`) for cancellation.
+
+#### `on()` — Listen for every value
+
+Registers a persistent handler that fires on every piece of data. Handlers are automatically cleaned up when the task run completes. Call `.off()` on the returned subscription to stop listening early.
+
+```ts
+const controller = new AbortController();
+cancelSignal.on((data) => {
+  console.log("Cancelled:", data.reason);
+  controller.abort();
+});
+const result = streamText({ ..., abortSignal: controller.signal });
+```
+
+#### `peek()` — Non-blocking check
+
+Returns the most recent buffered value without waiting, or `undefined` if nothing has been received yet.
+
+```ts
+const latest = cancelSignal.peek();
+if (latest) {
+  // A cancel was already sent before we checked
+}
+```
+
+### Sending data to a running task
+
+Use `.send(runId, data)` from your backend to push data into a running task. See the [backend input streams guide](/realtime/backend/input-streams) for API route patterns.
+
+```ts
+import { cancelSignal, approval } from "./trigger/streams";
+
+await cancelSignal.send(runId, { reason: "User clicked stop" });
+await approval.send(runId, { approved: true, reviewer: "alice@example.com" });
+```
+
+### Complete example: Cancellable AI streaming
+
+Stream an AI response while allowing the user to cancel mid-generation.
+
+**Define the streams:**
+
+```ts
+import { streams } from "@trigger.dev/sdk";
+
+export const aiOutput = streams.define<string>({ id: "ai" });
+export const cancelStream = streams.input<{ reason?: string }>({ id: "cancel" });
+```
+
+**Task:** Register `cancelStream.on()` to abort an `AbortController`, then pipe `streamText(...).textStream` to `aiOutput`. **Backend:** POST to an API route that calls `cancelStream.send(runId, { reason: "User clicked stop" })`. **Frontend:** Use `useRealtimeStream(aiOutput, runId, { accessToken })` and a button that calls your cancel API (or use the `useInputStreamSend` hook; see [Realtime React hooks](/realtime/react-hooks/streams#useinputstreamsend)).
+
+**Important notes (input streams):** You cannot send to a completed, failed, or canceled run. Max payload per `.send()` is 1MB. Data sent before a listener is registered is buffered and delivered when a listener attaches; `.wait()` handles the buffering race automatically. Use `.wait()` for long waits to free compute; use `.once()` for short waits or concurrent work. Define input streams in a shared location and combine with output streams for full bidirectional communication.
+
 ## Complete Example: AI Streaming
 
 ### Define the stream
@@ -709,11 +846,14 @@ Streams are now visible in the Trigger.dev dashboard, allowing you to:
 6. **Throttle frontend updates**: Use `throttleInMs` in `useRealtimeStream` to prevent excessive re-renders
 7. **Use descriptive stream IDs**: Choose clear, descriptive IDs like `"ai-output"` or `"progress"` instead of generic names
 
+## Pre-4.1.0 streams (legacy)
+
+Prior to SDK 4.1.0, streams used the older metadata-based API. If you're on an earlier version, see [metadata.stream()](/runs/metadata#stream) for legacy usage. With 4.4.2+, [Input Streams](#input-streams) are available and documented in this page.
+
 ## Troubleshooting
 
 ### Stream not appearing in dashboard
 
-- Ensure you've enabled Streams v2 via the future flag or environment variable
 - Verify your task is actually writing to the stream
 - Check that the stream key matches between writing and reading
 
@@ -725,6 +865,11 @@ Streams are now visible in the Trigger.dev dashboard, allowing you to:
 
 ### Missing chunks
 
-- With v2, chunks should never be lost due to automatic resumption
+- With the current streams implementation, chunks should not be lost due to automatic resumption
 - Verify you're reading from the correct stream key
 - Check the `startIndex` option if you're not seeing expected chunks
+
+### Input streams not working
+
+- Input streams require SDK **4.4.2 or later** and the default streams (v2) infrastructure. Ensure you're on a recent SDK and not using the legacy metadata.stream() API.
+- If `.on()` or `.once()` throw, follow the error message to enable v2 streams (they are default in 4.1.0+).
diff --git a/docs/triggering.mdx b/docs/triggering.mdx
index 599fe67e992..62ab9d5cb61 100644
--- a/docs/triggering.mdx
+++ b/docs/triggering.mdx
@@ -29,6 +29,10 @@ Trigger tasks **from inside a another task**:
 
 When you trigger a task from your backend code, you need to set the `TRIGGER_SECRET_KEY` environment variable. If you're [using a preview branch](/deployment/preview-branches), you also need to set the `TRIGGER_PREVIEW_BRANCH` environment variable. You can find the value on the API keys page in the Trigger.dev dashboard. [More info on API keys](/apikeys).
 
+<Note>
+**Which trigger pattern should I use?** If your triggering code can import the task definition (same codebase), use `yourTask.trigger()` for full type safety. Use `tasks.trigger()` with a type-only import when the task runs in a separate service or you need to avoid bundling task code into your app (common in Next.js). Both do the same thing at runtime.
+</Note>
+
 <Note>
   If you are using Next.js Server Actions [you'll need to be careful with
   bundling](/guides/frameworks/nextjs#triggering-your-task-in-next-js).
@@ -198,8 +202,8 @@ Triggers a single run of a task with the payload you pass in, and any options yo
 
 <Note>
   If you need to call `trigger()` on a task in a loop, use
-  [`batchTrigger()`](#yourTask-batchtrigger) instead which will trigger up to 500 runs in a single
-  call.
+  [`batchTrigger()`](#yourTask-batchtrigger) instead which will trigger up to 1,000 runs in a single
+  call with SDK 4.3.1+ (500 runs in prior versions).
 </Note>
 
 ```ts ./trigger/my-task.ts
@@ -541,7 +545,7 @@ export const parentTask = task({
       { id: "child-task-2", payload: { bar: 42 } }, // 👈 The payload is typed correctly based on the task `id`
     ]);
 
-    for (const result of results) {
+    for (const result of results.runs) {
       if (result.ok) {
         // 👇 Narrow the type of the result based on the taskIdentifier
         switch (result.taskIdentifier) {
@@ -707,7 +711,8 @@ Runs that are delayed and have not been enqueued yet will display in the dashboa
 
 <Note>
   Delayed runs will be enqueued at the time specified, and will run as soon as possible after that
-  time, just as a normally triggered run would.
+  time, just as a normally triggered run would. They execute on the currently deployed version when
+  they start, not the version that was active when they were enqueued.
 </Note>
 
 You can cancel a delayed run using the `runs.cancel` SDK function:
@@ -733,6 +738,12 @@ The `delay` option is also available when using `batchTrigger`:
 await myTask.batchTrigger([{ payload: { some: "data" }, options: { delay: "1h" } }]);
 ```
 
+<Note>
+  If your payload contains Date objects, pass them directly rather than manually stringifying with
+  `JSON.stringify()`. The SDK handles Date serialization automatically. If you need to stringify
+  manually, convert Dates to ISO strings first (e.g., `date.toISOString()`).
+</Note>
+
 ### `ttl`
 
 You can set a TTL (time to live) when triggering a task, which will automatically expire the run if it hasn't started within the specified time. This is useful for ensuring that a run doesn't get stuck in the queue for too long.
@@ -773,6 +784,10 @@ The timeline would look like this:
 
 For this reason, the `ttl` option only accepts durations and not absolute timestamps.
 
+<Note>
+  On [Trigger.dev Cloud](https://trigger.dev), there is a maximum TTL of 14 days. If you don't specify a TTL in staging or production, runs automatically get a 14-day TTL. If you specify a TTL longer than 14 days, it is clamped to 14 days. See [Limits — Maximum run TTL](/limits#maximum-run-ttl) for details.
+</Note>
+
 ### `idempotencyKey`
 
 You can provide an `idempotencyKey` to ensure that a task is only triggered once with the same key. This is useful if you are triggering a task within another task that might be retried:
@@ -799,12 +814,6 @@ export const myTask = task({
 
 For more information, see our [Idempotency](/idempotency) documentation.
 
-<Warning>
-  In version 3.3.0 and later, the `idempotencyKey` option is not available when using
-  `triggerAndWait` or `batchTriggerAndWait`, due to a bug that would sometimes cause the parent task
-  to become stuck. We are working on a fix for this issue.
-</Warning>
-
 ### `idempotencyKeyTTL`
 
 Idempotency keys automatically expire after 30 days, but you can set a custom TTL for an idempotency key when triggering a task:
@@ -831,6 +840,144 @@ export const myTask = task({
 
 For more information, see our [Idempotency](/idempotency) documentation.
 
+### `debounce`
+
+You can debounce task triggers to consolidate multiple trigger calls into a single delayed run. When a run with the same debounce key already exists in the delayed state, subsequent triggers "push" the existing run's execution time later rather than creating new runs.
+
+This is useful for scenarios like:
+
+- Real-time document indexing where you want to wait for the user to finish typing
+- Aggregating webhook events from the same source
+- Rate limiting expensive operations while still processing the final request
+
+```ts
+// First trigger creates a new run, delayed by 5 seconds
+await myTask.trigger({ some: "data" }, { debounce: { key: "user-123", delay: "5s" } });
+
+// If triggered again within 5 seconds, the existing run is pushed later
+await myTask.trigger({ updated: "data" }, { debounce: { key: "user-123", delay: "5s" } });
+
+// The run only executes after 5 seconds of no new triggers
+// Note: The first payload is used (first trigger wins)
+```
+
+<Note>
+  Debounce keys are scoped to the task identifier, so different tasks can use the same key without
+  conflicts.
+</Note>
+
+The `debounce` option accepts:
+
+- `key` - A unique string to identify the debounce group (scoped to the task)
+- `delay` - Duration string specifying how long to delay. Supported units: `s` (seconds), `m` (minutes), `h`/`hr` (hours), `d` (days), `w` (weeks). Minimum is 1 second. Examples: `"5s"`, `"1m"`, `"2h30m"`
+- `mode` - Optional. Controls which trigger's data is used: `"leading"` (default) or `"trailing"`
+- `maxDelay` - Optional. Maximum total time from the first trigger before the run must execute. Uses the same duration format as `delay`
+
+**How it works:**
+
+1. First trigger with a debounce key creates a new delayed run
+2. Subsequent triggers with the same key (while the run is still delayed) push the execution time further
+3. Once no new triggers occur within the delay duration, the run executes
+4. After the run starts executing, a new trigger with the same key will create a new run
+
+**Limiting total delay with `maxDelay`:**
+
+By default, continuous triggers can delay execution indefinitely. The `maxDelay` option sets an upper bound on the total delay from the first trigger, ensuring the run eventually executes even with constant activity.
+
+```ts
+await summarizeChat.trigger(
+  { conversationId: "123" },
+  {
+    debounce: {
+      key: "conversation-123",
+      delay: "10s",    // Wait 10s after each message
+      maxDelay: "5m",  // But always run within 5 minutes of first trigger
+    },
+  }
+);
+```
+
+This is useful for scenarios like:
+
+- Summarizing AI chat threads that need periodic updates even during active conversations
+- Syncing data that should happen regularly despite continuous changes
+- Any case where you want debouncing but also guarantee timely execution
+
+**Timeline example with `maxDelay`:**
+
+Consider `delay: "5s"` and `maxDelay: "30s"` with triggers arriving every 2 seconds:
+
+| Time | Event | Result |
+| :--- | :--- | :--- |
+| 0s | Trigger 1 | Run A created, scheduled for 5s |
+| 2s | Trigger 2 | Run A rescheduled to 7s |
+| 4s | Trigger 3 | Run A rescheduled to 9s |
+| ... | ... | ... |
+| 26s | Trigger 14 | Run A rescheduled to 31s |
+| 28s | Trigger 15 | Would reschedule to 33s, but exceeds maxDelay (30s). Run A executes, Run B created |
+| 30s | Trigger 16 | Run B rescheduled to 35s |
+
+Without `maxDelay`, continuous triggers would prevent the run from ever executing. With `maxDelay: "30s"`, execution is guaranteed within 30 seconds of the first trigger.
+
+<Note>
+  The `maxDelay` value is evaluated from each trigger call, not stored with the original run. This
+  means if you pass different `maxDelay` values for the same debounce key, each trigger uses its own
+  `maxDelay` to check against the original run's creation time. For consistent behavior, use the
+  same `maxDelay` value for all triggers with the same debounce key.
+</Note>
+
+**Leading vs Trailing mode:**
+
+By default, debounce uses **leading mode** - the run executes with data from the **first** trigger.
+
+With **trailing mode**, each subsequent trigger updates the run's data (payload, metadata, tags, maxAttempts, maxDuration, and machine), so the run executes with data from the **last** trigger:
+
+```ts
+// Leading mode (default): runs with first payload
+await myTask.trigger({ count: 1 }, { debounce: { key: "user-123", delay: "5s" } });
+await myTask.trigger({ count: 2 }, { debounce: { key: "user-123", delay: "5s" } });
+// After 5 seconds, runs with { count: 1 }
+
+// Trailing mode: runs with last payload
+await myTask.trigger(
+  { count: 1 },
+  { debounce: { key: "user-123", delay: "5s", mode: "trailing" } }
+);
+await myTask.trigger(
+  { count: 2 },
+  { debounce: { key: "user-123", delay: "5s", mode: "trailing" } }
+);
+// After 5 seconds, runs with { count: 2 }
+```
+
+Use **trailing mode** when you want to process the most recent data, such as:
+
+- Saving the latest version of a document after edits stop
+- Processing the final state after a series of rapid updates
+
+**With `triggerAndWait`:**
+
+When using `triggerAndWait` with debounce, the parent run blocks on the existing debounced run if one exists:
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload: string) => {
+    // Both will wait for the same run
+    const result = await childTask.triggerAndWait(
+      { data: payload },
+      { debounce: { key: "shared-key", delay: "3s" } }
+    );
+    return result;
+  },
+});
+```
+
+<Note>
+  Idempotency keys take precedence over debounce keys. If both are provided and an idempotency match
+  is found, it wins.
+</Note>
+
 ### `queue`
 
 When you trigger a task you can override the concurrency limit. This is really useful if you sometimes have high priority runs.
@@ -957,7 +1104,7 @@ You can override the default region when you trigger a run:
 await yourTask.trigger(payload, { region: "eu-central-1" });
 ```
 
-If you don't specify a region it will use the default for your project. Go to the "Regions" page in the dashboard to see available regions or switch your default.
+If you don't specify a region it will use the default for your project. Go to the "Regions" page in the dashboard to see available regions or switch your default. Static IP addresses are also available on the Regions page for paid plans.
 
 The region is where your runs are executed, it does not change where the run payload, output, tags, logs, or are any other data is stored.
 
@@ -971,6 +1118,126 @@ await yourTask.trigger(payload, { machine: "large-1x" });
 
 If you don't specify a machine it will use the machine preset for your task (or the default for your project). For more information read [the machines guide](/machines).
 
+## Streaming batch triggering
+
+<Note>This feature is only available with SDK 4.3.1+</Note>
+
+For large batches, you can pass an `AsyncIterable` or `ReadableStream` instead of an array. This allows you to generate items on-demand without loading them all into memory upfront.
+
+```ts /trigger/my-task.ts
+import { task } from "@trigger.dev/sdk";
+import { myOtherTask } from "~/trigger/my-other-task";
+
+export const myTask = task({
+  id: "my-task",
+  run: async (payload: { userIds: string[] }) => {
+    // Use an async generator to stream items
+    async function* generateItems() {
+      for (const userId of payload.userIds) {
+        yield { payload: { userId } };
+      }
+    }
+
+    const batchHandle = await myOtherTask.batchTrigger(generateItems());
+
+    return { batchId: batchHandle.batchId };
+  },
+});
+```
+
+This works with all batch trigger methods:
+
+- `yourTask.batchTrigger()`
+- `yourTask.batchTriggerAndWait()`
+- `batch.triggerByTask()`
+- `batch.triggerByTaskAndWait()`
+- `tasks.batchTrigger()`
+
+Streaming is especially useful when generating batches from database queries, API pagination, or
+file processing where you don't want to load all items into memory at once.
+
+## Handling batch trigger errors
+
+When batch triggering fails, the SDK throws a `BatchTriggerError` with properties that help you understand what went wrong and how to react:
+
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `isRateLimited` | `boolean` | `true` if the error was caused by rate limiting |
+| `retryAfterMs` | `number \| undefined` | Milliseconds until the rate limit resets |
+| `phase` | `"create" \| "stream"` | Which phase of batch creation failed |
+| `batchId` | `string \| undefined` | The batch ID if it was created before failure |
+| `itemCount` | `number` | Number of items attempted in the batch |
+| `cause` | `unknown` | The underlying error |
+
+### Detecting and handling rate limits
+
+When you hit [batch trigger rate limits](/limits#batch-trigger-rate-limits), you can detect this and implement retry logic:
+
+```ts Your backend
+import { tasks, BatchTriggerError } from "@trigger.dev/sdk";
+import type { myTask } from "~/trigger/myTask";
+
+async function triggerBatchWithRetry(items: { payload: { userId: string } }[], maxRetries = 3) {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await tasks.batchTrigger<typeof myTask>("my-task", items);
+    } catch (error) {
+      if (error instanceof BatchTriggerError && error.isRateLimited) {
+        // Rate limited - wait and retry
+        const waitMs = error.retryAfterMs ?? 10000;
+        console.log(`Rate limited. Waiting ${waitMs}ms before retry ${attempt + 1}/${maxRetries}`);
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+        continue;
+      }
+      // Not a rate limit error - rethrow
+      throw error;
+    }
+  }
+  throw new Error("Max retries exceeded");
+}
+```
+
+### Handling errors inside tasks
+
+When calling `batchTrigger` from inside another task, you can handle errors similarly:
+
+```ts /trigger/parent-task.ts
+import { task, BatchTriggerError } from "@trigger.dev/sdk";
+import { childTask } from "./child-task";
+
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload: { userIds: string[] }) => {
+    const items = payload.userIds.map((userId) => ({ payload: { userId } }));
+
+    try {
+      const batchHandle = await childTask.batchTrigger(items);
+      return { batchId: batchHandle.batchId };
+    } catch (error) {
+      if (error instanceof BatchTriggerError) {
+        // Log details about the failure
+        console.error("Batch trigger failed", {
+          message: error.message,
+          phase: error.phase,
+          itemCount: error.itemCount,
+          isRateLimited: error.isRateLimited,
+        });
+
+        if (error.isRateLimited) {
+          // You might want to re-throw to let the task retry naturally
+          throw error;
+        }
+      }
+      throw error;
+    }
+  },
+});
+```
+
+<Note>
+  For rate limit values and how the token bucket algorithm works, see [Batch trigger rate limits](/limits#batch-trigger-rate-limits).
+</Note>
+
 ## Large Payloads
 
 We recommend keeping your task payloads as small as possible. We currently have a hard limit on task payloads above 10MB.
@@ -1049,7 +1316,3 @@ export const myTask = task({
 ```
 
 </CodeGroup>
-
-### Batch Triggering
-
-When using triggering a batch, the total size of all payloads cannot exceed 1MB. This means if you are doing a batch of 100 runs, each payload should be less than 100KB. The max batch size is 500 runs.
diff --git a/docs/troubleshooting.mdx b/docs/troubleshooting.mdx
index b6254f62d93..f30a5eac475 100644
--- a/docs/troubleshooting.mdx
+++ b/docs/troubleshooting.mdx
@@ -73,6 +73,10 @@ This happens because Docker Desktop left behind a config file that's still tryin
 
 Usually there will be some useful guidance below this message. If you can't figure out what's going wrong then join [our Discord](https://trigger.dev/discord) and create a Help forum post with a link to your deployment.
 
+### `resource_exhausted`
+
+If you see a `resource_exhausted` error during deploy, the build may have hit resource limits on our build infrastructure. Try our [native builder](https://trigger.dev/changelog/deployments-with-native-builds).
+
 ### `No loader is configured for ".node" files`
 
 This happens because `.node` files are native code and can't be bundled like other packages. To fix this, add your package to [`build.external`](/config/config-file#external) in the `trigger.config.ts` file like this:
@@ -93,6 +97,10 @@ export default defineConfig({
 
 If you see this error, add pino (and any other associated packages) to your `external` build settings in your `trigger.config.ts` file. Learn more about the `external` setting in the [config docs](/config/config-file#external).
 
+### `Failed to index deployment` with `Column must be greater than or equal to 0, got -1`
+
+This can occur when using `runtime: "bun"` during the indexing phase (we load and execute your task files to discover exports). A short-term workaround is to [pnpm patch](https://pnpm.io/cli/patch) the `source-map` package. See [this GitHub issue](https://github.com/triggerdotdev/trigger.dev/issues/3045) for the patch details.
+
 ### `reactDOMServer.renderToPipeableStream is not a function` when using react-email
 
 If you see this error when using `@react-email/render`:
@@ -151,6 +159,10 @@ Your code is deployed separately from the rest of your app(s) so you need to mak
 
 Prisma uses code generation to create the client from your schema file. This means you need to add a bit of config so we can generate this file before your tasks run: [Read the guide](/config/extensions/prismaExtension).
 
+### Database connection requires IPv4
+
+Trigger.dev currently only supports IPv4 database connections. If your database provider only provides an IPv6 connection string, you'll need to use an IPv4 address instead. [Upvote IPv6 support](https://triggerdev.featurebase.app/p/support-ipv6-database-connections).
+
 ### `Parallel waits are not supported`
 
 In the current version, you can't perform more that one "wait" in parallel.
@@ -171,12 +183,52 @@ The most common situation this happens is if you're using `Promise.all` around s
 
 Make sure that you always use `await` when you call `trigger`, `triggerAndWait`, `batchTrigger`, and `batchTriggerAndWait`. If you don't then it's likely the task(s) won't be triggered because the calling function process can be terminated before the networks calls are sent.
 
+### `COULD_NOT_FIND_EXECUTOR`
+
+If you see a `COULD_NOT_FIND_EXECUTOR` error when triggering a task, it may be caused by dynamically importing the child task. When tasks are dynamically imported, the executor may not be properly registered.
+
+Use a top-level import instead:
+
+```ts
+import { myChildTask } from "~/trigger/my-child-task";
+
+export const myTask = task({
+  id: "my-task",
+  run: async (payload: string) => {
+    await myChildTask.trigger({ payload: "data" });
+  },
+});
+```
+
+Alternatively, use `tasks.trigger()` or `batch.triggerAndWait()` without importing the task:
+
+```ts
+import { batch } from "@trigger.dev/sdk";
+
+export const myTask = task({
+  id: "my-task",
+  run: async (payload: string) => {
+    await batch.triggerAndWait([{ id: "my-child-task", payload: "data" }]);
+  },
+});
+```
+
 ### Rate limit exceeded
 
 <RateLimitHitUseBatchTrigger />
 
 View the [rate limits](/limits) page for more information.
 
+### Runs waiting in queue due to concurrency limits
+
+If runs are staying in the `QUEUED` state for extended periods, check your concurrency usage in the dashboard. Review how many runs are `EXECUTING` or `DEQUEUED` (these count against limits) and check if any runs are stuck in `EXECUTING` state, as they may be blocking new runs.
+
+**Solutions:**
+
+- **Increase concurrency limits** - If you're on a paid plan, increase your environment concurrency limit via the dashboard
+- **Review queue concurrency limits** - Check if individual queues have restrictive `concurrencyLimit` settings
+- **Check for stuck runs** - See if stalled runs are blocking new executions
+
 ### `Crypto is not defined`
 
 This can happen in different situations, for example when using plain strings as idempotency keys. Support for `Crypto` without a special flag was added in Node `v19.0.0`. You will have to upgrade Node - we recommend even-numbered major releases, e.g. `v20` or `v22`. Alternatively, you can switch from plain strings to the `idempotencyKeys.create` SDK function. [Read the guide](/idempotency).
@@ -191,7 +243,11 @@ If this was a dev run, then most likely the `trigger.dev dev` CLI was stopped, a
 
 </Note>
 
-These errors can happen when code inside your task is blocking the event loop for too long. The most likely cause would be an accidental infinite loop. It could also be a CPU-heavy operation that's blocking the event loop, like nested loops with very large arrays. We recommend reading the [Don't Block the Event Loop](https://nodejs.org/en/learn/asynchronous-work/dont-block-the-event-loop) guide from Node.js for common patterns that can cause this.
+These errors can happen when code inside your task is blocking the event loop for too long. The most likely cause would be an accidental infinite loop. It could also be a CPU-heavy operation that's blocking the event loop, like nested loops with very large arrays.
+
+If you use **Prisma 7.x**, query compilation and caching run on the main thread and can block the event loop during heavy or repeated database work. In tasks that do a lot of Prisma calls (e.g. in loops or many sequential queries), add `await heartbeats.yield()` periodically so the event loop can run and send heartbeats.
+
+We recommend reading the [Don't Block the Event Loop](https://nodejs.org/en/learn/asynchronous-work/dont-block-the-event-loop) guide from Node.js for common patterns that can cause this.
 
 If you are doing a continuous CPU-heavy task, then we recommend you try using our `heartbeats.yield` function to automatically yield to the event loop periodically:
 
diff --git a/docs/v3-openapi.yaml b/docs/v3-openapi.yaml
index 67299f946f6..d6e46b3fc2f 100644
--- a/docs/v3-openapi.yaml
+++ b/docs/v3-openapi.yaml
@@ -360,24 +360,24 @@ paths:
 
             const handle = await runs.replay("run_1234");
 
-  "/api/v1/runs/{runId}/metadata":
+  "/api/v1/runs/{runId}/tags":
     parameters:
       - $ref: "#/components/parameters/runId"
-    put:
-      operationId: update_run_metadata_v1
-      summary: Update run metadata
-      description: Update the metadata of a run.
+    post:
+      operationId: add_run_tags_v1
+      summary: Add tags to a run
+      description: Adds one or more tags to a run. Runs can have a maximum of 10 tags. Duplicate tags are ignored.
       requestBody:
         required: true
         content:
           application/json:
             schema:
               type: object
+              required:
+                - tags
               properties:
-                metadata:
-                  type: object
-                  description: The new metadata to set on the run.
-                  example: { key: "value" }
+                tags:
+                  $ref: "#/components/schemas/RunTags"
       responses:
         "200":
           description: Successful request
@@ -386,9 +386,9 @@ paths:
               schema:
                 type: object
                 properties:
-                  metadata:
-                    type: object
-                    description: The updated metadata of the run.
+                  message:
+                    type: string
+                    example: "Successfully set 2 new tags."
         "400":
           description: Invalid request
           content:
@@ -398,9 +398,6 @@ paths:
                 properties:
                   error:
                     type: string
-                    enum:
-                      - Invalid or missing run ID
-                      - Invalid metadata
         "401":
           description: Unauthorized request
           content:
@@ -411,9 +408,9 @@ paths:
                   error:
                     type: string
                     enum:
-                      - Invalid or Missing API key
-        "404":
-          description: Resource not found
+                      - Invalid or Missing API Key
+        "422":
+          description: Too many tags
           content:
             application/json:
               schema:
@@ -421,33 +418,37 @@ paths:
                 properties:
                   error:
                     type: string
-                    enum:
-                      - Task Run not found
+                    description: Runs can only have 10 tags.
       tags:
         - runs
       security:
         - secretKey: []
       x-codeSamples:
         - lang: typescript
-          label: Save metadata
+          label: SDK
           source: |-
-            import { metadata, task } from "@trigger.dev/sdk";
+            import { runs } from "@trigger.dev/sdk";
 
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                await metadata.save({ key: "value" });
-              }
+            await runs.addTags("run_1234", ["tag-1", "tag-2"]);
+        - lang: typescript
+          label: Fetch
+          source: |-
+            await fetch("https://api.trigger.dev/api/v1/runs/run_1234/tags", {
+              method: "POST",
+              headers: {
+                "Authorization": `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+                "Content-Type": "application/json",
+              },
+              body: JSON.stringify({ tags: ["tag-1", "tag-2"] }),
             });
 
-  "/api/v2/runs/{runId}/cancel":
+  "/api/v1/runs/{runId}/trace":
     parameters:
       - $ref: "#/components/parameters/runId"
-    post:
-      operationId: cancel_run_v1
-      summary: Cancel a run
-      description: Cancels an in-progress run. If the run is already completed, this
-        will have no effect.
+    get:
+      operationId: get_run_trace_v1
+      summary: Retrieve run trace
+      description: Returns the full OTel trace tree for a run, including all spans and their children.
       responses:
         "200":
           description: Successful request
@@ -456,12 +457,27 @@ paths:
               schema:
                 type: object
                 properties:
-                  id:
+                  trace:
+                    type: object
+                    properties:
+                      traceId:
+                        type: string
+                        description: The OTel trace ID.
+                      rootSpan:
+                        $ref: "#/components/schemas/SpanDetailedSummary"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
                     type: string
-                    description: The ID of the run that was canceled.
-                    example: run_1234
-        "400":
-          description: Invalid request
+                    enum:
+                      - Invalid or Missing API key
+        "404":
+          description: Resource not found
           content:
             application/json:
               schema:
@@ -470,8 +486,122 @@ paths:
                   error:
                     type: string
                     enum:
-                      - Invalid or missing run ID
-                      - Failed to create new run
+                      - Run not found
+                      - Trace not found
+      tags:
+        - runs
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            const response = await fetch("https://api.trigger.dev/api/v1/runs/run_1234/trace", {
+              headers: {
+                Authorization: `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+              },
+            });
+
+            const { trace } = await response.json();
+
+  "/api/v1/runs/{runId}/events":
+    parameters:
+      - $ref: "#/components/parameters/runId"
+    get:
+      operationId: get_run_events_v1
+      summary: Retrieve run events
+      description: Returns all OTel span events for a run. Useful for debugging and observability.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  events:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        spanId:
+                          type: string
+                          description: The span ID of the event.
+                        parentId:
+                          type: string
+                          nullable: true
+                          description: The parent span ID, if any.
+                        runId:
+                          type: string
+                          nullable: true
+                          description: The run ID associated with this event.
+                        message:
+                          type: string
+                          description: The event message.
+                        startTime:
+                          type: string
+                          description: The start time of the event as a bigint string (nanoseconds since epoch).
+                        duration:
+                          type: number
+                          description: The duration of the event in nanoseconds.
+                        isError:
+                          type: boolean
+                          description: Whether this event represents an error.
+                        isPartial:
+                          type: boolean
+                          description: Whether this event is partial (still in progress).
+                        isCancelled:
+                          type: boolean
+                          description: Whether this event was cancelled.
+                        level:
+                          type: string
+                          enum: [TRACE, DEBUG, LOG, INFO, WARN, ERROR]
+                          description: The log level of the event.
+                        kind:
+                          type: string
+                          enum: [UNSPECIFIED, INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER, UNRECOGNIZED, LOG]
+                          description: The kind of span event.
+                        attemptNumber:
+                          type: number
+                          nullable: true
+                          description: The attempt number this event belongs to.
+                        taskSlug:
+                          type: string
+                          description: The task identifier.
+                        events:
+                          type: array
+                          description: Span events (e.g. exceptions, cancellations) that occurred during this event.
+                          items:
+                            type: object
+                            properties:
+                              name:
+                                type: string
+                                description: The event name (e.g. "exception", "cancellation", "attempt_failed").
+                              time:
+                                type: string
+                                format: date-time
+                                description: The time the event occurred.
+                              properties:
+                                type: object
+                                description: Event-specific properties.
+                        style:
+                          type: object
+                          description: Display style metadata for the event.
+                          properties:
+                            icon:
+                              type: string
+                              description: Icon identifier for display.
+                            variant:
+                              type: string
+                              description: Visual variant (e.g. "success", "failure").
+                            accessory:
+                              type: object
+                              description: Accessory display element.
+                              properties:
+                                text:
+                                  type: string
+                                style:
+                                  type: string
+                                  enum: [codepath]
         "401":
           description: Unauthorized request
           content:
@@ -501,30 +631,43 @@ paths:
       x-codeSamples:
         - lang: typescript
           source: |-
-            import { runs } from "@trigger.dev/sdk";
+            const response = await fetch("https://api.trigger.dev/api/v1/runs/run_1234/events", {
+              headers: {
+                Authorization: `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+              },
+            });
 
-            await runs.cancel("run_1234");
+            const { events } = await response.json();
 
-  "/api/v1/runs/{runId}/reschedule":
+  "/api/v1/runs/{runId}/metadata":
     parameters:
       - $ref: "#/components/parameters/runId"
-    post:
-      operationId: reschedule_run_v1
-      summary: Rescheduled a delayed run
-      description: Updates a delayed run with a new delay. Only valid when the run is in the DELAYED state.
+    put:
+      operationId: update_run_metadata_v1
+      summary: Update run metadata
+      description: Update the metadata of a run.
       requestBody:
         required: true
         content:
           application/json:
             schema:
-              "$ref": "#/components/schemas/RescheduleRunRequestBody"
+              type: object
+              properties:
+                metadata:
+                  type: object
+                  description: The new metadata to set on the run.
+                  example: { key: "value" }
       responses:
         "200":
           description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/RetrieveRunResponse"
+                type: object
+                properties:
+                  metadata:
+                    type: object
+                    description: The updated metadata of the run.
         "400":
           description: Invalid request
           content:
@@ -536,7 +679,7 @@ paths:
                     type: string
                     enum:
                       - Invalid or missing run ID
-                      - Failed to create new run
+                      - Invalid metadata
         "401":
           description: Unauthorized request
           content:
@@ -558,33 +701,44 @@ paths:
                   error:
                     type: string
                     enum:
-                      - Run not found
+                      - Task Run not found
       tags:
         - runs
       security:
         - secretKey: []
       x-codeSamples:
         - lang: typescript
+          label: Save metadata
           source: |-
-            import { runs } from "@trigger.dev/sdk";
+            import { metadata, task } from "@trigger.dev/sdk";
 
-            const handle = await runs.reschedule("run_1234", { delay: new Date("2024-06-29T20:45:56.340Z") });
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                await metadata.save({ key: "value" });
+              }
+            });
 
-  "/api/v3/runs/{runId}":
+  "/api/v2/runs/{runId}/cancel":
     parameters:
       - $ref: "#/components/parameters/runId"
-    get:
-      operationId: retrieve_run_v1
-      summary: Retrieve a run
-      description: |
-        Retrieve information about a run, including its status, payload, output, and attempts. If you authenticate with a Public API key, we will omit the payload and output fields for security reasons.
+    post:
+      operationId: cancel_run_v1
+      summary: Cancel a run
+      description: Cancels an in-progress run. If the run is already completed, this
+        will have no effect.
       responses:
         "200":
           description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/RetrieveRunResponse"
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The ID of the run that was canceled.
+                    example: run_1234
         "400":
           description: Invalid request
           content:
@@ -596,6 +750,7 @@ paths:
                     type: string
                     enum:
                       - Invalid or missing run ID
+                      - Failed to create new run
         "401":
           description: Unauthorized request
           content:
@@ -619,7 +774,7 @@ paths:
                     enum:
                       - Run not found
       tags:
-        - run
+        - runs
       security:
         - secretKey: []
       x-codeSamples:
@@ -627,274 +782,276 @@ paths:
           source: |-
             import { runs } from "@trigger.dev/sdk";
 
-            const result = await runs.retrieve("run_1234");
-
-            // We include boolean helpers to check the status of the run
-            // (isSuccess, isFailed, isCompleted, etc.)
-            if (result.isSuccess) {
-              console.log("Run was successful with output", result.output);
-            }
-
-            // You also have access to the run status that includes more granular information
-            console.log("Run status:", result.status);
-
-            // You can access the payload and output
-            console.log("Payload:", result.payload);
-            console.log("Output:", result.output);
-
-            // You can also access the attempts, which will give you information about errors (if they exist)
-            for (const attempt of result.attempts) {
-              if (attempt.status === "FAILED") {
-                console.log("Attempt failed with error:", attempt.error);
-              }
-            }
+            await runs.cancel("run_1234");
 
-  "/api/v1/runs":
+  "/api/v1/deployments/{deploymentId}":
+    parameters:
+      - in: path
+        name: deploymentId
+        required: true
+        schema:
+          type: string
+        description: The deployment ID.
     get:
-      operationId: list_runs_v1
-      summary: List runs
-      description: List runs in a specific environment. You can filter the runs by status, created at, task identifier, version, and more.
-      parameters:
-        - $ref: "#/components/parameters/cursorPagination"
-        - $ref: "#/components/parameters/runsFilter"
+      operationId: get_deployment_v1
+      summary: Get deployment
+      description: Retrieve information about a specific deployment by its ID.
       responses:
         "200":
           description: Successful request
           content:
             application/json:
               schema:
-                $ref: "#/components/schemas/ListRunsResult"
-        "400":
-          description: Invalid query parameters
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/ErrorWithDetailsResponse"
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The deployment ID
+                  status:
+                    type: string
+                    enum:
+                      [
+                        "PENDING",
+                        "INSTALLING",
+                        "BUILDING",
+                        "DEPLOYING",
+                        "DEPLOYED",
+                        "FAILED",
+                        "CANCELED",
+                        "TIMED_OUT",
+                      ]
+                    description: The current status of the deployment
+                  contentHash:
+                    type: string
+                    description: Hash of the deployment content
+                  shortCode:
+                    type: string
+                    description: The short code for the deployment
+                  version:
+                    type: string
+                    description: The deployment version (e.g., "20250228.1")
+                  imageReference:
+                    type: string
+                    nullable: true
+                    description: Reference to the deployment image
+                  imagePlatform:
+                    type: string
+                    description: Platform of the deployment image
+                  externalBuildData:
+                    type: object
+                    nullable: true
+                    description: External build data if applicable
+                  errorData:
+                    type: object
+                    nullable: true
+                    description: Error data if the deployment failed
+                  worker:
+                    type: object
+                    nullable: true
+                    description: Worker information if available
+                    properties:
+                      id:
+                        type: string
+                      version:
+                        type: string
+                      tasks:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            id:
+                              type: string
+                            slug:
+                              type: string
+                            filePath:
+                              type: string
+                            exportName:
+                              type: string
         "401":
-          description: Unauthorized request
+          description: Unauthorized - Access token is missing or invalid
+        "404":
+          description: Deployment not found
       tags:
-        - runs
+        - deployments
       security:
         - secretKey: []
       x-codeSamples:
         - lang: typescript
-          label: List runs
           source: |-
-            import { runs } from "@trigger.dev/sdk";
-
-            // Get the first page of runs
-            let page = await runs.list({ limit: 20 });
-
-            for (const run of page.data) {
-              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
-            }
-
-            // Convenience methods are provided for manually paginating:
-            while (page.hasNextPage()) {
-              page = await page.getNextPage();
-              // Do something with the next page of runs
-            }
-
-            // Auto-paginate through all runs
-            const allRuns = [];
-
-            for await (const run of runs.list({ limit: 20 })) {
-              allRuns.push(run);
-            }
-        - lang: typescript
-          label: Filter runs
+            const response = await fetch(
+              `https://api.trigger.dev/api/v1/deployments/${deploymentId}`,
+              {
+                method: "GET",
+                headers: {
+                  "Authorization": `Bearer ${secretKey}`,
+                },
+              }
+            );
+            const deployment = await response.json();
+        - lang: curl
           source: |-
-            import { runs } from "@trigger.dev/sdk";
-
-            const response = await runs.list({
-              status: ["QUEUED", "EXECUTING"],
-              taskIdentifier: ["my-task", "my-other-task"],
-              from: new Date("2024-04-01T00:00:00Z"),
-              to: new Date(),
-            });
-
-            for (const run of response.data) {
-              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
-            }
+            curl -X GET "https://api.trigger.dev/api/v1/deployments/deployment_1234" \
+              -H "Authorization: Bearer tr_dev_1234"
 
-  "/api/v1/projects/{projectRef}/runs":
-    parameters:
-      - $ref: "#/components/parameters/projectRef"
+  "/api/v1/deployments/latest":
     get:
-      operationId: list_project_runs_v1
-      summary: List project runs
-      description: List runs in a project, across multiple environments, using Personal Access Token auth. You can filter the runs by status, created at, task identifier, version, and more.
-      parameters:
-        - $ref: "#/components/parameters/cursorPagination"
-        - $ref: "#/components/parameters/runsFilterWithEnv"
+      operationId: get_latest_deployment_v1
+      summary: Get latest deployment
+      description: Retrieve information about the latest unmanaged deployment for the authenticated project.
       responses:
         "200":
           description: Successful request
           content:
             application/json:
               schema:
-                $ref: "#/components/schemas/ListRunsResult"
-        "400":
-          description: Invalid request
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/ErrorWithDetailsResponse"
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The deployment ID
+                  status:
+                    type: string
+                    enum:
+                      [
+                        "PENDING",
+                        "INSTALLING",
+                        "BUILDING",
+                        "DEPLOYING",
+                        "DEPLOYED",
+                        "FAILED",
+                        "CANCELED",
+                        "TIMED_OUT",
+                      ]
+                    description: The current status of the deployment
+                  contentHash:
+                    type: string
+                    description: Hash of the deployment content
+                  shortCode:
+                    type: string
+                    description: The short code for the deployment
+                  version:
+                    type: string
+                    description: The deployment version (e.g., "20250228.1")
+                  imageReference:
+                    type: string
+                    nullable: true
+                    description: Reference to the deployment image
+                  errorData:
+                    type: object
+                    nullable: true
+                    description: Error data if the deployment failed
         "401":
-          description: Unauthorized request
+          description: Unauthorized - API key is missing or invalid
+        "404":
+          description: No deployment found
       tags:
-        - runs
+        - deployments
       security:
-        - personalAccessToken: []
+        - secretKey: []
       x-codeSamples:
         - lang: typescript
-          label: List runs
           source: |-
-            import { runs, configure } from "@trigger.dev/sdk";
-
-            configure({
-              accessToken: "tr_pat_1234" // always use an environment variable for this
-            });
-
-            // Get the first page of runs
-            let page = await runs.list("proj_1234", { limit: 20 });
-
-            for (const run of page.data) {
-              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
-            }
-
-            // Convenience methods are provided for manually paginating:
-            while (page.hasNextPage()) {
-              page = await page.getNextPage();
-              // Do something with the next page of runs
-            }
-
-            // Auto-paginate through all runs
-            const allRuns = [];
-
-            for await (const run of runs.list("proj_1234", { limit: 20 })) {
-              allRuns.push(run);
-            }
-        - lang: typescript
-          label: Filter runs
+            const response = await fetch(
+              "https://api.trigger.dev/api/v1/deployments/latest",
+              {
+                method: "GET",
+                headers: {
+                  "Authorization": `Bearer ${secretKey}`,
+                },
+              }
+            );
+            const deployment = await response.json();
+        - lang: curl
           source: |-
-            import { runs, configure } from "@trigger.dev/sdk";
-
-            configure({
-              accessToken: "tr_pat_1234" // always use an environment variable for this
-            });
-
-            const response = await runs.list("proj_1234", {
-              env: ["prod", "staging"],
-              status: ["QUEUED", "EXECUTING"],
-              taskIdentifier: ["my-task", "my-other-task"],
-              from: new Date("2024-04-01T00:00:00Z"),
-              to: new Date(),
-            });
-
-            for (const run of response.data) {
-              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
-            }
+            curl -X GET "https://api.trigger.dev/api/v1/deployments/latest" \
+              -H "Authorization: Bearer tr_dev_1234"
 
-  "/api/v1/projects/{projectRef}/envvars/{env}":
+  "/api/v1/deployments/{version}/promote":
     parameters:
-      - $ref: "#/components/parameters/projectRef"
-      - $ref: "#/components/parameters/env"
-    get:
-      operationId: list_project_envvars_v1
-      summary: List environment variables
-      description: List all environment variables for a specific project and environment.
+      - in: path
+        name: version
+        required: true
+        schema:
+          type: string
+        description: The deployment version to promote (e.g., "20250228.1").
+    post:
+      operationId: promote_deployment_v1
+      summary: Promote deployment
+      description: Promote a previously deployed version to be the current version for the environment. This makes the specified version active for new task runs.
       responses:
         "200":
-          description: Successful request
+          description: Deployment promoted successfully
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ListEnvironmentVariablesResponse"
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The deployment ID
+                  version:
+                    type: string
+                    description: The deployment version (e.g., "20250228.1")
+                  shortCode:
+                    type: string
+                    description: The short code for the deployment
         "400":
-          description: Invalid request parameters or body
+          description: Invalid request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
         "401":
-          description: Unauthorized request
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+          description: Unauthorized - API key is missing or invalid
         "404":
-          description: Resource not found
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+          description: Deployment not found
       tags:
-        - envvars
+        - deployments
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Outside of a task
           source: |-
-            import { envvars, configure } from "@trigger.dev/sdk";
-
-            const variables = await envvars.list("proj_yubjwjsfkxnylobaqvqz", "dev");
-
-            for (const variable of variables) {
-              console.log(`Name: ${variable.name}, Value: ${variable.value}`);
-            }
-        - lang: typescript
-          label: Inside a task
+            const response = await fetch(
+              `https://api.trigger.dev/api/v1/deployments/${version}/promote`,
+              {
+                method: "POST",
+                headers: {
+                  "Authorization": `Bearer ${secretKey}`,
+                  "Content-Type": "application/json",
+                },
+              }
+            );
+            const result = await response.json();
+        - lang: curl
           source: |-
-            import { envvars, task } from "@trigger.dev/sdk";
-
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                // projectRef and env are automatically inferred from the task context
-                const variables = await envvars.list();
+            curl -X POST "https://api.trigger.dev/api/v1/deployments/20250228.1/promote" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -H "Content-Type: application/json"
 
-                for (const variable of variables) {
-                  console.log(`Name: ${variable.name}, Value: ${variable.value}`);
-                }
-              }
-            })
+  "/api/v1/query":
     post:
-      operationId: create_project_envvar_v1
-      summary: Create environment variable
-      description: Create a new environment variable for a specific project and environment.
+      operationId: execute_query_v1
+      summary: Execute a TRQL query
+      description: Execute a TRQL (Trigger.dev Query Language) query against your run data. TRQL is a SQL-style query language that allows you to analyze runs, calculate metrics, and export data.
       requestBody:
         required: true
         content:
           application/json:
             schema:
-              "$ref": "#/components/schemas/EnvVar"
+              "$ref": "#/components/schemas/ExecuteQueryRequestBody"
       responses:
         "200":
-          description: Environment variable created successfully
+          description: Query executed successfully
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/SucceedResponse"
+                "$ref": "#/components/schemas/ExecuteQueryResponse"
         "400":
-          description: Invalid request parameters or body
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
-        "401":
-          description: Unauthorized request
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  error:
-                    type: string
-        "404":
-          description: Resource not found
+          description: Invalid query or request parameters
           content:
             application/json:
               schema:
@@ -902,75 +1059,127 @@ paths:
                 properties:
                   error:
                     type: string
+                    description: Error message describing the query error
+        "401":
+          description: Unauthorized - API key is missing or invalid
+        "500":
+          description: Internal server error during query execution
       tags:
-        - envvars
+        - query
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Outside of a task
+          label: SDK - Basic query
           source: |-
-            import { envvars } from "@trigger.dev/sdk";
+            import { query } from "@trigger.dev/sdk";
 
-            await envvars.create("proj_yubjwjsfkxnylobaqvqz", "dev", {
-              name: "SLACK_API_KEY",
-              value: "slack_123456"
+            // Basic query with defaults (environment scope, json format)
+            const result = await query.execute(
+              "SELECT run_id, status FROM runs LIMIT 10"
+            );
+            console.log(result.results);
+        - lang: typescript
+          label: SDK - Type-safe query
+          source: |-
+            import { query, type QueryTable } from "@trigger.dev/sdk";
+
+            // Type-safe query using QueryTable
+            const result = await query.execute<
+              QueryTable<"runs", "run_id" | "status" | "triggered_at">
+            >(
+              "SELECT run_id, status, triggered_at FROM runs LIMIT 10"
+            );
+
+            result.results.forEach(row => {
+              console.log(row.run_id, row.status); // Fully typed!
             });
         - lang: typescript
-          label: Inside a task
+          label: SDK - With options
           source: |-
-            import { envvars, task } from "@trigger.dev/sdk";
+            import { query } from "@trigger.dev/sdk";
 
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                // projectRef and env are automatically inferred from the task context
-                await envvars.create({
-                  name: "SLACK_API_KEY",
-                  value: "slack_123456"
-                });
+            const result = await query.execute(
+              "SELECT COUNT(*) as count FROM runs WHERE status = 'Failed'",
+              {
+                scope: "project",       // Query across all environments
+                period: "7d",           // Last 7 days
+                format: "json"
               }
-            })
+            );
+        - lang: typescript
+          label: SDK - CSV export
+          source: |-
+            import { query } from "@trigger.dev/sdk";
 
-  "/api/v1/projects/{projectRef}/envvars/{env}/import":
+            const csvResult = await query.execute(
+              "SELECT run_id, status, triggered_at FROM runs",
+              {
+                format: "csv",
+                period: "30d"
+              }
+            );
+
+            // csvResult.results is a CSV string
+            const lines = csvResult.results.split('\n');
+        - lang: curl
+          label: cURL - Basic query
+          source: |-
+            curl -X POST "https://api.trigger.dev/api/v1/query" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -H "Content-Type: application/json" \
+              -d '{
+                "query": "SELECT run_id, status FROM runs LIMIT 10",
+                "scope": "environment",
+                "period": "7d",
+                "format": "json"
+              }'
+        - lang: curl
+          label: cURL - Aggregation query
+          source: |-
+            curl -X POST "https://api.trigger.dev/api/v1/query" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -H "Content-Type: application/json" \
+              -d '{
+                "query": "SELECT task_identifier, count() as runs, countIf(status = '\''Failed'\'') as failures FROM runs GROUP BY task_identifier",
+                "scope": "environment",
+                "from": "2024-01-01T00:00:00Z",
+                "to": "2024-01-31T23:59:59Z",
+                "format": "json"
+              }'
+
+  "/api/v1/runs/{runId}/reschedule":
     parameters:
-      - $ref: "#/components/parameters/projectRef"
-      - $ref: "#/components/parameters/env"
+      - $ref: "#/components/parameters/runId"
     post:
-      operationId: upload_project_envvars_v1
-      summary: Upload environment variables
-      description: Upload mulitple environment variables for a specific project and environment.
+      operationId: reschedule_run_v1
+      summary: Rescheduled a delayed run
+      description: Updates a delayed run with a new delay. Only valid when the run is in the DELAYED state.
       requestBody:
         required: true
         content:
           application/json:
             schema:
-              type: object
-              properties:
-                variables:
-                  type: array
-                  items:
-                    "$ref": "#/components/schemas/EnvVar"
-                override:
-                  type: boolean
-                  description: Whether to override existing variables or not
-                  default: false
-              required: ["variables"]
-
+              "$ref": "#/components/schemas/RescheduleRunRequestBody"
       responses:
         "200":
-          description: Environment variables imported successfully
+          description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/SucceedResponse"
+                "$ref": "#/components/schemas/RetrieveRunResponse"
         "400":
-          description: Invalid request parameters or body
+          description: Invalid request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Invalid or missing run ID
+                      - Failed to create new run
         "401":
           description: Unauthorized request
           content:
@@ -980,6 +1189,8 @@ paths:
                 properties:
                   error:
                     type: string
+                    enum:
+                      - Invalid or Missing API key
         "404":
           description: Resource not found
           content:
@@ -989,233 +1200,350 @@ paths:
                 properties:
                   error:
                     type: string
+                    enum:
+                      - Run not found
       tags:
-        - envvars
+        - runs
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Import variables from an array
           source: |-
-            import { envvars } from "@trigger.dev/sdk";
+            import { runs } from "@trigger.dev/sdk";
 
-            await envvars.upload("proj_yubjwjsfkxnylobaqvqz", "dev", {
-              variables: { SLACK_API_KEY: "slack_key_1234" },
-              override: false
-            });
+            const handle = await runs.reschedule("run_1234", { delay: new Date("2024-06-29T20:45:56.340Z") });
 
-  "/api/v1/projects/{projectRef}/envvars/{env}/{name}":
+  "/api/v1/runs/{runId}/result":
     parameters:
-      - $ref: "#/components/parameters/projectRef"
-      - $ref: "#/components/parameters/env"
-      - $ref: "#/components/parameters/envvarName"
+      - $ref: "#/components/parameters/runId"
     get:
-      operationId: get_project_envvar_v1
-      summary: Retrieve environment variable
-      description: Retrieve a specific environment variable for a specific project and environment.
+      operationId: get_run_result_v1
+      summary: Retrieve run result
+      description: Returns the execution result of a completed run. Returns 404 if the run doesn't exist or hasn't finished yet.
       responses:
         "200":
           description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/EnvVarValue"
-        "400":
-          description: Invalid request parameters or body
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                required: [ok, id]
+                properties:
+                  ok:
+                    type: boolean
+                    description: Whether the run completed successfully.
+                  id:
+                    type: string
+                    description: The run ID.
+                  output:
+                    type: string
+                    description: The serialized output as a string (present when ok is true). Use outputType to determine how to parse it — for "application/json" use JSON.parse().
+                  outputType:
+                    type: string
+                    description: The content type of the serialized output, e.g. "application/json".
+                  error:
+                    type: object
+                    description: Error details (present when ok is false).
+                  usage:
+                    type: object
+                    description: Execution usage stats.
+                    properties:
+                      durationMs:
+                        type: number
+                        description: Duration of the run in milliseconds.
+                  taskIdentifier:
+                    type: string
+                    description: The task identifier.
         "401":
           description: Unauthorized request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Invalid or Missing API Key
         "404":
-          description: Resource not found
+          description: Run not found or not yet finished
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Run either doesn't exist or is not finished
       tags:
-        - envvars
+        - runs
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Outside of a task
-          source: |-
-            import { envvars } from "@trigger.dev/sdk";
-
-            const variable = await envvars.retrieve("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY");
-
-            console.log(`Value: ${variable.value}`);
-        - lang: typescript
-          label: Inside a task
+          label: Fetch
           source: |-
-            import { envvars, task } from "@trigger.dev/sdk";
-
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                // projectRef and env are automatically inferred from the task context
-                const variable = await envvars.retrieve("SLACK_API_KEY");
-
-                console.log(`Value: ${variable.value}`);
-              }
-            })
+            const response = await fetch("https://api.trigger.dev/api/v1/runs/run_1234/result", {
+              headers: {
+                "Authorization": `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+              },
+            });
+            const result = await response.json();
 
-    delete:
-      operationId: delete_project_envvar_v1
-      summary: Delete environment variable
-      description: Delete a specific environment variable for a specific project and environment.
+  "/api/v3/runs/{runId}":
+    parameters:
+      - $ref: "#/components/parameters/runId"
+    get:
+      operationId: retrieve_run_v1
+      summary: Retrieve a run
+      description: |
+        Retrieve information about a run, including its status, payload, output, and attempts. If you authenticate with a Public API key, we will omit the payload and output fields for security reasons.
       responses:
         "200":
-          description: Environment variable deleted successfully
+          description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/SucceedResponse"
+                "$ref": "#/components/schemas/RetrieveRunResponse"
         "400":
-          description: Invalid request parameters or body
+          description: Invalid request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Invalid or missing run ID
         "401":
           description: Unauthorized request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Invalid or Missing API key
         "404":
           description: Resource not found
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                type: object
+                properties:
+                  error:
+                    type: string
+                    enum:
+                      - Run not found
       tags:
-        - envvars
+        - run
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Outside of a task
           source: |-
-            import { envvars } from "@trigger.dev/sdk";
+            import { runs } from "@trigger.dev/sdk";
 
-            await envvars.del("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY");
-        - lang: typescript
-          label: Inside a task
-          source: |-
-            import { envvars, task } from "@trigger.dev/sdk";
+            const result = await runs.retrieve("run_1234");
 
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                // projectRef and env are automatically inferred from the task context
-                await envvars.del("SLACK_API_KEY");
+            // We include boolean helpers to check the status of the run
+            // (isSuccess, isFailed, isCompleted, etc.)
+            if (result.isSuccess) {
+              console.log("Run was successful with output", result.output);
+            }
+
+            // You also have access to the run status that includes more granular information
+            console.log("Run status:", result.status);
+
+            // You can access the payload and output
+            console.log("Payload:", result.payload);
+            console.log("Output:", result.output);
+
+            // You can also access the attempts, which will give you information about errors (if they exist)
+            for (const attempt of result.attempts) {
+              if (attempt.status === "FAILED") {
+                console.log("Attempt failed with error:", attempt.error);
               }
-            })
-    put:
-      operationId: update_project_envvar_v1
-      summary: Update environment variable
-      description: Update a specific environment variable for a specific project and environment.
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/EnvVarValue"
+            }
+
+  "/api/v1/runs":
+    get:
+      operationId: list_runs_v1
+      summary: List runs
+      description: List runs in a specific environment. You can filter the runs by status, created at, task identifier, version, and more.
+      parameters:
+        - $ref: "#/components/parameters/cursorPagination"
+        - $ref: "#/components/parameters/runsFilter"
       responses:
         "200":
-          description: Environment variable updated successfully
+          description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/SucceedResponse"
+                $ref: "#/components/schemas/ListRunsResult"
         "400":
-          description: Invalid request parameters or body
+          description: Invalid query parameters
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
+                $ref: "#/components/schemas/ErrorWithDetailsResponse"
         "401":
           description: Unauthorized request
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
-        "404":
-          description: Resource not found
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
       tags:
-        - envvars
+        - runs
       security:
         - secretKey: []
-        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
-          label: Outside of a task
+          label: List runs
           source: |-
-            import { envvars } from "@trigger.dev/sdk";
+            import { runs } from "@trigger.dev/sdk";
 
-            await envvars.update("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY", {
-              value: "slack_123456"
-            });
+            // Get the first page of runs
+            let page = await runs.list({ limit: 20 });
+
+            for (const run of page.data) {
+              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
+            }
+
+            // Convenience methods are provided for manually paginating:
+            while (page.hasNextPage()) {
+              page = await page.getNextPage();
+              // Do something with the next page of runs
+            }
+
+            // Auto-paginate through all runs
+            const allRuns = [];
+
+            for await (const run of runs.list({ limit: 20 })) {
+              allRuns.push(run);
+            }
         - lang: typescript
-          label: Inside a task
+          label: Filter runs
           source: |-
-            import { envvars, task } from "@trigger.dev/sdk";
+            import { runs } from "@trigger.dev/sdk";
 
-            export const myTask = task({
-              id: "my-task",
-              run: async () => {
-                // projectRef and env are automatically inferred from the task context
-                await envvars.update("SLACK_API_KEY", {
-                  value: "slack_123456"
-                });
-              }
-            })
-  "/api/v1/tasks/{taskIdentifier}/trigger":
+            const response = await runs.list({
+              status: ["QUEUED", "EXECUTING"],
+              taskIdentifier: ["my-task", "my-other-task"],
+              from: new Date("2024-04-01T00:00:00Z"),
+              to: new Date(),
+            });
+
+            for (const run of response.data) {
+              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
+            }
+
+  "/api/v1/projects/{projectRef}/runs":
     parameters:
-      - $ref: "#/components/parameters/taskIdentifier"
-    post:
-      operationId: trigger_task_v1
-      summary: Trigger a task
-      description: Trigger a task by its identifier.
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/TriggerTaskRequestBody"
+      - $ref: "#/components/parameters/projectRef"
+    get:
+      operationId: list_project_runs_v1
+      summary: List project runs
+      description: List runs in a project, across multiple environments, using Personal Access Token auth. You can filter the runs by status, created at, task identifier, version, and more.
+      parameters:
+        - $ref: "#/components/parameters/cursorPagination"
+        - $ref: "#/components/parameters/runsFilterWithEnv"
       responses:
         "200":
-          description: Task triggered successfully
+          description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/TriggerTaskResponse"
+                $ref: "#/components/schemas/ListRunsResult"
         "400":
-          description: Invalid request parameters or body
+          description: Invalid request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                $ref: "#/components/schemas/ErrorWithDetailsResponse"
         "401":
           description: Unauthorized request
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - runs
+      security:
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: List runs
+          source: |-
+            import { runs, configure } from "@trigger.dev/sdk";
+
+            configure({
+              accessToken: "tr_pat_1234" // always use an environment variable for this
+            });
+
+            // Get the first page of runs
+            let page = await runs.list("proj_1234", { limit: 20 });
+
+            for (const run of page.data) {
+              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
+            }
+
+            // Convenience methods are provided for manually paginating:
+            while (page.hasNextPage()) {
+              page = await page.getNextPage();
+              // Do something with the next page of runs
+            }
+
+            // Auto-paginate through all runs
+            const allRuns = [];
+
+            for await (const run of runs.list("proj_1234", { limit: 20 })) {
+              allRuns.push(run);
+            }
+        - lang: typescript
+          label: Filter runs
+          source: |-
+            import { runs, configure } from "@trigger.dev/sdk";
+
+            configure({
+              accessToken: "tr_pat_1234" // always use an environment variable for this
+            });
+
+            const response = await runs.list("proj_1234", {
+              env: ["prod", "staging"],
+              status: ["QUEUED", "EXECUTING"],
+              taskIdentifier: ["my-task", "my-other-task"],
+              from: new Date("2024-04-01T00:00:00Z"),
+              to: new Date(),
+            });
+
+            for (const run of response.data) {
+              console.log(`Run ID: ${run.id}, Status: ${run.status}`);
+            }
+
+  "/api/v1/projects/{projectRef}/envvars/{env}":
+    parameters:
+      - $ref: "#/components/parameters/projectRef"
+      - $ref: "#/components/parameters/env"
+    get:
+      operationId: list_project_envvars_v1
+      summary: List environment variables
+      description: List all environment variables for a specific project and environment.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ListEnvironmentVariablesResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
         "404":
           description: Resource not found
           content:
@@ -1223,172 +1551,1452 @@ paths:
               schema:
                 "$ref": "#/components/schemas/ErrorResponse"
       tags:
-        - tasks
+        - envvars
       security:
         - secretKey: []
+        - personalAccessToken: []
       x-codeSamples:
         - lang: typescript
+          label: Outside of a task
           source: |-
-            import { task } from "@trigger.dev/sdk";
-
-            export const myTask = await task({
-              id: "my-task",
-              run: async (payload: { message: string }) => {
-                console.log("Hello, world!");
-              }
-            });
+            import { envvars, configure } from "@trigger.dev/sdk";
 
-            // Somewhere else in your code
-            await myTask.trigger({ message: "Hello, world!" }, {
-              idempotencyKey: "unique-key-123",
-              concurrencyKey: "user123-task",
-              queue: {
-                name: "my-task-queue",
-                concurrencyLimit: 5
-              },
-            });
-        - lang: curl
-          source: |-
-            curl -X POST "https://api.trigger.dev/api/v1/tasks/my-task/trigger" \
-              -H "Content-Type: application/json" \
-              -H "Authorization: Bearer tr_dev_1234" \
-              -d '{
-                    "payload": {
-                      "message": "Hello, world!"
-                    },
-                    "context": {
-                      "user": "user123"
-                    },
-                    "options": {
-                      "queue": {
-                        "name": "default",
-                        "concurrencyLimit": 5
-                      },
-                      "concurrencyKey": "user123-task",
-                      "idempotencyKey": "unique-key-123"
-                    }
-                  }'
-        - lang: python
-          source: |-
-            import requests
+            const variables = await envvars.list("proj_yubjwjsfkxnylobaqvqz", "dev");
 
-            url = "https://api.trigger.dev/api/v1/tasks/my-task/trigger"
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": "Bearer tr_dev_1234"
-            }
-            data = {
-                "payload": {
-                    "message": "Hello, world!"
-                },
-                "context": {
-                    "user": "user123"
-                },
-                "options": {
-                    "queue": {
-                        "name": "default",
-                        "concurrencyLimit": 5
-                    },
-                    "concurrencyKey": "user123-task",
-                    "idempotencyKey": "unique-key-123"
-                }
+            for (const variable of variables) {
+              console.log(`Name: ${variable.name}, Value: ${variable.value}`);
             }
+        - lang: typescript
+          label: Inside a task
+          source: |-
+            import { envvars, task } from "@trigger.dev/sdk";
 
-            response = requests.post(url, headers=headers, json=data)
-            print(response.json())
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                // projectRef and env are automatically inferred from the task context
+                const variables = await envvars.list();
 
-  "/api/v1/tasks/batch":
+                for (const variable of variables) {
+                  console.log(`Name: ${variable.name}, Value: ${variable.value}`);
+                }
+              }
+            })
     post:
-      operationId: batch_trigger_task_v1
-      summary: Batch trigger tasks
-      description: Batch trigger tasks with up to 500 payloads.
+      operationId: create_project_envvar_v1
+      summary: Create environment variable
+      description: Create a new environment variable for a specific project and environment.
       requestBody:
         required: true
         content:
           application/json:
             schema:
-              "$ref": "#/components/schemas/BatchTriggerV2RequestBody"
+              "$ref": "#/components/schemas/EnvVar"
       responses:
         "200":
-          description: Task batch triggered successfully
+          description: Environment variable created successfully
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/BatchTriggerTaskResponse"
+                "$ref": "#/components/schemas/SucceedResponse"
         "400":
           description: Invalid request parameters or body
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+      tags:
+        - envvars
+      security:
+        - secretKey: []
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: Outside of a task
+          source: |-
+            import { envvars } from "@trigger.dev/sdk";
+
+            await envvars.create("proj_yubjwjsfkxnylobaqvqz", "dev", {
+              name: "SLACK_API_KEY",
+              value: "slack_123456"
+            });
+        - lang: typescript
+          label: Inside a task
+          source: |-
+            import { envvars, task } from "@trigger.dev/sdk";
+
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                // projectRef and env are automatically inferred from the task context
+                await envvars.create({
+                  name: "SLACK_API_KEY",
+                  value: "slack_123456"
+                });
+              }
+            })
+
+  "/api/v1/projects/{projectRef}/envvars/{env}/import":
+    parameters:
+      - $ref: "#/components/parameters/projectRef"
+      - $ref: "#/components/parameters/env"
+    post:
+      operationId: upload_project_envvars_v1
+      summary: Upload environment variables
+      description: Upload mulitple environment variables for a specific project and environment.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                variables:
+                  type: array
+                  items:
+                    "$ref": "#/components/schemas/EnvVar"
+                override:
+                  type: boolean
+                  description: Whether to override existing variables or not
+                  default: false
+              required: ["variables"]
+
+      responses:
+        "200":
+          description: Environment variables imported successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/SucceedResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+      tags:
+        - envvars
+      security:
+        - secretKey: []
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: Import variables from an array
+          source: |-
+            import { envvars } from "@trigger.dev/sdk";
+
+            await envvars.upload("proj_yubjwjsfkxnylobaqvqz", "dev", {
+              variables: { SLACK_API_KEY: "slack_key_1234" },
+              override: false
+            });
+
+  "/api/v1/projects/{projectRef}/envvars/{env}/{name}":
+    parameters:
+      - $ref: "#/components/parameters/projectRef"
+      - $ref: "#/components/parameters/env"
+      - $ref: "#/components/parameters/envvarName"
+    get:
+      operationId: get_project_envvar_v1
+      summary: Retrieve environment variable
+      description: Retrieve a specific environment variable for a specific project and environment.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/EnvVarValue"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - envvars
+      security:
+        - secretKey: []
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: Outside of a task
+          source: |-
+            import { envvars } from "@trigger.dev/sdk";
+
+            const variable = await envvars.retrieve("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY");
+
+            console.log(`Value: ${variable.value}`);
+        - lang: typescript
+          label: Inside a task
+          source: |-
+            import { envvars, task } from "@trigger.dev/sdk";
+
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                // projectRef and env are automatically inferred from the task context
+                const variable = await envvars.retrieve("SLACK_API_KEY");
+
+                console.log(`Value: ${variable.value}`);
+              }
+            })
+
+    delete:
+      operationId: delete_project_envvar_v1
+      summary: Delete environment variable
+      description: Delete a specific environment variable for a specific project and environment.
+      responses:
+        "200":
+          description: Environment variable deleted successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/SucceedResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - envvars
+      security:
+        - secretKey: []
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: Outside of a task
+          source: |-
+            import { envvars } from "@trigger.dev/sdk";
+
+            await envvars.del("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY");
+        - lang: typescript
+          label: Inside a task
+          source: |-
+            import { envvars, task } from "@trigger.dev/sdk";
+
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                // projectRef and env are automatically inferred from the task context
+                await envvars.del("SLACK_API_KEY");
+              }
+            })
+    put:
+      operationId: update_project_envvar_v1
+      summary: Update environment variable
+      description: Update a specific environment variable for a specific project and environment.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              "$ref": "#/components/schemas/EnvVarValue"
+      responses:
+        "200":
+          description: Environment variable updated successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/SucceedResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/InvalidEnvVarsRequestResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - envvars
+      security:
+        - secretKey: []
+        - personalAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          label: Outside of a task
+          source: |-
+            import { envvars } from "@trigger.dev/sdk";
+
+            await envvars.update("proj_yubjwjsfkxnylobaqvqz", "dev", "SLACK_API_KEY", {
+              value: "slack_123456"
+            });
+        - lang: typescript
+          label: Inside a task
+          source: |-
+            import { envvars, task } from "@trigger.dev/sdk";
+
+            export const myTask = task({
+              id: "my-task",
+              run: async () => {
+                // projectRef and env are automatically inferred from the task context
+                await envvars.update("SLACK_API_KEY", {
+                  value: "slack_123456"
+                });
+              }
+            })
+  "/api/v1/tasks/{taskIdentifier}/trigger":
+    parameters:
+      - $ref: "#/components/parameters/taskIdentifier"
+    post:
+      operationId: trigger_task_v1
+      summary: Trigger a task
+      description: Trigger a task by its identifier.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              "$ref": "#/components/schemas/TriggerTaskRequestBody"
+      responses:
+        "200":
+          description: Task triggered successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/TriggerTaskResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - tasks
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { task } from "@trigger.dev/sdk";
+
+            export const myTask = await task({
+              id: "my-task",
+              run: async (payload: { message: string }) => {
+                console.log("Hello, world!");
+              }
+            });
+
+            // Somewhere else in your code
+            await myTask.trigger({ message: "Hello, world!" }, {
+              idempotencyKey: "unique-key-123",
+              concurrencyKey: "user123-task",
+              queue: {
+                name: "my-task-queue",
+                concurrencyLimit: 5
+              },
+            });
+        - lang: curl
+          source: |-
+            curl -X POST "https://api.trigger.dev/api/v1/tasks/my-task/trigger" \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -d '{
+                    "payload": {
+                      "message": "Hello, world!"
+                    },
+                    "context": {
+                      "user": "user123"
+                    },
+                    "options": {
+                      "queue": {
+                        "name": "default",
+                        "concurrencyLimit": 5
+                      },
+                      "concurrencyKey": "user123-task",
+                      "idempotencyKey": "unique-key-123"
+                    }
+                  }'
+        - lang: python
+          source: |-
+            import requests
+
+            url = "https://api.trigger.dev/api/v1/tasks/my-task/trigger"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer tr_dev_1234"
+            }
+            data = {
+                "payload": {
+                    "message": "Hello, world!"
+                },
+                "context": {
+                    "user": "user123"
+                },
+                "options": {
+                    "queue": {
+                        "name": "default",
+                        "concurrencyLimit": 5
+                    },
+                    "concurrencyKey": "user123-task",
+                    "idempotencyKey": "unique-key-123"
+                }
+            }
+
+            response = requests.post(url, headers=headers, json=data)
+            print(response.json())
+
+  "/api/v1/tasks/{taskIdentifier}/batch":
+    parameters:
+      - $ref: "#/components/parameters/taskIdentifier"
+    post:
+      operationId: batch_trigger_task_by_id_v1
+      summary: Batch trigger a specific task
+      description: Batch trigger a specific task with up to 1,000 payloads. All items in the batch run the same task.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: ["items"]
+              properties:
+                items:
+                  type: array
+                  description: An array of payloads to trigger the task with (max 1,000 items).
+                  maxItems: 1000
+                  items:
+                    $ref: "#/components/schemas/TriggerTaskRequestBody"
+      responses:
+        "200":
+          description: Batch triggered successfully
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/BatchTriggerTaskResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "404":
+          description: Task not found
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+      tags:
+        - tasks
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { task } from "@trigger.dev/sdk";
+
+            export const myTask = task({
+              id: "my-task",
+              run: async (payload: { message: string }) => {
+                console.log("Hello, world!");
+              }
+            });
+
+            // Somewhere else in your code
+            await myTask.batchTrigger([
+              { payload: { message: "Hello, world!" } },
+              { payload: { message: "Hello again!" } },
+            ]);
+        - lang: curl
+          source: |-
+            curl -X POST "https://api.trigger.dev/api/v1/tasks/my-task/batch" \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -d '{
+                    "items": [
+                      { "payload": { "message": "Hello, world!" } },
+                      { "payload": { "message": "Hello again!" } }
+                    ]
+                  }'
+
+  "/api/v1/tasks/batch":
+    post:
+      operationId: batch_trigger_task_v1
+      summary: Batch trigger tasks
+      description: Batch trigger tasks with up to 1,000 payloads with SDK 4.3.1+ (500 in prior versions).
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              "$ref": "#/components/schemas/BatchTriggerV2RequestBody"
+      responses:
+        "200":
+          description: Task batch triggered successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/BatchTriggerTaskResponse"
+        "400":
+          description: Invalid request parameters or body
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+        "404":
+          description: Resource not found
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ErrorResponse"
+      tags:
+        - tasks
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { task } from "@trigger.dev/sdk";
+
+            export const myTask = await task({
+              id: "my-task",
+              run: async (payload: { message: string }) => {
+                console.log("Hello, world!");
+              }
+            });
+
+            // Somewhere else in your code
+            await myTask.batchTrigger([
+              {
+                payload: { message: "Hello, world!" },
+                options: {
+                  idempotencyKey: "unique-key-123",
+                  concurrencyKey: "user-123-task",
+                  queue: {
+                    name: "my-task-queue",
+                    concurrencyLimit: 5
+                  }
+                }
+              }
+            ]);
+        - lang: curl
+          source: |-
+            curl -X POST "https://api.trigger.dev/api/v1/tasks/batch" \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer tr_dev_1234" \
+              -d '{
+                    "items": [
+                      {
+                        "task": "my-task",
+                        "payload": {
+                          "message": "Hello, world!"
+                        },
+                        "context": {
+                          "user": "user123"
+                        },
+                        "options": {
+                          "queue": {
+                            "name": "default",
+                            "concurrencyLimit": 5
+                          },
+                          "concurrencyKey": "user123-task",
+                          "idempotencyKey": "unique-key-123"
+                        }
+                      }
+                    ]
+                  }'
+
+  "/api/v1/batches/{batchId}":
+    parameters:
+      - $ref: "#/components/parameters/batchId"
+    get:
+      operationId: retrieve_batch_v1
+      summary: Retrieve a batch
+      description: Retrieve a batch by its ID, including its status and the IDs of all runs in the batch.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The batch ID.
+                  status:
+                    type: string
+                    enum: [PENDING, PROCESSING, COMPLETED, PARTIAL_FAILED, ABORTED]
+                    description: The current status of the batch.
+                  idempotencyKey:
+                    type: string
+                    nullable: true
+                    description: The idempotency key provided when triggering, if any.
+                  createdAt:
+                    type: string
+                    format: date-time
+                  updatedAt:
+                    type: string
+                    format: date-time
+                  runCount:
+                    type: integer
+                    description: The total number of runs in the batch.
+                  runs:
+                    type: array
+                    items:
+                      type: string
+                    description: Array of run IDs in the batch.
+                  successfulRunCount:
+                    type: integer
+                    nullable: true
+                    description: Number of successful runs (populated after completion).
+                  failedRunCount:
+                    type: integer
+                    nullable: true
+                    description: Number of failed runs (populated after completion).
+                  errors:
+                    type: array
+                    nullable: true
+                    description: Error details for failed items (present for PARTIAL_FAILED batches).
+                    items:
+                      type: object
+                      properties:
+                        index:
+                          type: integer
+                          description: The index of the failed item.
+                        taskIdentifier:
+                          type: string
+                          description: The task identifier of the failed item.
+                        error:
+                          type: object
+                          description: The error details.
+                        errorCode:
+                          type: string
+                          nullable: true
+                          description: An optional error code.
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "404":
+          description: Batch not found
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+      tags:
+        - batches
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          label: Fetch
+          source: |-
+            const response = await fetch("https://api.trigger.dev/api/v1/batches/batch_1234", {
+              headers: {
+                "Authorization": `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+              },
+            });
+            const batch = await response.json();
+
+  "/api/v1/batches/{batchId}/results":
+    parameters:
+      - $ref: "#/components/parameters/batchId"
+    get:
+      operationId: get_batch_results_v1
+      summary: Retrieve batch results
+      description: Returns the execution results of all completed runs in a batch. Only finished runs (successful or failed) are included in the items array — runs that are still executing are omitted. Returns 404 if the batch doesn't exist.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  id:
+                    type: string
+                    description: The batch ID.
+                  items:
+                    type: array
+                    description: Execution results for each run in the batch.
+                    items:
+                      type: object
+                      required: [ok, id]
+                      properties:
+                        ok:
+                          type: boolean
+                          description: Whether this run completed successfully.
+                        id:
+                          type: string
+                          description: The run ID.
+                        output:
+                          type: string
+                          description: The serialized output as a string (present when ok is true). Use outputType to determine how to parse it — for "application/json" use JSON.parse().
+                        outputType:
+                          type: string
+                          description: The content type of the serialized output, e.g. "application/json".
+                        error:
+                          type: object
+                          description: Error details (present when ok is false).
+                        usage:
+                          type: object
+                          properties:
+                            durationMs:
+                              type: number
+                              description: Duration of the run in milliseconds.
+                        taskIdentifier:
+                          type: string
+                          description: The task identifier.
+        "401":
+          description: Unauthorized request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+        "404":
+          description: Batch not found
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+      tags:
+        - batches
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          label: Fetch
+          source: |-
+            const response = await fetch("https://api.trigger.dev/api/v1/batches/batch_1234/results", {
+              headers: {
+                "Authorization": `Bearer ${process.env.TRIGGER_SECRET_KEY}`,
+              },
+            });
+            const results = await response.json();
+
+  "/api/v1/queues":
+    get:
+      operationId: list_queues_v1
+      summary: List all queues
+      description: List all queues in your environment with pagination support.
+      parameters:
+        - in: query
+          name: page
+          schema:
+            type: integer
+          required: false
+          description: Page number of the queue listing (1-based)
+        - in: query
+          name: perPage
+          schema:
+            type: integer
+          required: false
+          description: Number of queues per page
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ListQueuesResult"
+        "401":
+          description: Unauthorized request
+      tags:
+        - queues
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { queues } from "@trigger.dev/sdk";
+
+            // List all queues
+            const allQueues = await queues.list();
+
+            // With pagination
+            const pagedQueues = await queues.list({
+              page: 1,
+              perPage: 20,
+            });
+
+  "/api/v1/queues/{queueParam}":
+    get:
+      operationId: retrieve_queue_v1
+      summary: Retrieve a queue
+      description: Get a queue by its ID, or by type and name.
+      parameters:
+        - in: path
+          name: queueParam
+          required: true
+          schema:
+            type: string
+          description: The queue ID (e.g., `queue_1234`), or the name of the queue when using the `type` query parameter.
+          example: queue_1234
+        - in: query
+          name: type
+          schema:
+            type: string
+            enum: [id, task, custom]
+            default: id
+          required: false
+          description: |
+            How to interpret the `queueParam` path parameter:
+            - `id`: Treat as a queue ID (default)
+            - `task`: Treat as a task ID to get the task's default queue
+            - `custom`: Treat as a custom queue name
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/QueueObject"
+        "401":
+          description: Unauthorized request
+        "404":
+          description: Queue not found
+      tags:
+        - queues
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { queues } from "@trigger.dev/sdk";
+
+            // Using queue ID
+            const queue = await queues.retrieve("queue_1234");
+
+            // Using type and name for a task queue
+            const taskQueue = await queues.retrieve({
+              type: "task",
+              name: "my-task-id",
+            });
+
+            // Using type and name for a custom queue
+            const customQueue = await queues.retrieve({
+              type: "custom",
+              name: "my-custom-queue",
+            });
+
+  "/api/v1/queues/{queueParam}/pause":
+    post:
+      operationId: pause_queue_v1
+      summary: Pause or resume a queue
+      description: Pause a queue to prevent new runs from starting, or resume a paused queue. Runs that are currently executing will continue to completion.
+      parameters:
+        - in: path
+          name: queueParam
+          required: true
+          schema:
+            type: string
+          description: The queue ID (e.g., `queue_1234`), or the name of the queue when using the `type` body parameter.
+          example: queue_1234
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: ["action"]
+              properties:
+                type:
+                  type: string
+                  enum: [id, task, custom]
+                  default: id
+                  description: |
+                    How to interpret the `queueParam` path parameter:
+                    - `id`: Treat as a queue ID (default)
+                    - `task`: Treat as a task ID to get the task's default queue
+                    - `custom`: Treat as a custom queue name
+                action:
+                  type: string
+                  enum: [pause, resume]
+                  description: Whether to pause or resume the queue
+      responses:
+        "200":
+          description: Queue paused or resumed successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/QueueObject"
+        "400":
+          description: Invalid request parameters
+        "401":
+          description: Unauthorized request
+        "404":
+          description: Queue not found
+      tags:
+        - queues
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { queues } from "@trigger.dev/sdk";
+
+            // Pause a queue
+            await queues.pause("queue_1234");
+            await queues.pause({ type: "task", name: "my-task-id" });
+
+            // Resume a queue
+            await queues.resume("queue_1234");
+            await queues.resume({ type: "task", name: "my-task-id" });
+
+  "/api/v1/queues/{queueParam}/concurrency/override":
+    post:
+      operationId: override_queue_concurrency_v1
+      summary: Override queue concurrency limit
+      description: Override the concurrency limit of a queue. This is useful for temporarily scaling up or down based on demand.
+      parameters:
+        - in: path
+          name: queueParam
+          required: true
+          schema:
+            type: string
+          description: The queue ID (e.g., `queue_1234`), or the name of the queue when using the `type` body parameter.
+          example: queue_1234
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: ["concurrencyLimit"]
+              properties:
+                type:
+                  type: string
+                  enum: [id, task, custom]
+                  default: id
+                  description: |
+                    How to interpret the `queueParam` path parameter:
+                    - `id`: Treat as a queue ID (default)
+                    - `task`: Treat as a task ID to get the task's default queue
+                    - `custom`: Treat as a custom queue name
+                concurrencyLimit:
+                  type: integer
+                  minimum: 0
+                  maximum: 100000
+                  description: The new concurrency limit to set for the queue
+      responses:
+        "200":
+          description: Concurrency limit overridden successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/QueueObject"
+        "400":
+          description: Invalid request parameters
+        "401":
+          description: Unauthorized request
+        "404":
+          description: Queue not found
+      tags:
+        - queues
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { queues } from "@trigger.dev/sdk";
+
+            // Override concurrency limit to 5
+            await queues.overrideConcurrencyLimit("queue_1234", 5);
+
+            // Using type and name
+            await queues.overrideConcurrencyLimit(
+              { type: "task", name: "my-task-id" },
+              20
+            );
+
+  "/api/v1/queues/{queueParam}/concurrency/reset":
+    post:
+      operationId: reset_queue_concurrency_v1
+      summary: Reset queue concurrency limit
+      description: Reset the concurrency limit of a queue back to its base value defined in code.
+      parameters:
+        - in: path
+          name: queueParam
+          required: true
+          schema:
+            type: string
+          description: The queue ID (e.g., `queue_1234`), or the name of the queue when using the `type` body parameter.
+          example: queue_1234
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                type:
+                  type: string
+                  enum: [id, task, custom]
+                  default: id
+                  description: |
+                    How to interpret the `queueParam` path parameter:
+                    - `id`: Treat as a queue ID (default)
+                    - `task`: Treat as a task ID to get the task's default queue
+                    - `custom`: Treat as a custom queue name
+      responses:
+        "200":
+          description: Concurrency limit reset successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/QueueObject"
+        "400":
+          description: Queue is not overridden or invalid request parameters
+        "401":
+          description: Unauthorized request
+        "404":
+          description: Queue not found
+      tags:
+        - queues
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { queues } from "@trigger.dev/sdk";
+
+            // Reset concurrency limit to the base value
+            await queues.resetConcurrencyLimit("queue_1234");
+
+            // Using type and name
+            await queues.resetConcurrencyLimit({
+              type: "task",
+              name: "my-task-id",
+            });
+
+  "/api/v1/waitpoints/tokens":
+    post:
+      operationId: create_waitpoint_token_v1
+      summary: Create a waitpoint token
+      description: >-
+        Creates a new waitpoint token that can be used to pause a run until an external event completes it.
+        The token includes a `url` which can be called via HTTP POST to complete the waitpoint.
+        Use the token ID with `wait.forToken()` inside a task to pause execution until the token is completed.
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              "$ref": "#/components/schemas/CreateWaitpointTokenRequest"
+      responses:
+        "200":
+          description: Waitpoint token created successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/CreateWaitpointTokenResponse"
+        "401":
+          description: Unauthorized
+        "422":
+          description: Unprocessable Entity
+        "500":
+          description: Internal Server Error
+      tags:
+        - waitpoints
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { wait } from "@trigger.dev/sdk";
+
+            const token = await wait.createToken({
+              timeout: "1h",
+              tags: ["user:1234567"],
+            });
+
+            console.log(token.id);  // e.g. "waitpoint_abc123"
+            console.log(token.url); // HTTP callback URL to complete externally
+
+    get:
+      operationId: list_waitpoint_tokens_v1
+      summary: List waitpoint tokens
+      description: >-
+        Returns a paginated list of waitpoint tokens for the current environment.
+        Results are ordered by creation date, newest first. Use cursor-based pagination
+        with `page[after]` and `page[before]` to navigate pages.
+      parameters:
+        - in: query
+          name: "page[size]"
+          schema:
+            type: integer
+            minimum: 1
+            maximum: 100
+          required: false
+          description: Number of tokens to return per page (1–100).
+        - in: query
+          name: "page[after]"
+          schema:
+            type: string
+          required: false
+          description: Return tokens after this cursor (from `pagination.next` in a previous response).
+        - in: query
+          name: "page[before]"
+          schema:
+            type: string
+          required: false
+          description: Return tokens before this cursor (from `pagination.previous` in a previous response).
+        - in: query
+          name: "filter[status]"
+          schema:
+            type: string
+          required: false
+          description: >-
+            Comma-separated list of statuses to filter by.
+            Allowed values: `WAITING`, `COMPLETED`, `TIMED_OUT`.
+          example: "WAITING,COMPLETED"
+        - in: query
+          name: "filter[idempotencyKey]"
+          schema:
+            type: string
+          required: false
+          description: Filter by idempotency key.
+        - in: query
+          name: "filter[tags]"
+          schema:
+            type: string
+          required: false
+          description: Comma-separated list of tags to filter by.
+          example: "user:1234567,org:9876543"
+        - in: query
+          name: "filter[createdAt][period]"
+          schema:
+            type: string
+          required: false
+          description: >-
+            Shorthand time period to filter by creation date (e.g. `1h`, `24h`, `7d`).
+            Cannot be combined with `filter[createdAt][from]` or `filter[createdAt][to]`.
+          example: "24h"
+        - in: query
+          name: "filter[createdAt][from]"
+          schema:
+            type: string
+            format: date-time
+          required: false
+          description: Filter tokens created at or after this ISO 8601 timestamp.
+        - in: query
+          name: "filter[createdAt][to]"
+          schema:
+            type: string
+            format: date-time
+          required: false
+          description: Filter tokens created at or before this ISO 8601 timestamp.
+      responses:
+        "200":
+          description: Successful request
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/ListWaitpointTokensResult"
+        "401":
+          description: Unauthorized
+        "422":
+          description: Invalid query parameters (e.g. unrecognised status value)
+        "500":
+          description: Internal Server Error
+      tags:
+        - waitpoints
+      security:
+        - secretKey: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { wait } from "@trigger.dev/sdk";
+
+            // Iterate over all tokens (auto-paginated)
+            for await (const token of wait.listTokens()) {
+              console.log(token.id, token.status);
+            }
+
+            // Filter by status and tags
+            for await (const token of wait.listTokens({
+              status: ["WAITING"],
+              tags: ["user:1234567"],
+            })) {
+              console.log(token.id);
+            }
+
+  "/api/v1/waitpoints/tokens/{waitpointId}/callback/{callbackHash}":
+    post:
+      operationId: complete_waitpoint_token_callback_v1
+      summary: Complete a waitpoint token via HTTP callback
+      description: >-
+        Completes a waitpoint token using the pre-signed callback URL returned in the `url`
+        field when the token was created. No API key is required — the `callbackHash` in
+        the URL acts as the authentication token.
+
+
+        This is designed to be given directly to external services (e.g. as a webhook URL)
+        so they can unblock a waiting run without needing access to your API key.
+        The entire request body is passed as the output data to the waiting run.
+
+
+        If the token is already completed, this is a no-op and returns `success: true`.
+      parameters:
+        - in: path
+          name: waitpointId
+          required: true
+          schema:
+            type: string
+          description: The ID of the waitpoint token.
+          example: waitpoint_abc123
+        - in: path
+          name: callbackHash
+          required: true
+          schema:
+            type: string
+          description: >-
+            The HMAC hash that authenticates the request. This is embedded in the `url`
+            returned when creating the token — do not construct it manually.
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              type: object
+              description: >-
+                Any JSON object. The entire body is passed as the output data to the run
+                waiting on this token. If the body is not valid JSON, an empty object is used.
+              example:
+                status: approved
+                comment: Looks good to me!
+      responses:
+        "200":
+          description: Waitpoint token completed successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/CompleteWaitpointTokenResponse"
+        "401":
+          description: Invalid callback URL or hash mismatch
+        "404":
+          description: Waitpoint token not found
+        "405":
+          description: Method not allowed
+        "411":
+          description: Content-Length header is required
+        "413":
+          description: Request body too large
+        "500":
+          description: Internal Server Error
+      tags:
+        - waitpoints
+      x-codeSamples:
+        - lang: Shell
+          label: cURL
+          source: |-
+            # The full URL is returned as `url` when you create a token
+            curl -X POST "https://api.trigger.dev/api/v1/waitpoints/tokens/waitpoint_abc123/callback/abc123hash" \
+              -H "Content-Type: application/json" \
+              -d '{"status": "approved", "comment": "Looks good to me!"}'
+        - lang: typescript
+          source: |-
+            import { wait } from "@trigger.dev/sdk";
+
+            // In your task: create the token and send the URL to an external service
+            const token = await wait.createToken({ timeout: "1h" });
+
+            await sendApprovalRequestEmail({
+              callbackUrl: token.url, // give this URL to the external service
+            });
+
+            // The external service POSTs to token.url to unblock the run
+            const result = await wait.forToken<{ status: string }>(token);
+
+  "/api/v1/waitpoints/tokens/{waitpointId}/complete":
+    post:
+      operationId: complete_waitpoint_token_v1
+      summary: Complete a waitpoint token
+      description: >-
+        Completes a waitpoint token, unblocking any run that is waiting for it via `wait.forToken()`.
+        An optional `data` payload can be passed and will be returned to the waiting run.
+        If the token is already completed, this is a no-op and returns `success: true`.
+
+
+        This endpoint accepts both secret API keys and short-lived JWTs (public access tokens),
+        making it safe to call from frontend clients.
+      parameters:
+        - in: path
+          name: waitpointId
+          required: true
+          schema:
+            type: string
+          description: The ID of the waitpoint token to complete.
+          example: waitpoint_abc123
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              "$ref": "#/components/schemas/CompleteWaitpointTokenRequest"
+      responses:
+        "200":
+          description: Waitpoint token completed successfully
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/CompleteWaitpointTokenResponse"
         "401":
-          description: Unauthorized request
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+          description: Unauthorized
         "404":
-          description: Resource not found
+          description: Waitpoint token not found
+        "500":
+          description: Internal Server Error
+      tags:
+        - waitpoints
+      security:
+        - secretKey: []
+        - publicAccessToken: []
+      x-codeSamples:
+        - lang: typescript
+          source: |-
+            import { wait } from "@trigger.dev/sdk";
+
+            // Complete with data (returned to the waiting run)
+            await wait.completeToken(token, {
+              status: "approved",
+              comment: "Looks good to me!",
+            });
+
+            // Complete with no data
+            await wait.completeToken(token, {});
+
+  "/api/v1/waitpoints/tokens/{waitpointId}":
+    get:
+      operationId: retrieve_waitpoint_token_v1
+      summary: Retrieve a waitpoint token
+      description: >-
+        Retrieves a waitpoint token by its ID, including its current status and output
+        if it has been completed.
+      parameters:
+        - in: path
+          name: waitpointId
+          required: true
+          schema:
+            type: string
+          description: The ID of the waitpoint token.
+          example: waitpoint_abc123
+      responses:
+        "200":
+          description: Successful request
           content:
             application/json:
               schema:
-                "$ref": "#/components/schemas/ErrorResponse"
+                "$ref": "#/components/schemas/WaitpointTokenObject"
+        "401":
+          description: Unauthorized
+        "404":
+          description: Waitpoint token not found
+        "500":
+          description: Internal Server Error
       tags:
-        - tasks
+        - waitpoints
       security:
         - secretKey: []
       x-codeSamples:
         - lang: typescript
           source: |-
-            import { task } from "@trigger.dev/sdk";
+            import { wait } from "@trigger.dev/sdk";
 
-            export const myTask = await task({
-              id: "my-task",
-              run: async (payload: { message: string }) => {
-                console.log("Hello, world!");
-              }
-            });
+            const token = await wait.retrieveToken("waitpoint_abc123");
 
-            // Somewhere else in your code
-            await myTask.batchTrigger([
-              {
-                payload: { message: "Hello, world!" },
-                options: {
-                  idempotencyKey: "unique-key-123",
-                  concurrencyKey: "user-123-task",
-                  queue: {
-                    name: "my-task-queue",
-                    concurrencyLimit: 5
-                  }
-                }
-              }
-            ]);
-        - lang: curl
-          source: |-
-            curl -X POST "https://api.trigger.dev/api/v1/tasks/batch" \
-              -H "Content-Type: application/json" \
-              -H "Authorization: Bearer tr_dev_1234" \
-              -d '{
-                    "items": [
-                      {
-                        "task": "my-task",
-                        "payload": {
-                          "message": "Hello, world!"
-                        },
-                        "context": {
-                          "user": "user123"
-                        },
-                        "options": {
-                          "queue": {
-                            "name": "default",
-                            "concurrencyLimit": 5
-                          },
-                          "concurrencyKey": "user123-task",
-                          "idempotencyKey": "unique-key-123"
-                        }
-                      }
-                    ]
-                  }'
+            console.log(token.status); // "WAITING" | "COMPLETED" | "TIMED_OUT"
+
+            if (token.status === "COMPLETED") {
+              console.log(token.output);
+            }
 
 components:
   parameters:
@@ -1461,6 +3069,14 @@ components:
       description: |
         The ID of an run, starts with `run_`. The run ID will be returned when you trigger a run on a task.
       example: run_1234
+    batchId:
+      in: path
+      name: batchId
+      required: true
+      schema:
+        type: string
+      description: The ID of the batch, starts with `batch_`.
+      example: batch_1234
     projectRef:
       in: path
       name: projectRef
@@ -1516,7 +3132,98 @@ components:
 
         configure({ accessToken: "tr_pat_1234" });
         ```
+
+    publicAccessToken:
+      type: http
+      scheme: bearer
+      description: |
+        A short-lived JWT scoped to a specific waitpoint token. Returned as `publicAccessToken`
+        when you call `wait.createToken()` or `POST /api/v1/waitpoints/tokens`.
+
+        This token is safe to embed in frontend clients — it can only complete the specific
+        waitpoint it was issued for and cannot be used for any other API operations.
+
   schemas:
+    RunTag:
+      type: string
+      maxLength: 128
+      description: A single run tag. Must be less than 128 characters.
+      example: "user_123456"
+    RunTags:
+      oneOf:
+        - $ref: "#/components/schemas/RunTag"
+        - type: array
+          items:
+            $ref: "#/components/schemas/RunTag"
+          maxItems: 10
+          uniqueItems: true
+          example: ["user_123456", "product_4629101"]
+      description: One or more tags to attach to a run. Runs can have a maximum of 10 tags.
+    SpanDetailedSummary:
+      type: object
+      properties:
+        id:
+          type: string
+          description: The span ID.
+        parentId:
+          type: string
+          nullable: true
+          description: The parent span ID, if any.
+        runId:
+          type: string
+          description: The run ID this span belongs to.
+        data:
+          type: object
+          properties:
+            message:
+              type: string
+              description: The span message.
+            taskSlug:
+              type: string
+              description: The task identifier, if applicable.
+            startTime:
+              type: string
+              format: date-time
+              description: The start time of the span.
+            duration:
+              type: number
+              description: The duration of the span in nanoseconds.
+            isError:
+              type: boolean
+            isPartial:
+              type: boolean
+            isCancelled:
+              type: boolean
+            level:
+              type: string
+              enum: [TRACE, DEBUG, LOG, INFO, WARN, ERROR]
+            attemptNumber:
+              type: number
+              nullable: true
+            properties:
+              type: object
+              description: Arbitrary OTel attributes attached to the span.
+            events:
+              type: array
+              description: Span events (e.g. exceptions, cancellations) that occurred during this span.
+              items:
+                type: object
+                properties:
+                  name:
+                    type: string
+                    description: The event name (e.g. "exception", "cancellation", "attempt_failed").
+                  time:
+                    type: string
+                    format: date-time
+                    description: The time the event occurred.
+                  properties:
+                    type: object
+                    description: Event-specific properties.
+        children:
+          type: array
+          description: Nested child spans. Each child has the same structure as the parent span.
+          items:
+            $ref: "#/components/schemas/SpanDetailedSummary"
     TriggerTaskResponse:
       type: object
       properties:
@@ -1535,6 +3242,97 @@ components:
           minimum: 0
           maximum: 1000
           description: An optional property that specifies the maximum number of concurrent run executions. If this property is omitted, the task can potentially use up the full concurrency of an environment.
+    QueueObject:
+      type: object
+      required: ["id", "name", "type", "running", "queued", "paused"]
+      properties:
+        id:
+          type: string
+          description: The queue ID, e.g., `queue_1234`
+          example: queue_1234
+        name:
+          type: string
+          description: The queue name. For task queues, this is the task ID. For custom queues, this is the name you specified.
+          example: my-task-id
+        type:
+          type: string
+          enum: [task, custom]
+          description: |
+            The type of queue:
+            - `task`: Created automatically for each task
+            - `custom`: Created explicitly in your code using `queue()`
+          example: task
+        running:
+          type: integer
+          description: The number of runs currently executing
+          example: 5
+        queued:
+          type: integer
+          description: The number of runs currently queued
+          example: 10
+        paused:
+          type: boolean
+          description: Whether the queue is paused. When paused, no new runs will start.
+          example: false
+        concurrencyLimit:
+          type: integer
+          nullable: true
+          description: The current concurrency limit of the queue
+          example: 10
+        concurrency:
+          type: object
+          description: Detailed concurrency information
+          properties:
+            current:
+              type: integer
+              nullable: true
+              description: The effective/current concurrency limit
+              example: 10
+            base:
+              type: integer
+              nullable: true
+              description: The base concurrency limit defined in code
+              example: 10
+            override:
+              type: integer
+              nullable: true
+              description: The override concurrency limit (if set)
+              example: null
+            overriddenAt:
+              type: string
+              format: date-time
+              nullable: true
+              description: When the concurrency limit was overridden
+              example: null
+            overriddenBy:
+              type: string
+              nullable: true
+              description: Who overrode the concurrency limit (null if via API)
+              example: null
+    ListQueuesResult:
+      type: object
+      required: ["data", "pagination"]
+      properties:
+        data:
+          type: array
+          items:
+            "$ref": "#/components/schemas/QueueObject"
+          description: An array of queue objects
+        pagination:
+          type: object
+          properties:
+            currentPage:
+              type: integer
+              description: The current page number
+              example: 1
+            totalPages:
+              type: integer
+              description: The total number of pages
+              example: 5
+            count:
+              type: integer
+              description: The total number of queues
+              example: 50
     BatchTriggerRequestBody:
       type: object
       properties:
@@ -1600,18 +3398,14 @@ components:
             delay:
               $ref: "#/components/schemas/Delay"
             tags:
-              type:
-                - array
-                - string
-              example: ["user_123456", "product_4629101"]
+              allOf:
+                - $ref: "#/components/schemas/RunTags"
               description: |
                 Tags to attach to the run. Tags can be used to filter runs in the dashboard and using the SDK.
 
-                You can set up to 5 tags per run, they must be less than 64 characters each.
+                You can set up to 10 tags per run, each must be less than 128 characters.
 
                 We recommend prefixing tags with a namespace using an underscore or colon, like `user_1234567` or `org:9876543`. Stripe uses underscores.
-              items:
-                type: string
             machine:
               type: string
               enum:
@@ -2717,3 +4511,232 @@ components:
         stackTrace:
           type: string
           example: "Error: Something went wrong"
+    ExecuteQueryRequestBody:
+      type: object
+      required:
+        - query
+      properties:
+        query:
+          type: string
+          description: The TRQL query to execute
+          example: "SELECT run_id, status, triggered_at FROM runs WHERE status = 'Failed' LIMIT 10"
+        scope:
+          type: string
+          enum: ["environment", "project", "organization"]
+          default: "environment"
+          description: The scope of data to query - environment (default), project, or organization
+        period:
+          type: string
+          nullable: true
+          description: Time period shorthand (e.g., "7d", "30d", "1h"). Cannot be used with from/to.
+          example: "7d"
+        from:
+          type: string
+          format: date-time
+          nullable: true
+          description: Start of time range as ISO 8601 timestamp. Must be used with 'to'.
+          example: "2024-01-01T00:00:00Z"
+        to:
+          type: string
+          format: date-time
+          nullable: true
+          description: End of time range as ISO 8601 timestamp. Must be used with 'from'.
+          example: "2024-01-31T23:59:59Z"
+        format:
+          type: string
+          enum: ["json", "csv"]
+          default: "json"
+          description: Response format - "json" returns structured data (default), "csv" returns CSV string
+    ExecuteQueryResponse:
+      oneOf:
+        - type: object
+          description: JSON format response
+          properties:
+            format:
+              type: string
+              enum: ["json"]
+            results:
+              type: array
+              items:
+                type: object
+              description: Array of result rows
+        - type: object
+          description: CSV format response
+          properties:
+            format:
+              type: string
+              enum: ["csv"]
+            results:
+              type: string
+              description: CSV-formatted results
+    CompleteWaitpointTokenRequest:
+      type: object
+      properties:
+        data:
+          description: >-
+            Any JSON-serializable value to pass back to the run waiting on this token.
+            The data will be returned from `wait.forToken()` as the result payload.
+          example:
+            status: approved
+            comment: Looks good to me!
+    CompleteWaitpointTokenResponse:
+      type: object
+      required:
+        - success
+      properties:
+        success:
+          type: boolean
+          enum:
+            - true
+          description: Always `true` when the request succeeds.
+    ListWaitpointTokensResult:
+      type: object
+      required:
+        - data
+        - pagination
+      properties:
+        data:
+          type: array
+          items:
+            "$ref": "#/components/schemas/WaitpointTokenObject"
+          description: An array of waitpoint token objects.
+        pagination:
+          type: object
+          properties:
+            next:
+              type: string
+              nullable: true
+              description: >-
+                Cursor for the next page. Pass as `page[after]` in the next request.
+              example: waitpoint_abc123
+            previous:
+              type: string
+              nullable: true
+              description: >-
+                Cursor for the previous page. Pass as `page[before]` in the next request.
+              example: waitpoint_xyz789
+    WaitpointTokenObject:
+      type: object
+      required:
+        - id
+        - url
+        - status
+        - tags
+        - createdAt
+      properties:
+        id:
+          type: string
+          description: The unique ID of the waitpoint token.
+          example: waitpoint_abc123
+        url:
+          type: string
+          description: >-
+            An HTTP callback URL. A POST request to this URL (with an optional JSON body)
+            will complete the waitpoint without needing an API key.
+          example: https://api.trigger.dev/api/v1/waitpoints/tokens/waitpoint_abc123/callback/abc123hash
+        status:
+          type: string
+          enum:
+            - WAITING
+            - COMPLETED
+            - TIMED_OUT
+          description: The current status of the waitpoint token.
+        idempotencyKey:
+          type: string
+          nullable: true
+          description: The idempotency key used when creating the token, if any.
+        idempotencyKeyExpiresAt:
+          type: string
+          format: date-time
+          nullable: true
+          description: When the idempotency key expires.
+        timeoutAt:
+          type: string
+          format: date-time
+          nullable: true
+          description: When the token will time out, if a timeout was set.
+        completedAt:
+          type: string
+          format: date-time
+          nullable: true
+          description: When the token was completed, if it has been completed.
+        output:
+          type: string
+          nullable: true
+          description: >-
+            The serialized output data passed when completing the token.
+            Only present when `status` is `COMPLETED`.
+        outputType:
+          type: string
+          nullable: true
+          description: The content type of the output (e.g. `"application/json"`).
+        outputIsError:
+          type: boolean
+          nullable: true
+          description: Whether the output represents an error (e.g. a timeout).
+        tags:
+          type: array
+          items:
+            type: string
+          description: Tags attached to the waitpoint.
+        createdAt:
+          type: string
+          format: date-time
+          description: When the waitpoint token was created.
+    CreateWaitpointTokenRequest:
+      type: object
+      properties:
+        idempotencyKey:
+          type: string
+          description: >-
+            An optional idempotency key. If you pass the same key twice before it expires,
+            you will receive the original token back. The returned token may already be completed,
+            in which case `wait.forToken()` will continue immediately.
+          example: approval-user-1234567
+        idempotencyKeyTTL:
+          type: string
+          description: >-
+            How long the idempotency key is valid, after which passing the same key
+            creates a new waitpoint. Accepts durations like "30s", "1m", "2h", "3d".
+          example: 1h
+        timeout:
+          type: string
+          description: >-
+            How long to wait before the token times out. When a run is waiting for a timed-out
+            token, `wait.forToken()` returns with `ok: false`. Accepts an ISO 8601 date string
+            or duration shorthand like "30s", "1m", "2h", "3d", "4w".
+          example: 1h
+        tags:
+          oneOf:
+            - type: string
+            - type: array
+              items:
+                type: string
+          description: >-
+            Tags to attach to the waitpoint. You can set up to 10 tags, each under 128 characters.
+            We recommend namespacing tags with a prefix like `user:1234567` or `org_9876543`.
+          example:
+            - "user:1234567"
+            - "org:9876543"
+    CreateWaitpointTokenResponse:
+      type: object
+      required:
+        - id
+        - isCached
+        - url
+      properties:
+        id:
+          type: string
+          description: The unique ID of the waitpoint token.
+          example: waitpoint_abc123
+        isCached:
+          type: boolean
+          description: >-
+            `true` if an existing token was returned because the same `idempotencyKey`
+            was used within its TTL window.
+        url:
+          type: string
+          description: >-
+            An HTTP callback URL. A POST request to this URL (with an optional JSON body)
+            will complete the waitpoint without needing an API key.
+          example: https://api.trigger.dev/api/v1/waitpoints/tokens/waitpoint_abc123/callback/abc123hash
diff --git a/docs/vercel-integration.mdx b/docs/vercel-integration.mdx
index 36b769c2328..a465f5aa39b 100644
--- a/docs/vercel-integration.mdx
+++ b/docs/vercel-integration.mdx
@@ -1,8 +1,201 @@
 ---
 title: "Vercel integration"
-description: "When you deploy to Vercel, automatically deploy your associated tasks."
+description: "Automatically deploy your tasks whenever you deploy to Vercel."
 ---
 
-import ComingSoon from "/snippets/coming-soon-in-review.mdx"
+## How it works
 
-<ComingSoon />
+The Vercel integration connects your Vercel project to your Trigger.dev project so that every Vercel deployment automatically triggers a Trigger.dev deployment. It also syncs environment variables from Vercel into Trigger.dev and supports atomic deployments to keep your app and tasks in sync.
+
+This eliminates the need to manually run the `trigger.dev deploy` command or maintain custom CI/CD workflows for Vercel-based projects.
+
+<Note>
+  The Vercel integration requires the [GitHub integration](/github-integration) to be connected as
+  well, since Trigger.dev builds your tasks from your GitHub repository.
+</Note>
+
+## Installation
+
+You can connect Vercel from two entry points:
+
+### From the Trigger.dev dashboard
+
+<Steps>
+
+<Step title="Connect Vercel">
+  Go to your project's **Settings** page and click **Connect Vercel**. This will redirect you to
+  Vercel to authorize the Trigger.dev app.
+</Step>
+
+<Step title="Select a Vercel project">
+  Choose which Vercel project to connect to your Trigger.dev project.
+</Step>
+
+<Step title="Map environments">
+  If your Vercel project has custom environments, choose which one maps to your Trigger.dev staging
+  environment.
+</Step>
+
+<Step title="Sync environment variables">
+  Review the environment variables that will be pulled from Vercel into Trigger.dev. You can
+  deselect any variables you don't want to sync.
+</Step>
+
+<Step title="Configure build options">
+  Optionally adjust [build options](#build-options) for atomic deployments, env var pulling, and new
+  env var discovery.
+</Step>
+
+<Step title="Connect GitHub">
+  If your GitHub repository isn't already connected, you'll be prompted to connect it.
+</Step>
+
+</Steps>
+
+### From the Vercel Marketplace
+
+<Steps>
+
+<Step title="Install the integration">
+  Install the [Trigger.dev integration from the Vercel
+  Marketplace](https://vercel.com/marketplace/trigger). This will redirect you to Trigger.dev to
+  complete setup.
+</Step>
+
+<Step title="Select your Trigger.dev organization and project">
+  Choose which Trigger.dev organization and project to connect. If you're new to Trigger.dev, you'll
+  be guided through creating an organization and project.
+</Step>
+
+<Step title="Connect GitHub">
+  If your GitHub repository isn't already connected, you'll be prompted to connect it.
+</Step>
+
+</Steps>
+
+<Note>
+  When installing from the Vercel Marketplace, default Build options are applied automatically. You
+  can adjust them later in your project settings.
+</Note>
+
+<Warning>
+  **Vercel Root Directory:** If your Vercel project uses a **Root Directory** (e.g. you deploy a
+  single subfolder such as `app` or `web`), you may see "The specified Root Directory does not
+  exist" after connecting the integration. If you see this error, try using the **repository root**
+  (leave Root Directory empty) in your Vercel project settings. If your Vercel frontend build
+  requires a Root Directory (e.g. in a monorepo), keep that setting in Vercel and instead point
+  Trigger.dev to the subfolder by setting the **Trigger config file** path (and other [Build
+  options](#build-options)) in your Trigger.dev project configuration. Trigger.dev always builds
+  from the repo root.
+</Warning>
+
+## Environment variable sync
+
+The integration syncs environment variables in both directions:
+
+**Vercel → Trigger.dev**: Environment variables from your Vercel project are pulled into Trigger.dev. This happens during the initial setup and optionally before each build. Variables are synced per-environment (production, staging, preview).
+
+**Trigger.dev → Vercel**: Trigger.dev syncs API keys (like `TRIGGER_SECRET_KEY`) to your Vercel project so your app can communicate with Trigger.dev.
+
+The following variables are excluded from the Vercel → Trigger.dev sync:
+
+- `TRIGGER_SECRET_KEY`, `TRIGGER_VERSION`, `TRIGGER_PREVIEW_BRANCH` (managed by Trigger.dev)
+- Sensitive/secret-type variables (Vercel API limitation)
+
+You can control sync behavior per-variable from your project's Vercel settings. Deselecting a variable prevents its value from being updated during future syncs.
+
+<Warning>
+  If you are experiencing incorrectly populated environment variables, check that you are not using
+  the `syncVercelEnvVars` build extension in your `trigger.config.ts`. This extension is deprecated
+  and conflicts with the Vercel integration's built-in env var syncing. Remove it if present.
+</Warning>
+
+### Supabase and Neon database branching
+
+If you use [Supabase Branching](https://supabase.com/docs/guides/deployment/branching) or [Neon Database Branching](https://neon.tech/docs/guides/branching-intro) for preview environments, disable syncing for database env vars on the Environment Variables page and use the [syncSupabaseEnvVars](/config/extensions/syncEnvVars#syncsupabaseenvvars) or [syncNeonEnvVars](/config/extensions/syncEnvVars#syncneonenvvars) build extensions instead. These extensions automatically resolve the correct branch-specific credentials at build time.
+
+## Atomic deployments
+
+Atomic deployments ensure your Vercel app and Trigger.dev tasks are deployed in sync. When enabled, Trigger.dev gates your Vercel deployment until the task build completes, then triggers a Vercel redeployment with the correct `TRIGGER_VERSION` set. This guarantees your app always uses the matching version of your tasks.
+
+```mermaid
+sequenceDiagram
+  participant Dev as Developer
+  participant GH as GitHub
+  participant V as Vercel
+  participant TD as Trigger.dev
+
+  Dev->>GH: Push code
+  GH->>V: Webhook: new commit
+  V->>V: Start deployment
+  V->>TD: Deployment created
+  Dev->>GH: Create pull request
+  GH->>TD: Pull request created
+  TD->>TD: Start task build
+
+  V->>TD: Deployment check
+  TD-->>V: Check pending (gate deployment)
+  TD->>TD: Build completes
+  TD->>V: Set TRIGGER_VERSION env var
+  TD->>V: Trigger redeployment
+  V->>V: Redeploy with correct TRIGGER_VERSION
+  V->>TD: Deployment check (redeployment)
+  TD-->>V: Check passed
+  V->>V: Promote deployment
+  V->>TD: Deployment promoted
+  TD->>TD: Promote build
+```
+
+Atomic deployments are enabled for the production environment by default.
+
+<Note>
+  When atomic deployments are enabled, the integration automatically disables `Auto-assign Custom
+  Production Domains` on your Vercel project. This is required so that Vercel doesn't promote a
+  deployment before the Trigger.dev build is ready.
+</Note>
+
+Previously, setting up atomic deployments with Vercel required custom GitHub Actions workflows. The Vercel integration automates this entirely. For more details on how atomic deployments work, see [Atomic deploys](/deployment/atomic-deployment).
+
+## Environment mapping
+
+The integration maps Vercel environments to Trigger.dev environments:
+
+| Vercel environment | Trigger.dev environment        |
+| ------------------ | ------------------------------ |
+| Production         | Production                     |
+| Custom environment | Staging (you choose which one) |
+| Preview            | Preview                        |
+| Development        | Development                    |
+
+If your Vercel project has a custom environment, you can select which one maps to your Trigger.dev staging environment during setup or in your project settings.
+
+<Note>
+  Preview deployments require the preview environment to be enabled on your project. Learn more
+  about [preview branches](/deployment/preview-branches).
+</Note>
+
+## Build options
+
+You can configure the following settings per-environment from your project's Vercel settings:
+
+- **Atomic deployments**: Controls whether Trigger.dev and Vercel deployments are synchronized. Enabled for production by default.
+- **Pull env vars before build**: When enabled, Trigger.dev pulls the latest environment variables from Vercel before each build. Enabled for production, staging, and preview by default.
+- **Discover new env vars**: When enabled, new environment variables found in Vercel that don't yet exist in Trigger.dev are created automatically during builds. Only available for environments that also have env var pulling enabled. Enabled for production, staging, and preview by default.
+
+To change build options that would normally go in `trigger.config.ts` (such as [extensions](/config/config-file#extensions) or other build configuration), use **Build options** on your project's configuration page in the Trigger.dev dashboard.
+
+## Disconnecting
+
+You can disconnect the Vercel integration from either side:
+
+- **From Trigger.dev**: Go to your project **Settings** and disconnect Vercel.
+- **From Vercel**: Uninstall the Trigger.dev integration from your Vercel dashboard. This is automatically detected and the connection is removed on the Trigger.dev side.
+
+Disconnecting stops automatic deployments, environment variable syncing, and deployment checks. Your existing deployments and environment variables are not affected.
+
+## Related
+
+- [GitHub integration](/github-integration)
+- [Atomic deploys](/deployment/atomic-deployment)
+- [Environment variables](/deploy-environment-variables)
+- [Preview branches](/deployment/preview-branches)
diff --git a/docs/versioning.mdx b/docs/versioning.mdx
index 1e6170a9da8..743e7c47485 100644
--- a/docs/versioning.mdx
+++ b/docs/versioning.mdx
@@ -24,6 +24,8 @@ Versions numbers are incremented each time a new version is created for that dat
 
 When a task run starts it is locked to the latest version of the code (for that environment). Once locked it won't change versions, even if you deploy new versions. This is to ensure that a task run is not affected by changes to the code.
 
+Delayed runs are locked to the version that's active when they begin executing, not when they're enqueued.
+
 ### Child tasks and version locking
 
 Trigger and wait functions version lock child task runs to the parent task run version. This ensures the results from child runs match what the parent task is expecting. If you don't wait then version locking doesn't apply.
diff --git a/docs/wait-for-token.mdx b/docs/wait-for-token.mdx
index 9e050a3430e..9ac13af2c20 100644
--- a/docs/wait-for-token.mdx
+++ b/docs/wait-for-token.mdx
@@ -7,6 +7,10 @@ Waitpoint tokens pause task runs until you complete the token. They're commonly
 
 You can complete a token using the SDK or by making a POST request to the token's URL.
 
+<Note>
+  If you're waiting for data from an [input stream](/tasks/streams#input-streams), use [`inputStream.wait()`](/tasks/streams#wait--suspend-until-data-arrives) instead — it uses waitpoint tokens internally but provides a simpler API with full type safety from your stream definition.
+</Note>
+
 ## Usage
 
 To get started using wait tokens, you need to first create a token using the `wait.createToken` function:
@@ -177,7 +181,7 @@ You can complete a token using a raw HTTP request or from another language.
 curl -X POST "https://api.trigger.dev/api/v1/waitpoints/tokens/{tokenId}/complete" \
   -H "Authorization: Bearer {token}" \
   -H "Content-Type: application/json" \
-  -d '{"output": { "status": "approved"}}'
+  -d '{"data": { "status": "approved"}}'
 ```
 
 ```python python
@@ -186,7 +190,7 @@ import requests
 response = requests.post(
   "https://api.trigger.dev/api/v1/waitpoints/tokens/{tokenId}/complete",
   headers={"Authorization": f"Bearer {token}"},
-  json={"output": { "status": "approved"}}
+  json={"data": { "status": "approved"}}
 )
 ```
 
@@ -199,7 +203,7 @@ http = Net::HTTP.new(uri.host, uri.port)
 request = Net::HTTP::Post.new(uri)
 request["Authorization"] = "Bearer {token}"
 request["Content-Type"] = "application/json"
-request.body = JSON.generate({ output: { status: "approved" } })
+request.body = JSON.generate({ data: { status: "approved" } })
 
 response = http.request(request)
 ```
@@ -218,7 +222,7 @@ func main() {
 	url := "https://api.trigger.dev/api/v1/waitpoints/tokens/{tokenId}/complete"
 
 	payload := map[string]interface{}{
-		"output": map[string]interface{}{
+		"data": map[string]interface{}{
 			"status": "approved",
 		},
 	}
diff --git a/docs/wait.mdx b/docs/wait.mdx
index cfe5b2385bf..e67fbad9e6e 100644
--- a/docs/wait.mdx
+++ b/docs/wait.mdx
@@ -10,8 +10,9 @@ Waiting allows you to write complex tasks as a set of async code, without having
 
 <PausedExecutionFree />
 
-| Function                           | What it does                                     |
-| :--------------------------------- | :----------------------------------------------- |
-| [wait.for()](/wait-for)            | Waits for a specific period of time, e.g. 1 day. |
-| [wait.until()](/wait-until)        | Waits until the provided `Date`.                 |
-| [wait.forToken()](/wait-for-token) | Pauses runs until a token is completed.          |
+| Function                                          | What it does                                                     |
+| :------------------------------------------------ | :--------------------------------------------------------------- |
+| [wait.for()](/wait-for)                           | Waits for a specific period of time, e.g. 1 day.                |
+| [wait.until()](/wait-until)                       | Waits until the provided `Date`.                                 |
+| [wait.forToken()](/wait-for-token)                | Pauses runs until a token is completed.                          |
+| [inputStream.wait()](/tasks/streams#wait--suspend-until-data-arrives) | Pauses runs until data arrives on an input stream. |
diff --git a/hosting/docker/.env.example b/hosting/docker/.env.example
index 1fe7f6323f7..4c14201d1ab 100644
--- a/hosting/docker/.env.example
+++ b/hosting/docker/.env.example
@@ -77,12 +77,29 @@ DOCKER_REGISTRY_PASSWORD=very-secure-indeed
 DOCKER_REGISTRY_NAMESPACE=trigger
 
 # Object store
-# - You need to log into the Minio dashboard and create a bucket called "packets" 
+# - You need to log into the Minio dashboard and create a bucket called "packets"
 # - See the docs for more information: https://trigger.dev/docs/self-hosting/docker#object-storage
+# Default provider (backward compatible - no protocol prefix)
 OBJECT_STORE_ACCESS_KEY_ID=admin
 OBJECT_STORE_SECRET_ACCESS_KEY=very-safe-password
 # You will have to uncomment and configure this for production
 # OBJECT_STORE_BASE_URL=http://localhost:9000
+# OBJECT_STORE_REGION=auto
+# OBJECT_STORE_SERVICE=s3
+# OBJECT_STORE_DEFAULT_PROTOCOL=s3  # Optional: protocol to use for new uploads (e.g., "s3", "r2")
+#
+# Named providers (protocol-prefixed data) - optional for multi-provider support
+# OBJECT_STORE_S3_BASE_URL=https://s3.amazonaws.com
+# OBJECT_STORE_S3_ACCESS_KEY_ID=
+# OBJECT_STORE_S3_SECRET_ACCESS_KEY=
+# OBJECT_STORE_S3_REGION=us-east-1
+# OBJECT_STORE_S3_SERVICE=s3
+#
+# OBJECT_STORE_R2_BASE_URL=https://{bucket}.{accountId}.r2.cloudflarestorage.com
+# OBJECT_STORE_R2_ACCESS_KEY_ID=
+# OBJECT_STORE_R2_SECRET_ACCESS_KEY=
+# OBJECT_STORE_R2_REGION=auto
+# OBJECT_STORE_R2_SERVICE=s3
 # Credentials to access the Minio dashboard at http://localhost:9001
 # - You should change these credentials and not use them for the `OBJECT_STORE_` env vars above
 # - Instead, setup a non-root user with access the "packets" bucket
diff --git a/hosting/k8s/helm/templates/supervisor.yaml b/hosting/k8s/helm/templates/supervisor.yaml
index db85edf395a..ee3a1580b7a 100644
--- a/hosting/k8s/helm/templates/supervisor.yaml
+++ b/hosting/k8s/helm/templates/supervisor.yaml
@@ -151,7 +151,7 @@ spec:
               {{- else }}
               value: {{ .Values.supervisor.bootstrap.workerToken.value | quote }}
               {{- end }}
-            {{- if .Values.secrets.enabled }}
+            {{- if or .Values.secrets.enabled .Values.secrets.existingSecret }}
             - name: MANAGED_WORKER_SECRET
               valueFrom:
                 secretKeyRef:
diff --git a/hosting/k8s/helm/templates/webapp.yaml b/hosting/k8s/helm/templates/webapp.yaml
index 779aeaa4d21..0dd1bddbc41 100644
--- a/hosting/k8s/helm/templates/webapp.yaml
+++ b/hosting/k8s/helm/templates/webapp.yaml
@@ -263,7 +263,7 @@ spec:
             - name: DEFAULT_ORG_EXECUTION_CONCURRENCY_LIMIT
               value: {{ .Values.webapp.limits.defaultOrgExecutionConcurrencyLimit | quote }}
             {{- end }}
-            {{- if .Values.secrets.enabled }}
+            {{- if or .Values.secrets.enabled .Values.secrets.existingSecret }}
             - name: SESSION_SECRET
               valueFrom:
                 secretKeyRef:
diff --git a/hosting/k8s/helm/values.yaml b/hosting/k8s/helm/values.yaml
index 5576e436b51..262ffa4b8ed 100644
--- a/hosting/k8s/helm/values.yaml
+++ b/hosting/k8s/helm/values.yaml
@@ -645,6 +645,18 @@ s3:
     existingSecret: "" # Name of existing secret containing S3 credentials
     existingSecretAccessKeyIdKey: "access-key-id" # Key in existing secret containing access key ID
     existingSecretSecretAccessKeyKey: "secret-access-key" # Key in existing secret containing secret access key
+    #
+    # Multi-provider support (optional)
+    # To use multiple S3-compatible providers (e.g., S3 + R2), set defaultProtocol and configure named providers
+    # via extraEnvVars. For example:
+    #   - OBJECT_STORE_DEFAULT_PROTOCOL=s3  # Protocol to use for new uploads
+    #   - OBJECT_STORE_S3_BASE_URL=https://s3.amazonaws.com
+    #   - OBJECT_STORE_S3_ACCESS_KEY_ID=...
+    #   - OBJECT_STORE_S3_SECRET_ACCESS_KEY=...
+    #   - OBJECT_STORE_R2_BASE_URL=https://...r2.cloudflarestorage.com
+    #   - OBJECT_STORE_R2_ACCESS_KEY_ID=...
+    #   - OBJECT_STORE_R2_SECRET_ACCESS_KEY=...
+    # See documentation for migration guide: https://trigger.dev/docs/self-hosting/env/webapp
 
 # Docker Registry configuration
 registry:
diff --git a/internal-packages/cache/package.json b/internal-packages/cache/package.json
index 267ff2d92d9..02ba86e1fd6 100644
--- a/internal-packages/cache/package.json
+++ b/internal-packages/cache/package.json
@@ -10,9 +10,12 @@
     "@trigger.dev/core": "workspace:*",
     "@unkey/cache": "^1.5.0",
     "@unkey/error": "^0.2.0",
+    "lru-cache": "^11.2.4",
     "superjson": "^2.2.1"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:watch": "vitest"
   }
 }
\ No newline at end of file
diff --git a/internal-packages/cache/src/index.ts b/internal-packages/cache/src/index.ts
index 479d2fce1ba..c0064a08f0e 100644
--- a/internal-packages/cache/src/index.ts
+++ b/internal-packages/cache/src/index.ts
@@ -8,3 +8,8 @@ export {
 export { type Result, Ok, Err } from "@unkey/error";
 export { RedisCacheStore } from "./stores/redis.js";
 export { createMemoryStore, type MemoryStore } from "./stores/memory.js";
+export {
+  LRUMemoryStore,
+  createLRUMemoryStore,
+  type LRUMemoryStoreConfig,
+} from "./stores/lruMemory.js";
diff --git a/internal-packages/cache/src/stores/lruMemory.test.ts b/internal-packages/cache/src/stores/lruMemory.test.ts
new file mode 100644
index 00000000000..7b9580a19ff
--- /dev/null
+++ b/internal-packages/cache/src/stores/lruMemory.test.ts
@@ -0,0 +1,333 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { LRUMemoryStore, createLRUMemoryStore } from "./lruMemory.js";
+import type { Entry } from "@unkey/cache/stores";
+
+function createEntry<T>(value: T, freshUntil: number, staleUntil: number): Entry<T> {
+  return { value, freshUntil, staleUntil };
+}
+
+describe("LRUMemoryStore", () => {
+  let store: LRUMemoryStore<string, string>;
+
+  beforeEach(() => {
+    store = new LRUMemoryStore({ max: 5, name: "test-store" });
+  });
+
+  describe("basic operations", () => {
+    it("should set and get a value", async () => {
+      const entry = createEntry("test-value", Date.now() + 60000, Date.now() + 120000);
+
+      const setResult = await store.set("ns", "key1", entry);
+      expect(setResult.err).toBeUndefined();
+
+      const getResult = await store.get("ns", "key1");
+      expect(getResult.err).toBeUndefined();
+      expect(getResult.val).toEqual(entry);
+    });
+
+    it("should return undefined for missing keys", async () => {
+      const result = await store.get("ns", "nonexistent");
+      expect(result.err).toBeUndefined();
+      expect(result.val).toBeUndefined();
+    });
+
+    it("should remove a single key", async () => {
+      const entry = createEntry("value", Date.now() + 60000, Date.now() + 120000);
+      await store.set("ns", "key1", entry);
+
+      const removeResult = await store.remove("ns", "key1");
+      expect(removeResult.err).toBeUndefined();
+
+      const getResult = await store.get("ns", "key1");
+      expect(getResult.val).toBeUndefined();
+    });
+
+    it("should remove multiple keys", async () => {
+      const entry = createEntry("value", Date.now() + 60000, Date.now() + 120000);
+      await store.set("ns", "key1", entry);
+      await store.set("ns", "key2", entry);
+      await store.set("ns", "key3", entry);
+
+      const removeResult = await store.remove("ns", ["key1", "key2"]);
+      expect(removeResult.err).toBeUndefined();
+
+      expect((await store.get("ns", "key1")).val).toBeUndefined();
+      expect((await store.get("ns", "key2")).val).toBeUndefined();
+      expect((await store.get("ns", "key3")).val).not.toBeUndefined();
+    });
+  });
+
+  describe("namespace isolation", () => {
+    it("should isolate keys by namespace", async () => {
+      const entry1 = createEntry("value1", Date.now() + 60000, Date.now() + 120000);
+      const entry2 = createEntry("value2", Date.now() + 60000, Date.now() + 120000);
+
+      await store.set("ns1", "key", entry1);
+      await store.set("ns2", "key", entry2);
+
+      const result1 = await store.get("ns1", "key");
+      const result2 = await store.get("ns2", "key");
+
+      expect(result1.val?.value).toBe("value1");
+      expect(result2.val?.value).toBe("value2");
+    });
+  });
+
+  describe("TTL expiration", () => {
+    it("should return undefined for expired entries (past staleUntil)", async () => {
+      const entry = createEntry("value", Date.now() - 2000, Date.now() - 1000); // Already expired
+
+      await store.set("ns", "expired-key", entry);
+
+      const result = await store.get("ns", "expired-key");
+      expect(result.val).toBeUndefined();
+    });
+
+    it("should return entry that is stale but not expired", async () => {
+      const now = Date.now();
+      // Fresh until 1 second ago, stale until 1 hour from now
+      const entry = createEntry("value", now - 1000, now + 3600000);
+
+      await store.set("ns", "stale-key", entry);
+
+      const result = await store.get("ns", "stale-key");
+      expect(result.val).not.toBeUndefined();
+      expect(result.val?.value).toBe("value");
+    });
+
+    it("should delete expired entry on get", async () => {
+      const entry = createEntry("value", Date.now() - 2000, Date.now() - 1000);
+      await store.set("ns", "key", entry);
+
+      // First get should return undefined and delete
+      await store.get("ns", "key");
+
+      // Size should reflect deletion
+      expect(store.size).toBe(0);
+    });
+  });
+
+  describe("LRU eviction", () => {
+    it("should evict least recently used items when at capacity", async () => {
+      const entry = (val: string) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Fill the cache (max: 5)
+      await store.set("ns", "key1", entry("value1"));
+      await store.set("ns", "key2", entry("value2"));
+      await store.set("ns", "key3", entry("value3"));
+      await store.set("ns", "key4", entry("value4"));
+      await store.set("ns", "key5", entry("value5"));
+
+      expect(store.size).toBe(5);
+
+      // Add one more - should evict key1 (least recently used)
+      await store.set("ns", "key6", entry("value6"));
+
+      expect(store.size).toBe(5);
+      expect((await store.get("ns", "key1")).val).toBeUndefined(); // Evicted
+      expect((await store.get("ns", "key6")).val?.value).toBe("value6"); // Present
+    });
+
+    it("should update LRU order on get", async () => {
+      const entry = (val: string) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Fill the cache
+      await store.set("ns", "key1", entry("value1"));
+      await store.set("ns", "key2", entry("value2"));
+      await store.set("ns", "key3", entry("value3"));
+      await store.set("ns", "key4", entry("value4"));
+      await store.set("ns", "key5", entry("value5"));
+
+      // Access key1 to make it recently used
+      await store.get("ns", "key1");
+
+      // Add new item - should evict key2 (now least recently used)
+      await store.set("ns", "key6", entry("value6"));
+
+      expect((await store.get("ns", "key1")).val?.value).toBe("value1"); // Still present
+      expect((await store.get("ns", "key2")).val).toBeUndefined(); // Evicted
+    });
+
+    it("should update LRU order on set (update existing)", async () => {
+      const entry = (val: string) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Fill the cache
+      await store.set("ns", "key1", entry("value1"));
+      await store.set("ns", "key2", entry("value2"));
+      await store.set("ns", "key3", entry("value3"));
+      await store.set("ns", "key4", entry("value4"));
+      await store.set("ns", "key5", entry("value5"));
+
+      // Update key1 to make it recently used
+      await store.set("ns", "key1", entry("updated-value1"));
+
+      // Add new item - should evict key2 (now least recently used)
+      await store.set("ns", "key6", entry("value6"));
+
+      expect((await store.get("ns", "key1")).val?.value).toBe("updated-value1");
+      expect((await store.get("ns", "key2")).val).toBeUndefined(); // Evicted
+    });
+  });
+
+  describe("hard limit enforcement", () => {
+    it("should never exceed max size regardless of write rate", async () => {
+      const smallStore = new LRUMemoryStore<string, number>({ max: 10 });
+      const entry = (val: number) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Write 1000 items rapidly
+      for (let i = 0; i < 1000; i++) {
+        await smallStore.set("ns", `key${i}`, entry(i));
+        // Verify size never exceeds max
+        expect(smallStore.size).toBeLessThanOrEqual(10);
+      }
+
+      expect(smallStore.size).toBe(10);
+    });
+
+    it("should maintain most recent items when at capacity", async () => {
+      const smallStore = new LRUMemoryStore<string, number>({ max: 3 });
+      const entry = (val: number) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Write items sequentially
+      await smallStore.set("ns", "key1", entry(1));
+      await smallStore.set("ns", "key2", entry(2));
+      await smallStore.set("ns", "key3", entry(3));
+      await smallStore.set("ns", "key4", entry(4));
+      await smallStore.set("ns", "key5", entry(5));
+
+      // Only the 3 most recent should remain
+      expect((await smallStore.get("ns", "key1")).val).toBeUndefined();
+      expect((await smallStore.get("ns", "key2")).val).toBeUndefined();
+      expect((await smallStore.get("ns", "key3")).val?.value).toBe(3);
+      expect((await smallStore.get("ns", "key4")).val?.value).toBe(4);
+      expect((await smallStore.get("ns", "key5")).val?.value).toBe(5);
+    });
+  });
+
+  describe("utility methods", () => {
+    it("should report correct size", async () => {
+      const entry = createEntry("value", Date.now() + 60000, Date.now() + 120000);
+
+      expect(store.size).toBe(0);
+
+      await store.set("ns", "key1", entry);
+      expect(store.size).toBe(1);
+
+      await store.set("ns", "key2", entry);
+      expect(store.size).toBe(2);
+
+      await store.remove("ns", "key1");
+      expect(store.size).toBe(1);
+    });
+
+    it("should clear all items", async () => {
+      const entry = createEntry("value", Date.now() + 60000, Date.now() + 120000);
+
+      await store.set("ns1", "key1", entry);
+      await store.set("ns2", "key2", entry);
+      await store.set("ns3", "key3", entry);
+
+      expect(store.size).toBe(3);
+
+      store.clear();
+
+      expect(store.size).toBe(0);
+      expect((await store.get("ns1", "key1")).val).toBeUndefined();
+    });
+
+    it("should use custom name", () => {
+      const customStore = new LRUMemoryStore({ max: 10, name: "custom-name" });
+      expect(customStore.name).toBe("custom-name");
+    });
+
+    it("should use default name when not provided", () => {
+      const defaultStore = new LRUMemoryStore({ max: 10 });
+      expect(defaultStore.name).toBe("lru-memory");
+    });
+  });
+
+  describe("createLRUMemoryStore helper", () => {
+    it("should create a store with specified max size", async () => {
+      const helperStore = createLRUMemoryStore(3);
+      const entry = (val: number) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      await helperStore.set("ns", "key1", entry(1));
+      await helperStore.set("ns", "key2", entry(2));
+      await helperStore.set("ns", "key3", entry(3));
+      await helperStore.set("ns", "key4", entry(4));
+
+      expect(helperStore.size).toBe(3);
+      expect((await helperStore.get("ns", "key1")).val).toBeUndefined();
+    });
+
+    it("should accept custom name", () => {
+      const namedStore = createLRUMemoryStore(10, "my-cache");
+      expect(namedStore.name).toBe("my-cache");
+    });
+  });
+
+  describe("complex value types", () => {
+    it("should handle object values", async () => {
+      const objectStore = new LRUMemoryStore<string, { id: number; data: string[] }>({ max: 5 });
+      const complexValue = { id: 123, data: ["a", "b", "c"] };
+      const entry = createEntry(complexValue, Date.now() + 60000, Date.now() + 120000);
+
+      await objectStore.set("ns", "obj-key", entry);
+
+      const result = await objectStore.get("ns", "obj-key");
+      expect(result.val?.value).toEqual(complexValue);
+    });
+
+    it("should handle null and undefined values", async () => {
+      const nullStore = new LRUMemoryStore<string, null | undefined>({ max: 5 });
+
+      const nullEntry = createEntry(null, Date.now() + 60000, Date.now() + 120000);
+      const undefinedEntry = createEntry(undefined, Date.now() + 60000, Date.now() + 120000);
+
+      await nullStore.set("ns", "null-key", nullEntry);
+      await nullStore.set("ns", "undefined-key", undefinedEntry);
+
+      expect((await nullStore.get("ns", "null-key")).val?.value).toBeNull();
+      expect((await nullStore.get("ns", "undefined-key")).val?.value).toBeUndefined();
+    });
+  });
+
+  describe("concurrent operations", () => {
+    it("should handle concurrent writes safely", async () => {
+      const concurrentStore = new LRUMemoryStore<string, number>({ max: 100 });
+      const entry = (val: number) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Simulate concurrent writes
+      const writes = Array.from({ length: 50 }, (_, i) =>
+        concurrentStore.set("ns", `key${i}`, entry(i))
+      );
+
+      await Promise.all(writes);
+
+      expect(concurrentStore.size).toBe(50);
+    });
+
+    it("should handle concurrent reads and writes", async () => {
+      const concurrentStore = new LRUMemoryStore<string, number>({ max: 100 });
+      const entry = (val: number) => createEntry(val, Date.now() + 60000, Date.now() + 120000);
+
+      // Pre-populate
+      for (let i = 0; i < 50; i++) {
+        await concurrentStore.set("ns", `key${i}`, entry(i));
+      }
+
+      // Mix of reads and writes
+      const operations = [
+        ...Array.from({ length: 25 }, (_, i) => concurrentStore.get("ns", `key${i}`)),
+        ...Array.from({ length: 25 }, (_, i) =>
+          concurrentStore.set("ns", `new-key${i}`, entry(i + 100))
+        ),
+      ];
+
+      await Promise.all(operations);
+
+      // Should not exceed max
+      expect(concurrentStore.size).toBeLessThanOrEqual(100);
+    });
+  });
+});
diff --git a/internal-packages/cache/src/stores/lruMemory.ts b/internal-packages/cache/src/stores/lruMemory.ts
new file mode 100644
index 00000000000..63b1d5cd4b5
--- /dev/null
+++ b/internal-packages/cache/src/stores/lruMemory.ts
@@ -0,0 +1,167 @@
+import { LRUCache } from "lru-cache";
+import { CacheError } from "@unkey/cache";
+import type { Store, Entry } from "@unkey/cache/stores";
+import { Ok, Err, type Result } from "@unkey/error";
+
+export type LRUMemoryStoreConfig = {
+  /**
+   * Maximum number of items to store in the cache.
+   * This is a hard limit - the cache will never exceed this size.
+   */
+  max: number;
+
+  /**
+   * Name for metrics/tracing.
+   * @default "lru-memory"
+   */
+  name?: string;
+};
+
+/**
+ * A memory store implementation using lru-cache.
+ *
+ * This provides O(1) get/set/delete operations and automatic LRU eviction
+ * without blocking the event loop (unlike @unkey/cache's MemoryStore which
+ * uses O(n) synchronous iteration for eviction).
+ *
+ * TTL is checked lazily on get() - expired items are not proactively removed
+ * but will be evicted by LRU when the cache is full.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class LRUMemoryStore<TNamespace extends string, TValue = any>
+  implements Store<TNamespace, TValue>
+{
+  readonly name: string;
+  private readonly cache: LRUCache<string, Entry<TValue>>;
+
+  constructor(config: LRUMemoryStoreConfig) {
+    this.name = config.name ?? "lru-memory";
+    this.cache = new LRUCache<string, Entry<TValue>>({
+      max: config.max,
+      // Don't use ttlAutopurge - it creates a setTimeout per item which
+      // doesn't scale well at high throughput (thousands of items/second).
+      // Instead, we check TTL lazily on get().
+      ttlAutopurge: false,
+      // Allow returning stale values - the cache layer handles SWR semantics
+      allowStale: true,
+      // Use the staleUntil timestamp for TTL calculation
+      ttl: 1, // Placeholder, we set per-item TTL in set()
+    });
+  }
+
+  private buildCacheKey(namespace: TNamespace, key: string): string {
+    return `${namespace}::${key}`;
+  }
+
+  async get(
+    namespace: TNamespace,
+    key: string
+  ): Promise<Result<Entry<TValue> | undefined, CacheError>> {
+    try {
+      const cacheKey = this.buildCacheKey(namespace, key);
+      const entry = this.cache.get(cacheKey);
+
+      if (!entry) {
+        return Ok(undefined);
+      }
+
+      // Check if entry is expired (past staleUntil)
+      // The cache layer will handle fresh vs stale semantics
+      if (entry.staleUntil <= Date.now()) {
+        // Remove expired entry
+        this.cache.delete(cacheKey);
+        return Ok(undefined);
+      }
+
+      return Ok(entry);
+    } catch (err) {
+      return Err(
+        new CacheError({
+          tier: this.name,
+          key,
+          message: err instanceof Error ? err.message : String(err),
+        })
+      );
+    }
+  }
+
+  async set(
+    namespace: TNamespace,
+    key: string,
+    entry: Entry<TValue>
+  ): Promise<Result<void, CacheError>> {
+    try {
+      const cacheKey = this.buildCacheKey(namespace, key);
+
+      // Calculate TTL from staleUntil timestamp
+      const ttl = Math.max(0, entry.staleUntil - Date.now());
+
+      this.cache.set(cacheKey, entry, { ttl });
+
+      return Ok(undefined as void);
+    } catch (err) {
+      return Err(
+        new CacheError({
+          tier: this.name,
+          key,
+          message: err instanceof Error ? err.message : String(err),
+        })
+      );
+    }
+  }
+
+  async remove(
+    namespace: TNamespace,
+    keys: string | string[]
+  ): Promise<Result<void, CacheError>> {
+    try {
+      const keyArray = Array.isArray(keys) ? keys : [keys];
+
+      for (const key of keyArray) {
+        const cacheKey = this.buildCacheKey(namespace, key);
+        this.cache.delete(cacheKey);
+      }
+
+      return Ok(undefined as void);
+    } catch (err) {
+      return Err(
+        new CacheError({
+          tier: this.name,
+          key: Array.isArray(keys) ? keys.join(",") : keys,
+          message: err instanceof Error ? err.message : String(err),
+        })
+      );
+    }
+  }
+
+  /**
+   * Returns the current number of items in the cache.
+   */
+  get size(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Clears all items from the cache.
+   */
+  clear(): void {
+    this.cache.clear();
+  }
+}
+
+/**
+ * Creates an LRU memory store with the specified maximum size.
+ *
+ * This is a drop-in replacement for createMemoryStore() that uses lru-cache
+ * instead of @unkey/cache's MemoryStore, providing:
+ * - O(1) operations (vs O(n) eviction in MemoryStore)
+ * - No event loop blocking
+ * - Strict memory bounds (hard max vs soft cap)
+ *
+ * @param maxItems Maximum number of items to store
+ * @param name Optional name for metrics/tracing (default: "lru-memory")
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createLRUMemoryStore(maxItems: number, name?: string): LRUMemoryStore<string, any> {
+  return new LRUMemoryStore({ max: maxItems, name });
+}
diff --git a/internal-packages/cache/vitest.config.ts b/internal-packages/cache/vitest.config.ts
new file mode 100644
index 00000000000..e07f05e842b
--- /dev/null
+++ b/internal-packages/cache/vitest.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["**/*.test.ts"],
+    globals: true,
+    isolate: true,
+    testTimeout: 10_000,
+  },
+});
diff --git a/internal-packages/clickhouse/CLAUDE.md b/internal-packages/clickhouse/CLAUDE.md
new file mode 100644
index 00000000000..c3e4f9125a0
--- /dev/null
+++ b/internal-packages/clickhouse/CLAUDE.md
@@ -0,0 +1,30 @@
+# ClickHouse Package
+
+`@internal/clickhouse` - ClickHouse client for analytics and observability data.
+
+## Migrations
+
+Goose-format SQL migrations live in `schema/`. Create new numbered files:
+
+```sql
+-- +goose Up
+ALTER TABLE trigger_dev.your_table
+ADD COLUMN new_column String DEFAULT '';
+
+-- +goose Down
+ALTER TABLE trigger_dev.your_table
+DROP COLUMN new_column;
+```
+
+## Naming Conventions
+
+- `raw_` prefix for input tables (where data lands first)
+- `_v1`, `_v2` suffixes for table versioning
+- `_mv_v1` suffix for materialized views
+- `_per_day`, `_per_month` for aggregation tables
+
+See `README.md` in this directory for full naming convention documentation.
+
+## Purpose
+
+Stores time-series data for task run analytics, event streams, and performance metrics. Separate from PostgreSQL to handle high-volume writes from task execution.
diff --git a/internal-packages/clickhouse/package.json b/internal-packages/clickhouse/package.json
index da553146367..846ded63f1f 100644
--- a/internal-packages/clickhouse/package.json
+++ b/internal-packages/clickhouse/package.json
@@ -8,6 +8,7 @@
   "dependencies": {
     "@clickhouse/client": "^1.12.1",
     "@internal/tracing": "workspace:*",
+    "@internal/tsql": "workspace:*",
     "@trigger.dev/core": "workspace:*",
     "zod": "3.25.76",
     "zod-error": "1.5.0"
diff --git a/internal-packages/clickhouse/schema/012_add_task_runs_v2_max_duration.sql b/internal-packages/clickhouse/schema/012_add_task_runs_v2_max_duration.sql
new file mode 100644
index 00000000000..b4263e76541
--- /dev/null
+++ b/internal-packages/clickhouse/schema/012_add_task_runs_v2_max_duration.sql
@@ -0,0 +1,10 @@
+-- +goose Up
+/*
+Add max_duration_in_seconds column.
+ */
+ALTER TABLE trigger_dev.task_runs_v2
+ADD COLUMN max_duration_in_seconds Nullable (UInt32) DEFAULT NULL;
+
+-- +goose Down
+ALTER TABLE trigger_dev.task_runs_v2
+DROP COLUMN max_duration_in_seconds;
\ No newline at end of file
diff --git a/internal-packages/clickhouse/schema/013_add_task_runs_v2_idempotency_key_options.sql b/internal-packages/clickhouse/schema/013_add_task_runs_v2_idempotency_key_options.sql
new file mode 100644
index 00000000000..345e393afa4
--- /dev/null
+++ b/internal-packages/clickhouse/schema/013_add_task_runs_v2_idempotency_key_options.sql
@@ -0,0 +1,16 @@
+-- +goose Up
+
+-- Add columns for storing user-provided idempotency key and scope for searching
+ALTER TABLE trigger_dev.task_runs_v2
+ADD COLUMN idempotency_key_user String DEFAULT '';
+
+ALTER TABLE trigger_dev.task_runs_v2
+ADD COLUMN idempotency_key_scope String DEFAULT '';
+
+-- +goose Down
+
+ALTER TABLE trigger_dev.task_runs_v2
+DROP COLUMN idempotency_key_user;
+
+ALTER TABLE trigger_dev.task_runs_v2
+DROP COLUMN idempotency_key_scope;
diff --git a/internal-packages/clickhouse/schema/014_update_output_error_text_to_extract_data.sql b/internal-packages/clickhouse/schema/014_update_output_error_text_to_extract_data.sql
new file mode 100644
index 00000000000..c66a1492a55
--- /dev/null
+++ b/internal-packages/clickhouse/schema/014_update_output_error_text_to_extract_data.sql
@@ -0,0 +1,45 @@
+-- +goose Up
+-- Update the materialized columns to extract the 'data' field if it exists
+-- This avoids the {"data": ...} wrapper in the text representation
+-- Note: Direct JSON path access (output.data) returns null for nested objects,
+-- so we use JSONExtractRaw on the stringified JSON instead
+ALTER TABLE trigger_dev.task_runs_v2
+ADD COLUMN output_text String MATERIALIZED if (
+  toJSONString (output) = '{}',
+  '',
+  if (
+    length (JSONExtractRaw (toJSONString (output), 'data')) > 0,
+    JSONExtractRaw (toJSONString (output), 'data'),
+    toJSONString (output)
+  )
+);
+
+-- For error: extract error.data if it exists
+ALTER TABLE trigger_dev.task_runs_v2
+ADD COLUMN error_text String MATERIALIZED if (
+  toJSONString (error) = '{}',
+  '',
+  if (
+    length (JSONExtractRaw (toJSONString (error), 'data')) > 0,
+    JSONExtractRaw (toJSONString (error), 'data'),
+    toJSONString (error)
+  )
+);
+
+-- Add the indexes
+ALTER TABLE trigger_dev.task_runs_v2 ADD INDEX idx_output_text output_text TYPE ngrambf_v1 (3, 131072, 3, 0) GRANULARITY 4;
+
+ALTER TABLE trigger_dev.task_runs_v2 ADD INDEX idx_error_text error_text TYPE ngrambf_v1 (3, 131072, 3, 0) GRANULARITY 4;
+
+-- +goose Down
+ALTER TABLE trigger_dev.task_runs_v2
+DROP INDEX IF EXISTS idx_output_text;
+
+ALTER TABLE trigger_dev.task_runs_v2
+DROP INDEX IF EXISTS idx_error_text;
+
+ALTER TABLE trigger_dev.task_runs_v2
+DROP COLUMN IF EXISTS output_text;
+
+ALTER TABLE trigger_dev.task_runs_v2
+DROP COLUMN IF EXISTS error_text;
\ No newline at end of file
diff --git a/internal-packages/clickhouse/schema/015_add_task_runs_v2_search_indexes.sql b/internal-packages/clickhouse/schema/015_add_task_runs_v2_search_indexes.sql
new file mode 100644
index 00000000000..1d6af329451
--- /dev/null
+++ b/internal-packages/clickhouse/schema/015_add_task_runs_v2_search_indexes.sql
@@ -0,0 +1,20 @@
+-- +goose Up
+
+-- Add indexes for text search on task task_events_v2 tables for message and attributes fields
+ALTER TABLE trigger_dev.task_events_v2
+    ADD INDEX IF NOT EXISTS idx_attributes_text_search lower(attributes_text)
+    TYPE ngrambf_v1(3, 32768, 2, 0)
+    GRANULARITY 1;
+
+ALTER TABLE trigger_dev.task_events_v2
+    ADD INDEX IF NOT EXISTS idx_message_text_search lower(message)
+    TYPE ngrambf_v1(3, 32768, 2, 0)
+    GRANULARITY 1;
+
+-- +goose Down
+
+ALTER TABLE trigger_dev.task_events_v2
+DROP INDEX idx_attributes_text_search;
+
+ALTER TABLE trigger_dev.task_events_v2
+DROP INDEX idx_message_text_search;
diff --git a/internal-packages/clickhouse/schema/016_add_task_events_search_v1.sql b/internal-packages/clickhouse/schema/016_add_task_events_search_v1.sql
new file mode 100644
index 00000000000..60ed1eb1fc5
--- /dev/null
+++ b/internal-packages/clickhouse/schema/016_add_task_events_search_v1.sql
@@ -0,0 +1,63 @@
+-- +goose Up
+CREATE TABLE IF NOT EXISTS trigger_dev.task_events_search_v1
+(
+  environment_id String,
+  organization_id String,
+  project_id String,
+  triggered_timestamp DateTime64(9) CODEC(Delta(8), ZSTD(1)),
+  trace_id String CODEC(ZSTD(1)),
+  span_id String CODEC(ZSTD(1)),
+  run_id String CODEC(ZSTD(1)),
+  task_identifier String CODEC(ZSTD(1)),
+  start_time DateTime64(9) CODEC(Delta(8), ZSTD(1)),
+  inserted_at DateTime64(3),
+  message String CODEC(ZSTD(1)),
+  kind LowCardinality(String) CODEC(ZSTD(1)),
+  status LowCardinality(String) CODEC(ZSTD(1)),
+  duration UInt64 CODEC(ZSTD(1)),
+  parent_span_id String CODEC(ZSTD(1)),
+  attributes_text String CODEC(ZSTD(1)),
+
+  INDEX idx_run_id run_id TYPE bloom_filter(0.001) GRANULARITY 1,
+  INDEX idx_message_text_search lower(message) TYPE ngrambf_v1(3, 32768, 2, 0) GRANULARITY 1,
+  INDEX idx_attributes_text_search lower(attributes_text) TYPE ngrambf_v1(3, 32768, 2, 0) GRANULARITY 1
+)
+ENGINE = MergeTree
+PARTITION BY toDate(triggered_timestamp)
+ORDER BY (organization_id, environment_id, triggered_timestamp, trace_id)
+--Right now we have maximum retention of up to 30 days based on plan.
+--We put a logical limit for now, the 90 DAY TTL is just a backup
+--This might need to be updated for longer retention periods
+TTL toDateTime(triggered_timestamp) + INTERVAL 90 DAY
+SETTINGS ttl_only_drop_parts = 1;
+
+CREATE MATERIALIZED VIEW IF NOT EXISTS trigger_dev.task_events_search_mv_v1
+TO trigger_dev.task_events_search_v1 AS
+SELECT
+  environment_id,
+  organization_id,
+  project_id,
+  trace_id,
+  span_id,
+  run_id,
+  task_identifier,
+  start_time,
+  inserted_at,
+  message,
+  kind,
+  status,
+  duration,
+  parent_span_id,
+  attributes_text,
+  fromUnixTimestamp64Nano(toUnixTimestamp64Nano(start_time) + toInt64(duration)) AS triggered_timestamp
+FROM trigger_dev.task_events_v2
+WHERE
+    kind != 'DEBUG_EVENT'
+    AND status != 'PARTIAL'
+    AND NOT (kind = 'SPAN_EVENT' AND attributes_text = '{}')
+    AND kind != 'ANCESTOR_OVERRIDE'
+    AND message != 'trigger.dev/start';
+
+-- +goose Down
+DROP VIEW IF EXISTS trigger_dev.task_events_search_mv_v1;
+DROP TABLE IF EXISTS trigger_dev.task_events_search_v1;
diff --git a/internal-packages/clickhouse/schema/017_update_materialized_conditions_to_task_events_search_v1.sql b/internal-packages/clickhouse/schema/017_update_materialized_conditions_to_task_events_search_v1.sql
new file mode 100644
index 00000000000..3f84cf555f2
--- /dev/null
+++ b/internal-packages/clickhouse/schema/017_update_materialized_conditions_to_task_events_search_v1.sql
@@ -0,0 +1,62 @@
+-- +goose Up
+-- We drop the existing MV and recreate it with the new filter condition
+DROP VIEW IF EXISTS trigger_dev.task_events_search_mv_v1;
+
+CREATE MATERIALIZED VIEW IF NOT EXISTS trigger_dev.task_events_search_mv_v1
+TO trigger_dev.task_events_search_v1 AS
+SELECT
+    environment_id,
+    organization_id,
+    project_id,
+    trace_id,
+    span_id,
+    run_id,
+    task_identifier,
+    start_time,
+    inserted_at,
+    message,
+    kind,
+    status,
+    duration,
+    parent_span_id,
+    attributes_text,
+    fromUnixTimestamp64Nano(toUnixTimestamp64Nano(start_time) + toInt64(duration)) AS triggered_timestamp
+FROM trigger_dev.task_events_v2
+WHERE
+    trace_id != '' -- New condition added here
+    AND kind != 'DEBUG_EVENT'
+    AND status != 'PARTIAL'
+    AND NOT (kind = 'SPAN_EVENT' AND attributes_text = '{}')
+    AND kind != 'ANCESTOR_OVERRIDE'
+    AND message != 'trigger.dev/start';
+
+-- +goose Down
+-- In the down migration, we revert to the previous filter set
+DROP VIEW IF EXISTS trigger_dev.task_events_search_mv_v1;
+
+CREATE MATERIALIZED VIEW IF NOT EXISTS trigger_dev.task_events_search_mv_v1
+TO trigger_dev.task_events_search_v1 AS
+SELECT
+    environment_id,
+    organization_id,
+    project_id,
+    trace_id,
+    span_id,
+    run_id,
+    task_identifier,
+    start_time,
+    inserted_at,
+    message,
+    kind,
+    status,
+    duration,
+    parent_span_id,
+    attributes_text,
+    fromUnixTimestamp64Nano(toUnixTimestamp64Nano(start_time) + toInt64(duration)) AS triggered_timestamp
+FROM trigger_dev.task_events_v2
+WHERE
+    kind != 'DEBUG_EVENT'
+    AND status != 'PARTIAL'
+    AND NOT (kind = 'SPAN_EVENT' AND attributes_text = '{}')
+    AND kind != 'ANCESTOR_OVERRIDE'
+    AND message != 'trigger.dev/start';
\ No newline at end of file
diff --git a/internal-packages/clickhouse/schema/018_drop_unused_task_events_v2_indexes.sql b/internal-packages/clickhouse/schema/018_drop_unused_task_events_v2_indexes.sql
new file mode 100644
index 00000000000..81e3dbab61c
--- /dev/null
+++ b/internal-packages/clickhouse/schema/018_drop_unused_task_events_v2_indexes.sql
@@ -0,0 +1,22 @@
+-- +goose Up
+
+-- These indexes are not used in any WHERE clause.
+-- idx_duration: duration is only written/read as a column, never filtered on.
+-- idx_attributes_text: search queries use the task_events_search_v1 table instead.
+ALTER TABLE trigger_dev.task_events_v2
+    DROP INDEX IF EXISTS idx_duration;
+
+ALTER TABLE trigger_dev.task_events_v2
+    DROP INDEX IF EXISTS idx_attributes_text;
+
+-- +goose Down
+
+ALTER TABLE trigger_dev.task_events_v2
+    ADD INDEX IF NOT EXISTS idx_duration duration
+    TYPE minmax
+    GRANULARITY 1;
+
+ALTER TABLE trigger_dev.task_events_v2
+    ADD INDEX IF NOT EXISTS idx_attributes_text attributes_text
+    TYPE tokenbf_v1(32768, 3, 0)
+    GRANULARITY 8;
diff --git a/internal-packages/clickhouse/schema/019_create_metrics_v1.sql b/internal-packages/clickhouse/schema/019_create_metrics_v1.sql
new file mode 100644
index 00000000000..b4a808f1896
--- /dev/null
+++ b/internal-packages/clickhouse/schema/019_create_metrics_v1.sql
@@ -0,0 +1,44 @@
+-- +goose Up
+CREATE TABLE IF NOT EXISTS trigger_dev.metrics_v1
+(
+  organization_id     LowCardinality(String),
+  project_id          LowCardinality(String),
+  environment_id      String CODEC(ZSTD(1)),
+  metric_name         LowCardinality(String),
+  metric_type         LowCardinality(String),
+  metric_subject      String CODEC(ZSTD(1)),
+  bucket_start        DateTime CODEC(Delta(4), ZSTD(1)),
+  value               Float64 DEFAULT 0 CODEC(ZSTD(1)),
+  attributes          JSON(
+    `trigger.run_id` String,
+    `trigger.task_slug` String,
+    `trigger.attempt_number` Int64,
+    `trigger.environment_type` LowCardinality(String),
+    `trigger.machine_id` String,
+    `trigger.machine_name` LowCardinality(String),
+    `trigger.worker_id` String,
+    `trigger.worker_version` String,
+    `system.cpu.logical_number` String,
+    `system.cpu.state` LowCardinality(String),
+    `system.memory.state` LowCardinality(String),
+    `system.device` String,
+    `system.filesystem.type` LowCardinality(String),
+    `system.filesystem.mountpoint` String,
+    `system.filesystem.mode` LowCardinality(String),
+    `system.filesystem.state` LowCardinality(String),
+    `disk.io.direction` LowCardinality(String),
+    `process.cpu.state` LowCardinality(String),
+    `network.io.direction` LowCardinality(String),
+    max_dynamic_paths=8
+  ),
+  INDEX idx_run_id attributes.trigger.run_id TYPE bloom_filter(0.001) GRANULARITY 1,
+  INDEX idx_task_slug attributes.trigger.task_slug TYPE bloom_filter(0.001) GRANULARITY 1
+)
+ENGINE = MergeTree()
+PARTITION BY toDate(bucket_start)
+ORDER BY (organization_id, project_id, environment_id, metric_name, metric_subject, bucket_start)
+TTL bucket_start + INTERVAL 60 DAY
+SETTINGS ttl_only_drop_parts = 1;
+
+-- +goose Down
+DROP TABLE IF EXISTS trigger_dev.metrics_v1;
diff --git a/internal-packages/clickhouse/schema/020_add_machine_id_to_task_events_v2.sql b/internal-packages/clickhouse/schema/020_add_machine_id_to_task_events_v2.sql
new file mode 100644
index 00000000000..69af257afdd
--- /dev/null
+++ b/internal-packages/clickhouse/schema/020_add_machine_id_to_task_events_v2.sql
@@ -0,0 +1,7 @@
+-- +goose Up
+ALTER TABLE trigger_dev.task_events_v2
+ADD COLUMN machine_id String DEFAULT '' CODEC(ZSTD(1));
+
+-- +goose Down
+ALTER TABLE trigger_dev.task_events_v2
+DROP COLUMN machine_id;
diff --git a/internal-packages/clickhouse/schema/021_add_error_fingerprint_to_task_runs_v2.sql b/internal-packages/clickhouse/schema/021_add_error_fingerprint_to_task_runs_v2.sql
new file mode 100644
index 00000000000..f702b91d3b9
--- /dev/null
+++ b/internal-packages/clickhouse/schema/021_add_error_fingerprint_to_task_runs_v2.sql
@@ -0,0 +1,11 @@
+-- +goose Up
+ALTER TABLE trigger_dev.task_runs_v2
+  ADD COLUMN error_fingerprint String DEFAULT '';
+
+-- Bloom filter index for fast error fingerprint lookups
+ALTER TABLE trigger_dev.task_runs_v2
+  ADD INDEX idx_error_fingerprint error_fingerprint TYPE bloom_filter GRANULARITY 4;
+
+-- +goose Down
+ALTER TABLE trigger_dev.task_runs_v2 DROP INDEX idx_error_fingerprint;
+ALTER TABLE trigger_dev.task_runs_v2 DROP COLUMN error_fingerprint;
diff --git a/internal-packages/clickhouse/schema/022_create_errors_v1_table.sql b/internal-packages/clickhouse/schema/022_create_errors_v1_table.sql
new file mode 100644
index 00000000000..e9c6e5ea3c8
--- /dev/null
+++ b/internal-packages/clickhouse/schema/022_create_errors_v1_table.sql
@@ -0,0 +1,78 @@
+-- +goose Up
+
+-- Aggregated error groups table (per task + fingerprint)
+CREATE TABLE trigger_dev.errors_v1
+(
+  organization_id           String,
+  project_id                String,
+  environment_id            String,
+  task_identifier           String,
+  error_fingerprint         String,
+
+  -- Error details (samples from occurrences)
+  error_type                String,
+  error_message             String,
+  sample_stack_trace        String,
+
+  -- SimpleAggregateFunction stores raw values and applies the function during merge,
+  -- avoiding binary state encoding issues with AggregateFunction.
+  last_seen_date            SimpleAggregateFunction(max, DateTime),
+
+  first_seen                SimpleAggregateFunction(min, DateTime64(3)),
+  last_seen                 SimpleAggregateFunction(max, DateTime64(3)),
+  occurrence_count          AggregateFunction(sum, UInt64),
+  affected_task_versions    AggregateFunction(uniq, String),
+
+  -- Samples for debugging
+  sample_run_id             AggregateFunction(any, String),
+  sample_friendly_id        AggregateFunction(any, String),
+
+  -- Status distribution
+  status_distribution       AggregateFunction(sumMap, Array(String), Array(UInt64))
+)
+ENGINE = AggregatingMergeTree()
+ORDER BY (organization_id, project_id, environment_id, task_identifier, error_fingerprint)
+TTL last_seen_date + INTERVAL 90 DAY
+SETTINGS index_granularity = 8192;
+
+-- Materialized view to auto-populate from task_runs_v2
+CREATE MATERIALIZED VIEW trigger_dev.errors_mv_v1
+TO trigger_dev.errors_v1
+AS
+SELECT
+  organization_id,
+  project_id,
+  environment_id,
+  task_identifier,
+  error_fingerprint,
+
+  any(coalesce(nullIf(toString(error.data.type), ''), nullIf(toString(error.data.name), ''), 'Error')) as error_type,
+  any(coalesce(nullIf(substring(toString(error.data.message), 1, 500), ''), 'Unknown error')) as error_message,
+  any(coalesce(substring(toString(error.data.stack), 1, 2000), '')) as sample_stack_trace,
+
+  toDateTime(max(created_at)) as last_seen_date,
+
+  min(created_at) as first_seen,
+  max(created_at) as last_seen,
+  sumState(toUInt64(1)) as occurrence_count,
+  uniqState(task_version) as affected_task_versions,
+
+  anyState(run_id) as sample_run_id,
+  anyState(friendly_id) as sample_friendly_id,
+
+  sumMapState([status], [toUInt64(1)]) as status_distribution
+FROM trigger_dev.task_runs_v2
+WHERE
+  error_fingerprint != ''
+  AND status IN ('SYSTEM_FAILURE', 'CRASHED', 'INTERRUPTED', 'COMPLETED_WITH_ERRORS', 'TIMED_OUT')
+  AND _is_deleted = 0
+GROUP BY
+  organization_id,
+  project_id,
+  environment_id,
+  task_identifier,
+  error_fingerprint;
+
+-- +goose Down
+DROP VIEW IF EXISTS trigger_dev.errors_mv_v1;
+DROP TABLE IF EXISTS trigger_dev.errors_v1;
diff --git a/internal-packages/clickhouse/schema/023_create_error_occurrences_v1.sql b/internal-packages/clickhouse/schema/023_create_error_occurrences_v1.sql
new file mode 100644
index 00000000000..6b0aec271be
--- /dev/null
+++ b/internal-packages/clickhouse/schema/023_create_error_occurrences_v1.sql
@@ -0,0 +1,89 @@
+-- +goose Up
+-- Per-minute error occurrence counts, keyed by fingerprint + task + version.
+-- Powers precise time-range filtering and dynamic-granularity occurrence charts.
+CREATE TABLE
+  trigger_dev.error_occurrences_v1 (
+    organization_id String,
+    project_id String,
+    environment_id String,
+    task_identifier String,
+    error_fingerprint String,
+    task_version String,
+    minute DateTime,
+    error_type String,
+    error_message String,
+    stack_trace String,
+    count UInt64,
+    INDEX idx_error_type_search lower(error_type) TYPE ngrambf_v1 (3, 32768, 2, 0) GRANULARITY 1,
+    INDEX idx_error_message_search lower(error_message) TYPE ngrambf_v1 (3, 32768, 2, 0) GRANULARITY 1
+  ) ENGINE = SummingMergeTree (count)
+PARTITION BY
+  toDate (minute)
+ORDER BY
+  (
+    organization_id,
+    project_id,
+    environment_id,
+    task_identifier,
+    error_fingerprint,
+    task_version,
+    minute
+  ) TTL minute + INTERVAL 90 DAY SETTINGS index_granularity = 8192;
+
+CREATE MATERIALIZED VIEW trigger_dev.error_occurrences_mv_v1 TO trigger_dev.error_occurrences_v1 AS
+SELECT
+  organization_id,
+  project_id,
+  environment_id,
+  task_identifier,
+  error_fingerprint,
+  task_version,
+  toStartOfMinute (created_at) as minute,
+  any (
+    coalesce(
+      nullIf(toString (error.data.type), ''),
+      nullIf(toString (error.data.name), ''),
+      'Error'
+    )
+  ) as error_type,
+  any (
+    coalesce(
+      nullIf(
+        substring(toString (error.data.message), 1, 500),
+        ''
+      ),
+      'Unknown error'
+    )
+  ) as error_message,
+  any (
+    coalesce(
+      substring(toString (error.data.stack), 1, 2000),
+      ''
+    )
+  ) as stack_trace,
+  count() as count
+FROM
+  trigger_dev.task_runs_v2
+WHERE
+  error_fingerprint != ''
+  AND status IN (
+    'SYSTEM_FAILURE',
+    'CRASHED',
+    'INTERRUPTED',
+    'COMPLETED_WITH_ERRORS',
+    'TIMED_OUT'
+  )
+  AND _is_deleted = 0
+GROUP BY
+  organization_id,
+  project_id,
+  environment_id,
+  task_identifier,
+  error_fingerprint,
+  task_version,
+  minute;
+
+-- +goose Down
+DROP VIEW IF EXISTS trigger_dev.error_occurrences_mv_v1;
+
+DROP TABLE IF EXISTS trigger_dev.error_occurrences_v1;
\ No newline at end of file
diff --git a/internal-packages/clickhouse/schema/024_create_llm_usage_v1.sql b/internal-packages/clickhouse/schema/024_create_llm_usage_v1.sql
new file mode 100644
index 00000000000..7cfbc0cea98
--- /dev/null
+++ b/internal-packages/clickhouse/schema/024_create_llm_usage_v1.sql
@@ -0,0 +1,64 @@
+-- +goose Up
+CREATE TABLE IF NOT EXISTS trigger_dev.llm_metrics_v1
+(
+  -- Tenant context
+  organization_id   LowCardinality(String),
+  project_id        LowCardinality(String),
+  environment_id    String CODEC(ZSTD(1)),
+  run_id            String CODEC(ZSTD(1)),
+  task_identifier   LowCardinality(String),
+  trace_id          String CODEC(ZSTD(1)),
+  span_id           String CODEC(ZSTD(1)),
+
+  -- Model & provider
+  gen_ai_system     LowCardinality(String),
+  request_model     String CODEC(ZSTD(1)),
+  response_model    String CODEC(ZSTD(1)),
+  matched_model_id  String CODEC(ZSTD(1)),
+  operation_id      LowCardinality(String),
+  finish_reason     LowCardinality(String),
+  cost_source       LowCardinality(String),
+
+  -- Pricing
+  pricing_tier_id   String CODEC(ZSTD(1)),
+  pricing_tier_name LowCardinality(String),
+
+  -- Token usage
+  input_tokens      UInt64 DEFAULT 0,
+  output_tokens     UInt64 DEFAULT 0,
+  total_tokens      UInt64 DEFAULT 0,
+  usage_details     Map(LowCardinality(String), UInt64),
+
+  -- Cost
+  input_cost        Decimal64(12) DEFAULT 0,
+  output_cost       Decimal64(12) DEFAULT 0,
+  total_cost        Decimal64(12) DEFAULT 0,
+  cost_details      Map(LowCardinality(String), Decimal64(12)),
+  provider_cost     Decimal64(12) DEFAULT 0,
+
+  -- Performance
+  ms_to_first_chunk Float64 DEFAULT 0,
+  tokens_per_second Float64 DEFAULT 0,
+
+  -- Attribution
+  metadata          Map(LowCardinality(String), String),
+
+  -- Timing
+  start_time        DateTime64(9) CODEC(Delta(8), ZSTD(1)),
+  duration          UInt64 DEFAULT 0 CODEC(ZSTD(1)),
+  inserted_at       DateTime64(3) DEFAULT now64(3),
+
+  -- Indexes
+  INDEX idx_run_id run_id TYPE bloom_filter(0.001) GRANULARITY 1,
+  INDEX idx_span_id span_id TYPE bloom_filter(0.001) GRANULARITY 1,
+  INDEX idx_response_model response_model TYPE bloom_filter(0.01) GRANULARITY 1,
+  INDEX idx_metadata_keys mapKeys(metadata) TYPE bloom_filter(0.01) GRANULARITY 1
+)
+ENGINE = MergeTree
+PARTITION BY toDate(inserted_at)
+ORDER BY (organization_id, project_id, environment_id, toDate(inserted_at), run_id)
+TTL toDateTime(inserted_at) + INTERVAL 365 DAY
+SETTINGS ttl_only_drop_parts = 1;
+
+-- +goose Down
+DROP TABLE IF EXISTS trigger_dev.llm_metrics_v1;
diff --git a/internal-packages/clickhouse/schema/025_add_prompt_columns_to_llm_metrics_v1.sql b/internal-packages/clickhouse/schema/025_add_prompt_columns_to_llm_metrics_v1.sql
new file mode 100644
index 00000000000..edfea2887ee
--- /dev/null
+++ b/internal-packages/clickhouse/schema/025_add_prompt_columns_to_llm_metrics_v1.sql
@@ -0,0 +1,13 @@
+-- +goose Up
+ALTER TABLE trigger_dev.llm_metrics_v1
+  ADD COLUMN prompt_slug LowCardinality(String) DEFAULT '';
+
+ALTER TABLE trigger_dev.llm_metrics_v1
+  ADD COLUMN prompt_version UInt32 DEFAULT 0;
+
+-- +goose Down
+ALTER TABLE trigger_dev.llm_metrics_v1
+  DROP COLUMN prompt_slug;
+
+ALTER TABLE trigger_dev.llm_metrics_v1
+  DROP COLUMN prompt_version;
diff --git a/internal-packages/clickhouse/schema/026_add_base_response_model_to_llm_metrics_v1.sql b/internal-packages/clickhouse/schema/026_add_base_response_model_to_llm_metrics_v1.sql
new file mode 100644
index 00000000000..3d23295b026
--- /dev/null
+++ b/internal-packages/clickhouse/schema/026_add_base_response_model_to_llm_metrics_v1.sql
@@ -0,0 +1,7 @@
+-- +goose Up
+ALTER TABLE trigger_dev.llm_metrics_v1
+  ADD COLUMN base_response_model String DEFAULT '' CODEC(ZSTD(1));
+
+-- +goose Down
+ALTER TABLE trigger_dev.llm_metrics_v1
+  DROP COLUMN base_response_model;
diff --git a/internal-packages/clickhouse/schema/027_create_llm_model_aggregates_v1.sql b/internal-packages/clickhouse/schema/027_create_llm_model_aggregates_v1.sql
new file mode 100644
index 00000000000..3797f744bc2
--- /dev/null
+++ b/internal-packages/clickhouse/schema/027_create_llm_model_aggregates_v1.sql
@@ -0,0 +1,57 @@
+-- +goose Up
+
+-- Pre-aggregated model performance metrics with no tenant information.
+-- Used for cross-tenant model comparisons in the Model Registry.
+-- Aggregated per minute for high-resolution model performance tracking.
+CREATE TABLE IF NOT EXISTS trigger_dev.llm_model_aggregates_v1
+(
+  response_model        String,
+  base_response_model   String DEFAULT '',
+  gen_ai_system         LowCardinality(String),
+  minute                DateTime,
+
+  -- Counts & totals (SimpleAggregateFunction for sum)
+  call_count            SimpleAggregateFunction(sum, UInt64),
+  total_input_tokens    SimpleAggregateFunction(sum, UInt64),
+  total_output_tokens   SimpleAggregateFunction(sum, UInt64),
+  total_cost            SimpleAggregateFunction(sum, Float64),
+
+  -- Performance quantiles (AggregateFunction for merge across parts)
+  ttfc_quantiles        AggregateFunction(quantiles(0.5, 0.9, 0.95, 0.99), Float64),
+  tps_quantiles         AggregateFunction(quantiles(0.5, 0.9, 0.95, 0.99), Float64),
+  duration_quantiles    AggregateFunction(quantiles(0.5, 0.9, 0.95, 0.99), UInt64),
+
+  -- Finish reason distribution
+  finish_reason_counts  SimpleAggregateFunction(sumMap, Map(String, UInt64))
+)
+ENGINE = AggregatingMergeTree
+PARTITION BY toYYYYMM(minute)
+ORDER BY (response_model, base_response_model, gen_ai_system, minute)
+TTL toDate(minute) + INTERVAL 365 DAY
+SETTINGS ttl_only_drop_parts = 1;
+
+-- Materialized view that feeds the aggregate table from llm_metrics_v1.
+-- Strips all tenant-specific columns (org, project, env, run, span, trace).
+-- base_response_model comes from the source table (populated during event enrichment).
+CREATE MATERIALIZED VIEW IF NOT EXISTS trigger_dev.llm_model_aggregates_mv_v1
+TO trigger_dev.llm_model_aggregates_v1
+AS SELECT
+  response_model,
+  base_response_model,
+  gen_ai_system,
+  toStartOfMinute(start_time) AS minute,
+  count()            AS call_count,
+  sum(input_tokens)  AS total_input_tokens,
+  sum(output_tokens) AS total_output_tokens,
+  sum(total_cost)    AS total_cost,
+  quantilesStateIf(0.5, 0.9, 0.95, 0.99)(ms_to_first_chunk, ms_to_first_chunk > 0) AS ttfc_quantiles,
+  quantilesStateIf(0.5, 0.9, 0.95, 0.99)(tokens_per_second, tokens_per_second > 0)  AS tps_quantiles,
+  quantilesState(0.5, 0.9, 0.95, 0.99)(duration)           AS duration_quantiles,
+  sumMap(map(finish_reason, toUInt64(1)))                    AS finish_reason_counts
+FROM trigger_dev.llm_metrics_v1
+WHERE response_model != ''
+GROUP BY response_model, base_response_model, gen_ai_system, minute;
+
+-- +goose Down
+DROP TABLE IF EXISTS trigger_dev.llm_model_aggregates_mv_v1;
+DROP TABLE IF EXISTS trigger_dev.llm_model_aggregates_v1;
diff --git a/internal-packages/clickhouse/schema/028_add_trigger_source_and_warm_start_to_task_runs_v2.sql b/internal-packages/clickhouse/schema/028_add_trigger_source_and_warm_start_to_task_runs_v2.sql
new file mode 100644
index 00000000000..9381df8ddd5
--- /dev/null
+++ b/internal-packages/clickhouse/schema/028_add_trigger_source_and_warm_start_to_task_runs_v2.sql
@@ -0,0 +1,19 @@
+-- +goose Up
+ALTER TABLE trigger_dev.task_runs_v2
+  ADD COLUMN trigger_source LowCardinality(String) DEFAULT '';
+
+ALTER TABLE trigger_dev.task_runs_v2
+  ADD COLUMN root_trigger_source LowCardinality(String) DEFAULT '';
+
+ALTER TABLE trigger_dev.task_runs_v2
+  ADD COLUMN is_warm_start Nullable(UInt8) DEFAULT NULL;
+
+-- +goose Down
+ALTER TABLE trigger_dev.task_runs_v2
+  DROP COLUMN trigger_source;
+
+ALTER TABLE trigger_dev.task_runs_v2
+  DROP COLUMN root_trigger_source;
+
+ALTER TABLE trigger_dev.task_runs_v2
+  DROP COLUMN is_warm_start;
diff --git a/internal-packages/clickhouse/src/client/client.ts b/internal-packages/clickhouse/src/client/client.ts
index 3ed73032624..5a4118934e7 100644
--- a/internal-packages/clickhouse/src/client/client.ts
+++ b/internal-packages/clickhouse/src/client/client.ts
@@ -6,9 +6,11 @@ import {
   createClient,
   type ResultSet,
   type Row,
+  type BaseQueryParams,
+  type InsertResult,
 } from "@clickhouse/client";
 import { recordSpanError, Span, startSpan, trace, Tracer } from "@internal/tracing";
-import { flattenAttributes, tryCatch } from "@trigger.dev/core/v3";
+import { flattenAttributes, tryCatch, type Result } from "@trigger.dev/core/v3";
 import { z } from "zod";
 import { InsertError, QueryError } from "./errors.js";
 import type {
@@ -16,9 +18,11 @@ import type {
   ClickhouseQueryBuilderFastFunction,
   ClickhouseQueryBuilderFunction,
   ClickhouseQueryFunction,
+  ClickhouseQueryWithStatsFunction,
   ClickhouseReader,
   ClickhouseWriter,
   ColumnExpression,
+  QueryStats,
 } from "./types.js";
 import { generateErrorMessage } from "zod-error";
 import { Logger, type LogLevel } from "@trigger.dev/core/logger";
@@ -229,6 +233,184 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter {
     };
   }
 
+  public queryWithStats<TIn extends z.ZodSchema<any>, TOut extends z.ZodSchema<any>>(req: {
+    /**
+     * The name of the operation.
+     * This will be used to identify the operation in the span.
+     */
+    name: string;
+    /**
+     * The SQL query to run.
+     * Use {paramName: Type} to define parameters
+     * Example: `SELECT * FROM table WHERE id = {id: String}`
+     */
+    query: string;
+    /**
+     * The schema of the parameters
+     * Example: z.object({ id: z.string() })
+     */
+    params?: TIn;
+    /**
+     * The schema of the output of each row
+     * Example: z.object({ id: z.string() })
+     */
+    schema: TOut;
+    /**
+     * The settings to use for the query.
+     * These will be merged with the default settings.
+     */
+    settings?: ClickHouseSettings;
+  }): ClickhouseQueryWithStatsFunction<z.input<TIn>, z.output<TOut>> {
+    return async (params, options) => {
+      const queryId = randomUUID();
+
+      return await startSpan(this.tracer, "queryWithStats", async (span) => {
+        this.logger.debug("Querying clickhouse with stats", {
+          name: req.name,
+          query: req.query.replace(/\s+/g, " "),
+          params,
+          settings: req.settings,
+          attributes: options?.attributes,
+          queryId,
+        });
+
+        span.setAttributes({
+          "clickhouse.clientName": this.name,
+          "clickhouse.operationName": req.name,
+          "clickhouse.queryId": queryId,
+          ...flattenAttributes(req.settings, "clickhouse.settings"),
+          ...flattenAttributes(options?.attributes),
+        });
+
+        const validParams = req.params?.safeParse(params);
+
+        if (validParams?.error) {
+          recordSpanError(span, validParams.error);
+
+          this.logger.error("Error parsing query params", {
+            name: req.name,
+            error: validParams.error,
+            query: req.query,
+            params,
+            queryId,
+          });
+
+          return [
+            new QueryError(`Bad params: ${generateErrorMessage(validParams.error.issues)}`, {
+              query: req.query,
+            }),
+            null,
+          ];
+        }
+
+        let unparsedRows: Array<TOut> = [];
+
+        const [clickhouseError, res] = await tryCatch(
+          this.client.query({
+            query: req.query,
+            query_params: validParams?.data,
+            format: "JSONEachRow",
+            query_id: queryId,
+            ...options?.params,
+            clickhouse_settings: {
+              ...req.settings,
+              ...options?.params?.clickhouse_settings,
+            },
+          })
+        );
+
+        if (clickhouseError) {
+          this.logger.error("Error querying clickhouse", {
+            name: req.name,
+            error: clickhouseError,
+            query: req.query,
+            params,
+            queryId,
+          });
+
+          recordClickhouseError(span, clickhouseError);
+
+          return [
+            new QueryError(`Unable to query clickhouse: ${clickhouseError.message}`, {
+              query: req.query,
+            }),
+            null,
+          ];
+        }
+
+        unparsedRows = await res.json();
+
+        span.setAttributes({
+          "clickhouse.query_id": res.query_id,
+          ...flattenAttributes(res.response_headers, "clickhouse.response_headers"),
+        });
+
+        // Parse the summary header to get stats
+        const summaryHeader = res.response_headers["x-clickhouse-summary"];
+        let stats: QueryStats = {
+          read_rows: "0",
+          read_bytes: "0",
+          written_rows: "0",
+          written_bytes: "0",
+          total_rows_to_read: "0",
+          result_rows: "0",
+          result_bytes: "0",
+          elapsed_ns: "0",
+          byte_seconds: "0",
+        };
+
+        if (typeof summaryHeader === "string") {
+          const parsedSummary = JSON.parse(summaryHeader);
+          this.logger.debug("parsedSummary", parsedSummary);
+          const readBytes = parsedSummary.read_bytes ? parseInt(parsedSummary.read_bytes, 10) : 0;
+          const elapsedNs = parsedSummary.elapsed_ns ? parseInt(parsedSummary.elapsed_ns, 10) : 0;
+          const elapsedSeconds = elapsedNs / 1_000_000_000;
+          const byteSeconds = elapsedSeconds > 0 ? readBytes / elapsedSeconds : 0;
+          stats = {
+            read_rows: parsedSummary.read_rows ?? "0",
+            read_bytes: parsedSummary.read_bytes ?? "0",
+            written_rows: parsedSummary.written_rows ?? "0",
+            written_bytes: parsedSummary.written_bytes ?? "0",
+            total_rows_to_read: parsedSummary.total_rows_to_read ?? "0",
+            result_rows: parsedSummary.result_rows ?? "0",
+            result_bytes: parsedSummary.result_bytes ?? "0",
+            elapsed_ns: parsedSummary.elapsed_ns ?? "0",
+            byte_seconds: byteSeconds.toString(),
+          };
+          span.setAttributes({
+            ...flattenAttributes(parsedSummary, "clickhouse.summary"),
+          });
+        }
+
+        const parsed = z.array(req.schema).safeParse(unparsedRows);
+
+        if (parsed.error) {
+          this.logger.error("Error parsing clickhouse query result", {
+            name: req.name,
+            error: parsed.error,
+            query: req.query,
+            params,
+            queryId,
+          });
+
+          const queryError = new QueryError(generateErrorMessage(parsed.error.issues), {
+            query: req.query,
+          });
+
+          recordSpanError(span, queryError);
+
+          return [queryError, null];
+        }
+
+        span.setAttributes({
+          "clickhouse.rows": unparsedRows.length,
+        });
+
+        return [null, { rows: parsed.data, stats }];
+      });
+    };
+  }
+
   public queryFast<TOut extends Record<string, any>, TParams extends Record<string, any>>(req: {
     name: string;
     query: string;
@@ -465,6 +647,76 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter {
     };
   }
 
+  public insertCompact<TRecord extends Record<string, any>>(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    toArray: (record: TRecord) => any[];
+    settings?: ClickHouseSettings;
+  }): ClickhouseInsertFunction<TRecord> {
+    return async (events, options) => {
+      const queryId = randomUUID();
+
+      return await startSpan(this.tracer, "insert", async (span) => {
+        const eventsArray = Array.isArray(events) ? events : [events];
+
+        this.logger.debug("Inserting into clickhouse (compact)", {
+          clientName: this.name,
+          name: req.name,
+          table: req.table,
+          events: eventsArray.length,
+          settings: req.settings,
+          attributes: options?.attributes,
+          options,
+          queryId,
+        });
+
+        span.setAttributes({
+          "clickhouse.clientName": this.name,
+          "clickhouse.tableName": req.table,
+          "clickhouse.operationName": req.name,
+          "clickhouse.queryId": queryId,
+          "clickhouse.format": "JSONCompactEachRowWithNames",
+          ...flattenAttributes(req.settings, "clickhouse.settings"),
+          ...flattenAttributes(options?.attributes),
+        });
+
+        // Build compact format: [columns, ...rows]
+        const compactData: any[] = [Array.from(req.columns)];
+        for (let i = 0; i < eventsArray.length; i++) {
+          compactData.push(req.toArray(eventsArray[i]));
+        }
+
+        const [clickhouseError, result] = await tryCatch(
+          this.client.insert({
+            table: req.table,
+            format: "JSONCompactEachRowWithNames",
+            values: compactData,
+            query_id: queryId,
+            ...options?.params,
+            clickhouse_settings: {
+              ...req.settings,
+              ...options?.params?.clickhouse_settings,
+            },
+          })
+        );
+
+        if (clickhouseError) {
+          this.logger.error("Error inserting into clickhouse", {
+            name: req.name,
+            error: clickhouseError,
+            table: req.table,
+          });
+
+          recordClickhouseError(span, clickhouseError);
+          return [new InsertError(clickhouseError.message), null];
+        }
+
+        return [null, result];
+      });
+    };
+  }
+
   public insertUnsafe<TRecord extends Record<string, any>>(req: {
     name: string;
     table: string;
@@ -474,11 +726,13 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter {
       const queryId = randomUUID();
 
       return await startSpan(this.tracer, "insert", async (span) => {
+        const eventsArray = Array.isArray(events) ? events : [events];
+
         this.logger.debug("Inserting into clickhouse", {
           clientName: this.name,
           name: req.name,
           table: req.table,
-          events: Array.isArray(events) ? events.length : 1,
+          events: eventsArray.length,
           settings: req.settings,
           attributes: options?.attributes,
           options,
@@ -498,7 +752,7 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter {
           this.client.insert({
             table: req.table,
             format: "JSONEachRow",
-            values: Array.isArray(events) ? events : [events],
+            values: eventsArray,
             query_id: queryId,
             ...options?.params,
             clickhouse_settings: {
@@ -545,26 +799,119 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter {
       });
     };
   }
+
+  public insertCompactRaw(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    settings?: ClickHouseSettings;
+  }): (
+    events: readonly any[][] | any[],
+    options?: {
+      attributes?: Record<string, string | number | boolean>;
+      params?: BaseQueryParams;
+    }
+  ) => Promise<Result<InsertResult, InsertError>> {
+    return async (events, options) => {
+      const queryId = randomUUID();
+
+      return await startSpan(this.tracer, "insert", async (span) => {
+        // Check if events is a single row (array) or multiple rows (array of arrays)
+        // If first element is not an array, treat as single row
+        const isSingleRow = events.length > 0 && !Array.isArray(events[0]);
+        const eventsArray: readonly any[][] = isSingleRow
+          ? [events as any[]]
+          : (events as readonly any[][]);
+
+        this.logger.debug("Inserting into clickhouse (compact raw)", {
+          clientName: this.name,
+          name: req.name,
+          table: req.table,
+          events: eventsArray.length,
+          settings: req.settings,
+          attributes: options?.attributes,
+          options,
+          queryId,
+        });
+
+        span.setAttributes({
+          "clickhouse.clientName": this.name,
+          "clickhouse.tableName": req.table,
+          "clickhouse.operationName": req.name,
+          "clickhouse.queryId": queryId,
+          "clickhouse.format": "JSONCompactEachRowWithNames",
+          ...flattenAttributes(req.settings, "clickhouse.settings"),
+          ...flattenAttributes(options?.attributes),
+        });
+
+        // Build compact format: [columns, ...rows]
+        // Data is already in array format, no conversion needed
+        const compactData: any[] = [Array.from(req.columns), ...eventsArray];
+
+        const [clickhouseError, result] = await tryCatch(
+          this.client.insert({
+            table: req.table,
+            format: "JSONCompactEachRowWithNames",
+            values: compactData,
+            query_id: queryId,
+            ...options?.params,
+            clickhouse_settings: {
+              ...req.settings,
+              ...options?.params?.clickhouse_settings,
+            },
+          })
+        );
+
+        if (clickhouseError) {
+          this.logger.error("Error inserting into clickhouse", {
+            name: req.name,
+            error: clickhouseError,
+            table: req.table,
+          });
+
+          recordClickhouseError(span, clickhouseError);
+          return [new InsertError(clickhouseError.message), null];
+        }
+
+        this.logger.debug("Inserted into clickhouse", {
+          clientName: this.name,
+          name: req.name,
+          table: req.table,
+          result,
+          queryId,
+        });
+
+        span.setAttributes({
+          "clickhouse.query_id": result.query_id,
+          "clickhouse.executed": result.executed,
+          "clickhouse.summary.read_rows": result.summary?.read_rows,
+          "clickhouse.summary.read_bytes": result.summary?.read_bytes,
+          "clickhouse.summary.written_rows": result.summary?.written_rows,
+          "clickhouse.summary.written_bytes": result.summary?.written_bytes,
+          "clickhouse.summary.total_rows_to_read": result.summary?.total_rows_to_read,
+          "clickhouse.summary.result_rows": result.summary?.result_rows,
+          "clickhouse.summary.result_bytes": result.summary?.result_bytes,
+          "clickhouse.summary.elapsed_ns": result.summary?.elapsed_ns,
+        });
+
+        return [null, result];
+      });
+    };
+  }
 }
 
-function recordClickhouseError(span: Span, error: Error) {
+function recordClickhouseError(span: Span, error: Error): void {
   if (error instanceof ClickHouseError) {
     span.setAttributes({
       "clickhouse.error.code": error.code,
       "clickhouse.error.message": error.message,
       "clickhouse.error.type": error.type,
     });
-    recordSpanError(span, error);
-  } else {
-    recordSpanError(span, error);
   }
+  recordSpanError(span, error);
 }
 
-function convertLogLevelToClickhouseLogLevel(logLevel?: LogLevel) {
-  if (!logLevel) {
-    return ClickHouseLogLevel.INFO;
-  }
-
+function convertLogLevelToClickhouseLogLevel(logLevel?: LogLevel): ClickHouseLogLevel {
   switch (logLevel) {
     case "debug":
       return ClickHouseLogLevel.DEBUG;
diff --git a/internal-packages/clickhouse/src/client/noop.ts b/internal-packages/clickhouse/src/client/noop.ts
index 6815baf4f6b..e0872cada6a 100644
--- a/internal-packages/clickhouse/src/client/noop.ts
+++ b/internal-packages/clickhouse/src/client/noop.ts
@@ -3,9 +3,10 @@ import { InsertError, QueryError } from "./errors.js";
 import {
   ClickhouseQueryBuilderFastFunction,
   ClickhouseQueryBuilderFunction,
+  ClickhouseReader,
   ClickhouseWriter,
+  QueryResultWithStats,
 } from "./types.js";
-import { ClickhouseReader } from "./types.js";
 import { z } from "zod";
 import { ClickHouseSettings, InsertResult } from "@clickhouse/client";
 import { ClickhouseQueryBuilder, ClickhouseQueryFastBuilder } from "./queryBuilder.js";
@@ -51,6 +52,38 @@ export class NoopClient implements ClickhouseReader, ClickhouseWriter {
     };
   }
 
+  public queryWithStats<TIn extends z.ZodSchema<any>, TOut extends z.ZodSchema<any>>(req: {
+    query: string;
+    params?: TIn;
+    schema: TOut;
+  }): (params: z.input<TIn>) => Promise<Result<QueryResultWithStats<z.output<TOut>>, QueryError>> {
+    return async (params: z.input<TIn>) => {
+      const validParams = req.params?.safeParse(params);
+
+      if (validParams?.error) {
+        return [new QueryError(`Bad params: ${validParams.error.message}`, { query: "" }), null];
+      }
+
+      return [
+        null,
+        {
+          rows: [],
+          stats: {
+            read_rows: "0",
+            read_bytes: "0",
+            written_rows: "0",
+            written_bytes: "0",
+            total_rows_to_read: "0",
+            result_rows: "0",
+            result_bytes: "0",
+            elapsed_ns: "0",
+            byte_seconds: "0",
+          },
+        },
+      ];
+    };
+  }
+
   public queryFast<TOut extends Record<string, any>, TParams extends Record<string, any>>(req: {
     name: string;
     query: string;
@@ -126,4 +159,61 @@ export class NoopClient implements ClickhouseReader, ClickhouseWriter {
       ];
     };
   }
+
+  public insertCompact<TRecord extends Record<string, any>>(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    toArray: (record: TRecord) => any[];
+    settings?: ClickHouseSettings;
+  }): (events: TRecord | TRecord[]) => Promise<Result<InsertResult, InsertError>> {
+    return async (events: TRecord | TRecord[]) => {
+      return [
+        null,
+        {
+          executed: true,
+          query_id: "noop",
+          summary: {
+            read_rows: "0",
+            read_bytes: "0",
+            written_rows: "0",
+            written_bytes: "0",
+            total_rows_to_read: "0",
+            result_rows: "0",
+            result_bytes: "0",
+            elapsed_ns: "0",
+          },
+          response_headers: {},
+        },
+      ];
+    };
+  }
+
+  public insertCompactRaw(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    settings?: ClickHouseSettings;
+  }): (events: readonly any[][] | any[]) => Promise<Result<InsertResult, InsertError>> {
+    return async (events: readonly any[][] | any[]) => {
+      return [
+        null,
+        {
+          executed: true,
+          query_id: "noop",
+          summary: {
+            read_rows: "0",
+            read_bytes: "0",
+            written_rows: "0",
+            written_bytes: "0",
+            total_rows_to_read: "0",
+            result_rows: "0",
+            result_bytes: "0",
+            elapsed_ns: "0",
+          },
+          response_headers: {},
+        },
+      ];
+    };
+  }
 }
diff --git a/internal-packages/clickhouse/src/client/queryBuilder.ts b/internal-packages/clickhouse/src/client/queryBuilder.ts
index 78383fd270a..fb0430fd0db 100644
--- a/internal-packages/clickhouse/src/client/queryBuilder.ts
+++ b/internal-packages/clickhouse/src/client/queryBuilder.ts
@@ -4,10 +4,16 @@ import { ClickHouseSettings } from "@clickhouse/client";
 export type QueryParamValue = string | number | boolean | Array<string | number | boolean> | null;
 export type QueryParams = Record<string, QueryParamValue>;
 
+export type WhereCondition = {
+  clause: string;
+  params?: QueryParams;
+};
+
 export class ClickhouseQueryBuilder<TOutput> {
   private name: string;
   private baseQuery: string;
   private whereClauses: string[] = [];
+  private havingClauses: string[] = [];
   private params: QueryParams = {};
   private orderByClause: string | null = null;
   private limitClause: string | null = null;
@@ -30,6 +36,12 @@ export class ClickhouseQueryBuilder<TOutput> {
     this.settings = settings;
   }
 
+  /** Set query parameters without adding a WHERE clause. Use for base queries with inline params. */
+  setParams(params: QueryParams): this {
+    Object.assign(this.params, params);
+    return this;
+  }
+
   where(clause: string, params?: QueryParams): this {
     this.whereClauses.push(clause);
     if (params) {
@@ -45,11 +57,40 @@ export class ClickhouseQueryBuilder<TOutput> {
     return this;
   }
 
+  whereOr(conditions: WhereCondition[]): this {
+    if (conditions.length === 0) {
+      return this;
+    }
+    const combinedClause = conditions.map((c) => `(${c.clause})`).join(" OR ");
+    this.whereClauses.push(`(${combinedClause})`);
+    for (const condition of conditions) {
+      if (condition.params) {
+        Object.assign(this.params, condition.params);
+      }
+    }
+    return this;
+  }
+
   groupBy(clause: string): this {
     this.groupByClause = clause;
     return this;
   }
 
+  having(clause: string, params?: QueryParams): this {
+    this.havingClauses.push(clause);
+    if (params) {
+      Object.assign(this.params, params);
+    }
+    return this;
+  }
+
+  havingIf(condition: any, clause: string, params?: QueryParams): this {
+    if (condition) {
+      this.having(clause, params);
+    }
+    return this;
+  }
+
   orderBy(clause: string): this {
     this.orderByClause = clause;
     return this;
@@ -82,6 +123,9 @@ export class ClickhouseQueryBuilder<TOutput> {
     if (this.groupByClause) {
       query += ` GROUP BY ${this.groupByClause}`;
     }
+    if (this.havingClauses.length > 0) {
+      query += " HAVING " + this.havingClauses.join(" AND ");
+    }
     if (this.orderByClause) {
       query += ` ORDER BY ${this.orderByClause}`;
     }
@@ -98,7 +142,9 @@ export class ClickhouseQueryFastBuilder<TOutput extends Record<string, any>> {
   private columns: Array<string | ColumnExpression>;
   private reader: ClickhouseReader;
   private settings: ClickHouseSettings | undefined;
+  private prewhereClauses: string[] = [];
   private whereClauses: string[] = [];
+  private havingClauses: string[] = [];
   private params: QueryParams = {};
   private orderByClause: string | null = null;
   private limitClause: string | null = null;
@@ -118,6 +164,25 @@ export class ClickhouseQueryFastBuilder<TOutput extends Record<string, any>> {
     this.settings = settings;
   }
 
+  /**
+   * Add a PREWHERE clause - filters applied before reading columns.
+   * Use for primary key columns (environment_id, start_time) to reduce I/O.
+   */
+  prewhere(clause: string, params?: QueryParams): this {
+    this.prewhereClauses.push(clause);
+    if (params) {
+      Object.assign(this.params, params);
+    }
+    return this;
+  }
+
+  prewhereIf(condition: any, clause: string, params?: QueryParams): this {
+    if (condition) {
+      this.prewhere(clause, params);
+    }
+    return this;
+  }
+
   where(clause: string, params?: QueryParams): this {
     this.whereClauses.push(clause);
     if (params) {
@@ -133,11 +198,40 @@ export class ClickhouseQueryFastBuilder<TOutput extends Record<string, any>> {
     return this;
   }
 
+  whereOr(conditions: WhereCondition[]): this {
+    if (conditions.length === 0) {
+      return this;
+    }
+    const combinedClause = conditions.map((c) => `(${c.clause})`).join(" OR ");
+    this.whereClauses.push(`(${combinedClause})`);
+    for (const condition of conditions) {
+      if (condition.params) {
+        Object.assign(this.params, condition.params);
+      }
+    }
+    return this;
+  }
+
   groupBy(clause: string): this {
     this.groupByClause = clause;
     return this;
   }
 
+  having(clause: string, params?: QueryParams): this {
+    this.havingClauses.push(clause);
+    if (params) {
+      Object.assign(this.params, params);
+    }
+    return this;
+  }
+
+  havingIf(condition: any, clause: string, params?: QueryParams): this {
+    if (condition) {
+      this.having(clause, params);
+    }
+    return this;
+  }
+
   orderBy(clause: string): this {
     this.orderByClause = clause;
     return this;
@@ -163,12 +257,18 @@ export class ClickhouseQueryFastBuilder<TOutput extends Record<string, any>> {
 
   build(): { query: string; params: QueryParams } {
     let query = `SELECT ${this.buildColumns().join(", ")} FROM ${this.table}`;
+    if (this.prewhereClauses.length > 0) {
+      query += " PREWHERE " + this.prewhereClauses.join(" AND ");
+    }
     if (this.whereClauses.length > 0) {
       query += " WHERE " + this.whereClauses.join(" AND ");
     }
     if (this.groupByClause) {
       query += ` GROUP BY ${this.groupByClause}`;
     }
+    if (this.havingClauses.length > 0) {
+      query += " HAVING " + this.havingClauses.join(" AND ");
+    }
     if (this.orderByClause) {
       query += ` ORDER BY ${this.orderByClause}`;
     }
diff --git a/internal-packages/clickhouse/src/client/tsql.ts b/internal-packages/clickhouse/src/client/tsql.ts
new file mode 100644
index 00000000000..0a8367e7173
--- /dev/null
+++ b/internal-packages/clickhouse/src/client/tsql.ts
@@ -0,0 +1,345 @@
+/**
+ * TSQL Query Execution for ClickHouse
+ *
+ * This module provides a safe interface for executing TSQL queries against ClickHouse
+ * with enforced WHERE clause conditions (tenant isolation + plan limits) and SQL injection protection.
+ */
+
+import type { ClickHouseSettings } from "@clickhouse/client";
+import { z } from "zod";
+import {
+  compileTSQL,
+  sanitizeErrorMessage,
+  transformResults,
+  type TableSchema,
+  type QuerySettings,
+  type FieldMappings,
+  type TimeRange,
+  type WhereClauseCondition
+} from "@internal/tsql";
+import type { ClickhouseReader, QueryStats } from "./types.js";
+import { QueryError } from "./errors.js";
+import type { OutputColumnMetadata } from "@internal/tsql";
+import { Logger } from "@trigger.dev/core/logger";
+
+const logger = new Logger("tsql", "info");
+
+export type { QueryStats };
+
+export type { TableSchema, QuerySettings, FieldMappings, TimeRange, WhereClauseCondition };
+
+/**
+ * Options for executing a TSQL query
+ */
+export interface ExecuteTSQLOptions<TOut extends z.ZodSchema> {
+  /** The name of the operation (for logging/tracing) */
+  name: string;
+  /** The TSQL query string to execute */
+  query: string;
+  /** The Zod schema for validating output rows */
+  schema: TOut;
+  /** Schema registry defining allowed tables and columns */
+  tableSchema: TableSchema[];
+  /**
+   * REQUIRED: Conditions always applied at the table level.
+   * Must include tenant columns (e.g., organization_id) for multi-tenant tables.
+   * Applied to every table reference including subqueries, CTEs, and JOINs.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   // Tenant isolation
+   *   organization_id: { op: "eq", value: "org_123" },
+   *   project_id: { op: "eq", value: "proj_456" },
+   *   environment_id: { op: "eq", value: "env_789" },
+   *   // Plan-based time limit
+   *   triggered_at: { op: "gte", value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
+   * }
+   * ```
+   */
+  enforcedWhereClause: Record<string, WhereClauseCondition | undefined>;
+  /** Optional ClickHouse query settings */
+  clickhouseSettings?: ClickHouseSettings;
+  /** Optional TSQL query settings (maxRows, timezone, etc.) */
+  querySettings?: Partial<QuerySettings>;
+  /**
+   * Whether to transform result values using the schema's valueMap
+   * When enabled, internal ClickHouse values (e.g., 'COMPLETED_SUCCESSFULLY')
+   * are converted to user-friendly display names (e.g., 'Completed')
+   * @default true
+   */
+  transformValues?: boolean;
+  /**
+   * Runtime field mappings for dynamic value translation.
+   * Maps internal ClickHouse values to external user-facing values.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   project: { "cm12345": "my-project-ref" },
+   * }
+   * ```
+   */
+  fieldMappings?: FieldMappings;
+  /**
+   * Run EXPLAIN instead of executing the query.
+   * Returns the ClickHouse execution plan with index information.
+   * Should only be used by admins for debugging query performance.
+   * @default false
+   */
+  explain?: boolean;
+  /**
+   * Fallback WHERE conditions to apply when the user hasn't filtered on a column.
+   * Key is the column name, value is the fallback condition.
+   * These are applied at the AST level (top-level query only).
+   *
+   * @example
+   * ```typescript
+   * // Apply triggered_at >= 7 days ago if user doesn't filter on triggered_at
+   * whereClauseFallback: {
+   *   triggered_at: { op: 'gte', value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
+   * }
+   * ```
+   */
+  whereClauseFallback?: Record<string, WhereClauseCondition>;
+  /**
+   * Time range for `timeBucket()` interval calculation.
+   * When provided, `timeBucket()` uses this to determine the appropriate bucket size
+   * based on the span of the time range.
+   */
+  timeRange?: TimeRange;
+}
+
+/**
+ * Successful result from TSQL query execution
+ */
+export interface TSQLQuerySuccess<T> {
+  rows: T[];
+  columns: OutputColumnMetadata[];
+  stats: QueryStats;
+  /**
+   * Columns that were hidden when SELECT * was used.
+   * Only populated when SELECT * is transformed to core columns only.
+   */
+  hiddenColumns?: string[];
+  /**
+   * Whether the result count equals the maxRows limit.
+   * When true, the results may be truncated and more rows may exist.
+   */
+  reachedMaxRows: boolean;
+  /**
+   * The raw EXPLAIN output from ClickHouse.
+   * Only populated when `explain: true` is passed.
+   */
+  explainOutput?: string;
+  /**
+   * The generated ClickHouse SQL query.
+   * Only populated when `explain: true` is passed.
+   */
+  generatedSql?: string;
+}
+
+/**
+ * Result type for TSQL query execution
+ */
+export type TSQLQueryResult<T> = [QueryError, null] | [null, TSQLQuerySuccess<T>];
+
+/**
+ * Execute a TSQL query against ClickHouse
+ *
+ * This function:
+ * 1. Compiles the TSQL query to ClickHouse SQL (parse, validate, inject enforced WHERE clauses)
+ * 2. Executes the query and returns validated results
+ *
+ * @example
+ * ```typescript
+ * const [error, rows] = await executeTSQL(reader, {
+ *   name: "get_task_runs",
+ *   query: "SELECT id, status FROM task_runs WHERE status = 'completed' ORDER BY created_at DESC LIMIT 100",
+ *   schema: z.object({ id: z.string(), status: z.string() }),
+ *   tableSchema: [taskRunsSchema],
+ *   enforcedWhereClause: {
+ *     organization_id: { op: "eq", value: "org_123" },
+ *     project_id: { op: "eq", value: "proj_456" },
+ *     environment_id: { op: "eq", value: "env_789" },
+ *   },
+ * });
+ * ```
+ */
+export async function executeTSQL<TOut extends z.ZodSchema>(
+  reader: ClickhouseReader,
+  options: ExecuteTSQLOptions<TOut>
+): Promise<TSQLQueryResult<z.output<TOut>>> {
+  const shouldTransformValues = options.transformValues ?? true;
+  const isExplain = options.explain ?? false;
+  const maxRows = options.querySettings?.maxRows;
+
+  let generatedSql: string | undefined;
+  let generatedParams: Record<string, unknown> | undefined;
+
+  try {
+    // 1. Compile the TSQL query to ClickHouse SQL
+    // Pass maxRows + 1 to fetch one extra row for overflow detection
+    const compiledSettings = maxRows !== undefined
+      ? { ...options.querySettings, maxRows: maxRows + 1 }
+      : options.querySettings;
+
+    const { sql, params, columns, hiddenColumns } = compileTSQL(options.query, {
+      tableSchema: options.tableSchema,
+      enforcedWhereClause: options.enforcedWhereClause,
+      settings: compiledSettings,
+      fieldMappings: options.fieldMappings,
+      whereClauseFallback: options.whereClauseFallback,
+      timeRange: options.timeRange,
+    });
+
+    generatedSql = sql;
+    generatedParams = params;
+
+    // 2. Execute the query (or EXPLAIN) with stats
+    const queryToExecute = isExplain ? `EXPLAIN indexes = 1 ${sql}` : sql;
+
+    const queryFn = reader.queryWithStats({
+      name: isExplain ? `${options.name}-explain` : options.name,
+      query: queryToExecute,
+      params: z.record(z.any()),
+      // EXPLAIN returns rows with an 'explain' column
+      schema: isExplain ? z.object({ explain: z.string() }) : options.schema,
+      settings: options.clickhouseSettings,
+    });
+
+    const [error, result] = await queryFn(params);
+
+    if (error) {
+      // Sanitize error message to show TSQL names instead of ClickHouse internals
+      const sanitizedMessage = sanitizeErrorMessage(error.message, options.tableSchema);
+      return [new QueryError(sanitizedMessage, { query: options.query }), null];
+    }
+
+    const { rows, stats } = result;
+
+    // Handle EXPLAIN mode - run multiple explain types and combine outputs
+    if (isExplain) {
+      const explainRows = rows as Array<{ explain: string }>;
+      const indexesOutput = explainRows.map((r) => r.explain).join("\n");
+
+      // Run additional explain queries for more comprehensive output
+      const explainTypes = [
+        { name: "ESTIMATE", query: `EXPLAIN ESTIMATE ${sql}` },
+        { name: "PIPELINE", query: `EXPLAIN PIPELINE ${sql}` },
+      ];
+
+      const additionalOutputs: string[] = [];
+
+      for (const explainType of explainTypes) {
+        try {
+          const additionalQueryFn = reader.queryWithStats({
+            name: `${options.name}-explain-${explainType.name.toLowerCase()}`,
+            query: explainType.query,
+            params: z.record(z.any()),
+            schema: z.object({ explain: z.string() }),
+            settings: options.clickhouseSettings,
+          });
+
+          const [additionalError, additionalResult] = await additionalQueryFn(params);
+
+          if (!additionalError && additionalResult) {
+            const additionalRows = additionalResult.rows as Array<{ explain: string }>;
+            const output = additionalRows.map((r) => r.explain).join("\n");
+            additionalOutputs.push(`── ${explainType.name} ──\n${output}`);
+          }
+        } catch {
+          // Ignore errors from additional explain queries
+        }
+      }
+
+      // Combine all explain outputs
+      const combinedOutput = ["── INDEXES ──", indexesOutput, "", ...additionalOutputs].join("\n");
+
+      return [
+        null,
+        {
+          rows: [] as z.output<TOut>[],
+          columns: [],
+          stats,
+          hiddenColumns,
+          reachedMaxRows: false,
+          explainOutput: combinedOutput,
+          generatedSql,
+        },
+      ];
+    }
+
+    // Determine if we exceeded maxRows (we fetched maxRows + 1 to detect overflow)
+    const reachedMaxRows = maxRows !== undefined && rows !== undefined && rows.length > maxRows;
+
+    // Remove the overflow row if we got one (pop is O(1), slice would be O(n))
+    const finalRows = rows ?? [];
+    if (reachedMaxRows) {
+      finalRows.pop();
+    }
+
+    // Build the result, including hiddenColumns if present
+    const baseResult = { columns, stats, hiddenColumns, reachedMaxRows };
+
+    // 3. Transform result values if enabled
+    if (shouldTransformValues && finalRows.length > 0) {
+      const transformedRows = transformResults(
+        finalRows as Record<string, unknown>[],
+        options.tableSchema,
+        { fieldMappings: options.fieldMappings }
+      );
+      return [null, { rows: transformedRows as z.output<TOut>[], ...baseResult }];
+    }
+
+    return [null, { rows: finalRows as z.output<TOut>[], ...baseResult }];
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+    // Log TSQL compilation or unexpected errors (with original message for debugging)
+    logger.error("[TSQL] Query error", {
+      name: options.name,
+      error: errorMessage,
+      tsql: options.query,
+      generatedSql: generatedSql ?? "(compilation failed)",
+      generatedParams: generatedParams ?? {},
+    });
+
+    // Sanitize error message to show TSQL names instead of ClickHouse internals
+    const sanitizedMessage = sanitizeErrorMessage(errorMessage, options.tableSchema);
+
+    if (error instanceof Error) {
+      return [new QueryError(sanitizedMessage, { query: options.query }), null];
+    }
+    return [new QueryError("Unknown error executing TSQL query", { query: options.query }), null];
+  }
+}
+
+/**
+ * Create a reusable TSQL query executor bound to specific table schemas
+ *
+ * @example
+ * ```typescript
+ * const tsqlExecutor = createTSQLExecutor(reader, [taskRunsSchema, taskEventsSchema]);
+ *
+ * const [error, rows] = await tsqlExecutor.execute({
+ *   name: "get_task_runs",
+ *   query: "SELECT * FROM task_runs LIMIT 10",
+ *   schema: taskRunRowSchema,
+ *   enforcedWhereClause: {
+ *     organization_id: { op: "eq", value: "org_123" },
+ *     project_id: { op: "eq", value: "proj_456" },
+ *     environment_id: { op: "eq", value: "env_789" },
+ *   },
+ * });
+ * ```
+ */
+export function createTSQLExecutor(reader: ClickhouseReader, tableSchema: TableSchema[]) {
+  return {
+    execute: <TOut extends z.ZodSchema>(
+      options: Omit<ExecuteTSQLOptions<TOut>, "tableSchema">
+    ): Promise<TSQLQueryResult<z.output<TOut>>> => {
+      return executeTSQL(reader, { ...options, tableSchema });
+    },
+  };
+}
diff --git a/internal-packages/clickhouse/src/client/types.ts b/internal-packages/clickhouse/src/client/types.ts
index f0874c814d2..71204225081 100644
--- a/internal-packages/clickhouse/src/client/types.ts
+++ b/internal-packages/clickhouse/src/client/types.ts
@@ -13,6 +13,37 @@ export type ClickhouseQueryFunction<TInput, TOutput> = (
   }
 ) => Promise<Result<TOutput[], QueryError>>;
 
+/**
+ * Query statistics returned by ClickHouse
+ */
+export interface QueryStats {
+  read_rows: string;
+  read_bytes: string;
+  written_rows: string;
+  written_bytes: string;
+  total_rows_to_read: string;
+  result_rows: string;
+  result_bytes: string;
+  elapsed_ns: string;
+  byte_seconds: string;
+}
+
+/**
+ * Result type for queries that include stats
+ */
+export interface QueryResultWithStats<TOutput> {
+  rows: TOutput[];
+  stats: QueryStats;
+}
+
+export type ClickhouseQueryWithStatsFunction<TInput, TOutput> = (
+  params: TInput,
+  options?: {
+    attributes?: Record<string, string | number | boolean>;
+    params?: BaseQueryParams;
+  }
+) => Promise<Result<QueryResultWithStats<TOutput>, QueryError>>;
+
 export type ClickhouseQueryBuilderFunction<TOutput> = (options?: {
   settings?: ClickHouseSettings;
 }) => ClickhouseQueryBuilder<TOutput>;
@@ -56,6 +87,39 @@ export interface ClickhouseReader {
     settings?: ClickHouseSettings;
   }): ClickhouseQueryFunction<z.input<TIn>, z.output<TOut>>;
 
+  /**
+   * Execute a query and return both rows and query statistics.
+   * Same as `query` but includes ClickHouse query stats in the result.
+   */
+  queryWithStats<TIn extends z.ZodSchema<any>, TOut extends z.ZodSchema<any>>(req: {
+    /**
+     * The name of the operation.
+     * This will be used to identify the operation in the span.
+     */
+    name: string;
+    /**
+     * The SQL query to run.
+     * Use {paramName: Type} to define parameters
+     * Example: `SELECT * FROM table WHERE id = {id: String}`
+     */
+    query: string;
+    /**
+     * The schema of the parameters
+     * Example: z.object({ id: z.string() })
+     */
+    params?: TIn;
+    /**
+     * The schema of the output of each row
+     * Example: z.object({ id: z.string() })
+     */
+    schema: TOut;
+    /**
+     * The settings to use for the query.
+     * These will be merged with the default settings.
+     */
+    settings?: ClickHouseSettings;
+  }): ClickhouseQueryWithStatsFunction<z.input<TIn>, z.output<TOut>>;
+
   queryFast<TOut extends Record<string, any>, TParams extends Record<string, any>>(req: {
     /**
      * The name of the operation.
@@ -156,5 +220,26 @@ export interface ClickhouseWriter {
     settings?: ClickHouseSettings;
   }): ClickhouseInsertFunction<TRecord>;
 
+  insertCompact<TRecord extends Record<string, any>>(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    toArray: (record: TRecord) => any[];
+    settings?: ClickHouseSettings;
+  }): ClickhouseInsertFunction<TRecord>;
+
+  insertCompactRaw(req: {
+    name: string;
+    table: string;
+    columns: readonly string[];
+    settings?: ClickHouseSettings;
+  }): (
+    events: readonly any[][] | any[],
+    options?: {
+      attributes?: Record<string, string | number | boolean>;
+      params?: BaseQueryParams;
+    }
+  ) => Promise<Result<InsertResult, InsertError>>;
+
   close(): Promise<void>;
 }
diff --git a/internal-packages/clickhouse/src/errors.ts b/internal-packages/clickhouse/src/errors.ts
new file mode 100644
index 00000000000..4b13ce18c80
--- /dev/null
+++ b/internal-packages/clickhouse/src/errors.ts
@@ -0,0 +1,461 @@
+import { ClickHouseSettings } from "@clickhouse/client";
+import { z } from "zod";
+import { ClickhouseReader } from "./client/types.js";
+import { ClickhouseQueryBuilder } from "./client/queryBuilder.js";
+
+export const ErrorGroupsListQueryResult = z.object({
+  error_fingerprint: z.string(),
+  task_identifier: z.string(),
+  error_type: z.string(),
+  error_message: z.string(),
+  first_seen: z.string(),
+  last_seen: z.string(),
+  occurrence_count: z.number(),
+  sample_run_id: z.string(),
+  sample_friendly_id: z.string(),
+});
+
+export type ErrorGroupsListQueryResult = z.infer<typeof ErrorGroupsListQueryResult>;
+
+/**
+ * Gets a query builder for listing error groups from the pre-aggregated errors_v1 table.
+ * Allows flexible filtering and pagination.
+ */
+export function getErrorGroupsListQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getErrorGroupsList",
+    baseQuery: `
+      SELECT
+        error_fingerprint,
+        task_identifier,
+        any(error_type) as error_type,
+        any(error_message) as error_message,
+        toString(toUnixTimestamp64Milli(min(first_seen))) as first_seen,
+        toString(toUnixTimestamp64Milli(max(last_seen))) as last_seen,
+        toUInt64(sumMerge(occurrence_count)) as occurrence_count,
+        anyMerge(sample_run_id) as sample_run_id,
+        anyMerge(sample_friendly_id) as sample_friendly_id
+      FROM trigger_dev.errors_v1
+    `,
+    schema: ErrorGroupsListQueryResult,
+    settings,
+  });
+}
+
+export const ErrorGroupQueryResult = z.object({
+  error_fingerprint: z.string(),
+  task_identifier: z.string(),
+  error_type: z.string(),
+  error_message: z.string(),
+  first_seen: z.string(),
+  last_seen: z.string(),
+  occurrence_count: z.number(),
+  sample_run_id: z.string(),
+  sample_friendly_id: z.string(),
+});
+
+export type ErrorGroupQueryResult = z.infer<typeof ErrorGroupQueryResult>;
+
+export const ErrorGroupQueryParams = z.object({
+  organizationId: z.string(),
+  projectId: z.string(),
+  environmentId: z.string(),
+  days: z.number().int().default(30),
+  limit: z.number().int().default(50),
+  offset: z.number().int().default(0),
+});
+
+export type ErrorGroupQueryParams = z.infer<typeof ErrorGroupQueryParams>;
+
+/**
+ * Gets error groups from the pre-aggregated errors_v1 table.
+ * Much faster than on-the-fly aggregation.
+ */
+export function getErrorGroups(ch: ClickhouseReader, settings?: ClickHouseSettings) {
+  return ch.query({
+    name: "getErrorGroups",
+    query: `
+      SELECT
+        error_fingerprint,
+        task_identifier,
+        any(error_type) as error_type,
+        any(error_message) as error_message,
+        toString(toUnixTimestamp64Milli(min(first_seen))) as first_seen,
+        toString(toUnixTimestamp64Milli(max(last_seen))) as last_seen,
+        toUInt64(sumMerge(occurrence_count)) as occurrence_count,
+        anyMerge(sample_run_id) as sample_run_id,
+        anyMerge(sample_friendly_id) as sample_friendly_id
+      FROM trigger_dev.errors_v1
+      WHERE
+        organization_id = {organizationId: String}
+        AND project_id = {projectId: String}
+        AND environment_id = {environmentId: String}
+      GROUP BY error_fingerprint, task_identifier
+      HAVING toInt64(last_seen) >= toInt64(toUnixTimestamp(now() - INTERVAL {days: Int64} DAY)) * 1000
+      ORDER BY toInt64(last_seen) DESC
+      LIMIT {limit: Int64}
+      OFFSET {offset: Int64}
+    `,
+    schema: ErrorGroupQueryResult,
+    params: ErrorGroupQueryParams,
+    settings,
+  });
+}
+
+export const ErrorInstanceQueryResult = z.object({
+  run_id: z.string(),
+  friendly_id: z.string(),
+  task_identifier: z.string(),
+  created_at: z.string(),
+  status: z.string(),
+  error_text: z.string(),
+  trace_id: z.string(),
+  task_version: z.string(),
+});
+
+export type ErrorInstanceQueryResult = z.infer<typeof ErrorInstanceQueryResult>;
+
+export const ErrorInstanceQueryParams = z.object({
+  organizationId: z.string(),
+  projectId: z.string(),
+  environmentId: z.string(),
+  errorFingerprint: z.string(),
+  limit: z.number().int().default(50),
+  offset: z.number().int().default(0),
+});
+
+export type ErrorInstanceQueryParams = z.infer<typeof ErrorInstanceQueryParams>;
+
+export const ErrorHourlyOccurrencesQueryResult = z.object({
+  error_fingerprint: z.string(),
+  hour_epoch: z.number(),
+  count: z.number(),
+});
+
+export type ErrorHourlyOccurrencesQueryResult = z.infer<typeof ErrorHourlyOccurrencesQueryResult>;
+
+export const ErrorHourlyOccurrencesQueryParams = z.object({
+  organizationId: z.string(),
+  projectId: z.string(),
+  environmentId: z.string(),
+  fingerprints: z.array(z.string()),
+  hours: z.number().int().default(24),
+});
+
+export type ErrorHourlyOccurrencesQueryParams = z.infer<typeof ErrorHourlyOccurrencesQueryParams>;
+
+/**
+ * Gets hourly occurrence counts for specific error fingerprints over the past N hours.
+ * Queries task_runs_v2 directly, grouped by fingerprint and hour.
+ */
+export function getErrorHourlyOccurrences(ch: ClickhouseReader, settings?: ClickHouseSettings) {
+  return ch.query({
+    name: "getErrorHourlyOccurrences",
+    query: `
+      SELECT
+        error_fingerprint,
+        toUnixTimestamp(toStartOfHour(created_at)) as hour_epoch,
+        count() as count
+      FROM trigger_dev.task_runs_v2 FINAL
+      WHERE
+        organization_id = {organizationId: String}
+        AND project_id = {projectId: String}
+        AND environment_id = {environmentId: String}
+        AND created_at >= now() - INTERVAL {hours: Int64} HOUR
+        AND error_fingerprint IN {fingerprints: Array(String)}
+        AND status IN ('SYSTEM_FAILURE', 'CRASHED', 'INTERRUPTED', 'COMPLETED_WITH_ERRORS', 'TIMED_OUT')
+        AND _is_deleted = 0
+      GROUP BY
+        error_fingerprint,
+        hour_epoch
+      ORDER BY
+        error_fingerprint ASC,
+        hour_epoch ASC
+    `,
+    schema: ErrorHourlyOccurrencesQueryResult,
+    params: ErrorHourlyOccurrencesQueryParams,
+    settings,
+  });
+}
+
+/**
+ * Gets individual run instances for a specific error fingerprint.
+ */
+export function getErrorInstances(ch: ClickhouseReader, settings?: ClickHouseSettings) {
+  return ch.query({
+    name: "getErrorInstances",
+    query: `
+      SELECT
+        run_id,
+        friendly_id,
+        task_identifier,
+        toString(created_at) as created_at,
+        status,
+        error_text,
+        trace_id,
+        task_version
+      FROM trigger_dev.task_runs_v2 FINAL
+      WHERE
+        organization_id = {organizationId: String}
+        AND project_id = {projectId: String}
+        AND environment_id = {environmentId: String}
+        AND error_fingerprint = {errorFingerprint: String}
+        AND _is_deleted = 0
+      ORDER BY created_at DESC
+      LIMIT {limit: Int64}
+      OFFSET {offset: Int64}
+    `,
+    schema: ErrorInstanceQueryResult,
+    params: ErrorInstanceQueryParams,
+    settings,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Affected versions – distinct task_version from error_occurrences_v1
+// ---------------------------------------------------------------------------
+
+export const ErrorAffectedVersionsQueryResult = z.object({
+  task_version: z.string(),
+});
+
+export type ErrorAffectedVersionsQueryResult = z.infer<typeof ErrorAffectedVersionsQueryResult>;
+
+/**
+ * Query builder for fetching distinct task_version values for an error fingerprint
+ * from the error_occurrences_v1 SummingMergeTree table.
+ * task_version is part of the ORDER BY key, so this is efficient.
+ */
+export function getErrorAffectedVersionsQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getErrorAffectedVersions",
+    baseQuery: `
+      SELECT DISTINCT task_version
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    schema: ErrorAffectedVersionsQueryResult,
+    settings,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// error_occurrences_v1 – per-minute bucketed error counts
+// ---------------------------------------------------------------------------
+
+export const ErrorOccurrencesListQueryResult = z.object({
+  error_fingerprint: z.string(),
+  task_identifier: z.string(),
+  error_type: z.string(),
+  error_message: z.string(),
+  occurrence_count: z.number(),
+});
+
+export type ErrorOccurrencesListQueryResult = z.infer<typeof ErrorOccurrencesListQueryResult>;
+
+/**
+ * Query builder for listing error groups from the per-minute error_occurrences_v1 table.
+ * Time filtering is done via WHERE on the `minute` column, giving precise time-scoped counts.
+ */
+export function getErrorOccurrencesListQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getErrorOccurrencesList",
+    baseQuery: `
+      SELECT
+        error_fingerprint,
+        task_identifier,
+        any(error_type) as error_type,
+        any(error_message) as error_message,
+        sum(count) as occurrence_count
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    schema: ErrorOccurrencesListQueryResult,
+    settings,
+  });
+}
+
+export const ErrorOccurrencesBucketQueryResult = z.object({
+  error_fingerprint: z.string(),
+  bucket_epoch: z.number(),
+  count: z.number(),
+});
+
+export type ErrorOccurrencesBucketQueryResult = z.infer<typeof ErrorOccurrencesBucketQueryResult>;
+
+/**
+ * Creates a query builder for bucketed error occurrence counts.
+ * The `intervalExpr` is a ClickHouse INTERVAL literal (e.g. "INTERVAL 1 HOUR").
+ * Returns a builder directly since the base query varies with each granularity.
+ */
+export function createErrorOccurrencesQueryBuilder(
+  ch: ClickhouseReader,
+  intervalExpr: string,
+  settings?: ClickHouseSettings
+): ClickhouseQueryBuilder<ErrorOccurrencesBucketQueryResult> {
+  return new ClickhouseQueryBuilder(
+    "getErrorOccurrencesBucketed",
+    `
+      SELECT
+        error_fingerprint,
+        toUnixTimestamp(toStartOfInterval(minute, ${intervalExpr})) as bucket_epoch,
+        sum(count) as count
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    ch,
+    ErrorOccurrencesBucketQueryResult,
+    settings
+  );
+}
+
+export const ErrorOccurrencesByVersionQueryResult = z.object({
+  error_fingerprint: z.string(),
+  task_version: z.string(),
+  bucket_epoch: z.number(),
+  count: z.number(),
+});
+
+export type ErrorOccurrencesByVersionQueryResult = z.infer<
+  typeof ErrorOccurrencesByVersionQueryResult
+>;
+
+/**
+ * Creates a query builder for bucketed error occurrence counts grouped by task_version.
+ * Used for stacked-by-version activity charts on the error detail page.
+ */
+export function createErrorOccurrencesByVersionQueryBuilder(
+  ch: ClickhouseReader,
+  intervalExpr: string,
+  settings?: ClickHouseSettings
+): ClickhouseQueryBuilder<ErrorOccurrencesByVersionQueryResult> {
+  return new ClickhouseQueryBuilder(
+    "getErrorOccurrencesByVersion",
+    `
+      SELECT
+        error_fingerprint,
+        task_version,
+        toUnixTimestamp(toStartOfInterval(minute, ${intervalExpr})) as bucket_epoch,
+        sum(count) as count
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    ch,
+    ErrorOccurrencesByVersionQueryResult,
+    settings
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Alert evaluator – active errors since a timestamp
+// ---------------------------------------------------------------------------
+
+export const ActiveErrorsSinceQueryResult = z.object({
+  environment_id: z.string(),
+  task_identifier: z.string(),
+  error_fingerprint: z.string(),
+  error_type: z.string(),
+  error_message: z.string(),
+  sample_stack_trace: z.string(),
+  first_seen: z.string(),
+  last_seen: z.string(),
+  occurrence_count: z.number(),
+});
+
+export type ActiveErrorsSinceQueryResult = z.infer<typeof ActiveErrorsSinceQueryResult>;
+
+/**
+ * Query builder for fetching all errors active since a given timestamp.
+ * Returns errors with last_seen > scheduledAt, grouped by env/task/fingerprint.
+ * Used by the error alert evaluator to find new issues, regressions, and un-ignored errors.
+ */
+export function getActiveErrorsSinceQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getActiveErrorsSince",
+    baseQuery: `
+      SELECT
+        environment_id,
+        task_identifier,
+        error_fingerprint,
+        any(error_type) as error_type,
+        any(error_message) as error_message,
+        any(sample_stack_trace) as sample_stack_trace,
+        toString(toUnixTimestamp64Milli(min(first_seen))) as first_seen,
+        toString(toUnixTimestamp64Milli(max(last_seen))) as last_seen,
+        toUInt64(sumMerge(occurrence_count)) as occurrence_count
+      FROM trigger_dev.errors_v1
+    `,
+    schema: ActiveErrorsSinceQueryResult,
+    settings,
+  });
+}
+
+export const OccurrenceCountsSinceQueryResult = z.object({
+  environment_id: z.string(),
+  task_identifier: z.string(),
+  error_fingerprint: z.string(),
+  occurrences_since: z.number(),
+});
+
+export type OccurrenceCountsSinceQueryResult = z.infer<typeof OccurrenceCountsSinceQueryResult>;
+
+/**
+ * Query builder for occurrence counts since a given timestamp, grouped by error.
+ * Used by the alert evaluator to check ignore thresholds.
+ */
+export function getOccurrenceCountsSinceQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getOccurrenceCountsSince",
+    baseQuery: `
+      SELECT
+        environment_id,
+        task_identifier,
+        error_fingerprint,
+        sum(count) as occurrences_since
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    schema: OccurrenceCountsSinceQueryResult,
+    settings,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Alert evaluator helpers – occurrence rate & count since timestamp
+// ---------------------------------------------------------------------------
+
+export const ErrorOccurrenceTotalCountResult = z.object({
+  total_count: z.number(),
+});
+
+export type ErrorOccurrenceTotalCountResult = z.infer<typeof ErrorOccurrenceTotalCountResult>;
+
+/**
+ * Query builder for summing occurrences since a given timestamp.
+ * Used by the alert evaluator to check total-count-based ignore thresholds.
+ */
+export function getOccurrenceCountSinceQueryBuilder(
+  ch: ClickhouseReader,
+  settings?: ClickHouseSettings
+) {
+  return ch.queryBuilder({
+    name: "getOccurrenceCountSince",
+    baseQuery: `
+      SELECT
+        sum(count) as total_count
+      FROM trigger_dev.error_occurrences_v1
+    `,
+    schema: ErrorOccurrenceTotalCountResult,
+    settings,
+  });
+}
diff --git a/internal-packages/clickhouse/src/index.ts b/internal-packages/clickhouse/src/index.ts
index 4aceeb92d8d..c6b8858fa9c 100644
--- a/internal-packages/clickhouse/src/index.ts
+++ b/internal-packages/clickhouse/src/index.ts
@@ -1,10 +1,11 @@
-import { ClickHouseSettings } from "@clickhouse/client";
+import type { ClickHouseSettings } from "@clickhouse/client";
+export type { ClickHouseSettings };
 import { ClickhouseClient } from "./client/client.js";
 import { ClickhouseReader, ClickhouseWriter } from "./client/types.js";
 import { NoopClient } from "./client/noop.js";
 import {
-  insertTaskRuns,
-  insertRawTaskRunPayloads,
+  insertTaskRunsCompactArrays,
+  insertRawTaskRunPayloadsCompactArrays,
   getTaskRunsQueryBuilder,
   getTaskActivityQueryBuilder,
   getCurrentRunningStats,
@@ -22,15 +23,69 @@ import {
   getTraceSummaryQueryBuilderV2,
   insertTaskEvents,
   insertTaskEventsV2,
+  getLogDetailQueryBuilderV2,
+  getLogsSearchListQueryBuilder,
 } from "./taskEvents.js";
+import { insertMetrics } from "./metrics.js";
+import { insertLlmMetrics } from "./llmMetrics.js";
+import {
+  getGlobalModelMetrics,
+  getGlobalModelComparison,
+  getPopularModels,
+} from "./llmModelAggregates.js";
+import {
+  getErrorGroups,
+  getErrorInstances,
+  getErrorGroupsListQueryBuilder,
+  getErrorHourlyOccurrences,
+  getErrorOccurrencesListQueryBuilder,
+  createErrorOccurrencesQueryBuilder,
+  createErrorOccurrencesByVersionQueryBuilder,
+  getErrorAffectedVersionsQueryBuilder,
+  getOccurrenceCountSinceQueryBuilder,
+  getActiveErrorsSinceQueryBuilder,
+  getOccurrenceCountsSinceQueryBuilder,
+} from "./errors.js";
+export { msToClickHouseInterval } from "./intervals.js";
 import { Logger, type LogLevel } from "@trigger.dev/core/logger";
 import type { Agent as HttpAgent } from "http";
 import type { Agent as HttpsAgent } from "https";
 
 export type * from "./taskRuns.js";
 export type * from "./taskEvents.js";
+export type * from "./metrics.js";
+export type * from "./llmMetrics.js";
+export type * from "./llmModelAggregates.js";
+export type * from "./errors.js";
 export type * from "./client/queryBuilder.js";
 
+// Re-export column constants, indices, and type-safe accessors
+export {
+  TASK_RUN_COLUMNS,
+  TASK_RUN_INDEX,
+  PAYLOAD_COLUMNS,
+  PAYLOAD_INDEX,
+  getTaskRunField,
+  getPayloadField,
+} from "./taskRuns.js";
+
+// TSQL query execution
+export {
+  executeTSQL,
+  createTSQLExecutor,
+  type ExecuteTSQLOptions,
+  type TableSchema,
+  type TSQLQueryResult,
+  type TSQLQuerySuccess,
+  type QueryStats,
+  type FieldMappings,
+  type WhereClauseCondition,
+} from "./client/tsql.js";
+export type { ColumnFormatType, OutputColumnMetadata } from "@internal/tsql";
+
+// Errors
+export { QueryError } from "./client/errors.js";
+
 export type ClickhouseCommonConfig = {
   keepAlive?: {
     enabled?: boolean;
@@ -155,8 +210,8 @@ export class ClickHouse {
 
   get taskRuns() {
     return {
-      insert: insertTaskRuns(this.writer),
-      insertPayloads: insertRawTaskRunPayloads(this.writer),
+      insertCompactArrays: insertTaskRunsCompactArrays(this.writer),
+      insertPayloadsCompactArrays: insertRawTaskRunPayloadsCompactArrays(this.writer),
       queryBuilder: getTaskRunsQueryBuilder(this.reader),
       countQueryBuilder: getTaskRunsCountQueryBuilder(this.reader),
       tagQueryBuilder: getTaskRunTagsQueryBuilder(this.reader),
@@ -176,12 +231,57 @@ export class ClickHouse {
     };
   }
 
+  get metrics() {
+    return {
+      insert: insertMetrics(this.writer),
+    };
+  }
+
+  get llmMetrics() {
+    return {
+      insert: insertLlmMetrics(this.writer),
+    };
+  }
+
+  get llmModelAggregates() {
+    return {
+      globalMetrics: getGlobalModelMetrics(this.reader),
+      comparison: getGlobalModelComparison(this.reader),
+      popular: getPopularModels(this.reader),
+    };
+  }
+
   get taskEventsV2() {
     return {
       insert: insertTaskEventsV2(this.writer),
       traceSummaryQueryBuilder: getTraceSummaryQueryBuilderV2(this.reader),
       traceDetailedSummaryQueryBuilder: getTraceDetailedSummaryQueryBuilderV2(this.reader),
       spanDetailsQueryBuilder: getSpanDetailsQueryBuilderV2(this.reader),
+      logDetailQueryBuilder: getLogDetailQueryBuilderV2(this.reader),
+    };
+  }
+
+  get taskEventsSearch() {
+    return {
+      logsListQueryBuilder: getLogsSearchListQueryBuilder(this.reader),
+    };
+  }
+
+  get errors() {
+    return {
+      getGroups: getErrorGroups(this.reader),
+      getInstances: getErrorInstances(this.reader),
+      getHourlyOccurrences: getErrorHourlyOccurrences(this.reader),
+      affectedVersionsQueryBuilder: getErrorAffectedVersionsQueryBuilder(this.reader),
+      listQueryBuilder: getErrorGroupsListQueryBuilder(this.reader),
+      occurrencesListQueryBuilder: getErrorOccurrencesListQueryBuilder(this.reader),
+      createOccurrencesQueryBuilder: (intervalExpr: string) =>
+        createErrorOccurrencesQueryBuilder(this.reader, intervalExpr),
+      createOccurrencesByVersionQueryBuilder: (intervalExpr: string) =>
+        createErrorOccurrencesByVersionQueryBuilder(this.reader, intervalExpr),
+      occurrenceCountSinceQueryBuilder: getOccurrenceCountSinceQueryBuilder(this.reader),
+      activeErrorsSinceQueryBuilder: getActiveErrorsSinceQueryBuilder(this.reader),
+      occurrenceCountsSinceQueryBuilder: getOccurrenceCountsSinceQueryBuilder(this.reader),
     };
   }
 }
diff --git a/internal-packages/clickhouse/src/intervals.ts b/internal-packages/clickhouse/src/intervals.ts
new file mode 100644
index 00000000000..d21fd73815c
--- /dev/null
+++ b/internal-packages/clickhouse/src/intervals.ts
@@ -0,0 +1,5 @@
+/** Converts a granularity in milliseconds to a ClickHouse INTERVAL expression. */
+export function msToClickHouseInterval(ms: number): string {
+  const seconds = Math.round(ms / 1000);
+  return `INTERVAL ${seconds} SECOND`;
+}
diff --git a/internal-packages/clickhouse/src/llmMetrics.ts b/internal-packages/clickhouse/src/llmMetrics.ts
new file mode 100644
index 00000000000..ba064df125f
--- /dev/null
+++ b/internal-packages/clickhouse/src/llmMetrics.ts
@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { ClickhouseWriter } from "./client/types.js";
+
+export const LlmMetricsV1Input = z.object({
+  organization_id: z.string(),
+  project_id: z.string(),
+  environment_id: z.string(),
+  run_id: z.string(),
+  task_identifier: z.string(),
+  trace_id: z.string(),
+  span_id: z.string(),
+
+  gen_ai_system: z.string(),
+  request_model: z.string(),
+  response_model: z.string(),
+  base_response_model: z.string(),
+  matched_model_id: z.string(),
+  operation_id: z.string(),
+  finish_reason: z.string(),
+  cost_source: z.string(),
+
+  pricing_tier_id: z.string(),
+  pricing_tier_name: z.string(),
+
+  input_tokens: z.number(),
+  output_tokens: z.number(),
+  total_tokens: z.number(),
+  usage_details: z.record(z.string(), z.number()),
+
+  input_cost: z.number(),
+  output_cost: z.number(),
+  total_cost: z.number(),
+  cost_details: z.record(z.string(), z.number()),
+  provider_cost: z.number(),
+
+  ms_to_first_chunk: z.number(),
+  tokens_per_second: z.number(),
+
+  metadata: z.record(z.string(), z.string()),
+
+  prompt_slug: z.string(),
+  prompt_version: z.number(),
+
+  start_time: z.string(),
+  duration: z.string(),
+});
+
+export type LlmMetricsV1Input = z.input<typeof LlmMetricsV1Input>;
+
+export function insertLlmMetrics(ch: ClickhouseWriter) {
+  return ch.insertUnsafe<LlmMetricsV1Input>({
+    name: "insertLlmMetrics",
+    table: "trigger_dev.llm_metrics_v1",
+  });
+}
diff --git a/internal-packages/clickhouse/src/llmModelAggregates.ts b/internal-packages/clickhouse/src/llmModelAggregates.ts
new file mode 100644
index 00000000000..4e7bbba7bc9
--- /dev/null
+++ b/internal-packages/clickhouse/src/llmModelAggregates.ts
@@ -0,0 +1,138 @@
+import { z } from "zod";
+import { ClickhouseQueryBuilder } from "./client/queryBuilder.js";
+import type { ClickhouseReader } from "./client/types.js";
+
+// --- Schemas ---
+
+const ModelMetricsRow = z.object({
+  response_model: z.string(),
+  gen_ai_system: z.string(),
+  minute: z.string(),
+  call_count: z.coerce.number(),
+  total_input_tokens: z.coerce.number(),
+  total_output_tokens: z.coerce.number(),
+  total_cost: z.coerce.number(),
+  ttfc_p50: z.coerce.number(),
+  ttfc_p90: z.coerce.number(),
+  ttfc_p95: z.coerce.number(),
+  ttfc_p99: z.coerce.number(),
+  tps_p50: z.coerce.number(),
+  tps_p90: z.coerce.number(),
+  tps_p95: z.coerce.number(),
+  tps_p99: z.coerce.number(),
+  duration_p50: z.coerce.number(),
+  duration_p90: z.coerce.number(),
+  duration_p95: z.coerce.number(),
+  duration_p99: z.coerce.number(),
+});
+
+const ModelSummaryRow = z.object({
+  response_model: z.string(),
+  gen_ai_system: z.string(),
+  call_count: z.coerce.number(),
+  total_input_tokens: z.coerce.number(),
+  total_output_tokens: z.coerce.number(),
+  total_cost: z.coerce.number(),
+  ttfc_p50: z.coerce.number(),
+  ttfc_p90: z.coerce.number(),
+  tps_p50: z.coerce.number(),
+  tps_p90: z.coerce.number(),
+});
+
+const PopularModelRow = z.object({
+  response_model: z.string(),
+  gen_ai_system: z.string(),
+  call_count: z.coerce.number(),
+  total_cost: z.coerce.number(),
+  ttfc_p50: z.coerce.number(),
+});
+
+// --- Query builders ---
+
+/** Get per-minute metrics for a specific model over a date range. */
+export function getGlobalModelMetrics(reader: ClickhouseReader) {
+  return new ClickhouseQueryBuilder(
+    "getGlobalModelMetrics",
+    `SELECT
+      response_model,
+      gen_ai_system,
+      minute,
+      sum(call_count) AS call_count,
+      sum(total_input_tokens) AS total_input_tokens,
+      sum(total_output_tokens) AS total_output_tokens,
+      sum(total_cost) AS total_cost,
+      quantilesMerge(0.5, 0.9, 0.95, 0.99)(ttfc_quantiles) AS ttfc_arr,
+      ttfc_arr[1] AS ttfc_p50,
+      ttfc_arr[2] AS ttfc_p90,
+      ttfc_arr[3] AS ttfc_p95,
+      ttfc_arr[4] AS ttfc_p99,
+      quantilesMerge(0.5, 0.9, 0.95, 0.99)(tps_quantiles) AS tps_arr,
+      tps_arr[1] AS tps_p50,
+      tps_arr[2] AS tps_p90,
+      tps_arr[3] AS tps_p95,
+      tps_arr[4] AS tps_p99,
+      quantilesMerge(0.5, 0.9, 0.95, 0.99)(duration_quantiles) AS dur_arr,
+      dur_arr[1] AS duration_p50,
+      dur_arr[2] AS duration_p90,
+      dur_arr[3] AS duration_p95,
+      dur_arr[4] AS duration_p99
+    FROM trigger_dev.llm_model_aggregates_v1
+    WHERE response_model = {responseModel: String}
+      AND minute >= {startTime: DateTime}
+      AND minute <= {endTime: DateTime}
+    GROUP BY response_model, gen_ai_system, minute
+    ORDER BY minute`,
+    reader,
+    ModelMetricsRow
+  );
+}
+
+/** Get summary metrics for multiple models (for comparison). */
+export function getGlobalModelComparison(reader: ClickhouseReader) {
+  return new ClickhouseQueryBuilder(
+    "getGlobalModelComparison",
+    `SELECT
+      response_model,
+      gen_ai_system,
+      sum(call_count) AS call_count,
+      sum(total_input_tokens) AS total_input_tokens,
+      sum(total_output_tokens) AS total_output_tokens,
+      sum(total_cost) AS total_cost,
+      quantilesMerge(0.5, 0.9)(ttfc_quantiles) AS ttfc_arr,
+      ttfc_arr[1] AS ttfc_p50,
+      ttfc_arr[2] AS ttfc_p90,
+      quantilesMerge(0.5, 0.9)(tps_quantiles) AS tps_arr,
+      tps_arr[1] AS tps_p50,
+      tps_arr[2] AS tps_p90
+    FROM trigger_dev.llm_model_aggregates_v1
+    WHERE response_model IN {responseModels: Array(String)}
+      AND minute >= {startTime: DateTime}
+      AND minute <= {endTime: DateTime}
+    GROUP BY response_model, gen_ai_system
+    ORDER BY call_count DESC`,
+    reader,
+    ModelSummaryRow
+  );
+}
+
+/** Get the most popular models by call count. */
+export function getPopularModels(reader: ClickhouseReader) {
+  return new ClickhouseQueryBuilder(
+    "getPopularModels",
+    `SELECT
+      response_model,
+      gen_ai_system,
+      sum(call_count) AS call_count,
+      sum(total_cost) AS total_cost,
+      quantilesMerge(0.5)(ttfc_quantiles) AS ttfc_arr,
+      ttfc_arr[1] AS ttfc_p50
+    FROM trigger_dev.llm_model_aggregates_v1
+    WHERE minute >= {startTime: DateTime}
+      AND minute <= {endTime: DateTime}
+    GROUP BY response_model, gen_ai_system
+    ORDER BY call_count DESC
+    LIMIT {limit: UInt32}`,
+    reader,
+    PopularModelRow
+  );
+}
diff --git a/internal-packages/clickhouse/src/metrics.ts b/internal-packages/clickhouse/src/metrics.ts
new file mode 100644
index 00000000000..0367280f8d6
--- /dev/null
+++ b/internal-packages/clickhouse/src/metrics.ts
@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { ClickhouseWriter } from "./client/types.js";
+
+export const MetricsV1Input = z.object({
+  organization_id: z.string(),
+  project_id: z.string(),
+  environment_id: z.string(),
+  metric_name: z.string(),
+  metric_type: z.string(),
+  metric_subject: z.string(),
+  bucket_start: z.string(),
+  value: z.number(),
+  attributes: z.unknown(),
+});
+
+export type MetricsV1Input = z.input<typeof MetricsV1Input>;
+
+export function insertMetrics(ch: ClickhouseWriter) {
+  return ch.insertUnsafe<MetricsV1Input>({
+    name: "insertMetrics",
+    table: "trigger_dev.metrics_v1",
+    settings: {
+      enable_json_type: 1,
+      type_json_skip_duplicated_paths: 1,
+      input_format_json_throw_on_bad_escape_sequence: 0,
+      input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects: 1,
+    },
+  });
+}
diff --git a/internal-packages/clickhouse/src/taskEvents.ts b/internal-packages/clickhouse/src/taskEvents.ts
index d8c1b8b7f62..cfebd0a248b 100644
--- a/internal-packages/clickhouse/src/taskEvents.ts
+++ b/internal-packages/clickhouse/src/taskEvents.ts
@@ -19,6 +19,7 @@ export const TaskEventV1Input = z.object({
   attributes: z.unknown(),
   metadata: z.string(),
   expires_at: z.string(),
+  machine_id: z.string().optional(),
 });
 
 export type TaskEventV1Input = z.input<typeof TaskEventV1Input>;
@@ -153,6 +154,7 @@ export const TaskEventV2Input = z.object({
   attributes: z.unknown(),
   metadata: z.string(),
   expires_at: z.string(),
+  machine_id: z.string().optional(),
   // inserted_at has a default value in the table, so it's optional for inserts
   inserted_at: z.string().optional(),
 });
@@ -230,3 +232,98 @@ export function getSpanDetailsQueryBuilderV2(
     settings,
   });
 }
+
+
+// ============================================================================
+// Search Table Query Builders (for logs page, using task_events_search_v1)
+// ============================================================================
+
+export const LogsSearchListResult = z.object({
+  environment_id: z.string(),
+  organization_id: z.string(),
+  project_id: z.string(),
+  task_identifier: z.string(),
+  run_id: z.string(),
+  start_time: z.string(),
+  trace_id: z.string(),
+  span_id: z.string(),
+  parent_span_id: z.string(),
+  message: z.string(),
+  kind: z.string(),
+  status: z.string(),
+  duration: z.number().or(z.string()),
+  attributes_text: z.string(),
+  triggered_timestamp: z.string(),
+});
+
+export type LogsSearchListResult = z.output<typeof LogsSearchListResult>;
+
+export function getLogsSearchListQueryBuilder(ch: ClickhouseReader) {
+  return ch.queryBuilderFast<LogsSearchListResult>({
+    name: "getLogsSearchList",
+    table: "trigger_dev.task_events_search_v1",
+    columns: [
+      "environment_id",
+      "organization_id",
+      "project_id",
+      "task_identifier",
+      "run_id",
+      "start_time",
+      "trace_id",
+      "span_id",
+      "parent_span_id",
+      { name: "message", expression: "LEFT(message, 512)" },
+      "kind",
+      "status",
+      "duration",
+      "attributes_text",
+      "triggered_timestamp",
+    ],
+    settings: {
+      use_query_condition_cache: 1,
+    },
+  });
+}
+
+// Single log detail query builder (for side panel)
+export const LogDetailV2Result = z.object({
+  environment_id: z.string(),
+  organization_id: z.string(),
+  project_id: z.string(),
+  task_identifier: z.string(),
+  run_id: z.string(),
+  start_time: z.string(),
+  trace_id: z.string(),
+  span_id: z.string(),
+  parent_span_id: z.string(),
+  message: z.string(),
+  kind: z.string(),
+  status: z.string(),
+  duration: z.number().or(z.string()),
+  attributes_text: z.string()
+});
+
+export type LogDetailV2Result = z.output<typeof LogDetailV2Result>;
+
+export function getLogDetailQueryBuilderV2(ch: ClickhouseReader) {
+  return ch.queryBuilderFast<LogDetailV2Result>({
+    name: "getLogDetail",
+    table: "trigger_dev.task_events_v2",
+    columns: [
+      "environment_id",
+      "organization_id",
+      "project_id",
+      "task_identifier",
+      "run_id",
+      "start_time",
+      "trace_id",
+      "span_id",
+      "parent_span_id",
+      "message",
+      "kind",
+      "status",
+      "duration",
+      "attributes_text",
+    ],
+  });
+}
\ No newline at end of file
diff --git a/internal-packages/clickhouse/src/taskRuns.test.ts b/internal-packages/clickhouse/src/taskRuns.test.ts
index b51c9f38c01..8bd403f14f0 100644
--- a/internal-packages/clickhouse/src/taskRuns.test.ts
+++ b/internal-packages/clickhouse/src/taskRuns.test.ts
@@ -1,7 +1,13 @@
 import { clickhouseTest } from "@internal/testcontainers";
 import { z } from "zod";
 import { ClickhouseClient } from "./client/client.js";
-import { getTaskRunsQueryBuilder, insertRawTaskRunPayloads, insertTaskRuns } from "./taskRuns.js";
+import {
+  getTaskRunsQueryBuilder,
+  insertRawTaskRunPayloadsCompactArrays,
+  insertTaskRunsCompactArrays,
+  type TaskRunInsertArray,
+  type PayloadInsertArray,
+} from "./taskRuns.js";
 
 describe("Task Runs V2", () => {
   clickhouseTest("should be able to insert task runs", async ({ clickhouseContainer }) => {
@@ -11,61 +17,77 @@ describe("Task Runs V2", () => {
       logLevel: "debug",
     });
 
-    const insert = insertTaskRuns(client, {
+    const insert = insertTaskRunsCompactArrays(client, {
       async_insert: 0, // turn off async insert for this test
     });
 
-    const insertPayloads = insertRawTaskRunPayloads(client, {
+    const insertPayloads = insertRawTaskRunPayloadsCompactArrays(client, {
       async_insert: 0, // turn off async insert for this test
     });
 
-    const [insertError, insertResult] = await insert([
+    const now = Date.now();
+    const taskRunData: TaskRunInsertArray = [
+      "env_1234", // environment_id
+      "org_1234", // organization_id
+      "project_1234", // project_id
+      "run_1234", // run_id
+      now, // updated_at
+      now, // created_at
+      "PENDING", // status
+      "DEVELOPMENT", // environment_type
+      "friendly_1234", // friendly_id
+      1, // attempt
+      "V2", // engine
+      "my-task", // task_identifier
+      "my-queue", // queue
+      "schedule_1234", // schedule_id
+      "batch_1234", // batch_id
+      null, // completed_at
+      null, // started_at
+      null, // executed_at
+      null, // delay_until
+      null, // queued_at
+      null, // expired_at
+      1000, // usage_duration_ms
+      100, // cost_in_cents
+      0, // base_cost_in_cents
+      { data: { key: "value" } }, // output
       {
-        environment_id: "env_1234",
-        environment_type: "DEVELOPMENT",
-        organization_id: "org_1234",
-        project_id: "project_1234",
-        run_id: "run_1234",
-        friendly_id: "friendly_1234",
-        attempt: 1,
-        engine: "V2",
-        status: "PENDING",
-        task_identifier: "my-task",
-        queue: "my-queue",
-        schedule_id: "schedule_1234",
-        batch_id: "batch_1234",
-        created_at: Date.now(),
-        updated_at: Date.now(),
-        completed_at: undefined,
-        tags: ["tag1", "tag2"],
-        output: {
-          key: "value",
-        },
-        error: {
+        data: {
           type: "BUILT_IN_ERROR",
           name: "Error",
           message: "error",
           stackTrace: "stack trace",
         },
-        usage_duration_ms: 1000,
-        cost_in_cents: 100,
-        task_version: "1.0.0",
-        sdk_version: "1.0.0",
-        cli_version: "1.0.0",
-        machine_preset: "small-1x",
-        is_test: true,
-        span_id: "span_1234",
-        trace_id: "trace_1234",
-        idempotency_key: "idempotency_key_1234",
-        expiration_ttl: "1h",
-        root_run_id: "root_run_1234",
-        parent_run_id: "parent_run_1234",
-        depth: 1,
-        concurrency_key: "concurrency_key_1234",
-        bulk_action_group_ids: ["bulk_action_group_id_1234", "bulk_action_group_id_1235"],
-        _version: "1",
-      },
-    ]);
+      }, // error
+      "1234567890", // error_fingerprint
+      ["tag1", "tag2"], // tags
+      "1.0.0", // task_version
+      "1.0.0", // sdk_version
+      "1.0.0", // cli_version
+      "small-1x", // machine_preset
+      "root_run_1234", // root_run_id
+      "parent_run_1234", // parent_run_id
+      1, // depth
+      "span_1234", // span_id
+      "trace_1234", // trace_id
+      "idempotency_key_1234", // idempotency_key
+      "my-user-key", // idempotency_key_user
+      "run", // idempotency_key_scope
+      "1h", // expiration_ttl
+      true, // is_test
+      "1", // _version
+      0, // _is_deleted
+      "concurrency_key_1234", // concurrency_key
+      ["bulk_action_group_id_1234", "bulk_action_group_id_1235"], // bulk_action_group_ids
+      "", // worker_queue
+      null, // max_duration_in_seconds
+      "", // trigger_source
+      "", // root_trigger_source
+      null, // is_warm_start
+    ];
+
+    const [insertError, insertResult] = await insert([taskRunData]);
 
     expect(insertError).toBeNull();
     expect(insertResult).toEqual(expect.objectContaining({ executed: true }));
@@ -99,15 +121,13 @@ describe("Task Runs V2", () => {
       ])
     );
 
-    const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([
-      {
-        run_id: "run_1234",
-        created_at: Date.now(),
-        payload: {
-          key: "value",
-        },
-      },
-    ]);
+    const payloadData: PayloadInsertArray = [
+      "run_1234", // run_id
+      Date.now(), // created_at
+      { data: { key: "value" } }, // payload
+    ];
+
+    const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([payloadData]);
 
     expect(insertPayloadsError).toBeNull();
     expect(insertPayloadsResult).toEqual(expect.objectContaining({ executed: true }));
@@ -137,96 +157,122 @@ describe("Task Runs V2", () => {
       url: clickhouseContainer.getConnectionUrl(),
     });
 
-    const insert = insertTaskRuns(client, {
+    const insert = insertTaskRunsCompactArrays(client, {
       async_insert: 0, // turn off async insert for this test
     });
 
-    const [insertError, insertResult] = await insert([
-      {
-        environment_id: "cm9kddfcs01zqdy88ld9mmrli",
-        organization_id: "cm8zs78wb0002dy616dg75tv3",
-        project_id: "cm9kddfbz01zpdy88t9dstecu",
-        run_id: "cma45oli70002qrdy47w0j4n7",
-        environment_type: "PRODUCTION",
-        friendly_id: "run_cma45oli70002qrdy47w0j4n7",
-        attempt: 1,
-        engine: "V2",
-        status: "PENDING",
-        task_identifier: "retry-task",
-        queue: "task/retry-task",
-        schedule_id: "",
-        batch_id: "",
-        root_run_id: "",
-        parent_run_id: "",
-        depth: 0,
-        span_id: "538677637f937f54",
-        trace_id: "20a28486b0b9f50c647b35e8863e36a5",
-        idempotency_key: "",
-        created_at: new Date("2025-04-30 16:34:04.312").getTime(),
-        updated_at: new Date("2025-04-30 16:34:04.312").getTime(),
-        started_at: null,
-        executed_at: null,
-        completed_at: null,
-        delay_until: null,
-        queued_at: new Date("2025-04-30 16:34:04.311").getTime(),
-        expired_at: null,
-        expiration_ttl: "",
-        usage_duration_ms: 0,
-        cost_in_cents: 0,
-        base_cost_in_cents: 0,
-        output: null,
-        error: null,
-        tags: [],
-        task_version: "",
-        sdk_version: "",
-        cli_version: "",
-        machine_preset: "",
-        is_test: true,
-        _version: "1",
-      },
-      {
-        environment_id: "cm9kddfcs01zqdy88ld9mmrli",
-        organization_id: "cm8zs78wb0002dy616dg75tv3",
-        project_id: "cm9kddfbz01zpdy88t9dstecu",
-        run_id: "cma45oli70002qrdy47w0j4n7",
-        environment_type: "PRODUCTION",
-        friendly_id: "run_cma45oli70002qrdy47w0j4n7",
-        attempt: 1,
-        engine: "V2",
-        status: "COMPLETED_SUCCESSFULLY",
-        task_identifier: "retry-task",
-        queue: "task/retry-task",
-        schedule_id: "",
-        batch_id: "",
-        root_run_id: "",
-        parent_run_id: "",
-        depth: 0,
-        span_id: "538677637f937f54",
-        trace_id: "20a28486b0b9f50c647b35e8863e36a5",
-        idempotency_key: "",
-        created_at: new Date("2025-04-30 16:34:04.312").getTime(),
-        updated_at: new Date("2025-04-30 16:34:04.312").getTime(),
-        started_at: null,
-        executed_at: null,
-        completed_at: null,
-        delay_until: null,
-        queued_at: new Date("2025-04-30 16:34:04.311").getTime(),
-        expired_at: null,
-        expiration_ttl: "",
-        usage_duration_ms: 0,
-        cost_in_cents: 0,
-        base_cost_in_cents: 0,
-        output: null,
-        error: null,
-        tags: [],
-        task_version: "",
-        sdk_version: "",
-        cli_version: "",
-        machine_preset: "",
-        is_test: true,
-        _version: "2",
-      },
-    ]);
+    const createdAt = new Date("2025-04-30 16:34:04.312").getTime();
+    const queuedAt = new Date("2025-04-30 16:34:04.311").getTime();
+
+    const run1: TaskRunInsertArray = [
+      "cm9kddfcs01zqdy88ld9mmrli", // environment_id
+      "cm8zs78wb0002dy616dg75tv3", // organization_id
+      "cm9kddfbz01zpdy88t9dstecu", // project_id
+      "cma45oli70002qrdy47w0j4n7", // run_id
+      createdAt, // updated_at
+      createdAt, // created_at
+      "PENDING", // status
+      "PRODUCTION", // environment_type
+      "run_cma45oli70002qrdy47w0j4n7", // friendly_id
+      1, // attempt
+      "V2", // engine
+      "retry-task", // task_identifier
+      "task/retry-task", // queue
+      "", // schedule_id
+      "", // batch_id
+      null, // completed_at
+      null, // started_at
+      null, // executed_at
+      null, // delay_until
+      queuedAt, // queued_at
+      null, // expired_at
+      0, // usage_duration_ms
+      0, // cost_in_cents
+      0, // base_cost_in_cents
+      { data: null }, // output
+      { data: null }, // error
+      "", // error_fingerprint
+      [], // tags
+      "", // task_version
+      "", // sdk_version
+      "", // cli_version
+      "", // machine_preset
+      "", // root_run_id
+      "", // parent_run_id
+      0, // depth
+      "538677637f937f54", // span_id
+      "20a28486b0b9f50c647b35e8863e36a5", // trace_id
+      "", // idempotency_key
+      "", // idempotency_key_user
+      "", // idempotency_key_scope
+      "", // expiration_ttl
+      true, // is_test
+      "1", // _version
+      0, // _is_deleted
+      "", // concurrency_key
+      [], // bulk_action_group_ids
+      "", // worker_queue
+      null, // max_duration_in_seconds
+      "", // trigger_source
+      "", // root_trigger_source
+      null, // is_warm_start
+    ];
+
+    const run2: TaskRunInsertArray = [
+      "cm9kddfcs01zqdy88ld9mmrli", // environment_id
+      "cm8zs78wb0002dy616dg75tv3", // organization_id
+      "cm9kddfbz01zpdy88t9dstecu", // project_id
+      "cma45oli70002qrdy47w0j4n7", // run_id
+      createdAt, // updated_at
+      createdAt, // created_at
+      "COMPLETED_SUCCESSFULLY", // status
+      "PRODUCTION", // environment_type
+      "run_cma45oli70002qrdy47w0j4n7", // friendly_id
+      1, // attempt
+      "V2", // engine
+      "retry-task", // task_identifier
+      "task/retry-task", // queue
+      "", // schedule_id
+      "", // batch_id
+      null, // completed_at
+      null, // started_at
+      null, // executed_at
+      null, // delay_until
+      queuedAt, // queued_at
+      null, // expired_at
+      0, // usage_duration_ms
+      0, // cost_in_cents
+      0, // base_cost_in_cents
+      { data: null }, // output
+      { data: null }, // error
+      "", // error_fingerprint
+      [], // tags
+      "", // task_version
+      "", // sdk_version
+      "", // cli_version
+      "", // machine_preset
+      "", // root_run_id
+      "", // parent_run_id
+      0, // depth
+      "538677637f937f54", // span_id
+      "20a28486b0b9f50c647b35e8863e36a5", // trace_id
+      "", // idempotency_key
+      "", // idempotency_key_user
+      "", // idempotency_key_scope
+      "", // expiration_ttl
+      true, // is_test
+      "2", // _version
+      0, // _is_deleted
+      "", // concurrency_key
+      [], // bulk_action_group_ids
+      "", // worker_queue
+      null, // max_duration_in_seconds
+      "", // trigger_source
+      "", // root_trigger_source
+      null, // is_warm_start
+    ];
+
+    const [insertError, insertResult] = await insert([run1, run2]);
 
     expect(insertError).toBeNull();
     expect(insertResult).toEqual(expect.objectContaining({ executed: true }));
@@ -266,54 +312,68 @@ describe("Task Runs V2", () => {
         url: clickhouseContainer.getConnectionUrl(),
       });
 
-      const insert = insertTaskRuns(client, {
+      const insert = insertTaskRunsCompactArrays(client, {
         async_insert: 0, // turn off async insert for this test
       });
 
-      const [insertError, insertResult] = await insert([
-        {
-          environment_id: "cm9kddfcs01zqdy88ld9mmrli",
-          organization_id: "cm8zs78wb0002dy616dg75tv3",
-          project_id: "cm9kddfbz01zpdy88t9dstecu",
-          run_id: "cma45oli70002qrdy47w0j4n7",
-          environment_type: "PRODUCTION",
-          friendly_id: "run_cma45oli70002qrdy47w0j4n7",
-          attempt: 1,
-          engine: "V2",
-          status: "PENDING",
-          task_identifier: "retry-task",
-          queue: "task/retry-task",
-          schedule_id: "",
-          batch_id: "",
-          root_run_id: "",
-          parent_run_id: "",
-          depth: 0,
-          span_id: "538677637f937f54",
-          trace_id: "20a28486b0b9f50c647b35e8863e36a5",
-          idempotency_key: "",
-          created_at: new Date("2025-04-30 16:34:04.312").getTime(),
-          updated_at: new Date("2025-04-30 16:34:04.312").getTime(),
-          started_at: null,
-          executed_at: null,
-          completed_at: null,
-          delay_until: null,
-          queued_at: new Date("2025-04-30 16:34:04.311").getTime(),
-          expired_at: null,
-          expiration_ttl: "",
-          usage_duration_ms: 0,
-          cost_in_cents: 0,
-          base_cost_in_cents: 0,
-          output: null,
-          error: null,
-          tags: [],
-          task_version: "",
-          sdk_version: "",
-          cli_version: "",
-          machine_preset: "",
-          is_test: true,
-          _version: "1",
-        },
-      ]);
+      const createdAt = new Date("2025-04-30 16:34:04.312").getTime();
+      const queuedAt = new Date("2025-04-30 16:34:04.311").getTime();
+
+      const taskRun: TaskRunInsertArray = [
+        "cm9kddfcs01zqdy88ld9mmrli", // environment_id
+        "cm8zs78wb0002dy616dg75tv3", // organization_id
+        "cm9kddfbz01zpdy88t9dstecu", // project_id
+        "cma45oli70002qrdy47w0j4n7", // run_id
+        createdAt, // updated_at
+        createdAt, // created_at
+        "PENDING", // status
+        "PRODUCTION", // environment_type
+        "run_cma45oli70002qrdy47w0j4n7", // friendly_id
+        1, // attempt
+        "V2", // engine
+        "retry-task", // task_identifier
+        "task/retry-task", // queue
+        "", // schedule_id
+        "", // batch_id
+        null, // completed_at
+        null, // started_at
+        null, // executed_at
+        null, // delay_until
+        queuedAt, // queued_at
+        null, // expired_at
+        0, // usage_duration_ms
+        0, // cost_in_cents
+        0, // base_cost_in_cents
+        { data: null }, // output
+        { data: null }, // error
+        "", // error_fingerprint
+        [], // tags
+        "", // task_version
+        "", // sdk_version
+        "", // cli_version
+        "", // machine_preset
+        "", // root_run_id
+        "", // parent_run_id
+        0, // depth
+        "538677637f937f54", // span_id
+        "20a28486b0b9f50c647b35e8863e36a5", // trace_id
+        "", // idempotency_key
+        "", // idempotency_key_user
+        "", // idempotency_key_scope
+        "", // expiration_ttl
+        true, // is_test
+        "1", // _version
+        0, // _is_deleted
+        "", // concurrency_key
+        [], // bulk_action_group_ids
+        "", // worker_queue
+        null, // max_duration_in_seconds
+        "", // trigger_source
+        "", // root_trigger_source
+        null, // is_warm_start
+      ];
+
+      const [insertError, insertResult] = await insert([taskRun]);
 
       const queryBuilder = getTaskRunsQueryBuilder(client)();
       queryBuilder.where("environment_id = {environmentId: String}", {
@@ -360,15 +420,15 @@ describe("Task Runs V2", () => {
         url: clickhouseContainer.getConnectionUrl(),
       });
 
-      const insertPayloads = insertRawTaskRunPayloads(client, {
+      const insertPayloads = insertRawTaskRunPayloadsCompactArrays(client, {
         async_insert: 0, // turn off async insert for this test
       });
 
-      const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([
+      const payloadData: PayloadInsertArray = [
+        "run_1234", // run_id
+        Date.now(), // created_at
         {
-          run_id: "run_1234",
-          created_at: Date.now(),
-          payload: {
+          data: {
             data: {
               title: {
                 id: "123",
@@ -376,8 +436,10 @@ describe("Task Runs V2", () => {
               "title.id": 123,
             },
           },
-        },
-      ]);
+        }, // payload
+      ];
+
+      const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([payloadData]);
 
       expect(insertPayloadsError).toBeNull();
       expect(insertPayloadsResult).toEqual(expect.objectContaining({ executed: true }));
diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts
index b2410ee4b66..6a9f66d7844 100644
--- a/internal-packages/clickhouse/src/taskRuns.ts
+++ b/internal-packages/clickhouse/src/taskRuns.ts
@@ -29,6 +29,7 @@ export const TaskRunV2 = z.object({
   base_cost_in_cents: z.number().default(0),
   output: z.unknown(),
   error: z.unknown(),
+  error_fingerprint: z.string().default(""),
   tags: z.array(z.string()).default([]),
   task_version: z.string(),
   sdk_version: z.string(),
@@ -40,17 +41,173 @@ export const TaskRunV2 = z.object({
   span_id: z.string(),
   trace_id: z.string(),
   idempotency_key: z.string(),
+  idempotency_key_user: z.string().default(""),
+  idempotency_key_scope: z.string().default(""),
   expiration_ttl: z.string(),
   is_test: z.boolean().default(false),
   concurrency_key: z.string().default(""),
   bulk_action_group_ids: z.array(z.string()).default([]),
   worker_queue: z.string().default(""),
+  max_duration_in_seconds: z.number().int().nullish(),
+  trigger_source: z.string().default(""),
+  root_trigger_source: z.string().default(""),
+  is_warm_start: z.boolean().nullish(),
   _version: z.string(),
   _is_deleted: z.number().int().default(0),
 });
 
 export type TaskRunV2 = z.input<typeof TaskRunV2>;
 
+// Column order for compact format - must match ClickHouse table schema
+export const TASK_RUN_COLUMNS = [
+  "environment_id",
+  "organization_id",
+  "project_id",
+  "run_id",
+  "updated_at",
+  "created_at",
+  "status",
+  "environment_type",
+  "friendly_id",
+  "attempt",
+  "engine",
+  "task_identifier",
+  "queue",
+  "schedule_id",
+  "batch_id",
+  "completed_at",
+  "started_at",
+  "executed_at",
+  "delay_until",
+  "queued_at",
+  "expired_at",
+  "usage_duration_ms",
+  "cost_in_cents",
+  "base_cost_in_cents",
+  "output",
+  "error",
+  "error_fingerprint",
+  "tags",
+  "task_version",
+  "sdk_version",
+  "cli_version",
+  "machine_preset",
+  "root_run_id",
+  "parent_run_id",
+  "depth",
+  "span_id",
+  "trace_id",
+  "idempotency_key",
+  "idempotency_key_user",
+  "idempotency_key_scope",
+  "expiration_ttl",
+  "is_test",
+  "_version",
+  "_is_deleted",
+  "concurrency_key",
+  "bulk_action_group_ids",
+  "worker_queue",
+  "max_duration_in_seconds",
+  "trigger_source",
+  "root_trigger_source",
+  "is_warm_start",
+] as const;
+
+export type TaskRunColumnName = (typeof TASK_RUN_COLUMNS)[number];
+
+// Type-safe column indices generated from TASK_RUN_COLUMNS
+// This ensures indices stay in sync with column order automatically
+export const TASK_RUN_INDEX = Object.fromEntries(
+  TASK_RUN_COLUMNS.map((col, idx) => [col, idx])
+) as { readonly [K in TaskRunColumnName]: number };
+
+/**
+ * Type mapping from column name to its type in TaskRunInsertArray.
+ * This enables type-safe field access without manual casting.
+ */
+export type TaskRunFieldTypes = {
+  environment_id: string;
+  organization_id: string;
+  project_id: string;
+  run_id: string;
+  updated_at: number;
+  created_at: number;
+  status: string;
+  environment_type: string;
+  friendly_id: string;
+  attempt: number;
+  engine: string;
+  task_identifier: string;
+  queue: string;
+  schedule_id: string;
+  batch_id: string;
+  completed_at: number | null;
+  started_at: number | null;
+  executed_at: number | null;
+  delay_until: number | null;
+  queued_at: number | null;
+  expired_at: number | null;
+  usage_duration_ms: number;
+  cost_in_cents: number;
+  base_cost_in_cents: number;
+  output: { data: unknown };
+  error: { data: unknown };
+  error_fingerprint: string;
+  tags: string[];
+  task_version: string;
+  sdk_version: string;
+  cli_version: string;
+  machine_preset: string;
+  root_run_id: string;
+  parent_run_id: string;
+  depth: number;
+  span_id: string;
+  trace_id: string;
+  idempotency_key: string;
+  idempotency_key_user: string;
+  idempotency_key_scope: string;
+  expiration_ttl: string;
+  is_test: boolean;
+  _version: string;
+  _is_deleted: number;
+  concurrency_key: string;
+  bulk_action_group_ids: string[];
+  worker_queue: string;
+  max_duration_in_seconds: number | null;
+  trigger_source: string;
+  root_trigger_source: string;
+  is_warm_start: boolean | null;
+};
+
+/**
+ * Type-safe accessor for TaskRunInsertArray fields.
+ * Returns the correct type for each field without manual casting.
+ *
+ * @example
+ * const orgId = getTaskRunField(run, "organization_id"); // type: string
+ * const createdAt = getTaskRunField(run, "created_at"); // type: number
+ */
+export function getTaskRunField<K extends TaskRunColumnName>(
+  run: TaskRunInsertArray,
+  field: K
+): TaskRunFieldTypes[K] {
+  return run[TASK_RUN_INDEX[field]] as TaskRunFieldTypes[K];
+}
+
+export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: ClickHouseSettings) {
+  return ch.insertCompactRaw({
+    name: "insertTaskRunsCompactArrays",
+    table: "trigger_dev.task_runs_v2",
+    columns: TASK_RUN_COLUMNS,
+    settings: {
+      enable_json_type: 1,
+      type_json_skip_duplicated_paths: 1,
+      ...settings,
+    },
+  });
+}
+
+// Object-based insert function for tests and non-performance-critical code
 export function insertTaskRuns(ch: ClickhouseWriter, settings?: ClickHouseSettings) {
   return ch.insert({
     name: "insertTaskRuns",
@@ -72,6 +229,120 @@ export const RawTaskRunPayloadV1 = z.object({
 
 export type RawTaskRunPayloadV1 = z.infer<typeof RawTaskRunPayloadV1>;
 
+export const PAYLOAD_COLUMNS = ["run_id", "created_at", "payload"] as const;
+
+export type PayloadColumnName = (typeof PAYLOAD_COLUMNS)[number];
+
+// Type-safe column indices generated from PAYLOAD_COLUMNS
+export const PAYLOAD_INDEX = Object.fromEntries(PAYLOAD_COLUMNS.map((col, idx) => [col, idx])) as {
+  readonly [K in PayloadColumnName]: number;
+};
+
+/**
+ * Type mapping from column name to its type in PayloadInsertArray.
+ */
+export type PayloadFieldTypes = {
+  run_id: string;
+  created_at: number;
+  payload: { data: unknown };
+};
+
+/**
+ * Type-safe accessor for PayloadInsertArray fields.
+ * Returns the correct type for each field without manual casting.
+ */
+export function getPayloadField<K extends PayloadColumnName>(
+  payload: PayloadInsertArray,
+  field: K
+): PayloadFieldTypes[K] {
+  return payload[PAYLOAD_INDEX[field]] as PayloadFieldTypes[K];
+}
+
+/**
+ * Type-safe tuple representing a task run insert array.
+ * Order matches TASK_RUN_COLUMNS exactly.
+ */
+export type TaskRunInsertArray = [
+  environment_id: string,
+  organization_id: string,
+  project_id: string,
+  run_id: string,
+  updated_at: number,
+  created_at: number,
+  status: string,
+  environment_type: string,
+  friendly_id: string,
+  attempt: number,
+  engine: string,
+  task_identifier: string,
+  queue: string,
+  schedule_id: string,
+  batch_id: string,
+  completed_at: number | null,
+  started_at: number | null,
+  executed_at: number | null,
+  delay_until: number | null,
+  queued_at: number | null,
+  expired_at: number | null,
+  usage_duration_ms: number,
+  cost_in_cents: number,
+  base_cost_in_cents: number,
+  output: { data: unknown },
+  error: { data: unknown },
+  error_fingerprint: string,
+  tags: string[],
+  task_version: string,
+  sdk_version: string,
+  cli_version: string,
+  machine_preset: string,
+  root_run_id: string,
+  parent_run_id: string,
+  depth: number,
+  span_id: string,
+  trace_id: string,
+  idempotency_key: string,
+  idempotency_key_user: string,
+  idempotency_key_scope: string,
+  expiration_ttl: string,
+  is_test: boolean,
+  _version: string,
+  _is_deleted: number,
+  concurrency_key: string,
+  bulk_action_group_ids: string[],
+  worker_queue: string,
+  max_duration_in_seconds: number | null,
+  trigger_source: string,
+  root_trigger_source: string,
+  is_warm_start: boolean | null,
+];
+
+/**
+ * Type-safe tuple representing a payload insert array.
+ * Order matches PAYLOAD_COLUMNS exactly.
+ */
+export type PayloadInsertArray = [run_id: string, created_at: number, payload: { data: unknown }];
+
+export function insertRawTaskRunPayloadsCompactArrays(
+  ch: ClickhouseWriter,
+  settings?: ClickHouseSettings
+) {
+  return ch.insertCompactRaw({
+    name: "insertRawTaskRunPayloadsCompactArrays",
+    table: "trigger_dev.raw_task_runs_payload_v1",
+    columns: PAYLOAD_COLUMNS,
+    settings: {
+      async_insert: 1,
+      wait_for_async_insert: 0,
+      async_insert_max_data_size: "1000000",
+      async_insert_busy_timeout_ms: 1000,
+      enable_json_type: 1,
+      type_json_skip_duplicated_paths: 1,
+      ...settings,
+    },
+  });
+}
+
+// Object-based insert function for tests and non-performance-critical code
 export function insertRawTaskRunPayloads(ch: ClickhouseWriter, settings?: ClickHouseSettings) {
   return ch.insert({
     name: "insertRawTaskRunPayloads",
diff --git a/internal-packages/clickhouse/src/tsql.test.ts b/internal-packages/clickhouse/src/tsql.test.ts
new file mode 100644
index 00000000000..5c1d6ed8022
--- /dev/null
+++ b/internal-packages/clickhouse/src/tsql.test.ts
@@ -0,0 +1,1614 @@
+import { clickhouseTest } from "@internal/testcontainers";
+import { z } from "zod";
+import { ClickhouseClient } from "./client/client.js";
+import { executeTSQL, createTSQLExecutor, type TableSchema } from "./client/tsql.js";
+import { insertTaskRuns } from "./taskRuns.js";
+import { column } from "@internal/tsql";
+
+/**
+ * Schema definition for task_runs table used in TSQL tests
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    run_id: { name: "run_id", ...column("String") },
+    friendly_id: { name: "friendly_id", ...column("String") },
+    status: { name: "status", ...column("String") },
+    task_identifier: { name: "task_identifier", ...column("String") },
+    queue: { name: "queue", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+    environment_type: { name: "environment_type", ...column("String") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime") },
+    updated_at: { name: "updated_at", ...column("DateTime") },
+    is_test: { name: "is_test", ...column("Bool") },
+    tags: { name: "tags", ...column("Array(String)") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+const defaultTaskRun = {
+  environment_id: "env_tenant1",
+  environment_type: "DEVELOPMENT",
+  organization_id: "org_tenant1",
+  project_id: "proj_tenant1",
+  run_id: `run_${Math.random().toString(36).slice(2)}`,
+  friendly_id: `friendly_${Math.random().toString(36).slice(2)}`,
+  attempt: 1,
+  engine: "V2",
+  status: "PENDING",
+  task_identifier: "my-task",
+  queue: "my-queue",
+  schedule_id: "",
+  batch_id: "",
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  started_at: null as number | null,
+  completed_at: null as number | null,
+  tags: [] as string[],
+  output: null,
+  error: null,
+  usage_duration_ms: 0,
+  cost_in_cents: 0,
+  base_cost_in_cents: 0,
+  task_version: "",
+  sdk_version: "",
+  cli_version: "",
+  machine_preset: "",
+  is_test: false,
+  span_id: "",
+  trace_id: "",
+  idempotency_key: "",
+  expiration_ttl: "",
+  root_run_id: "",
+  parent_run_id: "",
+  depth: 0,
+  concurrency_key: "",
+  bulk_action_group_ids: [] as string[],
+  _version: "1",
+};
+
+/**
+ * Helper to create test task run data
+ */
+function createTaskRun(overrides: Partial<typeof defaultTaskRun> = {}) {
+  return {
+    ...defaultTaskRun,
+    ...overrides,
+  };
+}
+
+describe("TSQL Integration Tests", () => {
+  clickhouseTest("should execute a simple SELECT query", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    // Insert test data
+    const [insertError] = await insert([
+      createTaskRun({ run_id: "run_test1", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_test2", status: "PENDING" }),
+      createTaskRun({ run_id: "run_test3", status: "COMPLETED_SUCCESSFULLY" }),
+    ]);
+    expect(insertError).toBeNull();
+
+    // Execute TSQL query
+    const [error, result] = await executeTSQL(client, {
+      name: "test-simple-select",
+      query: "SELECT run_id, status FROM task_runs",
+      schema: z.object({ run_id: z.string(), status: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(3);
+    expect(result?.rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ run_id: "run_test1", status: "COMPLETED_SUCCESSFULLY" }),
+        expect.objectContaining({ run_id: "run_test2", status: "PENDING" }),
+        expect.objectContaining({ run_id: "run_test3", status: "COMPLETED_SUCCESSFULLY" }),
+      ])
+    );
+    // Verify stats are returned
+    expect(result?.stats).toBeDefined();
+    expect(result?.stats.read_rows).toBeDefined();
+    expect(result?.stats.elapsed_ns).toBeDefined();
+  });
+
+  clickhouseTest("should filter with WHERE clause", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_filter1", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_filter2", status: "PENDING" }),
+      createTaskRun({ run_id: "run_filter3", status: "COMPLETED_SUCCESSFULLY" }),
+    ]);
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-where-clause",
+      query: "SELECT run_id, status FROM task_runs WHERE status = 'COMPLETED_SUCCESSFULLY'",
+      schema: z.object({ run_id: z.string(), status: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(2);
+    expect(result?.rows?.every((r) => r.status === "COMPLETED_SUCCESSFULLY")).toBe(true);
+  });
+
+  clickhouseTest("should enforce tenant isolation", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    // Insert data for two different tenants
+    await insert([
+      createTaskRun({
+        run_id: "run_tenant1_a",
+        organization_id: "org_tenant1",
+        project_id: "proj_tenant1",
+        environment_id: "env_tenant1",
+      }),
+      createTaskRun({
+        run_id: "run_tenant1_b",
+        organization_id: "org_tenant1",
+        project_id: "proj_tenant1",
+        environment_id: "env_tenant1",
+      }),
+      createTaskRun({
+        run_id: "run_tenant2_a",
+        organization_id: "org_tenant2",
+        project_id: "proj_tenant2",
+        environment_id: "env_tenant2",
+      }),
+      createTaskRun({
+        run_id: "run_tenant2_b",
+        organization_id: "org_tenant2",
+        project_id: "proj_tenant2",
+        environment_id: "env_tenant2",
+      }),
+    ]);
+
+    // Query as tenant1 - should only see tenant1's data
+    const [error1, result1] = await executeTSQL(client, {
+      name: "test-tenant-isolation-1",
+      query: "SELECT run_id FROM task_runs",
+      schema: z.object({ run_id: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error1).toBeNull();
+    expect(result1?.rows).toHaveLength(2);
+    expect(result1?.rows?.map((r) => r.run_id).sort()).toEqual(["run_tenant1_a", "run_tenant1_b"]);
+
+    // Query as tenant2 - should only see tenant2's data
+    const [error2, result2] = await executeTSQL(client, {
+      name: "test-tenant-isolation-2",
+      query: "SELECT run_id FROM task_runs",
+      schema: z.object({ run_id: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant2" },
+        project_id: { op: "eq", value: "proj_tenant2" },
+        environment_id: { op: "eq", value: "env_tenant2" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error2).toBeNull();
+    expect(result2?.rows).toHaveLength(2);
+    expect(result2?.rows?.map((r) => r.run_id).sort()).toEqual(["run_tenant2_a", "run_tenant2_b"]);
+  });
+
+  clickhouseTest(
+    "should not allow cross-tenant access even with malicious WHERE",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_secret",
+          organization_id: "org_victim",
+          project_id: "proj_victim",
+          environment_id: "env_victim",
+          status: "SECRET_DATA",
+        }),
+        createTaskRun({
+          run_id: "run_attacker",
+          organization_id: "org_attacker",
+          project_id: "proj_attacker",
+          environment_id: "env_attacker",
+        }),
+      ]);
+
+      // Attacker tries to access victim's data with OR 1=1
+      const [error, result] = await executeTSQL(client, {
+        name: "test-cross-tenant-attack",
+        query: "SELECT run_id, status FROM task_runs WHERE status = 'COMPLETED' OR 1=1",
+        schema: z.object({ run_id: z.string(), status: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_attacker" },
+          project_id: { op: "eq", value: "proj_attacker" },
+          environment_id: { op: "eq", value: "env_attacker" },
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error).toBeNull();
+      // Should only get attacker's own data, not victim's
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_attacker");
+      expect(result?.rows?.find((r) => r.run_id === "run_secret")).toBeUndefined();
+    }
+  );
+
+  clickhouseTest("should handle aggregations", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_agg1", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_agg2", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_agg3", status: "PENDING" }),
+      createTaskRun({ run_id: "run_agg4", status: "FAILED" }),
+    ]);
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-aggregation",
+      query:
+        "SELECT status, count(*) as cnt FROM task_runs GROUP BY status ORDER BY cnt DESC, status ASC",
+      schema: z.object({ status: z.string(), cnt: z.coerce.number() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(3);
+    expect(result?.rows?.[0]).toEqual({ status: "COMPLETED_SUCCESSFULLY", cnt: 2 });
+    // The remaining rows have cnt=1, check they're both present
+    expect(result?.rows).toEqual(
+      expect.arrayContaining([
+        { status: "PENDING", cnt: 1 },
+        { status: "FAILED", cnt: 1 },
+      ])
+    );
+  });
+
+  clickhouseTest("should handle ORDER BY and LIMIT", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    const now = Date.now();
+    await insert([
+      createTaskRun({ run_id: "run_order1", created_at: now - 3000 }),
+      createTaskRun({ run_id: "run_order2", created_at: now - 1000 }),
+      createTaskRun({ run_id: "run_order3", created_at: now - 2000 }),
+    ]);
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-order-limit",
+      query: "SELECT run_id FROM task_runs ORDER BY created_at DESC LIMIT 2",
+      schema: z.object({ run_id: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(2);
+    expect(result?.rows?.[0].run_id).toBe("run_order2"); // Most recent
+    expect(result?.rows?.[1].run_id).toBe("run_order3"); // Second most recent
+  });
+
+  clickhouseTest("should reject unknown tables", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-unknown-table",
+      query: "SELECT * FROM unknown_table",
+      schema: z.object({ id: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).not.toBeNull();
+    expect(error?.message).toContain("unknown_table");
+    expect(result).toBeNull();
+  });
+
+  clickhouseTest("should work with createTSQLExecutor", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_executor1", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_executor2", status: "PENDING" }),
+    ]);
+
+    // Create a reusable executor
+    const tsql = createTSQLExecutor(client, [taskRunsSchema]);
+
+    const [error, result] = await tsql.execute({
+      name: "test-executor",
+      query: "SELECT run_id, status FROM task_runs WHERE status = 'PENDING'",
+      schema: z.object({ run_id: z.string(), status: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows?.[0]).toEqual({ run_id: "run_executor2", status: "PENDING" });
+  });
+
+  clickhouseTest("should handle string injection attempts", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_inject1", status: "NORMAL" }),
+      createTaskRun({ run_id: "run_inject2", status: "DROP TABLE task_runs" }),
+    ]);
+
+    // Query with a "malicious" value that looks like SQL
+    const [error, result] = await executeTSQL(client, {
+      name: "test-injection",
+      query: "SELECT run_id, status FROM task_runs WHERE status = 'DROP TABLE task_runs'",
+      schema: z.object({ run_id: z.string(), status: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    // Should find the row with the literal string value, not execute SQL
+    expect(result?.rows).toHaveLength(1);
+    expect(result?.rows?.[0].status).toBe("DROP TABLE task_runs");
+  });
+
+  clickhouseTest("should handle IN queries", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_in1", status: "COMPLETED_SUCCESSFULLY" }),
+      createTaskRun({ run_id: "run_in2", status: "PENDING" }),
+      createTaskRun({ run_id: "run_in3", status: "FAILED" }),
+      createTaskRun({ run_id: "run_in4", status: "CANCELLED" }),
+    ]);
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-in-query",
+      query:
+        "SELECT run_id, status FROM task_runs WHERE status IN ('COMPLETED_SUCCESSFULLY', 'FAILED')",
+      schema: z.object({ run_id: z.string(), status: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(2);
+    expect(result?.rows?.map((r) => r.status).sort()).toEqual(["COMPLETED_SUCCESSFULLY", "FAILED"]);
+  });
+
+  clickhouseTest("should handle LIKE queries", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    await insert([
+      createTaskRun({ run_id: "run_like1", task_identifier: "email/send" }),
+      createTaskRun({ run_id: "run_like2", task_identifier: "email/receive" }),
+      createTaskRun({ run_id: "run_like3", task_identifier: "sms/send" }),
+    ]);
+
+    const [error, result] = await executeTSQL(client, {
+      name: "test-like-query",
+      query: "SELECT run_id, task_identifier FROM task_runs WHERE task_identifier LIKE 'email%'",
+      schema: z.object({ run_id: z.string(), task_identifier: z.string() }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [taskRunsSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(2);
+    expect(result?.rows?.every((r) => r.task_identifier.startsWith("email"))).toBe(true);
+  });
+});
+
+describe("TSQL Optional Tenant Filter Tests", () => {
+  clickhouseTest(
+    "should query across all projects when projectId is omitted",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert data across multiple projects in the same org
+      await insert([
+        createTaskRun({
+          run_id: "run_proj1_a",
+          organization_id: "org_multi",
+          project_id: "proj_1",
+          environment_id: "env_dev",
+        }),
+        createTaskRun({
+          run_id: "run_proj1_b",
+          organization_id: "org_multi",
+          project_id: "proj_1",
+          environment_id: "env_dev",
+        }),
+        createTaskRun({
+          run_id: "run_proj2_a",
+          organization_id: "org_multi",
+          project_id: "proj_2",
+          environment_id: "env_dev",
+        }),
+        createTaskRun({
+          run_id: "run_proj3_a",
+          organization_id: "org_multi",
+          project_id: "proj_3",
+          environment_id: "env_prod",
+        }),
+        // Different org - should not be returned
+        createTaskRun({
+          run_id: "run_other_org",
+          organization_id: "org_other",
+          project_id: "proj_other",
+          environment_id: "env_other",
+        }),
+      ]);
+
+      // Query across all projects (omit projectId and environmentId)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-cross-project-query",
+        query: "SELECT run_id FROM task_runs",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_multi" },
+          // project_id and environment_id omitted - query across all
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(4); // All runs from org_multi
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual([
+        "run_proj1_a",
+        "run_proj1_b",
+        "run_proj2_a",
+        "run_proj3_a",
+      ]);
+    }
+  );
+
+  clickhouseTest(
+    "should query across all environments in a project when environmentId is omitted",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert data across multiple environments in the same project
+      await insert([
+        createTaskRun({
+          run_id: "run_dev_1",
+          organization_id: "org_envtest",
+          project_id: "proj_envtest",
+          environment_id: "env_development",
+        }),
+        createTaskRun({
+          run_id: "run_staging_1",
+          organization_id: "org_envtest",
+          project_id: "proj_envtest",
+          environment_id: "env_staging",
+        }),
+        createTaskRun({
+          run_id: "run_prod_1",
+          organization_id: "org_envtest",
+          project_id: "proj_envtest",
+          environment_id: "env_production",
+        }),
+        // Different project - should not be returned
+        createTaskRun({
+          run_id: "run_other_proj",
+          organization_id: "org_envtest",
+          project_id: "proj_other",
+          environment_id: "env_development",
+        }),
+      ]);
+
+      // Query across all environments (omit environmentId only)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-cross-env-query",
+        query: "SELECT run_id FROM task_runs",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_envtest" },
+          project_id: { op: "eq", value: "proj_envtest" },
+          // environment_id omitted - query across all environments
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(3); // All runs from proj_envtest across all envs
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual([
+        "run_dev_1",
+        "run_prod_1",
+        "run_staging_1",
+      ]);
+    }
+  );
+
+  clickhouseTest(
+    "should still enforce org isolation when querying across projects",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert data for multiple orgs
+      await insert([
+        createTaskRun({
+          run_id: "run_org1_a",
+          organization_id: "org_isolation_1",
+          project_id: "proj_a",
+          environment_id: "env_a",
+        }),
+        createTaskRun({
+          run_id: "run_org1_b",
+          organization_id: "org_isolation_1",
+          project_id: "proj_b",
+          environment_id: "env_b",
+        }),
+        createTaskRun({
+          run_id: "run_org2_a",
+          organization_id: "org_isolation_2",
+          project_id: "proj_c",
+          environment_id: "env_c",
+        }),
+        createTaskRun({
+          run_id: "run_org2_b",
+          organization_id: "org_isolation_2",
+          project_id: "proj_d",
+          environment_id: "env_d",
+        }),
+      ]);
+
+      // Query org1 across all projects - should NOT see org2's data
+      const [error1, result1] = await executeTSQL(client, {
+        name: "test-org-isolation-1",
+        query: "SELECT run_id FROM task_runs",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_isolation_1" },
+          // project_id and environment_id omitted
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error1).toBeNull();
+      expect(result1?.rows).toHaveLength(2);
+      expect(result1?.rows?.map((r) => r.run_id).sort()).toEqual(["run_org1_a", "run_org1_b"]);
+
+      // Query org2 across all projects - should NOT see org1's data
+      const [error2, result2] = await executeTSQL(client, {
+        name: "test-org-isolation-2",
+        query: "SELECT run_id FROM task_runs",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_isolation_2" },
+          // project_id and environment_id omitted
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error2).toBeNull();
+      expect(result2?.rows).toHaveLength(2);
+      expect(result2?.rows?.map((r) => r.run_id).sort()).toEqual(["run_org2_a", "run_org2_b"]);
+    }
+  );
+
+  clickhouseTest(
+    "should prevent OR clause bypass with org-only filter",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_victim",
+          organization_id: "org_victim",
+          project_id: "proj_victim",
+          environment_id: "env_victim",
+          status: "SECRET",
+        }),
+        createTaskRun({
+          run_id: "run_attacker",
+          organization_id: "org_attacker",
+          project_id: "proj_attacker",
+          environment_id: "env_attacker",
+          status: "PUBLIC",
+        }),
+      ]);
+
+      // Attacker tries to use OR 1=1 to bypass org filter
+      const [error, result] = await executeTSQL(client, {
+        name: "test-or-bypass-attempt",
+        query: "SELECT run_id, status FROM task_runs WHERE status = 'COMPLETED' OR 1=1",
+        schema: z.object({ run_id: z.string(), status: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_attacker" },
+          // No project/env filter - but org filter should still protect
+        },
+        tableSchema: [taskRunsSchema],
+      });
+
+      expect(error).toBeNull();
+      // Should only get attacker's data, not victim's
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_attacker");
+      expect(result?.rows?.find((r) => r.run_id === "run_victim")).toBeUndefined();
+    }
+  );
+
+  clickhouseTest(
+    "should work with createTSQLExecutor and optional filters",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_exec_1",
+          organization_id: "org_executor_test",
+          project_id: "proj_1",
+          environment_id: "env_1",
+        }),
+        createTaskRun({
+          run_id: "run_exec_2",
+          organization_id: "org_executor_test",
+          project_id: "proj_2",
+          environment_id: "env_2",
+        }),
+      ]);
+
+      const tsql = createTSQLExecutor(client, [taskRunsSchema]);
+
+      // Use executor with org-only filter
+      const [error, result] = await tsql.execute({
+        name: "test-executor-optional",
+        query: "SELECT run_id FROM task_runs",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_executor_test" },
+          // project_id and environment_id omitted
+        },
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(2);
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual(["run_exec_1", "run_exec_2"]);
+    }
+  );
+});
+
+describe("TSQL Virtual Column Tests", () => {
+  /**
+   * Schema with virtual (computed) columns
+   */
+  const virtualColumnSchema: TableSchema = {
+    name: "task_runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      friendly_id: { name: "friendly_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      task_identifier: { name: "task_identifier", ...column("String") },
+      queue: { name: "queue", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+      environment_type: { name: "environment_type", ...column("String") },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      created_at: { name: "created_at", ...column("DateTime") },
+      updated_at: { name: "updated_at", ...column("DateTime") },
+      started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+      completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+      usage_duration_ms: { name: "usage_duration_ms", ...column("UInt32") },
+      is_test: { name: "is_test", ...column("Bool") },
+      tags: { name: "tags", ...column("Array(String)") },
+      // Virtual column: execution_duration computes milliseconds between started_at and completed_at
+      execution_duration: {
+        name: "execution_duration",
+        ...column("Nullable(Int64)"),
+        expression: "dateDiff('millisecond', started_at, completed_at)",
+        description: "Time between started_at and completed_at in milliseconds",
+      },
+      // Virtual column: usage_duration_seconds converts ms to seconds
+      usage_duration_seconds: {
+        name: "usage_duration_seconds",
+        ...column("Float64"),
+        expression: "usage_duration_ms / 1000.0",
+        description: "Usage duration in seconds",
+      },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  clickhouseTest(
+    "should select virtual column and compute correct value",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      const now = Date.now();
+      const startedAt = now - 5000; // 5 seconds ago
+      const completedAt = now;
+
+      await insert([
+        createTaskRun({
+          run_id: "run_virtual_1",
+          started_at: startedAt,
+          completed_at: completedAt,
+          usage_duration_ms: 3500,
+        }),
+      ]);
+
+      const [error, result] = await executeTSQL(client, {
+        name: "test-virtual-column-select",
+        query: "SELECT run_id, execution_duration, usage_duration_seconds FROM task_runs",
+        schema: z.object({
+          run_id: z.string(),
+          execution_duration: z.number().nullable(),
+          usage_duration_seconds: z.number(),
+        }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [virtualColumnSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      // execution_duration should be approximately 5000ms (difference between started_at and completed_at)
+      expect(result?.rows?.[0].execution_duration).toBeCloseTo(5000, -2); // within 100ms tolerance
+      // usage_duration_seconds should be 3.5 (3500ms / 1000)
+      expect(result?.rows?.[0].usage_duration_seconds).toBeCloseTo(3.5, 1);
+    }
+  );
+
+  clickhouseTest(
+    "should filter by virtual column in WHERE clause",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      const now = Date.now();
+
+      await insert([
+        createTaskRun({
+          run_id: "run_short",
+          started_at: now - 1000, // 1 second duration
+          completed_at: now,
+        }),
+        createTaskRun({
+          run_id: "run_long",
+          started_at: now - 10000, // 10 second duration
+          completed_at: now,
+        }),
+        createTaskRun({
+          run_id: "run_very_long",
+          started_at: now - 60000, // 60 second duration
+          completed_at: now,
+        }),
+      ]);
+
+      // Query runs with execution_duration > 5000ms (5 seconds)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-virtual-column-where",
+        query: "SELECT run_id FROM task_runs WHERE execution_duration > 5000",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [virtualColumnSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(2);
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual(["run_long", "run_very_long"]);
+    }
+  );
+
+  clickhouseTest("should order by virtual column", async ({ clickhouseContainer }) => {
+    const client = new ClickhouseClient({
+      name: "test",
+      url: clickhouseContainer.getConnectionUrl(),
+    });
+
+    const insert = insertTaskRuns(client, { async_insert: 0 });
+
+    const now = Date.now();
+
+    await insert([
+      createTaskRun({
+        run_id: "run_order_a",
+        usage_duration_ms: 1000,
+      }),
+      createTaskRun({
+        run_id: "run_order_b",
+        usage_duration_ms: 3000,
+      }),
+      createTaskRun({
+        run_id: "run_order_c",
+        usage_duration_ms: 2000,
+      }),
+    ]);
+
+    // Order by usage_duration_seconds descending (virtual column)
+    const [error, result] = await executeTSQL(client, {
+      name: "test-virtual-column-order",
+      query:
+        "SELECT run_id, usage_duration_seconds FROM task_runs ORDER BY usage_duration_seconds DESC",
+      schema: z.object({
+        run_id: z.string(),
+        usage_duration_seconds: z.number(),
+      }),
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_tenant1" },
+        project_id: { op: "eq", value: "proj_tenant1" },
+        environment_id: { op: "eq", value: "env_tenant1" },
+      },
+      tableSchema: [virtualColumnSchema],
+    });
+
+    expect(error).toBeNull();
+    expect(result?.rows).toHaveLength(3);
+    // Should be ordered by usage_duration_seconds DESC: b (3), c (2), a (1)
+    expect(result?.rows?.[0].run_id).toBe("run_order_b");
+    expect(result?.rows?.[0].usage_duration_seconds).toBeCloseTo(3.0, 1);
+    expect(result?.rows?.[1].run_id).toBe("run_order_c");
+    expect(result?.rows?.[1].usage_duration_seconds).toBeCloseTo(2.0, 1);
+    expect(result?.rows?.[2].run_id).toBe("run_order_a");
+    expect(result?.rows?.[2].usage_duration_seconds).toBeCloseTo(1.0, 1);
+  });
+
+  clickhouseTest(
+    "should use virtual column with explicit alias",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_alias_test",
+          usage_duration_ms: 5000,
+        }),
+      ]);
+
+      // Use virtual column with custom alias
+      const [error, result] = await executeTSQL(client, {
+        name: "test-virtual-column-alias",
+        query: "SELECT run_id, usage_duration_seconds AS dur_sec FROM task_runs",
+        schema: z.object({
+          run_id: z.string(),
+          dur_sec: z.number(),
+        }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [virtualColumnSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].dur_sec).toBeCloseTo(5.0, 1);
+    }
+  );
+
+  clickhouseTest(
+    "should handle null values in virtual column expression",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_null_times",
+          // started_at and completed_at will be null
+        }),
+      ]);
+
+      const [error, result] = await executeTSQL(client, {
+        name: "test-virtual-column-null",
+        query: "SELECT run_id, execution_duration FROM task_runs",
+        schema: z.object({
+          run_id: z.string(),
+          execution_duration: z.number().nullable(),
+        }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [virtualColumnSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      // execution_duration should be null when started_at or completed_at is null
+      expect(result?.rows?.[0].execution_duration).toBeNull();
+    }
+  );
+
+  /**
+   * Schema with cost-based virtual columns that use division expressions
+   * This mimics the real runsSchema where invocation_cost = base_cost_in_cents / 100.0
+   */
+  const costExpressionSchema: TableSchema = {
+    name: "task_runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      friendly_id: { name: "friendly_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      task_identifier: { name: "task_identifier", ...column("String") },
+      queue: { name: "queue", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+      environment_type: { name: "environment_type", ...column("String") },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      created_at: { name: "created_at", ...column("DateTime") },
+      updated_at: { name: "updated_at", ...column("DateTime") },
+      is_test: { name: "is_test", ...column("Bool") },
+      tags: { name: "tags", ...column("Array(String)") },
+      // Raw cost columns stored in ClickHouse
+      cost_in_cents: { name: "cost_in_cents", ...column("Float64") },
+      base_cost_in_cents: { name: "base_cost_in_cents", ...column("Float64") },
+      // Virtual column: compute_cost = cost_in_cents / 100.0
+      compute_cost: {
+        name: "compute_cost",
+        ...column("Float64"),
+        expression: "cost_in_cents / 100.0",
+        description: "Compute cost in dollars (cost_in_cents / 100)",
+      },
+      // Virtual column: invocation_cost = base_cost_in_cents / 100.0
+      invocation_cost: {
+        name: "invocation_cost",
+        ...column("Float64"),
+        expression: "base_cost_in_cents / 100.0",
+        description: "Invocation cost in dollars (base_cost_in_cents / 100)",
+      },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  clickhouseTest(
+    "should filter by expression column with division in WHERE clause",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert runs with different cost values
+      // invocation_cost = base_cost_in_cents / 100.0
+      // So base_cost_in_cents of 500 = invocation_cost of 5.0
+      // And base_cost_in_cents of 50 = invocation_cost of 0.5
+      await insert([
+        createTaskRun({
+          run_id: "run_cheap",
+          base_cost_in_cents: 50, // invocation_cost = 0.5
+          cost_in_cents: 100,
+        }),
+        createTaskRun({
+          run_id: "run_medium",
+          base_cost_in_cents: 200, // invocation_cost = 2.0
+          cost_in_cents: 300,
+        }),
+        createTaskRun({
+          run_id: "run_expensive",
+          base_cost_in_cents: 500, // invocation_cost = 5.0
+          cost_in_cents: 800,
+        }),
+      ]);
+
+      // Query runs where invocation_cost > 1.0 (base_cost_in_cents > 100)
+      // Should return run_medium (2.0) and run_expensive (5.0)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-division-where",
+        query: "SELECT run_id, invocation_cost FROM task_runs WHERE invocation_cost > 1.0",
+        schema: z.object({ run_id: z.string(), invocation_cost: z.number() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(2);
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual(["run_expensive", "run_medium"]);
+    }
+  );
+
+  clickhouseTest(
+    "should filter by expression column with greater-than-or-equals comparison",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_1",
+          base_cost_in_cents: 100, // invocation_cost = 1.0
+        }),
+        createTaskRun({
+          run_id: "run_2",
+          base_cost_in_cents: 200, // invocation_cost = 2.0
+        }),
+        createTaskRun({
+          run_id: "run_3",
+          base_cost_in_cents: 50, // invocation_cost = 0.5
+        }),
+      ]);
+
+      // Query runs where invocation_cost >= 1.0
+      // Should return run_1 (1.0) and run_2 (2.0)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-gte-where",
+        query: "SELECT run_id, invocation_cost FROM task_runs WHERE invocation_cost >= 1.0",
+        schema: z.object({ run_id: z.string(), invocation_cost: z.number() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(2);
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual(["run_1", "run_2"]);
+    }
+  );
+
+  clickhouseTest(
+    "should filter by expression column with less-than comparison",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_small",
+          base_cost_in_cents: 50, // invocation_cost = 0.5
+        }),
+        createTaskRun({
+          run_id: "run_large",
+          base_cost_in_cents: 300, // invocation_cost = 3.0
+        }),
+      ]);
+
+      // Query runs where invocation_cost < 1.0
+      // Should return only run_small (0.5)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-lt-where",
+        query: "SELECT run_id, invocation_cost FROM task_runs WHERE invocation_cost < 1.0",
+        schema: z.object({ run_id: z.string(), invocation_cost: z.number() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_small");
+    }
+  );
+
+  clickhouseTest(
+    "should filter by expression column with BETWEEN comparison",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_low",
+          base_cost_in_cents: 50, // invocation_cost = 0.5
+        }),
+        createTaskRun({
+          run_id: "run_mid",
+          base_cost_in_cents: 150, // invocation_cost = 1.5
+        }),
+        createTaskRun({
+          run_id: "run_high",
+          base_cost_in_cents: 500, // invocation_cost = 5.0
+        }),
+      ]);
+
+      // Query runs where invocation_cost is between 1.0 and 2.0
+      // Should return only run_mid (1.5)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-between-where",
+        query:
+          "SELECT run_id, invocation_cost FROM task_runs WHERE invocation_cost BETWEEN 1.0 AND 2.0",
+        schema: z.object({ run_id: z.string(), invocation_cost: z.number() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_mid");
+    }
+  );
+
+  clickhouseTest(
+    "should use expression column in complex WHERE with AND/OR",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      await insert([
+        createTaskRun({
+          run_id: "run_a",
+          status: "COMPLETED_SUCCESSFULLY",
+          base_cost_in_cents: 100, // invocation_cost = 1.0
+        }),
+        createTaskRun({
+          run_id: "run_b",
+          status: "FAILED",
+          base_cost_in_cents: 300, // invocation_cost = 3.0
+        }),
+        createTaskRun({
+          run_id: "run_c",
+          status: "COMPLETED_SUCCESSFULLY",
+          base_cost_in_cents: 300, // invocation_cost = 3.0
+        }),
+      ]);
+
+      // Query completed runs with invocation_cost > 2.0
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-complex-where",
+        query:
+          "SELECT run_id FROM task_runs WHERE status = 'COMPLETED_SUCCESSFULLY' AND invocation_cost > 2.0",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_c");
+    }
+  );
+
+  clickhouseTest(
+    "should filter by expression column comparing with large integer value",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert runs with large base_cost_in_cents values
+      // So invocation_cost = base_cost_in_cents / 100.0
+      // To get invocation_cost > 100, we need base_cost_in_cents > 10000
+      await insert([
+        createTaskRun({
+          run_id: "run_small_cost",
+          base_cost_in_cents: 500, // invocation_cost = 5.0
+        }),
+        createTaskRun({
+          run_id: "run_medium_cost",
+          base_cost_in_cents: 5000, // invocation_cost = 50.0
+        }),
+        createTaskRun({
+          run_id: "run_large_cost",
+          base_cost_in_cents: 15000, // invocation_cost = 150.0
+        }),
+      ]);
+
+      // Query runs where invocation_cost > 100
+      // Should only return run_large_cost (150.0)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-expression-large-integer-where",
+        query: "SELECT run_id, invocation_cost FROM task_runs WHERE invocation_cost > 100",
+        schema: z.object({ run_id: z.string(), invocation_cost: z.number() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [costExpressionSchema],
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_large_cost");
+      expect(result?.rows?.[0].invocation_cost).toBeCloseTo(150.0, 1);
+    }
+  );
+});
+
+describe("Field Mapping Tests", () => {
+  /**
+   * Schema with a field mapping column (project_ref → project_id)
+   */
+  const fieldMappingSchema: TableSchema = {
+    name: "task_runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      project_ref: {
+        name: "project_ref",
+        clickhouseName: "project_id",
+        ...column("String"),
+        fieldMapping: "project",
+      },
+      environment_id: { name: "environment_id", ...column("String") },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  clickhouseTest(
+    "should transform field mapping values in SELECT results",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert test runs with known project_id values
+      await insert([
+        createTaskRun({
+          run_id: "run_fm1",
+          project_id: "proj_tenant1",
+          status: "COMPLETED_SUCCESSFULLY",
+        }),
+      ]);
+
+      // Execute TSQL query with field mappings
+      const [error, result] = await executeTSQL(client, {
+        name: "test-field-mapping-select",
+        query: "SELECT run_id, project_ref FROM task_runs",
+        schema: z.object({ run_id: z.string(), project_ref: z.string().nullable() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [fieldMappingSchema],
+        fieldMappings: {
+          project: {
+            proj_tenant1: "my-project-ref",
+          },
+        },
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].project_ref).toBe("my-project-ref");
+    }
+  );
+
+  clickhouseTest(
+    "should return null for unmapped values in field mapping",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert test run with a project_id that's NOT in the mapping
+      await insert([
+        createTaskRun({
+          run_id: "run_fm_unmapped",
+          project_id: "proj_tenant1", // This ID exists but won't be in our mapping
+          status: "PENDING",
+        }),
+      ]);
+
+      // Execute with an empty mapping (no project_id mapped)
+      const [error, result] = await executeTSQL(client, {
+        name: "test-field-mapping-unmapped",
+        query: "SELECT run_id, project_ref FROM task_runs WHERE run_id = 'run_fm_unmapped'",
+        schema: z.object({ run_id: z.string(), project_ref: z.string().nullable() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [fieldMappingSchema],
+        fieldMappings: {
+          project: {
+            some_other_id: "other-ref",
+          },
+        },
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].project_ref).toBeNull();
+    }
+  );
+
+  clickhouseTest(
+    "should transform field mapping values in WHERE clause",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert test runs
+      await insert([
+        createTaskRun({
+          run_id: "run_fm_where1",
+          project_id: "proj_tenant1",
+          status: "COMPLETED_SUCCESSFULLY",
+        }),
+        createTaskRun({
+          run_id: "run_fm_where2",
+          project_id: "proj_other",
+          organization_id: "org_tenant1",
+          status: "PENDING",
+        }),
+      ]);
+
+      // Query using external project_ref value in WHERE clause
+      const [error, result] = await executeTSQL(client, {
+        name: "test-field-mapping-where",
+        query: "SELECT run_id FROM task_runs WHERE project_ref = 'my-project-ref'",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          environment_id: { op: "eq", value: "env_tenant1" },
+        },
+        tableSchema: [fieldMappingSchema],
+        fieldMappings: {
+          project: {
+            proj_tenant1: "my-project-ref",
+            proj_other: "other-project",
+          },
+        },
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(1);
+      expect(result?.rows?.[0].run_id).toBe("run_fm_where1");
+    }
+  );
+
+  clickhouseTest(
+    "should handle field mapping with IN clause",
+    async ({ clickhouseContainer }) => {
+      const client = new ClickhouseClient({
+        name: "test",
+        url: clickhouseContainer.getConnectionUrl(),
+      });
+
+      const insert = insertTaskRuns(client, { async_insert: 0 });
+
+      // Insert test runs with different projects
+      await insert([
+        createTaskRun({
+          run_id: "run_fm_in1",
+          project_id: "proj_tenant1",
+          status: "COMPLETED_SUCCESSFULLY",
+        }),
+        createTaskRun({
+          run_id: "run_fm_in2",
+          project_id: "proj_other",
+          organization_id: "org_tenant1",
+          status: "PENDING",
+        }),
+      ]);
+
+      // Query using IN clause with external project_ref values
+      const [error, result] = await executeTSQL(client, {
+        name: "test-field-mapping-in",
+        query:
+          "SELECT run_id FROM task_runs WHERE project_ref IN ('my-project-ref', 'other-project')",
+        schema: z.object({ run_id: z.string() }),
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+        },
+        tableSchema: [fieldMappingSchema],
+        fieldMappings: {
+          project: {
+            proj_tenant1: "my-project-ref",
+            proj_other: "other-project",
+          },
+        },
+      });
+
+      expect(error).toBeNull();
+      expect(result?.rows).toHaveLength(2);
+      expect(result?.rows?.map((r) => r.run_id).sort()).toEqual(["run_fm_in1", "run_fm_in2"]);
+    }
+  );
+});
diff --git a/internal-packages/clickhouse/src/tsqlFunctions.test.ts b/internal-packages/clickhouse/src/tsqlFunctions.test.ts
new file mode 100644
index 00000000000..6959338256a
--- /dev/null
+++ b/internal-packages/clickhouse/src/tsqlFunctions.test.ts
@@ -0,0 +1,830 @@
+import { clickhouseTest } from "@internal/testcontainers";
+import { z } from "zod";
+import { ClickhouseClient } from "./client/client.js";
+import { executeTSQL, type TableSchema } from "./client/tsql.js";
+import { insertTaskRuns } from "./taskRuns.js";
+import { column } from "@internal/tsql";
+
+/**
+ * Schema definition for task_runs table used in function tests.
+ * Includes numeric, string, datetime, and array columns for exercising all function categories.
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    run_id: { name: "run_id", ...column("String") },
+    friendly_id: { name: "friendly_id", ...column("String") },
+    status: { name: "status", ...column("String") },
+    task_identifier: { name: "task_identifier", ...column("String") },
+    queue: { name: "queue", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+    environment_type: { name: "environment_type", ...column("String") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime64") },
+    updated_at: { name: "updated_at", ...column("DateTime64") },
+    started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+    completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+    is_test: { name: "is_test", ...column("UInt8") },
+    tags: { name: "tags", ...column("Array(String)") },
+    usage_duration_ms: { name: "usage_duration_ms", ...column("UInt32") },
+    cost_in_cents: { name: "cost_in_cents", ...column("Float64") },
+    attempt: { name: "attempt", ...column("UInt8") },
+    depth: { name: "depth", ...column("UInt8") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+const enforcedWhereClause = {
+  organization_id: { op: "eq" as const, value: "org_tenant1" },
+  project_id: { op: "eq" as const, value: "proj_tenant1" },
+  environment_id: { op: "eq" as const, value: "env_tenant1" },
+};
+
+const defaultTaskRun = {
+  environment_id: "env_tenant1",
+  environment_type: "DEVELOPMENT",
+  organization_id: "org_tenant1",
+  project_id: "proj_tenant1",
+  run_id: "run_func_test_1",
+  friendly_id: "friendly_func_test_1",
+  attempt: 1,
+  engine: "V2",
+  status: "COMPLETED_SUCCESSFULLY",
+  task_identifier: "my-task",
+  queue: "my-queue",
+  schedule_id: "",
+  batch_id: "",
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  started_at: Date.now() - 5000,
+  completed_at: Date.now(),
+  tags: ["tag-a", "tag-b"],
+  output: null,
+  error: null,
+  usage_duration_ms: 4500,
+  cost_in_cents: 1.5,
+  base_cost_in_cents: 0.5,
+  task_version: "1.0.0",
+  sdk_version: "4.0.0",
+  cli_version: "4.0.0",
+  machine_preset: "small-1x",
+  is_test: false,
+  span_id: "span_123",
+  trace_id: "trace_123",
+  idempotency_key: "idem_123",
+  expiration_ttl: "",
+  root_run_id: "",
+  parent_run_id: "",
+  depth: 2,
+  concurrency_key: "",
+  bulk_action_group_ids: [] as string[],
+  _version: "1",
+};
+
+/**
+ * Helper: execute a TSQL query and assert no errors.
+ */
+async function assertQueryExecutes(client: ClickhouseClient, tsqlQuery: string): Promise<void> {
+  const [error] = await executeTSQL(client, {
+    name: "func-test",
+    query: tsqlQuery,
+    schema: z.record(z.any()),
+    enforcedWhereClause,
+    tableSchema: [taskRunsSchema],
+  });
+
+  if (error) {
+    throw new Error(`Query failed: ${tsqlQuery}\n\nError: ${error.message}`);
+  }
+}
+
+/**
+ * Helper: set up a client with test data inserted.
+ */
+async function setupClient(clickhouseContainer: { getConnectionUrl(): string }) {
+  const client = new ClickhouseClient({
+    name: "func-test",
+    url: clickhouseContainer.getConnectionUrl(),
+  });
+
+  const insert = insertTaskRuns(client, { async_insert: 0 });
+  const [insertError] = await insert([defaultTaskRun]);
+  expect(insertError).toBeNull();
+
+  return client;
+}
+
+/**
+ * Helper: run all test cases in a single ClickHouse container.
+ * Each case is a [name, tsqlQuery] tuple.
+ */
+async function runCases(client: ClickhouseClient, cases: [string, string][]): Promise<void> {
+  const failures: string[] = [];
+
+  for (const [name, query] of cases) {
+    try {
+      await assertQueryExecutes(client, query);
+    } catch (e) {
+      failures.push(`  ${name}: ${(e as Error).message}`);
+    }
+  }
+
+  if (failures.length > 0) {
+    throw new Error(
+      `${failures.length}/${cases.length} function(s) failed:\n${failures.join("\n")}`
+    );
+  }
+}
+
+const url = "https://user:pass@www.example.com:8080/path/page?q=1&r=2#frag";
+
+describe("TSQL Function Smoke Tests", () => {
+  // ─── Arithmetic functions ─────────────────────────────────────────────────
+
+  clickhouseTest("Arithmetic functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["plus", "SELECT plus(usage_duration_ms, 1) AS r FROM task_runs"],
+      ["minus", "SELECT minus(usage_duration_ms, 1) AS r FROM task_runs"],
+      ["multiply", "SELECT multiply(usage_duration_ms, 2) AS r FROM task_runs"],
+      ["divide", "SELECT divide(usage_duration_ms, 2) AS r FROM task_runs"],
+      ["intDiv", "SELECT intDiv(usage_duration_ms, 2) AS r FROM task_runs"],
+      ["intDivOrZero", "SELECT intDivOrZero(usage_duration_ms, 0) AS r FROM task_runs"],
+      ["modulo", "SELECT modulo(usage_duration_ms, 3) AS r FROM task_runs"],
+      ["moduloOrZero", "SELECT moduloOrZero(usage_duration_ms, 0) AS r FROM task_runs"],
+      ["positiveModulo", "SELECT positiveModulo(usage_duration_ms, 3) AS r FROM task_runs"],
+      ["negate", "SELECT negate(cost_in_cents) AS r FROM task_runs"],
+      ["abs", "SELECT abs(cost_in_cents) AS r FROM task_runs"],
+      ["gcd", "SELECT gcd(12, 8) AS r FROM task_runs"],
+      ["lcm", "SELECT lcm(12, 8) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Mathematical functions ───────────────────────────────────────────────
+
+  clickhouseTest("Mathematical functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["exp", "SELECT exp(1) AS r FROM task_runs"],
+      ["log", "SELECT log(2.718) AS r FROM task_runs"],
+      ["ln", "SELECT ln(2.718) AS r FROM task_runs"],
+      ["exp2", "SELECT exp2(3) AS r FROM task_runs"],
+      ["log2", "SELECT log2(8) AS r FROM task_runs"],
+      ["exp10", "SELECT exp10(2) AS r FROM task_runs"],
+      ["log10", "SELECT log10(100) AS r FROM task_runs"],
+      ["sqrt", "SELECT sqrt(16) AS r FROM task_runs"],
+      ["cbrt", "SELECT cbrt(27) AS r FROM task_runs"],
+      ["erf", "SELECT erf(1) AS r FROM task_runs"],
+      ["erfc", "SELECT erfc(1) AS r FROM task_runs"],
+      ["lgamma", "SELECT lgamma(5) AS r FROM task_runs"],
+      ["tgamma", "SELECT tgamma(5) AS r FROM task_runs"],
+      ["sin", "SELECT sin(1) AS r FROM task_runs"],
+      ["cos", "SELECT cos(1) AS r FROM task_runs"],
+      ["tan", "SELECT tan(1) AS r FROM task_runs"],
+      ["asin", "SELECT asin(0.5) AS r FROM task_runs"],
+      ["acos", "SELECT acos(0.5) AS r FROM task_runs"],
+      ["atan", "SELECT atan(1) AS r FROM task_runs"],
+      ["pow", "SELECT pow(2, 3) AS r FROM task_runs"],
+      ["power", "SELECT power(2, 3) AS r FROM task_runs"],
+      ["round", "SELECT round(3.14159, 2) AS r FROM task_runs"],
+      ["floor", "SELECT floor(3.7) AS r FROM task_runs"],
+      ["ceil", "SELECT ceil(3.2) AS r FROM task_runs"],
+      ["ceiling", "SELECT ceiling(3.2) AS r FROM task_runs"],
+      ["trunc", "SELECT trunc(3.7) AS r FROM task_runs"],
+      ["truncate", "SELECT truncate(3.7) AS r FROM task_runs"],
+      ["sign", "SELECT sign(-5) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── String functions ─────────────────────────────────────────────────────
+
+  clickhouseTest("String functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["empty", "SELECT empty(status) AS r FROM task_runs"],
+      ["notEmpty", "SELECT notEmpty(status) AS r FROM task_runs"],
+      ["length", "SELECT length(status) AS r FROM task_runs"],
+      ["lengthUTF8", "SELECT lengthUTF8(status) AS r FROM task_runs"],
+      ["char_length", "SELECT char_length(status) AS r FROM task_runs"],
+      ["character_length", "SELECT character_length(status) AS r FROM task_runs"],
+      ["lower", "SELECT lower(status) AS r FROM task_runs"],
+      ["upper", "SELECT upper(status) AS r FROM task_runs"],
+      ["lowerUTF8", "SELECT lowerUTF8(status) AS r FROM task_runs"],
+      ["upperUTF8", "SELECT upperUTF8(status) AS r FROM task_runs"],
+      ["reverse", "SELECT reverse(status) AS r FROM task_runs"],
+      ["reverseUTF8", "SELECT reverseUTF8(status) AS r FROM task_runs"],
+      ["concat", "SELECT concat(status, '-', run_id) AS r FROM task_runs"],
+      ["substring", "SELECT substring(status, 1, 3) AS r FROM task_runs"],
+      ["substr", "SELECT substr(status, 1, 3) AS r FROM task_runs"],
+      ["mid", "SELECT mid(status, 1, 3) AS r FROM task_runs"],
+      ["substringUTF8", "SELECT substringUTF8(status, 1, 3) AS r FROM task_runs"],
+      [
+        "appendTrailingCharIfAbsent",
+        "SELECT appendTrailingCharIfAbsent(status, '!') AS r FROM task_runs",
+      ],
+      ["base64Encode", "SELECT base64Encode(status) AS r FROM task_runs"],
+      ["base64Decode", "SELECT base64Decode(base64Encode(status)) AS r FROM task_runs"],
+      ["tryBase64Decode", "SELECT tryBase64Decode('aGVsbG8=') AS r FROM task_runs"],
+      ["endsWith", "SELECT endsWith(status, 'LY') AS r FROM task_runs"],
+      ["startsWith", "SELECT startsWith(status, 'COM') AS r FROM task_runs"],
+      ["trim", "SELECT trim(status) AS r FROM task_runs"],
+      ["trimLeft", "SELECT trimLeft(status) AS r FROM task_runs"],
+      ["trimRight", "SELECT trimRight(status) AS r FROM task_runs"],
+      ["ltrim", "SELECT ltrim(status) AS r FROM task_runs"],
+      ["rtrim", "SELECT rtrim(status) AS r FROM task_runs"],
+      ["leftPad", "SELECT leftPad(status, 30, '*') AS r FROM task_runs"],
+      ["rightPad", "SELECT rightPad(status, 30, '*') AS r FROM task_runs"],
+      ["leftPadUTF8", "SELECT leftPadUTF8(status, 30, '*') AS r FROM task_runs"],
+      ["rightPadUTF8", "SELECT rightPadUTF8(status, 30, '*') AS r FROM task_runs"],
+      ["left", "SELECT left(status, 3) AS r FROM task_runs"],
+      ["right", "SELECT right(status, 3) AS r FROM task_runs"],
+      ["repeat", "SELECT repeat(status, 2) AS r FROM task_runs"],
+      ["space", "SELECT space(5) AS r FROM task_runs"],
+      ["replace", "SELECT replace(status, 'COMPLETED', 'DONE') AS r FROM task_runs"],
+      ["replaceOne", "SELECT replaceOne(status, 'COMPLETED', 'DONE') AS r FROM task_runs"],
+      ["replaceAll", "SELECT replaceAll(status, 'COMPLETED', 'DONE') AS r FROM task_runs"],
+      ["replaceRegexpOne", "SELECT replaceRegexpOne(status, '[A-Z]+', 'X') AS r FROM task_runs"],
+      ["replaceRegexpAll", "SELECT replaceRegexpAll(status, '[A-Z]', 'x') AS r FROM task_runs"],
+      ["position", "SELECT position(status, 'COM') AS r FROM task_runs"],
+      [
+        "positionCaseInsensitive",
+        "SELECT positionCaseInsensitive(status, 'com') AS r FROM task_runs",
+      ],
+      ["positionUTF8", "SELECT positionUTF8(status, 'COM') AS r FROM task_runs"],
+      [
+        "positionCaseInsensitiveUTF8",
+        "SELECT positionCaseInsensitiveUTF8(status, 'com') AS r FROM task_runs",
+      ],
+      ["locate", "SELECT locate(status, 'COM') AS r FROM task_runs"],
+      ["match", "SELECT match(status, 'COMPLETED.*') AS r FROM task_runs"],
+      ["like", "SELECT like(status, '%COMPLETED%') AS r FROM task_runs"],
+      ["ilike", "SELECT ilike(status, '%completed%') AS r FROM task_runs"],
+      ["notLike", "SELECT notLike(status, '%PENDING%') AS r FROM task_runs"],
+      ["notILike", "SELECT notILike(status, '%pending%') AS r FROM task_runs"],
+      ["splitByChar", "SELECT splitByChar('_', status) AS r FROM task_runs"],
+      ["splitByString", "SELECT splitByString('_', status) AS r FROM task_runs"],
+      ["splitByRegexp", "SELECT splitByRegexp('_', status) AS r FROM task_runs"],
+      ["arrayStringConcat", "SELECT arrayStringConcat(tags, ',') AS r FROM task_runs"],
+      ["format", "SELECT format('{0}-{1}', status, run_id) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Null functions ───────────────────────────────────────────────────────
+
+  clickhouseTest("Null functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["coalesce", "SELECT coalesce(started_at, now()) AS r FROM task_runs"],
+      ["ifNull", "SELECT ifNull(started_at, now()) AS r FROM task_runs"],
+      ["nullIf", "SELECT nullIf(status, 'PENDING') AS r FROM task_runs"],
+      ["assumeNotNull", "SELECT assumeNotNull(started_at) AS r FROM task_runs"],
+      ["toNullable", "SELECT toNullable(status) AS r FROM task_runs"],
+      ["isNull", "SELECT isNull(started_at) AS r FROM task_runs"],
+      ["isNotNull", "SELECT isNotNull(started_at) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Conditional functions ────────────────────────────────────────────────
+
+  clickhouseTest("Conditional functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["if", "SELECT if(usage_duration_ms > 1000, 'slow', 'fast') AS r FROM task_runs"],
+      [
+        "multiIf",
+        "SELECT multiIf(usage_duration_ms > 5000, 'slow', usage_duration_ms > 1000, 'medium', 'fast') AS r FROM task_runs",
+      ],
+    ]);
+  });
+
+  // ─── Comparison functions ─────────────────────────────────────────────────
+
+  clickhouseTest("Comparison functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["equals", "SELECT equals(status, 'PENDING') AS r FROM task_runs"],
+      ["notEquals", "SELECT notEquals(status, 'PENDING') AS r FROM task_runs"],
+      ["less", "SELECT less(usage_duration_ms, 9999) AS r FROM task_runs"],
+      ["greater", "SELECT greater(usage_duration_ms, 0) AS r FROM task_runs"],
+      ["lessOrEquals", "SELECT lessOrEquals(usage_duration_ms, 9999) AS r FROM task_runs"],
+      ["greaterOrEquals", "SELECT greaterOrEquals(usage_duration_ms, 0) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Logical functions ────────────────────────────────────────────────────
+
+  clickhouseTest("Logical functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["and", "SELECT and(usage_duration_ms > 0, is_test = 0) AS r FROM task_runs"],
+      ["or", "SELECT or(usage_duration_ms > 9999, is_test = 0) AS r FROM task_runs"],
+      ["xor", "SELECT xor(usage_duration_ms > 0, is_test = 1) AS r FROM task_runs"],
+      ["not", "SELECT not(is_test) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Type conversion functions ────────────────────────────────────────────
+
+  clickhouseTest("Type conversion functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["toString", "SELECT toString(usage_duration_ms) AS r FROM task_runs"],
+      ["toFixedString", "SELECT toFixedString(status, 30) AS r FROM task_runs"],
+      ["toUInt8", "SELECT toUInt8(is_test) AS r FROM task_runs"],
+      ["toUInt16", "SELECT toUInt16(usage_duration_ms) AS r FROM task_runs"],
+      ["toUInt32", "SELECT toUInt32(usage_duration_ms) AS r FROM task_runs"],
+      ["toUInt64", "SELECT toUInt64(usage_duration_ms) AS r FROM task_runs"],
+      ["toInt8", "SELECT toInt8(1) AS r FROM task_runs"],
+      ["toInt16", "SELECT toInt16(1) AS r FROM task_runs"],
+      ["toInt32", "SELECT toInt32(1) AS r FROM task_runs"],
+      ["toInt64", "SELECT toInt64(usage_duration_ms) AS r FROM task_runs"],
+      ["toInt128", "SELECT toInt128(1) AS r FROM task_runs"],
+      ["toInt256", "SELECT toInt256(1) AS r FROM task_runs"],
+      ["toUInt128", "SELECT toUInt128(1) AS r FROM task_runs"],
+      ["toUInt256", "SELECT toUInt256(1) AS r FROM task_runs"],
+      ["toFloat32", "SELECT toFloat32(cost_in_cents) AS r FROM task_runs"],
+      ["toFloat64", "SELECT toFloat64(cost_in_cents) AS r FROM task_runs"],
+      ["toDecimal32", "SELECT toDecimal32(cost_in_cents, 2) AS r FROM task_runs"],
+      ["toDecimal64", "SELECT toDecimal64(cost_in_cents, 2) AS r FROM task_runs"],
+      ["toDecimal128", "SELECT toDecimal128(cost_in_cents, 2) AS r FROM task_runs"],
+      ["toDecimal256", "SELECT toDecimal256(cost_in_cents, 2) AS r FROM task_runs"],
+      ["toDate", "SELECT toDate(created_at) AS r FROM task_runs"],
+      ["toDateOrNull", "SELECT toDateOrNull('2024-01-01') AS r FROM task_runs"],
+      ["toDateOrZero", "SELECT toDateOrZero('invalid') AS r FROM task_runs"],
+      ["toDate32", "SELECT toDate32(created_at) AS r FROM task_runs"],
+      ["toDate32OrNull", "SELECT toDate32OrNull('2024-01-01') AS r FROM task_runs"],
+      ["toDate32OrZero", "SELECT toDate32OrZero('invalid') AS r FROM task_runs"],
+      ["toDateTime", "SELECT toDateTime(created_at) AS r FROM task_runs"],
+      ["toDateTimeOrNull", "SELECT toDateTimeOrNull('2024-01-01 00:00:00') AS r FROM task_runs"],
+      ["toDateTimeOrZero", "SELECT toDateTimeOrZero('invalid') AS r FROM task_runs"],
+      ["toDateTime64", "SELECT toDateTime64(created_at, 3) AS r FROM task_runs"],
+      [
+        "toDateTime64OrNull",
+        "SELECT toDateTime64OrNull('2024-01-01 00:00:00.000', 3) AS r FROM task_runs",
+      ],
+      ["toDateTime64OrZero", "SELECT toDateTime64OrZero('invalid', 3) AS r FROM task_runs"],
+      ["toTypeName", "SELECT toTypeName(status) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Date/time functions ──────────────────────────────────────────────────
+
+  clickhouseTest("Date/time functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["now", "SELECT now() AS r FROM task_runs"],
+      ["now64", "SELECT now64() AS r FROM task_runs"],
+      ["today", "SELECT today() AS r FROM task_runs"],
+      ["yesterday", "SELECT yesterday() AS r FROM task_runs"],
+      ["toYear", "SELECT toYear(created_at) AS r FROM task_runs"],
+      ["toQuarter", "SELECT toQuarter(created_at) AS r FROM task_runs"],
+      ["toMonth", "SELECT toMonth(created_at) AS r FROM task_runs"],
+      ["toDayOfYear", "SELECT toDayOfYear(created_at) AS r FROM task_runs"],
+      ["toDayOfMonth", "SELECT toDayOfMonth(created_at) AS r FROM task_runs"],
+      ["toDayOfWeek", "SELECT toDayOfWeek(created_at) AS r FROM task_runs"],
+      ["toHour", "SELECT toHour(created_at) AS r FROM task_runs"],
+      ["toMinute", "SELECT toMinute(created_at) AS r FROM task_runs"],
+      ["toSecond", "SELECT toSecond(created_at) AS r FROM task_runs"],
+      ["toUnixTimestamp", "SELECT toUnixTimestamp(created_at) AS r FROM task_runs"],
+      ["toStartOfYear", "SELECT toStartOfYear(created_at) AS r FROM task_runs"],
+      ["toStartOfQuarter", "SELECT toStartOfQuarter(created_at) AS r FROM task_runs"],
+      ["toStartOfMonth", "SELECT toStartOfMonth(created_at) AS r FROM task_runs"],
+      ["toMonday", "SELECT toMonday(created_at) AS r FROM task_runs"],
+      ["toStartOfWeek", "SELECT toStartOfWeek(created_at) AS r FROM task_runs"],
+      ["toStartOfDay", "SELECT toStartOfDay(created_at) AS r FROM task_runs"],
+      ["toStartOfHour", "SELECT toStartOfHour(created_at) AS r FROM task_runs"],
+      ["toStartOfMinute", "SELECT toStartOfMinute(created_at) AS r FROM task_runs"],
+      ["toStartOfSecond", "SELECT toStartOfSecond(created_at) AS r FROM task_runs"],
+      ["toStartOfFiveMinutes", "SELECT toStartOfFiveMinutes(created_at) AS r FROM task_runs"],
+      ["toStartOfTenMinutes", "SELECT toStartOfTenMinutes(created_at) AS r FROM task_runs"],
+      ["toStartOfFifteenMinutes", "SELECT toStartOfFifteenMinutes(created_at) AS r FROM task_runs"],
+      [
+        "toStartOfInterval",
+        "SELECT toStartOfInterval(created_at, INTERVAL 1 hour) AS r FROM task_runs",
+      ],
+      ["toTime", "SELECT toTime(created_at) AS r FROM task_runs"],
+      ["toISOYear", "SELECT toISOYear(created_at) AS r FROM task_runs"],
+      ["toISOWeek", "SELECT toISOWeek(created_at) AS r FROM task_runs"],
+      ["toWeek", "SELECT toWeek(created_at) AS r FROM task_runs"],
+      ["toYearWeek", "SELECT toYearWeek(created_at) AS r FROM task_runs"],
+      ["dateAdd (string unit)", "SELECT dateAdd('day', 7, created_at) AS r FROM task_runs"],
+      ["dateAdd (keyword unit)", "SELECT dateAdd(day, 7, created_at) AS r FROM task_runs"],
+      ["dateSub (string unit)", "SELECT dateSub('hour', 1, created_at) AS r FROM task_runs"],
+      [
+        "dateDiff (string unit)",
+        "SELECT dateDiff('minute', created_at, updated_at) AS r FROM task_runs",
+      ],
+      [
+        "dateDiff (millisecond)",
+        "SELECT dateDiff('millisecond', created_at, updated_at) AS r FROM task_runs",
+      ],
+      [
+        "dateDiff (microsecond)",
+        "SELECT dateDiff('microsecond', created_at, updated_at) AS r FROM task_runs",
+      ],
+      [
+        "dateDiff (nanosecond)",
+        "SELECT dateDiff('nanosecond', created_at, updated_at) AS r FROM task_runs",
+      ],
+      ["dateTrunc (string unit)", "SELECT dateTrunc('month', created_at) AS r FROM task_runs"],
+      ["date_add (string unit)", "SELECT date_add('day', 7, created_at) AS r FROM task_runs"],
+      ["date_sub (string unit)", "SELECT date_sub('hour', 1, created_at) AS r FROM task_runs"],
+      [
+        "date_diff (string unit)",
+        "SELECT date_diff('minute', created_at, updated_at) AS r FROM task_runs",
+      ],
+      ["date_trunc (string unit)", "SELECT date_trunc('month', created_at) AS r FROM task_runs"],
+      ["addSeconds", "SELECT addSeconds(created_at, 10) AS r FROM task_runs"],
+      ["addMinutes", "SELECT addMinutes(created_at, 10) AS r FROM task_runs"],
+      ["addHours", "SELECT addHours(created_at, 1) AS r FROM task_runs"],
+      ["addDays", "SELECT addDays(created_at, 1) AS r FROM task_runs"],
+      ["addWeeks", "SELECT addWeeks(created_at, 1) AS r FROM task_runs"],
+      ["addMonths", "SELECT addMonths(created_at, 1) AS r FROM task_runs"],
+      ["addQuarters", "SELECT addQuarters(created_at, 1) AS r FROM task_runs"],
+      ["addYears", "SELECT addYears(created_at, 1) AS r FROM task_runs"],
+      ["subtractSeconds", "SELECT subtractSeconds(created_at, 10) AS r FROM task_runs"],
+      ["subtractMinutes", "SELECT subtractMinutes(created_at, 10) AS r FROM task_runs"],
+      ["subtractHours", "SELECT subtractHours(created_at, 1) AS r FROM task_runs"],
+      ["subtractDays", "SELECT subtractDays(created_at, 1) AS r FROM task_runs"],
+      ["subtractWeeks", "SELECT subtractWeeks(created_at, 1) AS r FROM task_runs"],
+      ["subtractMonths", "SELECT subtractMonths(created_at, 1) AS r FROM task_runs"],
+      ["subtractQuarters", "SELECT subtractQuarters(created_at, 1) AS r FROM task_runs"],
+      ["subtractYears", "SELECT subtractYears(created_at, 1) AS r FROM task_runs"],
+      ["toTimeZone", "SELECT toTimeZone(created_at, 'America/New_York') AS r FROM task_runs"],
+      ["formatDateTime", "SELECT formatDateTime(created_at, '%Y-%m-%d') AS r FROM task_runs"],
+      ["parseDateTime", "SELECT parseDateTime('2024-01-15', '%Y-%m-%d') AS r FROM task_runs"],
+      [
+        "parseDateTimeBestEffort",
+        "SELECT parseDateTimeBestEffort('2024-01-15 10:30:00') AS r FROM task_runs",
+      ],
+      [
+        "parseDateTimeBestEffortOrNull",
+        "SELECT parseDateTimeBestEffortOrNull('invalid') AS r FROM task_runs",
+      ],
+      [
+        "parseDateTimeBestEffortOrZero",
+        "SELECT parseDateTimeBestEffortOrZero('invalid') AS r FROM task_runs",
+      ],
+      [
+        "parseDateTime64BestEffort",
+        "SELECT parseDateTime64BestEffort('2024-01-15 10:30:00.123') AS r FROM task_runs",
+      ],
+      [
+        "parseDateTime64BestEffortOrNull",
+        "SELECT parseDateTime64BestEffortOrNull('invalid') AS r FROM task_runs",
+      ],
+      [
+        "parseDateTime64BestEffortOrZero",
+        "SELECT parseDateTime64BestEffortOrZero('invalid') AS r FROM task_runs",
+      ],
+    ]);
+  });
+
+  // ─── Interval functions ───────────────────────────────────────────────────
+
+  clickhouseTest("Interval functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["toIntervalSecond", "SELECT toIntervalSecond(10) AS r FROM task_runs"],
+      ["toIntervalMinute", "SELECT toIntervalMinute(5) AS r FROM task_runs"],
+      ["toIntervalHour", "SELECT toIntervalHour(1) AS r FROM task_runs"],
+      ["toIntervalDay", "SELECT toIntervalDay(7) AS r FROM task_runs"],
+      ["toIntervalWeek", "SELECT toIntervalWeek(2) AS r FROM task_runs"],
+      ["toIntervalMonth", "SELECT toIntervalMonth(3) AS r FROM task_runs"],
+      ["toIntervalQuarter", "SELECT toIntervalQuarter(1) AS r FROM task_runs"],
+      ["toIntervalYear", "SELECT toIntervalYear(1) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Array functions ──────────────────────────────────────────────────────
+
+  clickhouseTest("Array functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["array", "SELECT array(1, 2, 3) AS r FROM task_runs"],
+      ["range", "SELECT range(5) AS r FROM task_runs"],
+      ["arrayElement", "SELECT arrayElement(tags, 1) AS r FROM task_runs"],
+      ["has", "SELECT has(tags, 'tag-a') AS r FROM task_runs"],
+      ["hasAll", "SELECT hasAll(tags, array('tag-a')) AS r FROM task_runs"],
+      ["hasAny", "SELECT hasAny(tags, array('tag-a', 'tag-c')) AS r FROM task_runs"],
+      ["hasSubstr", "SELECT hasSubstr(tags, array('tag-a')) AS r FROM task_runs"],
+      ["indexOf", "SELECT indexOf(tags, 'tag-a') AS r FROM task_runs"],
+      ["arrayCount", "SELECT arrayCount(array(1, 0, 1, 0)) AS r FROM task_runs"],
+      ["countEqual", "SELECT countEqual(tags, 'tag-a') AS r FROM task_runs"],
+      ["arrayEnumerate", "SELECT arrayEnumerate(tags) AS r FROM task_runs"],
+      ["arrayEnumerateDense", "SELECT arrayEnumerateDense(tags) AS r FROM task_runs"],
+      ["arrayEnumerateUniq", "SELECT arrayEnumerateUniq(tags) AS r FROM task_runs"],
+      ["arrayPopBack", "SELECT arrayPopBack(tags) AS r FROM task_runs"],
+      ["arrayPopFront", "SELECT arrayPopFront(tags) AS r FROM task_runs"],
+      ["arrayPushBack", "SELECT arrayPushBack(tags, 'tag-new') AS r FROM task_runs"],
+      ["arrayPushFront", "SELECT arrayPushFront(tags, 'tag-new') AS r FROM task_runs"],
+      ["arrayResize", "SELECT arrayResize(tags, 5, '') AS r FROM task_runs"],
+      ["arraySlice", "SELECT arraySlice(tags, 1, 1) AS r FROM task_runs"],
+      ["arraySort", "SELECT arraySort(tags) AS r FROM task_runs"],
+      ["arrayReverseSort", "SELECT arrayReverseSort(tags) AS r FROM task_runs"],
+      ["arrayShuffle", "SELECT arrayShuffle(tags) AS r FROM task_runs"],
+      ["arrayUniq", "SELECT arrayUniq(tags) AS r FROM task_runs"],
+      ["arrayDifference", "SELECT arrayDifference(array(1, 2, 5)) AS r FROM task_runs"],
+      ["arrayDistinct", "SELECT arrayDistinct(tags) AS r FROM task_runs"],
+      ["arrayIntersect", "SELECT arrayIntersect(tags, array('tag-a')) AS r FROM task_runs"],
+      ["arrayReduce", "SELECT arrayReduce('sum', array(1, 2, 3)) AS r FROM task_runs"],
+      ["arrayReverse", "SELECT arrayReverse(tags) AS r FROM task_runs"],
+      ["arrayFlatten", "SELECT arrayFlatten(array(array(1, 2), array(3))) AS r FROM task_runs"],
+      ["arrayCompact", "SELECT arrayCompact(array(1, 1, 2, 3, 3)) AS r FROM task_runs"],
+      ["arrayZip", "SELECT arrayZip(array(1, 2), array('a', 'b')) AS r FROM task_runs"],
+      ["arrayMin", "SELECT arrayMin(array(1, 2, 3)) AS r FROM task_runs"],
+      ["arrayMax", "SELECT arrayMax(array(1, 2, 3)) AS r FROM task_runs"],
+      ["arraySum", "SELECT arraySum(array(1, 2, 3)) AS r FROM task_runs"],
+      ["arrayAvg", "SELECT arrayAvg(array(1, 2, 3)) AS r FROM task_runs"],
+      ["arrayCumSum", "SELECT arrayCumSum(array(1, 2, 3)) AS r FROM task_runs"],
+      [
+        "arrayCumSumNonNegative",
+        "SELECT arrayCumSumNonNegative(array(1, -2, 3)) AS r FROM task_runs",
+      ],
+      ["arrayProduct", "SELECT arrayProduct(array(1, 2, 3)) AS r FROM task_runs"],
+      ["arrayJoin", "SELECT arrayJoin(array(1, 2, 3)) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── JSON functions ───────────────────────────────────────────────────────
+
+  clickhouseTest("JSON functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["JSONHas", `SELECT JSONHas('{"a": 1}', 'a') AS r FROM task_runs`],
+      ["JSONLength", `SELECT JSONLength('{"a": 1, "b": 2}') AS r FROM task_runs`],
+      ["JSONType", `SELECT JSONType('{"a": 1}', 'a') AS r FROM task_runs`],
+      ["JSONExtractUInt", `SELECT JSONExtractUInt('{"a": 1}', 'a') AS r FROM task_runs`],
+      ["JSONExtractInt", `SELECT JSONExtractInt('{"a": -1}', 'a') AS r FROM task_runs`],
+      ["JSONExtractFloat", `SELECT JSONExtractFloat('{"a": 1.5}', 'a') AS r FROM task_runs`],
+      ["JSONExtractBool", `SELECT JSONExtractBool('{"a": true}', 'a') AS r FROM task_runs`],
+      ["JSONExtractString", `SELECT JSONExtractString('{"a": "hello"}', 'a') AS r FROM task_runs`],
+      ["JSONExtractRaw", `SELECT JSONExtractRaw('{"a": [1,2]}', 'a') AS r FROM task_runs`],
+      [
+        "JSONExtractArrayRaw",
+        `SELECT JSONExtractArrayRaw('{"a": [1,2]}', 'a') AS r FROM task_runs`,
+      ],
+      ["JSONExtractKeys", `SELECT JSONExtractKeys('{"a": 1, "b": 2}') AS r FROM task_runs`],
+      ["toJSONString", "SELECT toJSONString(map('a', 1)) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Tuple functions ──────────────────────────────────────────────────────
+
+  clickhouseTest("Tuple functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["tuple", "SELECT tuple(1, 'a', 3.14) AS r FROM task_runs"],
+      ["tupleElement", "SELECT tupleElement(tuple(1, 'a'), 1) AS r FROM task_runs"],
+      ["untuple", "SELECT untuple(tuple(1, 'a')) FROM task_runs"],
+    ]);
+  });
+
+  // ─── Map functions ────────────────────────────────────────────────────────
+
+  clickhouseTest("Map functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["map", "SELECT map('a', 1, 'b', 2) AS r FROM task_runs"],
+      ["mapFromArrays", "SELECT mapFromArrays(array('a', 'b'), array(1, 2)) AS r FROM task_runs"],
+      ["mapContains", "SELECT mapContains(map('a', 1), 'a') AS r FROM task_runs"],
+      ["mapKeys", "SELECT mapKeys(map('a', 1, 'b', 2)) AS r FROM task_runs"],
+      ["mapValues", "SELECT mapValues(map('a', 1, 'b', 2)) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Hash functions ───────────────────────────────────────────────────────
+
+  clickhouseTest("Hash functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["MD5", "SELECT hex(MD5('hello')) AS r FROM task_runs"],
+      ["SHA1", "SELECT hex(SHA1('hello')) AS r FROM task_runs"],
+      ["SHA224", "SELECT hex(SHA224('hello')) AS r FROM task_runs"],
+      ["SHA256", "SELECT hex(SHA256('hello')) AS r FROM task_runs"],
+      ["SHA384", "SELECT hex(SHA384('hello')) AS r FROM task_runs"],
+      ["SHA512", "SELECT hex(SHA512('hello')) AS r FROM task_runs"],
+      ["sipHash64", "SELECT sipHash64('hello') AS r FROM task_runs"],
+      ["sipHash128", "SELECT hex(sipHash128('hello')) AS r FROM task_runs"],
+      ["cityHash64", "SELECT cityHash64('hello') AS r FROM task_runs"],
+      ["intHash32", "SELECT intHash32(42) AS r FROM task_runs"],
+      ["intHash64", "SELECT intHash64(42) AS r FROM task_runs"],
+      ["farmHash64", "SELECT farmHash64('hello') AS r FROM task_runs"],
+      ["farmFingerprint64", "SELECT farmFingerprint64('hello') AS r FROM task_runs"],
+      ["xxHash32", "SELECT xxHash32('hello') AS r FROM task_runs"],
+      ["xxHash64", "SELECT xxHash64('hello') AS r FROM task_runs"],
+      ["murmurHash2_32", "SELECT murmurHash2_32('hello') AS r FROM task_runs"],
+      ["murmurHash2_64", "SELECT murmurHash2_64('hello') AS r FROM task_runs"],
+      ["murmurHash3_32", "SELECT murmurHash3_32('hello') AS r FROM task_runs"],
+      ["murmurHash3_64", "SELECT murmurHash3_64('hello') AS r FROM task_runs"],
+      ["murmurHash3_128", "SELECT hex(murmurHash3_128('hello')) AS r FROM task_runs"],
+      ["hex", "SELECT hex(255) AS r FROM task_runs"],
+      ["unhex", "SELECT unhex('48656C6C6F') AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── URL functions ────────────────────────────────────────────────────────
+
+  clickhouseTest("URL functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["protocol", `SELECT protocol('${url}') AS r FROM task_runs`],
+      ["domain", `SELECT domain('${url}') AS r FROM task_runs`],
+      ["domainWithoutWWW", `SELECT domainWithoutWWW('${url}') AS r FROM task_runs`],
+      ["topLevelDomain", `SELECT topLevelDomain('${url}') AS r FROM task_runs`],
+      [
+        "firstSignificantSubdomain",
+        `SELECT firstSignificantSubdomain('${url}') AS r FROM task_runs`,
+      ],
+      [
+        "cutToFirstSignificantSubdomain",
+        `SELECT cutToFirstSignificantSubdomain('${url}') AS r FROM task_runs`,
+      ],
+      [
+        "cutToFirstSignificantSubdomainWithWWW",
+        `SELECT cutToFirstSignificantSubdomainWithWWW('${url}') AS r FROM task_runs`,
+      ],
+      ["port", `SELECT port('${url}') AS r FROM task_runs`],
+      ["path", `SELECT path('${url}') AS r FROM task_runs`],
+      ["pathFull", `SELECT pathFull('${url}') AS r FROM task_runs`],
+      ["queryString", `SELECT queryString('${url}') AS r FROM task_runs`],
+      ["fragment", `SELECT fragment('${url}') AS r FROM task_runs`],
+      ["extractURLParameter", `SELECT extractURLParameter('${url}', 'q') AS r FROM task_runs`],
+      ["extractURLParameters", `SELECT extractURLParameters('${url}') AS r FROM task_runs`],
+      ["encodeURLComponent", "SELECT encodeURLComponent('hello world') AS r FROM task_runs"],
+      ["decodeURLComponent", "SELECT decodeURLComponent('hello%20world') AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── UUID functions ───────────────────────────────────────────────────────
+
+  clickhouseTest("UUID functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["generateUUIDv4", "SELECT generateUUIDv4() AS r FROM task_runs"],
+      [
+        "UUIDStringToNum",
+        "SELECT UUIDStringToNum('00000000-0000-0000-0000-000000000000') AS r FROM task_runs",
+      ],
+      [
+        "UUIDNumToString",
+        "SELECT UUIDNumToString(UUIDStringToNum('00000000-0000-0000-0000-000000000000')) AS r FROM task_runs",
+      ],
+      ["toUUID", "SELECT toUUID('00000000-0000-0000-0000-000000000000') AS r FROM task_runs"],
+      ["toUUIDOrNull", "SELECT toUUIDOrNull('not-a-uuid') AS r FROM task_runs"],
+      ["toUUIDOrZero", "SELECT toUUIDOrZero('not-a-uuid') AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Misc functions ───────────────────────────────────────────────────────
+
+  clickhouseTest("Misc functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["isFinite", "SELECT isFinite(1.0) AS r FROM task_runs"],
+      ["isInfinite", "SELECT isInfinite(1.0 / 0) AS r FROM task_runs"],
+      ["ifNotFinite", "SELECT ifNotFinite(1.0 / 0, 0) AS r FROM task_runs"],
+      ["isNaN", "SELECT isNaN(0.0 / 0) AS r FROM task_runs"],
+      ["bar", "SELECT bar(usage_duration_ms, 0, 10000, 20) AS r FROM task_runs"],
+      [
+        "transform",
+        "SELECT transform(status, array('PENDING', 'COMPLETED_SUCCESSFULLY'), array('P', 'C'), 'X') AS r FROM task_runs",
+      ],
+      [
+        "formatReadableDecimalSize",
+        "SELECT formatReadableDecimalSize(1000000) AS r FROM task_runs",
+      ],
+      ["formatReadableSize", "SELECT formatReadableSize(1000000) AS r FROM task_runs"],
+      ["formatReadableQuantity", "SELECT formatReadableQuantity(1000000) AS r FROM task_runs"],
+      ["formatReadableTimeDelta", "SELECT formatReadableTimeDelta(3661) AS r FROM task_runs"],
+      ["least", "SELECT least(1, 2) AS r FROM task_runs"],
+      ["greatest", "SELECT greatest(1, 2) AS r FROM task_runs"],
+      ["min2", "SELECT min2(1, 2) AS r FROM task_runs"],
+      ["max2", "SELECT max2(1, 2) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Aggregate functions ──────────────────────────────────────────────────
+
+  clickhouseTest("Aggregate functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["count()", "SELECT count() AS r FROM task_runs"],
+      ["count(col)", "SELECT count(run_id) AS r FROM task_runs"],
+      ["countDistinct", "SELECT countDistinct(status) AS r FROM task_runs"],
+      ["min", "SELECT min(usage_duration_ms) AS r FROM task_runs"],
+      ["max", "SELECT max(usage_duration_ms) AS r FROM task_runs"],
+      ["sum", "SELECT sum(usage_duration_ms) AS r FROM task_runs"],
+      ["avg", "SELECT avg(usage_duration_ms) AS r FROM task_runs"],
+      ["any", "SELECT any(status) AS r FROM task_runs"],
+      ["anyLast", "SELECT anyLast(status) AS r FROM task_runs"],
+      ["anyHeavy", "SELECT anyHeavy(status) AS r FROM task_runs"],
+      ["argMin", "SELECT argMin(run_id, usage_duration_ms) AS r FROM task_runs"],
+      ["argMax", "SELECT argMax(run_id, usage_duration_ms) AS r FROM task_runs"],
+      ["stddevPop", "SELECT stddevPop(usage_duration_ms) AS r FROM task_runs"],
+      ["stddevSamp", "SELECT stddevSamp(usage_duration_ms) AS r FROM task_runs"],
+      ["varPop", "SELECT varPop(usage_duration_ms) AS r FROM task_runs"],
+      ["varSamp", "SELECT varSamp(usage_duration_ms) AS r FROM task_runs"],
+      ["covarPop", "SELECT covarPop(usage_duration_ms, cost_in_cents) AS r FROM task_runs"],
+      ["covarSamp", "SELECT covarSamp(usage_duration_ms, cost_in_cents) AS r FROM task_runs"],
+      ["corr", "SELECT corr(usage_duration_ms, cost_in_cents) AS r FROM task_runs"],
+      ["groupArray", "SELECT groupArray(status) AS r FROM task_runs"],
+      ["groupUniqArray", "SELECT groupUniqArray(status) AS r FROM task_runs"],
+      ["groupArrayMovingAvg", "SELECT groupArrayMovingAvg(usage_duration_ms) AS r FROM task_runs"],
+      ["groupArrayMovingSum", "SELECT groupArrayMovingSum(usage_duration_ms) AS r FROM task_runs"],
+      ["uniq", "SELECT uniq(status) AS r FROM task_runs"],
+      ["uniqExact", "SELECT uniqExact(status) AS r FROM task_runs"],
+      ["uniqHLL12", "SELECT uniqHLL12(status) AS r FROM task_runs"],
+      ["uniqTheta", "SELECT uniqTheta(status) AS r FROM task_runs"],
+      ["median", "SELECT median(usage_duration_ms) AS r FROM task_runs"],
+      ["medianExact", "SELECT medianExact(usage_duration_ms) AS r FROM task_runs"],
+      ["quantile", "SELECT quantile(0.95)(usage_duration_ms) AS r FROM task_runs"],
+      ["quantiles", "SELECT quantiles(0.5, 0.9, 0.99)(usage_duration_ms) AS r FROM task_runs"],
+      ["topK", "SELECT topK(3)(status) AS r FROM task_runs"],
+      [
+        "simpleLinearRegression",
+        "SELECT simpleLinearRegression(usage_duration_ms, cost_in_cents) AS r FROM task_runs",
+      ],
+      ["groupArraySample", "SELECT groupArraySample(2)(status) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Conditional aggregate functions ──────────────────────────────────────
+
+  clickhouseTest("Conditional aggregate functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      ["countIf", "SELECT countIf(usage_duration_ms > 1000) AS r FROM task_runs"],
+      [
+        "countDistinctIf",
+        "SELECT countDistinctIf(status, usage_duration_ms > 0) AS r FROM task_runs",
+      ],
+      ["minIf", "SELECT minIf(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["maxIf", "SELECT maxIf(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["sumIf", "SELECT sumIf(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["avgIf", "SELECT avgIf(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["anyIf", "SELECT anyIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      ["anyLastIf", "SELECT anyLastIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      ["anyHeavyIf", "SELECT anyHeavyIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      ["groupArrayIf", "SELECT groupArrayIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      [
+        "groupUniqArrayIf",
+        "SELECT groupUniqArrayIf(status, usage_duration_ms > 0) AS r FROM task_runs",
+      ],
+      ["uniqIf", "SELECT uniqIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      ["uniqExactIf", "SELECT uniqExactIf(status, usage_duration_ms > 0) AS r FROM task_runs"],
+      ["medianIf", "SELECT medianIf(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["quantileIf", "SELECT quantileIf(0.95)(usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["argMinIf", "SELECT argMinIf(run_id, usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+      ["argMaxIf", "SELECT argMaxIf(run_id, usage_duration_ms, is_test = 0) AS r FROM task_runs"],
+    ]);
+  });
+
+  // ─── Search functions ─────────────────────────────────────────────────────
+
+  clickhouseTest("Search functions", async ({ clickhouseContainer }) => {
+    const client = await setupClient(clickhouseContainer);
+    await runCases(client, [
+      [
+        "multiMatchAny",
+        "SELECT multiMatchAny(status, array('COMPLETED.*', 'PENDING')) AS r FROM task_runs",
+      ],
+      [
+        "multiMatchAnyIndex",
+        "SELECT multiMatchAnyIndex(status, array('COMPLETED.*', 'PENDING')) AS r FROM task_runs",
+      ],
+      [
+        "multiMatchAllIndices",
+        "SELECT multiMatchAllIndices(status, array('COMPLETED.*', 'PEND.*')) AS r FROM task_runs",
+      ],
+      [
+        "multiSearchFirstPosition",
+        "SELECT multiSearchFirstPosition(status, array('COMP', 'PEND')) AS r FROM task_runs",
+      ],
+      [
+        "multiSearchFirstIndex",
+        "SELECT multiSearchFirstIndex(status, array('COMP', 'PEND')) AS r FROM task_runs",
+      ],
+      [
+        "multiSearchAny",
+        "SELECT multiSearchAny(status, array('COMP', 'PEND')) AS r FROM task_runs",
+      ],
+      ["extract", "SELECT extract(status, '[A-Z]+') AS r FROM task_runs"],
+      ["extractAll", "SELECT extractAll(status, '[A-Z]+') AS r FROM task_runs"],
+      [
+        "extractAllGroupsHorizontal",
+        "SELECT extractAllGroupsHorizontal(status, '([A-Z]+)') AS r FROM task_runs",
+      ],
+      [
+        "extractAllGroupsVertical",
+        "SELECT extractAllGroupsVertical(status, '([A-Z]+)') AS r FROM task_runs",
+      ],
+    ]);
+  });
+});
diff --git a/internal-packages/clickhouse/tsconfig.build.json b/internal-packages/clickhouse/tsconfig.build.json
index 619461da80d..6a71c854eef 100644
--- a/internal-packages/clickhouse/tsconfig.build.json
+++ b/internal-packages/clickhouse/tsconfig.build.json
@@ -6,8 +6,8 @@
     "target": "ES2019",
     "lib": ["ES2019", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
     "outDir": "dist",
-    "module": "Node16",
-    "moduleResolution": "Node16",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "moduleDetection": "force",
     "verbatimModuleSyntax": false,
     "esModuleInterop": true,
@@ -16,6 +16,7 @@
     "preserveWatchOutput": true,
     "skipLibCheck": true,
     "strict": true,
+    "noImplicitAny": false,
     "declaration": true
   }
 }
diff --git a/internal-packages/compute/package.json b/internal-packages/compute/package.json
new file mode 100644
index 00000000000..4e221879382
--- /dev/null
+++ b/internal-packages/compute/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@internal/compute",
+  "private": true,
+  "version": "0.0.1",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "@triggerdotdev/source": "./src/index.ts",
+      "import": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "dependencies": {
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "rimraf": "6.0.1"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "dev": "tsc --watch -p tsconfig.build.json"
+  }
+}
diff --git a/internal-packages/compute/src/client.ts b/internal-packages/compute/src/client.ts
new file mode 100644
index 00000000000..4f627bd2830
--- /dev/null
+++ b/internal-packages/compute/src/client.ts
@@ -0,0 +1,151 @@
+import type {
+  TemplateCreateRequest,
+  InstanceCreateRequest,
+  InstanceCreateResponse,
+  InstanceSnapshotRequest,
+  SnapshotRestoreRequest,
+} from "./types.js";
+
+export type ComputeClientOptions = {
+  gatewayUrl: string;
+  authToken?: string;
+  timeoutMs: number;
+};
+
+export class ComputeClient {
+  readonly templates: TemplatesNamespace;
+  readonly instances: InstancesNamespace;
+  readonly snapshots: SnapshotsNamespace;
+
+  constructor(private opts: ComputeClientOptions) {
+    const http = new HttpTransport(opts);
+    this.templates = new TemplatesNamespace(http);
+    this.instances = new InstancesNamespace(http);
+    this.snapshots = new SnapshotsNamespace(http);
+  }
+}
+
+// ── HTTP transport (shared plumbing) ─────────────────────────────────────────
+
+type RequestOptions = {
+  signal?: AbortSignal;
+};
+
+class HttpTransport {
+  constructor(private opts: ComputeClientOptions) {}
+
+  private get headers(): Record<string, string> {
+    const h: Record<string, string> = { "Content-Type": "application/json" };
+    if (this.opts.authToken) {
+      h["Authorization"] = `Bearer ${this.opts.authToken}`;
+    }
+    return h;
+  }
+
+  private signal(options?: RequestOptions): AbortSignal {
+    return options?.signal ?? AbortSignal.timeout(this.opts.timeoutMs);
+  }
+
+  async post<T = unknown>(path: string, body: unknown, options?: RequestOptions): Promise<T | undefined> {
+    const url = `${this.opts.gatewayUrl}${path}`;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: this.signal(options),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "unknown error");
+      throw new ComputeClientError(response.status, errorBody, url);
+    }
+
+    // 202 Accepted or 204 No Content - no body to parse
+    if (response.status === 202 || response.status === 204) {
+      return undefined;
+    }
+
+    return (await response.json()) as T;
+  }
+
+  async delete(path: string, options?: RequestOptions): Promise<void> {
+    const url = `${this.opts.gatewayUrl}${path}`;
+
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: this.signal(options),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "unknown error");
+      throw new ComputeClientError(response.status, errorBody, url);
+    }
+  }
+}
+
+// ── Error ────────────────────────────────────────────────────────────────────
+
+export class ComputeClientError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly body: string,
+    public readonly url: string
+  ) {
+    super(`Compute gateway request failed (${status}): ${body}`);
+    this.name = "ComputeClientError";
+  }
+}
+
+// ── Namespaces ───────────────────────────────────────────────────────────────
+
+class TemplatesNamespace {
+  constructor(private http: HttpTransport) {}
+
+  async create(
+    req: TemplateCreateRequest,
+    options?: RequestOptions
+  ): Promise<void> {
+    await this.http.post("/api/templates", req, options);
+  }
+}
+
+class InstancesNamespace {
+  constructor(private http: HttpTransport) {}
+
+  async create(
+    req: InstanceCreateRequest,
+    options?: RequestOptions
+  ): Promise<InstanceCreateResponse> {
+    const result = await this.http.post<InstanceCreateResponse>("/api/instances", req, options);
+    if (!result) {
+      throw new Error("Compute gateway returned no instance body");
+    }
+    return result;
+  }
+
+  async delete(runnerId: string, options?: RequestOptions): Promise<void> {
+    return this.http.delete(`/api/instances/${runnerId}`, options);
+  }
+
+  async snapshot(
+    runnerId: string,
+    req: InstanceSnapshotRequest,
+    options?: RequestOptions
+  ): Promise<void> {
+    await this.http.post(`/api/instances/${runnerId}/snapshot`, req, options);
+  }
+}
+
+class SnapshotsNamespace {
+  constructor(private http: HttpTransport) {}
+
+  async restore(
+    snapshotId: string,
+    req: SnapshotRestoreRequest,
+    options?: RequestOptions
+  ): Promise<void> {
+    await this.http.post(`/api/snapshots/${snapshotId}/restore`, req, options);
+  }
+}
diff --git a/internal-packages/compute/src/imageRef.ts b/internal-packages/compute/src/imageRef.ts
new file mode 100644
index 00000000000..813f2a6a663
--- /dev/null
+++ b/internal-packages/compute/src/imageRef.ts
@@ -0,0 +1,11 @@
+/**
+ * Strip the digest suffix from a container image reference.
+ * Tags are immutable, so we resolve by tag rather than pinning to a digest.
+ *
+ * "ghcr.io/org/image:tag@sha256:abc..." -> "ghcr.io/org/image:tag"
+ * "ghcr.io/org/image@sha256:abc..."     -> "ghcr.io/org/image"
+ * "ghcr.io/org/image:tag"              -> "ghcr.io/org/image:tag" (unchanged)
+ */
+export function stripImageDigest(imageRef: string): string {
+  return imageRef.split("@")[0] ?? imageRef;
+}
diff --git a/internal-packages/compute/src/index.ts b/internal-packages/compute/src/index.ts
new file mode 100644
index 00000000000..1cec45e6484
--- /dev/null
+++ b/internal-packages/compute/src/index.ts
@@ -0,0 +1,21 @@
+export { ComputeClient, ComputeClientError } from "./client.js";
+export type { ComputeClientOptions } from "./client.js";
+export { stripImageDigest } from "./imageRef.js";
+export {
+  TemplateCreateRequestSchema,
+  TemplateCallbackPayloadSchema,
+  InstanceCreateRequestSchema,
+  InstanceCreateResponseSchema,
+  InstanceSnapshotRequestSchema,
+  SnapshotRestoreRequestSchema,
+  SnapshotCallbackPayloadSchema,
+} from "./types.js";
+export type {
+  TemplateCreateRequest,
+  TemplateCallbackPayload,
+  InstanceCreateRequest,
+  InstanceCreateResponse,
+  InstanceSnapshotRequest,
+  SnapshotRestoreRequest,
+  SnapshotCallbackPayload,
+} from "./types.js";
diff --git a/internal-packages/compute/src/types.ts b/internal-packages/compute/src/types.ts
new file mode 100644
index 00000000000..296e38b59c1
--- /dev/null
+++ b/internal-packages/compute/src/types.ts
@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+// ── Templates ────────────────────────────────────────────────────────────────
+
+export const TemplateCreateRequestSchema = z.object({
+  image: z.string(),
+  cpu: z.number(),
+  memory_gb: z.number(),
+  background: z.boolean().optional(),
+  callback: z
+    .object({
+      url: z.string(),
+      metadata: z.record(z.string()).optional(),
+    })
+    .optional(),
+});
+export type TemplateCreateRequest = z.infer<typeof TemplateCreateRequestSchema>;
+
+export const TemplateCallbackPayloadSchema = z.object({
+  template_id: z.string().optional(),
+  image: z.string(),
+  status: z.enum(["completed", "failed"]),
+  error: z.string().optional(),
+  metadata: z.record(z.string()).optional(),
+  duration_ms: z.number().optional(),
+});
+export type TemplateCallbackPayload = z.infer<typeof TemplateCallbackPayloadSchema>;
+
+// ── Instances ────────────────────────────────────────────────────────────────
+
+export const InstanceCreateRequestSchema = z.object({
+  name: z.string(),
+  image: z.string(),
+  env: z.record(z.string()),
+  cpu: z.number(),
+  memory_gb: z.number(),
+  metadata: z.record(z.unknown()).optional(),
+});
+export type InstanceCreateRequest = z.infer<typeof InstanceCreateRequestSchema>;
+
+export const InstanceCreateResponseSchema = z.object({
+  id: z.string(),
+  _timing: z.unknown().optional(),
+});
+export type InstanceCreateResponse = z.infer<typeof InstanceCreateResponseSchema>;
+
+export const InstanceSnapshotRequestSchema = z.object({
+  callback: z.object({
+    url: z.string(),
+    metadata: z.record(z.string()),
+  }),
+});
+export type InstanceSnapshotRequest = z.infer<typeof InstanceSnapshotRequestSchema>;
+
+// ── Snapshots ────────────────────────────────────────────────────────────────
+
+export const SnapshotRestoreRequestSchema = z.object({
+  name: z.string(),
+  metadata: z.record(z.string()),
+  cpu: z.number(),
+  memory_gb: z.number(),
+});
+export type SnapshotRestoreRequest = z.infer<typeof SnapshotRestoreRequestSchema>;
+
+export const SnapshotCallbackPayloadSchema = z.object({
+  snapshot_id: z.string(),
+  instance_id: z.string(),
+  status: z.enum(["completed", "failed"]),
+  error: z.string().optional(),
+  metadata: z.record(z.string()).optional(),
+  duration_ms: z.number().optional(),
+});
+export type SnapshotCallbackPayload = z.infer<typeof SnapshotCallbackPayloadSchema>;
diff --git a/internal-packages/compute/tsconfig.build.json b/internal-packages/compute/tsconfig.build.json
new file mode 100644
index 00000000000..89c87a3dc67
--- /dev/null
+++ b/internal-packages/compute/tsconfig.build.json
@@ -0,0 +1,21 @@
+{
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"],
+  "compilerOptions": {
+    "composite": true,
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
+    "outDir": "dist",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "declaration": true
+  }
+}
diff --git a/internal-packages/compute/tsconfig.json b/internal-packages/compute/tsconfig.json
new file mode 100644
index 00000000000..ec9998c5e00
--- /dev/null
+++ b/internal-packages/compute/tsconfig.json
@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "lib": ["ES2019", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}
diff --git a/internal-packages/database/CLAUDE.md b/internal-packages/database/CLAUDE.md
new file mode 100644
index 00000000000..56ba681b8a3
--- /dev/null
+++ b/internal-packages/database/CLAUDE.md
@@ -0,0 +1,60 @@
+# Database Package
+
+Prisma 6.14.0 client and schema for PostgreSQL (`@trigger.dev/database`).
+
+## Schema
+
+Located at `prisma/schema.prisma`. Key models include TaskRun, BackgroundWorker, BackgroundWorkerTask, WorkerDeployment, RuntimeEnvironment, and Project.
+
+### Engine Versions
+
+```prisma
+enum RunEngineVersion {
+  V1  // Legacy (MarQS + Graphile) - DEPRECATED
+  V2  // Current (run-engine + redis-worker)
+}
+```
+
+New code should always target V2.
+
+## Creating Migrations
+
+1. Edit `prisma/schema.prisma`
+2. Generate migration:
+   ```bash
+   cd internal-packages/database
+   pnpm run db:migrate:dev:create --name "descriptive_name"
+   ```
+3. **Clean up generated migration** - remove extraneous lines for:
+   - `_BackgroundWorkerToBackgroundWorkerFile`
+   - `_BackgroundWorkerToTaskQueue`
+   - `_TaskRunToTaskRunTag`
+   - `_WaitpointRunConnections`
+   - `_completedWaitpoints`
+   - `SecretStore_key_idx`
+   - Various `TaskRun` indexes (unless you added them)
+4. Apply migration:
+   ```bash
+   pnpm run db:migrate:deploy && pnpm run generate
+   ```
+
+## Index Migration Rules
+
+When adding indexes to **existing tables**:
+
+- Use `CREATE INDEX CONCURRENTLY IF NOT EXISTS` to avoid table locks in production
+- CONCURRENTLY indexes **must be in their own separate migration file** - they cannot be combined with other schema changes (PostgreSQL requirement)
+- Only add one index per migration file
+- Pre-apply the index manually in production before deploying the migration (Prisma will skip creation if the index already exists)
+
+Indexes on **newly created tables** (in the same migration as `CREATE TABLE`) do not need CONCURRENTLY and can be in the same migration file.
+
+When adding an index on a **new column on an existing table**, use two migrations:
+1. First migration: `ALTER TABLE ... ADD COLUMN IF NOT EXISTS ...` (the column)
+2. Second migration: `CREATE INDEX CONCURRENTLY IF NOT EXISTS ...` (the index, in its own file)
+
+See `README.md` in this directory and `ai/references/migrations.md` for the full index workflow.
+
+## Read Replicas
+
+Use `$replica` from `~/db.server` for read-heavy queries in the webapp.
diff --git a/internal-packages/database/prisma/migrations/20251220201230_add_customer_query/migration.sql b/internal-packages/database/prisma/migrations/20251220201230_add_customer_query/migration.sql
new file mode 100644
index 00000000000..1216962abd7
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20251220201230_add_customer_query/migration.sql
@@ -0,0 +1,40 @@
+-- CreateEnum
+CREATE TYPE "public"."CustomerQuerySource" AS ENUM ('DASHBOARD', 'API');
+
+-- CreateEnum
+CREATE TYPE "public"."CustomerQueryScope" AS ENUM ('ORGANIZATION', 'PROJECT', 'ENVIRONMENT');
+
+-- CreateTable
+CREATE TABLE
+    "public"."CustomerQuery" (
+        "id" TEXT NOT NULL,
+        "query" TEXT NOT NULL,
+        "scope" "public"."CustomerQueryScope" NOT NULL,
+        "stats" JSONB NOT NULL,
+        "costInCents" DOUBLE PRECISION NOT NULL DEFAULT 0,
+        "source" "public"."CustomerQuerySource" NOT NULL DEFAULT 'DASHBOARD',
+        "organizationId" TEXT NOT NULL,
+        "projectId" TEXT,
+        "environmentId" TEXT,
+        "userId" TEXT,
+        "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT "CustomerQuery_pkey" PRIMARY KEY ("id")
+    );
+
+-- CreateIndex
+CREATE INDEX "CustomerQuery_organizationId_createdAt_idx" ON "public"."CustomerQuery" ("organizationId", "createdAt" DESC);
+
+-- CreateIndex
+CREATE INDEX "CustomerQuery_createdAt_idx" ON "public"."CustomerQuery" ("createdAt");
+
+-- AddForeignKey
+ALTER TABLE "public"."CustomerQuery" ADD CONSTRAINT "CustomerQuery_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Organization" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."CustomerQuery" ADD CONSTRAINT "CustomerQuery_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."CustomerQuery" ADD CONSTRAINT "CustomerQuery_environmentId_fkey" FOREIGN KEY ("environmentId") REFERENCES "public"."RuntimeEnvironment" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."CustomerQuery" ADD CONSTRAINT "CustomerQuery_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User" ("id") ON DELETE SET NULL ON UPDATE CASCADE;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260108164613_add_impersonation_audit_log/migration.sql b/internal-packages/database/prisma/migrations/20260108164613_add_impersonation_audit_log/migration.sql
new file mode 100644
index 00000000000..ca89a8d9d7f
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260108164613_add_impersonation_audit_log/migration.sql
@@ -0,0 +1,29 @@
+-- CreateEnum
+CREATE TYPE "public"."ImpersonationAuditLogAction" AS ENUM ('START', 'STOP');
+
+-- CreateTable
+CREATE TABLE "public"."ImpersonationAuditLog" (
+    "id" TEXT NOT NULL,
+    "action" "public"."ImpersonationAuditLogAction" NOT NULL,
+    "adminId" TEXT NOT NULL,
+    "targetId" TEXT NOT NULL,
+    "ipAddress" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ImpersonationAuditLog_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "ImpersonationAuditLog_adminId_idx" ON "public"."ImpersonationAuditLog"("adminId");
+
+-- CreateIndex
+CREATE INDEX "ImpersonationAuditLog_targetId_idx" ON "public"."ImpersonationAuditLog"("targetId");
+
+-- CreateIndex
+CREATE INDEX "ImpersonationAuditLog_createdAt_idx" ON "public"."ImpersonationAuditLog"("createdAt");
+
+-- AddForeignKey
+ALTER TABLE "public"."ImpersonationAuditLog" ADD CONSTRAINT "ImpersonationAuditLog_adminId_fkey" FOREIGN KEY ("adminId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."ImpersonationAuditLog" ADD CONSTRAINT "ImpersonationAuditLog_targetId_fkey" FOREIGN KEY ("targetId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260113182122_add_timestamps_to_feature_flag/migration.sql b/internal-packages/database/prisma/migrations/20260113182122_add_timestamps_to_feature_flag/migration.sql
new file mode 100644
index 00000000000..2cd32655394
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260113182122_add_timestamps_to_feature_flag/migration.sql
@@ -0,0 +1,4 @@
+-- AlterTable
+ALTER TABLE "public"."FeatureFlag" ADD COLUMN     "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ADD COLUMN     "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP;
+
diff --git a/internal-packages/database/prisma/migrations/20260115125846_add_project_id_to_task_schedule_instance/migration.sql b/internal-packages/database/prisma/migrations/20260115125846_add_project_id_to_task_schedule_instance/migration.sql
new file mode 100644
index 00000000000..59f75a93772
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260115125846_add_project_id_to_task_schedule_instance/migration.sql
@@ -0,0 +1,16 @@
+-- AlterTable
+ALTER TABLE "public"."TaskScheduleInstance"
+ADD COLUMN IF NOT EXISTS "projectId" TEXT;
+
+-- AddForeignKey
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint WHERE conname = 'TaskScheduleInstance_projectId_fkey'
+  ) THEN
+    ALTER TABLE "public"."TaskScheduleInstance"
+    ADD CONSTRAINT "TaskScheduleInstance_projectId_fkey"
+    FOREIGN KEY ("projectId") REFERENCES "public"."Project" ("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+  END IF;
+END $$;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260115130417_taskscheduleinstance_environmentid_index/migration.sql b/internal-packages/database/prisma/migrations/20260115130417_taskscheduleinstance_environmentid_index/migration.sql
new file mode 100644
index 00000000000..c88056b784b
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260115130417_taskscheduleinstance_environmentid_index/migration.sql
@@ -0,0 +1,2 @@
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "TaskScheduleInstance_environmentId_idx" ON "public"."TaskScheduleInstance" ("environmentId");
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260115154554_taskscheduleinstance_required_projectid/migration.sql b/internal-packages/database/prisma/migrations/20260115154554_taskscheduleinstance_required_projectid/migration.sql
new file mode 100644
index 00000000000..584b0b438a0
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260115154554_taskscheduleinstance_required_projectid/migration.sql
@@ -0,0 +1,21 @@
+/*
+Warnings:
+
+- Made the column `projectId` on table `TaskScheduleInstance` required. This step will fail if there are existing NULL values in that column.
+
+ */
+-- Backfill from TaskSchedule
+UPDATE "TaskScheduleInstance" tsi
+SET
+  "projectId" = ts."projectId"
+FROM
+  "TaskSchedule" ts
+WHERE
+  tsi."taskScheduleId" = ts."id"
+  AND tsi."projectId" IS NULL;
+
+-- AlterTable
+ALTER TABLE "public"."TaskScheduleInstance"
+ALTER COLUMN "projectId"
+SET
+  NOT NULL;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260115164415_taskscheduleinstance_required_projectid_index/migration.sql b/internal-packages/database/prisma/migrations/20260115164415_taskscheduleinstance_required_projectid_index/migration.sql
new file mode 100644
index 00000000000..cb130c04007
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260115164415_taskscheduleinstance_required_projectid_index/migration.sql
@@ -0,0 +1,2 @@
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "TaskScheduleInstance_projectId_active_idx" ON "public"."TaskScheduleInstance" ("projectId", "active");
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260116154810_add_idempotency_key_options_to_task_run/migration.sql b/internal-packages/database/prisma/migrations/20260116154810_add_idempotency_key_options_to_task_run/migration.sql
new file mode 100644
index 00000000000..330f42dfaf9
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260116154810_add_idempotency_key_options_to_task_run/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "TaskRun" ADD COLUMN IF NOT EXISTS "idempotencyKeyOptions" JSONB;
diff --git a/internal-packages/database/prisma/migrations/20260120115732_add_time_filter_to_customer_query/migration.sql b/internal-packages/database/prisma/migrations/20260120115732_add_time_filter_to_customer_query/migration.sql
new file mode 100644
index 00000000000..c30e72d52b1
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260120115732_add_time_filter_to_customer_query/migration.sql
@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "public"."CustomerQuery"
+ADD COLUMN "filterFrom" TIMESTAMP(3),
+ADD COLUMN "filterPeriod" TEXT,
+ADD COLUMN "filterTo" TIMESTAMP(3);
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260124203524_customer_query_add_title_remove_cost/migration.sql b/internal-packages/database/prisma/migrations/20260124203524_customer_query_add_title_remove_cost/migration.sql
new file mode 100644
index 00000000000..ab542e6090d
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260124203524_customer_query_add_title_remove_cost/migration.sql
@@ -0,0 +1,7 @@
+-- AlterTable
+ALTER TABLE "CustomerQuery"
+ADD COLUMN IF NOT EXISTS "title" TEXT;
+
+-- AlterTable
+ALTER TABLE "CustomerQuery"
+DROP COLUMN IF EXISTS "costInCents";
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql b/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql
new file mode 100644
index 00000000000..17f013f388b
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260126175159_add_environment_variable_versioning/migration.sql
@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "public"."EnvironmentVariableValue" ADD COLUMN     "lastUpdatedBy" JSONB,
+ADD COLUMN     "version" INTEGER NOT NULL DEFAULT 1;
diff --git a/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql b/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql
new file mode 100644
index 00000000000..2c18bd2e1da
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162621_add_organization_project_integration/migration.sql
@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "public"."OrganizationProjectIntegration" (
+    "id" TEXT NOT NULL,
+    "organizationIntegrationId" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "externalEntityId" TEXT NOT NULL,
+    "integrationData" JSONB NOT NULL,
+    "installedBy" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "OrganizationProjectIntegration_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_projectId_idx" ON "public"."OrganizationProjectIntegration"("projectId");
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_projectId_organizationIntegr_idx" ON "public"."OrganizationProjectIntegration"("projectId", "organizationIntegrationId");
+
+-- CreateIndex
+CREATE INDEX "OrganizationProjectIntegration_externalEntityId_idx" ON "public"."OrganizationProjectIntegration"("externalEntityId");
+
+-- AddForeignKey
+ALTER TABLE "public"."OrganizationProjectIntegration" ADD CONSTRAINT "OrganizationProjectIntegration_organizationIntegrationId_fkey" FOREIGN KEY ("organizationIntegrationId") REFERENCES "public"."OrganizationIntegration"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."OrganizationProjectIntegration" ADD CONSTRAINT "OrganizationProjectIntegration_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql b/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql
new file mode 100644
index 00000000000..987d643810c
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162810_add_integration_deployment/migration.sql
@@ -0,0 +1,22 @@
+-- CreateTable
+CREATE TABLE "public"."IntegrationDeployment" (
+    "id" TEXT NOT NULL,
+    "integrationName" TEXT NOT NULL,
+    "integrationDeploymentId" TEXT NOT NULL,
+    "commitSHA" TEXT NOT NULL,
+    "deploymentId" TEXT,
+    "status" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "IntegrationDeployment_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "IntegrationDeployment_deploymentId_idx" ON "public"."IntegrationDeployment"("deploymentId");
+
+-- CreateIndex
+CREATE INDEX "IntegrationDeployment_commitSHA_idx" ON "public"."IntegrationDeployment"("commitSHA");
+
+-- AddForeignKey
+ALTER TABLE "public"."IntegrationDeployment" ADD CONSTRAINT "IntegrationDeployment_deploymentId_fkey" FOREIGN KEY ("deploymentId") REFERENCES "public"."WorkerDeployment"("id") ON DELETE SET NULL ON UPDATE CASCADE;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql b/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql
new file mode 100644
index 00000000000..345d337f187
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129162946_alter_tables_for_integrations_data/migration.sql
@@ -0,0 +1,9 @@
+-- AlterEnum
+ALTER TYPE "public"."IntegrationService" ADD VALUE 'VERCEL';
+
+-- AlterTable
+ALTER TABLE "public"."OrganizationIntegration" ADD COLUMN     "deletedAt" TIMESTAMP(3),
+ADD COLUMN     "externalOrganizationId" TEXT;
+
+-- AlterTable
+ALTER TABLE "public"."WorkerDeployment" ADD COLUMN     "commitSHA" TEXT;
diff --git a/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql b/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql
new file mode 100644
index 00000000000..ac24fc4bdb0
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129165555_add_organization_integration_idx/migration.sql
@@ -0,0 +1,3 @@
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "OrganizationIntegration_externalOrganizationId_idx" ON "public"."OrganizationIntegration"("externalOrganizationId");
+
diff --git a/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql b/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql
new file mode 100644
index 00000000000..fcf74c0d978
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260129165809_add_worker_deployment_idx/migration.sql
@@ -0,0 +1,3 @@
+
+-- CreateIndex
+CREATE INDEX CONCURRENTLY IF NOT EXISTS "WorkerDeployment_commitSHA_idx" ON "public"."WorkerDeployment"("commitSHA");
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260201130503_metrics_dashboard_table_created/migration.sql b/internal-packages/database/prisma/migrations/20260201130503_metrics_dashboard_table_created/migration.sql
new file mode 100644
index 00000000000..321b3148ca0
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260201130503_metrics_dashboard_table_created/migration.sql
@@ -0,0 +1,25 @@
+-- CreateTable
+CREATE TABLE
+    "public"."MetricsDashboard" (
+        "id" TEXT NOT NULL,
+        "title" TEXT NOT NULL,
+        "organizationId" TEXT NOT NULL,
+        "projectId" TEXT,
+        "ownerId" TEXT NOT NULL,
+        "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" TIMESTAMP(3) NOT NULL,
+        "layout" TEXT NOT NULL,
+        CONSTRAINT "MetricsDashboard_pkey" PRIMARY KEY ("id")
+    );
+
+-- CreateIndex
+CREATE INDEX "MetricsDashboard_projectId_createdAt_idx" ON "public"."MetricsDashboard" ("projectId", "createdAt" DESC);
+
+-- AddForeignKey
+ALTER TABLE "public"."MetricsDashboard" ADD CONSTRAINT "MetricsDashboard_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Organization" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."MetricsDashboard" ADD CONSTRAINT "MetricsDashboard_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."MetricsDashboard" ADD CONSTRAINT "MetricsDashboard_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "public"."User" ("id") ON DELETE SET NULL ON UPDATE CASCADE;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260202044337_metrics_dashboard_description/migration.sql b/internal-packages/database/prisma/migrations/20260202044337_metrics_dashboard_description/migration.sql
new file mode 100644
index 00000000000..d7c25db8b80
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260202044337_metrics_dashboard_description/migration.sql
@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "public"."MetricsDashboard"
+ADD COLUMN "description" TEXT NOT NULL DEFAULT '';
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260202100000_add_friendlyid_to_metrics_dashboard/migration.sql b/internal-packages/database/prisma/migrations/20260202100000_add_friendlyid_to_metrics_dashboard/migration.sql
new file mode 100644
index 00000000000..6e48faf18f6
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260202100000_add_friendlyid_to_metrics_dashboard/migration.sql
@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "public"."MetricsDashboard" ADD COLUMN "friendlyId" TEXT NOT NULL;
+
+-- CreateIndex
+CREATE UNIQUE INDEX "MetricsDashboard_friendlyId_key" ON "public"."MetricsDashboard"("friendlyId");
diff --git a/internal-packages/database/prisma/migrations/20260211120000_make_metrics_dashboard_owner_nullable/migration.sql b/internal-packages/database/prisma/migrations/20260211120000_make_metrics_dashboard_owner_nullable/migration.sql
new file mode 100644
index 00000000000..5ea906c4ee2
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260211120000_make_metrics_dashboard_owner_nullable/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable: make ownerId nullable to match ON DELETE SET NULL foreign key
+ALTER TABLE "public"."MetricsDashboard" ALTER COLUMN "ownerId" DROP NOT NULL;
diff --git a/internal-packages/database/prisma/migrations/20260220120000_add_onboarding_data_to_user_and_project/migration.sql b/internal-packages/database/prisma/migrations/20260220120000_add_onboarding_data_to_user_and_project/migration.sql
new file mode 100644
index 00000000000..97861c2223d
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260220120000_add_onboarding_data_to_user_and_project/migration.sql
@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "public"."User" ADD COLUMN "onboardingData" JSONB;
+
+-- AlterTable
+ALTER TABLE "public"."Project" ADD COLUMN "onboardingData" JSONB;
diff --git a/internal-packages/database/prisma/migrations/20260223123615_add_platform_notification_tables/migration.sql b/internal-packages/database/prisma/migrations/20260223123615_add_platform_notification_tables/migration.sql
new file mode 100644
index 00000000000..ae76fad81c0
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260223123615_add_platform_notification_tables/migration.sql
@@ -0,0 +1,69 @@
+-- CreateEnum
+CREATE TYPE "public"."PlatformNotificationSurface" AS ENUM ('WEBAPP', 'CLI');
+
+-- CreateEnum
+CREATE TYPE "public"."PlatformNotificationScope" AS ENUM ('USER', 'PROJECT', 'ORGANIZATION', 'GLOBAL');
+
+-- CreateTable
+CREATE TABLE "public"."PlatformNotification" (
+    "id" TEXT NOT NULL,
+    "friendlyId" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "payload" JSONB NOT NULL,
+    "surface" "public"."PlatformNotificationSurface" NOT NULL,
+    "scope" "public"."PlatformNotificationScope" NOT NULL,
+    "userId" TEXT,
+    "organizationId" TEXT,
+    "projectId" TEXT,
+    "startsAt" TIMESTAMP(3) NOT NULL,
+    "endsAt" TIMESTAMP(3) NOT NULL,
+    "cliMaxDaysAfterFirstSeen" INTEGER,
+    "cliMaxShowCount" INTEGER,
+    "cliShowEvery" INTEGER,
+    "priority" INTEGER NOT NULL DEFAULT 0,
+    "archivedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "PlatformNotification_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "public"."PlatformNotificationInteraction" (
+    "id" TEXT NOT NULL,
+    "notificationId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "firstSeenAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "showCount" INTEGER NOT NULL DEFAULT 1,
+    "webappDismissedAt" TIMESTAMP(3),
+    "webappClickedAt" TIMESTAMP(3),
+    "cliDismissedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "PlatformNotificationInteraction_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PlatformNotification_friendlyId_key" ON "public"."PlatformNotification"("friendlyId");
+
+-- CreateIndex
+CREATE INDEX "PlatformNotification_surface_scope_startsAt_idx" ON "public"."PlatformNotification"("surface", "scope", "startsAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PlatformNotificationInteraction_notificationId_userId_key" ON "public"."PlatformNotificationInteraction"("notificationId", "userId");
+
+-- AddForeignKey
+ALTER TABLE "public"."PlatformNotification" ADD CONSTRAINT "PlatformNotification_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."PlatformNotification" ADD CONSTRAINT "PlatformNotification_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Organization"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."PlatformNotification" ADD CONSTRAINT "PlatformNotification_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."PlatformNotificationInteraction" ADD CONSTRAINT "PlatformNotificationInteraction_notificationId_fkey" FOREIGN KEY ("notificationId") REFERENCES "public"."PlatformNotification"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."PlatformNotificationInteraction" ADD CONSTRAINT "PlatformNotificationInteraction_userId_fkey" FOREIGN KEY ("userId") REFERENCES "public"."User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260226120000_add_onboarding_data_to_organization/migration.sql b/internal-packages/database/prisma/migrations/20260226120000_add_onboarding_data_to_organization/migration.sql
new file mode 100644
index 00000000000..064dc077431
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260226120000_add_onboarding_data_to_organization/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."Organization" ADD COLUMN "onboardingData" JSONB;
diff --git a/internal-packages/database/prisma/migrations/20260306102053_error_group_state/migration.sql b/internal-packages/database/prisma/migrations/20260306102053_error_group_state/migration.sql
new file mode 100644
index 00000000000..0510505b6ae
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260306102053_error_group_state/migration.sql
@@ -0,0 +1,53 @@
+-- CreateEnum
+CREATE TYPE "public"."ErrorGroupStatus" AS ENUM ('UNRESOLVED', 'RESOLVED', 'IGNORED');
+
+-- AlterEnum
+ALTER TYPE "public"."ProjectAlertType" ADD VALUE IF NOT EXISTS 'ERROR_GROUP';
+
+-- CreateTable
+CREATE TABLE
+    "public"."ErrorGroupState" (
+        "id" TEXT NOT NULL,
+        "organizationId" TEXT NOT NULL,
+        "projectId" TEXT NOT NULL,
+        "environmentId" TEXT,
+        "taskIdentifier" TEXT NOT NULL,
+        "errorFingerprint" TEXT NOT NULL,
+        "status" "public"."ErrorGroupStatus" NOT NULL DEFAULT 'UNRESOLVED',
+        "ignoredUntil" TIMESTAMP(3),
+        "ignoredUntilOccurrenceRate" INTEGER,
+        "ignoredUntilTotalOccurrences" INTEGER,
+        "ignoredAtOccurrenceCount" BIGINT,
+        "ignoredAt" TIMESTAMP(3),
+        "ignoredReason" TEXT,
+        "ignoredByUserId" TEXT,
+        "resolvedAt" TIMESTAMP(3),
+        "resolvedInVersion" TEXT,
+        "resolvedBy" TEXT,
+        "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" TIMESTAMP(3) NOT NULL,
+        CONSTRAINT "ErrorGroupState_pkey" PRIMARY KEY ("id")
+    );
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ErrorGroupState_environmentId_taskIdentifier_errorFingerpri_key" ON "public"."ErrorGroupState" (
+    "environmentId",
+    "taskIdentifier",
+    "errorFingerprint"
+);
+
+-- CreateIndex
+CREATE INDEX "ErrorGroupState_environmentId_status_idx" ON "public"."ErrorGroupState" ("environmentId", "status");
+
+-- AddForeignKey
+ALTER TABLE "public"."ErrorGroupState" ADD CONSTRAINT "ErrorGroupState_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Organization" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."ErrorGroupState" ADD CONSTRAINT "ErrorGroupState_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."ErrorGroupState" ADD CONSTRAINT "ErrorGroupState_environmentId_fkey" FOREIGN KEY ("environmentId") REFERENCES "public"."RuntimeEnvironment" ("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AlterTable
+ALTER TABLE "public"."ProjectAlertChannel"
+ADD COLUMN "errorAlertConfig" JSONB;
\ No newline at end of file
diff --git a/internal-packages/database/prisma/migrations/20260309120000_add_ttl_to_background_worker_task/migration.sql b/internal-packages/database/prisma/migrations/20260309120000_add_ttl_to_background_worker_task/migration.sql
new file mode 100644
index 00000000000..569fb94643b
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260309120000_add_ttl_to_background_worker_task/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."BackgroundWorkerTask" ADD COLUMN IF NOT EXISTS "ttl" TEXT;
diff --git a/internal-packages/database/prisma/migrations/20260310155049_add_llm_pricing_tables/migration.sql b/internal-packages/database/prisma/migrations/20260310155049_add_llm_pricing_tables/migration.sql
new file mode 100644
index 00000000000..286de6eacfb
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260310155049_add_llm_pricing_tables/migration.sql
@@ -0,0 +1,67 @@
+-- CreateTable
+CREATE TABLE "public"."llm_models" (
+    "id" TEXT NOT NULL,
+    "friendly_id" TEXT NOT NULL,
+    "project_id" TEXT,
+    "model_name" TEXT NOT NULL,
+    "match_pattern" TEXT NOT NULL,
+    "start_date" TIMESTAMP(3),
+    "source" TEXT NOT NULL DEFAULT 'default',
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "llm_models_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "public"."llm_pricing_tiers" (
+    "id" TEXT NOT NULL,
+    "model_id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "is_default" BOOLEAN NOT NULL DEFAULT true,
+    "priority" INTEGER NOT NULL DEFAULT 0,
+    "conditions" JSONB NOT NULL DEFAULT '[]',
+
+    CONSTRAINT "llm_pricing_tiers_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "public"."llm_prices" (
+    "id" TEXT NOT NULL,
+    "model_id" TEXT NOT NULL,
+    "pricing_tier_id" TEXT NOT NULL,
+    "usage_type" TEXT NOT NULL,
+    "price" DECIMAL(20,12) NOT NULL,
+
+    CONSTRAINT "llm_prices_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "llm_models_friendly_id_key" ON "public"."llm_models"("friendly_id");
+
+-- CreateIndex
+CREATE INDEX "llm_models_project_id_idx" ON "public"."llm_models"("project_id");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "llm_models_project_id_model_name_start_date_key" ON "public"."llm_models"("project_id", "model_name", "start_date");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "llm_pricing_tiers_model_id_priority_key" ON "public"."llm_pricing_tiers"("model_id", "priority");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "llm_pricing_tiers_model_id_name_key" ON "public"."llm_pricing_tiers"("model_id", "name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "llm_prices_model_id_usage_type_pricing_tier_id_key" ON "public"."llm_prices"("model_id", "usage_type", "pricing_tier_id");
+
+-- AddForeignKey
+ALTER TABLE "public"."llm_models" ADD CONSTRAINT "llm_models_project_id_fkey" FOREIGN KEY ("project_id") REFERENCES "public"."Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."llm_pricing_tiers" ADD CONSTRAINT "llm_pricing_tiers_model_id_fkey" FOREIGN KEY ("model_id") REFERENCES "public"."llm_models"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."llm_prices" ADD CONSTRAINT "llm_prices_model_id_fkey" FOREIGN KEY ("model_id") REFERENCES "public"."llm_models"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."llm_prices" ADD CONSTRAINT "llm_prices_pricing_tier_id_fkey" FOREIGN KEY ("pricing_tier_id") REFERENCES "public"."llm_pricing_tiers"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260317221618_add_prompt_management/migration.sql b/internal-packages/database/prisma/migrations/20260317221618_add_prompt_management/migration.sql
new file mode 100644
index 00000000000..8d2e0bba1e3
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260317221618_add_prompt_management/migration.sql
@@ -0,0 +1,74 @@
+-- CreateTable
+CREATE TABLE "public"."prompts" (
+    "id" TEXT NOT NULL,
+    "slug" TEXT NOT NULL,
+    "description" TEXT,
+    "type" TEXT NOT NULL DEFAULT 'text',
+    "organizationId" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "runtimeEnvironmentId" TEXT NOT NULL,
+    "filePath" TEXT,
+    "exportName" TEXT,
+    "variableSchema" JSONB,
+    "defaultModel" TEXT,
+    "defaultConfig" JSONB,
+    "tags" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "archivedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "prompts_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "public"."prompt_versions" (
+    "id" TEXT NOT NULL,
+    "version" INTEGER NOT NULL,
+    "promptId" TEXT NOT NULL,
+    "textContent" TEXT,
+    "chatContent" JSONB,
+    "model" TEXT,
+    "config" JSONB,
+    "source" TEXT NOT NULL,
+    "commitMessage" TEXT,
+    "contentHash" TEXT NOT NULL,
+    "labels" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "workerId" TEXT,
+    "createdBy" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "prompt_versions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "prompts_projectId_idx" ON "public"."prompts"("projectId");
+
+-- CreateIndex
+CREATE INDEX "prompts_runtimeEnvironmentId_idx" ON "public"."prompts"("runtimeEnvironmentId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "prompts_projectId_runtimeEnvironmentId_slug_key" ON "public"."prompts"("projectId", "runtimeEnvironmentId", "slug");
+
+-- CreateIndex
+CREATE INDEX "prompt_versions_promptId_idx" ON "public"."prompt_versions"("promptId");
+
+-- CreateIndex
+CREATE INDEX "prompt_versions_contentHash_idx" ON "public"."prompt_versions"("contentHash");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "prompt_versions_promptId_version_key" ON "public"."prompt_versions"("promptId", "version");
+
+-- AddForeignKey
+ALTER TABLE "public"."prompts" ADD CONSTRAINT "prompts_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Organization"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."prompts" ADD CONSTRAINT "prompts_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "public"."Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."prompts" ADD CONSTRAINT "prompts_runtimeEnvironmentId_fkey" FOREIGN KEY ("runtimeEnvironmentId") REFERENCES "public"."RuntimeEnvironment"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."prompt_versions" ADD CONSTRAINT "prompt_versions_promptId_fkey" FOREIGN KEY ("promptId") REFERENCES "public"."prompts"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "public"."prompt_versions" ADD CONSTRAINT "prompt_versions_workerId_fkey" FOREIGN KEY ("workerId") REFERENCES "public"."BackgroundWorker"("id") ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/internal-packages/database/prisma/migrations/20260318114244_add_prompt_friendly_id/migration.sql b/internal-packages/database/prisma/migrations/20260318114244_add_prompt_friendly_id/migration.sql
new file mode 100644
index 00000000000..2a2ca830ef9
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260318114244_add_prompt_friendly_id/migration.sql
@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "public"."prompts" ADD COLUMN "friendly_id" TEXT NOT NULL;
+
+-- CreateIndex
+CREATE UNIQUE INDEX "prompts_friendly_id_key" ON "public"."prompts"("friendly_id");
diff --git a/internal-packages/database/prisma/migrations/20260323085243_add_task_run_annotations/migration.sql b/internal-packages/database/prisma/migrations/20260323085243_add_task_run_annotations/migration.sql
new file mode 100644
index 00000000000..4a5abdc464c
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260323085243_add_task_run_annotations/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."TaskRun" ADD COLUMN     "annotations" JSONB;
diff --git a/internal-packages/database/prisma/migrations/20260323104144_add_catalog_columns_to_llm_models/migration.sql b/internal-packages/database/prisma/migrations/20260323104144_add_catalog_columns_to_llm_models/migration.sql
new file mode 100644
index 00000000000..759d17dc93e
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260323104144_add_catalog_columns_to_llm_models/migration.sql
@@ -0,0 +1,7 @@
+-- AlterTable
+ALTER TABLE "public"."llm_models" ADD COLUMN     "capabilities" TEXT[] DEFAULT ARRAY[]::TEXT[],
+ADD COLUMN     "context_window" INTEGER,
+ADD COLUMN     "description" TEXT,
+ADD COLUMN     "is_hidden" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "max_output_tokens" INTEGER,
+ADD COLUMN     "provider" TEXT;
diff --git a/internal-packages/database/prisma/migrations/20260324142824_add_base_model_name_to_llm_models/migration.sql b/internal-packages/database/prisma/migrations/20260324142824_add_base_model_name_to_llm_models/migration.sql
new file mode 100644
index 00000000000..acdae6e37ba
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260324142824_add_base_model_name_to_llm_models/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."llm_models" ADD COLUMN     "base_model_name" TEXT;
diff --git a/internal-packages/database/prisma/migrations/20260325165730_add_is_warm_start_to_task_run/migration.sql b/internal-packages/database/prisma/migrations/20260325165730_add_is_warm_start_to_task_run/migration.sql
new file mode 100644
index 00000000000..29274427d3c
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260325165730_add_is_warm_start_to_task_run/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."TaskRun" ADD COLUMN "isWarmStart" BOOLEAN;
diff --git a/internal-packages/database/prisma/migrations/20260326150000_add_workload_type_to_worker_instance_group/migration.sql b/internal-packages/database/prisma/migrations/20260326150000_add_workload_type_to_worker_instance_group/migration.sql
new file mode 100644
index 00000000000..4865ae070e3
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260326150000_add_workload_type_to_worker_instance_group/migration.sql
@@ -0,0 +1,5 @@
+-- CreateEnum
+CREATE TYPE "WorkloadType" AS ENUM ('CONTAINER', 'MICROVM');
+
+-- AlterTable
+ALTER TABLE "WorkerInstanceGroup" ADD COLUMN "workloadType" "WorkloadType" NOT NULL DEFAULT 'CONTAINER';
diff --git a/internal-packages/database/prisma/migrations/20260328000000_add_compute_checkpoint_type/migration.sql b/internal-packages/database/prisma/migrations/20260328000000_add_compute_checkpoint_type/migration.sql
new file mode 100644
index 00000000000..45faeca79b1
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260328000000_add_compute_checkpoint_type/migration.sql
@@ -0,0 +1,2 @@
+-- AlterEnum
+ALTER TYPE "TaskRunCheckpointType" ADD VALUE 'COMPUTE';
diff --git a/internal-packages/database/prisma/migrations/20260330210247_add_enable_fast_path_to_worker_instance_group/migration.sql b/internal-packages/database/prisma/migrations/20260330210247_add_enable_fast_path_to_worker_instance_group/migration.sql
new file mode 100644
index 00000000000..b7ca1576264
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260330210247_add_enable_fast_path_to_worker_instance_group/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "public"."WorkerInstanceGroup" ADD COLUMN     "enableFastPath" BOOLEAN NOT NULL DEFAULT false;
diff --git a/internal-packages/database/prisma/migrations/20260401000000_drop_taskrun_foreign_keys/migration.sql b/internal-packages/database/prisma/migrations/20260401000000_drop_taskrun_foreign_keys/migration.sql
new file mode 100644
index 00000000000..a2ec4e42304
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260401000000_drop_taskrun_foreign_keys/migration.sql
@@ -0,0 +1,9 @@
+-- Drop all foreign key constraints on TaskRun (no schema change, data intact)
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_runtimeEnvironmentId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_projectId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_lockedById_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_lockedToVersionId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_rootTaskRunId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_parentTaskRunId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_parentTaskRunAttemptId_fkey";
+ALTER TABLE "TaskRun" DROP CONSTRAINT IF EXISTS "TaskRun_batchId_fkey";
diff --git a/internal-packages/database/prisma/migrations/20260401130744_drop_task_run_runtime_environment_id_index/migration.sql b/internal-packages/database/prisma/migrations/20260401130744_drop_task_run_runtime_environment_id_index/migration.sql
new file mode 100644
index 00000000000..7778de20c10
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260401130744_drop_task_run_runtime_environment_id_index/migration.sql
@@ -0,0 +1,2 @@
+-- DropIndex
+DROP INDEX CONCURRENTLY IF EXISTS "public"."TaskRun_runtimeEnvironmentId_id_idx";
diff --git a/internal-packages/database/prisma/migrations/20260401132332_drop_task_run_schedule_id_idx/migration.sql b/internal-packages/database/prisma/migrations/20260401132332_drop_task_run_schedule_id_idx/migration.sql
new file mode 100644
index 00000000000..f9006fe2081
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260401132332_drop_task_run_schedule_id_idx/migration.sql
@@ -0,0 +1,2 @@
+-- DropIndex
+DROP INDEX CONCURRENTLY IF EXISTS "public"."TaskRun_scheduleId_idx";
diff --git a/internal-packages/database/prisma/migrations/20260401132508_drop_task_run_root_task_run_id_idx/migration.sql b/internal-packages/database/prisma/migrations/20260401132508_drop_task_run_root_task_run_id_idx/migration.sql
new file mode 100644
index 00000000000..ccfa6f6d19c
--- /dev/null
+++ b/internal-packages/database/prisma/migrations/20260401132508_drop_task_run_root_task_run_id_idx/migration.sql
@@ -0,0 +1,2 @@
+-- DropIndex
+DROP INDEX CONCURRENTLY IF EXISTS "public"."TaskRun_rootTaskRunId_idx";
diff --git a/internal-packages/database/prisma/schema.prisma b/internal-packages/database/prisma/schema.prisma
index 28c83329661..7138aeaab0d 100644
--- a/internal-packages/database/prisma/schema.prisma
+++ b/internal-packages/database/prisma/schema.prisma
@@ -43,6 +43,7 @@ model User {
   confirmedBasicDetails Boolean @default(false)
 
   referralSource String?
+  onboardingData Json?
 
   orgMemberships OrgMember[]
   sentInvites    OrgMemberInvite[]
@@ -59,6 +60,13 @@ model User {
   deployments          WorkerDeployment[]
   backupCodes          MfaBackupCode[]
   bulkActions          BulkActionGroup[]
+
+  impersonationsPerformed          ImpersonationAuditLog[]           @relation("ImpersonationAdmin")
+  impersonationsReceived           ImpersonationAuditLog[]           @relation("ImpersonationTarget")
+  customerQueries                  CustomerQuery[]
+  metricsDashboards                MetricsDashboard[]
+  platformNotifications            PlatformNotification[]
+  platformNotificationInteractions PlatformNotificationInteraction[]
 }
 
 model MfaBackupCode {
@@ -185,6 +193,8 @@ model Organization {
 
   companySize String?
 
+  onboardingData Json?
+
   avatar Json?
 
   runsEnabled Boolean @default(true)
@@ -218,6 +228,12 @@ model Organization {
   workerGroups             WorkerInstanceGroup[]
   workerInstances          WorkerInstance[]
   githubAppInstallations   GithubAppInstallation[]
+  customerQueries          CustomerQuery[]
+  metricsDashboards        MetricsDashboard[]
+  prompts                  Prompt[]
+
+  platformNotifications PlatformNotification[]
+  errorGroupStates      ErrorGroupState[]
 }
 
 model OrgMember {
@@ -335,6 +351,9 @@ model RuntimeEnvironment {
   workerInstances      WorkerInstance[]
   waitpointTags        WaitpointTag[]
   BulkActionGroup      BulkActionGroup[]
+  customerQueries      CustomerQuery[]
+  prompts              Prompt[]
+  errorGroupStates     ErrorGroupState[]
 
   @@unique([projectId, slug, orgMemberId])
   @@unique([projectId, shortcode])
@@ -378,29 +397,38 @@ model Project {
   /// The master queues they are allowed to use (impacts what they can set as default and trigger runs with)
   allowedWorkerQueues String[] @default([]) @map("allowedMasterQueues")
 
-  environments              RuntimeEnvironment[]
-  backgroundWorkers         BackgroundWorker[]
-  backgroundWorkerTasks     BackgroundWorkerTask[]
-  taskRuns                  TaskRun[]
-  runTags                   TaskRunTag[]
-  taskQueues                TaskQueue[]
-  environmentVariables      EnvironmentVariable[]
-  checkpoints               Checkpoint[]
-  WorkerDeployment          WorkerDeployment[]
-  CheckpointRestoreEvent    CheckpointRestoreEvent[]
-  taskSchedules             TaskSchedule[]
-  alertChannels             ProjectAlertChannel[]
-  alerts                    ProjectAlert[]
-  alertStorages             ProjectAlertStorage[]
-  bulkActionGroups          BulkActionGroup[]
-  BackgroundWorkerFile      BackgroundWorkerFile[]
-  waitpoints                Waitpoint[]
-  taskRunWaitpoints         TaskRunWaitpoint[]
-  taskRunCheckpoints        TaskRunCheckpoint[]
-  waitpointTags             WaitpointTag[]
-  connectedGithubRepository ConnectedGithubRepository?
-
-  buildSettings Json?
+  environments                   RuntimeEnvironment[]
+  backgroundWorkers              BackgroundWorker[]
+  backgroundWorkerTasks          BackgroundWorkerTask[]
+  taskRuns                       TaskRun[]
+  runTags                        TaskRunTag[]
+  taskQueues                     TaskQueue[]
+  environmentVariables           EnvironmentVariable[]
+  checkpoints                    Checkpoint[]
+  WorkerDeployment               WorkerDeployment[]
+  CheckpointRestoreEvent         CheckpointRestoreEvent[]
+  taskSchedules                  TaskSchedule[]
+  alertChannels                  ProjectAlertChannel[]
+  alerts                         ProjectAlert[]
+  alertStorages                  ProjectAlertStorage[]
+  bulkActionGroups               BulkActionGroup[]
+  BackgroundWorkerFile           BackgroundWorkerFile[]
+  waitpoints                     Waitpoint[]
+  taskRunWaitpoints              TaskRunWaitpoint[]
+  taskRunCheckpoints             TaskRunCheckpoint[]
+  waitpointTags                  WaitpointTag[]
+  connectedGithubRepository      ConnectedGithubRepository?
+  organizationProjectIntegration OrganizationProjectIntegration[]
+  customerQueries                CustomerQuery[]
+
+  buildSettings         Json?
+  onboardingData        Json?
+  taskScheduleInstances TaskScheduleInstance[]
+  metricsDashboards     MetricsDashboard[]
+  llmModels             LlmModel[]
+  prompts               Prompt[]
+  platformNotifications PlatformNotification[]
+  errorGroupStates      ErrorGroupState[]
 }
 
 enum ProjectVersion {
@@ -475,11 +503,12 @@ model BackgroundWorker {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  tasks      BackgroundWorkerTask[]
-  attempts   TaskRunAttempt[]
-  lockedRuns TaskRun[]
-  files      BackgroundWorkerFile[]
-  queues     TaskQueue[]
+  tasks          BackgroundWorkerTask[]
+  attempts       TaskRunAttempt[]
+  lockedRuns     TaskRun[]
+  files          BackgroundWorkerFile[]
+  queues         TaskQueue[]
+  promptVersions PromptVersion[]
 
   deployment WorkerDeployment?
 
@@ -515,6 +544,73 @@ model BackgroundWorkerFile {
   @@unique([projectId, contentHash])
 }
 
+model Prompt {
+  id          String  @id @default(cuid())
+  friendlyId  String  @unique @map("friendly_id")
+  slug        String
+  description String?
+  type        String  @default("text") // "text" | "chat"
+
+  organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationId String
+
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String
+
+  runtimeEnvironment   RuntimeEnvironment @relation(fields: [runtimeEnvironmentId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  runtimeEnvironmentId String
+
+  filePath       String?
+  exportName     String?
+  variableSchema Json?
+  defaultModel   String?
+  defaultConfig  Json?
+
+  tags       String[]  @default([])
+  archivedAt DateTime?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  versions PromptVersion[]
+
+  @@unique([projectId, runtimeEnvironmentId, slug])
+  @@index([projectId])
+  @@index([runtimeEnvironmentId])
+  @@map("prompts")
+}
+
+model PromptVersion {
+  id      String @id @default(cuid())
+  version Int
+
+  prompt   Prompt @relation(fields: [promptId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  promptId String
+
+  textContent String?
+  chatContent Json?
+
+  model  String?
+  config Json?
+
+  source        String // "deploy" | "dashboard" | "api"
+  commitMessage String?
+  contentHash   String
+
+  labels String[] @default([])
+
+  worker   BackgroundWorker? @relation(fields: [workerId], references: [id])
+  workerId String?
+
+  createdBy String?
+  createdAt DateTime @default(now())
+
+  @@unique([promptId, version])
+  @@index([promptId])
+  @@index([contentHash])
+  @@map("prompt_versions")
+}
+
 model BackgroundWorkerTask {
   id   String @id @default(cuid())
   slug String
@@ -553,6 +649,8 @@ model BackgroundWorkerTask {
 
   maxDurationInSeconds Int?
 
+  ttl String?
+
   triggerSource TaskTriggerSource @default(STANDARD)
 
   payloadSchema Json?
@@ -581,11 +679,13 @@ model TaskRun {
 
   idempotencyKey          String?
   idempotencyKeyExpiresAt DateTime?
+  /// Stores the user-provided key and scope: { key: string, scope: "run" | "attempt" | "global" }
+  idempotencyKeyOptions   Json?
 
   /// Debounce options: { key: string, delay: string, createdAt: Date }
   debounce Json?
 
-  taskIdentifier          String
+  taskIdentifier String
 
   isTest Boolean @default(false)
 
@@ -747,6 +847,12 @@ model TaskRun {
   metadataType    String  @default("application/json")
   metadataVersion Int     @default(1)
 
+  /// Structured annotations: triggerSource, triggerAction, rootTriggerSource, rootScheduleId
+  annotations Json?
+
+  /// Whether the latest attempt was a warm start. Null until first attempt starts.
+  isWarmStart Boolean?
+
   /// Run output
   output     String?
   outputType String  @default("application/json")
@@ -768,10 +874,6 @@ model TaskRun {
   @@unique([runtimeEnvironmentId, taskIdentifier, idempotencyKey])
   // Finding child runs
   @@index([parentTaskRunId])
-  // Finding ancestor runs
-  @@index([rootTaskRunId])
-  //Schedules
-  @@index([scheduleId])
   // Run page inspector
   @@index([spanId])
   @@index([parentSpanId])
@@ -780,8 +882,6 @@ model TaskRun {
   // Finding runs in a batch
   @@index([runTags(ops: ArrayOps)], type: Gin)
   @@index([runtimeEnvironmentId, batchId])
-  // This will include the createdAt index to help speed up the run list page
-  @@index([runtimeEnvironmentId, id(sort: Desc)])
   @@index([runtimeEnvironmentId, createdAt(sort: Desc)])
   @@index([createdAt], type: Brin)
   @@index([status, runtimeEnvironmentId, createdAt, id(sort: Desc)])
@@ -997,6 +1097,7 @@ model TaskRunCheckpoint {
 enum TaskRunCheckpointType {
   DOCKER
   KUBERNETES
+  COMPUTE
 }
 
 /// A Waitpoint blocks a run from continuing until it's completed
@@ -1140,6 +1241,9 @@ model FeatureFlag {
 
   key   String @unique
   value Json?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
 }
 
 model WorkerInstance {
@@ -1183,6 +1287,11 @@ enum WorkerInstanceGroupType {
   UNMANAGED
 }
 
+enum WorkloadType {
+  CONTAINER
+  MICROVM
+}
+
 model WorkerInstanceGroup {
   id   String                  @id @default(cuid())
   type WorkerInstanceGroupType
@@ -1217,6 +1326,12 @@ model WorkerInstanceGroup {
   location      String?
   staticIPs     String?
 
+  workloadType WorkloadType @default(CONTAINER)
+
+  /// When true, runs enqueued to this worker queue may skip the intermediate queue
+  /// and be pushed directly to the worker queue when concurrency is available.
+  enableFastPath Boolean @default(false)
+
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 }
@@ -1699,6 +1814,9 @@ model EnvironmentVariableValue {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
+  version       Int   @default(1)
+  lastUpdatedBy Json?
+
   @@unique([variableId, environmentId])
 }
 
@@ -1815,6 +1933,7 @@ model WorkerDeployment {
   triggeredBy   User?   @relation(fields: [triggeredById], references: [id], onDelete: SetNull, onUpdate: Cascade)
   triggeredById String?
   triggeredVia  String?
+  commitSHA     String?
 
   startedAt   DateTime?
   installedAt DateTime?
@@ -1833,12 +1952,14 @@ model WorkerDeployment {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  promotions     WorkerDeploymentPromotion[]
-  alerts         ProjectAlert[]
-  workerInstance WorkerInstance[]
+  promotions             WorkerDeploymentPromotion[]
+  alerts                 ProjectAlert[]
+  workerInstance         WorkerInstance[]
+  integrationDeployments IntegrationDeployment[]
 
   @@unique([projectId, shortCode])
   @@unique([environmentId, version])
+  @@index([commitSHA])
 }
 
 enum WorkerDeploymentStatus {
@@ -1938,6 +2059,9 @@ model TaskScheduleInstance {
   environment   RuntimeEnvironment @relation(fields: [environmentId], references: [id], onDelete: Cascade, onUpdate: Cascade)
   environmentId String
 
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String
+
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
@@ -1948,6 +2072,8 @@ model TaskScheduleInstance {
 
   //you can only have a schedule attached to each environment once
   @@unique([taskScheduleId, environmentId])
+  @@index([environmentId])
+  @@index([projectId, active])
 }
 
 model RuntimeEnvironmentSession {
@@ -1985,6 +2111,8 @@ model ProjectAlertChannel {
   alertTypes       ProjectAlertType[]
   environmentTypes RuntimeEnvironmentType[] @default([STAGING, PRODUCTION])
 
+  errorAlertConfig Json?
+
   project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
   projectId String
 
@@ -2039,6 +2167,7 @@ enum ProjectAlertType {
   TASK_RUN_ATTEMPT
   DEPLOYMENT_FAILURE
   DEPLOYMENT_SUCCESS
+  ERROR_GROUP
 }
 
 enum ProjectAlertStatus {
@@ -2070,7 +2199,8 @@ model OrganizationIntegration {
 
   friendlyId String @unique
 
-  service IntegrationService
+  service                IntegrationService
+  externalOrganizationId String? /// Identifier for external, integration's organization (e.g. Vercel's team)
 
   integrationData Json
 
@@ -2080,14 +2210,41 @@ model OrganizationIntegration {
   organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
   organizationId String
 
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @updatedAt
+  deletedAt DateTime?
+
+  alertChannels                  ProjectAlertChannel[]
+  organizationProjectIntegration OrganizationProjectIntegration[]
 
-  alertChannels ProjectAlertChannel[]
+  @@index([externalOrganizationId])
+}
+
+model OrganizationProjectIntegration {
+  id String @id @default(cuid())
+
+  organizationIntegration   OrganizationIntegration @relation(fields: [organizationIntegrationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationIntegrationId String
+
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String
+
+  externalEntityId String /// Identifier for webhooks, for example Vercel's projectId
+  integrationData  Json /// Save useful data like config or external entity name
+  installedBy      String? /// UserId who installed the integration
+
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @updatedAt
+  deletedAt DateTime?
+
+  @@index([projectId])
+  @@index([projectId, organizationIntegrationId])
+  @@index([externalEntityId])
 }
 
 enum IntegrationService {
   SLACK
+  VERCEL
 }
 
 /// Bulk actions, like canceling and replaying runs
@@ -2383,3 +2540,380 @@ model ConnectedGithubRepository {
   @@unique([projectId])
   @@index([repositoryId])
 }
+
+enum ImpersonationAuditLogAction {
+  START
+  STOP
+}
+
+model ImpersonationAuditLog {
+  id String @id @default(cuid())
+
+  action ImpersonationAuditLogAction
+
+  /// The admin user who initiated/ended the impersonation
+  admin   User   @relation("ImpersonationAdmin", fields: [adminId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  adminId String
+
+  /// The user being impersonated
+  target   User   @relation("ImpersonationTarget", fields: [targetId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  targetId String
+
+  ipAddress String?
+
+  createdAt DateTime @default(now())
+
+  @@index([adminId])
+  @@index([targetId])
+  @@index([createdAt])
+}
+
+enum CustomerQuerySource {
+  DASHBOARD
+  API
+}
+
+enum CustomerQueryScope {
+  ORGANIZATION
+  PROJECT
+  ENVIRONMENT
+}
+
+model CustomerQuery {
+  id String @id @default(cuid())
+
+  /// The TSQL query text that was executed
+  query String
+
+  /// The scope of the query (determines which tenant IDs were used)
+  scope CustomerQueryScope
+
+  /// Query execution statistics from ClickHouse
+  stats Json
+
+  /// AI-generated title summarizing the query
+  title String?
+
+  /// Where the query originated from
+  source CustomerQuerySource @default(DASHBOARD)
+
+  organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationId String
+
+  project   Project? @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String?
+
+  environment   RuntimeEnvironment? @relation(fields: [environmentId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  environmentId String?
+
+  /// Optional user who executed the query (null for API calls)
+  user   User?   @relation(fields: [userId], references: [id], onDelete: SetNull, onUpdate: Cascade)
+  userId String?
+
+  /// Time filter settings used when the query was executed
+  /// Period like "7d", "24h", etc.
+  filterPeriod String?
+  /// Custom start date (ISO 8601)
+  filterFrom   DateTime?
+  /// Custom end date (ISO 8601)
+  filterTo     DateTime?
+
+  createdAt DateTime @default(now())
+
+  /// Fast lookup for history menu (most recent 20 per org)
+  @@index([organizationId, createdAt(sort: Desc)])
+  /// For Stripe metering job - find unprocessed queries
+  @@index([createdAt])
+}
+
+model IntegrationDeployment {
+  id String @id @default(cuid())
+
+  integrationName         String /// For example Vercel
+  integrationDeploymentId String /// External ID
+  commitSHA               String
+  deploymentId            String?
+  status                  String? /// External deployment status
+
+  workerDeployment WorkerDeployment? @relation(fields: [deploymentId], references: [id], onDelete: SetNull, onUpdate: Cascade)
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([commitSHA])
+  @@index([deploymentId])
+}
+
+/// A user-defined metrics dashboard
+model MetricsDashboard {
+  id String @id @default(cuid())
+
+  friendlyId String @unique
+
+  title       String
+  description String @default("")
+
+  organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationId String
+
+  project   Project? @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String?
+
+  /// Who created the dashboard
+  owner   User?   @relation(fields: [ownerId], references: [id], onDelete: SetNull, onUpdate: Cascade)
+  ownerId String?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  /// JSON that defines the config, queries, layout and config of all widgets. 
+  /// There will be a version field for the format.
+  layout String
+
+  /// Fast lookup for the list
+  @@index([projectId, createdAt(sort: Desc)])
+}
+
+// ====================================================
+// LLM Pricing Models
+// ====================================================
+
+/// A known LLM model or model pattern for cost tracking
+model LlmModel {
+  id           String    @id @default(cuid())
+  friendlyId   String    @unique @map("friendly_id")
+  projectId    String?   @map("project_id")
+  project      Project?  @relation(fields: [projectId], references: [id], onDelete: Cascade)
+  modelName    String    @map("model_name")
+  matchPattern String    @map("match_pattern")
+  startDate    DateTime? @map("start_date")
+  source       String    @default("default") // "default", "admin", "project"
+  createdAt    DateTime  @default(now()) @map("created_at")
+  updatedAt    DateTime  @updatedAt @map("updated_at")
+
+  // Catalog metadata for model registry
+  provider        String?  @map("provider")
+  description     String?  @map("description")
+  contextWindow   Int?     @map("context_window")
+  maxOutputTokens Int?     @map("max_output_tokens")
+  capabilities    String[] @default([]) @map("capabilities")
+  isHidden        Boolean  @default(false) @map("is_hidden")
+  baseModelName   String?  @map("base_model_name")
+
+  pricingTiers LlmPricingTier[]
+  prices       LlmPrice[]
+
+  @@unique([projectId, modelName, startDate])
+  @@index([projectId])
+  @@map("llm_models")
+}
+
+/// A pricing tier for a model (supports volume-based or conditional pricing)
+model LlmPricingTier {
+  id         String   @id @default(cuid())
+  modelId    String   @map("model_id")
+  model      LlmModel @relation(fields: [modelId], references: [id], onDelete: Cascade)
+  name       String
+  isDefault  Boolean  @default(true) @map("is_default")
+  priority   Int      @default(0)
+  conditions Json     @default("[]") @db.JsonB
+
+  prices LlmPrice[]
+
+  @@unique([modelId, priority])
+  @@unique([modelId, name])
+  @@map("llm_pricing_tiers")
+}
+
+/// A price point for a usage type within a pricing tier
+model LlmPrice {
+  id            String         @id @default(cuid())
+  modelId       String         @map("model_id")
+  model         LlmModel       @relation(fields: [modelId], references: [id], onDelete: Cascade)
+  pricingTierId String         @map("pricing_tier_id")
+  pricingTier   LlmPricingTier @relation(fields: [pricingTierId], references: [id], onDelete: Cascade)
+  usageType     String         @map("usage_type")
+  price         Decimal        @db.Decimal(20, 12)
+
+  @@unique([modelId, usageType, pricingTierId])
+  @@map("llm_prices")
+}
+
+enum PlatformNotificationSurface {
+  WEBAPP
+  CLI
+}
+
+enum PlatformNotificationScope {
+  USER
+  PROJECT
+  ORGANIZATION
+  GLOBAL
+}
+
+/// Admin-created notification definitions
+model PlatformNotification {
+  id String @id @default(cuid())
+
+  friendlyId String @unique @default(cuid())
+
+  /// Admin-facing title for identification in admin tools
+  title String
+
+  /// Versioned JSON rendering content (see payload schema in spec)
+  payload Json
+
+  surface PlatformNotificationSurface
+  scope   PlatformNotificationScope
+
+  /// Set when scope = USER
+  user   User?   @relation(fields: [userId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  userId String?
+
+  /// Set when scope = ORGANIZATION
+  organization   Organization? @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationId String?
+
+  /// Set when scope = PROJECT
+  project   Project? @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String?
+
+  /// When notification becomes active
+  startsAt DateTime
+
+  /// When notification expires
+  endsAt DateTime
+
+  /// CLI: auto-expire N days after user first saw it
+  cliMaxDaysAfterFirstSeen Int?
+
+  /// CLI: auto-expire after shown N times to user
+  cliMaxShowCount Int?
+
+  /// CLI: only show every N-th request (e.g. cliShowEvery=3 means show on 3rd, 6th, 9th…)
+  cliShowEvery Int?
+
+  /// Ordering within same scope level (higher = more important)
+  priority Int @default(0)
+
+  /// Soft delete
+  archivedAt DateTime?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  interactions PlatformNotificationInteraction[]
+
+  @@index([surface, scope, startsAt])
+}
+
+/// Per-user tracking of notification views and dismissals
+model PlatformNotificationInteraction {
+  id String @id @default(cuid())
+
+  notification   PlatformNotification @relation(fields: [notificationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  notificationId String
+
+  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  userId String
+
+  /// Set by beacon/CLI GET on first impression
+  firstSeenAt DateTime @default(now())
+
+  /// Times shown (incremented per beacon/CLI view)
+  showCount Int @default(1)
+
+  /// User dismissed in webapp
+  webappDismissedAt DateTime?
+
+  /// User clicked a link in webapp
+  webappClickedAt DateTime?
+
+  /// Auto-dismissed or expired in CLI
+  cliDismissedAt DateTime?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([notificationId, userId])
+}
+
+enum ErrorGroupStatus {
+  UNRESOLVED
+  RESOLVED
+  IGNORED
+}
+
+/**
+ * Error group state is used to track when a user has interacted with an error (ignored/resolved)
+ * The actual error data is in ClickHouse.
+ */
+model ErrorGroupState {
+  id String @id @default(cuid())
+
+  organization   Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  organizationId String
+
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  projectId String
+
+  /**
+   * You can ignore/resolve an error across all environments, or specific ones
+   */
+  environment   RuntimeEnvironment? @relation(fields: [environmentId], references: [id], onDelete: Cascade, onUpdate: Cascade)
+  environmentId String?
+
+  taskIdentifier   String
+  errorFingerprint String
+
+  status ErrorGroupStatus @default(UNRESOLVED)
+
+  /**
+   * Error is ignored until this date
+   */
+  ignoredUntil                 DateTime?
+  /**
+   * Error is ignored until this occurrence rate
+   */
+  ignoredUntilOccurrenceRate   Int?
+  /**
+   * Error is ignored until this total occurrences
+   */
+  ignoredUntilTotalOccurrences Int?
+
+  /// Total occurrence count at the time the error was ignored (from ClickHouse).
+  /// Used with ignoredUntilTotalOccurrences to compute occurrences since ignoring.
+  ignoredAtOccurrenceCount BigInt?
+
+  /**
+   * Error was ignored at this date
+   */
+  ignoredAt       DateTime?
+  /**
+   * Reason for ignoring the error
+   */
+  ignoredReason   String?
+  /**
+   * User who ignored the error
+   */
+  ignoredByUserId String?
+
+  /**
+   * Error was resolved at this date
+   */
+  resolvedAt        DateTime?
+  /**
+   * Error was resolved in this version
+   */
+  resolvedInVersion String?
+  /**
+   * User who resolved the error
+   */
+  resolvedBy        String?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([environmentId, taskIdentifier, errorFingerprint])
+  @@index([environmentId, status])
+}
diff --git a/internal-packages/emails/emails/alert-error-group.tsx b/internal-packages/emails/emails/alert-error-group.tsx
new file mode 100644
index 00000000000..f584f06edba
--- /dev/null
+++ b/internal-packages/emails/emails/alert-error-group.tsx
@@ -0,0 +1,114 @@
+import {
+  Body,
+  CodeBlock,
+  Container,
+  Head,
+  Html,
+  Link,
+  Preview,
+  Text,
+  dracula,
+} from "@react-email/components";
+import { z } from "zod";
+import { Footer } from "./components/Footer";
+import { Image } from "./components/Image";
+import { anchor, container, h1, main, paragraphLight, paragraphTight } from "./components/styles";
+import React from "react";
+
+export const AlertErrorGroupEmailSchema = z.object({
+  email: z.literal("alert-error-group"),
+  classification: z.enum(["new_issue", "regression", "unignored"]),
+  taskIdentifier: z.string(),
+  environment: z.string(),
+  error: z.object({
+    message: z.string(),
+    type: z.string().optional(),
+    stackTrace: z.string().optional(),
+  }),
+  occurrenceCount: z.number(),
+  errorLink: z.string().url(),
+  organization: z.string(),
+  project: z.string(),
+});
+
+type AlertErrorGroupEmailProps = z.infer<typeof AlertErrorGroupEmailSchema>;
+
+const classificationLabels: Record<string, string> = {
+  new_issue: "New error",
+  regression: "Regression",
+  unignored: "Error resurfaced",
+};
+
+const previewDefaults: AlertErrorGroupEmailProps = {
+  email: "alert-error-group",
+  classification: "new_issue",
+  taskIdentifier: "my-task",
+  environment: "Production",
+  error: {
+    message: "Cannot read property 'foo' of undefined",
+    type: "TypeError",
+    stackTrace: "TypeError: Cannot read property 'foo' of undefined\n    at Object.<anonymous>",
+  },
+  occurrenceCount: 42,
+  errorLink: "https://trigger.dev",
+  organization: "my-organization",
+  project: "my-project",
+};
+
+export default function Email(props: AlertErrorGroupEmailProps) {
+  const {
+    classification,
+    taskIdentifier,
+    environment,
+    error,
+    occurrenceCount,
+    errorLink,
+    organization,
+    project,
+  } = {
+    ...previewDefaults,
+    ...props,
+  };
+
+  const label = classificationLabels[classification] ?? "Error alert";
+
+  return (
+    <Html>
+      <Head />
+      <Preview>
+        {`${organization}: [${label}] ${error.type ?? "Error"} in ${taskIdentifier} (${environment})`}
+      </Preview>
+      <Body style={main}>
+        <Container style={container}>
+          <Text style={h1}>
+            {label}: {error.type ?? "Error"} in {taskIdentifier}
+          </Text>
+          <Text style={paragraphTight}>Organization: {organization}</Text>
+          <Text style={paragraphTight}>Project: {project}</Text>
+          <Text style={paragraphTight}>Task: {taskIdentifier}</Text>
+          <Text style={paragraphTight}>Environment: {environment}</Text>
+          <Text style={paragraphTight}>Occurrences: {occurrenceCount}</Text>
+
+          <Text style={paragraphLight}>{error.message}</Text>
+          {error.stackTrace && (
+            <CodeBlock code={error.stackTrace} theme={dracula} lineNumbers language="log" />
+          )}
+          <Link
+            href={errorLink}
+            target="_blank"
+            style={{
+              ...anchor,
+              display: "block",
+              marginBottom: "50px",
+            }}
+          >
+            Investigate this error
+          </Link>
+
+          <Image path="/emails/logo-mono.png" width="120" height="22" alt="Trigger.dev" />
+          <Footer />
+        </Container>
+      </Body>
+    </Html>
+  );
+}
diff --git a/internal-packages/emails/emails/deployment-failure.tsx b/internal-packages/emails/emails/deployment-failure.tsx
index 476208360b2..c4cf363c2e7 100644
--- a/internal-packages/emails/emails/deployment-failure.tsx
+++ b/internal-packages/emails/emails/deployment-failure.tsx
@@ -1,18 +1,20 @@
 import {
   Body,
   CodeBlock,
+  Column,
   Container,
   Head,
   Html,
   Link,
   Preview,
+  Row,
   Text,
   dracula,
 } from "@react-email/components";
 import { z } from "zod";
 import { Footer } from "./components/Footer";
 import { Image } from "./components/Image";
-import { anchor, container, h1, main, paragraphLight } from "./components/styles";
+import { anchor, bullets, container, grey, h1, main, paragraphLight } from "./components/styles";
 
 export const AlertDeploymentFailureEmailSchema = z.object({
   email: z.literal("alert-deployment-failure"),
@@ -27,6 +29,19 @@ export const AlertDeploymentFailureEmailSchema = z.object({
     stack: z.string().optional(),
   }),
   deploymentLink: z.string().url(),
+  git: z
+    .object({
+      branchName: z.string(),
+      shortSha: z.string(),
+      commitMessage: z.string(),
+      commitUrl: z.string(),
+      branchUrl: z.string(),
+      pullRequestNumber: z.number().optional(),
+      pullRequestTitle: z.string().optional(),
+      pullRequestUrl: z.string().optional(),
+    })
+    .optional(),
+  vercelDeploymentUrl: z.string().url().optional(),
 });
 
 const previewDefaults = {
@@ -40,10 +55,31 @@ const previewDefaults = {
     stack: "Error: Something went wrong\n    at main.ts:12:34",
   },
   deploymentLink: "https://trigger.dev",
+  git: {
+    branchName: "feat/new-feature",
+    shortSha: "abc1234",
+    commitMessage: "Add new background task for processing uploads",
+    commitUrl: "https://github.com/acme/app/commit/abc1234",
+    branchUrl: "https://github.com/acme/app/tree/feat/new-feature",
+    pullRequestNumber: 42,
+    pullRequestTitle: "Add upload processing",
+    pullRequestUrl: "https://github.com/acme/app/pull/42",
+  },
+  vercelDeploymentUrl: "https://vercel.com/acme/app/abc1234",
 };
 
 export default function Email(props: z.infer<typeof AlertDeploymentFailureEmailSchema>) {
-  const { version, environment, organization, shortCode, failedAt, error, deploymentLink } = {
+  const {
+    version,
+    environment,
+    organization,
+    shortCode,
+    failedAt,
+    error,
+    deploymentLink,
+    git,
+    vercelDeploymentUrl,
+  } = {
     ...previewDefaults,
     ...props,
   };
@@ -63,6 +99,7 @@ export default function Email(props: z.infer<typeof AlertDeploymentFailureEmailS
           {error.stack && (
             <CodeBlock code={error.stack} theme={dracula} lineNumbers language="log" />
           )}
+
           <Link
             href={deploymentLink}
             target="_blank"
@@ -75,6 +112,49 @@ export default function Email(props: z.infer<typeof AlertDeploymentFailureEmailS
             Investigate this error
           </Link>
 
+          {git && (
+            <>
+              <Row>
+                <Column style={{ ...bullets, width: "33%" }}>Branch</Column>
+                <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                  <Link href={git.branchUrl} style={anchor}>
+                    {git.branchName}
+                  </Link>
+                </Column>
+              </Row>
+              <Row>
+                <Column style={{ ...bullets, width: "33%" }}>Commit</Column>
+                <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                  <Link href={git.commitUrl} style={anchor}>
+                    {git.shortSha}
+                  </Link>{" "}
+                  {git.commitMessage}
+                </Column>
+              </Row>
+              {git.pullRequestNumber && git.pullRequestUrl && (
+                <Row>
+                  <Column style={{ ...bullets, width: "33%" }}>Pull Request</Column>
+                  <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                    <Link href={git.pullRequestUrl} style={anchor}>
+                      #{git.pullRequestNumber}
+                    </Link>
+                    {git.pullRequestTitle ? ` ${git.pullRequestTitle}` : ""}
+                  </Column>
+                </Row>
+              )}
+            </>
+          )}
+          {vercelDeploymentUrl && (
+            <Row>
+              <Column style={{ ...bullets, width: "33%" }}>Vercel</Column>
+              <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                <Link href={vercelDeploymentUrl} style={anchor}>
+                  View Vercel Deployment
+                </Link>
+              </Column>
+            </Row>
+          )}
+
           <Image path="/emails/logo-mono.png" width="120" height="22" alt="Trigger.dev" />
           <Footer />
         </Container>
diff --git a/internal-packages/emails/emails/deployment-success.tsx b/internal-packages/emails/emails/deployment-success.tsx
index ab54d4c282c..5a2a090cbfc 100644
--- a/internal-packages/emails/emails/deployment-success.tsx
+++ b/internal-packages/emails/emails/deployment-success.tsx
@@ -1,8 +1,18 @@
-import { Body, Container, Head, Html, Link, Preview, Text } from "@react-email/components";
+import {
+  Body,
+  Column,
+  Container,
+  Head,
+  Html,
+  Link,
+  Preview,
+  Row,
+  Text,
+} from "@react-email/components";
 import { z } from "zod";
 import { Footer } from "./components/Footer";
 import { Image } from "./components/Image";
-import { anchor, container, h1, main } from "./components/styles";
+import { anchor, bullets, container, grey, h1, main } from "./components/styles";
 
 export const AlertDeploymentSuccessEmailSchema = z.object({
   email: z.literal("alert-deployment-success"),
@@ -13,6 +23,19 @@ export const AlertDeploymentSuccessEmailSchema = z.object({
   deployedAt: z.date(),
   taskCount: z.number(),
   deploymentLink: z.string().url(),
+  git: z
+    .object({
+      branchName: z.string(),
+      shortSha: z.string(),
+      commitMessage: z.string(),
+      commitUrl: z.string(),
+      branchUrl: z.string(),
+      pullRequestNumber: z.number().optional(),
+      pullRequestTitle: z.string().optional(),
+      pullRequestUrl: z.string().optional(),
+    })
+    .optional(),
+  vercelDeploymentUrl: z.string().url().optional(),
 });
 
 const previewDefaults = {
@@ -23,10 +46,31 @@ const previewDefaults = {
   deployedAt: new Date().toISOString(),
   taskCount: 3,
   deploymentLink: "https://trigger.dev",
+  git: {
+    branchName: "feat/new-feature",
+    shortSha: "abc1234",
+    commitMessage: "Add new background task for processing uploads",
+    commitUrl: "https://github.com/acme/app/commit/abc1234",
+    branchUrl: "https://github.com/acme/app/tree/feat/new-feature",
+    pullRequestNumber: 42,
+    pullRequestTitle: "Add upload processing",
+    pullRequestUrl: "https://github.com/acme/app/pull/42",
+  },
+  vercelDeploymentUrl: "https://vercel.com/acme/app/abc1234",
 };
 
 export default function Email(props: z.infer<typeof AlertDeploymentSuccessEmailSchema>) {
-  const { version, environment, organization, shortCode, deployedAt, taskCount, deploymentLink } = {
+  const {
+    version,
+    environment,
+    organization,
+    shortCode,
+    deployedAt,
+    taskCount,
+    deploymentLink,
+    git,
+    vercelDeploymentUrl,
+  } = {
     ...previewDefaults,
     ...props,
   };
@@ -53,6 +97,49 @@ export default function Email(props: z.infer<typeof AlertDeploymentSuccessEmailS
             View Deployment
           </Link>
 
+          {git && (
+            <>
+              <Row>
+                <Column style={{ ...bullets, width: "33%" }}>Branch</Column>
+                <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                  <Link href={git.branchUrl} style={anchor}>
+                    {git.branchName}
+                  </Link>
+                </Column>
+              </Row>
+              <Row>
+                <Column style={{ ...bullets, width: "33%" }}>Commit</Column>
+                <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                  <Link href={git.commitUrl} style={anchor}>
+                    {git.shortSha}
+                  </Link>{" "}
+                  {git.commitMessage}
+                </Column>
+              </Row>
+              {git.pullRequestNumber && git.pullRequestUrl && (
+                <Row>
+                  <Column style={{ ...bullets, width: "33%" }}>Pull Request</Column>
+                  <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                    <Link href={git.pullRequestUrl} style={anchor}>
+                      #{git.pullRequestNumber}
+                    </Link>
+                    {git.pullRequestTitle ? ` ${git.pullRequestTitle}` : ""}
+                  </Column>
+                </Row>
+              )}
+            </>
+          )}
+          {vercelDeploymentUrl && (
+            <Row>
+              <Column style={{ ...bullets, width: "33%" }}>Vercel</Column>
+              <Column style={{ ...bullets, ...grey, width: "66%" }}>
+                <Link href={vercelDeploymentUrl} style={anchor}>
+                  View Vercel Deployment
+                </Link>
+              </Column>
+            </Row>
+          )}
+
           <Image path="/emails/logo-mono.png" width="120" height="22" alt="Trigger.dev" />
           <Footer />
         </Container>
diff --git a/internal-packages/emails/src/index.tsx b/internal-packages/emails/src/index.tsx
index e43e60f3f4c..a1bd00d03cf 100644
--- a/internal-packages/emails/src/index.tsx
+++ b/internal-packages/emails/src/index.tsx
@@ -2,6 +2,9 @@ import { ReactElement } from "react";
 
 import { z } from "zod";
 import AlertAttemptFailureEmail, { AlertAttemptEmailSchema } from "../emails/alert-attempt-failure";
+import AlertErrorGroupEmail, {
+  AlertErrorGroupEmailSchema,
+} from "../emails/alert-error-group";
 import AlertRunFailureEmail, { AlertRunEmailSchema } from "../emails/alert-run-failure";
 import { setGlobalBasePath } from "../emails/components/BasePath";
 import AlertDeploymentFailureEmail, {
@@ -31,6 +34,7 @@ export const DeliverEmailSchema = z
     InviteEmailSchema,
     AlertRunEmailSchema,
     AlertAttemptEmailSchema,
+    AlertErrorGroupEmailSchema,
     AlertDeploymentFailureEmailSchema,
     AlertDeploymentSuccessEmailSchema,
     MfaEnabledEmailSchema,
@@ -114,6 +118,18 @@ export class EmailClient {
           component: <AlertRunFailureEmail {...data} />,
         };
       }
+      case "alert-error-group": {
+        const classLabel =
+          data.classification === "new_issue"
+            ? "New error"
+            : data.classification === "regression"
+              ? "Regression"
+              : "Error resurfaced";
+        return {
+          subject: `[${data.organization}] ${classLabel}: ${data.error.type ?? "Error"} in ${data.taskIdentifier} [${data.environment}]`,
+          component: <AlertErrorGroupEmail {...data} />,
+        };
+      }
       case "alert-deployment-failure": {
         return {
           subject: `[${data.organization}] Deployment ${data.version} [${data.environment}] failed: ${data.error.name}`,
diff --git a/internal-packages/llm-model-catalog/package.json b/internal-packages/llm-model-catalog/package.json
new file mode 100644
index 00000000000..ac5cdafc0a6
--- /dev/null
+++ b/internal-packages/llm-model-catalog/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@internal/llm-model-catalog",
+  "private": true,
+  "version": "0.0.1",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "type": "module",
+  "dependencies": {
+    "@trigger.dev/core": "workspace:*",
+    "@trigger.dev/database": "workspace:*"
+  },
+  "devDependencies": {
+    "@internal/testcontainers": "workspace:*",
+    "vitest": "3.1.4"
+  },
+  "scripts": {
+    "test": "vitest --sequence.concurrent=false --no-file-parallelism",
+    "typecheck": "tsc --noEmit",
+    "generate": "node scripts/generate.mjs",
+    "sync-prices": "bash scripts/sync-model-prices.sh && node scripts/generate.mjs",
+    "sync-prices:check": "bash scripts/sync-model-prices.sh --check",
+    "generate-catalog": "bash scripts/generate-model-catalog.sh && node scripts/generate.mjs",
+    "generate-catalog:dry-run": "bash scripts/generate-model-catalog.sh --dry-run"
+  }
+}
diff --git a/internal-packages/llm-model-catalog/scripts/.gitignore b/internal-packages/llm-model-catalog/scripts/.gitignore
new file mode 100644
index 00000000000..333c1e910a3
--- /dev/null
+++ b/internal-packages/llm-model-catalog/scripts/.gitignore
@@ -0,0 +1 @@
+logs/
diff --git a/internal-packages/llm-model-catalog/scripts/generate-model-catalog.sh b/internal-packages/llm-model-catalog/scripts/generate-model-catalog.sh
new file mode 100755
index 00000000000..c1d945e04b3
--- /dev/null
+++ b/internal-packages/llm-model-catalog/scripts/generate-model-catalog.sh
@@ -0,0 +1,346 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Generate model-catalog.json by researching each unique base model using Claude Code CLI.
+# Usage: ./scripts/generate-model-catalog.sh [options]
+#
+# Options:
+#   --dry-run            Print models that would be researched without running Claude
+#   --filter <pattern>   Only research models matching this ERE pattern (e.g. "gpt-4o|claude")
+#   --max <n>            Maximum number of models to research (useful for testing)
+#   --stale-days <n>     Re-research models older than N days (default: 7)
+#   --force              Re-research all models regardless of resolvedAt timestamp
+#   --skip-hidden        Skip models already marked as hidden/deprecated (saves time)
+#   --concurrency <n>    Number of models to research in parallel (default: 5)
+#
+# The script:
+# 1. Extracts all modelNames from defaultPrices.ts
+# 2. Groups dated variants to their base model
+# 3. Runs research-model.sh for each base model (in parallel)
+# 4. Writes results incrementally to model-catalog.json
+#
+# Logs are written to scripts/logs/ for debugging failures.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
+DEFAULTS_FILE="$PACKAGE_DIR/src/defaultPrices.ts"
+CATALOG_FILE="$PACKAGE_DIR/src/model-catalog.json"
+RESEARCH_SCRIPT="$SCRIPT_DIR/research-model.sh"
+
+LOG_DIR="$SCRIPT_DIR/logs"
+mkdir -p "$LOG_DIR"
+
+DRY_RUN=false
+FILTER=""
+MAX_MODELS=0
+STALE_DAYS=7
+FORCE=false
+SKIP_HIDDEN=false
+CONCURRENCY=5
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --dry-run) DRY_RUN=true; shift ;;
+    --filter) FILTER="$2"; shift 2 ;;
+    --max) MAX_MODELS="$2"; shift 2 ;;
+    --stale-days) STALE_DAYS="$2"; shift 2 ;;
+    --force) FORCE=true; shift ;;
+    --skip-hidden) SKIP_HIDDEN=true; shift ;;
+    --concurrency) CONCURRENCY="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Extract all model names from defaultPrices.ts
+ALL_MODELS=$(grep -o '"modelName": "[^"]*"' "$DEFAULTS_FILE" | sed 's/"modelName": "//;s/"//' | sort -u)
+
+# Skip embedding, legacy completion, and fine-tuned models
+SKIP_PATTERNS="^text-embedding|^textembedding|^text-ada|^text-babbage|^text-curie|^text-davinci|^text-bison|^text-unicorn|^code-bison|^code-gecko|^codechat-bison|^chat-bison|^babbage-002|^davinci-002|^ft:|^gemini-live"
+
+FILTERED_MODELS=$(echo "$ALL_MODELS" | grep -vE "$SKIP_PATTERNS")
+
+if [[ -n "$FILTER" ]]; then
+  FILTERED_MODELS=$(echo "$FILTERED_MODELS" | grep -E "$FILTER" || true)
+fi
+
+# Group dated variants to base models
+declare -A BASE_TO_VARIANTS
+declare -A MODEL_TO_BASE
+
+for model in $FILTERED_MODELS; do
+  base=$(echo "$model" | sed -E 's/-[0-9]{4}-?[0-9]{2}-?[0-9]{2}$//')
+  base_no_latest=$(echo "$base" | sed -E 's/-latest$//')
+  if [[ ${#base_no_latest} -lt ${#base} ]]; then
+    base="$base_no_latest"
+  fi
+
+  MODEL_TO_BASE["$model"]="$base"
+
+  if [[ -n "${BASE_TO_VARIANTS[$base]:-}" ]]; then
+    BASE_TO_VARIANTS["$base"]="${BASE_TO_VARIANTS[$base]} $model"
+  else
+    BASE_TO_VARIANTS["$base"]="$model"
+  fi
+done
+
+BASE_MODELS=$(printf '%s\n' "${!BASE_TO_VARIANTS[@]}" | sort -u)
+TOTAL=$(echo "$BASE_MODELS" | wc -l | tr -d ' ')
+
+if [[ "$MAX_MODELS" -gt 0 ]]; then
+  BASE_MODELS=$(echo "$BASE_MODELS" | head -n "$MAX_MODELS")
+  TOTAL=$(echo "$BASE_MODELS" | wc -l | tr -d ' ')
+fi
+
+echo "Found $TOTAL unique base models (concurrency: $CONCURRENCY)"
+
+if $DRY_RUN; then
+  echo ""
+  echo "Base models and their variants:"
+  for base in $BASE_MODELS; do
+    echo "  $base → ${BASE_TO_VARIANTS[$base]}"
+  done
+  exit 0
+fi
+
+# Load existing catalog
+if [[ -f "$CATALOG_FILE" ]]; then
+  EXISTING_CATALOG=$(cat "$CATALOG_FILE")
+else
+  EXISTING_CATALOG="{}"
+fi
+
+# Lock file for thread-safe catalog writes
+LOCK_FILE="$LOG_DIR/.catalog.lock"
+RESULTS_DIR="$LOG_DIR/results"
+mkdir -p "$RESULTS_DIR"
+
+ERRORS=0
+FAILED_MODELS=""
+SKIPPED=0
+RESEARCHED=0
+CHANGED=0
+
+# --- Determine which models need research ---
+
+MODELS_TO_RESEARCH=""
+COUNT=0
+
+for base in $BASE_MODELS; do
+  COUNT=$((COUNT + 1))
+
+  SKIP_REASON=$(echo "$EXISTING_CATALOG" | node -e "
+    const data = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+    const entry = data['$base'];
+    if (!entry) { process.stdout.write('missing'); return; }
+    if ($FORCE) { process.stdout.write('force'); return; }
+    if ($SKIP_HIDDEN && entry.isHidden) { process.stdout.write('hidden'); return; }
+    const resolvedAt = entry.resolvedAt ? new Date(entry.resolvedAt) : null;
+    if (!resolvedAt) { process.stdout.write('no_timestamp'); return; }
+    const staleMs = $STALE_DAYS * 24 * 60 * 60 * 1000;
+    if (Date.now() - resolvedAt.getTime() > staleMs) { process.stdout.write('stale'); return; }
+    process.stdout.write('fresh');
+  " 2>/dev/null || echo "missing")
+
+  case "$SKIP_REASON" in
+    fresh)
+      RESOLVED_DATE=$(echo "$EXISTING_CATALOG" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));const r=d['$base']?.resolvedAt;console.log(r?r.split('T')[0]:'?')" 2>/dev/null)
+      echo "[$COUNT/$TOTAL] Skipping $base (resolved $RESOLVED_DATE)"
+      SKIPPED=$((SKIPPED + 1))
+      ;;
+    hidden)
+      echo "[$COUNT/$TOTAL] Skipping $base (hidden/deprecated)"
+      SKIPPED=$((SKIPPED + 1))
+      ;;
+    *)
+      MODELS_TO_RESEARCH="$MODELS_TO_RESEARCH $base"
+      ;;
+  esac
+done
+
+RESEARCH_COUNT=$(echo "$MODELS_TO_RESEARCH" | wc -w | tr -d ' ')
+echo ""
+echo "Researching $RESEARCH_COUNT models, skipped $SKIPPED"
+echo ""
+
+if [[ "$RESEARCH_COUNT" -eq 0 ]]; then
+  echo "Nothing to do."
+  exit 0
+fi
+
+# --- Research function (called per model, may run in parallel) ---
+
+research_model() {
+  local base="$1"
+  local idx="$2"
+  local total="$3"
+  local model_log="$LOG_DIR/$base.log"
+  local result_file="$RESULTS_DIR/$base.json"
+
+  echo "[$idx/$total] Researching $base..."
+
+  local raw
+  raw=$("$RESEARCH_SCRIPT" "$base" 3 2>&1) || {
+    echo "$raw" > "$model_log"
+    echo "  ERROR: Failed to research $base (after retries). Log: $model_log" >&2
+    echo '{"error":true}' > "$result_file"
+    return 1
+  }
+
+  echo "$raw" > "$model_log"
+
+  local entry
+  entry=$(echo "$raw" | node -e "
+    try {
+      const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+      let text = (typeof d.result === 'string' ? d.result : JSON.stringify(d)).trim();
+      text = text.replace(/^\`\`\`(?:json)?\s*/i, '').replace(/\s*\`\`\`\s*$/, '').trim();
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) text = jsonMatch[0];
+      const r = JSON.parse(text);
+      if (!r.provider) throw new Error('missing provider field');
+      process.stdout.write(JSON.stringify({
+        provider: r.provider,
+        description: r.description || '',
+        contextWindow: r.contextWindow || null,
+        maxOutputTokens: r.maxOutputTokens || null,
+        capabilities: r.capabilities || [],
+        releaseDate: r.releaseDate || null,
+        isHidden: r.isHidden === true,
+        supportsStructuredOutput: r.supportsStructuredOutput === true,
+        supportsParallelToolCalls: r.supportsParallelToolCalls === true,
+        supportsStreamingToolCalls: r.supportsStreamingToolCalls === true,
+        deprecationDate: r.deprecationDate || null,
+        knowledgeCutoff: r.knowledgeCutoff || null,
+        resolvedAt: new Date().toISOString()
+      }));
+    } catch(e) {
+      process.stderr.write(e.message);
+      process.exit(1);
+    }
+  " 2>"$LOG_DIR/$base.parse-error") || {
+    local parse_err
+    parse_err=$(cat "$LOG_DIR/$base.parse-error" 2>/dev/null)
+    echo "  ERROR: Failed to parse response for $base: $parse_err" >&2
+    echo "  Raw response saved to: $model_log" >&2
+    echo '{"error":true}' > "$result_file"
+    return 1
+  }
+
+  echo "$entry" > "$result_file"
+  echo "  OK: $(echo "$entry" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));console.log(d.provider + ' / ' + (d.contextWindow||'?') + ' ctx / ' + d.capabilities.length + ' caps')" 2>/dev/null)"
+}
+
+export -f research_model
+export RESEARCH_SCRIPT LOG_DIR RESULTS_DIR
+
+# --- Run research in parallel ---
+
+IDX=0
+PIDS=()
+MODEL_LIST=($MODELS_TO_RESEARCH)
+
+for base in "${MODEL_LIST[@]}"; do
+  IDX=$((IDX + 1))
+
+  research_model "$base" "$IDX" "$RESEARCH_COUNT" &
+  PIDS+=($!)
+
+  # Throttle concurrency
+  if [[ ${#PIDS[@]} -ge $CONCURRENCY ]]; then
+    wait "${PIDS[0]}" 2>/dev/null || true
+    PIDS=("${PIDS[@]:1}")
+  fi
+done
+
+# Wait for remaining
+for pid in "${PIDS[@]}"; do
+  wait "$pid" 2>/dev/null || true
+done
+
+echo ""
+echo "Research complete. Merging results..."
+
+# --- Merge results into catalog ---
+
+CATALOG="$EXISTING_CATALOG"
+
+for base in "${MODEL_LIST[@]}"; do
+  RESULT_FILE="$RESULTS_DIR/$base.json"
+
+  if [[ ! -f "$RESULT_FILE" ]]; then
+    ERRORS=$((ERRORS + 1))
+    FAILED_MODELS="$FAILED_MODELS $base"
+    continue
+  fi
+
+  ENTRY=$(cat "$RESULT_FILE")
+
+  # Check for error marker
+  if echo "$ENTRY" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));process.exit(d.error?0:1)" 2>/dev/null; then
+    ERRORS=$((ERRORS + 1))
+    FAILED_MODELS="$FAILED_MODELS $base"
+    continue
+  fi
+
+  RESEARCHED=$((RESEARCHED + 1))
+
+  # Diff detection: compare with existing entry
+  OLD_ENTRY=$(echo "$EXISTING_CATALOG" | node -e "
+    const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+    const e = d['$base'];
+    if (e) { delete e.resolvedAt; process.stdout.write(JSON.stringify(e)); }
+    else process.stdout.write('null');
+  " 2>/dev/null)
+
+  NEW_FOR_DIFF=$(echo "$ENTRY" | node -e "
+    const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+    delete d.resolvedAt;
+    process.stdout.write(JSON.stringify(d));
+  " 2>/dev/null)
+
+  if [[ "$OLD_ENTRY" != "null" && "$OLD_ENTRY" != "$NEW_FOR_DIFF" ]]; then
+    CHANGED=$((CHANGED + 1))
+    # Log what changed
+    node -e "
+      const old = JSON.parse('$OLD_ENTRY');
+      const cur = JSON.parse('$NEW_FOR_DIFF');
+      const changes = [];
+      for (const k of new Set([...Object.keys(old), ...Object.keys(cur)])) {
+        const o = JSON.stringify(old[k]); const n = JSON.stringify(cur[k]);
+        if (o !== n) changes.push(k + ': ' + o + ' → ' + n);
+      }
+      if (changes.length) console.log('  CHANGED: ' + changes.join(', '));
+    " 2>/dev/null || true
+  fi
+
+  # Apply to all variants of this base model
+  for variant in ${BASE_TO_VARIANTS[$base]}; do
+    CATALOG=$(echo "$CATALOG" | node -e "
+      const catalog = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+      catalog['$variant'] = $ENTRY;
+      process.stdout.write(JSON.stringify(catalog));
+    ")
+  done
+done
+
+# Write final catalog
+echo "$CATALOG" | node -e "
+  const data = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+  const sorted = Object.keys(data).sort().reduce((acc, k) => { acc[k] = data[k]; return acc; }, {});
+  process.stdout.write(JSON.stringify(sorted, null, 2) + '\n');
+" > "$CATALOG_FILE"
+
+# Cleanup results
+rm -rf "$RESULTS_DIR"
+
+FINAL_COUNT=$(node -e "console.log(Object.keys(JSON.parse(require('fs').readFileSync('$CATALOG_FILE','utf-8'))).length)")
+echo ""
+echo "Done! $FINAL_COUNT entries in catalog"
+echo "  Researched: $RESEARCHED | Changed: $CHANGED | Skipped: $SKIPPED | Errors: $ERRORS"
+
+if [[ "$ERRORS" -gt 0 ]]; then
+  echo ""
+  echo "Failed models:$FAILED_MODELS"
+  RETRY_PATTERN=$(echo "$FAILED_MODELS" | tr ' ' '\n' | grep -v '^$' | sed 's/\./\\./g; s/^/^/; s/$/$/' | paste -sd '|' -)
+  echo "Retry with: $0 --filter \"$RETRY_PATTERN\""
+fi
diff --git a/internal-packages/llm-model-catalog/scripts/generate.mjs b/internal-packages/llm-model-catalog/scripts/generate.mjs
new file mode 100644
index 00000000000..115643b1dff
--- /dev/null
+++ b/internal-packages/llm-model-catalog/scripts/generate.mjs
@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+// Cross-platform generation script for the llm-pricing package.
+// Generates TypeScript modules from JSON data files:
+//   1. defaultPrices.ts   ← default-model-prices.json (synced from Langfuse)
+//   2. modelCatalog.ts    ← model-catalog.json (our maintained catalog metadata)
+//
+// Usage: node scripts/generate.mjs
+//
+// To update the source JSON files:
+//   - Pricing:  pnpm run sync-prices  (fetches from Langfuse, requires curl)
+//   - Catalog:  pnpm run generate-catalog  (uses Claude CLI to research models)
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const srcDir = join(__dirname, "..", "src");
+
+// --- 1. Generate defaultPrices.ts from default-model-prices.json ---
+
+const pricesJsonPath = join(srcDir, "default-model-prices.json");
+
+if (existsSync(pricesJsonPath)) {
+  const raw = JSON.parse(readFileSync(pricesJsonPath, "utf-8"));
+  const stripped = raw.map((e) => ({
+    modelName: e.modelName.trim(),
+    matchPattern: e.matchPattern,
+    startDate: e.createdAt,
+    pricingTiers: e.pricingTiers.map((t) => ({
+      name: t.name,
+      isDefault: t.isDefault,
+      priority: t.priority,
+      conditions: t.conditions.map((c) => ({
+        usageDetailPattern: c.usageDetailPattern,
+        operator: c.operator,
+        value: c.value,
+      })),
+      prices: t.prices,
+    })),
+  }));
+
+  let out = 'import type { DefaultModelDefinition } from "./types.js";\n\n';
+  out += "// Auto-generated from default-model-prices.json — do not edit manually.\n";
+  out += "// Run `pnpm run sync-prices` to update the JSON, then `pnpm run generate` to regenerate.\n";
+  out += "// Source: https://github.com/langfuse/langfuse\n\n";
+  out += "export const defaultModelPrices: DefaultModelDefinition[] = ";
+  out += JSON.stringify(stripped, null, 2) + ";\n";
+
+  writeFileSync(join(srcDir, "defaultPrices.ts"), out);
+  console.log(`Generated defaultPrices.ts (${stripped.length} models)`);
+} else {
+  console.log("Skipping defaultPrices.ts — default-model-prices.json not found");
+}
+
+// --- 2. Generate modelCatalog.ts from model-catalog.json ---
+
+const catalogJsonPath = join(srcDir, "model-catalog.json");
+
+if (existsSync(catalogJsonPath)) {
+  const data = JSON.parse(readFileSync(catalogJsonPath, "utf-8"));
+
+  // Backfill missing fields for old entries
+  for (const key of Object.keys(data)) {
+    if (data[key].releaseDate === undefined) data[key].releaseDate = null;
+    if (data[key].isHidden === undefined) data[key].isHidden = false;
+    if (data[key].supportsStructuredOutput === undefined) data[key].supportsStructuredOutput = false;
+    if (data[key].supportsParallelToolCalls === undefined) data[key].supportsParallelToolCalls = false;
+    if (data[key].supportsStreamingToolCalls === undefined) data[key].supportsStreamingToolCalls = false;
+    if (data[key].deprecationDate === undefined) data[key].deprecationDate = null;
+    if (data[key].knowledgeCutoff === undefined) data[key].knowledgeCutoff = null;
+    if (data[key].resolvedAt === undefined) data[key].resolvedAt = new Date().toISOString();
+    {
+      // Always recompute base model name (don't trust existing values)
+      // Strip trailing date (-YYYYMMDD or -YYYY-MM-DD) and -latest suffix
+      // Keep original naming (dots, etc.) — don't normalize
+      let base = key.replace(/-\d{4}-?\d{2}-?\d{2}$/, "").replace(/-latest$/, "");
+      data[key].baseModelName = base !== key ? base : null;
+    }
+  }
+
+  let out = 'import type { ModelCatalogEntry } from "./types.js";\n\n';
+  out += "// Auto-generated from model-catalog.json — do not edit manually.\n";
+  out += "// Run `pnpm run generate-catalog` to update the JSON, then `pnpm run generate` to regenerate.\n\n";
+  out += "export const modelCatalog: Record<string, ModelCatalogEntry> = ";
+  out += JSON.stringify(data, null, 2) + ";\n";
+
+  writeFileSync(join(srcDir, "modelCatalog.ts"), out);
+  console.log(`Generated modelCatalog.ts (${Object.keys(data).length} entries)`);
+} else {
+  console.log("Skipping modelCatalog.ts — model-catalog.json not found");
+}
diff --git a/internal-packages/llm-model-catalog/scripts/research-model.sh b/internal-packages/llm-model-catalog/scripts/research-model.sh
new file mode 100755
index 00000000000..422b7a5689a
--- /dev/null
+++ b/internal-packages/llm-model-catalog/scripts/research-model.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Research a single LLM model using Claude Code CLI and output structured JSON.
+# Usage: ./scripts/research-model.sh <model-name>
+#
+# Example:
+#   ./scripts/research-model.sh gpt-4o
+#   → {"provider":"openai","description":"...","contextWindow":128000,...}
+
+if [[ $# -lt 1 ]]; then
+  echo "Usage: $0 <model-name>" >&2
+  exit 1
+fi
+
+MODEL_NAME="$1"
+MAX_RETRIES="${2:-3}"
+
+PROMPT="Research the LLM model '${MODEL_NAME}' and return ONLY a valid JSON object (no markdown, no explanation, no code fences) with these exact fields:
+
+{
+  \"provider\": \"<provider-id>\",
+  \"description\": \"<1-2 sentence description of the model>\",
+  \"contextWindow\": <max input context window in tokens, or null if unknown>,
+  \"maxOutputTokens\": <max output tokens, or null if unknown>,
+  \"capabilities\": [<list of capability strings>],
+  \"releaseDate\": \"<YYYY-MM-DD or null if unknown>\",
+  \"isHidden\": <true if deprecated, false otherwise>,
+  \"supportsStructuredOutput\": <true/false>,
+  \"supportsParallelToolCalls\": <true/false>,
+  \"supportsStreamingToolCalls\": <true/false>,
+  \"deprecationDate\": \"<YYYY-MM-DD or null if no known sunset date>\",
+  \"knowledgeCutoff\": \"<YYYY-MM-DD or null if unknown>\"
+}
+
+Rules:
+- provider must be one of: \"openai\", \"anthropic\", \"google\", \"meta\", \"mistral\", \"cohere\", \"ai21\", \"amazon\", \"xai\", \"deepseek\", \"qwen\", \"perplexity\" or the correct provider lowercase id
+- description should be concise and factual (what the model is good at, its position in the provider's lineup)
+- contextWindow is the maximum input context in tokens (e.g. 128000 for GPT-4o, 200000 for Claude Sonnet 4)
+- maxOutputTokens is the maximum output the model can generate in a single response
+- capabilities should be drawn from: \"vision\", \"tool_use\", \"streaming\", \"json_mode\", \"extended_thinking\", \"code_execution\", \"image_generation\", \"audio_input\", \"audio_output\", \"embedding\", \"fine_tunable\"
+- Only include capabilities you are confident the model supports
+- releaseDate is when the model was first publicly available (API launch date), in YYYY-MM-DD format. Use null if unknown. If the model is a dated variant (e.g. gpt-4o-2024-08-06), the date in the name IS the release date.
+- isHidden should be true if the model is deprecated, discontinued, no longer available via API, or superseded by a newer version. Examples: gpt-3.5-turbo, claude-1.x, claude-2.x, text-davinci-003, gpt-4-0314 are hidden. Current/active models like gpt-4o, claude-sonnet-4-6, gemini-2.5-flash are NOT hidden.
+- supportsStructuredOutput: true if the model reliably follows JSON schemas / structured output mode (e.g. OpenAI's response_format, Anthropic's tool_use for structured output). false for older models that don't support it well.
+- supportsParallelToolCalls: true if the model can call multiple tools in a single assistant turn. Most modern models support this.
+- supportsStreamingToolCalls: true if the model supports streaming partial tool call arguments as they're generated.
+- deprecationDate: the date the provider has announced the model will be sunset/removed from their API, in YYYY-MM-DD format. Use null if no deprecation date has been announced. Only use dates that have been officially published by the provider.
+- knowledgeCutoff: the date when the model's training data ends, in YYYY-MM-DD format. Use null if unknown. This is different from releaseDate — it's when the training data was cut off, not when the model launched.
+- Output ONLY the JSON object, nothing else"
+
+for attempt in $(seq 1 "$MAX_RETRIES"); do
+  RESULT=$(claude -p "$PROMPT" --model opus --output-format json --permission-mode bypassPermissions --tools WebSearch,WebFetch 2>/dev/null) && {
+    echo "$RESULT"
+    exit 0
+  }
+  if [[ "$attempt" -lt "$MAX_RETRIES" ]]; then
+    echo "  Retry $attempt/$MAX_RETRIES for $MODEL_NAME..." >&2
+    sleep 2
+  fi
+done
+
+echo "  Failed after $MAX_RETRIES attempts for $MODEL_NAME" >&2
+exit 1
diff --git a/internal-packages/llm-model-catalog/scripts/sync-model-prices.sh b/internal-packages/llm-model-catalog/scripts/sync-model-prices.sh
new file mode 100755
index 00000000000..74ad04f6bb3
--- /dev/null
+++ b/internal-packages/llm-model-catalog/scripts/sync-model-prices.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Sync default model prices from Langfuse's repository and generate the TS module.
+# Usage: ./scripts/sync-model-prices.sh [--check]
+#   --check: Exit 1 if prices are outdated (for CI)
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
+JSON_TARGET="$PACKAGE_DIR/src/default-model-prices.json"
+SOURCE_URL="https://raw.githubusercontent.com/langfuse/langfuse/main/worker/src/constants/default-model-prices.json"
+
+CHECK_MODE=false
+if [[ "${1:-}" == "--check" ]]; then
+  CHECK_MODE=true
+fi
+
+echo "Fetching latest model prices from Langfuse..."
+TMPFILE=$(mktemp)
+trap 'rm -f "$TMPFILE"' EXIT
+
+if ! curl -fsSL "$SOURCE_URL" -o "$TMPFILE"; then
+  echo "ERROR: Failed to fetch from $SOURCE_URL"
+  exit 1
+fi
+
+# Validate it's valid JSON with at least some models
+MODEL_COUNT=$(node -e "console.log(JSON.parse(require('fs').readFileSync('$TMPFILE','utf-8')).length)" 2>/dev/null || echo "0")
+if [[ "$MODEL_COUNT" -lt 10 ]]; then
+  echo "ERROR: Downloaded file has only $MODEL_COUNT models (expected 100+). Aborting."
+  exit 1
+fi
+
+if $CHECK_MODE; then
+  if diff -q "$JSON_TARGET" "$TMPFILE" > /dev/null 2>&1; then
+    echo "Model prices are up to date ($MODEL_COUNT models)"
+    exit 0
+  else
+    echo "Model prices are OUTDATED. Run 'pnpm run sync-prices' in @internal/llm-model-catalog to update."
+    exit 1
+  fi
+fi
+
+cp "$TMPFILE" "$JSON_TARGET"
+echo "Updated default-model-prices.json ($MODEL_COUNT models)"
+echo "Run 'pnpm run generate' to regenerate defaultPrices.ts"
diff --git a/internal-packages/llm-model-catalog/src/default-model-prices.json b/internal-packages/llm-model-catalog/src/default-model-prices.json
new file mode 100644
index 00000000000..62e9adbf03e
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/default-model-prices.json
@@ -0,0 +1,3991 @@
+[
+  {
+    "id": "b9854a5c92dc496b997d99d20",
+    "modelName": "gpt-4o",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o)$",
+    "createdAt": "2024-05-13T23:15:07.670Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "b9854a5c92dc496b997d99d20_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "b9854a5c92dc496b997d99d21",
+    "modelName": "gpt-4o-2024-05-13",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-2024-05-13)$",
+    "createdAt": "2024-05-13T23:15:07.670Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o-2024-05-13",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "b9854a5c92dc496b997d99d21_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "output": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkvq6iq000008ju6c16gynt",
+    "modelName": "gpt-4-1106-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-1106-preview)$",
+    "createdAt": "2024-04-23T10:37:17.092Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-1106-preview",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkvq6iq000008ju6c16gynt_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkvx5gp000108juaogs54ea",
+    "modelName": "gpt-4-turbo-vision",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4(-\\d{4})?-vision-preview)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-vision-preview",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkvx5gp000108juaogs54ea_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkvyzgw000308jue4hse4j9",
+    "modelName": "gpt-4-32k",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-32k)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-32k",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkvyzgw000308jue4hse4j9_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkwk4cb000108l5hwwh3zdi",
+    "modelName": "gpt-4-32k-0613",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-32k-0613)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-32k-0613",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkwk4cb000108l5hwwh3zdi_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkwk4cb000208l59yvb9yq8",
+    "modelName": "gpt-3.5-turbo-1106",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-1106)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-1106",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkwk4cb000208l59yvb9yq8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000001,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkwk4cc000808l51xmk4uic",
+    "modelName": "gpt-3.5-turbo-0613",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-0613)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-0613",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkwk4cc000808l51xmk4uic_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000015,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkwk4cc000908l537kl0rx3",
+    "modelName": "gpt-4-0613",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-0613)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-0613",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkwk4cc000908l537kl0rx3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrkwk4cc000a08l562uc3s9g",
+    "modelName": "gpt-3.5-turbo-instruct",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-instruct)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrkwk4cc000a08l562uc3s9g_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000015,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000108jwcou1af71",
+    "modelName": "text-ada-001",
+    "matchPattern": "(?i)^(text-ada-001)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-ada-001"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000108jwcou1af71_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.000004
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000208jwawjr894q",
+    "modelName": "text-babbage-001",
+    "matchPattern": "(?i)^(text-babbage-001)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-babbage-001"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000208jwawjr894q_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000308jw0jtfa4rs",
+    "modelName": "text-curie-001",
+    "matchPattern": "(?i)^(text-curie-001)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-curie-001"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000308jw0jtfa4rs_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000408jwc2c93h6i",
+    "modelName": "text-davinci-001",
+    "matchPattern": "(?i)^(text-davinci-001)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-davinci-001"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000408jwc2c93h6i_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000508jw192m64qi",
+    "modelName": "text-davinci-002",
+    "matchPattern": "(?i)^(text-davinci-002)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-davinci-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000508jw192m64qi_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000608jw4m3x5s55",
+    "modelName": "text-davinci-003",
+    "matchPattern": "(?i)^(text-davinci-003)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-davinci-003"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000608jw4m3x5s55_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000908jwhvkz5crg",
+    "modelName": "text-embedding-ada-002-v2",
+    "matchPattern": "(?i)^(text-embedding-ada-002-v2)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-embedding-ada-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000908jwhvkz5crg_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000908jwhvkz5crm",
+    "modelName": "text-embedding-ada-002",
+    "matchPattern": "(?i)^(text-embedding-ada-002)$",
+    "createdAt": "2024-01-24T18:18:50.861Z",
+    "updatedAt": "2024-01-24T18:18:50.861Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-embedding-ada-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000908jwhvkz5crm_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntjt89000a08jw0gcdbd5a",
+    "modelName": "gpt-3.5-turbo-16k-0613",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-16k-0613)$",
+    "createdAt": "2024-02-03T17:29:57.350Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-16k-0613",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntjt89000a08jw0gcdbd5a_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "output": 0.000004
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntkjgy000a08jx4e062mr0",
+    "modelName": "gpt-3.5-turbo-0301",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-0301)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": -1,
+      "tokenizerModel": "gpt-3.5-turbo-0301",
+      "tokensPerMessage": 4
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntkjgy000a08jx4e062mr0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntkjgy000d08jx0p4y9h4l",
+    "modelName": "gpt-4-32k-0314",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-32k-0314)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-32k-0314",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntkjgy000d08jx0p4y9h4l_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntkjgy000e08jx4x6uawoo",
+    "modelName": "gpt-4-0314",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-0314)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-0314",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntkjgy000e08jx4x6uawoo_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrntkjgy000f08jx79v9g1xj",
+    "modelName": "gpt-4",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4)$",
+    "createdAt": "2024-01-24T10:19:21.693Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrntkjgy000f08jx79v9g1xj_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwb41q000308jsfrac9uh6",
+    "modelName": "claude-instant-1.2",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-instant-1.2)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwb41q000308jsfrac9uh6_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000163,
+          "output": 0.00000551
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwb836000408jsallr6u11",
+    "modelName": "claude-2.0",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-2.0)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwb836000408jsallr6u11_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwbd1m000508js4hxu6o7n",
+    "modelName": "claude-2.1",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-2.1)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwbd1m000508js4hxu6o7n_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwbg2b000608jse2pp4q2d",
+    "modelName": "claude-1.3",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-1.3)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwbg2b000608jse2pp4q2d_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwbi9d000708jseiy44k26",
+    "modelName": "claude-1.2",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-1.2)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwbi9d000708jseiy44k26_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwblo0000808jsc1385hdp",
+    "modelName": "claude-1.1",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-1.1)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwblo0000808jsc1385hdp_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrnwbota000908jsgg9mb1ml",
+    "modelName": "claude-instant-1",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-instant-1)$",
+    "createdAt": "2024-01-30T15:44:13.447Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clrnwbota000908jsgg9mb1ml_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000163,
+          "output": 0.00000551
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrs2dnql000108l46vo0gp2t",
+    "modelName": "babbage-002",
+    "matchPattern": "(?i)^(babbage-002)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2024-01-26T17:35:21.129Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "babbage-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrs2dnql000108l46vo0gp2t_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "id": "clrs2ds35000208l4g4b0hi3u",
+    "modelName": "davinci-002",
+    "matchPattern": "(?i)^(davinci-002)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2024-01-26T17:35:21.129Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "davinci-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clrs2ds35000208l4g4b0hi3u_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000006,
+          "output": 0.000012
+        }
+      }
+    ]
+  },
+  {
+    "id": "clruwn3pc00010al7bl611c8o",
+    "modelName": "text-embedding-3-small",
+    "matchPattern": "(?i)^(text-embedding-3-small)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2024-01-26T17:35:21.129Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-embedding-ada-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clruwn3pc00010al7bl611c8o_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 2e-8
+        }
+      }
+    ]
+  },
+  {
+    "id": "clruwn76700020al7gp8e4g4l",
+    "modelName": "text-embedding-3-large",
+    "matchPattern": "(?i)^(text-embedding-3-large)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2024-01-26T17:35:21.129Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "text-embedding-ada-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clruwn76700020al7gp8e4g4l_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1.3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clruwnahl00030al7ab9rark7",
+    "modelName": "gpt-3.5-turbo-0125",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-0125)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clruwnahl00030al7ab9rark7_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "clruwnahl00040al78f1lb0at",
+    "modelName": "gpt-3.5-turbo",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo)$",
+    "createdAt": "2024-02-13T12:00:37.424Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clruwnahl00040al78f1lb0at_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "clruwnahl00050al796ck3p44",
+    "modelName": "gpt-4-0125-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-0125-preview)$",
+    "createdAt": "2024-01-26T17:35:21.129Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clruwnahl00050al796ck3p44_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls08r8sq000308jq14ae96f0",
+    "modelName": "ft:gpt-3.5-turbo-1106",
+    "matchPattern": "(?i)^(ft:)(gpt-3.5-turbo-1106:)(.+)(:)(.*)(:)(.+)$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-1106",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cls08r8sq000308jq14ae96f0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "output": 0.000006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls08rp99000408jqepxoakjv",
+    "modelName": "ft:gpt-3.5-turbo-0613",
+    "matchPattern": "(?i)^(ft:)(gpt-3.5-turbo-0613:)(.+)(:)(.*)(:)(.+)$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-0613",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cls08rp99000408jqepxoakjv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000012,
+          "output": 0.000016
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls08rv9g000508jq5p4z4nlr",
+    "modelName": "ft:davinci-002",
+    "matchPattern": "(?i)^(ft:)(davinci-002:)(.+)(:)(.*)(:)(.+)$$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "davinci-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cls08rv9g000508jq5p4z4nlr_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000012,
+          "output": 0.000012
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls08s2bw000608jq57wj4un2",
+    "modelName": "ft:babbage-002",
+    "matchPattern": "(?i)^(ft:)(babbage-002:)(.+)(:)(.*)(:)(.+)$$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "tokenizerConfig": {
+      "tokenizerModel": "babbage-002"
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cls08s2bw000608jq57wj4un2_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000016,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0iv12d000108l251gf3038",
+    "modelName": "chat-bison",
+    "matchPattern": "(?i)^(chat-bison)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0iv12d000108l251gf3038_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0j33v1000008joagkc4lql",
+    "modelName": "codechat-bison-32k",
+    "matchPattern": "(?i)^(codechat-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0j33v1000008joagkc4lql_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0jmc9v000008l8ee6r3gsd",
+    "modelName": "codechat-bison",
+    "matchPattern": "(?i)^(codechat-bison)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0jmc9v000008l8ee6r3gsd_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0jmjt3000108l83ix86w0d",
+    "modelName": "text-bison-32k",
+    "matchPattern": "(?i)^(text-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0jmjt3000108l83ix86w0d_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0jni4t000008jk3kyy803r",
+    "modelName": "chat-bison-32k",
+    "matchPattern": "(?i)^(chat-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0jni4t000008jk3kyy803r_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0jungb000208jk12gm4gk1",
+    "modelName": "text-unicorn",
+    "matchPattern": "(?i)^(text-unicorn)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0jungb000208jk12gm4gk1_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "output": 0.0000075
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls0juygp000308jk2a6x9my2",
+    "modelName": "text-bison",
+    "matchPattern": "(?i)^(text-bison)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls0juygp000308jk2a6x9my2_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls1nyj5q000208l33ne901d8",
+    "modelName": "textembedding-gecko",
+    "matchPattern": "(?i)^(textembedding-gecko)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls1nyj5q000208l33ne901d8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls1nyyjp000308l31gxy1bih",
+    "modelName": "textembedding-gecko-multilingual",
+    "matchPattern": "(?i)^(textembedding-gecko-multilingual)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls1nyyjp000308l31gxy1bih_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls1nzjt3000508l3dnwad3g0",
+    "modelName": "code-gecko",
+    "matchPattern": "(?i)^(code-gecko)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls1nzjt3000508l3dnwad3g0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls1nzwx4000608l38va7e4tv",
+    "modelName": "code-bison",
+    "matchPattern": "(?i)^(code-bison)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls1nzwx4000608l38va7e4tv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cls1o053j000708l39f8g4bgs",
+    "modelName": "code-bison-32k",
+    "matchPattern": "(?i)^(code-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-01-31T13:25:02.141Z",
+    "updatedAt": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "id": "cls1o053j000708l39f8g4bgs_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clsk9lntu000008jwfc51bbqv",
+    "modelName": "gpt-3.5-turbo-16k",
+    "matchPattern": "(?i)^(openai\/)?(gpt-)(35|3.5)(-turbo-16k)$",
+    "createdAt": "2024-02-13T12:00:37.424Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-3.5-turbo-16k",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clsk9lntu000008jwfc51bbqv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "clsnq07bn000008l4e46v1ll8",
+    "modelName": "gpt-4-turbo-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-turbo-preview)$",
+    "createdAt": "2024-02-15T21:21:50.947Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clsnq07bn000008l4e46v1ll8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "cltgy0iuw000008le3vod1hhy",
+    "modelName": "claude-3-opus-20240229",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-opus-20240229|anthropic\\.claude-3-opus-20240229-v1:0|claude-3-opus@20240229)$",
+    "createdAt": "2024-03-07T17:55:38.139Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cltgy0iuw000008le3vod1hhy_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.000075
+        }
+      }
+    ]
+  },
+  {
+    "id": "cltgy0pp6000108le56se7bl3",
+    "modelName": "claude-3-sonnet-20240229",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-sonnet-20240229|anthropic\\.claude-3-sonnet-20240229-v1:0|claude-3-sonnet@20240229)$",
+    "createdAt": "2024-03-07T17:55:38.139Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cltgy0pp6000108le56se7bl3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cltr0w45b000008k1407o9qv1",
+    "modelName": "claude-3-haiku-20240307",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-haiku-20240307|anthropic\\.claude-3-haiku-20240307-v1:0|claude-3-haiku@20240307)$",
+    "createdAt": "2024-03-14T09:41:18.736Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cltr0w45b000008k1407o9qv1_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 0.00000125
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2sjeo000008ih0fv23hi0",
+    "modelName": "gemini-1.0-pro-latest",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-1.0-pro-latest)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-04-11T10:27:46.517Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cluv2sjeo000008ih0fv23hi0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2subq000108ih2mlrga6a",
+    "modelName": "gemini-1.0-pro",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-1.0-pro)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-04-11T10:27:46.517Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cluv2subq000108ih2mlrga6a_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2sx04000208ihbek75lsz",
+    "modelName": "gemini-1.0-pro-001",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-1.0-pro-001)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-04-11T10:27:46.517Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cluv2sx04000208ihbek75lsz_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2szw0000308ihch3n79x7",
+    "modelName": "gemini-pro",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-pro)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-04-11T10:27:46.517Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cluv2szw0000308ihch3n79x7_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2t2x0000408ihfytl45l1",
+    "modelName": "gemini-1.5-pro-latest",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-1.5-pro-latest)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2024-04-11T10:27:46.517Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cluv2t2x0000408ihfytl45l1_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "output": 0.0000075
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluv2t5k3000508ih5kve9zag",
+    "modelName": "gpt-4-turbo-2024-04-09",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-turbo-2024-04-09)$",
+    "createdAt": "2024-04-23T10:37:17.092Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-turbo-2024-04-09",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cluv2t5k3000508ih5kve9zag_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "cluvpl4ls000008l6h2gx3i07",
+    "modelName": "gpt-4-turbo",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-turbo)$",
+    "createdAt": "2024-04-11T21:13:44.989Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-1106-preview",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cluvpl4ls000008l6h2gx3i07_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "clv2o2x0p000008jsf9afceau",
+    "modelName": " gpt-4-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4-preview)$",
+    "createdAt": "2024-04-23T10:37:17.092Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4-turbo-preview",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clv2o2x0p000008jsf9afceau_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "id": "clxt0n0m60000pumz1j5b7zsf",
+    "modelName": "claude-3-5-sonnet-20240620",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-5-sonnet-20240620|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-sonnet-20240620-v1:0|claude-3-5-sonnet@20240620)$",
+    "createdAt": "2024-06-25T11:47:24.475Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "clxt0n0m60000pumz1j5b7zsf_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clyrjp56f0000t0mzapoocd7u",
+    "modelName": "gpt-4o-mini",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-mini)$",
+    "createdAt": "2024-07-18T17:56:09.591Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clyrjp56f0000t0mzapoocd7u_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.5e-7,
+          "output": 6e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8
+        }
+      }
+    ]
+  },
+  {
+    "id": "clyrjpbe20000t0mzcbwc42rg",
+    "modelName": "gpt-4o-mini-2024-07-18",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-mini-2024-07-18)$",
+    "createdAt": "2024-07-18T17:56:09.591Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clyrjpbe20000t0mzcbwc42rg_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.5e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8,
+          "output": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "clzjr85f70000ymmzg7hqffra",
+    "modelName": "gpt-4o-2024-08-06",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-2024-08-06)$",
+    "createdAt": "2024-08-07T11:54:31.298Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "clzjr85f70000ymmzg7hqffra_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm10ivcdp0000gix7lelmbw80",
+    "modelName": "o1-preview",
+    "matchPattern": "(?i)^(openai\/)?(o1-preview)$",
+    "createdAt": "2024-09-13T10:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm10ivcdp0000gix7lelmbw80_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm10ivo130000n8x7qopcjjcg",
+    "modelName": "o1-preview-2024-09-12",
+    "matchPattern": "(?i)^(openai\/)?(o1-preview-2024-09-12)$",
+    "createdAt": "2024-09-13T10:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm10ivo130000n8x7qopcjjcg_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm10ivwo40000r1x7gg3syjq0",
+    "modelName": "o1-mini",
+    "matchPattern": "(?i)^(openai\/)?(o1-mini)$",
+    "createdAt": "2024-09-13T10:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm10ivwo40000r1x7gg3syjq0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm10iw6p20000wgx7it1hlb22",
+    "modelName": "o1-mini-2024-09-12",
+    "matchPattern": "(?i)^(openai\/)?(o1-mini-2024-09-12)$",
+    "createdAt": "2024-09-13T10:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm10iw6p20000wgx7it1hlb22_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm2krz1uf000208jjg5653iud",
+    "modelName": "claude-3.5-sonnet-20241022",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-5-sonnet-20241022|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-sonnet-20241022-v2:0|claude-3-5-sonnet-V2@20241022)$",
+    "createdAt": "2024-10-22T18:48:01.676Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm2krz1uf000208jjg5653iud_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm2ks2vzn000308jjh4ze1w7q",
+    "modelName": "claude-3.5-sonnet-latest",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-5-sonnet-latest)$",
+    "createdAt": "2024-10-22T18:48:01.676Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm2ks2vzn000308jjh4ze1w7q_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm34aq60d000207ml0j1h31ar",
+    "modelName": "claude-3-5-haiku-20241022",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-5-haiku-20241022|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-haiku-20241022-v1:0|claude-3-5-haiku-V1@20241022)$",
+    "createdAt": "2024-11-05T10:30:50.566Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm34aq60d000207ml0j1h31ar_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 8e-7,
+          "input_tokens": 8e-7,
+          "output": 0.000004,
+          "output_tokens": 0.000004,
+          "cache_creation_input_tokens": 0.000001,
+          "input_cache_creation": 0.000001,
+          "input_cache_creation_5m": 0.000001,
+          "input_cache_creation_1h": 0.0000016,
+          "cache_read_input_tokens": 8e-8,
+          "input_cache_read": 8e-8
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm34aqb9h000307ml6nypd618",
+    "modelName": "claude-3.5-haiku-latest",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-5-haiku-latest)$",
+    "createdAt": "2024-11-05T10:30:50.566Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm34aqb9h000307ml6nypd618_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 8e-7,
+          "input_tokens": 8e-7,
+          "output": 0.000004,
+          "output_tokens": 0.000004,
+          "cache_creation_input_tokens": 0.000001,
+          "input_cache_creation": 0.000001,
+          "input_cache_creation_5m": 0.000001,
+          "input_cache_creation_1h": 0.0000016,
+          "cache_read_input_tokens": 8e-8,
+          "input_cache_read": 8e-8
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm3x0p8ev000008kyd96800c8",
+    "modelName": "chatgpt-4o-latest",
+    "matchPattern": "(?i)^(chatgpt-4o-latest)$",
+    "createdAt": "2024-11-25T12:47:17.504Z",
+    "updatedAt": "2024-11-25T12:47:17.504Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm3x0p8ev000008kyd96800c8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "output": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48akqgo000008ldbia24qg0",
+    "modelName": "gpt-4o-2024-11-20",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-2024-11-20)$",
+    "createdAt": "2024-12-03T10:06:12.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4o",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm48akqgo000008ldbia24qg0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48b2ksh000008l0hn3u0hl3",
+    "modelName": "gpt-4o-audio-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-audio-preview)$",
+    "createdAt": "2024-12-03T10:19:56.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48b2ksh000008l0hn3u0hl3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00001,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48bbm0k000008l69nsdakwf",
+    "modelName": "gpt-4o-audio-preview-2024-10-01",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-audio-preview-2024-10-01)$",
+    "createdAt": "2024-12-03T10:19:56.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48bbm0k000008l69nsdakwf_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00001,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48c2qh4000008mhgy4mg2qc",
+    "modelName": "gpt-4o-realtime-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-realtime-preview)$",
+    "createdAt": "2024-12-03T10:19:56.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48c2qh4000008mhgy4mg2qc_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.000005,
+          "input_cached_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00002,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "input_cached_audio_tokens": 0.00002,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48cjxtc000008jrcsso3avv",
+    "modelName": "gpt-4o-realtime-preview-2024-10-01",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4o-realtime-preview-2024-10-01)$",
+    "createdAt": "2024-12-03T10:19:56.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48cjxtc000008jrcsso3avv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.000005,
+          "input_cached_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00002,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "input_cached_audio_tokens": 0.00002,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48cjxtc000108jrcsso3avv",
+    "modelName": "o1",
+    "matchPattern": "(?i)^(openai\/)?(o1)$",
+    "createdAt": "2025-01-17T00:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48cjxtc000108jrcsso3avv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm48cjxtc000208jrcsso3avv",
+    "modelName": "o1-2024-12-17",
+    "matchPattern": "(?i)^(openai\/)?(o1-2024-12-17)$",
+    "createdAt": "2025-01-17T00:01:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm48cjxtc000208jrcsso3avv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm6l8j7vs0000tymz9vk7ew8t",
+    "modelName": "o3-mini",
+    "matchPattern": "(?i)^(openai\/)?(o3-mini)$",
+    "createdAt": "2025-01-31T20:41:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm6l8j7vs0000tymz9vk7ew8t_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm6l8jan90000tymz52sh0ql8",
+    "modelName": "o3-mini-2025-01-31",
+    "matchPattern": "(?i)^(openai\/)?(o3-mini-2025-01-31)$",
+    "createdAt": "2025-01-31T20:41:35.373Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm6l8jan90000tymz52sh0ql8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm6l8jdef0000tymz52sh0ql0",
+    "modelName": "gemini-2.0-flash-001",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.0-flash-001)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2025-02-06T11:11:35.241Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cm6l8jdef0000tymz52sh0ql0_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm6l8jfgh0000tymz52sh0ql1",
+    "modelName": "gemini-2.0-flash-lite-preview-02-05",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.0-flash-lite-preview-02-05)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2025-02-06T11:11:35.241Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cm6l8jfgh0000tymz52sh0ql1_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-8,
+          "output": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7ka7561000108js3t9tb3at",
+    "modelName": "claude-3.7-sonnet-20250219",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3.7-sonnet-20250219|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3.7-sonnet-20250219-v1:0|claude-3-7-sonnet-V1@20250219)$",
+    "createdAt": "2025-02-25T09:35:39.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm7ka7561000108js3t9tb3at_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7ka7zob000208jsfs9h5ajj",
+    "modelName": "claude-3.7-sonnet-latest",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-3-7-sonnet-latest)$",
+    "createdAt": "2025-02-25T09:35:39.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cm7ka7zob000208jsfs9h5ajj_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7nusjvk0000tvmz71o85jwg",
+    "modelName": "gpt-4.5-preview",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.5-preview)$",
+    "createdAt": "2025-02-27T21:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm7nusjvk0000tvmz71o85jwg_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000075,
+          "input_cached_tokens": 0.0000375,
+          "input_cached_text_tokens": 0.0000375,
+          "input_cache_read": 0.0000375,
+          "output": 0.00015
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7nusn640000tvmzf10z2x65",
+    "modelName": "gpt-4.5-preview-2025-02-27",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.5-preview-2025-02-27)$",
+    "createdAt": "2025-02-27T21:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm7nusn640000tvmzf10z2x65_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000075,
+          "input_cached_tokens": 0.0000375,
+          "input_cached_text_tokens": 0.0000375,
+          "input_cache_read": 0.0000375,
+          "output": 0.00015
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7nusn643377tvmzh27m33kl",
+    "modelName": "gpt-4.1",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1)$",
+    "createdAt": "2025-04-15T10:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7nusn643377tvmzh27m33kl_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cached_text_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7qahw732891bpmzy45r3x70",
+    "modelName": "gpt-4.1-2025-04-14",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1-2025-04-14)$",
+    "createdAt": "2025-04-15T10:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7qahw732891bpmzy45r3x70_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cached_text_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7sglt825463kxnza72p6v81",
+    "modelName": "gpt-4.1-mini-2025-04-14",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1-mini-2025-04-14)$",
+    "createdAt": "2025-04-15T10:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7sglt825463kxnza72p6v81_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "input_cached_tokens": 1e-7,
+          "input_cached_text_tokens": 1e-7,
+          "input_cache_read": 1e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7vxpz967124dhjtb95w8f92",
+    "modelName": "gpt-4.1-nano-2025-04-14",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1-nano-2025-04-14)$",
+    "createdAt": "2025-04-15T10:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7vxpz967124dhjtb95w8f92_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "input_cached_text_tokens": 2.5e-8,
+          "input_cache_read": 2.5e-8,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7wmny967124dhjtb95w8f81",
+    "modelName": "o3",
+    "matchPattern": "(?i)^(openai\/)?(o3)$",
+    "createdAt": "2025-04-16T23:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm7wmny967124dhjtb95w8f81_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008,
+          "output_reasoning_tokens": 0.000008,
+          "output_reasoning": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7wopq3327124dhjtb95w8f81",
+    "modelName": "o3-2025-04-16",
+    "matchPattern": "(?i)^(openai\/)?(o3-2025-04-16)$",
+    "createdAt": "2025-04-16T23:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cm7wopq3327124dhjtb95w8f81_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008,
+          "output_reasoning_tokens": 0.000008,
+          "output_reasoning": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7wqrs1327124dhjtb95w8f81",
+    "modelName": "o4-mini",
+    "matchPattern": "(?i)^(o4-mini)$",
+    "createdAt": "2025-04-16T23:26:54.132Z",
+    "updatedAt": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "id": "cm7wqrs1327124dhjtb95w8f81_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 2.75e-7,
+          "input_cache_read": 2.75e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7zqrs1327124dhjtb95w8f82",
+    "modelName": "o4-mini-2025-04-16",
+    "matchPattern": "(?i)^(o4-mini-2025-04-16)$",
+    "createdAt": "2025-04-16T23:26:54.132Z",
+    "updatedAt": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "id": "cm7zqrs1327124dhjtb95w8f82_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 2.75e-7,
+          "input_cache_read": 2.75e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7zsrs1327124dhjtb95w8f74",
+    "modelName": "gemini-2.0-flash",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.0-flash)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2025-04-22T10:11:35.241Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cm7zsrs1327124dhjtb95w8f74_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7ztrs1327124dhjtb95w8f19",
+    "modelName": "gemini-2.0-flash-lite-preview",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.0-flash-lite-preview)(@[a-zA-Z0-9]+)?$",
+    "createdAt": "2025-04-22T10:11:35.241Z",
+    "updatedAt": "2026-03-06T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cm7ztrs1327124dhjtb95w8f19_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-8,
+          "output": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7zxrs1327124dhjtb95w8f45",
+    "modelName": "gpt-4.1-nano",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1-nano)$",
+    "createdAt": "2025-04-22T10:11:35.241Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7zxrs1327124dhjtb95w8f45_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "input_cached_text_tokens": 2.5e-8,
+          "input_cache_read": 2.5e-8,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cm7zzrs1327124dhjtb95w8p96",
+    "modelName": "gpt-4.1-mini",
+    "matchPattern": "(?i)^(openai\/)?(gpt-4.1-mini)$",
+    "createdAt": "2025-04-22T10:11:35.241Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cm7zzrs1327124dhjtb95w8p96_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "input_cached_tokens": 1e-7,
+          "input_cached_text_tokens": 1e-7,
+          "input_cache_read": 1e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "id": "c5qmrqolku82tra3vgdixmys",
+    "modelName": "claude-sonnet-4-5-20250929",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-sonnet-4-5(-20250929)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4-5(-20250929)?-v1(:0)?|claude-sonnet-4-5-V1(@20250929)?|claude-sonnet-4-5(@20250929)?)$",
+    "createdAt": "2025-09-29T00:00:00.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "c5qmrqolku82tra3vgdixmys_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      },
+      {
+        "id": "00b65240-047b-4722-9590-808edbc2067f",
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "input",
+            "operator": "gt",
+            "value": 200000,
+            "caseSensitive": false
+          }
+        ],
+        "prices": {
+          "input": 0.000006,
+          "input_tokens": 0.000006,
+          "output": 0.0000225,
+          "output_tokens": 0.0000225,
+          "cache_creation_input_tokens": 0.0000075,
+          "input_cache_creation": 0.0000075,
+          "input_cache_creation_5m": 0.0000075,
+          "input_cache_creation_1h": 0.000012,
+          "cache_read_input_tokens": 6e-7,
+          "input_cache_read": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmazmkzlm00000djp1e1qe4k4",
+    "modelName": "claude-sonnet-4-20250514",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-sonnet-4(-20250514)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4(-20250514)?-v1(:0)?|claude-sonnet-4-V1(@20250514)?|claude-sonnet-4(@20250514)?)$",
+    "createdAt": "2025-05-22T17:09:02.131Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmazmkzlm00000djp1e1qe4k4_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmazmlbnv00010djpazed91va",
+    "modelName": "claude-sonnet-4-latest",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-sonnet-4-latest)$",
+    "createdAt": "2025-05-22T17:09:02.131Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmazmlbnv00010djpazed91va_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmazmlm2p00020djpa9s64jw5",
+    "modelName": "claude-opus-4-20250514",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-opus-4(-20250514)?|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-opus-4(-20250514)?-v1(:0)?|claude-opus-4(@20250514)?)$",
+    "createdAt": "2025-05-22T17:09:02.131Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmazmlm2p00020djpa9s64jw5_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_tokens": 0.000015,
+          "output": 0.000075,
+          "output_tokens": 0.000075,
+          "cache_creation_input_tokens": 0.00001875,
+          "input_cache_creation": 0.00001875,
+          "input_cache_creation_5m": 0.00001875,
+          "input_cache_creation_1h": 0.00003,
+          "cache_read_input_tokens": 0.0000015,
+          "input_cache_read": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmz9x72kq55721pqrs83y4n2bx",
+    "modelName": "o3-pro",
+    "matchPattern": "(?i)^(openai\/)?(o3-pro)$",
+    "createdAt": "2025-06-10T22:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cmz9x72kq55721pqrs83y4n2bx_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00002,
+          "output": 0.00008,
+          "output_reasoning_tokens": 0.00008,
+          "output_reasoning": 0.00008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmz9x72kq55721pqrs83y4n2by",
+    "modelName": "o3-pro-2025-06-10",
+    "matchPattern": "(?i)^(openai\/)?(o3-pro-2025-06-10)$",
+    "createdAt": "2025-06-10T22:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cmz9x72kq55721pqrs83y4n2by_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00002,
+          "output": 0.00008,
+          "output_reasoning_tokens": 0.00008,
+          "output_reasoning": 0.00008
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmbrold5b000107lbftb9fdoo",
+    "modelName": "o1-pro",
+    "matchPattern": "(?i)^(openai\/)?(o1-pro)$",
+    "createdAt": "2025-06-10T22:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cmbrold5b000107lbftb9fdoo_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00015,
+          "output": 0.0006,
+          "output_reasoning_tokens": 0.0006,
+          "output_reasoning": 0.0006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmbrolpax000207lb3xkedysz",
+    "modelName": "o1-pro-2025-03-19",
+    "matchPattern": "(?i)^(openai\/)?(o1-pro-2025-03-19)$",
+    "createdAt": "2025-06-10T22:26:54.132Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "pricingTiers": [
+      {
+        "id": "cmbrolpax000207lb3xkedysz_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00015,
+          "output": 0.0006,
+          "output_reasoning_tokens": 0.0006,
+          "output_reasoning": 0.0006
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmcnjkfwn000107l43bf5e8ax",
+    "modelName": "gemini-2.5-flash",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.5-flash)$",
+    "createdAt": "2025-07-03T13:44:06.964Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cmcnjkfwn000107l43bf5e8ax_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 3e-7,
+          "input_text": 3e-7,
+          "input_modality_1": 3e-7,
+          "prompt_token_count": 3e-7,
+          "promptTokenCount": 3e-7,
+          "input_cached_tokens": 3e-8,
+          "cached_content_token_count": 3e-8,
+          "output": 0.0000025,
+          "output_text": 0.0000025,
+          "output_modality_1": 0.0000025,
+          "candidates_token_count": 0.0000025,
+          "candidatesTokenCount": 0.0000025,
+          "thoughtsTokenCount": 0.0000025,
+          "thoughts_token_count": 0.0000025,
+          "output_reasoning": 0.0000025,
+          "input_audio_tokens": 0.000001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmcnjkrfa000207l4fpnh5mnv",
+    "modelName": "gemini-2.5-flash-lite",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.5-flash-lite)$",
+    "createdAt": "2025-07-03T13:44:06.964Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cmcnjkrfa000207l4fpnh5mnv_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_text": 1e-7,
+          "input_modality_1": 1e-7,
+          "prompt_token_count": 1e-7,
+          "promptTokenCount": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "cached_content_token_count": 2.5e-8,
+          "output": 4e-7,
+          "output_text": 4e-7,
+          "output_modality_1": 4e-7,
+          "candidates_token_count": 4e-7,
+          "candidatesTokenCount": 4e-7,
+          "thoughtsTokenCount": 4e-7,
+          "thoughts_token_count": 4e-7,
+          "output_reasoning": 4e-7,
+          "input_audio_tokens": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmdysde5w0000rkmzbc1g5au3",
+    "modelName": "claude-opus-4-1-20250805",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-opus-4-1(-20250805)?|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-opus-4-1(-20250805)?-v1(:0)?|claude-opus-4-1(@20250805)?)$",
+    "createdAt": "2025-08-05T15:00:00.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmdysde5w0000rkmzbc1g5au3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_tokens": 0.000015,
+          "output": 0.000075,
+          "output_tokens": 0.000075,
+          "cache_creation_input_tokens": 0.00001875,
+          "input_cache_creation": 0.00001875,
+          "input_cache_creation_5m": 0.00001875,
+          "input_cache_creation_1h": 0.00003,
+          "cache_read_input_tokens": 0.0000015,
+          "input_cache_read": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "id": "38c3822a-09a3-457b-b200-2c6f17f7cf2f",
+    "modelName": "gpt-5",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5)$",
+    "createdAt": "2025-08-07T16:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "38c3822a-09a3-457b-b200-2c6f17f7cf2f_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "12543803-2d5f-4189-addc-821ad71c8b55",
+    "modelName": "gpt-5-2025-08-07",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-2025-08-07)$",
+    "createdAt": "2025-08-11T08:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "12543803-2d5f-4189-addc-821ad71c8b55_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "3d6a975a-a42d-4ea2-a3ec-4ae567d5a364",
+    "modelName": "gpt-5-mini",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-mini)$",
+    "createdAt": "2025-08-07T16:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "3d6a975a-a42d-4ea2-a3ec-4ae567d5a364_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "input_cached_tokens": 2.5e-8,
+          "output": 0.000002,
+          "input_cache_read": 2.5e-8,
+          "output_reasoning_tokens": 0.000002,
+          "output_reasoning": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "03b83894-7172-4e1e-8e8b-37d792484efd",
+    "modelName": "gpt-5-mini-2025-08-07",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-mini-2025-08-07)$",
+    "createdAt": "2025-08-11T08:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "03b83894-7172-4e1e-8e8b-37d792484efd_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "input_cached_tokens": 2.5e-8,
+          "output": 0.000002,
+          "input_cache_read": 2.5e-8,
+          "output_reasoning_tokens": 0.000002,
+          "output_reasoning": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "id": "f0b40234-b694-4c40-9494-7b0efd860fb9",
+    "modelName": "gpt-5-nano",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-nano)$",
+    "createdAt": "2025-08-07T16:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "f0b40234-b694-4c40-9494-7b0efd860fb9_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-8,
+          "input_cached_tokens": 5e-9,
+          "output": 4e-7,
+          "input_cache_read": 5e-9,
+          "output_reasoning_tokens": 4e-7,
+          "output_reasoning": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "4489fde4-a594-4011-948b-526989300cd3",
+    "modelName": "gpt-5-nano-2025-08-07",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-nano-2025-08-07)$",
+    "createdAt": "2025-08-11T08:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "4489fde4-a594-4011-948b-526989300cd3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-8,
+          "input_cached_tokens": 5e-9,
+          "output": 4e-7,
+          "input_cache_read": 5e-9,
+          "output_reasoning_tokens": 4e-7,
+          "output_reasoning": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "8ba72ee3-ebe8-4110-a614-bf81094447e5",
+    "modelName": "gpt-5-chat-latest",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-chat-latest)$",
+    "createdAt": "2025-08-07T16:00:00.000Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "8ba72ee3-ebe8-4110-a614-bf81094447e5_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmgg9zco3000004l258um9xk8",
+    "modelName": "gpt-5-pro",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-pro)$",
+    "createdAt": "2025-10-07T08:03:54.727Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmgg9zco3000004l258um9xk8_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.00012,
+          "output_reasoning_tokens": 0.00012,
+          "output_reasoning": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmgga0vh9000104l22qe4fes4",
+    "modelName": "gpt-5-pro-2025-10-06",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5-pro-2025-10-06)$",
+    "createdAt": "2025-10-07T08:03:54.727Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmgga0vh9000104l22qe4fes4_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.00012,
+          "output_reasoning_tokens": 0.00012,
+          "output_reasoning": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmgt5gnkv000104jx171tbq4e",
+    "modelName": "claude-haiku-4-5-20251001",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-haiku-4-5-20251001|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-haiku-4-5-20251001-v1:0|claude-4-5-haiku@20251001)$",
+    "createdAt": "2025-10-16T08:20:44.558Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmgt5gnkv000104jx171tbq4e_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000001,
+          "input_tokens": 0.000001,
+          "output": 0.000005,
+          "output_tokens": 0.000005,
+          "cache_creation_input_tokens": 0.00000125,
+          "input_cache_creation": 0.00000125,
+          "input_cache_creation_5m": 0.00000125,
+          "input_cache_creation_1h": 0.000002,
+          "cache_read_input_tokens": 1e-7,
+          "input_cache_read": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmhymgpym000d04ih34rndvhr",
+    "modelName": "gpt-5.1",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.1)$",
+    "createdAt": "2025-11-14T08:57:23.481Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmhymgpym000d04ih34rndvhr_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmhymgxiw000e04ihh9pw12ef",
+    "modelName": "gpt-5.1-2025-11-13",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.1-2025-11-13)$",
+    "createdAt": "2025-11-14T08:57:23.481Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmhymgxiw000e04ihh9pw12ef_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmieupdva000004l541kwae70",
+    "modelName": "claude-opus-4-5-20251101",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-opus-4-5(-20251101)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-opus-4-5(-20251101)?-v1(:0)?|claude-opus-4-5(@20251101)?)$",
+    "createdAt": "2025-11-24T20:53:27.571Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerConfig": null,
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "cmieupdva000004l541kwae70_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-6,
+          "input_tokens": 5e-6,
+          "output": 25e-6,
+          "output_tokens": 25e-6,
+          "cache_creation_input_tokens": 6.25e-6,
+          "input_cache_creation": 6.25e-6,
+          "input_cache_creation_5m": 6.25e-6,
+          "input_cache_creation_1h": 10e-6,
+          "cache_read_input_tokens": 0.5e-6,
+          "input_cache_read": 0.5e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "90ec5ec3-1a48-4ff0-919c-70cdb8f632ed",
+    "modelName": "claude-sonnet-4-6",
+    "matchPattern": "(?i)^(anthropic\\/)?(claude-sonnet-4-6|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4-6(-v1(:0)?)?|claude-sonnet-4-6)$",
+    "createdAt": "2026-02-18T00:00:00.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerConfig": null,
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "90ec5ec3-1a48-4ff0-919c-70cdb8f632ed_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 3e-6,
+          "input_tokens": 3e-6,
+          "output": 15e-6,
+          "output_tokens": 15e-6,
+          "cache_creation_input_tokens": 3.75e-6,
+          "input_cache_creation": 3.75e-6,
+          "input_cache_creation_5m": 3.75e-6,
+          "input_cache_creation_1h": 6e-6,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      },
+      {
+        "id": "7830bfc2-c464-4ffe-b9a2-6e741f6c5486",
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "input",
+            "operator": "gt",
+            "value": 200000,
+            "caseSensitive": false
+          }
+        ],
+        "prices": {
+          "input": 6e-6,
+          "input_tokens": 6e-6,
+          "output": 22.5e-6,
+          "output_tokens": 22.5e-6,
+          "cache_creation_input_tokens": 7.5e-6,
+          "input_cache_creation": 7.5e-6,
+          "input_cache_creation_5m": 7.5e-6,
+          "input_cache_creation_1h": 12e-6,
+          "cache_read_input_tokens": 6e-7,
+          "input_cache_read": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "id": "13458bc0-1c20-44c2-8753-172f54b67647",
+    "modelName": "claude-opus-4-6",
+    "matchPattern": "(?i)^(anthropic\/)?(claude-opus-4-6|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-opus-4-6-v1(:0)?|claude-opus-4-6)$",
+    "createdAt": "2026-02-09T00:00:00.000Z",
+    "updatedAt": "2026-03-04T00:00:00.000Z",
+    "tokenizerConfig": null,
+    "tokenizerId": "claude",
+    "pricingTiers": [
+      {
+        "id": "13458bc0-1c20-44c2-8753-172f54b67647_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-6,
+          "input_tokens": 5e-6,
+          "output": 25e-6,
+          "output_tokens": 25e-6,
+          "cache_creation_input_tokens": 6.25e-6,
+          "input_cache_creation": 6.25e-6,
+          "input_cache_creation_5m": 6.25e-6,
+          "input_cache_creation_1h": 10e-6,
+          "cache_read_input_tokens": 0.5e-6,
+          "input_cache_read": 0.5e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmig1hb7i000104l72qrzgc6h",
+    "modelName": "gemini-2.5-pro",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-2.5-pro)$",
+    "createdAt": "2025-11-26T13:27:53.545Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cmig1hb7i000104l72qrzgc6h_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-6,
+          "input_text": 1.25e-6,
+          "input_modality_1": 1.25e-6,
+          "prompt_token_count": 1.25e-6,
+          "promptTokenCount": 1.25e-6,
+          "input_cached_tokens": 0.125e-6,
+          "cached_content_token_count": 0.125e-6,
+          "output": 10e-6,
+          "output_text": 10e-6,
+          "output_modality_1": 10e-6,
+          "candidates_token_count": 10e-6,
+          "candidatesTokenCount": 10e-6,
+          "thoughtsTokenCount": 10e-6,
+          "thoughts_token_count": 10e-6,
+          "output_reasoning": 10e-6
+        }
+      },
+      {
+        "id": "bcf39e8f-9969-455f-be9a-541a00256092",
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000,
+            "caseSensitive": false
+          }
+        ],
+        "prices": {
+          "input": 2.5e-6,
+          "input_text": 2.5e-6,
+          "input_modality_1": 2.5e-6,
+          "prompt_token_count": 2.5e-6,
+          "promptTokenCount": 2.5e-6,
+          "input_cached_tokens": 0.25e-6,
+          "cached_content_token_count": 0.25e-6,
+          "output": 15e-6,
+          "output_text": 15e-6,
+          "output_modality_1": 15e-6,
+          "candidates_token_count": 15e-6,
+          "candidatesTokenCount": 15e-6,
+          "thoughtsTokenCount": 15e-6,
+          "thoughts_token_count": 15e-6,
+          "output_reasoning": 15e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmig1wmep000404l7fh6q5uog",
+    "modelName": "gemini-3-pro-preview",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-3-pro-preview)$",
+    "createdAt": "2025-11-26T13:27:53.545Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cmig1wmep000404l7fh6q5uog_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2e-6,
+          "input_text": 2e-6,
+          "input_modality_1": 2e-6,
+          "prompt_token_count": 2e-6,
+          "promptTokenCount": 2e-6,
+          "input_cached_tokens": 0.2e-6,
+          "cached_content_token_count": 0.2e-6,
+          "output": 12e-6,
+          "output_text": 12e-6,
+          "output_modality_1": 12e-6,
+          "candidates_token_count": 12e-6,
+          "candidatesTokenCount": 12e-6,
+          "thoughtsTokenCount": 12e-6,
+          "thoughts_token_count": 12e-6,
+          "output_reasoning": 12e-6
+        }
+      },
+      {
+        "id": "4da930c8-7146-4e27-b66c-b62f2c2ec357",
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000,
+            "caseSensitive": false
+          }
+        ],
+        "prices": {
+          "input": 4e-6,
+          "input_text": 4e-6,
+          "input_modality_1": 4e-6,
+          "prompt_token_count": 4e-6,
+          "promptTokenCount": 4e-6,
+          "input_cached_tokens": 0.4e-6,
+          "cached_content_token_count": 0.4e-6,
+          "output": 18e-6,
+          "output_text": 18e-6,
+          "output_modality_1": 18e-6,
+          "candidates_token_count": 18e-6,
+          "candidatesTokenCount": 18e-6,
+          "thoughtsTokenCount": 18e-6,
+          "thoughts_token_count": 18e-6,
+          "output_reasoning": 18e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "55106bba-a5dd-441b-bc0d-5652582b349d",
+    "modelName": "gemini-3.1-pro-preview",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-3.1-pro-preview(-customtools)?)$",
+    "createdAt": "2026-02-19T00:00:00.000Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "55106bba-a5dd-441b-bc0d-5652582b349d_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2e-6,
+          "input_modality_1": 2e-6,
+          "input_text": 2e-6,
+          "prompt_token_count": 2e-6,
+          "promptTokenCount": 2e-6,
+          "input_cached_tokens": 0.2e-6,
+          "cached_content_token_count": 0.2e-6,
+          "output": 12e-6,
+          "output_text": 12e-6,
+          "output_modality_1": 12e-6,
+          "candidates_token_count": 12e-6,
+          "candidatesTokenCount": 12e-6,
+          "thoughtsTokenCount": 12e-6,
+          "thoughts_token_count": 12e-6,
+          "output_reasoning": 12e-6
+        }
+      },
+      {
+        "id": "ada11e9f-fe0d-465a-92af-ce334d0eedeb",
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000,
+            "caseSensitive": false
+          }
+        ],
+        "prices": {
+          "input": 4e-6,
+          "input_modality_1": 4e-6,
+          "input_text": 4e-6,
+          "prompt_token_count": 4e-6,
+          "promptTokenCount": 4e-6,
+          "input_cached_tokens": 0.4e-6,
+          "cached_content_token_count": 0.4e-6,
+          "output": 18e-6,
+          "output_text": 18e-6,
+          "output_modality_1": 18e-6,
+          "candidates_token_count": 18e-6,
+          "candidatesTokenCount": 18e-6,
+          "thoughtsTokenCount": 18e-6,
+          "thoughts_token_count": 18e-6,
+          "output_reasoning": 18e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmj2n4f2a000304kz49g4c43u",
+    "modelName": "gpt-5.2",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.2)$",
+    "createdAt": "2025-12-12T09:00:06.513Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmj2n4f2a000304kz49g4c43u_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.75e-6,
+          "input_cached_tokens": 0.175e-6,
+          "input_cache_read": 0.175e-6,
+          "output": 14e-6,
+          "output_reasoning_tokens": 14e-6,
+          "output_reasoning": 14e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmj2muxg6000104kzd2tc8953",
+    "modelName": "gpt-5.2-2025-12-11",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.2-2025-12-11)$",
+    "createdAt": "2025-12-12T09:00:06.513Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmj2muxg6000104kzd2tc8953_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.75e-6,
+          "input_cached_tokens": 0.175e-6,
+          "input_cache_read": 0.175e-6,
+          "output": 14e-6,
+          "output_reasoning_tokens": 14e-6,
+          "output_reasoning": 14e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmj2n6pkq000404kz2s0b6if7",
+    "modelName": "gpt-5.2-pro",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.2-pro)$",
+    "createdAt": "2025-12-12T09:00:06.513Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmj2n6pkq000404kz2s0b6if7_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 21e-6,
+          "output": 168e-6,
+          "output_reasoning_tokens": 168e-6,
+          "output_reasoning": 168e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmj2n70oe000504kz21b76mes",
+    "modelName": "gpt-5.2-pro-2025-12-11",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.2-pro-2025-12-11)$",
+    "createdAt": "2025-12-12T09:00:06.513Z",
+    "updatedAt": "2025-12-12T15:00:06.513Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "cmj2n70oe000504kz21b76mes_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 21e-6,
+          "output": 168e-6,
+          "output_reasoning_tokens": 168e-6,
+          "output_reasoning": 168e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "bee3c111-fe6f-4641-8775-73ea33b29fca",
+    "modelName": "gpt-5.4",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.4)$",
+    "createdAt": "2026-03-05T00:00:00.000Z",
+    "updatedAt": "2026-03-05T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "bee3c111-fe6f-4641-8775-73ea33b29fca_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-6,
+          "input_cached_tokens": 0.25e-6,
+          "input_cache_read": 0.25e-6,
+          "output": 15e-6,
+          "output_reasoning_tokens": 15e-6,
+          "output_reasoning": 15e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "68d32054-8748-4d25-9f64-d78d483601bd",
+    "modelName": "gpt-5.4-pro",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.4-pro)$",
+    "createdAt": "2026-03-05T00:00:00.000Z",
+    "updatedAt": "2026-03-05T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "68d32054-8748-4d25-9f64-d78d483601bd_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 30e-6,
+          "output": 180e-6,
+          "output_reasoning_tokens": 180e-6,
+          "output_reasoning": 180e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "22dfc7e1-1fe1-4286-b1af-928635e7ecb9",
+    "modelName": "gpt-5.4-2026-03-05",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.4-2026-03-05)$",
+    "createdAt": "2026-03-05T00:00:00.000Z",
+    "updatedAt": "2026-03-05T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "22dfc7e1-1fe1-4286-b1af-928635e7ecb9_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-6,
+          "input_cached_tokens": 0.25e-6,
+          "input_cache_read": 0.25e-6,
+          "output": 15e-6,
+          "output_reasoning_tokens": 15e-6,
+          "output_reasoning": 15e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "d8873413-05ab-4374-8223-e8c9005c4a0e",
+    "modelName": "gpt-5.4-pro-2026-03-05",
+    "matchPattern": "(?i)^(openai\/)?(gpt-5.4-pro-2026-03-05)$",
+    "createdAt": "2026-03-05T00:00:00.000Z",
+    "updatedAt": "2026-03-05T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "d8873413-05ab-4374-8223-e8c9005c4a0e_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 30e-6,
+          "output": 180e-6,
+          "output_reasoning_tokens": 180e-6,
+          "output_reasoning": 180e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "4bf01a9f-663f-4302-a05c-b2b42c5348e3",
+    "modelName": "gpt-5.4-mini",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-mini)$",
+    "createdAt": "2026-03-18T00:00:00.000Z",
+    "updatedAt": "2026-03-18T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "4bf01a9f-663f-4302-a05c-b2b42c5348e3_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.75e-6,
+          "input_cached_tokens": 0.075e-6,
+          "input_cache_read": 0.075e-6,
+          "output": 4.5e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "3d8027df-7491-442e-9770-1363ab2452fc",
+    "modelName": "gpt-5.4-mini-2026-03-17",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-mini-2026-03-17)$",
+    "createdAt": "2026-03-18T00:00:00.000Z",
+    "updatedAt": "2026-03-18T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "3d8027df-7491-442e-9770-1363ab2452fc_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.75e-6,
+          "input_cached_tokens": 0.075e-6,
+          "input_cache_read": 0.075e-6,
+          "output": 4.5e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "2d83d130-d0f1-4b5d-be1c-7caf70b8e444",
+    "modelName": "gpt-5.4-nano",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-nano)$",
+    "createdAt": "2026-03-18T00:00:00.000Z",
+    "updatedAt": "2026-03-18T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "2d83d130-d0f1-4b5d-be1c-7caf70b8e444_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.2e-6,
+          "input_cached_tokens": 0.02e-6,
+          "input_cache_read": 0.02e-6,
+          "output": 1.25e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "33c7321b-c56e-45e9-9640-33ba3f5cb4fa",
+    "modelName": "gpt-5.4-nano-2026-03-17",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-nano-2026-03-17)$",
+    "createdAt": "2026-03-18T00:00:00.000Z",
+    "updatedAt": "2026-03-18T00:00:00.000Z",
+    "tokenizerConfig": {
+      "tokensPerName": 1,
+      "tokenizerModel": "gpt-4",
+      "tokensPerMessage": 3
+    },
+    "tokenizerId": "openai",
+    "pricingTiers": [
+      {
+        "id": "33c7321b-c56e-45e9-9640-33ba3f5cb4fa_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.2e-6,
+          "input_cached_tokens": 0.02e-6,
+          "input_cache_read": 0.02e-6,
+          "output": 1.25e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "cmjfoeykl000004l8ffzra8c7",
+    "modelName": "gemini-3-flash-preview",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-3-flash-preview)$",
+    "createdAt": "2025-12-21T12:01:42.282Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "cmjfoeykl000004l8ffzra8c7_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.5e-6,
+          "input_text": 0.5e-6,
+          "input_modality_1": 0.5e-6,
+          "prompt_token_count": 0.5e-6,
+          "promptTokenCount": 0.5e-6,
+          "input_cached_tokens": 0.05e-6,
+          "cached_content_token_count": 0.05e-6,
+          "output": 3e-6,
+          "output_text": 3e-6,
+          "output_modality_1": 3e-6,
+          "candidates_token_count": 3e-6,
+          "candidatesTokenCount": 3e-6,
+          "thoughtsTokenCount": 3e-6,
+          "thoughts_token_count": 3e-6,
+          "output_reasoning": 3e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "0707bef8-10c8-46e2-a871-0436f05f0b92",
+    "modelName": "gemini-3.1-flash-lite-preview",
+    "matchPattern": "(?i)^(google(ai)?\/)?(gemini-3.1-flash-lite-preview)$",
+    "createdAt": "2026-03-03T00:00:00.000Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "id": "0707bef8-10c8-46e2-a871-0436f05f0b92_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.25e-6,
+          "input_modality_1": 0.25e-6,
+          "input_text": 0.25e-6,
+          "prompt_token_count": 0.25e-6,
+          "promptTokenCount": 0.25e-6,
+          "input_cached_tokens": 0.025e-6,
+          "cached_content_token_count": 0.025e-6,
+          "output": 1.5e-6,
+          "output_text": 1.5e-6,
+          "output_modality_1": 1.5e-6,
+          "candidates_token_count": 1.5e-6,
+          "candidatesTokenCount": 1.5e-6,
+          "thoughtsTokenCount": 1.5e-6,
+          "thoughts_token_count": 1.5e-6,
+          "output_reasoning": 1.5e-6,
+          "input_audio_tokens": 0.5e-6
+        }
+      }
+    ]
+  },
+  {
+    "id": "029e6695-ff24-47f0-b37b-7285fb2e5785",
+    "modelName": "gemini-live-2.5-flash-native-audio",
+    "matchPattern": "(?i)^(google\/)?(gemini-live-2.5-flash-native-audio)$",
+    "createdAt": "2026-03-16T00:00:00.000Z",
+    "updatedAt": "2026-03-19T00:00:00.000Z",
+    "tokenizerConfig": null,
+    "tokenizerId": null,
+    "pricingTiers": [
+      {
+        "id": "029e6695-ff24-47f0-b37b-7285fb2e5785_tier_default",
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text": 0.5e-6,
+          "input_audio": 3e-6,
+          "input_image": 3e-6,
+          "output_text": 2e-6,
+          "output_audio": 12e-6
+        }
+      }
+    ]
+  }
+]
diff --git a/internal-packages/llm-model-catalog/src/defaultPrices.ts b/internal-packages/llm-model-catalog/src/defaultPrices.ts
new file mode 100644
index 00000000000..fb347c2bef6
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/defaultPrices.ts
@@ -0,0 +1,3096 @@
+import type { DefaultModelDefinition } from "./types.js";
+
+// Auto-generated from default-model-prices.json — do not edit manually.
+// Run `pnpm run sync-prices` to update the JSON, then `pnpm run generate` to regenerate.
+// Source: https://github.com/langfuse/langfuse
+
+export const defaultModelPrices: DefaultModelDefinition[] = [
+  {
+    "modelName": "gpt-4o",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o)$",
+    "startDate": "2024-05-13T23:15:07.670Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-2024-05-13",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-2024-05-13)$",
+    "startDate": "2024-05-13T23:15:07.670Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "output": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-1106-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-1106-preview)$",
+    "startDate": "2024-04-23T10:37:17.092Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-turbo-vision",
+    "matchPattern": "(?i)^(openai/)?(gpt-4(-\\d{4})?-vision-preview)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-32k",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-32k)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-32k-0613",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-32k-0613)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-1106",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-1106)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000001,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-0613",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-0613)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000015,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-0613",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-0613)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-instruct",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-instruct)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000015,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-ada-001",
+    "matchPattern": "(?i)^(text-ada-001)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.000004
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-babbage-001",
+    "matchPattern": "(?i)^(text-babbage-001)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-curie-001",
+    "matchPattern": "(?i)^(text-curie-001)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-davinci-001",
+    "matchPattern": "(?i)^(text-davinci-001)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-davinci-002",
+    "matchPattern": "(?i)^(text-davinci-002)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-davinci-003",
+    "matchPattern": "(?i)^(text-davinci-003)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 0.00002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-embedding-ada-002-v2",
+    "matchPattern": "(?i)^(text-embedding-ada-002-v2)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-embedding-ada-002",
+    "matchPattern": "(?i)^(text-embedding-ada-002)$",
+    "startDate": "2024-01-24T18:18:50.861Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-16k-0613",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-16k-0613)$",
+    "startDate": "2024-02-03T17:29:57.350Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "output": 0.000004
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-0301",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-0301)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "output": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-32k-0314",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-32k-0314)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00006,
+          "output": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-0314",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-0314)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4",
+    "matchPattern": "(?i)^(openai/)?(gpt-4)$",
+    "startDate": "2024-01-24T10:19:21.693Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-instant-1.2",
+    "matchPattern": "(?i)^(anthropic/)?(claude-instant-1.2)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000163,
+          "output": 0.00000551
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-2.0",
+    "matchPattern": "(?i)^(anthropic/)?(claude-2.0)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-2.1",
+    "matchPattern": "(?i)^(anthropic/)?(claude-2.1)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-1.3",
+    "matchPattern": "(?i)^(anthropic/)?(claude-1.3)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-1.2",
+    "matchPattern": "(?i)^(anthropic/)?(claude-1.2)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-1.1",
+    "matchPattern": "(?i)^(anthropic/)?(claude-1.1)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000008,
+          "output": 0.000024
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-instant-1",
+    "matchPattern": "(?i)^(anthropic/)?(claude-instant-1)$",
+    "startDate": "2024-01-30T15:44:13.447Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000163,
+          "output": 0.00000551
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "babbage-002",
+    "matchPattern": "(?i)^(babbage-002)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "davinci-002",
+    "matchPattern": "(?i)^(davinci-002)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000006,
+          "output": 0.000012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-embedding-3-small",
+    "matchPattern": "(?i)^(text-embedding-3-small)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 2e-8
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-embedding-3-large",
+    "matchPattern": "(?i)^(text-embedding-3-large)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1.3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-0125",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-0125)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo)$",
+    "startDate": "2024-02-13T12:00:37.424Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-0125-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-0125-preview)$",
+    "startDate": "2024-01-26T17:35:21.129Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "ft:gpt-3.5-turbo-1106",
+    "matchPattern": "(?i)^(ft:)(gpt-3.5-turbo-1106:)(.+)(:)(.*)(:)(.+)$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "output": 0.000006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "ft:gpt-3.5-turbo-0613",
+    "matchPattern": "(?i)^(ft:)(gpt-3.5-turbo-0613:)(.+)(:)(.*)(:)(.+)$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000012,
+          "output": 0.000016
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "ft:davinci-002",
+    "matchPattern": "(?i)^(ft:)(davinci-002:)(.+)(:)(.*)(:)(.+)$$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000012,
+          "output": 0.000012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "ft:babbage-002",
+    "matchPattern": "(?i)^(ft:)(babbage-002:)(.+)(:)(.*)(:)(.+)$$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000016,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "chat-bison",
+    "matchPattern": "(?i)^(chat-bison)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "codechat-bison-32k",
+    "matchPattern": "(?i)^(codechat-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "codechat-bison",
+    "matchPattern": "(?i)^(codechat-bison)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-bison-32k",
+    "matchPattern": "(?i)^(text-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "chat-bison-32k",
+    "matchPattern": "(?i)^(chat-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-unicorn",
+    "matchPattern": "(?i)^(text-unicorn)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "output": 0.0000075
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "text-bison",
+    "matchPattern": "(?i)^(text-bison)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "textembedding-gecko",
+    "matchPattern": "(?i)^(textembedding-gecko)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "textembedding-gecko-multilingual",
+    "matchPattern": "(?i)^(textembedding-gecko-multilingual)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "total": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "code-gecko",
+    "matchPattern": "(?i)^(code-gecko)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "code-bison",
+    "matchPattern": "(?i)^(code-bison)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "code-bison-32k",
+    "matchPattern": "(?i)^(code-bison-32k)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-01-31T13:25:02.141Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-3.5-turbo-16k",
+    "matchPattern": "(?i)^(openai/)?(gpt-)(35|3.5)(-turbo-16k)$",
+    "startDate": "2024-02-13T12:00:37.424Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "output": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-turbo-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-turbo-preview)$",
+    "startDate": "2024-02-15T21:21:50.947Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3-opus-20240229",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-opus-20240229|anthropic\\.claude-3-opus-20240229-v1:0|claude-3-opus@20240229)$",
+    "startDate": "2024-03-07T17:55:38.139Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.000075
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3-sonnet-20240229",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-sonnet-20240229|anthropic\\.claude-3-sonnet-20240229-v1:0|claude-3-sonnet@20240229)$",
+    "startDate": "2024-03-07T17:55:38.139Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3-haiku-20240307",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-haiku-20240307|anthropic\\.claude-3-haiku-20240307-v1:0|claude-3-haiku@20240307)$",
+    "startDate": "2024-03-14T09:41:18.736Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 0.00000125
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-1.0-pro-latest",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-1.0-pro-latest)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-04-11T10:27:46.517Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "output": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-1.0-pro",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-1.0-pro)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-04-11T10:27:46.517Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-1.0-pro-001",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-1.0-pro-001)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-04-11T10:27:46.517Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-pro",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-pro)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-04-11T10:27:46.517Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.25e-7,
+          "output": 3.75e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-1.5-pro-latest",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-1.5-pro-latest)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2024-04-11T10:27:46.517Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "output": 0.0000075
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-turbo-2024-04-09",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-turbo-2024-04-09)$",
+    "startDate": "2024-04-23T10:37:17.092Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-turbo",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-turbo)$",
+    "startDate": "2024-04-11T21:13:44.989Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4-preview)$",
+    "startDate": "2024-04-23T10:37:17.092Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00001,
+          "output": 0.00003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3-5-sonnet-20240620",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-5-sonnet-20240620|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-sonnet-20240620-v1:0|claude-3-5-sonnet@20240620)$",
+    "startDate": "2024-06-25T11:47:24.475Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-mini",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-mini)$",
+    "startDate": "2024-07-18T17:56:09.591Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.5e-7,
+          "output": 6e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-mini-2024-07-18",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-mini-2024-07-18)$",
+    "startDate": "2024-07-18T17:56:09.591Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1.5e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8,
+          "output": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-2024-08-06",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-2024-08-06)$",
+    "startDate": "2024-08-07T11:54:31.298Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-preview",
+    "matchPattern": "(?i)^(openai/)?(o1-preview)$",
+    "startDate": "2024-09-13T10:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-preview-2024-09-12",
+    "matchPattern": "(?i)^(openai/)?(o1-preview-2024-09-12)$",
+    "startDate": "2024-09-13T10:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-mini",
+    "matchPattern": "(?i)^(openai/)?(o1-mini)$",
+    "startDate": "2024-09-13T10:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-mini-2024-09-12",
+    "matchPattern": "(?i)^(openai/)?(o1-mini-2024-09-12)$",
+    "startDate": "2024-09-13T10:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3.5-sonnet-20241022",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-5-sonnet-20241022|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-sonnet-20241022-v2:0|claude-3-5-sonnet-V2@20241022)$",
+    "startDate": "2024-10-22T18:48:01.676Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3.5-sonnet-latest",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-5-sonnet-latest)$",
+    "startDate": "2024-10-22T18:48:01.676Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3-5-haiku-20241022",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-5-haiku-20241022|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3-5-haiku-20241022-v1:0|claude-3-5-haiku-V1@20241022)$",
+    "startDate": "2024-11-05T10:30:50.566Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 8e-7,
+          "input_tokens": 8e-7,
+          "output": 0.000004,
+          "output_tokens": 0.000004,
+          "cache_creation_input_tokens": 0.000001,
+          "input_cache_creation": 0.000001,
+          "input_cache_creation_5m": 0.000001,
+          "input_cache_creation_1h": 0.0000016,
+          "cache_read_input_tokens": 8e-8,
+          "input_cache_read": 8e-8
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3.5-haiku-latest",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-5-haiku-latest)$",
+    "startDate": "2024-11-05T10:30:50.566Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 8e-7,
+          "input_tokens": 8e-7,
+          "output": 0.000004,
+          "output_tokens": 0.000004,
+          "cache_creation_input_tokens": 0.000001,
+          "input_cache_creation": 0.000001,
+          "input_cache_creation_5m": 0.000001,
+          "input_cache_creation_1h": 0.0000016,
+          "cache_read_input_tokens": 8e-8,
+          "input_cache_read": 8e-8
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "chatgpt-4o-latest",
+    "matchPattern": "(?i)^(chatgpt-4o-latest)$",
+    "startDate": "2024-11-25T12:47:17.504Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "output": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-2024-11-20",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-2024-11-20)$",
+    "startDate": "2024-12-03T10:06:12.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 0.00000125,
+          "input_cache_read": 0.00000125,
+          "output": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-audio-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-audio-preview)$",
+    "startDate": "2024-12-03T10:19:56.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00001,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-audio-preview-2024-10-01",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-audio-preview-2024-10-01)$",
+    "startDate": "2024-12-03T10:19:56.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00001,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-realtime-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-realtime-preview)$",
+    "startDate": "2024-12-03T10:19:56.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.000005,
+          "input_cached_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00002,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "input_cached_audio_tokens": 0.00002,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4o-realtime-preview-2024-10-01",
+    "matchPattern": "(?i)^(openai/)?(gpt-4o-realtime-preview-2024-10-01)$",
+    "startDate": "2024-12-03T10:19:56.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text_tokens": 0.000005,
+          "input_cached_text_tokens": 0.0000025,
+          "output_text_tokens": 0.00002,
+          "input_audio_tokens": 0.0001,
+          "input_audio": 0.0001,
+          "input_cached_audio_tokens": 0.00002,
+          "output_audio_tokens": 0.0002,
+          "output_audio": 0.0002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1",
+    "matchPattern": "(?i)^(openai/)?(o1)$",
+    "startDate": "2025-01-17T00:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-2024-12-17",
+    "matchPattern": "(?i)^(openai/)?(o1-2024-12-17)$",
+    "startDate": "2025-01-17T00:01:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_cached_tokens": 0.0000075,
+          "input_cache_read": 0.0000075,
+          "output": 0.00006,
+          "output_reasoning_tokens": 0.00006,
+          "output_reasoning": 0.00006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3-mini",
+    "matchPattern": "(?i)^(openai/)?(o3-mini)$",
+    "startDate": "2025-01-31T20:41:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3-mini-2025-01-31",
+    "matchPattern": "(?i)^(openai/)?(o3-mini-2025-01-31)$",
+    "startDate": "2025-01-31T20:41:35.373Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 5.5e-7,
+          "input_cache_read": 5.5e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.0-flash-001",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.0-flash-001)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2025-02-06T11:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.0-flash-lite-preview-02-05",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.0-flash-lite-preview-02-05)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2025-02-06T11:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-8,
+          "output": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3.7-sonnet-20250219",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3.7-sonnet-20250219|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-3.7-sonnet-20250219-v1:0|claude-3-7-sonnet-V1@20250219)$",
+    "startDate": "2025-02-25T09:35:39.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-3.7-sonnet-latest",
+    "matchPattern": "(?i)^(anthropic/)?(claude-3-7-sonnet-latest)$",
+    "startDate": "2025-02-25T09:35:39.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.5-preview",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.5-preview)$",
+    "startDate": "2025-02-27T21:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000075,
+          "input_cached_tokens": 0.0000375,
+          "input_cached_text_tokens": 0.0000375,
+          "input_cache_read": 0.0000375,
+          "output": 0.00015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.5-preview-2025-02-27",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.5-preview-2025-02-27)$",
+    "startDate": "2025-02-27T21:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000075,
+          "input_cached_tokens": 0.0000375,
+          "input_cached_text_tokens": 0.0000375,
+          "input_cache_read": 0.0000375,
+          "output": 0.00015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1)$",
+    "startDate": "2025-04-15T10:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cached_text_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1-2025-04-14",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1-2025-04-14)$",
+    "startDate": "2025-04-15T10:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cached_text_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1-mini-2025-04-14",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1-mini-2025-04-14)$",
+    "startDate": "2025-04-15T10:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "input_cached_tokens": 1e-7,
+          "input_cached_text_tokens": 1e-7,
+          "input_cache_read": 1e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1-nano-2025-04-14",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1-nano-2025-04-14)$",
+    "startDate": "2025-04-15T10:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "input_cached_text_tokens": 2.5e-8,
+          "input_cache_read": 2.5e-8,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3",
+    "matchPattern": "(?i)^(openai/)?(o3)$",
+    "startDate": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008,
+          "output_reasoning_tokens": 0.000008,
+          "output_reasoning": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3-2025-04-16",
+    "matchPattern": "(?i)^(openai/)?(o3-2025-04-16)$",
+    "startDate": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_cached_tokens": 5e-7,
+          "input_cache_read": 5e-7,
+          "output": 0.000008,
+          "output_reasoning_tokens": 0.000008,
+          "output_reasoning": 0.000008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o4-mini",
+    "matchPattern": "(?i)^(o4-mini)$",
+    "startDate": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 2.75e-7,
+          "input_cache_read": 2.75e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o4-mini-2025-04-16",
+    "matchPattern": "(?i)^(o4-mini-2025-04-16)$",
+    "startDate": "2025-04-16T23:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000011,
+          "input_cached_tokens": 2.75e-7,
+          "input_cache_read": 2.75e-7,
+          "output": 0.0000044,
+          "output_reasoning_tokens": 0.0000044,
+          "output_reasoning": 0.0000044
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.0-flash",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.0-flash)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2025-04-22T10:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.0-flash-lite-preview",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.0-flash-lite-preview)(@[a-zA-Z0-9]+)?$",
+    "startDate": "2025-04-22T10:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-8,
+          "output": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1-nano",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1-nano)$",
+    "startDate": "2025-04-22T10:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "input_cached_text_tokens": 2.5e-8,
+          "input_cache_read": 2.5e-8,
+          "output": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-4.1-mini",
+    "matchPattern": "(?i)^(openai/)?(gpt-4.1-mini)$",
+    "startDate": "2025-04-22T10:11:35.241Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 4e-7,
+          "input_cached_tokens": 1e-7,
+          "input_cached_text_tokens": 1e-7,
+          "input_cache_read": 1e-7,
+          "output": 0.0000016
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-sonnet-4-5-20250929",
+    "matchPattern": "(?i)^(anthropic/)?(claude-sonnet-4-5(-20250929)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4-5(-20250929)?-v1(:0)?|claude-sonnet-4-5-V1(@20250929)?|claude-sonnet-4-5(@20250929)?)$",
+    "startDate": "2025-09-29T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      },
+      {
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "input",
+            "operator": "gt",
+            "value": 200000
+          }
+        ],
+        "prices": {
+          "input": 0.000006,
+          "input_tokens": 0.000006,
+          "output": 0.0000225,
+          "output_tokens": 0.0000225,
+          "cache_creation_input_tokens": 0.0000075,
+          "input_cache_creation": 0.0000075,
+          "input_cache_creation_5m": 0.0000075,
+          "input_cache_creation_1h": 0.000012,
+          "cache_read_input_tokens": 6e-7,
+          "input_cache_read": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-sonnet-4-20250514",
+    "matchPattern": "(?i)^(anthropic/)?(claude-sonnet-4(-20250514)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4(-20250514)?-v1(:0)?|claude-sonnet-4-V1(@20250514)?|claude-sonnet-4(@20250514)?)$",
+    "startDate": "2025-05-22T17:09:02.131Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-sonnet-4-latest",
+    "matchPattern": "(?i)^(anthropic/)?(claude-sonnet-4-latest)$",
+    "startDate": "2025-05-22T17:09:02.131Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-opus-4-20250514",
+    "matchPattern": "(?i)^(anthropic/)?(claude-opus-4(-20250514)?|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-opus-4(-20250514)?-v1(:0)?|claude-opus-4(@20250514)?)$",
+    "startDate": "2025-05-22T17:09:02.131Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_tokens": 0.000015,
+          "output": 0.000075,
+          "output_tokens": 0.000075,
+          "cache_creation_input_tokens": 0.00001875,
+          "input_cache_creation": 0.00001875,
+          "input_cache_creation_5m": 0.00001875,
+          "input_cache_creation_1h": 0.00003,
+          "cache_read_input_tokens": 0.0000015,
+          "input_cache_read": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3-pro",
+    "matchPattern": "(?i)^(openai/)?(o3-pro)$",
+    "startDate": "2025-06-10T22:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00002,
+          "output": 0.00008,
+          "output_reasoning_tokens": 0.00008,
+          "output_reasoning": 0.00008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o3-pro-2025-06-10",
+    "matchPattern": "(?i)^(openai/)?(o3-pro-2025-06-10)$",
+    "startDate": "2025-06-10T22:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00002,
+          "output": 0.00008,
+          "output_reasoning_tokens": 0.00008,
+          "output_reasoning": 0.00008
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-pro",
+    "matchPattern": "(?i)^(openai/)?(o1-pro)$",
+    "startDate": "2025-06-10T22:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00015,
+          "output": 0.0006,
+          "output_reasoning_tokens": 0.0006,
+          "output_reasoning": 0.0006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "o1-pro-2025-03-19",
+    "matchPattern": "(?i)^(openai/)?(o1-pro-2025-03-19)$",
+    "startDate": "2025-06-10T22:26:54.132Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00015,
+          "output": 0.0006,
+          "output_reasoning_tokens": 0.0006,
+          "output_reasoning": 0.0006
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.5-flash",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.5-flash)$",
+    "startDate": "2025-07-03T13:44:06.964Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 3e-7,
+          "input_text": 3e-7,
+          "input_modality_1": 3e-7,
+          "prompt_token_count": 3e-7,
+          "promptTokenCount": 3e-7,
+          "input_cached_tokens": 3e-8,
+          "cached_content_token_count": 3e-8,
+          "output": 0.0000025,
+          "output_text": 0.0000025,
+          "output_modality_1": 0.0000025,
+          "candidates_token_count": 0.0000025,
+          "candidatesTokenCount": 0.0000025,
+          "thoughtsTokenCount": 0.0000025,
+          "thoughts_token_count": 0.0000025,
+          "output_reasoning": 0.0000025,
+          "input_audio_tokens": 0.000001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.5-flash-lite",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.5-flash-lite)$",
+    "startDate": "2025-07-03T13:44:06.964Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 1e-7,
+          "input_text": 1e-7,
+          "input_modality_1": 1e-7,
+          "prompt_token_count": 1e-7,
+          "promptTokenCount": 1e-7,
+          "input_cached_tokens": 2.5e-8,
+          "cached_content_token_count": 2.5e-8,
+          "output": 4e-7,
+          "output_text": 4e-7,
+          "output_modality_1": 4e-7,
+          "candidates_token_count": 4e-7,
+          "candidatesTokenCount": 4e-7,
+          "thoughtsTokenCount": 4e-7,
+          "thoughts_token_count": 4e-7,
+          "output_reasoning": 4e-7,
+          "input_audio_tokens": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-opus-4-1-20250805",
+    "matchPattern": "(?i)^(anthropic/)?(claude-opus-4-1(-20250805)?|(eu\\.|us\\.|apac\\.)?anthropic\\.claude-opus-4-1(-20250805)?-v1(:0)?|claude-opus-4-1(@20250805)?)$",
+    "startDate": "2025-08-05T15:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "input_tokens": 0.000015,
+          "output": 0.000075,
+          "output_tokens": 0.000075,
+          "cache_creation_input_tokens": 0.00001875,
+          "input_cache_creation": 0.00001875,
+          "input_cache_creation_5m": 0.00001875,
+          "input_cache_creation_1h": 0.00003,
+          "cache_read_input_tokens": 0.0000015,
+          "input_cache_read": 0.0000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5",
+    "matchPattern": "(?i)^(openai/)?(gpt-5)$",
+    "startDate": "2025-08-07T16:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-2025-08-07",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-2025-08-07)$",
+    "startDate": "2025-08-11T08:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-mini",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-mini)$",
+    "startDate": "2025-08-07T16:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "input_cached_tokens": 2.5e-8,
+          "output": 0.000002,
+          "input_cache_read": 2.5e-8,
+          "output_reasoning_tokens": 0.000002,
+          "output_reasoning": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-mini-2025-08-07",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-mini-2025-08-07)$",
+    "startDate": "2025-08-11T08:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "input_cached_tokens": 2.5e-8,
+          "output": 0.000002,
+          "input_cache_read": 2.5e-8,
+          "output_reasoning_tokens": 0.000002,
+          "output_reasoning": 0.000002
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-nano",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-nano)$",
+    "startDate": "2025-08-07T16:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-8,
+          "input_cached_tokens": 5e-9,
+          "output": 4e-7,
+          "input_cache_read": 5e-9,
+          "output_reasoning_tokens": 4e-7,
+          "output_reasoning": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-nano-2025-08-07",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-nano-2025-08-07)$",
+    "startDate": "2025-08-11T08:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-8,
+          "input_cached_tokens": 5e-9,
+          "output": 4e-7,
+          "input_cache_read": 5e-9,
+          "output_reasoning_tokens": 4e-7,
+          "output_reasoning": 4e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-chat-latest",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-chat-latest)$",
+    "startDate": "2025-08-07T16:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-pro",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-pro)$",
+    "startDate": "2025-10-07T08:03:54.727Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.00012,
+          "output_reasoning_tokens": 0.00012,
+          "output_reasoning": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5-pro-2025-10-06",
+    "matchPattern": "(?i)^(openai/)?(gpt-5-pro-2025-10-06)$",
+    "startDate": "2025-10-07T08:03:54.727Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000015,
+          "output": 0.00012,
+          "output_reasoning_tokens": 0.00012,
+          "output_reasoning": 0.00012
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-haiku-4-5-20251001",
+    "matchPattern": "(?i)^(anthropic/)?(claude-haiku-4-5-20251001|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-haiku-4-5-20251001-v1:0|claude-4-5-haiku@20251001)$",
+    "startDate": "2025-10-16T08:20:44.558Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000001,
+          "input_tokens": 0.000001,
+          "output": 0.000005,
+          "output_tokens": 0.000005,
+          "cache_creation_input_tokens": 0.00000125,
+          "input_cache_creation": 0.00000125,
+          "input_cache_creation_5m": 0.00000125,
+          "input_cache_creation_1h": 0.000002,
+          "cache_read_input_tokens": 1e-7,
+          "input_cache_read": 1e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.1",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.1)$",
+    "startDate": "2025-11-14T08:57:23.481Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.1-2025-11-13",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.1-2025-11-13)$",
+    "startDate": "2025-11-14T08:57:23.481Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "output": 0.00001,
+          "input_cache_read": 1.25e-7,
+          "output_reasoning_tokens": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-opus-4-5-20251101",
+    "matchPattern": "(?i)^(anthropic/)?(claude-opus-4-5(-20251101)?|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-opus-4-5(-20251101)?-v1(:0)?|claude-opus-4-5(@20251101)?)$",
+    "startDate": "2025-11-24T20:53:27.571Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "input_tokens": 0.000005,
+          "output": 0.000025,
+          "output_tokens": 0.000025,
+          "cache_creation_input_tokens": 0.00000625,
+          "input_cache_creation": 0.00000625,
+          "input_cache_creation_5m": 0.00000625,
+          "input_cache_creation_1h": 0.00001,
+          "cache_read_input_tokens": 5e-7,
+          "input_cache_read": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-sonnet-4-6",
+    "matchPattern": "(?i)^(anthropic\\/)?(claude-sonnet-4-6|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-sonnet-4-6(-v1(:0)?)?|claude-sonnet-4-6)$",
+    "startDate": "2026-02-18T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000003,
+          "input_tokens": 0.000003,
+          "output": 0.000015,
+          "output_tokens": 0.000015,
+          "cache_creation_input_tokens": 0.00000375,
+          "input_cache_creation": 0.00000375,
+          "input_cache_creation_5m": 0.00000375,
+          "input_cache_creation_1h": 0.000006,
+          "cache_read_input_tokens": 3e-7,
+          "input_cache_read": 3e-7
+        }
+      },
+      {
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "input",
+            "operator": "gt",
+            "value": 200000
+          }
+        ],
+        "prices": {
+          "input": 0.000006,
+          "input_tokens": 0.000006,
+          "output": 0.0000225,
+          "output_tokens": 0.0000225,
+          "cache_creation_input_tokens": 0.0000075,
+          "input_cache_creation": 0.0000075,
+          "input_cache_creation_5m": 0.0000075,
+          "input_cache_creation_1h": 0.000012,
+          "cache_read_input_tokens": 6e-7,
+          "input_cache_read": 6e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "claude-opus-4-6",
+    "matchPattern": "(?i)^(anthropic/)?(claude-opus-4-6|(eu\\.|us\\.|apac\\.|global\\.)?anthropic\\.claude-opus-4-6-v1(:0)?|claude-opus-4-6)$",
+    "startDate": "2026-02-09T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000005,
+          "input_tokens": 0.000005,
+          "output": 0.000025,
+          "output_tokens": 0.000025,
+          "cache_creation_input_tokens": 0.00000625,
+          "input_cache_creation": 0.00000625,
+          "input_cache_creation_5m": 0.00000625,
+          "input_cache_creation_1h": 0.00001,
+          "cache_read_input_tokens": 5e-7,
+          "input_cache_read": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-2.5-pro",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-2.5-pro)$",
+    "startDate": "2025-11-26T13:27:53.545Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000125,
+          "input_text": 0.00000125,
+          "input_modality_1": 0.00000125,
+          "prompt_token_count": 0.00000125,
+          "promptTokenCount": 0.00000125,
+          "input_cached_tokens": 1.25e-7,
+          "cached_content_token_count": 1.25e-7,
+          "output": 0.00001,
+          "output_text": 0.00001,
+          "output_modality_1": 0.00001,
+          "candidates_token_count": 0.00001,
+          "candidatesTokenCount": 0.00001,
+          "thoughtsTokenCount": 0.00001,
+          "thoughts_token_count": 0.00001,
+          "output_reasoning": 0.00001
+        }
+      },
+      {
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000
+          }
+        ],
+        "prices": {
+          "input": 0.0000025,
+          "input_text": 0.0000025,
+          "input_modality_1": 0.0000025,
+          "prompt_token_count": 0.0000025,
+          "promptTokenCount": 0.0000025,
+          "input_cached_tokens": 2.5e-7,
+          "cached_content_token_count": 2.5e-7,
+          "output": 0.000015,
+          "output_text": 0.000015,
+          "output_modality_1": 0.000015,
+          "candidates_token_count": 0.000015,
+          "candidatesTokenCount": 0.000015,
+          "thoughtsTokenCount": 0.000015,
+          "thoughts_token_count": 0.000015,
+          "output_reasoning": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-3-pro-preview",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-3-pro-preview)$",
+    "startDate": "2025-11-26T13:27:53.545Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_text": 0.000002,
+          "input_modality_1": 0.000002,
+          "prompt_token_count": 0.000002,
+          "promptTokenCount": 0.000002,
+          "input_cached_tokens": 2e-7,
+          "cached_content_token_count": 2e-7,
+          "output": 0.000012,
+          "output_text": 0.000012,
+          "output_modality_1": 0.000012,
+          "candidates_token_count": 0.000012,
+          "candidatesTokenCount": 0.000012,
+          "thoughtsTokenCount": 0.000012,
+          "thoughts_token_count": 0.000012,
+          "output_reasoning": 0.000012
+        }
+      },
+      {
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000
+          }
+        ],
+        "prices": {
+          "input": 0.000004,
+          "input_text": 0.000004,
+          "input_modality_1": 0.000004,
+          "prompt_token_count": 0.000004,
+          "promptTokenCount": 0.000004,
+          "input_cached_tokens": 4e-7,
+          "cached_content_token_count": 4e-7,
+          "output": 0.000018,
+          "output_text": 0.000018,
+          "output_modality_1": 0.000018,
+          "candidates_token_count": 0.000018,
+          "candidatesTokenCount": 0.000018,
+          "thoughtsTokenCount": 0.000018,
+          "thoughts_token_count": 0.000018,
+          "output_reasoning": 0.000018
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-3.1-pro-preview",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-3.1-pro-preview(-customtools)?)$",
+    "startDate": "2026-02-19T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000002,
+          "input_modality_1": 0.000002,
+          "input_text": 0.000002,
+          "prompt_token_count": 0.000002,
+          "promptTokenCount": 0.000002,
+          "input_cached_tokens": 2e-7,
+          "cached_content_token_count": 2e-7,
+          "output": 0.000012,
+          "output_text": 0.000012,
+          "output_modality_1": 0.000012,
+          "candidates_token_count": 0.000012,
+          "candidatesTokenCount": 0.000012,
+          "thoughtsTokenCount": 0.000012,
+          "thoughts_token_count": 0.000012,
+          "output_reasoning": 0.000012
+        }
+      },
+      {
+        "name": "Large Context",
+        "isDefault": false,
+        "priority": 1,
+        "conditions": [
+          {
+            "usageDetailPattern": "(input|prompt|cached)",
+            "operator": "gt",
+            "value": 200000
+          }
+        ],
+        "prices": {
+          "input": 0.000004,
+          "input_modality_1": 0.000004,
+          "input_text": 0.000004,
+          "prompt_token_count": 0.000004,
+          "promptTokenCount": 0.000004,
+          "input_cached_tokens": 4e-7,
+          "cached_content_token_count": 4e-7,
+          "output": 0.000018,
+          "output_text": 0.000018,
+          "output_modality_1": 0.000018,
+          "candidates_token_count": 0.000018,
+          "candidatesTokenCount": 0.000018,
+          "thoughtsTokenCount": 0.000018,
+          "thoughts_token_count": 0.000018,
+          "output_reasoning": 0.000018
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.2",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.2)$",
+    "startDate": "2025-12-12T09:00:06.513Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000175,
+          "input_cached_tokens": 1.75e-7,
+          "input_cache_read": 1.75e-7,
+          "output": 0.000014,
+          "output_reasoning_tokens": 0.000014,
+          "output_reasoning": 0.000014
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.2-2025-12-11",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.2-2025-12-11)$",
+    "startDate": "2025-12-12T09:00:06.513Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00000175,
+          "input_cached_tokens": 1.75e-7,
+          "input_cache_read": 1.75e-7,
+          "output": 0.000014,
+          "output_reasoning_tokens": 0.000014,
+          "output_reasoning": 0.000014
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.2-pro",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.2-pro)$",
+    "startDate": "2025-12-12T09:00:06.513Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000021,
+          "output": 0.000168,
+          "output_reasoning_tokens": 0.000168,
+          "output_reasoning": 0.000168
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.2-pro-2025-12-11",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.2-pro-2025-12-11)$",
+    "startDate": "2025-12-12T09:00:06.513Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.000021,
+          "output": 0.000168,
+          "output_reasoning_tokens": 0.000168,
+          "output_reasoning": 0.000168
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.4)$",
+    "startDate": "2026-03-05T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 2.5e-7,
+          "input_cache_read": 2.5e-7,
+          "output": 0.000015,
+          "output_reasoning_tokens": 0.000015,
+          "output_reasoning": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-pro",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.4-pro)$",
+    "startDate": "2026-03-05T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00018,
+          "output_reasoning_tokens": 0.00018,
+          "output_reasoning": 0.00018
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-2026-03-05",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.4-2026-03-05)$",
+    "startDate": "2026-03-05T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.0000025,
+          "input_cached_tokens": 2.5e-7,
+          "input_cache_read": 2.5e-7,
+          "output": 0.000015,
+          "output_reasoning_tokens": 0.000015,
+          "output_reasoning": 0.000015
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-pro-2026-03-05",
+    "matchPattern": "(?i)^(openai/)?(gpt-5.4-pro-2026-03-05)$",
+    "startDate": "2026-03-05T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 0.00003,
+          "output": 0.00018,
+          "output_reasoning_tokens": 0.00018,
+          "output_reasoning": 0.00018
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-mini",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-mini)$",
+    "startDate": "2026-03-18T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8,
+          "output": 0.0000045
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-mini-2026-03-17",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-mini-2026-03-17)$",
+    "startDate": "2026-03-18T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 7.5e-7,
+          "input_cached_tokens": 7.5e-8,
+          "input_cache_read": 7.5e-8,
+          "output": 0.0000045
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-nano",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-nano)$",
+    "startDate": "2026-03-18T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2e-7,
+          "input_cached_tokens": 2e-8,
+          "input_cache_read": 2e-8,
+          "output": 0.00000125
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gpt-5.4-nano-2026-03-17",
+    "matchPattern": "(?i)^(openai\\/)?(gpt-5.4-nano-2026-03-17)$",
+    "startDate": "2026-03-18T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2e-7,
+          "input_cached_tokens": 2e-8,
+          "input_cache_read": 2e-8,
+          "output": 0.00000125
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-3-flash-preview",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-3-flash-preview)$",
+    "startDate": "2025-12-21T12:01:42.282Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 5e-7,
+          "input_text": 5e-7,
+          "input_modality_1": 5e-7,
+          "prompt_token_count": 5e-7,
+          "promptTokenCount": 5e-7,
+          "input_cached_tokens": 5e-8,
+          "cached_content_token_count": 5e-8,
+          "output": 0.000003,
+          "output_text": 0.000003,
+          "output_modality_1": 0.000003,
+          "candidates_token_count": 0.000003,
+          "candidatesTokenCount": 0.000003,
+          "thoughtsTokenCount": 0.000003,
+          "thoughts_token_count": 0.000003,
+          "output_reasoning": 0.000003
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-3.1-flash-lite-preview",
+    "matchPattern": "(?i)^(google(ai)?/)?(gemini-3.1-flash-lite-preview)$",
+    "startDate": "2026-03-03T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input": 2.5e-7,
+          "input_modality_1": 2.5e-7,
+          "input_text": 2.5e-7,
+          "prompt_token_count": 2.5e-7,
+          "promptTokenCount": 2.5e-7,
+          "input_cached_tokens": 2.5e-8,
+          "cached_content_token_count": 2.5e-8,
+          "output": 0.0000015,
+          "output_text": 0.0000015,
+          "output_modality_1": 0.0000015,
+          "candidates_token_count": 0.0000015,
+          "candidatesTokenCount": 0.0000015,
+          "thoughtsTokenCount": 0.0000015,
+          "thoughts_token_count": 0.0000015,
+          "output_reasoning": 0.0000015,
+          "input_audio_tokens": 5e-7
+        }
+      }
+    ]
+  },
+  {
+    "modelName": "gemini-live-2.5-flash-native-audio",
+    "matchPattern": "(?i)^(google/)?(gemini-live-2.5-flash-native-audio)$",
+    "startDate": "2026-03-16T00:00:00.000Z",
+    "pricingTiers": [
+      {
+        "name": "Standard",
+        "isDefault": true,
+        "priority": 0,
+        "conditions": [],
+        "prices": {
+          "input_text": 5e-7,
+          "input_audio": 0.000003,
+          "input_image": 0.000003,
+          "output_text": 0.000002,
+          "output_audio": 0.000012
+        }
+      }
+    ]
+  }
+];
diff --git a/internal-packages/llm-model-catalog/src/index.ts b/internal-packages/llm-model-catalog/src/index.ts
new file mode 100644
index 00000000000..8533e66ddd7
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/index.ts
@@ -0,0 +1,14 @@
+export { ModelPricingRegistry } from "./registry.js";
+export { seedLlmPricing } from "./seed.js";
+export { syncLlmCatalog } from "./sync.js";
+export { defaultModelPrices } from "./defaultPrices.js";
+export { modelCatalog } from "./modelCatalog.js";
+export type {
+  LlmModelWithPricing,
+  LlmCostResult,
+  LlmPricingTierWithPrices,
+  LlmPriceEntry,
+  PricingCondition,
+  DefaultModelDefinition,
+  ModelCatalogEntry,
+} from "./types.js";
diff --git a/internal-packages/llm-model-catalog/src/model-catalog.json b/internal-packages/llm-model-catalog/src/model-catalog.json
new file mode 100644
index 00000000000..0f602683528
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/model-catalog.json
@@ -0,0 +1,2446 @@
+{
+  "chatgpt-4o-latest": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model optimized for speed and cost, capable of processing text, images, and audio with strong performance across reasoning, coding, and creative tasks.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T10:55:46.469Z"
+  },
+  "claude-1.1": {
+    "provider": "anthropic",
+    "description": "An early-generation Claude model from Anthropic, offering basic conversational and text completion capabilities. It was quickly superseded by Claude 1.2, 1.3, and the Claude 2 family.",
+    "contextWindow": 9000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:47.906Z"
+  },
+  "claude-1.2": {
+    "provider": "anthropic",
+    "description": "An early-generation Anthropic model, part of the original Claude 1.x family. It offered improved performance over Claude 1.0 but was quickly superseded by Claude 1.3 and later model families.",
+    "contextWindow": 9000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": null,
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:46.760Z"
+  },
+  "claude-1.3": {
+    "provider": "anthropic",
+    "description": "Early-generation Claude model from Anthropic, offering improved performance over Claude 1.0-1.2 in reasoning and instruction-following tasks.",
+    "contextWindow": 100000,
+    "maxOutputTokens": null,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:46.227Z"
+  },
+  "claude-2.0": {
+    "provider": "anthropic",
+    "description": "Anthropic's second-generation large language model, offering improved performance over Claude 1.x with longer context support. Succeeded by Claude 2.1 and later the Claude 3 family.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-07-11",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-02-01",
+    "resolvedAt": "2026-03-24T10:55:45.922Z"
+  },
+  "claude-2.1": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 2.1 model featuring a 200K context window, reduced hallucination rates compared to Claude 2.0, and improved accuracy on long document comprehension.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "tool_use"
+    ],
+    "releaseDate": "2023-11-21",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:56:22.743Z"
+  },
+  "claude-3-5-haiku-20241022": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most cost-effective model in the Claude 3.5 family, optimized for speed and efficiency while maintaining strong performance across common tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-10-22",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-07-01",
+    "resolvedAt": "2026-03-24T10:56:25.724Z"
+  },
+  "claude-3-5-sonnet-20240620": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.5 Sonnet is a mid-tier model balancing intelligence and speed, excelling at coding, analysis, and vision tasks while being faster and cheaper than Opus.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:56:35.401Z"
+  },
+  "claude-3-haiku-20240307": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most compact Claude 3 model, optimized for speed and cost-efficiency while maintaining strong performance on everyday tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-08-01",
+    "resolvedAt": "2026-03-24T10:56:25.288Z"
+  },
+  "claude-3-opus-20240229": {
+    "provider": "anthropic",
+    "description": "Anthropic's most capable model in the Claude 3 family, excelling at complex analysis, nuanced content generation, and advanced reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-04",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-08-01",
+    "resolvedAt": "2026-03-24T10:56:26.008Z"
+  },
+  "claude-3-sonnet-20240229": {
+    "provider": "anthropic",
+    "description": "Mid-tier model in Anthropic's Claude 3 family, balancing performance and speed for a wide range of tasks including analysis, coding, and content generation.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-04",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-02-01",
+    "resolvedAt": "2026-03-24T10:56:59.532Z"
+  },
+  "claude-3.5-haiku-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most cost-effective model in the Claude 3.5 family, optimized for speed and efficiency while maintaining strong performance across a wide range of tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-10-29",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-07-01",
+    "resolvedAt": "2026-03-24T10:57:04.392Z"
+  },
+  "claude-3.5-sonnet-20241022": {
+    "provider": "anthropic",
+    "description": "Anthropic's mid-tier model offering strong reasoning, coding, and analysis capabilities at a balance of speed and intelligence, positioned between Haiku and Opus in the Claude 3.5 family.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:57:13.346Z"
+  },
+  "claude-3.5-sonnet-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's mid-tier model offering strong reasoning, coding, and analysis capabilities at a balance of speed and intelligence, positioned between Haiku and Opus in the Claude 3.5 family.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:57:13.346Z"
+  },
+  "claude-3.7-sonnet-20250219": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.7 Sonnet is a hybrid reasoning model that introduced extended thinking capabilities, offering strong performance on coding, math, and complex reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-02-24",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-04-01",
+    "resolvedAt": "2026-03-24T10:57:12.967Z"
+  },
+  "claude-3.7-sonnet-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.7 Sonnet is a hybrid reasoning model that introduced extended thinking capabilities, offering strong performance on coding, math, and complex reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-02-24",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-04-01",
+    "resolvedAt": "2026-03-24T10:57:12.967Z"
+  },
+  "claude-haiku-4-5-20251001": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest model with near-frontier intelligence, optimized for speed and cost efficiency while supporting extended thinking and vision.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-07-01",
+    "resolvedAt": "2026-03-24T10:57:29.685Z"
+  },
+  "claude-instant-1": {
+    "provider": "anthropic",
+    "description": "Anthropic's fast and cost-effective model optimized for speed and efficiency, positioned as a lighter alternative to Claude 1.x for tasks requiring lower latency.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-01-06",
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:57:36.888Z"
+  },
+  "claude-instant-1.2": {
+    "provider": "anthropic",
+    "description": "Anthropic's fast and cost-effective model, optimized for speed and efficiency while maintaining strong performance on conversational and text generation tasks.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-08-09",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:57:41.865Z"
+  },
+  "claude-opus-4-1-20250805": {
+    "provider": "anthropic",
+    "description": "Anthropic's hybrid reasoning model with strong software engineering and agentic capabilities, scoring 74.5% on SWE-bench Verified. Supports both rapid responses and step-by-step extended thinking.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 32000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-08-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:36.876Z"
+  },
+  "claude-opus-4-20250514": {
+    "provider": "anthropic",
+    "description": "Anthropic's flagship model from the Claude 4 family, excelling at complex coding tasks, long-running agent workflows, and deep reasoning with extended thinking support.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 32000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:47.518Z"
+  },
+  "claude-opus-4-5-20251101": {
+    "provider": "anthropic",
+    "description": "Anthropic's flagship intelligence model released in November 2025, excelling at complex reasoning, vision, and extended thinking with the best performance in Anthropic's lineup before Opus 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-11-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:48.961Z"
+  },
+  "claude-opus-4-6": {
+    "provider": "anthropic",
+    "description": "Anthropic's most intelligent model, optimized for building agents and coding with exceptional reasoning capabilities and extended agentic task horizons.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-02-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-05-01",
+    "resolvedAt": "2026-03-24T10:58:42.061Z"
+  },
+  "claude-sonnet-4-20250514": {
+    "provider": "anthropic",
+    "description": "Anthropic's balanced Claude 4 model offering strong coding, reasoning, and multilingual performance at moderate cost. Now a legacy model superseded by Claude Sonnet 4.5 and 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:39.601Z"
+  },
+  "claude-sonnet-4-5-20250929": {
+    "provider": "anthropic",
+    "description": "Anthropic's high-performance mid-tier model with strong coding, reasoning, and multi-step problem solving capabilities. Successor to Claude Sonnet 4, offering improved benchmarks at the same price point.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-09-29",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T10:59:54.426Z"
+  },
+  "claude-sonnet-4-6": {
+    "provider": "anthropic",
+    "description": "Anthropic's best combination of speed and intelligence, excelling at coding, agentic tasks, and computer use, with a 1M token context window and performance rivaling prior Opus-class models.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-02-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2026-01-01",
+    "resolvedAt": "2026-03-24T10:59:59.014Z"
+  },
+  "claude-sonnet-4-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's balanced Claude 4 model offering strong coding, reasoning, and multilingual performance at moderate cost. Now a legacy model superseded by Claude Sonnet 4.5 and 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:39.601Z"
+  },
+  "gemini-1.0-pro": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini Pro model, a mid-size multimodal model designed for text generation, reasoning, and chat applications. Succeeded by Gemini 1.5 Pro.",
+    "contextWindow": 32760,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:26.767Z"
+  },
+  "gemini-1.0-pro-001": {
+    "provider": "google",
+    "description": "Google's first-generation Pro model optimized for text generation, reasoning, and multi-turn conversation tasks, part of the original Gemini 1.0 lineup.",
+    "contextWindow": 30720,
+    "maxOutputTokens": 2048,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-02-15",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:27.391Z"
+  },
+  "gemini-1.0-pro-latest": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini Pro model, a mid-size multimodal model designed for text generation, reasoning, and chat applications. Succeeded by Gemini 1.5 Pro.",
+    "contextWindow": 32760,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:26.767Z"
+  },
+  "gemini-1.5-pro-latest": {
+    "provider": "google",
+    "description": "Google's mid-size multimodal model with a massive context window, strong at long-document understanding, code generation, and multi-turn conversation.",
+    "contextWindow": 2097152,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input"
+    ],
+    "releaseDate": "2024-02-15",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-24",
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:59:25.463Z"
+  },
+  "gemini-2.0-flash": {
+    "provider": "google",
+    "description": "Google's second-generation workhorse model optimized for speed, with native tool use, multimodal input (text, images, audio, video), and a 1M token context window.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:01:15.429Z"
+  },
+  "gemini-2.0-flash-001": {
+    "provider": "google",
+    "description": "Google's fast and efficient multimodal model that outperforms Gemini 1.5 Pro on key benchmarks at twice the speed, supporting text, image, audio, and video inputs with native tool use.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "image_generation",
+      "audio_output",
+      "code_execution"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-08-01",
+    "resolvedAt": "2026-03-24T11:01:04.084Z"
+  },
+  "gemini-2.0-flash-lite-preview": {
+    "provider": "google",
+    "description": "A lightweight, cost-efficient variant of Gemini 2.0 Flash optimized for low latency and high throughput, supporting multimodal input with text output.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:00:56.775Z"
+  },
+  "gemini-2.0-flash-lite-preview-02-05": {
+    "provider": "google",
+    "description": "Google's cost-optimized, low-latency model in the Gemini 2.0 family, designed for high-volume tasks like summarization, multimodal processing, and categorization.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-12-09",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:01:34.165Z"
+  },
+  "gemini-2.5-flash": {
+    "provider": "google",
+    "description": "Google's best price-performance model optimized for low-latency, high-volume tasks requiring reasoning, with built-in thinking capabilities and multimodal input support.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-06-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:01:25.200Z"
+  },
+  "gemini-2.5-flash-lite": {
+    "provider": "google",
+    "description": "Google's most cost-efficient Gemini model, optimized for low-latency use cases with strong reasoning, multilingual, and long-context capabilities at minimal cost.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65535,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-07-22",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-07-22",
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:30.060Z"
+  },
+  "gemini-2.5-pro": {
+    "provider": "google",
+    "description": "Google's most advanced reasoning model with deep thinking capabilities, excelling at complex tasks like coding, math, and multimodal understanding across text, images, audio, and video.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65535,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-03-25",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-17",
+    "knowledgeCutoff": "2025-01-31",
+    "resolvedAt": "2026-03-24T11:02:25.573Z"
+  },
+  "gemini-3-flash-preview": {
+    "provider": "google",
+    "description": "Google's high-speed thinking model that matches Gemini 2.5 Pro performance at ~3x faster speed and lower cost, designed for agentic workflows, multi-turn chat, and coding assistance with configurable reasoning levels.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:13.388Z"
+  },
+  "gemini-3-pro-preview": {
+    "provider": "google",
+    "description": "Google's flagship reasoning and multimodal model with strong coding and agentic capabilities, now deprecated in favor of Gemini 3.1 Pro.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-11-01",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-03-09",
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:29.313Z"
+  },
+  "gemini-3.1-flash-lite-preview": {
+    "provider": "google",
+    "description": "Google's most cost-efficient multimodal model in the Gemini 3 series, optimized for high-volume, low-latency tasks like translation, classification, and simple data extraction. Offers 2.5x faster time-to-first-token than Gemini 2.5 Flash.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2026-03-03",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:29.253Z"
+  },
+  "gemini-3.1-pro-preview": {
+    "provider": "google",
+    "description": "Google's most advanced reasoning model in the Gemini 3.1 family, excelling at complex problem-solving across text, audio, images, video, and code with a 1M token context window and extended thinking capabilities.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2026-02-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:03:33.071Z"
+  },
+  "gemini-pro": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini model for text generation, reasoning, and multi-turn conversation. Superseded by Gemini 1.5 Pro and later models.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-04-09",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:03:45.401Z"
+  },
+  "gpt-3.5-turbo": {
+    "provider": "openai",
+    "description": "OpenAI's fast and cost-effective model optimized for chat and instruction-following tasks, now superseded by GPT-4o mini.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-03-01",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:11.412Z"
+  },
+  "gpt-3.5-turbo-0125": {
+    "provider": "openai",
+    "description": "A fast and cost-effective GPT-3.5 Turbo snapshot optimized for chat completions, offering improved accuracy for function calling and reduced instances of incomplete responses.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:11.310Z"
+  },
+  "gpt-3.5-turbo-0301": {
+    "provider": "openai",
+    "description": "Early snapshot of GPT-3.5 Turbo, OpenAI's first ChatGPT-optimized model for chat completions. Fast and cost-effective for simple tasks but superseded by later revisions.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-03-01",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:12.060Z"
+  },
+  "gpt-3.5-turbo-0613": {
+    "provider": "openai",
+    "description": "A snapshot of GPT-3.5 Turbo from June 2023, optimized for chat and instruction-following tasks with function calling support.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:04.463Z"
+  },
+  "gpt-3.5-turbo-1106": {
+    "provider": "openai",
+    "description": "A dated snapshot of GPT-3.5 Turbo released in November 2023, offering improved instruction following, JSON mode, and parallel function calling over previous GPT-3.5 variants.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:23.054Z"
+  },
+  "gpt-3.5-turbo-16k": {
+    "provider": "openai",
+    "description": "Extended context version of GPT-3.5 Turbo with 16K token context window, offering the same capabilities as the base model but able to process longer inputs.",
+    "contextWindow": 16384,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "json_mode",
+      "fine_tunable",
+      "tool_use"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:36.307Z"
+  },
+  "gpt-3.5-turbo-16k-0613": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-3.5 Turbo with 16K token context, snapshot from June 2023. Optimized for chat completions with longer document processing.",
+    "contextWindow": 16384,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:22.894Z"
+  },
+  "gpt-3.5-turbo-instruct": {
+    "provider": "openai",
+    "description": "OpenAI's GPT-3.5 Turbo Instruct is a completions-only model (not chat) optimized for following explicit instructions, replacing the legacy text-davinci-003 model.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-09-19",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-01-27",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:22.309Z"
+  },
+  "gpt-4": {
+    "provider": "openai",
+    "description": "OpenAI's flagship large language model that preceded GPT-4o, known for strong reasoning and instruction-following capabilities across a wide range of tasks.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:04:36.773Z"
+  },
+  "gpt-4-0125-preview": {
+    "provider": "openai",
+    "description": "An improved GPT-4 Turbo preview model with better task completion, reduced laziness in code generation, and enhanced instruction following.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:04:54.196Z"
+  },
+  "gpt-4-0314": {
+    "provider": "openai",
+    "description": "Original GPT-4 snapshot from March 2023, a large multimodal model (text-only at launch) that was one of OpenAI's first GPT-4 releases. Now deprecated and replaced by newer GPT-4 variants.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:14.112Z"
+  },
+  "gpt-4-0613": {
+    "provider": "openai",
+    "description": "A snapshot of GPT-4 from June 2023, offering strong reasoning and instruction-following capabilities. It was one of the first widely available GPT-4 variants with function calling support.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:13.885Z"
+  },
+  "gpt-4-1106-preview": {
+    "provider": "openai",
+    "description": "GPT-4 Turbo preview model with 128K context window, offering improved instruction following and JSON mode support at reduced cost compared to GPT-4.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:05:12.960Z"
+  },
+  "gpt-4-32k": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-4 with 32,768 token capacity, offering the same capabilities as GPT-4 but able to process longer documents and conversations.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:14.584Z"
+  },
+  "gpt-4-32k-0314": {
+    "provider": "openai",
+    "description": "Extended context (32k token) variant of the original GPT-4 launch snapshot from March 2024, offering the same capabilities as gpt-4-0314 but with 4x the context window.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:32.044Z"
+  },
+  "gpt-4-32k-0613": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-4 with 32,768 token context, based on the June 2023 snapshot. Offers the same capabilities as GPT-4 but with 4x the context length.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:53.070Z"
+  },
+  "gpt-4-preview": {
+    "provider": "openai",
+    "description": "GPT-4 Turbo preview model with 128K context window, JSON mode, and parallel function calling. A preview release in the GPT-4 Turbo series, now deprecated in favor of newer models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:06:54.248Z"
+  },
+  "gpt-4-turbo": {
+    "provider": "openai",
+    "description": "OpenAI's optimized GPT-4 variant offering faster inference and lower cost than the original GPT-4, with vision capabilities and a 128K context window.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-04-09",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:51.415Z"
+  },
+  "gpt-4-turbo-2024-04-09": {
+    "provider": "openai",
+    "description": "OpenAI's optimized GPT-4 variant offering faster inference and lower cost than the original GPT-4, with vision capabilities and a 128K context window.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-04-09",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:51.415Z"
+  },
+  "gpt-4-turbo-preview": {
+    "provider": "openai",
+    "description": "An early preview of GPT-4 Turbo with a 128K context window, offering improved instruction following and JSON mode support at reduced cost compared to GPT-4.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:52.346Z"
+  },
+  "gpt-4-turbo-vision": {
+    "provider": "openai",
+    "description": "OpenAI's GPT-4 Turbo model with vision capabilities, able to analyze and understand images alongside text. It was a preview model later superseded by GPT-4 Turbo (gpt-4-turbo-2024-04-09) and then GPT-4o.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2024-12-06",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:06:38.455Z"
+  },
+  "gpt-4.1": {
+    "provider": "openai",
+    "description": "OpenAI's flagship model optimized for coding, instruction following, and tool calling with a 1M token context window. Excels at structured outputs and long-context tasks.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:07:00.439Z"
+  },
+  "gpt-4.1-2025-04-14": {
+    "provider": "openai",
+    "description": "OpenAI's flagship model optimized for coding, instruction following, and tool calling with a 1M token context window. Excels at structured outputs and long-context tasks.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:07:00.439Z"
+  },
+  "gpt-4.1-mini": {
+    "provider": "openai",
+    "description": "A compact, cost-efficient model in OpenAI's GPT-4.1 family that matches or exceeds GPT-4o on many benchmarks while offering nearly half the latency and significantly lower cost.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:14.524Z"
+  },
+  "gpt-4.1-mini-2025-04-14": {
+    "provider": "openai",
+    "description": "A compact, cost-efficient model in OpenAI's GPT-4.1 family that matches or exceeds GPT-4o on many benchmarks while offering nearly half the latency and significantly lower cost.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:14.524Z"
+  },
+  "gpt-4.1-nano": {
+    "provider": "openai",
+    "description": "OpenAI's fastest and most cost-effective model in the GPT-4.1 family, optimized for low-latency tasks like classification, autocompletion, and lightweight agentic workflows with strong instruction-following and tool-calling capabilities.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:04.533Z"
+  },
+  "gpt-4.1-nano-2025-04-14": {
+    "provider": "openai",
+    "description": "OpenAI's fastest and most cost-effective model in the GPT-4.1 family, optimized for low-latency tasks like classification, autocompletion, and lightweight agentic workflows with strong instruction-following and tool-calling capabilities.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:04.533Z"
+  },
+  "gpt-4.5-preview": {
+    "provider": "openai",
+    "description": "OpenAI's largest pretrained model before the GPT-5 series, emphasizing broad knowledge, creative writing, and improved emotional intelligence over reasoning-focused models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-27",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-07-14",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:57.880Z"
+  },
+  "gpt-4.5-preview-2025-02-27": {
+    "provider": "openai",
+    "description": "OpenAI's largest pretrained model before the GPT-5 series, emphasizing broad knowledge, creative writing, and improved emotional intelligence over reasoning-focused models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-27",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-07-14",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:57.880Z"
+  },
+  "gpt-4o": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z"
+  },
+  "gpt-4o-2024-05-13": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z"
+  },
+  "gpt-4o-2024-08-06": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z"
+  },
+  "gpt-4o-2024-11-20": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z"
+  },
+  "gpt-4o-audio-preview": {
+    "provider": "openai",
+    "description": "GPT-4o variant with native audio input and output capabilities via the Chat Completions API, supporting both text and audio modalities for conversational and voice-based applications.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:08:09.590Z"
+  },
+  "gpt-4o-audio-preview-2024-10-01": {
+    "provider": "openai",
+    "description": "GPT-4o variant with native audio input and output capabilities via the Chat Completions API, supporting both text and audio modalities for conversational and voice-based applications.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:08:09.590Z"
+  },
+  "gpt-4o-mini": {
+    "provider": "openai",
+    "description": "Fast, affordable small model optimized for focused tasks. Positioned as OpenAI's cost-efficient option with strong performance on benchmarks relative to its size.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-07-18",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:50.130Z"
+  },
+  "gpt-4o-mini-2024-07-18": {
+    "provider": "openai",
+    "description": "Fast, affordable small model optimized for focused tasks. Positioned as OpenAI's cost-efficient option with strong performance on benchmarks relative to its size.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-07-18",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:50.130Z"
+  },
+  "gpt-4o-realtime-preview": {
+    "provider": "openai",
+    "description": "OpenAI's real-time multimodal model capable of processing and generating both text and audio over WebRTC or WebSocket, enabling low-latency voice conversations and audio interactions.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:35.495Z"
+  },
+  "gpt-4o-realtime-preview-2024-10-01": {
+    "provider": "openai",
+    "description": "OpenAI's real-time multimodal model capable of processing and generating both text and audio over WebRTC or WebSocket, enabling low-latency voice conversations and audio interactions.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:35.495Z"
+  },
+  "gpt-5": {
+    "provider": "openai",
+    "description": "OpenAI's flagship reasoning model released August 2025, featuring a 400K token context window with strong coding, reasoning, and agentic capabilities.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "image_generation",
+      "code_execution"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:28.216Z"
+  },
+  "gpt-5-2025-08-07": {
+    "provider": "openai",
+    "description": "OpenAI's flagship reasoning model released August 2025, featuring a 400K token context window with strong coding, reasoning, and agentic capabilities.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "image_generation",
+      "code_execution"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:28.216Z"
+  },
+  "gpt-5-chat-latest": {
+    "provider": "openai",
+    "description": "Non-reasoning GPT-5 model used in ChatGPT, optimized for conversational tasks. Supports text and image inputs with function calling and structured outputs.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:24.834Z"
+  },
+  "gpt-5-mini": {
+    "provider": "openai",
+    "description": "A faster, more cost-efficient version of GPT-5 designed for well-defined tasks and precise prompts. Supports reasoning with configurable effort levels and offers reduced latency compared to the full GPT-5 model.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:09:42.822Z"
+  },
+  "gpt-5-mini-2025-08-07": {
+    "provider": "openai",
+    "description": "A faster, more cost-efficient version of GPT-5 designed for well-defined tasks and precise prompts. Supports reasoning with configurable effort levels and offers reduced latency compared to the full GPT-5 model.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:09:42.822Z"
+  },
+  "gpt-5-nano": {
+    "provider": "openai",
+    "description": "The smallest and fastest variant in the GPT-5 family, optimized for developer tools, rapid interactions, and ultra-low latency environments. Best suited for classification, data extraction, ranking, and sub-agent tasks.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:11:24.884Z"
+  },
+  "gpt-5-nano-2025-08-07": {
+    "provider": "openai",
+    "description": "The smallest and fastest variant in the GPT-5 family, optimized for developer tools, rapid interactions, and ultra-low latency environments. Best suited for classification, data extraction, ranking, and sub-agent tasks.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:11:24.884Z"
+  },
+  "gpt-5-pro": {
+    "provider": "openai",
+    "description": "OpenAI's enhanced GPT-5 variant optimized for complex tasks requiring step-by-step reasoning, with reduced hallucination and improved code quality compared to the base GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-10-06",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-10-01",
+    "resolvedAt": "2026-03-24T11:11:37.048Z"
+  },
+  "gpt-5-pro-2025-10-06": {
+    "provider": "openai",
+    "description": "OpenAI's enhanced GPT-5 variant optimized for complex tasks requiring step-by-step reasoning, with reduced hallucination and improved code quality compared to the base GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-10-06",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-10-01",
+    "resolvedAt": "2026-03-24T11:11:37.048Z"
+  },
+  "gpt-5.1": {
+    "provider": "openai",
+    "description": "GPT-5.1 is OpenAI's frontier-grade model in the GPT-5 series, offering adaptive reasoning with configurable effort levels, improved coding and math performance, and a more natural conversational style compared to GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-11-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:11:47.327Z"
+  },
+  "gpt-5.1-2025-11-13": {
+    "provider": "openai",
+    "description": "GPT-5.1 is OpenAI's frontier-grade model in the GPT-5 series, offering adaptive reasoning with configurable effort levels, improved coding and math performance, and a more natural conversational style compared to GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-11-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:11:47.327Z"
+  },
+  "gpt-5.2": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model released December 2025, excelling at long-context reasoning, agentic tool use, software engineering, and professional knowledge work. Available in Instant, Thinking, and Pro variants.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:13.129Z"
+  },
+  "gpt-5.2-2025-12-11": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model released December 2025, excelling at long-context reasoning, agentic tool use, software engineering, and professional knowledge work. Available in Instant, Thinking, and Pro variants.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:13.129Z"
+  },
+  "gpt-5.2-pro": {
+    "provider": "openai",
+    "description": "OpenAI's previous pro-tier reasoning model optimized for complex professional work requiring step-by-step reasoning, instruction following, and accuracy in high-stakes use cases. Superseded by GPT-5.4 pro.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:12.711Z"
+  },
+  "gpt-5.2-pro-2025-12-11": {
+    "provider": "openai",
+    "description": "OpenAI's previous pro-tier reasoning model optimized for complex professional work requiring step-by-step reasoning, instruction following, and accuracy in high-stakes use cases. Superseded by GPT-5.4 pro.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:12.711Z"
+  },
+  "gpt-5.4": {
+    "provider": "openai",
+    "description": "OpenAI's most capable frontier model as of March 2026, featuring state-of-the-art coding, native computer-use capabilities, and a 1M-token context window for professional and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:09.220Z"
+  },
+  "gpt-5.4-2026-03-05": {
+    "provider": "openai",
+    "description": "OpenAI's most capable frontier model as of March 2026, featuring state-of-the-art coding, native computer-use capabilities, and a 1M-token context window for professional and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:09.220Z"
+  },
+  "gpt-5.4-mini": {
+    "provider": "openai",
+    "description": "OpenAI's fast and efficient small model from the GPT-5.4 family, designed for high-volume workloads. Approaches GPT-5.4 performance on coding and reasoning while running over 2x faster than GPT-5 mini.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:35.473Z"
+  },
+  "gpt-5.4-mini-2026-03-17": {
+    "provider": "openai",
+    "description": "OpenAI's fast and efficient small model from the GPT-5.4 family, designed for high-volume workloads. Approaches GPT-5.4 performance on coding and reasoning while running over 2x faster than GPT-5 mini.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:35.473Z"
+  },
+  "gpt-5.4-nano": {
+    "provider": "openai",
+    "description": "OpenAI's cheapest GPT-5.4-class model optimized for simple high-volume tasks like classification, data extraction, ranking, and sub-agent delegation in agentic workflows.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:52.285Z"
+  },
+  "gpt-5.4-nano-2026-03-17": {
+    "provider": "openai",
+    "description": "OpenAI's cheapest GPT-5.4-class model optimized for simple high-volume tasks like classification, data extraction, ranking, and sub-agent delegation in agentic workflows.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:52.285Z"
+  },
+  "gpt-5.4-pro": {
+    "provider": "openai",
+    "description": "OpenAI's highest-capability GPT-5.4 variant, using additional compute for harder problems. Available via Responses API only, designed for complex reasoning, coding, and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:56.903Z"
+  },
+  "gpt-5.4-pro-2026-03-05": {
+    "provider": "openai",
+    "description": "OpenAI's highest-capability GPT-5.4 variant, using additional compute for harder problems. Available via Responses API only, designed for complex reasoning, coding, and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:56.903Z"
+  },
+  "o1": {
+    "provider": "openai",
+    "description": "OpenAI's reasoning model designed for complex tasks requiring multi-step logical thinking, excelling at math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:23.948Z"
+  },
+  "o1-2024-12-17": {
+    "provider": "openai",
+    "description": "OpenAI's reasoning model designed for complex tasks requiring multi-step logical thinking, excelling at math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:23.948Z"
+  },
+  "o1-mini": {
+    "provider": "openai",
+    "description": "A smaller, faster, and cheaper reasoning model in OpenAI's o1 series, optimized for coding, math, and science tasks requiring multi-step reasoning.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-30",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:37.030Z"
+  },
+  "o1-mini-2024-09-12": {
+    "provider": "openai",
+    "description": "A smaller, faster, and cheaper reasoning model in OpenAI's o1 series, optimized for coding, math, and science tasks requiring multi-step reasoning.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-30",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:37.030Z"
+  },
+  "o1-preview": {
+    "provider": "openai",
+    "description": "OpenAI's first reasoning model using chain-of-thought to solve complex problems in science, coding, and math. Predecessor to o1 and o3 series.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-10-31",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:59.198Z"
+  },
+  "o1-preview-2024-09-12": {
+    "provider": "openai",
+    "description": "OpenAI's first reasoning model using chain-of-thought to solve complex problems in science, coding, and math. Predecessor to o1 and o3 series.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-10-31",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:59.198Z"
+  },
+  "o1-pro": {
+    "provider": "openai",
+    "description": "A version of OpenAI's o1 reasoning model that uses significantly more compute to deliver better, more consistent answers on complex reasoning tasks in science, coding, and math.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-03-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:13:57.532Z"
+  },
+  "o1-pro-2025-03-19": {
+    "provider": "openai",
+    "description": "A version of OpenAI's o1 reasoning model that uses significantly more compute to deliver better, more consistent answers on complex reasoning tasks in science, coding, and math.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-03-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:13:57.532Z"
+  },
+  "o3": {
+    "provider": "openai",
+    "description": "OpenAI's advanced reasoning model designed for complex tasks requiring deep reasoning, excelling at software engineering, mathematics, scientific reasoning, and visual reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:04.906Z"
+  },
+  "o3-2025-04-16": {
+    "provider": "openai",
+    "description": "OpenAI's advanced reasoning model designed for complex tasks requiring deep reasoning, excelling at software engineering, mathematics, scientific reasoning, and visual reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:04.906Z"
+  },
+  "o3-mini": {
+    "provider": "openai",
+    "description": "OpenAI's compact reasoning model optimized for STEM tasks, offering strong performance in math, science, and coding at lower cost than o3.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-01-31",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:13:33.788Z"
+  },
+  "o3-mini-2025-01-31": {
+    "provider": "openai",
+    "description": "OpenAI's compact reasoning model optimized for STEM tasks, offering strong performance in math, science, and coding at lower cost than o3.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-01-31",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:13:33.788Z"
+  },
+  "o3-pro": {
+    "provider": "openai",
+    "description": "OpenAI's most reliable reasoning model, a version of o3 designed to think longer and provide more consistently accurate answers for challenging math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-06-10",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:10.900Z"
+  },
+  "o3-pro-2025-06-10": {
+    "provider": "openai",
+    "description": "OpenAI's most reliable reasoning model, a version of o3 designed to think longer and provide more consistently accurate answers for challenging math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-06-10",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:10.900Z"
+  },
+  "o4-mini": {
+    "provider": "openai",
+    "description": "OpenAI's small reasoning model optimized for fast, cost-efficient reasoning with strong performance in math, coding, and visual tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:16.050Z"
+  },
+  "o4-mini-2025-04-16": {
+    "provider": "openai",
+    "description": "OpenAI's small reasoning model optimized for fast, cost-efficient reasoning with strong performance in math, coding, and visual tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:16.050Z"
+  }
+}
diff --git a/internal-packages/llm-model-catalog/src/modelCatalog.ts b/internal-packages/llm-model-catalog/src/modelCatalog.ts
new file mode 100644
index 00000000000..71ae921c3e7
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/modelCatalog.ts
@@ -0,0 +1,2572 @@
+import type { ModelCatalogEntry } from "./types.js";
+
+// Auto-generated from model-catalog.json — do not edit manually.
+// Run `pnpm run generate-catalog` to update the JSON, then `pnpm run generate` to regenerate.
+
+export const modelCatalog: Record<string, ModelCatalogEntry> = {
+  "chatgpt-4o-latest": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model optimized for speed and cost, capable of processing text, images, and audio with strong performance across reasoning, coding, and creative tasks.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T10:55:46.469Z",
+    "baseModelName": "chatgpt-4o"
+  },
+  "claude-1.1": {
+    "provider": "anthropic",
+    "description": "An early-generation Claude model from Anthropic, offering basic conversational and text completion capabilities. It was quickly superseded by Claude 1.2, 1.3, and the Claude 2 family.",
+    "contextWindow": 9000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:47.906Z",
+    "baseModelName": null
+  },
+  "claude-1.2": {
+    "provider": "anthropic",
+    "description": "An early-generation Anthropic model, part of the original Claude 1.x family. It offered improved performance over Claude 1.0 but was quickly superseded by Claude 1.3 and later model families.",
+    "contextWindow": 9000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": null,
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:46.760Z",
+    "baseModelName": null
+  },
+  "claude-1.3": {
+    "provider": "anthropic",
+    "description": "Early-generation Claude model from Anthropic, offering improved performance over Claude 1.0-1.2 in reasoning and instruction-following tasks.",
+    "contextWindow": 100000,
+    "maxOutputTokens": null,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": null,
+    "resolvedAt": "2026-03-24T10:55:46.227Z",
+    "baseModelName": null
+  },
+  "claude-2.0": {
+    "provider": "anthropic",
+    "description": "Anthropic's second-generation large language model, offering improved performance over Claude 1.x with longer context support. Succeeded by Claude 2.1 and later the Claude 3 family.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-07-11",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-02-01",
+    "resolvedAt": "2026-03-24T10:55:45.922Z",
+    "baseModelName": null
+  },
+  "claude-2.1": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 2.1 model featuring a 200K context window, reduced hallucination rates compared to Claude 2.0, and improved accuracy on long document comprehension.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "tool_use"
+    ],
+    "releaseDate": "2023-11-21",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:56:22.743Z",
+    "baseModelName": null
+  },
+  "claude-3-5-haiku-20241022": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most cost-effective model in the Claude 3.5 family, optimized for speed and efficiency while maintaining strong performance across common tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-10-22",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-07-01",
+    "resolvedAt": "2026-03-24T10:56:25.724Z",
+    "baseModelName": "claude-3-5-haiku"
+  },
+  "claude-3-5-sonnet-20240620": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.5 Sonnet is a mid-tier model balancing intelligence and speed, excelling at coding, analysis, and vision tasks while being faster and cheaper than Opus.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:56:35.401Z",
+    "baseModelName": "claude-3-5-sonnet"
+  },
+  "claude-3-haiku-20240307": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most compact Claude 3 model, optimized for speed and cost-efficiency while maintaining strong performance on everyday tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-08-01",
+    "resolvedAt": "2026-03-24T10:56:25.288Z",
+    "baseModelName": "claude-3-haiku"
+  },
+  "claude-3-opus-20240229": {
+    "provider": "anthropic",
+    "description": "Anthropic's most capable model in the Claude 3 family, excelling at complex analysis, nuanced content generation, and advanced reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-04",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-08-01",
+    "resolvedAt": "2026-03-24T10:56:26.008Z",
+    "baseModelName": "claude-3-opus"
+  },
+  "claude-3-sonnet-20240229": {
+    "provider": "anthropic",
+    "description": "Mid-tier model in Anthropic's Claude 3 family, balancing performance and speed for a wide range of tasks including analysis, coding, and content generation.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-03-04",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-02-01",
+    "resolvedAt": "2026-03-24T10:56:59.532Z",
+    "baseModelName": "claude-3-sonnet"
+  },
+  "claude-3.5-haiku-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest and most cost-effective model in the Claude 3.5 family, optimized for speed and efficiency while maintaining strong performance across a wide range of tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-10-29",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-07-01",
+    "resolvedAt": "2026-03-24T10:57:04.392Z",
+    "baseModelName": "claude-3.5-haiku"
+  },
+  "claude-3.5-sonnet-20241022": {
+    "provider": "anthropic",
+    "description": "Anthropic's mid-tier model offering strong reasoning, coding, and analysis capabilities at a balance of speed and intelligence, positioned between Haiku and Opus in the Claude 3.5 family.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:57:13.346Z",
+    "baseModelName": "claude-3.5-sonnet"
+  },
+  "claude-3.5-sonnet-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's mid-tier model offering strong reasoning, coding, and analysis capabilities at a balance of speed and intelligence, positioned between Haiku and Opus in the Claude 3.5 family.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-06-20",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:57:13.346Z",
+    "baseModelName": "claude-3.5-sonnet"
+  },
+  "claude-3.7-sonnet-20250219": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.7 Sonnet is a hybrid reasoning model that introduced extended thinking capabilities, offering strong performance on coding, math, and complex reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-02-24",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-04-01",
+    "resolvedAt": "2026-03-24T10:57:12.967Z",
+    "baseModelName": "claude-3.7-sonnet"
+  },
+  "claude-3.7-sonnet-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's Claude 3.7 Sonnet is a hybrid reasoning model that introduced extended thinking capabilities, offering strong performance on coding, math, and complex reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-02-24",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-04-01",
+    "resolvedAt": "2026-03-24T10:57:12.967Z",
+    "baseModelName": "claude-3.7-sonnet"
+  },
+  "claude-haiku-4-5-20251001": {
+    "provider": "anthropic",
+    "description": "Anthropic's fastest model with near-frontier intelligence, optimized for speed and cost efficiency while supporting extended thinking and vision.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-07-01",
+    "resolvedAt": "2026-03-24T10:57:29.685Z",
+    "baseModelName": "claude-haiku-4-5"
+  },
+  "claude-instant-1": {
+    "provider": "anthropic",
+    "description": "Anthropic's fast and cost-effective model optimized for speed and efficiency, positioned as a lighter alternative to Claude 1.x for tasks requiring lower latency.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-01-06",
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:57:36.888Z",
+    "baseModelName": null
+  },
+  "claude-instant-1.2": {
+    "provider": "anthropic",
+    "description": "Anthropic's fast and cost-effective model, optimized for speed and efficiency while maintaining strong performance on conversational and text generation tasks.",
+    "contextWindow": 100000,
+    "maxOutputTokens": 8191,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-08-09",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-01-01",
+    "resolvedAt": "2026-03-24T10:57:41.865Z",
+    "baseModelName": null
+  },
+  "claude-opus-4-1-20250805": {
+    "provider": "anthropic",
+    "description": "Anthropic's hybrid reasoning model with strong software engineering and agentic capabilities, scoring 74.5% on SWE-bench Verified. Supports both rapid responses and step-by-step extended thinking.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 32000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-08-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:36.876Z",
+    "baseModelName": "claude-opus-4-1"
+  },
+  "claude-opus-4-20250514": {
+    "provider": "anthropic",
+    "description": "Anthropic's flagship model from the Claude 4 family, excelling at complex coding tasks, long-running agent workflows, and deep reasoning with extended thinking support.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 32000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:47.518Z",
+    "baseModelName": "claude-opus-4"
+  },
+  "claude-opus-4-5-20251101": {
+    "provider": "anthropic",
+    "description": "Anthropic's flagship intelligence model released in November 2025, excelling at complex reasoning, vision, and extended thinking with the best performance in Anthropic's lineup before Opus 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-11-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:48.961Z",
+    "baseModelName": "claude-opus-4-5"
+  },
+  "claude-opus-4-6": {
+    "provider": "anthropic",
+    "description": "Anthropic's most intelligent model, optimized for building agents and coding with exceptional reasoning capabilities and extended agentic task horizons.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-02-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-05-01",
+    "resolvedAt": "2026-03-24T10:58:42.061Z",
+    "baseModelName": null
+  },
+  "claude-sonnet-4-20250514": {
+    "provider": "anthropic",
+    "description": "Anthropic's balanced Claude 4 model offering strong coding, reasoning, and multilingual performance at moderate cost. Now a legacy model superseded by Claude Sonnet 4.5 and 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:39.601Z",
+    "baseModelName": "claude-sonnet-4"
+  },
+  "claude-sonnet-4-5-20250929": {
+    "provider": "anthropic",
+    "description": "Anthropic's high-performance mid-tier model with strong coding, reasoning, and multi-step problem solving capabilities. Successor to Claude Sonnet 4, offering improved benchmarks at the same price point.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-09-29",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T10:59:54.426Z",
+    "baseModelName": "claude-sonnet-4-5"
+  },
+  "claude-sonnet-4-6": {
+    "provider": "anthropic",
+    "description": "Anthropic's best combination of speed and intelligence, excelling at coding, agentic tasks, and computer use, with a 1M token context window and performance rivaling prior Opus-class models.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-02-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2026-01-01",
+    "resolvedAt": "2026-03-24T10:59:59.014Z",
+    "baseModelName": null
+  },
+  "claude-sonnet-4-latest": {
+    "provider": "anthropic",
+    "description": "Anthropic's balanced Claude 4 model offering strong coding, reasoning, and multilingual performance at moderate cost. Now a legacy model superseded by Claude Sonnet 4.5 and 4.6.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 64000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-05-14",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-03-01",
+    "resolvedAt": "2026-03-24T10:58:39.601Z",
+    "baseModelName": "claude-sonnet-4"
+  },
+  "gemini-1.0-pro": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini Pro model, a mid-size multimodal model designed for text generation, reasoning, and chat applications. Succeeded by Gemini 1.5 Pro.",
+    "contextWindow": 32760,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:26.767Z",
+    "baseModelName": null
+  },
+  "gemini-1.0-pro-001": {
+    "provider": "google",
+    "description": "Google's first-generation Pro model optimized for text generation, reasoning, and multi-turn conversation tasks, part of the original Gemini 1.0 lineup.",
+    "contextWindow": 30720,
+    "maxOutputTokens": 2048,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-02-15",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:27.391Z",
+    "baseModelName": null
+  },
+  "gemini-1.0-pro-latest": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini Pro model, a mid-size multimodal model designed for text generation, reasoning, and chat applications. Succeeded by Gemini 1.5 Pro.",
+    "contextWindow": 32760,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-02-15",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T10:59:26.767Z",
+    "baseModelName": "gemini-1.0-pro"
+  },
+  "gemini-1.5-pro-latest": {
+    "provider": "google",
+    "description": "Google's mid-size multimodal model with a massive context window, strong at long-document understanding, code generation, and multi-turn conversation.",
+    "contextWindow": 2097152,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input"
+    ],
+    "releaseDate": "2024-02-15",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-24",
+    "knowledgeCutoff": "2024-04-01",
+    "resolvedAt": "2026-03-24T10:59:25.463Z",
+    "baseModelName": "gemini-1.5-pro"
+  },
+  "gemini-2.0-flash": {
+    "provider": "google",
+    "description": "Google's second-generation workhorse model optimized for speed, with native tool use, multimodal input (text, images, audio, video), and a 1M token context window.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:01:15.429Z",
+    "baseModelName": null
+  },
+  "gemini-2.0-flash-001": {
+    "provider": "google",
+    "description": "Google's fast and efficient multimodal model that outperforms Gemini 1.5 Pro on key benchmarks at twice the speed, supporting text, image, audio, and video inputs with native tool use.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "image_generation",
+      "audio_output",
+      "code_execution"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-08-01",
+    "resolvedAt": "2026-03-24T11:01:04.084Z",
+    "baseModelName": null
+  },
+  "gemini-2.0-flash-lite-preview": {
+    "provider": "google",
+    "description": "A lightweight, cost-efficient variant of Gemini 2.0 Flash optimized for low latency and high throughput, supporting multimodal input with text output.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-01",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:00:56.775Z",
+    "baseModelName": null
+  },
+  "gemini-2.0-flash-lite-preview-02-05": {
+    "provider": "google",
+    "description": "Google's cost-optimized, low-latency model in the Gemini 2.0 family, designed for high-volume tasks like summarization, multimodal processing, and categorization.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-05",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-12-09",
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:01:34.165Z",
+    "baseModelName": null
+  },
+  "gemini-2.5-flash": {
+    "provider": "google",
+    "description": "Google's best price-performance model optimized for low-latency, high-volume tasks requiring reasoning, with built-in thinking capabilities and multimodal input support.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-06-01",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:01:25.200Z",
+    "baseModelName": null
+  },
+  "gemini-2.5-flash-lite": {
+    "provider": "google",
+    "description": "Google's most cost-efficient Gemini model, optimized for low-latency use cases with strong reasoning, multilingual, and long-context capabilities at minimal cost.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65535,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-07-22",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-07-22",
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:30.060Z",
+    "baseModelName": null
+  },
+  "gemini-2.5-pro": {
+    "provider": "google",
+    "description": "Google's most advanced reasoning model with deep thinking capabilities, excelling at complex tasks like coding, math, and multimodal understanding across text, images, audio, and video.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65535,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-03-25",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-06-17",
+    "knowledgeCutoff": "2025-01-31",
+    "resolvedAt": "2026-03-24T11:02:25.573Z",
+    "baseModelName": null
+  },
+  "gemini-3-flash-preview": {
+    "provider": "google",
+    "description": "Google's high-speed thinking model that matches Gemini 2.5 Pro performance at ~3x faster speed and lower cost, designed for agentic workflows, multi-turn chat, and coding assistance with configurable reasoning levels.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:13.388Z",
+    "baseModelName": null
+  },
+  "gemini-3-pro-preview": {
+    "provider": "google",
+    "description": "Google's flagship reasoning and multimodal model with strong coding and agentic capabilities, now deprecated in favor of Gemini 3.1 Pro.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2025-11-01",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-03-09",
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:29.313Z",
+    "baseModelName": null
+  },
+  "gemini-3.1-flash-lite-preview": {
+    "provider": "google",
+    "description": "Google's most cost-efficient multimodal model in the Gemini 3 series, optimized for high-volume, low-latency tasks like translation, classification, and simple data extraction. Offers 2.5x faster time-to-first-token than Gemini 2.5 Flash.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2026-03-03",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:02:29.253Z",
+    "baseModelName": null
+  },
+  "gemini-3.1-pro-preview": {
+    "provider": "google",
+    "description": "Google's most advanced reasoning model in the Gemini 3.1 family, excelling at complex problem-solving across text, audio, images, video, and code with a 1M token context window and extended thinking capabilities.",
+    "contextWindow": 1048576,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking",
+      "code_execution",
+      "audio_input"
+    ],
+    "releaseDate": "2026-02-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:03:33.071Z",
+    "baseModelName": null
+  },
+  "gemini-pro": {
+    "provider": "google",
+    "description": "Google's first-generation Gemini model for text generation, reasoning, and multi-turn conversation. Superseded by Gemini 1.5 Pro and later models.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-12-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-04-09",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:03:45.401Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo": {
+    "provider": "openai",
+    "description": "OpenAI's fast and cost-effective model optimized for chat and instruction-following tasks, now superseded by GPT-4o mini.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-03-01",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:11.412Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-0125": {
+    "provider": "openai",
+    "description": "A fast and cost-effective GPT-3.5 Turbo snapshot optimized for chat completions, offering improved accuracy for function calling and reduced instances of incomplete responses.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:11.310Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-0301": {
+    "provider": "openai",
+    "description": "Early snapshot of GPT-3.5 Turbo, OpenAI's first ChatGPT-optimized model for chat completions. Fast and cost-effective for simple tasks but superseded by later revisions.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-03-01",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:03:12.060Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-0613": {
+    "provider": "openai",
+    "description": "A snapshot of GPT-3.5 Turbo from June 2023, optimized for chat and instruction-following tasks with function calling support.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:04.463Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-1106": {
+    "provider": "openai",
+    "description": "A dated snapshot of GPT-3.5 Turbo released in November 2023, offering improved instruction following, JSON mode, and parallel function calling over previous GPT-3.5 variants.",
+    "contextWindow": 16385,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:23.054Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-16k": {
+    "provider": "openai",
+    "description": "Extended context version of GPT-3.5 Turbo with 16K token context window, offering the same capabilities as the base model but able to process longer inputs.",
+    "contextWindow": 16384,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "json_mode",
+      "fine_tunable",
+      "tool_use"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:36.307Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-16k-0613": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-3.5 Turbo with 16K token context, snapshot from June 2023. Optimized for chat completions with longer document processing.",
+    "contextWindow": 16384,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-09-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:22.894Z",
+    "baseModelName": null
+  },
+  "gpt-3.5-turbo-instruct": {
+    "provider": "openai",
+    "description": "OpenAI's GPT-3.5 Turbo Instruct is a completions-only model (not chat) optimized for following explicit instructions, replacing the legacy text-davinci-003 model.",
+    "contextWindow": 4096,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-09-19",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-01-27",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:04:22.309Z",
+    "baseModelName": null
+  },
+  "gpt-4": {
+    "provider": "openai",
+    "description": "OpenAI's flagship large language model that preceded GPT-4o, known for strong reasoning and instruction-following capabilities across a wide range of tasks.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:04:36.773Z",
+    "baseModelName": null
+  },
+  "gpt-4-0125-preview": {
+    "provider": "openai",
+    "description": "An improved GPT-4 Turbo preview model with better task completion, reduced laziness in code generation, and enhanced instruction following.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:04:54.196Z",
+    "baseModelName": null
+  },
+  "gpt-4-0314": {
+    "provider": "openai",
+    "description": "Original GPT-4 snapshot from March 2023, a large multimodal model (text-only at launch) that was one of OpenAI's first GPT-4 releases. Now deprecated and replaced by newer GPT-4 variants.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:14.112Z",
+    "baseModelName": null
+  },
+  "gpt-4-0613": {
+    "provider": "openai",
+    "description": "A snapshot of GPT-4 from June 2023, offering strong reasoning and instruction-following capabilities. It was one of the first widely available GPT-4 variants with function calling support.",
+    "contextWindow": 8192,
+    "maxOutputTokens": 8192,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:13.885Z",
+    "baseModelName": null
+  },
+  "gpt-4-1106-preview": {
+    "provider": "openai",
+    "description": "GPT-4 Turbo preview model with 128K context window, offering improved instruction following and JSON mode support at reduced cost compared to GPT-4.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:05:12.960Z",
+    "baseModelName": null
+  },
+  "gpt-4-32k": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-4 with 32,768 token capacity, offering the same capabilities as GPT-4 but able to process longer documents and conversations.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:14.584Z",
+    "baseModelName": null
+  },
+  "gpt-4-32k-0314": {
+    "provider": "openai",
+    "description": "Extended context (32k token) variant of the original GPT-4 launch snapshot from March 2024, offering the same capabilities as gpt-4-0314 but with 4x the context window.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2023-03-14",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2024-06-13",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:32.044Z",
+    "baseModelName": null
+  },
+  "gpt-4-32k-0613": {
+    "provider": "openai",
+    "description": "Extended context window variant of GPT-4 with 32,768 token context, based on the June 2023 snapshot. Offers the same capabilities as GPT-4 but with 4x the context length.",
+    "contextWindow": 32768,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-06-13",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2021-09-01",
+    "resolvedAt": "2026-03-24T11:05:53.070Z",
+    "baseModelName": null
+  },
+  "gpt-4-preview": {
+    "provider": "openai",
+    "description": "GPT-4 Turbo preview model with 128K context window, JSON mode, and parallel function calling. A preview release in the GPT-4 Turbo series, now deprecated in favor of newer models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-06-06",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:06:54.248Z",
+    "baseModelName": null
+  },
+  "gpt-4-turbo": {
+    "provider": "openai",
+    "description": "OpenAI's optimized GPT-4 variant offering faster inference and lower cost than the original GPT-4, with vision capabilities and a 128K context window.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-04-09",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:51.415Z",
+    "baseModelName": null
+  },
+  "gpt-4-turbo-2024-04-09": {
+    "provider": "openai",
+    "description": "OpenAI's optimized GPT-4 variant offering faster inference and lower cost than the original GPT-4, with vision capabilities and a 128K context window.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-04-09",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:51.415Z",
+    "baseModelName": "gpt-4-turbo"
+  },
+  "gpt-4-turbo-preview": {
+    "provider": "openai",
+    "description": "An early preview of GPT-4 Turbo with a 128K context window, offering improved instruction following and JSON mode support at reduced cost compared to GPT-4.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-01-25",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-12-01",
+    "resolvedAt": "2026-03-24T11:05:52.346Z",
+    "baseModelName": null
+  },
+  "gpt-4-turbo-vision": {
+    "provider": "openai",
+    "description": "OpenAI's GPT-4 Turbo model with vision capabilities, able to analyze and understand images alongside text. It was a preview model later superseded by GPT-4 Turbo (gpt-4-turbo-2024-04-09) and then GPT-4o.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2023-11-06",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2024-12-06",
+    "knowledgeCutoff": "2023-04-01",
+    "resolvedAt": "2026-03-24T11:06:38.455Z",
+    "baseModelName": null
+  },
+  "gpt-4.1": {
+    "provider": "openai",
+    "description": "OpenAI's flagship model optimized for coding, instruction following, and tool calling with a 1M token context window. Excels at structured outputs and long-context tasks.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:07:00.439Z",
+    "baseModelName": null
+  },
+  "gpt-4.1-2025-04-14": {
+    "provider": "openai",
+    "description": "OpenAI's flagship model optimized for coding, instruction following, and tool calling with a 1M token context window. Excels at structured outputs and long-context tasks.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:07:00.439Z",
+    "baseModelName": "gpt-4.1"
+  },
+  "gpt-4.1-mini": {
+    "provider": "openai",
+    "description": "A compact, cost-efficient model in OpenAI's GPT-4.1 family that matches or exceeds GPT-4o on many benchmarks while offering nearly half the latency and significantly lower cost.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:14.524Z",
+    "baseModelName": null
+  },
+  "gpt-4.1-mini-2025-04-14": {
+    "provider": "openai",
+    "description": "A compact, cost-efficient model in OpenAI's GPT-4.1 family that matches or exceeds GPT-4o on many benchmarks while offering nearly half the latency and significantly lower cost.",
+    "contextWindow": 1000000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:14.524Z",
+    "baseModelName": "gpt-4.1-mini"
+  },
+  "gpt-4.1-nano": {
+    "provider": "openai",
+    "description": "OpenAI's fastest and most cost-effective model in the GPT-4.1 family, optimized for low-latency tasks like classification, autocompletion, and lightweight agentic workflows with strong instruction-following and tool-calling capabilities.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:04.533Z",
+    "baseModelName": null
+  },
+  "gpt-4.1-nano-2025-04-14": {
+    "provider": "openai",
+    "description": "OpenAI's fastest and most cost-effective model in the GPT-4.1 family, optimized for low-latency tasks like classification, autocompletion, and lightweight agentic workflows with strong instruction-following and tool-calling capabilities.",
+    "contextWindow": 1047576,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-04-14",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:08:04.533Z",
+    "baseModelName": "gpt-4.1-nano"
+  },
+  "gpt-4.5-preview": {
+    "provider": "openai",
+    "description": "OpenAI's largest pretrained model before the GPT-5 series, emphasizing broad knowledge, creative writing, and improved emotional intelligence over reasoning-focused models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-27",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-07-14",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:57.880Z",
+    "baseModelName": null
+  },
+  "gpt-4.5-preview-2025-02-27": {
+    "provider": "openai",
+    "description": "OpenAI's largest pretrained model before the GPT-5 series, emphasizing broad knowledge, creative writing, and improved emotional intelligence over reasoning-focused models.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-02-27",
+    "isHidden": true,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2025-07-14",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:57.880Z",
+    "baseModelName": "gpt-4.5-preview"
+  },
+  "gpt-4o": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z",
+    "baseModelName": null
+  },
+  "gpt-4o-2024-05-13": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z",
+    "baseModelName": "gpt-4o"
+  },
+  "gpt-4o-2024-08-06": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z",
+    "baseModelName": "gpt-4o"
+  },
+  "gpt-4o-2024-11-20": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model combining strong reasoning with vision, audio, and tool use capabilities at faster speeds and lower cost than GPT-4 Turbo.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "audio_input",
+      "audio_output",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-05-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:07:31.638Z",
+    "baseModelName": "gpt-4o"
+  },
+  "gpt-4o-audio-preview": {
+    "provider": "openai",
+    "description": "GPT-4o variant with native audio input and output capabilities via the Chat Completions API, supporting both text and audio modalities for conversational and voice-based applications.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:08:09.590Z",
+    "baseModelName": null
+  },
+  "gpt-4o-audio-preview-2024-10-01": {
+    "provider": "openai",
+    "description": "GPT-4o variant with native audio input and output capabilities via the Chat Completions API, supporting both text and audio modalities for conversational and voice-based applications.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:08:09.590Z",
+    "baseModelName": "gpt-4o-audio-preview"
+  },
+  "gpt-4o-mini": {
+    "provider": "openai",
+    "description": "Fast, affordable small model optimized for focused tasks. Positioned as OpenAI's cost-efficient option with strong performance on benchmarks relative to its size.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-07-18",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:50.130Z",
+    "baseModelName": null
+  },
+  "gpt-4o-mini-2024-07-18": {
+    "provider": "openai",
+    "description": "Fast, affordable small model optimized for focused tasks. Positioned as OpenAI's cost-efficient option with strong performance on benchmarks relative to its size.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "fine_tunable"
+    ],
+    "releaseDate": "2024-07-18",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:50.130Z",
+    "baseModelName": "gpt-4o-mini"
+  },
+  "gpt-4o-realtime-preview": {
+    "provider": "openai",
+    "description": "OpenAI's real-time multimodal model capable of processing and generating both text and audio over WebRTC or WebSocket, enabling low-latency voice conversations and audio interactions.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:35.495Z",
+    "baseModelName": null
+  },
+  "gpt-4o-realtime-preview-2024-10-01": {
+    "provider": "openai",
+    "description": "OpenAI's real-time multimodal model capable of processing and generating both text and audio over WebRTC or WebSocket, enabling low-latency voice conversations and audio interactions.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 4096,
+    "capabilities": [
+      "audio_input",
+      "audio_output",
+      "tool_use",
+      "streaming"
+    ],
+    "releaseDate": "2024-10-01",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2026-05-07",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:09:35.495Z",
+    "baseModelName": "gpt-4o-realtime-preview"
+  },
+  "gpt-5": {
+    "provider": "openai",
+    "description": "OpenAI's flagship reasoning model released August 2025, featuring a 400K token context window with strong coding, reasoning, and agentic capabilities.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "image_generation",
+      "code_execution"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:28.216Z",
+    "baseModelName": null
+  },
+  "gpt-5-2025-08-07": {
+    "provider": "openai",
+    "description": "OpenAI's flagship reasoning model released August 2025, featuring a 400K token context window with strong coding, reasoning, and agentic capabilities.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "image_generation",
+      "code_execution"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:28.216Z",
+    "baseModelName": "gpt-5"
+  },
+  "gpt-5-chat-latest": {
+    "provider": "openai",
+    "description": "Non-reasoning GPT-5 model used in ChatGPT, optimized for conversational tasks. Supports text and image inputs with function calling and structured outputs.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 16384,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:09:24.834Z",
+    "baseModelName": "gpt-5-chat"
+  },
+  "gpt-5-mini": {
+    "provider": "openai",
+    "description": "A faster, more cost-efficient version of GPT-5 designed for well-defined tasks and precise prompts. Supports reasoning with configurable effort levels and offers reduced latency compared to the full GPT-5 model.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:09:42.822Z",
+    "baseModelName": null
+  },
+  "gpt-5-mini-2025-08-07": {
+    "provider": "openai",
+    "description": "A faster, more cost-efficient version of GPT-5 designed for well-defined tasks and precise prompts. Supports reasoning with configurable effort levels and offers reduced latency compared to the full GPT-5 model.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:09:42.822Z",
+    "baseModelName": "gpt-5-mini"
+  },
+  "gpt-5-nano": {
+    "provider": "openai",
+    "description": "The smallest and fastest variant in the GPT-5 family, optimized for developer tools, rapid interactions, and ultra-low latency environments. Best suited for classification, data extraction, ranking, and sub-agent tasks.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:11:24.884Z",
+    "baseModelName": null
+  },
+  "gpt-5-nano-2025-08-07": {
+    "provider": "openai",
+    "description": "The smallest and fastest variant in the GPT-5 family, optimized for developer tools, rapid interactions, and ultra-low latency environments. Best suited for classification, data extraction, ranking, and sub-agent tasks.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-08-07",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-05-31",
+    "resolvedAt": "2026-03-24T11:11:24.884Z",
+    "baseModelName": "gpt-5-nano"
+  },
+  "gpt-5-pro": {
+    "provider": "openai",
+    "description": "OpenAI's enhanced GPT-5 variant optimized for complex tasks requiring step-by-step reasoning, with reduced hallucination and improved code quality compared to the base GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-10-06",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-10-01",
+    "resolvedAt": "2026-03-24T11:11:37.048Z",
+    "baseModelName": null
+  },
+  "gpt-5-pro-2025-10-06": {
+    "provider": "openai",
+    "description": "OpenAI's enhanced GPT-5 variant optimized for complex tasks requiring step-by-step reasoning, with reduced hallucination and improved code quality compared to the base GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-10-06",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-10-01",
+    "resolvedAt": "2026-03-24T11:11:37.048Z",
+    "baseModelName": "gpt-5-pro"
+  },
+  "gpt-5.1": {
+    "provider": "openai",
+    "description": "GPT-5.1 is OpenAI's frontier-grade model in the GPT-5 series, offering adaptive reasoning with configurable effort levels, improved coding and math performance, and a more natural conversational style compared to GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-11-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:11:47.327Z",
+    "baseModelName": null
+  },
+  "gpt-5.1-2025-11-13": {
+    "provider": "openai",
+    "description": "GPT-5.1 is OpenAI's frontier-grade model in the GPT-5 series, offering adaptive reasoning with configurable effort levels, improved coding and math performance, and a more natural conversational style compared to GPT-5.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2025-11-13",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-09-30",
+    "resolvedAt": "2026-03-24T11:11:47.327Z",
+    "baseModelName": "gpt-5.1"
+  },
+  "gpt-5.2": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model released December 2025, excelling at long-context reasoning, agentic tool use, software engineering, and professional knowledge work. Available in Instant, Thinking, and Pro variants.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:13.129Z",
+    "baseModelName": null
+  },
+  "gpt-5.2-2025-12-11": {
+    "provider": "openai",
+    "description": "OpenAI's flagship multimodal model released December 2025, excelling at long-context reasoning, agentic tool use, software engineering, and professional knowledge work. Available in Instant, Thinking, and Pro variants.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:13.129Z",
+    "baseModelName": "gpt-5.2"
+  },
+  "gpt-5.2-pro": {
+    "provider": "openai",
+    "description": "OpenAI's previous pro-tier reasoning model optimized for complex professional work requiring step-by-step reasoning, instruction following, and accuracy in high-stakes use cases. Superseded by GPT-5.4 pro.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:12.711Z",
+    "baseModelName": null
+  },
+  "gpt-5.2-pro-2025-12-11": {
+    "provider": "openai",
+    "description": "OpenAI's previous pro-tier reasoning model optimized for complex professional work requiring step-by-step reasoning, instruction following, and accuracy in high-stakes use cases. Superseded by GPT-5.4 pro.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-12-11",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:11:12.711Z",
+    "baseModelName": "gpt-5.2-pro"
+  },
+  "gpt-5.4": {
+    "provider": "openai",
+    "description": "OpenAI's most capable frontier model as of March 2026, featuring state-of-the-art coding, native computer-use capabilities, and a 1M-token context window for professional and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:09.220Z",
+    "baseModelName": null
+  },
+  "gpt-5.4-2026-03-05": {
+    "provider": "openai",
+    "description": "OpenAI's most capable frontier model as of March 2026, featuring state-of-the-art coding, native computer-use capabilities, and a 1M-token context window for professional and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "code_execution"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:09.220Z",
+    "baseModelName": "gpt-5.4"
+  },
+  "gpt-5.4-mini": {
+    "provider": "openai",
+    "description": "OpenAI's fast and efficient small model from the GPT-5.4 family, designed for high-volume workloads. Approaches GPT-5.4 performance on coding and reasoning while running over 2x faster than GPT-5 mini.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:35.473Z",
+    "baseModelName": null
+  },
+  "gpt-5.4-mini-2026-03-17": {
+    "provider": "openai",
+    "description": "OpenAI's fast and efficient small model from the GPT-5.4 family, designed for high-volume workloads. Approaches GPT-5.4 performance on coding and reasoning while running over 2x faster than GPT-5 mini.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:35.473Z",
+    "baseModelName": "gpt-5.4-mini"
+  },
+  "gpt-5.4-nano": {
+    "provider": "openai",
+    "description": "OpenAI's cheapest GPT-5.4-class model optimized for simple high-volume tasks like classification, data extraction, ranking, and sub-agent delegation in agentic workflows.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:52.285Z",
+    "baseModelName": null
+  },
+  "gpt-5.4-nano-2026-03-17": {
+    "provider": "openai",
+    "description": "OpenAI's cheapest GPT-5.4-class model optimized for simple high-volume tasks like classification, data extraction, ranking, and sub-agent delegation in agentic workflows.",
+    "contextWindow": 400000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2026-03-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:52.285Z",
+    "baseModelName": "gpt-5.4-nano"
+  },
+  "gpt-5.4-pro": {
+    "provider": "openai",
+    "description": "OpenAI's highest-capability GPT-5.4 variant, using additional compute for harder problems. Available via Responses API only, designed for complex reasoning, coding, and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:56.903Z",
+    "baseModelName": null
+  },
+  "gpt-5.4-pro-2026-03-05": {
+    "provider": "openai",
+    "description": "OpenAI's highest-capability GPT-5.4 variant, using additional compute for harder problems. Available via Responses API only, designed for complex reasoning, coding, and agentic workflows.",
+    "contextWindow": 1050000,
+    "maxOutputTokens": 128000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "extended_thinking"
+    ],
+    "releaseDate": "2026-03-05",
+    "isHidden": false,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-08-31",
+    "resolvedAt": "2026-03-24T11:12:56.903Z",
+    "baseModelName": "gpt-5.4-pro"
+  },
+  "o1": {
+    "provider": "openai",
+    "description": "OpenAI's reasoning model designed for complex tasks requiring multi-step logical thinking, excelling at math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:23.948Z",
+    "baseModelName": null
+  },
+  "o1-2024-12-17": {
+    "provider": "openai",
+    "description": "OpenAI's reasoning model designed for complex tasks requiring multi-step logical thinking, excelling at math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-12-17",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:23.948Z",
+    "baseModelName": "o1"
+  },
+  "o1-mini": {
+    "provider": "openai",
+    "description": "A smaller, faster, and cheaper reasoning model in OpenAI's o1 series, optimized for coding, math, and science tasks requiring multi-step reasoning.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-30",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:37.030Z",
+    "baseModelName": null
+  },
+  "o1-mini-2024-09-12": {
+    "provider": "openai",
+    "description": "A smaller, faster, and cheaper reasoning model in OpenAI's o1 series, optimized for coding, math, and science tasks requiring multi-step reasoning.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 65536,
+    "capabilities": [
+      "streaming",
+      "json_mode"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-06-30",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:37.030Z",
+    "baseModelName": "o1-mini"
+  },
+  "o1-preview": {
+    "provider": "openai",
+    "description": "OpenAI's first reasoning model using chain-of-thought to solve complex problems in science, coding, and math. Predecessor to o1 and o3 series.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-10-31",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:59.198Z",
+    "baseModelName": null
+  },
+  "o1-preview-2024-09-12": {
+    "provider": "openai",
+    "description": "OpenAI's first reasoning model using chain-of-thought to solve complex problems in science, coding, and math. Predecessor to o1 and o3 series.",
+    "contextWindow": 128000,
+    "maxOutputTokens": 32768,
+    "capabilities": [
+      "streaming"
+    ],
+    "releaseDate": "2024-09-12",
+    "isHidden": true,
+    "supportsStructuredOutput": false,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": "2025-10-31",
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:12:59.198Z",
+    "baseModelName": "o1-preview"
+  },
+  "o1-pro": {
+    "provider": "openai",
+    "description": "A version of OpenAI's o1 reasoning model that uses significantly more compute to deliver better, more consistent answers on complex reasoning tasks in science, coding, and math.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-03-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:13:57.532Z",
+    "baseModelName": null
+  },
+  "o1-pro-2025-03-19": {
+    "provider": "openai",
+    "description": "A version of OpenAI's o1 reasoning model that uses significantly more compute to deliver better, more consistent answers on complex reasoning tasks in science, coding, and math.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-03-19",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2023-10-01",
+    "resolvedAt": "2026-03-24T11:13:57.532Z",
+    "baseModelName": "o1-pro"
+  },
+  "o3": {
+    "provider": "openai",
+    "description": "OpenAI's advanced reasoning model designed for complex tasks requiring deep reasoning, excelling at software engineering, mathematics, scientific reasoning, and visual reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:04.906Z",
+    "baseModelName": null
+  },
+  "o3-2025-04-16": {
+    "provider": "openai",
+    "description": "OpenAI's advanced reasoning model designed for complex tasks requiring deep reasoning, excelling at software engineering, mathematics, scientific reasoning, and visual reasoning tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:04.906Z",
+    "baseModelName": "o3"
+  },
+  "o3-mini": {
+    "provider": "openai",
+    "description": "OpenAI's compact reasoning model optimized for STEM tasks, offering strong performance in math, science, and coding at lower cost than o3.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-01-31",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:13:33.788Z",
+    "baseModelName": null
+  },
+  "o3-mini-2025-01-31": {
+    "provider": "openai",
+    "description": "OpenAI's compact reasoning model optimized for STEM tasks, offering strong performance in math, science, and coding at lower cost than o3.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-01-31",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2025-01-01",
+    "resolvedAt": "2026-03-24T11:13:33.788Z",
+    "baseModelName": "o3-mini"
+  },
+  "o3-pro": {
+    "provider": "openai",
+    "description": "OpenAI's most reliable reasoning model, a version of o3 designed to think longer and provide more consistently accurate answers for challenging math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-06-10",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:10.900Z",
+    "baseModelName": null
+  },
+  "o3-pro-2025-06-10": {
+    "provider": "openai",
+    "description": "OpenAI's most reliable reasoning model, a version of o3 designed to think longer and provide more consistently accurate answers for challenging math, science, and coding problems.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-06-10",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": false,
+    "supportsStreamingToolCalls": false,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:10.900Z",
+    "baseModelName": "o3-pro"
+  },
+  "o4-mini": {
+    "provider": "openai",
+    "description": "OpenAI's small reasoning model optimized for fast, cost-efficient reasoning with strong performance in math, coding, and visual tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:16.050Z",
+    "baseModelName": null
+  },
+  "o4-mini-2025-04-16": {
+    "provider": "openai",
+    "description": "OpenAI's small reasoning model optimized for fast, cost-efficient reasoning with strong performance in math, coding, and visual tasks.",
+    "contextWindow": 200000,
+    "maxOutputTokens": 100000,
+    "capabilities": [
+      "vision",
+      "tool_use",
+      "streaming",
+      "json_mode",
+      "extended_thinking"
+    ],
+    "releaseDate": "2025-04-16",
+    "isHidden": false,
+    "supportsStructuredOutput": true,
+    "supportsParallelToolCalls": true,
+    "supportsStreamingToolCalls": true,
+    "deprecationDate": null,
+    "knowledgeCutoff": "2024-06-01",
+    "resolvedAt": "2026-03-24T11:14:16.050Z",
+    "baseModelName": "o4-mini"
+  }
+};
diff --git a/internal-packages/llm-model-catalog/src/registry.test.ts b/internal-packages/llm-model-catalog/src/registry.test.ts
new file mode 100644
index 00000000000..679c8c4cfcf
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/registry.test.ts
@@ -0,0 +1,396 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ModelPricingRegistry } from "./registry.js";
+import { defaultModelPrices } from "./defaultPrices.js";
+import type { LlmModelWithPricing } from "./types.js";
+
+// Convert POSIX-style (?i) inline flag to JS RegExp 'i' flag
+function compilePattern(pattern: string): RegExp {
+  if (pattern.startsWith("(?i)")) {
+    return new RegExp(pattern.slice(4), "i");
+  }
+  return new RegExp(pattern);
+}
+
+// Create a mock registry that we can load with test data without Prisma
+class TestableRegistry extends ModelPricingRegistry {
+  loadPatterns(models: LlmModelWithPricing[]) {
+    // Access private fields via any cast for testing
+    const self = this as any;
+    self._patterns = models.map((model) => ({
+      regex: compilePattern(model.matchPattern),
+      model,
+    }));
+    self._exactMatchCache = new Map();
+    self._loaded = true;
+  }
+}
+
+const gpt4o: LlmModelWithPricing = {
+  id: "model-gpt4o",
+  friendlyId: "llm_model_gpt4o",
+  modelName: "gpt-4o",
+  matchPattern: "^gpt-4o(-\\d{4}-\\d{2}-\\d{2})?$",
+  startDate: null,
+  pricingTiers: [
+    {
+      id: "tier-gpt4o-standard",
+      name: "Standard",
+      isDefault: true,
+      priority: 0,
+      conditions: [],
+      prices: [
+        { usageType: "input", price: 0.0000025 },
+        { usageType: "output", price: 0.00001 },
+        { usageType: "input_cached_tokens", price: 0.00000125 },
+      ],
+    },
+  ],
+};
+
+const claudeSonnet: LlmModelWithPricing = {
+  id: "model-claude-sonnet",
+  friendlyId: "llm_model_claude_sonnet",
+  modelName: "claude-sonnet-4-0",
+  matchPattern: "^claude-sonnet-4-0(-\\d{8})?$",
+  startDate: null,
+  pricingTiers: [
+    {
+      id: "tier-claude-sonnet-standard",
+      name: "Standard",
+      isDefault: true,
+      priority: 0,
+      conditions: [],
+      prices: [
+        { usageType: "input", price: 0.000003 },
+        { usageType: "output", price: 0.000015 },
+        { usageType: "input_cached_tokens", price: 0.0000015 },
+      ],
+    },
+  ],
+};
+
+describe("ModelPricingRegistry", () => {
+  let registry: TestableRegistry;
+
+  beforeEach(() => {
+    registry = new TestableRegistry(null as any);
+    registry.loadPatterns([gpt4o, claudeSonnet]);
+  });
+
+  describe("match", () => {
+    it("should match exact model name", () => {
+      const result = registry.match("gpt-4o");
+      expect(result).not.toBeNull();
+      expect(result!.modelName).toBe("gpt-4o");
+    });
+
+    it("should match model with date suffix", () => {
+      const result = registry.match("gpt-4o-2024-08-06");
+      expect(result).not.toBeNull();
+      expect(result!.modelName).toBe("gpt-4o");
+    });
+
+    it("should match claude model", () => {
+      const result = registry.match("claude-sonnet-4-0-20250514");
+      expect(result).not.toBeNull();
+      expect(result!.modelName).toBe("claude-sonnet-4-0");
+    });
+
+    it("should return null for unknown model", () => {
+      const result = registry.match("unknown-model-xyz");
+      expect(result).toBeNull();
+    });
+
+    it("should cache exact matches", () => {
+      registry.match("gpt-4o");
+      registry.match("gpt-4o");
+      // Second call should use cache - no way to verify without mocking, but it shouldn't error
+      expect(registry.match("gpt-4o")!.modelName).toBe("gpt-4o");
+    });
+
+    it("should cache misses", () => {
+      expect(registry.match("unknown")).toBeNull();
+      expect(registry.match("unknown")).toBeNull();
+    });
+  });
+
+  describe("calculateCost", () => {
+    it("should calculate cost for input and output tokens", () => {
+      const result = registry.calculateCost("gpt-4o", {
+        input: 1000,
+        output: 100,
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.matchedModelName).toBe("gpt-4o");
+      expect(result!.pricingTierName).toBe("Standard");
+      expect(result!.inputCost).toBeCloseTo(0.0025); // 1000 * 0.0000025
+      expect(result!.outputCost).toBeCloseTo(0.001); // 100 * 0.00001
+      expect(result!.totalCost).toBeCloseTo(0.0035);
+    });
+
+    it("should include cached token costs", () => {
+      const result = registry.calculateCost("gpt-4o", {
+        input: 500,
+        output: 50,
+        input_cached_tokens: 200,
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.costDetails["input"]).toBeCloseTo(0.00125); // 500 * 0.0000025
+      expect(result!.costDetails["output"]).toBeCloseTo(0.0005); // 50 * 0.00001
+      expect(result!.costDetails["input_cached_tokens"]).toBeCloseTo(0.00025); // 200 * 0.00000125
+      expect(result!.totalCost).toBeCloseTo(0.002);
+    });
+
+    it("should return null for unknown model", () => {
+      const result = registry.calculateCost("unknown-model", { input: 100, output: 50 });
+      expect(result).toBeNull();
+    });
+
+    it("should handle zero tokens", () => {
+      const result = registry.calculateCost("gpt-4o", { input: 0, output: 0 });
+      expect(result).not.toBeNull();
+      expect(result!.totalCost).toBe(0);
+    });
+
+    it("should handle missing usage types gracefully", () => {
+      const result = registry.calculateCost("gpt-4o", { input: 100 });
+      expect(result).not.toBeNull();
+      expect(result!.inputCost).toBeCloseTo(0.00025);
+      expect(result!.outputCost).toBe(0); // No output tokens
+      expect(result!.totalCost).toBeCloseTo(0.00025);
+    });
+  });
+
+  describe("isLoaded", () => {
+    it("should return false before loading", () => {
+      const freshRegistry = new TestableRegistry(null as any);
+      expect(freshRegistry.isLoaded).toBe(false);
+    });
+
+    it("should return true after loading", () => {
+      expect(registry.isLoaded).toBe(true);
+    });
+  });
+
+  describe("prefix stripping", () => {
+    it("should match gateway-prefixed model names", () => {
+      const result = registry.match("openai/gpt-4o");
+      expect(result).not.toBeNull();
+      expect(result!.modelName).toBe("gpt-4o");
+    });
+
+    it("should match openrouter-prefixed model names with date suffix", () => {
+      const result = registry.match("openai/gpt-4o-2024-08-06");
+      expect(result).not.toBeNull();
+      expect(result!.modelName).toBe("gpt-4o");
+    });
+
+    it("should return null for prefixed unknown model", () => {
+      const result = registry.match("xai/unknown-model");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("tier matching", () => {
+    const multiTierModel: LlmModelWithPricing = {
+      id: "model-gemini-pro",
+      friendlyId: "llm_model_gemini_pro",
+      modelName: "gemini-2.5-pro",
+      matchPattern: "^gemini-2\\.5-pro$",
+      startDate: null,
+      pricingTiers: [
+        {
+          id: "tier-large-context",
+          name: "Large Context",
+          isDefault: false,
+          priority: 0,
+          conditions: [
+            { usageDetailPattern: "input", operator: "gt" as const, value: 200000 },
+          ],
+          prices: [
+            { usageType: "input", price: 0.0000025 },
+            { usageType: "output", price: 0.00001 },
+          ],
+        },
+        {
+          id: "tier-standard",
+          name: "Standard",
+          isDefault: true,
+          priority: 1,
+          conditions: [],
+          prices: [
+            { usageType: "input", price: 0.00000125 },
+            { usageType: "output", price: 0.000005 },
+          ],
+        },
+      ],
+    };
+
+    it("should use conditional tier when conditions match", () => {
+      const tieredRegistry = new TestableRegistry(null as any);
+      tieredRegistry.loadPatterns([multiTierModel]);
+
+      const result = tieredRegistry.calculateCost("gemini-2.5-pro", {
+        input: 250000,
+        output: 1000,
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.pricingTierName).toBe("Large Context");
+      expect(result!.inputCost).toBeCloseTo(0.625); // 250000 * 0.0000025
+    });
+
+    it("should fall back to default tier when conditions do not match", () => {
+      const tieredRegistry = new TestableRegistry(null as any);
+      tieredRegistry.loadPatterns([multiTierModel]);
+
+      const result = tieredRegistry.calculateCost("gemini-2.5-pro", {
+        input: 1000,
+        output: 100,
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.pricingTierName).toBe("Standard");
+      expect(result!.inputCost).toBeCloseTo(0.00125); // 1000 * 0.00000125
+    });
+
+    it("should not let unconditional tier win over conditional match", () => {
+      // Model where unconditional tier has lower priority than conditional
+      const model: LlmModelWithPricing = {
+        ...multiTierModel,
+        pricingTiers: [
+          {
+            id: "tier-unconditional",
+            name: "Unconditional",
+            isDefault: false,
+            priority: 0,
+            conditions: [],
+            prices: [{ usageType: "input", price: 0.001 }],
+          },
+          {
+            id: "tier-conditional",
+            name: "Conditional",
+            isDefault: false,
+            priority: 1,
+            conditions: [
+              { usageDetailPattern: "input", operator: "gt" as const, value: 100 },
+            ],
+            prices: [{ usageType: "input", price: 0.0001 }],
+          },
+          {
+            id: "tier-default",
+            name: "Default",
+            isDefault: true,
+            priority: 2,
+            conditions: [],
+            prices: [{ usageType: "input", price: 0.01 }],
+          },
+        ],
+      };
+
+      const tieredRegistry = new TestableRegistry(null as any);
+      tieredRegistry.loadPatterns([model]);
+
+      // Condition matches — conditional tier should win, not the unconditional one
+      const result = tieredRegistry.calculateCost("gemini-2.5-pro", { input: 500 });
+      expect(result).not.toBeNull();
+      expect(result!.pricingTierName).toBe("Conditional");
+    });
+
+    it("should fall back to isDefault tier when no conditions match", () => {
+      const model: LlmModelWithPricing = {
+        ...multiTierModel,
+        pricingTiers: [
+          {
+            id: "tier-conditional",
+            name: "Conditional",
+            isDefault: false,
+            priority: 0,
+            conditions: [
+              { usageDetailPattern: "input", operator: "gt" as const, value: 999999 },
+            ],
+            prices: [{ usageType: "input", price: 0.001 }],
+          },
+          {
+            id: "tier-default",
+            name: "Default",
+            isDefault: true,
+            priority: 1,
+            conditions: [],
+            prices: [{ usageType: "input", price: 0.0001 }],
+          },
+        ],
+      };
+
+      const tieredRegistry = new TestableRegistry(null as any);
+      tieredRegistry.loadPatterns([model]);
+
+      const result = tieredRegistry.calculateCost("gemini-2.5-pro", { input: 100 });
+      expect(result).not.toBeNull();
+      expect(result!.pricingTierName).toBe("Default");
+    });
+  });
+
+  describe("defaultModelPrices (Langfuse JSON)", () => {
+    it("should load all models from the JSON file", () => {
+      expect(defaultModelPrices.length).toBeGreaterThan(100);
+    });
+
+    it("should compile all match patterns without errors", () => {
+      const langfuseRegistry = new TestableRegistry(null as any);
+      const models: LlmModelWithPricing[] = defaultModelPrices.map((def, i) => ({
+        id: `test-${i}`,
+        friendlyId: `llm_model_test${i}`,
+        modelName: def.modelName,
+        matchPattern: def.matchPattern,
+        startDate: def.startDate ? new Date(def.startDate) : null,
+        pricingTiers: def.pricingTiers.map((tier, j) => ({
+          id: `tier-${i}-${j}`,
+          name: tier.name,
+          isDefault: tier.isDefault,
+          priority: tier.priority,
+          conditions: tier.conditions,
+          prices: Object.entries(tier.prices).map(([usageType, price]) => ({
+            usageType,
+            price,
+          })),
+        })),
+      }));
+
+      // This should not throw — all 141 patterns should compile
+      expect(() => langfuseRegistry.loadPatterns(models)).not.toThrow();
+      expect(langfuseRegistry.isLoaded).toBe(true);
+    });
+
+    it("should match real-world model names from Langfuse patterns", () => {
+      const langfuseRegistry = new TestableRegistry(null as any);
+      const models: LlmModelWithPricing[] = defaultModelPrices.map((def, i) => ({
+        id: `test-${i}`,
+        friendlyId: `llm_model_test${i}`,
+        modelName: def.modelName,
+        matchPattern: def.matchPattern,
+        startDate: null,
+        pricingTiers: def.pricingTiers.map((tier, j) => ({
+          id: `tier-${i}-${j}`,
+          name: tier.name,
+          isDefault: tier.isDefault,
+          priority: tier.priority,
+          conditions: tier.conditions,
+          prices: Object.entries(tier.prices).map(([usageType, price]) => ({
+            usageType,
+            price,
+          })),
+        })),
+      }));
+      langfuseRegistry.loadPatterns(models);
+
+      // Test real model strings that SDKs send
+      expect(langfuseRegistry.match("gpt-4o")).not.toBeNull();
+      expect(langfuseRegistry.match("gpt-4o-mini")).not.toBeNull();
+      expect(langfuseRegistry.match("claude-sonnet-4-5-20250929")).not.toBeNull();
+      expect(langfuseRegistry.match("claude-sonnet-4-20250514")).not.toBeNull();
+    });
+  });
+});
diff --git a/internal-packages/llm-model-catalog/src/registry.ts b/internal-packages/llm-model-catalog/src/registry.ts
new file mode 100644
index 00000000000..80da40ba980
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/registry.ts
@@ -0,0 +1,223 @@
+import type { PrismaClient, PrismaReplicaClient } from "@trigger.dev/database";
+import type {
+  LlmModelWithPricing,
+  LlmCostResult,
+  LlmPricingTierWithPrices,
+  PricingCondition,
+} from "./types.js";
+
+type CompiledPattern = {
+  regex: RegExp;
+  model: LlmModelWithPricing;
+};
+
+// Convert POSIX-style (?i) inline flag to JS RegExp 'i' flag
+function compilePattern(pattern: string): RegExp {
+  if (pattern.startsWith("(?i)")) {
+    return new RegExp(pattern.slice(4), "i");
+  }
+  return new RegExp(pattern);
+}
+
+export class ModelPricingRegistry {
+  private _prisma: PrismaClient | PrismaReplicaClient;
+  private _patterns: CompiledPattern[] = [];
+  // TODO: When we add project-based models (users adding their own), this cache grows unbounded
+  // between reloads. Fine-tuned model IDs (e.g. "ft:gpt-3.5-turbo:org:name:id") create unique
+  // entries per model string. Consider adding an LRU cap or size limit at that point.
+  private _exactMatchCache: Map<string, LlmModelWithPricing | null> = new Map();
+  private _loaded = false;
+  private _readyResolve!: () => void;
+
+  /** Resolves once the initial `loadFromDatabase()` completes successfully. */
+  readonly isReady: Promise<void>;
+
+  constructor(prisma: PrismaClient | PrismaReplicaClient) {
+    this._prisma = prisma;
+    this.isReady = new Promise<void>((resolve) => {
+      this._readyResolve = resolve;
+    });
+  }
+
+  get isLoaded(): boolean {
+    return this._loaded;
+  }
+
+  async loadFromDatabase(): Promise<void> {
+    const models = await this._prisma.llmModel.findMany({
+      where: { projectId: null },
+      include: {
+        pricingTiers: {
+          include: { prices: true },
+          orderBy: { priority: "asc" },
+        },
+      },
+      orderBy: [{ startDate: "desc" }],
+    });
+
+    const compiled: CompiledPattern[] = [];
+
+    for (const model of models) {
+      try {
+        const regex = compilePattern(model.matchPattern);
+        const tiers: LlmPricingTierWithPrices[] = model.pricingTiers.map((tier) => ({
+          id: tier.id,
+          name: tier.name,
+          isDefault: tier.isDefault,
+          priority: tier.priority,
+          conditions: (tier.conditions as PricingCondition[]) ?? [],
+          prices: tier.prices.map((p) => ({
+            usageType: p.usageType,
+            price: Number(p.price),
+          })),
+        }));
+
+        compiled.push({
+          regex,
+          model: {
+            id: model.id,
+            friendlyId: model.friendlyId,
+            modelName: model.modelName,
+            matchPattern: model.matchPattern,
+            startDate: model.startDate,
+            pricingTiers: tiers,
+          },
+        });
+      } catch {
+        // Skip models with invalid regex patterns
+        console.warn(`Invalid regex pattern for model ${model.modelName}: ${model.matchPattern}`);
+      }
+    }
+
+    this._patterns = compiled;
+    this._exactMatchCache.clear();
+
+    if (!this._loaded) {
+      this._loaded = true;
+      this._readyResolve();
+    }
+  }
+
+  async reload(): Promise<void> {
+    await this.loadFromDatabase();
+  }
+
+  match(responseModel: string): LlmModelWithPricing | null {
+    if (!this._loaded) return null;
+
+    // Check exact match cache
+    const cached = this._exactMatchCache.get(responseModel);
+    if (cached !== undefined) return cached;
+
+    // Iterate compiled regex patterns
+    for (const { regex, model } of this._patterns) {
+      if (regex.test(responseModel)) {
+        this._exactMatchCache.set(responseModel, model);
+        return model;
+      }
+    }
+
+    // Fallback: strip provider prefix (e.g. "mistral/mistral-large-3" → "mistral-large-3")
+    // Gateway and OpenRouter prepend the provider to the model name.
+    if (responseModel.includes("/")) {
+      const stripped = responseModel.split("/").slice(1).join("/");
+      for (const { regex, model } of this._patterns) {
+        if (regex.test(stripped)) {
+          this._exactMatchCache.set(responseModel, model);
+          return model;
+        }
+      }
+    }
+
+    // Cache miss
+    this._exactMatchCache.set(responseModel, null);
+    return null;
+  }
+
+  calculateCost(
+    responseModel: string,
+    usageDetails: Record<string, number>
+  ): LlmCostResult | null {
+    const model = this.match(responseModel);
+    if (!model) return null;
+
+    const tier = this._matchPricingTier(model.pricingTiers, usageDetails);
+    if (!tier) return null;
+
+    const costDetails: Record<string, number> = {};
+    let totalCost = 0;
+
+    for (const priceEntry of tier.prices) {
+      const tokenCount = usageDetails[priceEntry.usageType] ?? 0;
+      if (tokenCount === 0) continue;
+      const cost = tokenCount * priceEntry.price;
+      costDetails[priceEntry.usageType] = cost;
+      totalCost += cost;
+    }
+
+    const inputCost = costDetails["input"] ?? 0;
+    const outputCost = costDetails["output"] ?? 0;
+
+    return {
+      matchedModelId: model.friendlyId,
+      matchedModelName: model.modelName,
+      pricingTierId: tier.id,
+      pricingTierName: tier.name,
+      inputCost,
+      outputCost,
+      totalCost,
+      costDetails,
+    };
+  }
+
+  private _matchPricingTier(
+    tiers: LlmPricingTierWithPrices[],
+    usageDetails: Record<string, number>
+  ): LlmPricingTierWithPrices | null {
+    if (tiers.length === 0) return null;
+
+    // Tiers are sorted by priority ascending (lowest first).
+    // First pass: evaluate tiers that have conditions — first match wins.
+    for (const tier of tiers) {
+      if (tier.conditions.length > 0 && this._evaluateConditions(tier.conditions, usageDetails)) {
+        return tier;
+      }
+    }
+
+    // Second pass: fall back to the default tier, or first tier with no conditions
+    const defaultTier = tiers.find((t) => t.isDefault);
+    if (defaultTier) return defaultTier;
+
+    const unconditional = tiers.find((t) => t.conditions.length === 0);
+    return unconditional ?? tiers[0] ?? null;
+  }
+
+  private _evaluateConditions(
+    conditions: PricingCondition[],
+    usageDetails: Record<string, number>
+  ): boolean {
+    return conditions.every((condition) => {
+      // Find matching usage detail key
+      const regex = new RegExp(condition.usageDetailPattern);
+      const matchingValue = Object.entries(usageDetails).find(([key]) => regex.test(key));
+      const value = matchingValue?.[1] ?? 0;
+
+      switch (condition.operator) {
+        case "gt":
+          return value > condition.value;
+        case "gte":
+          return value >= condition.value;
+        case "lt":
+          return value < condition.value;
+        case "lte":
+          return value <= condition.value;
+        case "eq":
+          return value === condition.value;
+        case "neq":
+          return value !== condition.value;
+        default:
+          return false;
+      }
+    });
+  }
+}
diff --git a/internal-packages/llm-model-catalog/src/seed.ts b/internal-packages/llm-model-catalog/src/seed.ts
new file mode 100644
index 00000000000..72d212a9120
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/seed.ts
@@ -0,0 +1,79 @@
+import type { PrismaClient } from "@trigger.dev/database";
+import { generateFriendlyId } from "@trigger.dev/core/v3/isomorphic";
+import { defaultModelPrices } from "./defaultPrices.js";
+import { modelCatalog } from "./modelCatalog.js";
+import { syncLlmCatalog } from "./sync.js";
+
+export async function seedLlmPricing(prisma: PrismaClient): Promise<{
+  modelsCreated: number;
+  modelsSkipped: number;
+  modelsUpdated: number;
+}> {
+  let modelsCreated = 0;
+  let modelsSkipped = 0;
+
+  for (const modelDef of defaultModelPrices) {
+    // Check if this model already exists (don't overwrite admin changes)
+    const existing = await prisma.llmModel.findFirst({
+      where: {
+        projectId: null,
+        modelName: modelDef.modelName,
+      },
+    });
+
+    if (existing) {
+      modelsSkipped++;
+      continue;
+    }
+
+    // Look up catalog metadata for this model
+    const catalog = modelCatalog[modelDef.modelName];
+
+    // Create model + tiers atomically so partial models can't be left behind
+    await prisma.$transaction(async (tx) => {
+      const model = await tx.llmModel.create({
+        data: {
+          friendlyId: generateFriendlyId("llm_model"),
+          modelName: modelDef.modelName.trim(),
+          matchPattern: modelDef.matchPattern,
+          startDate: modelDef.startDate ? new Date(modelDef.startDate) : null,
+          source: "default",
+          // Catalog metadata (from model-catalog.json)
+          provider: catalog?.provider ?? null,
+          description: catalog?.description ?? null,
+          contextWindow: catalog?.contextWindow ?? null,
+          maxOutputTokens: catalog?.maxOutputTokens ?? null,
+          capabilities: catalog?.capabilities ?? [],
+          isHidden: catalog?.isHidden ?? false,
+          baseModelName: catalog?.baseModelName ?? null,
+        },
+      });
+
+      for (const tier of modelDef.pricingTiers) {
+        await tx.llmPricingTier.create({
+          data: {
+            modelId: model.id,
+            name: tier.name,
+            isDefault: tier.isDefault,
+            priority: tier.priority,
+            conditions: tier.conditions,
+            prices: {
+              create: Object.entries(tier.prices).map(([usageType, price]) => ({
+                modelId: model.id,
+                usageType,
+                price,
+              })),
+            },
+          },
+        });
+      }
+    });
+
+    modelsCreated++;
+  }
+
+  // Sync catalog metadata on existing default models
+  const syncResult = await syncLlmCatalog(prisma);
+
+  return { modelsCreated, modelsSkipped, modelsUpdated: syncResult.modelsUpdated };
+}
diff --git a/internal-packages/llm-model-catalog/src/sync.test.ts b/internal-packages/llm-model-catalog/src/sync.test.ts
new file mode 100644
index 00000000000..d2138564ef6
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/sync.test.ts
@@ -0,0 +1,203 @@
+import type { PrismaClient } from "@trigger.dev/database";
+import { postgresTest } from "@internal/testcontainers";
+import { generateFriendlyId } from "@trigger.dev/core/v3/isomorphic";
+import { describe, expect } from "vitest";
+import { defaultModelPrices } from "./defaultPrices.js";
+import { modelCatalog } from "./modelCatalog.js";
+import { syncLlmCatalog } from "./sync.js";
+
+function getGpt4oDefinition() {
+  const def = defaultModelPrices.find((m) => m.modelName === "gpt-4o");
+  if (def === undefined) {
+    throw new Error("expected gpt-4o in defaultModelPrices");
+  }
+  return def;
+}
+
+const gpt4oDef = getGpt4oDefinition();
+
+function getGeminiProDefinition() {
+  const def = defaultModelPrices.find((m) => m.modelName === "gemini-pro");
+  if (def === undefined) {
+    throw new Error("expected gemini-pro in defaultModelPrices");
+  }
+  return def;
+}
+
+const geminiProDef = getGeminiProDefinition();
+
+/** If sync used `catalog?.baseModelName ?? existing.baseModelName`, sync would keep this string instead of clearing to null. */
+const STALE_BASE_MODEL_NAME = "wrong-base-model-sentinel";
+
+const STALE_INPUT_PRICE = 0.099;
+const STALE_OUTPUT_PRICE = 0.088;
+
+async function createGpt4oWithStalePricing(
+  prisma: PrismaClient,
+  source: "default" | "admin"
+) {
+  const model = await prisma.llmModel.create({
+    data: {
+      friendlyId: generateFriendlyId("llm_model"),
+      projectId: null,
+      modelName: gpt4oDef.modelName,
+      matchPattern: "^stale-pattern$",
+      startDate: gpt4oDef.startDate ? new Date(gpt4oDef.startDate) : null,
+      source,
+      provider: "stale-provider",
+      description: "stale description",
+      contextWindow: 111,
+      maxOutputTokens: 222,
+      capabilities: ["stale-cap"],
+      isHidden: true,
+      baseModelName: "stale-base",
+    },
+  });
+
+  await prisma.llmPricingTier.create({
+    data: {
+      modelId: model.id,
+      name: "Standard",
+      isDefault: true,
+      priority: 0,
+      conditions: [],
+      prices: {
+        create: [
+          { modelId: model.id, usageType: "input", price: STALE_INPUT_PRICE },
+          { modelId: model.id, usageType: "output", price: STALE_OUTPUT_PRICE },
+        ],
+      },
+    },
+  });
+
+  return model;
+}
+
+async function createGeminiProWithStaleBaseModelName(prisma: PrismaClient) {
+  const catalogEntry = modelCatalog[geminiProDef.modelName];
+  expect(catalogEntry).toBeDefined();
+  expect(catalogEntry.baseModelName).toBeNull();
+
+  const model = await prisma.llmModel.create({
+    data: {
+      friendlyId: generateFriendlyId("llm_model"),
+      projectId: null,
+      modelName: geminiProDef.modelName,
+      matchPattern: "^stale-gemini-pattern$",
+      startDate: geminiProDef.startDate ? new Date(geminiProDef.startDate) : null,
+      source: "default",
+      provider: "stale-provider",
+      description: "stale description",
+      contextWindow: 111,
+      maxOutputTokens: 222,
+      capabilities: ["stale-cap"],
+      isHidden: true,
+      baseModelName: STALE_BASE_MODEL_NAME,
+    },
+  });
+
+  const tier = geminiProDef.pricingTiers[0];
+  await prisma.llmPricingTier.create({
+    data: {
+      modelId: model.id,
+      name: tier.name,
+      isDefault: tier.isDefault,
+      priority: tier.priority,
+      conditions: tier.conditions,
+      prices: {
+        create: Object.entries(tier.prices).map(([usageType, price]) => ({
+          modelId: model.id,
+          usageType,
+          price,
+        })),
+      },
+    },
+  });
+
+  return model;
+}
+
+async function loadGpt4oWithTiers(prisma: PrismaClient) {
+  return prisma.llmModel.findFirst({
+    where: { projectId: null, modelName: gpt4oDef.modelName },
+    include: {
+      pricingTiers: {
+        include: { prices: true },
+        orderBy: { priority: "asc" },
+      },
+    },
+  });
+}
+
+function expectBundledGpt4oPricing(model: NonNullable<Awaited<ReturnType<typeof loadGpt4oWithTiers>>>) {
+  expect(model.matchPattern).toBe(gpt4oDef.matchPattern);
+  expect(model.pricingTiers).toHaveLength(gpt4oDef.pricingTiers.length);
+
+  const dbTier = model.pricingTiers[0];
+  const defTier = gpt4oDef.pricingTiers[0];
+  expect(dbTier.name).toBe(defTier.name);
+  expect(dbTier.isDefault).toBe(defTier.isDefault);
+  expect(dbTier.priority).toBe(defTier.priority);
+
+  const priceByType = new Map(dbTier.prices.map((p) => [p.usageType, Number(p.price)]));
+  for (const [usageType, expected] of Object.entries(defTier.prices)) {
+    expect(priceByType.get(usageType)).toBeCloseTo(expected, 12);
+  }
+  expect(priceByType.size).toBe(Object.keys(defTier.prices).length);
+}
+
+describe("syncLlmCatalog", () => {
+  postgresTest(
+    "rebuilds gpt-4o pricing tiers from bundled defaults when source is default",
+    async ({ prisma }) => {
+      await createGpt4oWithStalePricing(prisma, "default");
+
+      const result = await syncLlmCatalog(prisma);
+
+      expect(result.modelsUpdated).toBe(1);
+      expect(result.modelsSkipped).toBe(defaultModelPrices.length - 1);
+
+      const after = await loadGpt4oWithTiers(prisma);
+      expect(after).not.toBeNull();
+      expectBundledGpt4oPricing(after!);
+    }
+  );
+
+  postgresTest(
+    "does not replace pricing tiers when model source is not default",
+    async ({ prisma }) => {
+      await createGpt4oWithStalePricing(prisma, "admin");
+
+      const result = await syncLlmCatalog(prisma);
+
+      expect(result.modelsUpdated).toBe(0);
+      expect(result.modelsSkipped).toBeGreaterThanOrEqual(1);
+
+      const after = await loadGpt4oWithTiers(prisma);
+      expect(after).not.toBeNull();
+      expect(after!.matchPattern).toBe("^stale-pattern$");
+      expect(after!.pricingTiers).toHaveLength(1);
+      const prices = after!.pricingTiers[0].prices;
+      const input = prices.find((p) => p.usageType === "input");
+      const output = prices.find((p) => p.usageType === "output");
+      expect(Number(input?.price)).toBeCloseTo(STALE_INPUT_PRICE, 12);
+      expect(Number(output?.price)).toBeCloseTo(STALE_OUTPUT_PRICE, 12);
+      expect(prices).toHaveLength(2);
+    }
+  );
+
+  postgresTest(
+    "clears baseModelName when bundled catalog has null (regression for nullish-coalescing merge)",
+    async ({ prisma }) => {
+      await createGeminiProWithStaleBaseModelName(prisma);
+
+      await syncLlmCatalog(prisma);
+
+      const after = await prisma.llmModel.findFirst({
+        where: { projectId: null, modelName: geminiProDef.modelName },
+      });
+      expect(after).not.toBeNull();
+      expect(after!.baseModelName).toBeNull();
+    }
+  );
+});
diff --git a/internal-packages/llm-model-catalog/src/sync.ts b/internal-packages/llm-model-catalog/src/sync.ts
new file mode 100644
index 00000000000..aa0611dbda2
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/sync.ts
@@ -0,0 +1,101 @@
+import type { Prisma, PrismaClient } from "@trigger.dev/database";
+import { defaultModelPrices } from "./defaultPrices.js";
+import { modelCatalog } from "./modelCatalog.js";
+import type { DefaultModelDefinition } from "./types.js";
+
+function pricingTierCreateData(
+  modelId: string,
+  tier: DefaultModelDefinition["pricingTiers"][number]
+): Prisma.LlmPricingTierUncheckedCreateInput {
+  return {
+    modelId,
+    name: tier.name,
+    isDefault: tier.isDefault,
+    priority: tier.priority,
+    conditions: tier.conditions,
+    prices: {
+      create: Object.entries(tier.prices).map(([usageType, price]) => ({
+        modelId,
+        usageType,
+        price,
+      })),
+    },
+  };
+}
+
+export async function syncLlmCatalog(prisma: PrismaClient): Promise<{
+  modelsUpdated: number;
+  modelsSkipped: number;
+}> {
+  let modelsUpdated = 0;
+  let modelsSkipped = 0;
+
+  for (const modelDef of defaultModelPrices) {
+    const existing = await prisma.llmModel.findFirst({
+      where: {
+        projectId: null,
+        modelName: modelDef.modelName,
+      },
+    });
+
+    // Skip if model doesn't exist yet (seed handles creation)
+    if (!existing) {
+      modelsSkipped++;
+      continue;
+    }
+
+    // Don't overwrite admin-edited models
+    if (existing.source !== "default") {
+      modelsSkipped++;
+      continue;
+    }
+
+    const catalog = modelCatalog[modelDef.modelName];
+
+    const applied = await prisma.$transaction(async (tx) => {
+      const updateResult = await tx.llmModel.updateMany({
+        where: { id: existing.id, source: "default" },
+        data: {
+          // Update match pattern and start date from Langfuse (may have changed)
+          matchPattern: modelDef.matchPattern,
+          startDate: modelDef.startDate ? new Date(modelDef.startDate) : null,
+          // Update catalog metadata
+          provider: catalog?.provider ?? existing.provider,
+          description: catalog?.description ?? existing.description,
+          contextWindow:
+            catalog?.contextWindow === undefined ? existing.contextWindow : catalog.contextWindow,
+          maxOutputTokens:
+            catalog?.maxOutputTokens === undefined
+              ? existing.maxOutputTokens
+              : catalog.maxOutputTokens,
+          capabilities: catalog?.capabilities ?? existing.capabilities,
+          isHidden: catalog?.isHidden ?? existing.isHidden,
+          baseModelName:
+            catalog?.baseModelName === undefined
+              ? existing.baseModelName
+              : catalog.baseModelName,
+        },
+      });
+
+      if (updateResult.count !== 1) {
+        return false;
+      }
+
+      await tx.llmPricingTier.deleteMany({ where: { modelId: existing.id } });
+
+      for (const tier of modelDef.pricingTiers) {
+        await tx.llmPricingTier.create({
+          data: pricingTierCreateData(existing.id, tier),
+        });
+      }
+
+      return true;
+    });
+
+    if (applied) {
+      modelsUpdated++;
+    }
+  }
+
+  return { modelsUpdated, modelsSkipped };
+}
diff --git a/internal-packages/llm-model-catalog/src/types.ts b/internal-packages/llm-model-catalog/src/types.ts
new file mode 100644
index 00000000000..d6c6638d620
--- /dev/null
+++ b/internal-packages/llm-model-catalog/src/types.ts
@@ -0,0 +1,87 @@
+import type { Decimal } from "@trigger.dev/database";
+
+export type PricingCondition = {
+  usageDetailPattern: string;
+  operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
+  value: number;
+};
+
+export type LlmPriceEntry = {
+  usageType: string;
+  price: number;
+};
+
+export type LlmPricingTierWithPrices = {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  priority: number;
+  conditions: PricingCondition[];
+  prices: LlmPriceEntry[];
+};
+
+export type LlmModelWithPricing = {
+  id: string;
+  friendlyId: string;
+  modelName: string;
+  matchPattern: string;
+  startDate: Date | null;
+  pricingTiers: LlmPricingTierWithPrices[];
+};
+
+export type LlmCostResult = {
+  matchedModelId: string;
+  matchedModelName: string;
+  pricingTierId: string;
+  pricingTierName: string;
+  inputCost: number;
+  outputCost: number;
+  totalCost: number;
+  costDetails: Record<string, number>;
+};
+
+export type ModelCatalogEntry = {
+  provider: string;
+  description: string;
+  contextWindow: number | null;
+  maxOutputTokens: number | null;
+  capabilities: string[];
+  /** ISO date string of when the model was publicly released (e.g. "2025-06-15"). */
+  releaseDate: string | null;
+  /** Whether the model is deprecated/legacy and should be hidden from the registry by default. */
+  isHidden: boolean;
+  /** Whether the model supports reliable structured JSON output (schema adherence). */
+  supportsStructuredOutput: boolean;
+  /** Whether the model can call multiple tools in a single turn. */
+  supportsParallelToolCalls: boolean;
+  /** Whether the model supports streaming partial tool call results. */
+  supportsStreamingToolCalls: boolean;
+  /** ISO date string of when the model will be deprecated/sunset, if known. */
+  deprecationDate: string | null;
+  /** ISO date string of the model's training data cutoff (e.g. "2024-10-01"). */
+  knowledgeCutoff: string | null;
+  /** ISO timestamp of when this entry was last researched/resolved. */
+  resolvedAt: string;
+  /** The base model this is a variant of, or null if this IS the base model. */
+  baseModelName: string | null;
+};
+
+export type DefaultModelDefinition = {
+  modelName: string;
+  matchPattern: string;
+  startDate?: string;
+  // Catalog metadata (merged from model-catalog.json during seed)
+  provider?: string;
+  description?: string;
+  contextWindow?: number | null;
+  maxOutputTokens?: number | null;
+  capabilities?: string[];
+  isHidden?: boolean;
+  pricingTiers: Array<{
+    name: string;
+    isDefault: boolean;
+    priority: number;
+    conditions: PricingCondition[];
+    prices: Record<string, number>;
+  }>;
+};
diff --git a/internal-packages/llm-model-catalog/tsconfig.json b/internal-packages/llm-model-catalog/tsconfig.json
new file mode 100644
index 00000000000..7c980007eef
--- /dev/null
+++ b/internal-packages/llm-model-catalog/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "lib": ["ES2019", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "strict": true,
+    "resolveJsonModule": true
+  },
+  "exclude": ["node_modules", "**/*.test.ts"]
+}
diff --git a/internal-packages/llm-model-catalog/vitest.config.ts b/internal-packages/llm-model-catalog/vitest.config.ts
new file mode 100644
index 00000000000..474961216bf
--- /dev/null
+++ b/internal-packages/llm-model-catalog/vitest.config.ts
@@ -0,0 +1,16 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["**/*.test.ts"],
+    globals: true,
+    isolate: true,
+    fileParallelism: false,
+    poolOptions: {
+      threads: {
+        singleThread: true,
+      },
+    },
+    testTimeout: 120_000,
+  },
+});
diff --git a/internal-packages/otlp-importer/src/index.ts b/internal-packages/otlp-importer/src/index.ts
index 7401431a847..3a70776ddff 100644
--- a/internal-packages/otlp-importer/src/index.ts
+++ b/internal-packages/otlp-importer/src/index.ts
@@ -10,6 +10,12 @@ import {
   ExportLogsServiceResponse,
 } from "./generated/opentelemetry/proto/collector/logs/v1/logs_service";
 
+import {
+  ExportMetricsPartialSuccess,
+  ExportMetricsServiceRequest,
+  ExportMetricsServiceResponse,
+} from "./generated/opentelemetry/proto/collector/metrics/v1/metrics_service";
+
 import type {
   AnyValue,
   KeyValue,
@@ -33,6 +39,21 @@ import {
   Status,
   Status_StatusCode,
 } from "./generated/opentelemetry/proto/trace/v1/trace";
+import {
+  ResourceMetrics,
+  ScopeMetrics,
+  Metric,
+  Gauge,
+  Sum,
+  Histogram,
+  ExponentialHistogram,
+  Summary,
+  NumberDataPoint,
+  HistogramDataPoint,
+  ExponentialHistogramDataPoint,
+  SummaryDataPoint,
+  AggregationTemporality,
+} from "./generated/opentelemetry/proto/metrics/v1/metrics";
 
 export {
   LogRecord,
@@ -57,3 +78,21 @@ export {
 export { ExportTracePartialSuccess, ExportTraceServiceRequest, ExportTraceServiceResponse };
 
 export { ExportLogsPartialSuccess, ExportLogsServiceRequest, ExportLogsServiceResponse };
+
+export { ExportMetricsPartialSuccess, ExportMetricsServiceRequest, ExportMetricsServiceResponse };
+
+export {
+  ResourceMetrics,
+  ScopeMetrics,
+  Metric,
+  Gauge,
+  Sum,
+  Histogram,
+  ExponentialHistogram,
+  Summary,
+  NumberDataPoint,
+  HistogramDataPoint,
+  ExponentialHistogramDataPoint,
+  SummaryDataPoint,
+  AggregationTemporality,
+};
diff --git a/internal-packages/replication/src/pgoutput.ts b/internal-packages/replication/src/pgoutput.ts
index 0e75a697f4e..809ad877581 100644
--- a/internal-packages/replication/src/pgoutput.ts
+++ b/internal-packages/replication/src/pgoutput.ts
@@ -20,6 +20,18 @@ export type PgoutputMessage =
   | MessageType
   | MessageUpdate;
 
+export type PgoutputMessageArray =
+  | MessageBegin
+  | MessageCommit
+  | MessageDeleteArray
+  | MessageInsertArray
+  | MessageMessage
+  | MessageOrigin
+  | MessageRelation
+  | MessageTruncate
+  | MessageType
+  | MessageUpdateArray;
+
 export interface MessageBegin {
   tag: "begin";
   commitLsn: string | null;
@@ -95,6 +107,26 @@ export interface MessageUpdate {
   new: Record<string, any>;
 }
 
+// Array variants for zero-copy performance
+export interface MessageInsertArray {
+  tag: "insert";
+  relation: MessageRelation;
+  new: any[];
+}
+export interface MessageUpdateArray {
+  tag: "update";
+  relation: MessageRelation;
+  key: any[] | null;
+  old: any[] | null;
+  new: any[];
+}
+export interface MessageDeleteArray {
+  tag: "delete";
+  relation: MessageRelation;
+  key: any[] | null;
+  old: any[] | null;
+}
+
 class BinaryReader {
   private offset = 0;
   constructor(private buf: Buffer) {}
@@ -193,6 +225,35 @@ export class PgoutputParser {
     }
   }
 
+  public parseArray(buf: Buffer): PgoutputMessageArray {
+    const reader = new BinaryReader(buf);
+    const tag = reader.readUint8();
+    switch (tag) {
+      case 0x42:
+        return this.msgBegin(reader);
+      case 0x4f:
+        return this.msgOrigin(reader);
+      case 0x59:
+        return this.msgType(reader);
+      case 0x52:
+        return this.msgRelation(reader);
+      case 0x49:
+        return this.msgInsertArray(reader);
+      case 0x55:
+        return this.msgUpdateArray(reader);
+      case 0x44:
+        return this.msgDeleteArray(reader);
+      case 0x54:
+        return this.msgTruncate(reader);
+      case 0x4d:
+        return this.msgMessage(reader);
+      case 0x43:
+        return this.msgCommit(reader);
+      default:
+        throw Error("unknown pgoutput message");
+    }
+  }
+
   private msgBegin(reader: BinaryReader): MessageBegin {
     return {
       tag: "begin",
@@ -312,6 +373,55 @@ export class PgoutputParser {
     }
     return { tag: "delete", relation, key, old };
   }
+
+  // Array variants - skip object creation for performance
+  private msgInsertArray(reader: BinaryReader): MessageInsertArray {
+    const relation = this._relationCache.get(reader.readInt32());
+    if (!relation) throw Error("missing relation");
+    reader.readUint8(); // consume the 'N' key
+    return {
+      tag: "insert",
+      relation,
+      new: this.readTupleAsArray(reader, relation),
+    };
+  }
+  private msgUpdateArray(reader: BinaryReader): MessageUpdateArray {
+    const relation = this._relationCache.get(reader.readInt32());
+    if (!relation) throw Error("missing relation");
+    let key: any[] | null = null;
+    let old: any[] | null = null;
+    let new_: any[] | null = null;
+    const subMsgKey = reader.readUint8();
+    if (subMsgKey === 0x4b) {
+      key = this.readTupleAsArray(reader, relation);
+      reader.readUint8();
+      new_ = this.readTupleAsArray(reader, relation);
+    } else if (subMsgKey === 0x4f) {
+      old = this.readTupleAsArray(reader, relation);
+      reader.readUint8();
+      new_ = this.readTupleAsArray(reader, relation, old);
+    } else if (subMsgKey === 0x4e) {
+      new_ = this.readTupleAsArray(reader, relation);
+    } else {
+      throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`);
+    }
+    return { tag: "update", relation, key, old, new: new_ };
+  }
+  private msgDeleteArray(reader: BinaryReader): MessageDeleteArray {
+    const relation = this._relationCache.get(reader.readInt32());
+    if (!relation) throw Error("missing relation");
+    let key: any[] | null = null;
+    let old: any[] | null = null;
+    const subMsgKey = reader.readUint8();
+    if (subMsgKey === 0x4b) {
+      key = this.readTupleAsArray(reader, relation);
+    } else if (subMsgKey === 0x4f) {
+      old = this.readTupleAsArray(reader, relation);
+    } else {
+      throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`);
+    }
+    return { tag: "delete", relation, key, old };
+  }
   private readKeyTuple(reader: BinaryReader, relation: MessageRelation): Record<string, any> {
     const tuple = this.readTuple(reader, relation);
     const key = Object.create(null);
@@ -354,6 +464,40 @@ export class PgoutputParser {
     }
     return tuple;
   }
+
+  private readTupleAsArray(
+    reader: BinaryReader,
+    { columns }: MessageRelation,
+    unchangedToastFallback?: any[] | null
+  ): any[] {
+    const nfields = reader.readInt16();
+    const tuple = new Array(nfields);
+    for (let i = 0; i < nfields; i++) {
+      const { parser } = columns[i];
+      const kind = reader.readUint8();
+      switch (kind) {
+        case 0x62: // 'b' binary
+          const bsize = reader.readInt32();
+          tuple[i] = reader.read(bsize);
+          break;
+        case 0x74: // 't' text
+          const valsize = reader.readInt32();
+          const valbuf = reader.read(valsize);
+          const valtext = reader.decodeText(valbuf);
+          tuple[i] = parser(valtext);
+          break;
+        case 0x6e: // 'n' null
+          tuple[i] = null;
+          break;
+        case 0x75: // 'u' unchanged toast datum
+          tuple[i] = unchangedToastFallback?.[i];
+          break;
+        default:
+          throw Error(`unknown attribute kind ${String.fromCharCode(kind)}`);
+      }
+    }
+    return tuple;
+  }
   private msgTruncate(reader: BinaryReader): MessageTruncate {
     const nrels = reader.readInt32();
     const flags = reader.readUint8();
diff --git a/internal-packages/run-engine/CLAUDE.md b/internal-packages/run-engine/CLAUDE.md
new file mode 100644
index 00000000000..74e25338ca9
--- /dev/null
+++ b/internal-packages/run-engine/CLAUDE.md
@@ -0,0 +1,46 @@
+# Run Engine 2.0
+
+Core run lifecycle management system (`@internal/run-engine`). This is where ALL new run lifecycle logic should go - not in `apps/webapp/app/v3/services/` directly.
+
+## Architecture
+
+The `RunEngine` class (`src/engine/index.ts`) orchestrates modular systems:
+
+### Systems (`src/engine/systems/`)
+
+Each system handles one concern:
+- **BatchSystem**: Batch trigger processing with DRR (Deficit Round Robin)
+- **CheckpointSystem**: Execution checkpoints for recovery
+- **DebounceSystem**: Configurable debouncing with delay
+- **DelayedRunSystem**: TTL-based delayed execution
+- **DequeueSystem**: Pulls runs from queue, assigns to workers
+- **EnqueueSystem**: Adds runs to queue with ordering
+- **ExecutionSnapshotSystem**: Stores/restores run state for warm restarts
+- **PendingVersionSystem**: Version management for deployments
+- **RunAttemptSystem**: Individual execution attempts (retries, heartbeats)
+- **TTLSystem**: Automatic run expiration
+- **WaitpointSystem**: Synchronization primitive for waiting between tasks
+
+### Queue and Locking
+
+- **RunQueue** (`src/run-queue/`): Redis-backed fair queue with concurrency management
+- **BatchQueue** (`src/batch-queue/`): Batch processing queue
+- **RunLocker** (`src/locking.ts`): Redis locks preventing concurrent run execution
+
+## Key Design Patterns
+
+- Event-driven via EventBus
+- OpenTelemetry tracer/meter integration
+- Redis for distributed locks and queues
+- Prisma for persistence with read-only replica support (`readOnlyPrisma`)
+
+## Testing
+
+Tests live in `src/engine/tests/` and use testcontainers (Redis + PostgreSQL):
+
+```bash
+cd internal-packages/run-engine
+pnpm run test ./src/engine/tests/ttl.test.ts --run
+```
+
+May need to build dependencies first: `pnpm run build --filter @internal/run-engine`
diff --git a/internal-packages/run-engine/README.md b/internal-packages/run-engine/README.md
index 499242da21c..a2b80b5f916 100644
--- a/internal-packages/run-engine/README.md
+++ b/internal-packages/run-engine/README.md
@@ -19,6 +19,107 @@ It is responsible for:
       - **Run controller**: The code that manages running the task.
       - **Run executor**: The actual task running.
 
+## Overview
+
+```
+                                                                                                     ╔═══════════════════════════════╗
+                                                                                                     ║                               ║░
+                                                                                                     ║         Run triggered         ║░
+                                                                                                     ║                               ║░
+                                                                                                     ╚═══════════════════════════════╝░
+                                               ___             ___           _                        ░░░░░░░░░░░░░░░│░░░░░░░░░░░░░░░░░
+                                              | _ \_  _ _ _   | __|_ _  __ _(_)_ _  ___                              │
+                                           ╔══|   / || | ' \  | _|| ' \/ _` | | ' \/ -_)═════════════════════════════╬══════════════════════════════════════╗
+                                           ║  |_|_\\_,_|_||_| |___|_||_\__, |_|_||_\___|                             │                                      ║
+                                           ║                           |___/                                         │                                      ║
+                                           ║                                                                         │                                      ║
+                                           ║                       ┌────────────────────────────────────── Has delay/debounce?                              ║
+                                           ║                       │                                                 │                                      ║
+                                           ║                      Yes                                               No                                      ║
+                                           ║                       │                                                 │                                      ║
+                                           ║                       ▼                                                 ▼                                      ║
+                                           ║       ╔═══════════════════════════════╗                 ╔═══════════════════════════════╗                      ║
+                                           ║       ║                               ║      Delay/     ║                               ║                      ║
+                                           ║       ║            DELAYED            ║◀────debounce────║          RUN_CREATED          ║                      ║
+                                           ║       ║                               ║                 ║                               ║                      ║
+                                           ║       ╚═══════════════════════════════╝                 ╚═══════════════════════════════╝                      ║
+                                           ║                       │                                                 │                                      ║
+                                           ║                       │                                                 │                                      ║
+                                           ║       +===============================+                         No delay/debounce                              ║
+                                           ║       |                               |                                 │                                      ║
+                                           ║       |         Redis Worker          |                                 │                                      ║
+                                           ║       |                               |                                 ▼                                      ║
+                                           ║       +===============================+                 ╔═══════════════════════════════╗                      ║
+                                           ║                       │                                 ║                               ║                      ║
+                                           ║                       └───────────After delay──────────▶║            QUEUED             ║◀────────────┐        ║
+                                           ║                                                         ║                               ║             │        ║
+                                           ║                                                         ╚═══════════════════════════════╝             │        ║
+                                           ║                       ┌────All Waitpoints complete?─────┐               │                             │        ║
+                                           ║                       │                                 │               │                             │        ║
+                                           ║                       │                                 ▼               ▼                             │        ║
+                                           ║       ╔═══════════════════════════════╗                 +===============================+             │        ║
+                                           ║       ║                               ║                 |                               |        Slow retry    ║
+                                           ║       ║           SUSPENDED           ║                 |           Run Queue           |             │        ║
+                                           ║       ║                               ║                 |                               |             │        ║
+                                           ║       ╚═══════════════════════════════╝                 +===============================+             │        ║
+                        Run not executing  ║                       ▲                                                                               │        ║
+                                           ║                       │                                                 │                             │        ║
+       ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ╬ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ╬ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ╬ ═ ═ ═ ═║═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═
+                                           ║                       │                                                 │                             │        ║
+                      Run maybe executing  ║                       │                                                                               │        ║    ╔═══════════════════════════════╗
+                                           ║                       │                                                 │                             │        ║    ║                               ║░
+                                           ║                       │                                       Pulled from the queue ◀─────────────────┼────────╬───◈║         Dequeue a run         ║░
+                                           ║                       │                                                 │                             │        ║    ║                               ║░
+                                           ║                       │                                                 ▼                             │        ║    ╚═══════════════════════════════╝░
+                                           ║                       │                                 ╔═══════════════════════════════╗             │        ║     ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+                                           ║                       │                                 ║                               ║             │        ║
+                                           ║                       │                                 ║       PENDING_EXECUTING       ║             │        ║
+      ╔═══════════════════════════════╗    ║                       │                                 ║                               ║             │        ║
+      ║                               ║░   ║                       │                                 ╚═══════════════════════════════╝             │        ║
+      ║      Checkpoint created       ║◈───╬───────────────────────┤                                                 │                             │        ║    ╔═══════════════════════════════╗
+      ║                               ║░   ║                                                                                                       │        ║    ║                               ║░
+      ╚═══════════════════════════════╝░   ║                       │                                                 ├─────────────────────────────┼────────╬───◈║         Start attempt         ║░
+       ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   ║                                                                         │                             │        ║    ║                               ║░
+                                           ║                       │                                                 ▼                             │        ║    ╚═══════════════════════════════╝░
+                                           ║                                               All            Is executing on worker                   │        ║     ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+                                           ║                       │               ┌────Waitpoints───┐               │               ┌─Quick retry │        ║
+                                           ║                                       │    complete?    │               │               │      │      │        ║
+                                           ║                       │               │                 ▼               ▼               ▼      │      │        ║
+                                           ║       ╔═══════════════════════════════╗                 ╔═══════════════════════════════╗      │      │        ║
+                                           ║       ║                               ║     Hits a      ║                               ║      │      │        ║
+                                           ║       ║   EXECUTING_WITH_WAITPOINTS   ║◀───Waitpoint────║           EXECUTING           ║      │      │        ║
+                                           ║       ║                               ║                 ║                               ║      │      │        ║
+                                           ║       ╚═══════════════════════════════╝                 ╚═══════════════════════════════╝      │      │        ║
+                                           ║                                                                         │                      │      │        ║    ╔═══════════════════════════════╗
+                                           ║                                                                                                │      │        ║    ║                               ║░
+                                           ║                                                                         ◀──────────────────────┼──────┼────────╬───◈║       Complete attempt        ║░
+                                           ║                                                                         │                      │      │        ║    ║                               ║░
+                                           ║                                                                         │                      │      │        ║    ╚═══════════════════════════════╝░
+                                           ║                                                                         │                      │      │        ║     ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+                                           ║                                                                         ├───────────────▶ Attempt failed       ║
+                                           ║                                                                         │                        │             ║
+                                           ║                                                                  Attempt success                 │             ║
+                                           ║                                                                         │                   All retries        ║
+                                           ║                                                                         ▼                      used            ║
+      ╔═══════════════════════════════╗    ║                                                         ╔═══════════════════════════════╗        │             ║
+      ║                               ║░   ║                                                         ║                               ║        │             ║
+      ║      User cancels a run       ║────╬──────────────▶  Is executing?  ─────────── No ─────────▶║           FINISHED            ║◀───────┘             ║
+      ║                               ║░   ║                       │                                 ║                               ║                      ║
+      ╚═══════════════════════════════╝░   ║                      Yes                                ╚═══════════════════════════════╝                      ║
+       ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   ║                       │                                                 ▲                                      ║
+                                           ║                       ▼                                                 │                                      ║
+                                           ║       ╔═══════════════════════════════╗                                 │                                      ║
+                                           ║       ║                               ║                                 │                                      ║
+                                           ║       ║        PENDING_CANCEL         ║─────────────────────────────────┘                                      ║
+                                           ║       ║                               ║                                                                        ║
+                                           ║       ╚═══════════════════════════════╝                                                                        ║
+                                           ║                                                                                                                ║
+                                           ║                                                                                                                ║
+                                           ║                                                                                                                ║
+                                           ╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝
+
+```
+
 ## Run locking
 
 Many operations on the run are "atomic" in the sense that only a single operation can mutate them at a time. We use RedLock to create a distributed lock to ensure this. Postgres locking is not enough on its own because we have multiple API instances and Redis is used for the queue.
@@ -31,8 +132,6 @@ There are race conditions we need to deal with:
 
 The execution state of a run is stored in the `TaskRunExecutionSnapshot` table in Postgres. This is separate from the `TaskRun` status which is exposed to users via the dashboard and API.
 
-![The execution states](./execution-states.png)
-
 The `TaskRunExecutionSnapshot` `executionStatus` is used to determine the execution status and is internal to the run engine. It is a log of events that impact run execution – the data is used to execute the run.
 
 A common pattern we use is to read the current state and check that the passed in `snapshotId` matches the current `snapshotId`. If it doesn't, we know that the state has moved on. In the case of a checkpoint coming in, we know we can just ignore it.
@@ -41,28 +140,15 @@ We can also store invalid states by setting an error. These invalid states are p
 
 ## Workers
 
-A worker is a server that runs tasks. There are two types of workers:
-
-- Hosted workers (serverless, managed and cloud-only)
-- Self-hosted workers
-
-In the dashboard under the "Workers" page, you can see all worker groups including the "main" group which is the default and not self-hosted. You can also see alternative worker groups that are available to you, such as "EU", "v3.2 (beta)", and any self-hosted worker groups you have created.
-
-You add a new self-hosted worker group by clicking "Add" and choosing an `id` that is unique to your project.
+A worker is a server that runs tasks.
 
-Then when triggering runs, you can specify the `workerGroup` to use. It defaults to "main". The workerGroup is used internally to set the `masterQueue` that a run is placed in, this allows pulling runs only for that worker group.
+In the dashboard under the "Regions" page, you can see all worker groups. You can set the default `region` there.
 
-On the "Workers" page, you can see the status of each worker group, including the number of workers in the group, the number of runs that are queued.
+Then when triggering runs, you can override the `region` to use. The region is used internally to set the `masterQueue` that a run is placed in, this allows pulling runs only for that worker group.
 
 ## Pulling from the queue
 
-A worker will call the Trigger.dev API with it's `workerGroup`.
-
-For warm starts, self-hosted workers we will also pass the `BackgroundWorker` id and `environment` id. This allow pulling relevant runs.
-
-For dev environments, we will pass the `environment` id.
-
-If there's only a `workerGroup`, we can just `dequeueFromMasterQueue()` to get runs. If there's a `BackgroundWorker` id, we need to determine if that `BackgroundWorker` is the latest. If it's the latest we call `dequeueFromEnvironmentMasterQueue()` to get any runs that aren't locked to a version. If it's not the latest, we call `dequeueFromBackgroundWorkerMasterQueue()` to get runs that are locked to that version.
+A worker will call the Trigger.dev API with it's `region`. For dev environments, we will pass the `environment` id.
 
 ## Run Queue
 
@@ -120,22 +206,39 @@ When triggering a run and passing the `delay` option, we use a `DATETIME` waitpo
 
 Wait until a request has been received at the URL that you are given. This is useful for pausing a run and then continuing it again when some external event occurs on another service. For example, Replicate have an API where they will callback when their work is complete.
 
-### `wait.forWaitpoint(waitpointId)`
+### `wait.forToken(waitpointId)`
 
 A more advanced SDK which would require uses to explicitly create a waitpoint. We would also need `createWaitpoint()`, `completeWaitpoint()`, and `failWaitpoint()`.
 
 ```ts
-const waitpoint = await waitpoints.create({ idempotencyKey: `purchase-${payload.cart.id}` });
-const waitpoint = await waitpoints.retrieve(waitpoint.id);
-const waitpoint = await waitpoints.complete(waitpoint.id, result);
-const waitpoint = await waitpoints.fail(waitpoint.id, error);
+// Your backend
+import { wait } from "@trigger.dev/sdk";
+
+type ApprovalToken = {
+  status: "approved" | "rejected";
+};
+
+const waitpoint = await wait.createToken({ idempotencyKey: `purchase-${payload.cart.id}` });
+const waitpoint = await wait.retrieveToken(waitpoint.id);
 
+await wait.completeToken<ApprovalToken>(tokenId, {
+  status: "approved",
+});
+
+// /trigger/approval.ts
 export const approvalFlow = task({
   id: "approvalFlow",
   run: async (payload) => {
     //...do stuff
 
-    const result = await wait.forWaitpoint(waitpoint.id, { timeout: "1h" });
+    // This must be called inside a task run function
+    const result = await wait.forToken<ApprovalToken>(payload.tokenId);
+
+    if (result.ok) {
+      console.log("Token completed", result.output.status); // "approved" or "rejected"
+    } else {
+      console.log("Token timed out", result.error);
+    }
     if (!result.ok) {
       //...timeout
     }
@@ -145,10 +248,6 @@ export const approvalFlow = task({
 });
 ```
 
-### `wait.forRunToComplete(runId)`
-
-You could wait for another run (or runs) using their run ids. This would allow you to wait for runs that you haven't triggered inside that run.
-
 ## Run flow control
 
 There are several ways to control when a run will execute (or not). Each of these should be configurable on a task, a named queue that is shared between tasks, and at trigger time including the ability to pass a `key` so you can have per-tenant controls.
@@ -157,15 +256,6 @@ There are several ways to control when a run will execute (or not). Each of thes
 
 When `trigger` is called the run is added to the queue. We only dequeue when the concurrency limit hasn't been exceeded for that task/queue.
 
-### Rate limiting
-
-When `trigger` is called, we check if the rate limit has been exceeded. If it has then we ignore the trigger. The run is thrown away and an appropriate error is returned.
-
-This is useful:
-
-- To prevent abuse.
-- To control how many executions a user can do (using a `key` with rate limiting).
-
 ### Debouncing
 
 When `trigger` is called, we prevent too many runs happening in a period by collapsing into a single run. This is done by discarding some runs in a period.
@@ -176,25 +266,6 @@ This is useful:
 
 We should mark the run as `"DELAYED"` with the correct `delayUntil` time. This will allow the user to see that the run is delayed and why.
 
-### Throttling
-
-When `trigger` is called the run is added to the queue. We only run them when they don't exceed the limit in that time period, by controlling the timing of when they are dequeued.
-
-This is useful:
-
-- To prevent too many runs happening in a short period.
-- To control how many executions a user can do (using a `key` with throttling).
-- When you need to execute every run but not too many in a short period, e.g. avoiding rate limits.
-
-### Batching
-
-When `trigger` is called, we batch the runs together. This means the payload of the run is an array of items, each being a single payload.
-
-This is useful:
-
-- For performance, as it reduces the number of runs in the system.
-- It can be useful when using 3rd party APIs that support batching.
-
 ## Emitting events
 
 The Run Engine emits events using its `eventBus`. This is used for runs completing, failing, or things that any workers should be aware of.
diff --git a/internal-packages/run-engine/execution-states.png b/internal-packages/run-engine/execution-states.png
deleted file mode 100644
index 7bc7e0d0f9b..00000000000
Binary files a/internal-packages/run-engine/execution-states.png and /dev/null differ
diff --git a/internal-packages/run-engine/runengine-diagram.monojson b/internal-packages/run-engine/runengine-diagram.monojson
new file mode 100644
index 00000000000..970ad4f8806
--- /dev/null
+++ b/internal-packages/run-engine/runengine-diagram.monojson
@@ -0,0 +1,4639 @@
+{
+  "header" : {
+    "v" : 5
+  },
+  "object_list" : [
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "01806FE3-09CD-47AE-9C10-69BC2C15F20E",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "024E1882-EA58-4655-AF81-61F7D1DCBEED",
+      "type_id" : 18
+    },
+    {
+      "border_dash_enabled" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "border_tixels" : "C6997D75-5E0D-43E9-8F8B-C500AEF0E7D3",
+      "content_offset" : "0,3",
+      "content_tixels" : "3605858D-8F35-496F-8077-FF6BD22B6EC5",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "06523895-9FF0-40A9-A1FC-24B12F94A24E",
+      "frame_size" : "114,88",
+      "model_text" : "8CA8575A-5A95-4A7B-9257-C54A53BDAB0C",
+      "mps_border_color" : 4294967294,
+      "name" : "Rectangle 2",
+      "object_id" : "0260D409-FE9E-48A0-A273-7146617D6792",
+      "origin" : "34,8",
+      "position_refs" : [
+        "06523895-9FF0-40A9-A1FC-24B12F94A24E",
+        "FF77AC96-AFF7-4C74-8ACC-A6324ED4702E",
+        "900BD446-F8E1-4006-9588-5AC73CA288F6",
+        "0CFB721B-5963-4847-8826-7E58915A4AC0",
+        "C122EF43-A812-440B-B126-11CC3381770A"
+      ],
+      "rectangular_border" : 6,
+      "shape_type" : 1,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0304CB72-1D42-4280-B345-29F3A7E93FC4",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "030EE553-C5B4-4671-B4BE-CC1C26A33E72",
+      "position_ref" : "FC8D371A-D317-4A4D-B6E3-1A56DA60B5FC",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "03380185-52CB-42AA-B140-6CCBCABF197C",
+      "type_id" : 18
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "040CE454-0AF5-47F9-958E-EA2274961F46",
+      "text" : "PENDING_CANCEL",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "04EB1AD6-462B-46CC-9ABB-DC88DFE2DA70",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "04F3FEDE-59A5-4FEE-807A-008FD3C1FC5D",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "058B2C77-EA4B-4299-A4DE-C6465F734375",
+      "type_id" : 24
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "05CD5A1A-3519-475E-85D3-2275644C12D2",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "06523895-9FF0-40A9-A1FC-24B12F94A24E",
+      "point" : "15,3",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "06FBACF1-15F7-4630-B120-105FDB8C34B9",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "3B214FFD-0519-4963-A550-41DEDBB096B7",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "88B01512-B6E2-4F78-9422-1746B41833DA",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "AA0D777D-A84A-488B-AB5E-81F8C747EC76",
+      "frame_corner" : 5,
+      "frame_size" : "22,3",
+      "model_text" : "A8BD65F3-E402-4CFF-97AC-DA7ED435BFE9",
+      "name" : "Has delay\/debounce?",
+      "object_id" : "07A1185A-5BB9-41DE-B2E2-2F015886E3DC",
+      "origin" : "0,1",
+      "position_refs" : [
+        "AA0D777D-A84A-488B-AB5E-81F8C747EC76",
+        "C213B3CA-646C-43D8-9336-A07E7D4BE165",
+        "89DA6A11-FB45-481F-8EDB-17EFB6A24BFA",
+        "CF6C6D62-FEFF-4B4D-8D48-9B5D1DF5B851"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "07A56291-A68A-45F3-9B19-534E79914414",
+      "text" : "Quick retry",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "07B1BB83-FFC4-4CAA-AA45-8E9BEFE31BFD",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0912714A-7D88-4775-8CC0-B75C40DDED88",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0931A992-31D7-46D5-A794-DD06B7BCEC6B",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0937DD3C-F637-465D-A7A3-EB5BF9258CFF",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0986AD13-CEC9-4D2E-BE7C-F0496A23B098",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "099C7E4D-A294-45B1-9043-AF80018B7425",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "09CE0196-EB93-46DF-A12D-A84FDC0338BE",
+      "text" : "Yes",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0A3B4947-C6CD-40C4-BAFA-CBA4EE2B323E",
+      "rect_position" : 10,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "23975A1A-0F52-45B8-8FE6-9FCD6FB98E37",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "AEBA5891-E068-406E-BDC4-31CAA91BC86C",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "A2CB37AE-2CF5-472C-A3B5-02B7572B0C41",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "3AC23F54-0CB8-4171-9989-32C14968C792",
+      "mps_bckg_color" : 4284374622,
+      "mps_border_color" : 4294966643,
+      "name" : "Dequeue a run",
+      "object_id" : "0A774E8A-8D9C-4AC0-802E-02A7B791DC49",
+      "origin" : "91,30",
+      "position_refs" : [
+        "A2CB37AE-2CF5-472C-A3B5-02B7572B0C41",
+        "41D7A155-524D-4075-AD53-835E66AC921E",
+        "EC920DF0-C4DC-4A1A-9616-C2727B098E43",
+        "F2DA4D10-715D-436C-80F2-BBF29898B919",
+        "FD9D4EB7-FDEB-44B6-B8BA-499210B14F47"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "color" : 4286086655,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0AA5C677-81D7-4605-96CA-4B25416C1A88",
+      "text" : "Redis Worker",
+      "type_id" : 27
+    },
+    {
+      "border_dash_enabled" : {
+        "o" : 1,
+        "p" : 1,
+        "u" : 1
+      },
+      "border_tixel_bl" : "+",
+      "border_tixel_br" : "+",
+      "border_tixel_bs" : "=",
+      "border_tixel_ls" : "|",
+      "border_tixel_rs" : "|",
+      "border_tixel_tl" : "+",
+      "border_tixel_tr" : "+",
+      "border_tixel_ts" : "=",
+      "border_tixels" : "F8783797-AD8A-481F-B4D9-A8F901624AA4",
+      "content_tixels" : "BF526605-3900-4AE2-9B80-D5313C040823",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "3C2241EC-0549-4D93-95C6-D4B9810E0767",
+      "frame_size" : "33,5",
+      "model_text" : "0AA5C677-81D7-4605-96CA-4B25416C1A88",
+      "mps_border_color" : 4286086655,
+      "name" : "Redis Worker",
+      "object_id" : "0AB3CCAA-A2AB-4E3B-A9C7-4A413516EF17",
+      "origin" : "7,19",
+      "position_refs" : [
+        "3C2241EC-0549-4D93-95C6-D4B9810E0767",
+        "8A825469-347A-488A-9429-8C6189F91BCA",
+        "58AA4066-2C42-4783-8A8B-2FAD7C629EA0",
+        "1FB49C89-D21A-4EEB-94F1-36F261625FD2",
+        "A46D17E6-5E7F-42D8-8CBA-D4C800C4E7E8"
+      ],
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "0AF1312A-C97F-45BD-947F-32E902EF9D25",
+      "position_ref" : "C7518EE9-4EB1-4392-8048-AA9C3D68BF67",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0B3443AE-5E87-40E9-B5E0-BE940EB8B36C",
+      "point" : "89,20",
+      "type_id" : 11
+    },
+    {
+      "border_tixels" : "7CF87AFB-C487-45EF-AC9C-9155B229961F",
+      "content_tixels" : "7C60E869-510F-4AF6-87E3-F60A5C1623A6",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "2C2E9944-7178-4CCC-AE2E-540E20F2FE4C",
+      "frame_size" : "33,5",
+      "model_text" : "E8030752-5278-47FF-B213-75C860FF1113",
+      "mps_border_color" : 4287822336,
+      "name" : "FINISHED",
+      "object_id" : "0B5DB076-D0BC-4D9B-85A3-C82E9EBBE136",
+      "origin" : "57,75",
+      "position_refs" : [
+        "2C2E9944-7178-4CCC-AE2E-540E20F2FE4C",
+        "565340C2-F7FE-49E9-9F78-C5971E706C13",
+        "7F8CD780-C9F2-4426-9937-878C1D90E9BE",
+        "257A838B-4C9A-44B7-9300-1D311354AAE5",
+        "DD41B632-4B22-41A4-8B7F-74CCF9C4F857",
+        "259F267C-1CC1-485A-82E6-981A1751AA4F",
+        "0912714A-7D88-4775-8CC0-B75C40DDED88",
+        "373B889E-1CE6-4687-9AD3-5B76045A3B2F"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0BED2F7C-D377-4C2F-8FA3-326680C0D951",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "0CE3B0B5-2ED3-4CD7-93A6-DA575E38B2B9",
+      "position_ref" : "257A838B-4C9A-44B7-9300-1D311354AAE5",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0CFB721B-5963-4847-8826-7E58915A4AC0",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0D05510C-E817-4E96-AC39-4C2930808C71",
+      "type_id" : 9
+    },
+    {
+      "border_tixels" : "9152D1F3-D96E-427F-8074-03B6F54C61D1",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "248AA5C6-B62B-4C03-B4F8-A3A42B265A27",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "14174E52-6798-423F-A788-30AFC81D3200",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "CA4E5E51-5D50-4D07-8E41-284583AD0750",
+      "mps_bckg_color" : 4284374622,
+      "mps_border_color" : 4294966643,
+      "name" : "Complete attempt",
+      "object_id" : "0D907E82-3DAA-4AAF-A9A5-86ECEF509537",
+      "origin" : "91,54",
+      "position_refs" : [
+        "14174E52-6798-423F-A788-30AFC81D3200",
+        "F49C6867-AF1B-48BE-B405-AD773508A1F4",
+        "8496EF2B-00B1-4F67-B98A-239F334E2F62",
+        "C3799A91-0903-4D15-A49B-D9DA7CEB04F9",
+        "1954748D-08EA-4782-82D4-2B4D81D6313E"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "C1A2CBF8-A868-424B-9C69-FE5327AB9C03",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 2",
+      "object_id" : "0E94D869-828D-4D47-8A32-13411F9AB5F9",
+      "origin" : "-40,12",
+      "position_refs" : [
+        "1979CFCF-3603-427B-86A8-C4B8F52C91B0",
+        "6330AF33-2CB7-4826-BA36-51F17A8D7620",
+        "35886DDE-96E8-4D0A-8AC6-ECF57BFDC280"
+      ],
+      "segment_end_refs" : [
+        "1979CFCF-3603-427B-86A8-C4B8F52C91B0",
+        "6330AF33-2CB7-4826-BA36-51F17A8D7620"
+      ],
+      "segment_refs" : [
+        "99F3C04E-73FB-4FA0-946A-4D80CDDB2EAF"
+      ],
+      "type_id" : 5
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.44827586206896552,
+      "object_id" : "0F1F0B56-28D1-40DA-AE63-F5F8380C3002",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "0FC22524-992E-4A27-B8AE-B254C8C665EA",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "10317F1D-EFE3-4963-AA33-E14C9AA470E4",
+      "position_ref" : "352C6968-FB85-4DAC-BA82-57378A7BB4A9",
+      "type_id" : 10
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.42857142857142855,
+      "object_id" : "109648C4-C44A-454C-8EBE-9AE442C760FA",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "10B4A4F8-BDA7-4399-9E0A-8F34CC8BE7B3",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "10E6858F-CFE8-4BA5-841B-D6054129577F",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "13119978-2754-4B35-BA99-41824CE7C40F",
+      "point" : "59,47",
+      "type_id" : 11
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "AE0A1A44-2926-4F59-BDF3-8D1BBE10A541",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 1 Copy 4",
+      "object_id" : "1341372C-7AB5-45C3-88DE-FFA35A25C707",
+      "origin" : "91,40",
+      "position_refs" : [
+        "A724A3A9-4323-4D8E-B76B-E2C958171957",
+        "87885581-C2A4-427B-BAF3-02974D59699B",
+        "AE3295F3-E261-4A5E-8F54-1D516FF96061",
+        "E6698869-9500-4AD0-BA05-813FC0CE876D"
+      ],
+      "segment_end_refs" : [
+        "A724A3A9-4323-4D8E-B76B-E2C958171957",
+        "87885581-C2A4-427B-BAF3-02974D59699B"
+      ],
+      "segment_refs" : [
+        "55E3449B-AB31-49B8-98B4-800E613DA95B"
+      ],
+      "type_id" : 5
+    },
+    {
+      "content_tixmap_ref" : "7AB06A62-6AC5-4DBC-A1E1-F3A92E0B9AEC",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_type" : 4,
+      "name" : "Line 6",
+      "object_id" : "135D1ED0-4BD8-4782-89DC-89F4798D07B1",
+      "origin" : "34,15",
+      "position_refs" : [
+        "95EFBE75-44E6-421A-B204-69332A046A53",
+        "CFD10BFD-59E6-4671-9F29-666F26892F0F",
+        "DF3F21FD-E308-48CA-B8EB-C49F9EFC372E",
+        "FA9EB949-3D30-4945-A249-8B9826E0EE93"
+      ],
+      "segment_end_refs" : [
+        "95EFBE75-44E6-421A-B204-69332A046A53",
+        "CFD10BFD-59E6-4671-9F29-666F26892F0F"
+      ],
+      "segment_refs" : [
+        "FE60719A-2605-42D7-AD2A-510BEE132435"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "14174E52-6798-423F-A788-30AFC81D3200",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "53907C3E-182A-41E6-9038-6EFE784F3CBE",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1",
+      "object_id" : "15A6F943-15C1-4C60-A052-5CC56DFE4630",
+      "origin" : "57,12",
+      "position_refs" : [
+        "872AD196-1857-49AC-BDF3-29CFB1C77E50",
+        "8ABEF1B1-ADE2-44B2-93A4-F023F1317A1B",
+        "21381E53-A444-4744-A9D9-9C1908AACCA0"
+      ],
+      "segment_end_refs" : [
+        "872AD196-1857-49AC-BDF3-29CFB1C77E50",
+        "8ABEF1B1-ADE2-44B2-93A4-F023F1317A1B"
+      ],
+      "segment_refs" : [
+        "364AD09D-80A9-4297-9CA5-8A5370152C52"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "16BFB865-AAEC-46F4-A2EF-8A37C11F8D8D",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1703EE8C-7017-4438-8904-2197CFE37FC4",
+      "point" : "45,18",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1755EE35-D2F5-4BB1-8F38-521CDCFD3B65",
+      "position_ref" : "27169B53-16AD-443E-957E-156F44EC84C8",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "17B499AD-1237-4699-B8BF-CD844AADBA1E",
+      "rect_position" : 17,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1954748D-08EA-4782-82D4-2B4D81D6313E",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1979CFCF-3603-427B-86A8-C4B8F52C91B0",
+      "position_ref" : "FEB0F91E-2CAE-4F20-BFF8-12C89B0DBA42",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1A1D76DE-F977-485C-B24F-A57751359FFE",
+      "type_id" : 18
+    },
+    {
+      "border_tixels" : "6280D9DF-09E9-4493-A182-9154DA63FDFC",
+      "content_tixels" : "3F3A504B-C3CA-46DE-BDB0-22DF35F0DCA0",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "5A9843EB-A96C-488B-B3B8-26777ADB2F9A",
+      "frame_size" : "33,5",
+      "model_text" : "5077238B-68D6-45C3-B2F6-4D178557A47D",
+      "mps_border_color" : 4286108927,
+      "name" : "EXECUTING_WITH_WAITPOINTS",
+      "object_id" : "1A250DE9-B89F-4A0E-A4F1-7DCD34390E88",
+      "origin" : "7,59",
+      "position_refs" : [
+        "5A9843EB-A96C-488B-B3B8-26777ADB2F9A",
+        "BB47437C-904E-4F3C-A152-F5F18AE81470",
+        "92669FB6-93F4-4498-98C0-97D74045E4F5",
+        "73A51679-81BE-4A08-B47D-9F53DD53A0C7",
+        "A431B440-7502-470D-A8BC-95395359D3FD",
+        "4BD475E0-CE48-4321-97B3-4DE5EE2A9F41",
+        "17B499AD-1237-4699-B8BF-CD844AADBA1E",
+        "280FEFB3-4B6E-496A-B1FD-C1EA8177F3FC"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1AA59300-95C1-4004-9817-6388A96D2A6C",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "1B0F2973-7D6D-4784-880A-5457A3E383F3",
+      "position_ref" : "4C6BE27A-0156-4FB1-9A9E-C4C9A09EF80B",
+      "type_id" : 10
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "1B5E0523-77FB-4FA4-A1C3-4EC4C58F1128",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1D90DC7A-9829-442C-BE91-955BB5B633E9",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1DFD320C-D36E-4CA4-AE31-7CBC6CE8591A",
+      "position_ref" : "DA22D7AA-5AC9-4A83-B7F3-7AA3D4810B26",
+      "type_id" : 10
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1F3FD34F-89DA-4D82-85AC-A256D89562F3",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1F4C43EE-41E2-42D5-AF90-ACA44B83919C",
+      "rect_position" : 14,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1F5E4B71-2CC5-4F92-9C17-2BC9C08342C7",
+      "point" : "109,47",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "1F6DC5EA-931F-4872-9518-CD05E8745F97",
+      "position_ref" : "5569620F-DC05-42BF-B631-4BF1DB356AF2",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1FAB2CC0-F161-406F-8E41-E3B7CD7A77DE",
+      "position_ref" : "50F9947D-8D42-4D5B-89BA-4E91811C9E60",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "1FB49C89-D21A-4EEB-94F1-36F261625FD2",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "E27C48FD-C2F1-4BFD-BCD9-40A194D14CED",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 5",
+      "object_id" : "201D6215-0684-4AEC-8C4C-7040CB431093",
+      "origin" : "54,36",
+      "position_refs" : [
+        "10317F1D-EFE3-4963-AA33-E14C9AA470E4",
+        "909BD60D-9DC6-4741-96EB-7328035DD54D",
+        "CBEC7845-3011-450D-A4C2-EDD6944CC894"
+      ],
+      "segment_end_refs" : [
+        "10317F1D-EFE3-4963-AA33-E14C9AA470E4",
+        "909BD60D-9DC6-4741-96EB-7328035DD54D"
+      ],
+      "segment_refs" : [
+        "EC386826-2B8F-4117-83FD-C07D588CC613"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "204D5BFC-12BA-4B4C-9048-7A0ECBE9DE61",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "20FFC03D-B351-4920-A318-AA6F0916F280",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "21381E53-A444-4744-A9D9-9C1908AACCA0",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "21D7DD73-6F32-4E2A-B161-72C581906A27",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "221C766F-6827-4404-8F24-F888990CB512",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "23975A1A-0F52-45B8-8FE6-9FCD6FB98E37",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "23BCC60B-5153-4D3A-A469-5CEA51985025",
+      "type_id" : 18
+    },
+    {
+      "color" : 4294966643,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "23EEA27C-D7EC-4B52-A13E-A008B73E79B7",
+      "text" : "Checkpoint created",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "24228F46-EDCB-43E9-A5DA-5BF09DB3A091",
+      "position_ref" : "221C766F-6827-4404-8F24-F888990CB512",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "244E9055-B419-4A91-B86E-4EB9DBF5600B",
+      "rect_position" : 10,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "248AA5C6-B62B-4C03-B4F8-A3A42B265A27",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "256D0788-25DD-45B1-BC3E-F256911EEC56",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "25719DB7-FE53-4EB7-9896-1E08DB5A1C51",
+      "position_ref" : "3F827B0A-FD14-422E-8B7C-1C25BCCB4FC2",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "257A838B-4C9A-44B7-9300-1D311354AAE5",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "259F267C-1CC1-485A-82E6-981A1751AA4F",
+      "rect_position" : 10,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "25AD3E71-2F2B-4E47-B489-FB7E065303DC",
+      "point" : "58,27",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "25C62047-A2DB-4898-9FC1-131D25CC4565",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "25F1A022-8F9F-4248-8DF6-D47F36E20521",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "261945C0-8A87-413B-835D-CD23A28E1A77",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "26360FE9-3676-4EBB-A6FD-ECA0FFE2A306",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "26D85C63-885C-4639-B67A-402315003377",
+      "type_id" : 18
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "E9A668B9-4912-428A-A6A1-9760CBDB8318",
+      "content_tixels" : "5463FA31-57C3-48D9-AB58-0BE2DB11C6CD",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "6C94511F-BBD2-41D6-A9A9-2F9D633D69B0",
+      "frame_corner" : 5,
+      "frame_size" : "10,3",
+      "model_text" : "A668AA0B-E8B2-45F8-9E16-9B906D39732F",
+      "name" : "All Waitpoints complete?",
+      "object_id" : "2706D57E-4869-4D0F-9435-640B05BDA51B",
+      "origin" : "34,27",
+      "position_refs" : [
+        "6C94511F-BBD2-41D6-A9A9-2F9D633D69B0",
+        "38E33C5B-6FD5-492F-9F8B-7A56D55130D1"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "27169B53-16AD-443E-957E-156F44EC84C8",
+      "point" : "79,39",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "27F3BD5A-220C-436D-8CDC-F91D34219EAA",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "280FEFB3-4B6E-496A-B1FD-C1EA8177F3FC",
+      "rect_position" : 20,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "3B791DDB-15E3-495A-9CB1-68E2BBEF56F2",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 1 Copy 3",
+      "object_id" : "2AC63D46-DD1A-4DC9-B241-A49951E95668",
+      "origin" : "73,59",
+      "position_refs" : [
+        "95DD2A83-6B63-4836-B6A8-7CCE590DD659",
+        "FE605DB0-B757-4D29-8D13-946FB7988215",
+        "109648C4-C44A-454C-8EBE-9AE442C760FA"
+      ],
+      "segment_end_refs" : [
+        "95DD2A83-6B63-4836-B6A8-7CCE590DD659",
+        "FE605DB0-B757-4D29-8D13-946FB7988215"
+      ],
+      "segment_refs" : [
+        "A205BDF9-9645-4343-9F64-C1249A9FA908"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2B1919EA-4BD8-4664-BB63-20792FDB1AB2",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "2B9D7887-B7F4-44B6-83CC-99CBE6818B40",
+      "position_ref" : "7F8CD780-C9F2-4426-9937-878C1D90E9BE",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2C0C3256-11DD-4782-8692-5D0C61DD3D41",
+      "rect_position" : 21,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2C2E9944-7178-4CCC-AE2E-540E20F2FE4C",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2C3DA79C-B51F-4F9E-A32F-8BF89879D523",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2CB932D2-E47D-4244-A0C4-DEE104788514",
+      "point" : "12,48",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2DA31E79-974F-47F4-812F-90011A16AC86",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2EB68039-3964-4231-A1C1-A6A7E1BEFBD5",
+      "rect_position" : 18,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "2F442885-C9B5-48CC-9F3A-E75BD5263973",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "26D85C63-885C-4639-B67A-402315003377",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 4",
+      "object_id" : "2F84C981-06FE-46F6-9E89-6581317BD8DD",
+      "origin" : "57,13",
+      "position_refs" : [
+        "1DFD320C-D36E-4CA4-AE31-7CBC6CE8591A",
+        "B6ED9A50-BAF5-40A4-AD34-87CB6E77C42C"
+      ],
+      "segment_end_refs" : [
+        "1DFD320C-D36E-4CA4-AE31-7CBC6CE8591A",
+        "B6ED9A50-BAF5-40A4-AD34-87CB6E77C42C"
+      ],
+      "segment_refs" : [
+        "6643DEDF-9E29-4103-AAEB-DF1B4EF54AFC"
+      ],
+      "type_id" : 5
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3035BDFB-2CA3-4B80-BDD3-ACF178DC341E",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3044F349-71EB-4B40-B128-5705AC84A520",
+      "point" : "94,20",
+      "type_id" : 11
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "304B40BD-1964-4735-9B89-2D18551338FA",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "305B8CE7-3FE8-4141-8F6B-0ED78C538551",
+      "rect_position" : 17,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "30C6C4C1-AA58-4E23-8688-CF1723EC06E3",
+      "type_id" : 9
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "311B638D-020F-4F69-B5D5-C2D627BA57E8",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3217DA12-0116-48B4-9C20-1B2AE32C7EFC",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "329D9A77-7F34-4103-8145-83F58DE29D84",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "3394CDC0-F69B-422C-A397-04745F267F38",
+      "position_ref" : "46A8612F-9699-4139-9D53-6FA85BC7923B",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "34030465-3432-4DBB-8321-A1CEBF230847",
+      "point" : "83,25",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "344BFBF5-00F0-42D6-B6E5-60E78D768136",
+      "type_id" : 18
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "54BC1053-69E5-4E8D-8140-4387CA2D9F04",
+      "content_color" : 4292203989,
+      "content_tixels" : "07B1BB83-FFC4-4CAA-AA45-8E9BEFE31BFD",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "8CBABF6D-723A-47AB-A073-9CE6EC45BF0B",
+      "frame_corner" : 5,
+      "frame_size" : "25,3",
+      "model_text" : "43680066-286B-41AE-9FAE-D5E311FFA4DE",
+      "name" : "Pulled from the queue",
+      "object_id" : "344EA014-CF97-4607-AAF7-45F152715D8C",
+      "origin" : "34,30",
+      "position_refs" : [
+        "8CBABF6D-723A-47AB-A073-9CE6EC45BF0B"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "352C6968-FB85-4DAC-BA82-57378A7BB4A9",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "alignment" : 2,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3542B8A1-5168-4496-97F5-A123A4D093A6",
+      "position" : 0,
+      "text" : "Run maybe executing",
+      "type_id" : 27
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.46666666666666667,
+      "object_id" : "35886DDE-96E8-4D0A-8AC6-ECF57BFDC280",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3605858D-8F35-496F-8077-FF6BD22B6EC5",
+      "type_id" : 18
+    },
+    {
+      "border_tixels" : "BF480007-B41F-44D5-9729-349D757A1F2A",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "20FFC03D-B351-4920-A318-AA6F0916F280",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "619EB124-313C-442B-BB59-EA0C2031CB0C",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "23EEA27C-D7EC-4B52-A13E-A008B73E79B7",
+      "mps_bckg_color" : 4284374622,
+      "mps_border_color" : 4294966643,
+      "name" : "Checkpoint created",
+      "object_id" : "362A661B-200C-475C-A811-ED89E5D48A03",
+      "origin" : "-64,34",
+      "position_refs" : [
+        "619EB124-313C-442B-BB59-EA0C2031CB0C",
+        "B5CDDB1E-E3F5-4484-B4E5-C1976F44F786",
+        "5FD3E4F7-08BC-4DC6-AED0-9FA5FB2E692F",
+        "99FB47C5-E697-4E70-B378-D01571CE56B1",
+        "69716B22-4ECD-450F-81F3-8A9ACFCB4879"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "364AD09D-80A9-4297-9CA5-8A5370152C52",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "36EF01C9-5E4E-48A5-93A8-4D7691F9E114",
+      "point" : "91,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "373B889E-1CE6-4687-9AD3-5B76045A3B2F",
+      "rect_position" : 21,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "9090A07E-15C7-49E5-AFCE-DC8830136245",
+      "content_color" : 4292203989,
+      "content_offset" : "-6,0",
+      "content_tixels" : "256D0788-25DD-45B1-BC3E-F256911EEC56",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "928889EA-ABCA-45D1-AC83-5F78B9680844",
+      "frame_corner" : 5,
+      "frame_size" : "17,2",
+      "model_text" : "AB436F11-971E-495D-94CE-C3090551A158",
+      "name" : "Attempt failure",
+      "object_id" : "37818C91-943F-48C6-AAD1-CBFB482824B4",
+      "origin" : "49,55",
+      "position_refs" : [
+        "928889EA-ABCA-45D1-AC83-5F78B9680844",
+        "10E6858F-CFE8-4BA5-841B-D6054129577F",
+        "AC0AAB7F-0AB8-40F4-B6CE-BD1862AB5368",
+        "F90D0FC8-7097-4E44-9390-88F245E10DD2",
+        "DC0B59E7-D472-4B35-A7A7-BB0A653024B1",
+        "16BFB865-AAEC-46F4-A2EF-8A37C11F8D8D"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "380CD52E-2F7E-462C-9782-C5331B6DE34E",
+      "position_ref" : "FCBA08D5-02A0-4C7A-875C-411E678AFC67",
+      "type_id" : 10
+    },
+    {
+      "color" : 4294966643,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "38602516-CD0B-49ED-ABEC-7E171055BDA7",
+      "text" : "wait() \/ triggerAndWait()",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "38E33C5B-6FD5-492F-9F8B-7A56D55130D1",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "39884B41-B18D-400B-AB1D-B1DA27875821",
+      "text" : "Yes",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3A6E71C3-7B1F-4565-8301-ABED78994930",
+      "rect_position" : 21,
+      "type_id" : 12
+    },
+    {
+      "color" : 4294966643,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3AC23F54-0CB8-4171-9989-32C14968C792",
+      "text" : "Dequeue a run",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3B214FFD-0519-4963-A550-41DEDBB096B7",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3B4EE80E-AEF6-4651-A5E8-AD1FA2F90FFE",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3B791DDB-15E3-495A-9CB1-68E2BBEF56F2",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3C2241EC-0549-4D93-95C6-D4B9810E0767",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "border_tixels" : "D0E26C00-EF01-4B95-97C4-208DC50082DD",
+      "content_color" : 4294967294,
+      "content_offset" : "-3,1",
+      "content_tixels" : "DD31B6F5-1FCF-4BB5-90A7-32AA18684463",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "C3856D18-BCFF-4D54-8C1E-84585785DEA6",
+      "frame_size" : "42,5",
+      "model_text" : "C73B83AE-3AC7-49E5-990F-65275E30FC7E",
+      "mps_border_color" : 4294935511,
+      "name" : "Run Engine",
+      "object_id" : "3C3443D6-F420-46C0-9477-59441B077CD1",
+      "origin" : "-18,7",
+      "position_refs" : [
+        "C3856D18-BCFF-4D54-8C1E-84585785DEA6",
+        "25F1A022-8F9F-4248-8DF6-D47F36E20521",
+        "E83D0E5B-ABF5-4997-8441-C237E0139DB5",
+        "A7C0832E-4D00-4E67-A168-404E7A387CF0",
+        "C848A73B-70E5-429E-B08E-A1CB03DCB736"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3D10EA2D-D500-4A7B-A4CD-13EC6973FDEC",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3D23FB3D-4B98-4BD8-BB43-52E623DEC4E0",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3D3A9815-C924-4D0B-A24A-46E8D48A2302",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3F3A504B-C3CA-46DE-BDB0-22DF35F0DCA0",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "3F827B0A-FD14-422E-8B7C-1C25BCCB4FC2",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "81458BD7-79B8-48F4-A20A-4A0ECE3C752E",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "A2A58C37-05A3-42D6-BD7F-5912147A0272",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "E17F14D4-3AD5-45F2-8E0D-33952AF566C0",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "C5144DEB-F58A-4BE8-B122-086661650F25",
+      "mps_bckg_color" : 4284374622,
+      "mps_border_color" : 4294966643,
+      "name" : "Start attempt",
+      "object_id" : "40BB3E01-00FF-419F-9222-77583706372D",
+      "origin" : "91,40",
+      "position_refs" : [
+        "E17F14D4-3AD5-45F2-8E0D-33952AF566C0",
+        "5D3F0948-5344-4030-BA7D-4EF474B0B466",
+        "A761DC9F-C050-4277-942F-4354BC0DD88C",
+        "06FBACF1-15F7-4630-B120-105FDB8C34B9",
+        "5F860F88-855F-4815-9652-A3C066725F84"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "40E09C54-8E39-4370-BB48-F7545A04A315",
+      "position_ref" : "D80AB812-A827-457D-82E7-6637E6849740",
+      "type_id" : 10
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "DF9B03F8-1242-4722-94D3-F214F2DA372E",
+      "content_color" : 4292203989,
+      "content_offset" : "-2,0",
+      "content_tixels" : "8B490612-1671-4F58-9712-8D93D5E36D2F",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "36EF01C9-5E4E-48A5-93A8-4D7691F9E114",
+      "frame_corner" : 5,
+      "frame_size" : "13,3",
+      "model_text" : "B0F57680-86BA-475D-B32C-14FFA920B308",
+      "name" : "All retries used",
+      "object_id" : "414FF17D-0426-4DA3-B7DB-DF2732E1CF45",
+      "origin" : "57,62",
+      "position_refs" : [
+        "36EF01C9-5E4E-48A5-93A8-4D7691F9E114",
+        "68869AC9-1B25-411F-9293-720F4C49024D"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "41D7A155-524D-4075-AD53-835E66AC921E",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "1D90DC7A-9829-442C-BE91-955BB5B633E9",
+      "content_color" : 4292203989,
+      "content_tixels" : "D77D187A-4765-4760-A074-7C36F7B4F8B5",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "0B3443AE-5E87-40E9-B5E0-BE940EB8B36C",
+      "frame_corner" : 5,
+      "frame_size" : "29,3",
+      "model_text" : "DDF3DF13-4E44-443D-AD0C-07A2A5163F16",
+      "name" : "All Waitpoints complete?",
+      "object_id" : "41E35C8F-8EF4-4A0B-AADB-7433C7BEA8F0",
+      "origin" : "1,16",
+      "position_refs" : [
+        "0B3443AE-5E87-40E9-B5E0-BE940EB8B36C"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4226E36E-88ED-440F-912E-D6EFF6A30E84",
+      "point" : "59,47",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "428932DF-AAC3-4979-937E-B3C5B2C96DC2",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.45454545454545453,
+      "object_id" : "434C5097-DE3B-4817-8A7C-9D2F57D557C6",
+      "type_id" : 24
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "A44857A0-CE2B-4695-B1D0-AA35DA2574B2",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 3",
+      "object_id" : "4354ED16-27CF-4F09-8599-9412822ABA82",
+      "origin" : "22,79",
+      "position_refs" : [
+        "E966926D-1590-4E8F-BA71-624870F049D2",
+        "8D1CCE89-F11C-45C2-8F21-2EF1608CD931",
+        "C63D4669-A41E-41C6-8F0B-548A884E2644"
+      ],
+      "segment_end_refs" : [
+        "E966926D-1590-4E8F-BA71-624870F049D2",
+        "8D1CCE89-F11C-45C2-8F21-2EF1608CD931"
+      ],
+      "segment_refs" : [
+        "EF909D44-C625-4EFB-B134-15ACE3B8C913"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "435E6772-339C-4CCA-A0A8-D63A3E340B69",
+      "type_id" : 18
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "43680066-286B-41AE-9FAE-D5E311FFA4DE",
+      "text" : "Pulled from the queue",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "454BF47B-AEE8-4038-BA47-F54B504F6A6D",
+      "position_ref" : "4BD475E0-CE48-4321-97B3-4DE5EE2A9F41",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "46A8612F-9699-4139-9D53-6FA85BC7923B",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "46D554EE-3055-4B78-A86B-EA8F1D08EC69",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4294966643,
+      "content_tixmap_ref" : "B44ACC14-D84A-44F8-860F-1F5DC08A43EB",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "473C75A8-75E0-4017-9808-CABA7473A740",
+      "origin" : "-2,52",
+      "position_refs" : [
+        "C23606D9-99F1-4384-B2B3-51B3CE4A8FC2",
+        "76C821D1-CC7B-46C8-8C10-F8AF1F15C5ED",
+        "C62D5AB7-CCDB-4ADB-9511-2A2C1D4FFB9D",
+        "EF82D23F-D757-400A-8159-76DC891503F5"
+      ],
+      "segment_end_refs" : [
+        "C23606D9-99F1-4384-B2B3-51B3CE4A8FC2",
+        "76C821D1-CC7B-46C8-8C10-F8AF1F15C5ED"
+      ],
+      "segment_refs" : [
+        "64AA4D50-98DA-4E78-927D-BDB1EC324D9A"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "47C3538C-B57E-4235-BF94-B8B04B3572F7",
+      "position_ref" : "FD5F4C49-5268-4584-AB9C-EC60DE5F21DE",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "48AAC497-7877-4CB7-BDDA-719C8EEF8C03",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "49830C9A-0A41-4265-B153-5B20304FB8C7",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4AABA440-35D4-481C-8630-4E4E2491917B",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4BD475E0-CE48-4321-97B3-4DE5EE2A9F41",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4C6BE27A-0156-4FB1-9A9E-C4C9A09EF80B",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "8E224A02-EB39-46A1-AD9A-0445387F71BE",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 3",
+      "object_id" : "4CE9B747-B939-4DC3-9A2B-44A4BB419BDB",
+      "origin" : "44,39",
+      "position_refs" : [
+        "1755EE35-D2F5-4BB1-8F38-521CDCFD3B65",
+        "8E55D93E-A435-4DF5-9C8E-187643A58C6D",
+        "304B40BD-1964-4735-9B89-2D18551338FA",
+        "27169B53-16AD-443E-957E-156F44EC84C8",
+        "68B0397E-E294-423E-ABF0-014F8ED74865"
+      ],
+      "segment_end_refs" : [
+        "1755EE35-D2F5-4BB1-8F38-521CDCFD3B65",
+        "8E55D93E-A435-4DF5-9C8E-187643A58C6D"
+      ],
+      "segment_refs" : [
+        "B1BEE084-F681-4686-9C36-A2BDDB40DD05"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4D0DC480-C606-44F0-AC1C-38E9A9AA86C5",
+      "position_ref" : "CF6C6D62-FEFF-4B4D-8D48-9B5D1DF5B851",
+      "type_id" : 10
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4D6588F0-F19E-46EF-87F0-FB032DB0490D",
+      "text" : "Slow retry",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4D71F51C-34CA-4F11-A62D-46E6305200E0",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "4FD5F62E-202D-4A49-A79E-31388F738E03",
+      "type_id" : 9
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5077238B-68D6-45C3-B2F6-4D178557A47D",
+      "text" : "EXECUTING_WITH_WAITPOINTS",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "50F9947D-8D42-4D5B-89BA-4E91811C9E60",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "FBBAD83B-0F19-4E4B-A408-AAA16493114E",
+      "content_offset" : "6,0",
+      "content_tixels" : "49830C9A-0A41-4265-B153-5B20304FB8C7",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "4226E36E-88ED-440F-912E-D6EFF6A30E84",
+      "frame_corner" : 5,
+      "frame_size" : "17,1",
+      "model_text" : "7B07E38B-58B2-4196-A66E-9F6BC8A86DE5",
+      "name" : "Is executing?",
+      "object_id" : "530C12A4-8948-40B1-B284-FB3387C9314B",
+      "origin" : "14,38",
+      "position_refs" : [
+        "4226E36E-88ED-440F-912E-D6EFF6A30E84",
+        "4C6BE27A-0156-4FB1-9A9E-C4C9A09EF80B",
+        "A45FDBBD-3875-4100-8357-D9B576A0ED05",
+        "50F9947D-8D42-4D5B-89BA-4E91811C9E60"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "53907C3E-182A-41E6-9038-6EFE784F3CBE",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "53DE2297-1868-46F5-9B1F-799A1B6AED59",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5463FA31-57C3-48D9-AB58-0BE2DB11C6CD",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "54BC1053-69E5-4E8D-8140-4387CA2D9F04",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5569620F-DC05-42BF-B631-4BF1DB356AF2",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "55E3449B-AB31-49B8-98B4-800E613DA95B",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "564E7239-A7F7-4155-8904-1F4BFB40C85A",
+      "position_ref" : "972CFDA3-A7A2-43EF-8DAC-0884DE8E3BEF",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "565340C2-F7FE-49E9-9F78-C5971E706C13",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "56D3103C-F681-43F4-8BC6-2F47EA6E1E92",
+      "position_ref" : "FD7FC36A-7576-4AC4-9621-D73179475822",
+      "type_id" : 10
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.3888888888888889,
+      "object_id" : "57EDF807-5283-4EF6-B81F-6A4278EC39E2",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "584699E8-33C4-40B0-AC1F-993AFEB14756",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "58AA4066-2C42-4783-8A8B-2FAD7C629EA0",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5A9843EB-A96C-488B-B3B8-26777ADB2F9A",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5A9D3C1C-D2CA-48C4-BB90-91A9C04F94E4",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "A363B846-62E9-4100-9E31-197F518B6B3A",
+      "content_color" : 4292203989,
+      "content_offset" : "1,0",
+      "content_tixels" : "3D3A9815-C924-4D0B-A24A-46E8D48A2302",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "74379CCF-7A21-4A4D-8725-D4B2D7655AF8",
+      "frame_corner" : 5,
+      "frame_size" : "11,1",
+      "model_text" : "4D6588F0-F19E-46EF-87F0-FB032DB0490D",
+      "name" : "Slow retry",
+      "object_id" : "5D302402-269D-478D-957A-F48E581D77BA",
+      "origin" : "65,20",
+      "position_refs" : [
+        "74379CCF-7A21-4A4D-8725-D4B2D7655AF8",
+        "584699E8-33C4-40B0-AC1F-993AFEB14756"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5D3F0948-5344-4030-BA7D-4EF474B0B466",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5D660488-252F-4EED-AD84-EDFC694FED41",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5DA6EC85-9D1B-45A1-AD8A-C9162853778A",
+      "position_ref" : "61CD1957-4BB5-4544-B7FE-9F87B1E93F88",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5DF01E86-C7CF-4857-B910-468BB874E123",
+      "point" : "89,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5DFF05AF-C833-4495-9A7C-02202901F8AC",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5E8F0012-51A8-4118-AEB1-A56C5C27105F",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5F6200FF-54CA-4A5B-8D76-461CF883FC25",
+      "point" : "29,32",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5F860F88-855F-4815-9652-A3C066725F84",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5FBDAD4E-3F81-435E-AAFF-4ED0DB0F4EA7",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5FCF3E5F-18B2-40F8-AB26-F35E4CD66ECF",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5FD3E4F7-08BC-4DC6-AED0-9FA5FB2E692F",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "5FD7D587-D4D5-4085-91C3-ECCCF00047C8",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "622FEB41-BAD7-4D21-82BE-B15C55A70D3A",
+      "content_color" : 4292203989,
+      "content_offset" : "4,0",
+      "content_tixels" : "99499F57-22A0-4899-996D-C3D4032927E7",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "A09866AB-D356-4C87-82C3-FDD9F8327867",
+      "frame_corner" : 5,
+      "frame_size" : "6,1",
+      "model_text" : "39884B41-B18D-400B-AB1D-B1DA27875821",
+      "name" : "Yes",
+      "object_id" : "61189AF3-7EBD-4409-B034-1EB1D963B0A4",
+      "origin" : "-42,3",
+      "position_refs" : [
+        "A09866AB-D356-4C87-82C3-FDD9F8327867"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "border_tixels" : "FCEA7123-2AD0-4563-936A-3DFB06F5739E",
+      "content_tixels" : "3D23FB3D-4B98-4BD8-BB43-52E623DEC4E0",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "F4E29C50-845C-42DB-B3B9-BBBC44B76C50",
+      "frame_size" : "33,5",
+      "model_text" : "040CE454-0AF5-47F9-958E-EA2274961F46",
+      "mps_border_color" : 4286108927,
+      "name" : "PENDING_CANCEL",
+      "object_id" : "611CA29C-CB6F-4426-8E83-EDA1F2A29DA7",
+      "origin" : "7,82",
+      "position_refs" : [
+        "F4E29C50-845C-42DB-B3B9-BBBC44B76C50",
+        "FC8D371A-D317-4A4D-B6E3-1A56DA60B5FC",
+        "10B4A4F8-BDA7-4399-9E0A-8F34CC8BE7B3",
+        "84587447-C1DE-46AF-BBC2-002E84B57097",
+        "4AABA440-35D4-481C-8630-4E4E2491917B",
+        "A3980A6D-41A3-460E-9892-29B942165B24",
+        "FA43E6F4-ADDF-4C02-BA79-CFF11F275A55",
+        "3A6E71C3-7B1F-4565-8301-ABED78994930"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "61922A36-E1E3-4115-9F4F-8DE0B77F1C40",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "619EB124-313C-442B-BB59-EA0C2031CB0C",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "61CD1957-4BB5-4544-B7FE-9F87B1E93F88",
+      "point" : "113,55",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "622FEB41-BAD7-4D21-82BE-B15C55A70D3A",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6280D9DF-09E9-4493-A182-9154DA63FDFC",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "6330AF33-2CB7-4826-BA36-51F17A8D7620",
+      "position_ref" : "04F3FEDE-59A5-4FEE-807A-008FD3C1FC5D",
+      "type_id" : 10
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "63A9C839-D66F-4E88-81DA-20AEB1ACD766",
+      "type_id" : 24
+    },
+    {
+      "border_tixels" : "9DA030E2-2F87-4159-BBFD-159577B58427",
+      "content_color" : 4292203989,
+      "content_tixels" : "21D7DD73-6F32-4E2A-B161-72C581906A27",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "5DF01E86-C7CF-4857-B910-468BB874E123",
+      "frame_corner" : 5,
+      "frame_size" : "25,1",
+      "model_text" : "DBCC428F-EC2B-485C-AC4F-33A0AAAC7B33",
+      "name" : "Is executing on worker",
+      "object_id" : "6420C140-0D72-41BF-BC3B-B8A83EA07F2A",
+      "origin" : "34,43",
+      "position_refs" : [
+        "5DF01E86-C7CF-4857-B910-468BB874E123",
+        "EEC56D34-7624-4EE6-AE15-8A93446EBECF",
+        "972CFDA3-A7A2-43EF-8DAC-0884DE8E3BEF",
+        "3F827B0A-FD14-422E-8B7C-1C25BCCB4FC2"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "64AA4D50-98DA-4E78-927D-BDB1EC324D9A",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "65F1C1D4-2133-49B1-AA3A-727534E35274",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6643DEDF-9E29-4103-AAEB-DF1B4EF54AFC",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "664900DA-7DA3-4D0F-BD1E-F8D4EEF5AA4B",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "668C32C8-7B94-4C4E-A6A0-F6DCA9F47529",
+      "point" : "89,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "669EBDF1-424A-459B-8335-FA6614A97A77",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "67641920-F3F8-4282-96C4-4B24CD37E6E0",
+      "position_ref" : "7DF924CD-5DD9-473A-8F55-FA9BBE1227FA",
+      "type_id" : 10
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "6779896C-8DA8-41B0-A429-A57A660C5DEE",
+      "type_id" : 24
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "67CCABA8-CA30-416A-9CEF-56144939D2D1",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "68869AC9-1B25-411F-9293-720F4C49024D",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "68B0397E-E294-423E-ABF0-014F8ED74865",
+      "point" : "95,39",
+      "type_id" : 11
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "69129880-7542-4DA6-BF2D-7D6C55A6F4F0",
+      "text" : "Run triggered",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "69716B22-4ECD-450F-81F3-8A9ACFCB4879",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "03380185-52CB-42AA-B140-6CCBCABF197C",
+      "content_color" : 4292203989,
+      "content_offset" : "-5,0",
+      "content_tixels" : "D4CB1CA9-2C22-4D92-93E1-2A062667CCB7",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "3044F349-71EB-4B40-B128-5705AC84A520",
+      "frame_corner" : 5,
+      "frame_size" : "17,1",
+      "model_text" : "C8127403-66E4-473F-8CBF-1766F526C1CF",
+      "name" : "Attempt success",
+      "object_id" : "697CE8E2-9A99-460C-BF9C-7D70417E9E15",
+      "origin" : "29,60",
+      "position_refs" : [
+        "3044F349-71EB-4B40-B128-5705AC84A520"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "border_tixels" : "9AF5726A-C355-425D-900C-83C2BB5450E1",
+      "content_tixels" : "CC9543C6-05FB-46B1-BAD9-1F4650631AB8",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "F465F56F-4975-4EC7-8A2C-8E21EC58B6CA",
+      "frame_size" : "33,5",
+      "model_text" : "F276D10C-284E-4470-B119-77C7BD94CCC9",
+      "mps_border_color" : 4286108927,
+      "name" : "DELAYED",
+      "object_id" : "6985CD55-3C7E-48D0-B327-55AF77FF6365",
+      "origin" : "7,12",
+      "position_refs" : [
+        "F465F56F-4975-4EC7-8A2C-8E21EC58B6CA",
+        "D80AB812-A827-457D-82E7-6637E6849740",
+        "65F1C1D4-2133-49B1-AA3A-727534E35274",
+        "04F3FEDE-59A5-4FEE-807A-008FD3C1FC5D",
+        "84E52FAC-959F-40F0-B5EE-1328154051FE"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "6AE066AF-D8A8-4970-BAE7-5C20581E325F",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6B3BDA63-0CA3-4788-88D8-188AA36DF511",
+      "type_id" : 18
+    },
+    {
+      "border_tixels" : "3217DA12-0116-48B4-9C20-1B2AE32C7EFC",
+      "content_color" : 4292203989,
+      "content_tixels" : "D22327ED-CDEC-4EB4-8BBD-E826C6E88B50",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "83B1F409-B54A-4AC5-A9D2-30CFFCB97CFC",
+      "frame_corner" : 5,
+      "frame_size" : "4,3",
+      "model_text" : "6FC78A61-A5BB-4EB7-B5EB-CF972A313724",
+      "name" : "No",
+      "object_id" : "6C0F5656-8B93-427F-8E7C-CFE6AA67080A",
+      "origin" : "6,65",
+      "position_refs" : [
+        "83B1F409-B54A-4AC5-A9D2-30CFFCB97CFC"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.46666666666666667,
+      "object_id" : "6C1DC524-2544-4BDA-B2E1-79FFC8DA65B8",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6C94511F-BBD2-41D6-A9A9-2F9D633D69B0",
+      "point" : "65,47",
+      "type_id" : 11
+    },
+    {
+      "content_tixmap_ref" : "7CB16153-65D3-4CEC-9948-A2FD45AB1C04",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 6",
+      "object_id" : "6CF46792-BF7B-4795-9F80-A2BCEE750065",
+      "origin" : "39,12",
+      "position_refs" : [
+        "EF81545C-6F7F-403D-B5F7-3D7D44F4BE0A",
+        "F40CBAB0-BE5D-413E-9DBD-5A6F83201311",
+        "E94E855B-4E74-4A48-A974-E50A6B2FD50B"
+      ],
+      "segment_end_refs" : [
+        "EF81545C-6F7F-403D-B5F7-3D7D44F4BE0A",
+        "F40CBAB0-BE5D-413E-9DBD-5A6F83201311"
+      ],
+      "segment_refs" : [
+        "30C6C4C1-AA58-4E23-8688-CF1723EC06E3"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6D56CBBC-140B-456B-B68F-A0474C4C34FA",
+      "point" : "19,0",
+      "type_id" : 11
+    },
+    {
+      "border_tixels" : "EE44FBCF-D451-4CA3-A777-863286A87D69",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "D097D2A4-697D-4DDE-A627-19E732421418",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "9759D941-079D-4ABB-9D57-54D56F0EE120",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "38602516-CD0B-49ED-ABEC-7E171055BDA7",
+      "mps_bckg_color" : 4284374622,
+      "mps_border_color" : 4294966643,
+      "name" : "wait() \/ triggerAndWait()",
+      "object_id" : "6DDFA6AA-8E6C-4740-AA17-290DB9AF20DF",
+      "origin" : "-64,41",
+      "position_refs" : [
+        "9759D941-079D-4ABB-9D57-54D56F0EE120",
+        "5FCF3E5F-18B2-40F8-AB26-F35E4CD66ECF",
+        "FDFCEAA1-416B-45CB-843B-B151C3E5625D",
+        "46D554EE-3055-4B78-A86B-EA8F1D08EC69",
+        "8A64C46F-5F4B-4DD3-8268-91060BC63149"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6EEE60B9-5715-4D52-A8F2-17C1F6259786",
+      "position_ref" : "1703EE8C-7017-4438-8904-2197CFE37FC4",
+      "type_id" : 10
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6F28153C-738C-4E97-A288-6A7970805267",
+      "text" : "No delay\/debounce",
+      "type_id" : 27
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "6FC78A61-A5BB-4EB7-B5EB-CF972A313724",
+      "text" : "No",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "70969C04-2A41-4680-AF6A-5DAD091E4A72",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "70E2C023-CA31-48CA-942A-85D8E4368E5A",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "71AD836E-CAA6-46B7-A079-171D3592E08E",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "7302DF42-5479-470D-BE9E-783A02D84ED8",
+      "position_ref" : "5FD7D587-D4D5-4085-91C3-ECCCF00047C8",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "73A51679-81BE-4A08-B47D-9F53DD53A0C7",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "AC04F11E-AE03-402A-A8A2-D8FB0956EC82",
+      "content_color" : 4292203989,
+      "content_offset" : "-2,0",
+      "content_tixels" : "2DA31E79-974F-47F4-812F-90011A16AC86",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "B4E894F3-FB8D-4CF3-AD1F-46E7E0A00B21",
+      "frame_corner" : 5,
+      "frame_size" : "17,3",
+      "model_text" : "07A56291-A68A-45F3-9B19-534E79914414",
+      "name" : "Quick retry",
+      "object_id" : "73BFB879-6953-4ED1-8D8C-94C3E41CEFFC",
+      "origin" : "55,44",
+      "position_refs" : [
+        "B4E894F3-FB8D-4CF3-AD1F-46E7E0A00B21",
+        "5FBDAD4E-3F81-435E-AAFF-4ED0DB0F4EA7"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "74379CCF-7A21-4A4D-8725-D4B2D7655AF8",
+      "point" : "88,20",
+      "type_id" : 11
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "743943E8-A2D9-4599-B4A3-8B26831DA02B",
+      "type_id" : 24
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "760098EF-14E3-41AF-83C4-2C03D454A870",
+      "text" : "After delay",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "76C821D1-CC7B-46C8-8C10-F8AF1F15C5ED",
+      "position_ref" : "EF82D23F-D757-400A-8159-76DC891503F5",
+      "type_id" : 10
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "204D5BFC-12BA-4B4C-9048-7A0ECBE9DE61",
+      "content_offset" : "5,-1",
+      "content_tixels" : "6B3BDA63-0CA3-4788-88D8-188AA36DF511",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "5F6200FF-54CA-4A5B-8D76-461CF883FC25",
+      "frame_size" : "21,4",
+      "model_text" : "8C1ADB6F-F687-43C8-AE38-4742E07E9B6C",
+      "name" : "Run not executing",
+      "object_id" : "77197D52-5E97-4413-8E34-9C1E8B5E792F",
+      "origin" : "-3,9",
+      "position_refs" : [
+        "5F6200FF-54CA-4A5B-8D76-461CF883FC25",
+        "5DFF05AF-C833-4495-9A7C-02202901F8AC",
+        "C5DED5F9-31C8-49C6-8E5A-376B7698DA2A",
+        "DBF48E76-9A6D-40B8-8897-CDF9F9837132",
+        "D1D7FBE8-50C2-4A3E-847B-9F5CB53A206C"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "778DC5E0-EF91-4406-8ABD-87AE432924AE",
+      "point" : "116,19",
+      "type_id" : 11
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "77A43E14-D6C5-46BB-A8D1-68A449EF7AC9",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "77D829F6-A8E7-4BE8-9711-C1553267E0F5",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "84A3C079-20EC-4C88-8DCF-6374E0A32B1C",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 2",
+      "object_id" : "79A10693-2CF0-496C-916E-2F1C6DE42D00",
+      "origin" : "-10,5",
+      "position_refs" : [
+        "24228F46-EDCB-43E9-A5DA-5BF09DB3A091",
+        "BEBA99B0-15F1-425A-98FC-57FDB510E765",
+        "6C1DC524-2544-4BDA-B2E1-79FFC8DA65B8"
+      ],
+      "segment_end_refs" : [
+        "24228F46-EDCB-43E9-A5DA-5BF09DB3A091",
+        "BEBA99B0-15F1-425A-98FC-57FDB510E765"
+      ],
+      "segment_refs" : [
+        "71AD836E-CAA6-46B7-A079-171D3592E08E"
+      ],
+      "type_id" : 5
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "79BA29CA-9B8C-4CAC-840A-73F7D58F55F5",
+      "text" : "No",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7AB06A62-6AC5-4DBC-A1E1-F3A92E0B9AEC",
+      "type_id" : 18
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7B07E38B-58B2-4196-A66E-9F6BC8A86DE5",
+      "text" : "Is executing?",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7B48C438-F85B-409A-A1B1-F0FDDA497B70",
+      "type_id" : 18
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "854C4D7B-0199-4F16-94FB-1C2A6FF93D2F",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "86B94A3C-EDA5-4494-AB59-0191556BFEF2",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "CAAC047E-A15D-4EDE-A30A-4D20EFA2662B",
+      "frame_corner" : 5,
+      "frame_size" : "16,3",
+      "model_text" : "FC357827-3DD5-49F3-927A-462D8D2704F7",
+      "name" : "Delay\/\ndebounce",
+      "object_id" : "7B9FF690-E4D4-4D47-B131-1C0837B873B6",
+      "origin" : "-24,8",
+      "position_refs" : [
+        "CAAC047E-A15D-4EDE-A30A-4D20EFA2662B"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7C484943-D2D1-47A2-9B6A-FC4F012A024E",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7C60E869-510F-4AF6-87E3-F60A5C1623A6",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "7C86DD97-844E-4A4E-A964-C60F06D52673",
+      "position_ref" : "565340C2-F7FE-49E9-9F78-C5971E706C13",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7C8AAC4D-B8EF-4A06-99ED-C1179988D12F",
+      "position_ref" : "6D56CBBC-140B-456B-B68F-A0474C4C34FA",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7CB16153-65D3-4CEC-9948-A2FD45AB1C04",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7CF87AFB-C487-45EF-AC9C-9155B229961F",
+      "type_id" : 18
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "B83A5841-7E36-480B-A19C-A08D3CF180A4",
+      "content_color" : 4292203989,
+      "content_tixels" : "344BFBF5-00F0-42D6-B6E5-60E78D768136",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "778DC5E0-EF91-4406-8ABD-87AE432924AE",
+      "frame_corner" : 5,
+      "frame_size" : "19,3",
+      "model_text" : "6F28153C-738C-4E97-A288-6A7970805267",
+      "name" : "No delay\/debounce",
+      "object_id" : "7D0AAACC-6028-4F17-A664-CA1BFAC947D2",
+      "origin" : "7,8",
+      "position_refs" : [
+        "778DC5E0-EF91-4406-8ABD-87AE432924AE"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "70969C04-2A41-4680-AF6A-5DAD091E4A72",
+      "content_color" : 4292203989,
+      "content_tixels" : "8D981040-D72F-4301-A596-670EE9F9C4FA",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "668C32C8-7B94-4C4E-A6A0-F6DCA9F47529",
+      "frame_corner" : 5,
+      "frame_size" : "9,2",
+      "model_text" : "BCCED5AD-395F-4CCB-8347-96339FDD1591",
+      "name" : "Hits a Waitpoint",
+      "object_id" : "7D2F5C8E-FC73-4DA0-9BE4-D186E3100CD6",
+      "origin" : "9,44",
+      "position_refs" : [
+        "668C32C8-7B94-4C4E-A6A0-F6DCA9F47529",
+        "A6EC6474-DC80-486C-937D-A6ED206DAE9B",
+        "FCBA08D5-02A0-4C7A-875C-411E678AFC67",
+        "D19A90AA-C448-4401-BAF5-C5905BABC5DA",
+        "5FD7D587-D4D5-4085-91C3-ECCCF00047C8"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7DF0E6FA-1FCD-48C3-A71A-584CAF0DCF38",
+      "position_ref" : "A45FDBBD-3875-4100-8357-D9B576A0ED05",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7DF924CD-5DD9-473A-8F55-FA9BBE1227FA",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7E232F1B-5226-4005-B062-1996C5E55CBE",
+      "position_ref" : "2CB932D2-E47D-4244-A0C4-DEE104788514",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "7F8CD780-C9F2-4426-9937-878C1D90E9BE",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "92E32A71-EC6A-4A73-9E52-910AA78490D3",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 3",
+      "object_id" : "7FB0C882-7A72-4777-8CDF-8B2325DC550D",
+      "origin" : "57,60",
+      "position_refs" : [
+        "47C3538C-B57E-4235-BF94-B8B04B3572F7",
+        "7C86DD97-844E-4A4E-A964-C60F06D52673",
+        "6779896C-8DA8-41B0-A429-A57A660C5DEE",
+        "FD5F4C49-5268-4584-AB9C-EC60DE5F21DE"
+      ],
+      "segment_end_refs" : [
+        "47C3538C-B57E-4235-BF94-B8B04B3572F7",
+        "7C86DD97-844E-4A4E-A964-C60F06D52673"
+      ],
+      "segment_refs" : [
+        "01806FE3-09CD-47AE-9C10-69BC2C15F20E"
+      ],
+      "type_id" : 5
+    },
+    {
+      "border_tixels" : "ADE330B0-A1B6-459E-9F09-211D6D18B3D8",
+      "content_tixels" : "0986AD13-CEC9-4D2E-BE7C-F0496A23B098",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "E978FB9C-7321-48A6-8D65-88F7C0462A51",
+      "frame_size" : "33,5",
+      "model_text" : "B95DD873-1184-4F2A-9AF7-8264A6A96E5B",
+      "mps_border_color" : 4286108927,
+      "name" : "EXECUTING Copy",
+      "object_id" : "80F153AB-580B-4F21-A6BF-B0F1ECD64D91",
+      "origin" : "57,59",
+      "position_refs" : [
+        "E978FB9C-7321-48A6-8D65-88F7C0462A51",
+        "F4F19348-2079-41F4-B650-6A62F7AA8768",
+        "881102CC-ED0F-4481-A0DE-0EB85FD1F4EE",
+        "9F67FE2C-8761-456E-8E90-D457BA24DD38",
+        "7DF924CD-5DD9-473A-8F55-FA9BBE1227FA",
+        "244E9055-B419-4A91-B86E-4EB9DBF5600B",
+        "5569620F-DC05-42BF-B631-4BF1DB356AF2",
+        "2C0C3256-11DD-4782-8692-5D0C61DD3D41",
+        "ECE104FA-6D00-4568-A0F7-92E130B37823",
+        "1F4C43EE-41E2-42D5-AF90-ACA44B83919C",
+        "305B8CE7-3FE8-4141-8F6B-0ED78C538551"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "81458BD7-79B8-48F4-A20A-4A0ECE3C752E",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "81E3CBF3-39A5-4C07-8B01-28930CDD2EEA",
+      "position_ref" : "B82904F7-9B67-4E46-B5A7-C8F89E6F7444",
+      "type_id" : 10
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "48AAC497-7877-4CB7-BDDA-719C8EEF8C03",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 2",
+      "object_id" : "823B845E-90FE-4CD9-893F-9AA0C8540451",
+      "origin" : "-20,34",
+      "position_refs" : [
+        "4D0DC480-C606-44F0-AC1C-38E9A9AA86C5",
+        "40E09C54-8E39-4370-BB48-F7545A04A315",
+        "E32B9AB8-825E-4568-A3EE-66ABEC7BB45D"
+      ],
+      "segment_end_refs" : [
+        "4D0DC480-C606-44F0-AC1C-38E9A9AA86C5",
+        "40E09C54-8E39-4370-BB48-F7545A04A315"
+      ],
+      "segment_refs" : [
+        "53DE2297-1868-46F5-9B1F-799A1B6AED59"
+      ],
+      "type_id" : 5
+    },
+    {
+      "content_color" : 4294966643,
+      "content_tixmap_ref" : "A6516ECD-EB27-4712-B646-9BC79D7FD113",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 6",
+      "object_id" : "83312855-B41E-4EAB-99A1-5C29BED2371A",
+      "origin" : "-86,60",
+      "position_refs" : [
+        "E7BEF7A9-A403-4363-83B4-85B028152517",
+        "7302DF42-5479-470D-BE9E-783A02D84ED8",
+        "1B5E0523-77FB-4FA4-A1C3-4EC4C58F1128"
+      ],
+      "segment_end_refs" : [
+        "E7BEF7A9-A403-4363-83B4-85B028152517",
+        "7302DF42-5479-470D-BE9E-783A02D84ED8"
+      ],
+      "segment_refs" : [
+        "311B638D-020F-4F69-B5D5-C2D627BA57E8"
+      ],
+      "type_id" : 5
+    },
+    {
+      "color" : 4286086655,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8359781B-23F8-48CA-AB1B-C630F0211638",
+      "text" : "Run Queue",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 8,
+      "object_id" : "8395FC43-6137-4BDC-904C-91044FCBF19C",
+      "position_ref" : "B5CDDB1E-E3F5-4484-B4E5-C1976F44F786",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "83B1F409-B54A-4AC5-A9D2-30CFFCB97CFC",
+      "point" : "89,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "84587447-C1DE-46AF-BBC2-002E84B57097",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "border_tixels" : "DAB46331-B8CB-4697-B4CF-C6FDD2D3915A",
+      "content_color" : 4292203989,
+      "content_offset" : "-5,0",
+      "content_tixels" : "428932DF-AAC3-4979-937E-B3C5B2C96DC2",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "F05788FC-EAC4-4E3B-BEE6-3E1129EC1BE0",
+      "frame_corner" : 5,
+      "frame_size" : "17,1",
+      "model_text" : "DAB178C0-5D4D-453D-B52D-A572102263AF",
+      "name" : "Attempt failed",
+      "object_id" : "84610025-CDB4-4062-89CB-1192B3BB0B57",
+      "origin" : "54,58",
+      "position_refs" : [
+        "F05788FC-EAC4-4E3B-BEE6-3E1129EC1BE0",
+        "0FC22524-992E-4A27-B8AE-B254C8C665EA",
+        "BB599FFE-E6C2-4001-B9F0-5BC4FE5E2024",
+        "27F3BD5A-220C-436D-8CDC-F91D34219EAA"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "846D4811-6560-4A20-83D2-D6D2C3F2FA58",
+      "position_ref" : "915DA1CA-F8CC-4CEE-83D7-0632CDE5A1DF",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8496EF2B-00B1-4F67-B98A-239F334E2F62",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "84A3C079-20EC-4C88-8DCF-6374E0A32B1C",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "84E52FAC-959F-40F0-B5EE-1328154051FE",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8523D6EE-F820-4235-9E63-919135246129",
+      "position_ref" : "1F5E4B71-2CC5-4F92-9C17-2BC9C08342C7",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "854C4D7B-0199-4F16-94FB-1C2A6FF93D2F",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "86B94A3C-EDA5-4494-AB59-0191556BFEF2",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "86EF494E-C3C7-41B4-A145-8591D675AD5E",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "872AD196-1857-49AC-BDF3-29CFB1C77E50",
+      "position_ref" : "25C62047-A2DB-4898-9FC1-131D25CC4565",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "87885581-C2A4-427B-BAF3-02974D59699B",
+      "position_ref" : "5E8F0012-51A8-4118-AEB1-A56C5C27105F",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "881102CC-ED0F-4481-A0DE-0EB85FD1F4EE",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "88B01512-B6E2-4F78-9422-1746B41833DA",
+      "type_id" : 18
+    },
+    {
+      "content_tixmap_ref" : "2F442885-C9B5-48CC-9F3A-E75BD5263973",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "line_style" : 5,
+      "name" : "Line 8",
+      "object_id" : "89200781-C15E-4D84-B28C-B95274CDECCF",
+      "origin" : "0,-2",
+      "position_refs" : [
+        "D0156743-703F-4B2D-A02D-97A5CAEDFB29",
+        "F4061998-DD69-452D-BC81-261F799034C2",
+        "2CB932D2-E47D-4244-A0C4-DEE104788514",
+        "7E232F1B-5226-4005-B062-1996C5E55CBE"
+      ],
+      "segment_end_refs" : [
+        "F4061998-DD69-452D-BC81-261F799034C2",
+        "7E232F1B-5226-4005-B062-1996C5E55CBE"
+      ],
+      "segment_refs" : [
+        "26360FE9-3676-4EBB-A6FD-ECA0FFE2A306"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 8,
+      "object_id" : "89CA5F0E-DAF6-4683-8DAC-4CA84E61AEFB",
+      "position_ref" : "06FBACF1-15F7-4630-B120-105FDB8C34B9",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "89DA6A11-FB45-481F-8EDB-17EFB6A24BFA",
+      "rect_position" : 18,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8A64C46F-5F4B-4DD3-8268-91060BC63149",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8A825469-347A-488A-9429-8C6189F91BCA",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "8ABEF1B1-ADE2-44B2-93A4-F023F1317A1B",
+      "position_ref" : "2C3DA79C-B51F-4F9E-A32F-8BF89879D523",
+      "type_id" : 10
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "1AA59300-95C1-4004-9817-6388A96D2A6C",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 3",
+      "object_id" : "8AF0B57C-0CBB-4002-B498-A38741D63F78",
+      "origin" : "-36,12",
+      "position_refs" : [
+        "ECD8E365-42A8-4F12-A81A-1F14F2246B7A",
+        "3394CDC0-F69B-422C-A397-04745F267F38",
+        "B04AC561-CC3E-431B-8CA0-7FA5AC3FFF33"
+      ],
+      "segment_end_refs" : [
+        "ECD8E365-42A8-4F12-A81A-1F14F2246B7A",
+        "3394CDC0-F69B-422C-A397-04745F267F38"
+      ],
+      "segment_refs" : [
+        "67CCABA8-CA30-416A-9CEF-56144939D2D1"
+      ],
+      "type_id" : 5
+    },
+    {
+      "border_tixels" : "0937DD3C-F637-465D-A7A3-EB5BF9258CFF",
+      "content_color" : 4292203989,
+      "content_offset" : "-2,0",
+      "content_tixels" : "435E6772-339C-4CCA-A0A8-D63A3E340B69",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "FC13BD1B-F9D6-425C-A09F-5D05A4ABD176",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "ABB4ABC8-6A3A-4FB0-AF54-0A667CA18662",
+      "mps_bckg_color" : 4284374622,
+      "name" : "User cancels a run",
+      "object_id" : "8B2D65B5-52BE-4F6C-B83F-8E5EE2CDFE95",
+      "origin" : "-63,65",
+      "position_refs" : [
+        "FC13BD1B-F9D6-425C-A09F-5D05A4ABD176",
+        "B82904F7-9B67-4E46-B5A7-C8F89E6F7444"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8B490612-1671-4F58-9712-8D93D5E36D2F",
+      "type_id" : 18
+    },
+    {
+      "alignment" : 2,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8C1ADB6F-F687-43C8-AE38-4742E07E9B6C",
+      "position" : 2,
+      "text" : "Run not executing",
+      "type_id" : 27
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "8C65F3E5-CF8B-4CFD-B7E6-BF7FF34FC219",
+      "type_id" : 24
+    },
+    {
+      "alignment" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "enabled" : false,
+      "object_id" : "8CA8575A-5A95-4A7B-9257-C54A53BDAB0C",
+      "position" : 0,
+      "text" : "",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8CBABF6D-723A-47AB-A073-9CE6EC45BF0B",
+      "point" : "89,20",
+      "type_id" : 11
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "8CF9133F-5AA3-4A43-9574-6BDF9C8A2B2F",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "8D1CCE89-F11C-45C2-8F21-2EF1608CD931",
+      "position_ref" : "DD41B632-4B22-41A4-8B7F-74CCF9C4F857",
+      "type_id" : 10
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8D4E6A8A-A765-4B8B-A44E-4E5E0FF5C15A",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8D981040-D72F-4301-A596-670EE9F9C4FA",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8E224A02-EB39-46A1-AD9A-0445387F71BE",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "8E55D93E-A435-4DF5-9C8E-187643A58C6D",
+      "position_ref" : "68B0397E-E294-423E-ABF0-014F8ED74865",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "8EFB8F3B-44EE-406D-A5FE-9A9DF382191D",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "900BD446-F8E1-4006-9588-5AC73CA288F6",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "94F65FE8-37B4-4B9D-A5BD-AF290518C7C5",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 2",
+      "object_id" : "906722A7-BBCF-47FE-AA2E-D21A7935C5C6",
+      "origin" : "57,48",
+      "position_refs" : [
+        "25719DB7-FE53-4EB7-9896-1E08DB5A1C51",
+        "B5BB92EE-86B2-4A75-95A9-54CEF5EDD397",
+        "8C65F3E5-CF8B-4CFD-B7E6-BF7FF34FC219"
+      ],
+      "segment_end_refs" : [
+        "25719DB7-FE53-4EB7-9896-1E08DB5A1C51",
+        "B5BB92EE-86B2-4A75-95A9-54CEF5EDD397"
+      ],
+      "segment_refs" : [
+        "3035BDFB-2CA3-4B80-BDD3-ACF178DC341E"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9090A07E-15C7-49E5-AFCE-DC8830136245",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "909BD60D-9DC6-4741-96EB-7328035DD54D",
+      "position_ref" : "0A3B4947-C6CD-40C4-BAFA-CBA4EE2B323E",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9152D1F3-D96E-427F-8074-03B6F54C61D1",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "915DA1CA-F8CC-4CEE-83D7-0632CDE5A1DF",
+      "point" : "66,14",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "92669FB6-93F4-4498-98C0-97D74045E4F5",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "928889EA-ABCA-45D1-AC83-5F78B9680844",
+      "point" : "95,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "92E32A71-EC6A-4A73-9E52-910AA78490D3",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "93F53073-E24E-4ADA-98CF-F061A5CE38E2",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "94F65FE8-37B4-4B9D-A5BD-AF290518C7C5",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "95DD2A83-6B63-4836-B6A8-7CCE590DD659",
+      "position_ref" : "244E9055-B419-4A91-B86E-4EB9DBF5600B",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "95EFBE75-44E6-421A-B204-69332A046A53",
+      "position_ref" : "FA9EB949-3D30-4945-A249-8B9826E0EE93",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 8,
+      "object_id" : "96E3D88F-E3FE-4A11-B5E2-C3941AF9D50B",
+      "position_ref" : "F2DA4D10-715D-436C-80F2-BBF29898B919",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "972CFDA3-A7A2-43EF-8DAC-0884DE8E3BEF",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9759D941-079D-4ABB-9D57-54D56F0EE120",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "99499F57-22A0-4899-996D-C3D4032927E7",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "99F3C04E-73FB-4FA0-946A-4D80CDDB2EAF",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "99FB47C5-E697-4E70-B378-D01571CE56B1",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Canvas 1",
+      "object_id" : "9A4BAB9D-4F8D-47FF-8C31-0F7B10664D63",
+      "subshape_refs" : [
+        "6420C140-0D72-41BF-BC3B-B8A83EA07F2A",
+        "B7F2E871-BE14-477F-86F9-D72E5FF16609",
+        "6CF46792-BF7B-4795-9F80-A2BCEE750065",
+        "7D2F5C8E-FC73-4DA0-9BE4-D186E3100CD6",
+        "2AC63D46-DD1A-4DC9-B241-A49951E95668",
+        "83312855-B41E-4EAB-99A1-5C29BED2371A",
+        "6DDFA6AA-8E6C-4740-AA17-290DB9AF20DF",
+        "4CE9B747-B939-4DC3-9A2B-44A4BB419BDB",
+        "84610025-CDB4-4062-89CB-1192B3BB0B57",
+        "473C75A8-75E0-4017-9808-CABA7473A740",
+        "0D907E82-3DAA-4AAF-A9A5-86ECEF509537",
+        "CD76F306-B69A-47C5-87F7-26729E3BA0B9",
+        "D5146D8D-8B2E-402A-8616-B8A3E9100602",
+        "1341372C-7AB5-45C3-88DE-FFA35A25C707",
+        "B50EDE93-4905-4F45-90F2-871B50A100F4",
+        "362A661B-200C-475C-A811-ED89E5D48A03",
+        "DC987C5D-238F-43FC-917A-FFDD362E6FA2",
+        "77197D52-5E97-4413-8E34-9C1E8B5E792F",
+        "697CE8E2-9A99-460C-BF9C-7D70417E9E15",
+        "40BB3E01-00FF-419F-9222-77583706372D",
+        "A86C8338-0335-4D69-B572-E7710C1C138B",
+        "0A774E8A-8D9C-4AC0-802E-02A7B791DC49",
+        "61189AF3-7EBD-4409-B034-1EB1D963B0A4",
+        "B0B0C84A-7A41-4DF7-A506-74EFFCC91CCC",
+        "823B845E-90FE-4CD9-893F-9AA0C8540451",
+        "07A1185A-5BB9-41DE-B2E2-2F015886E3DC",
+        "79A10693-2CF0-496C-916E-2F1C6DE42D00",
+        "E02E7718-B76D-47F9-99F0-B0D45C1172D3",
+        "6C0F5656-8B93-427F-8E7C-CFE6AA67080A",
+        "B01D24F9-10B2-444F-AE95-E9DA9B829C76",
+        "A8D3BC1E-25F1-49F5-87DE-776F99870F67",
+        "E000EC47-592A-4F5A-B115-0E91560AD77F",
+        "530C12A4-8948-40B1-B284-FB3387C9314B",
+        "BFD4DBC9-5BE5-4206-85D1-26176BF04DC3",
+        "8B2D65B5-52BE-4F6C-B83F-8E5EE2CDFE95",
+        "4354ED16-27CF-4F09-8599-9412822ABA82",
+        "611CA29C-CB6F-4426-8E83-EDA1F2A29DA7",
+        "5D302402-269D-478D-957A-F48E581D77BA",
+        "B63689AE-15F0-4BC9-ADFE-BC043FB08391",
+        "73BFB879-6953-4ED1-8D8C-94C3E41CEFFC",
+        "CF628EAD-FDA3-4853-9A42-99F87FF9793E",
+        "414FF17D-0426-4DA3-B7DB-DF2732E1CF45",
+        "F4229049-751E-4459-94C0-A6DE9FF09DBE",
+        "37818C91-943F-48C6-AAD1-CBFB482824B4",
+        "7FB0C882-7A72-4777-8CDF-8B2325DC550D",
+        "0B5DB076-D0BC-4D9B-85A3-C82E9EBBE136",
+        "2706D57E-4869-4D0F-9435-640B05BDA51B",
+        "135D1ED0-4BD8-4782-89DC-89F4798D07B1",
+        "41E35C8F-8EF4-4A0B-AADB-7433C7BEA8F0",
+        "201D6215-0684-4AEC-8C4C-7040CB431093",
+        "E1AD9E4E-EA41-4F76-BEE6-E33F45DA8C1F",
+        "E0A5CBA3-C6FA-4EB0-A09B-1C7A758393B1",
+        "9EB79889-368C-4EE6-A23D-A33E33990AE9",
+        "906722A7-BBCF-47FE-AA2E-D21A7935C5C6",
+        "80F153AB-580B-4F21-A6BF-B0F1ECD64D91",
+        "344EA014-CF97-4607-AAF7-45F152715D8C",
+        "9B8CC001-12BB-45E2-A256-2683374EC5F3",
+        "3C3443D6-F420-46C0-9477-59441B077CD1",
+        "2F84C981-06FE-46F6-9E89-6581317BD8DD",
+        "0AB3CCAA-A2AB-4E3B-A9C7-4A413516EF17",
+        "E4674D10-BD98-4041-AA78-440FEAF31A8B",
+        "DE6094F4-057D-4D9A-BCFF-67BA7EBB7705",
+        "8AF0B57C-0CBB-4002-B498-A38741D63F78",
+        "7B9FF690-E4D4-4D47-B131-1C0837B873B6",
+        "0E94D869-828D-4D47-8A32-13411F9AB5F9",
+        "7D0AAACC-6028-4F17-A664-CA1BFAC947D2",
+        "15A6F943-15C1-4C60-A052-5CC56DFE4630",
+        "B7E9F534-AB48-434D-BA14-B40878B5BE0B",
+        "BEE7F123-7843-4458-9EBC-D1123E8BF513",
+        "6985CD55-3C7E-48D0-B327-55AF77FF6365",
+        "1A250DE9-B89F-4A0E-A4F1-7DCD34390E88",
+        "A431764C-1016-4AFC-8959-D20421864C9C",
+        "89200781-C15E-4D84-B28C-B95274CDECCF",
+        "0260D409-FE9E-48A0-A273-7146617D6792"
+      ],
+      "type_id" : 1
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9AD8F9CB-774F-46DB-8DBC-47780A84A5EE",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9AF5726A-C355-425D-900C-83C2BB5450E1",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9B4402E8-E9D1-4ABC-897E-86FA47CE4ECC",
+      "type_id" : 18
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9B8A66ED-6B4A-46F6-B456-EE7A0840931A",
+      "text" : "SUSPENDED",
+      "type_id" : 27
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "CC6F1AE9-608B-45C0-9BA8-AE35A1278A2E",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 1,
+        "p" : 1,
+        "u" : 1
+      },
+      "name" : "Line 1 Copy",
+      "object_id" : "9B8CC001-12BB-45E2-A256-2683374EC5F3",
+      "origin" : "57,36",
+      "position_refs" : [
+        "846D4811-6560-4A20-83D2-D6D2C3F2FA58",
+        "B5BA051A-820C-4C71-8E74-9EF05E73E4CE",
+        "6AE066AF-D8A8-4970-BAE7-5C20581E325F",
+        "915DA1CA-F8CC-4CEE-83D7-0632CDE5A1DF"
+      ],
+      "segment_end_refs" : [
+        "846D4811-6560-4A20-83D2-D6D2C3F2FA58",
+        "B5BA051A-820C-4C71-8E74-9EF05E73E4CE"
+      ],
+      "segment_refs" : [
+        "4FD5F62E-202D-4A49-A79E-31388F738E03"
+      ],
+      "type_id" : 5
+    },
+    {
+      "canvas_refs" : [
+        "9A4BAB9D-4F8D-47FF-8C31-0F7B10664D63"
+      ],
+      "object_id" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "shape_seq_numbers" : {
+        "1" : 2,
+        "2" : 8,
+        "4" : 3,
+        "6" : 1,
+        "12" : 1
+      },
+      "type_id" : 0
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9DA030E2-2F87-4159-BBFD-159577B58427",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "C839A2E4-17D2-42C8-8574-496ED2B774CE",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 3",
+      "object_id" : "9EB79889-368C-4EE6-A23D-A33E33990AE9",
+      "origin" : "57,58",
+      "position_refs" : [
+        "380CD52E-2F7E-462C-9782-C5331B6DE34E",
+        "454BF47B-AEE8-4038-BA47-F54B504F6A6D",
+        "8CF9133F-5AA3-4A43-9574-6BDF9C8A2B2F"
+      ],
+      "segment_end_refs" : [
+        "380CD52E-2F7E-462C-9782-C5331B6DE34E",
+        "454BF47B-AEE8-4038-BA47-F54B504F6A6D"
+      ],
+      "segment_refs" : [
+        "D3200457-BF2B-4D38-BEBA-8403119C0F09"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "9F67FE2C-8761-456E-8E90-D457BA24DD38",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A0371294-ADC5-4D6A-B32F-8A170CAC516A",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A09866AB-D356-4C87-82C3-FDD9F8327867",
+      "point" : "116,14",
+      "type_id" : 11
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A205BDF9-9645-4343-9F64-C1249A9FA908",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A2A58C37-05A3-42D6-BD7F-5912147A0272",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A2CB37AE-2CF5-472C-A3B5-02B7572B0C41",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A363B846-62E9-4100-9E31-197F518B6B3A",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A3980A6D-41A3-460E-9892-29B942165B24",
+      "rect_position" : 10,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A42CA60B-0AA3-44A5-A591-F834AEC89D04",
+      "point" : "123,14",
+      "type_id" : 11
+    },
+    {
+      "border_tixels" : "D280C64C-856C-45ED-ADED-C0F419A91BE1",
+      "content_tixels" : "23BCC60B-5153-4D3A-A469-5CEA51985025",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "DE810199-FFC9-45FA-9442-7804CC8C1E3C",
+      "frame_size" : "33,5",
+      "model_text" : "E689B2D6-CC08-4AF4-8880-EE6420A515DD",
+      "mps_border_color" : 4286108927,
+      "name" : "RUN_CREATED",
+      "object_id" : "A431764C-1016-4AFC-8959-D20421864C9C",
+      "origin" : "57,12",
+      "position_refs" : [
+        "DE810199-FFC9-45FA-9442-7804CC8C1E3C",
+        "9AD8F9CB-774F-46DB-8DBC-47780A84A5EE",
+        "FEB0F91E-2CAE-4F20-BFF8-12C89B0DBA42",
+        "7C484943-D2D1-47A2-9B6A-FC4F012A024E",
+        "25C62047-A2DB-4898-9FC1-131D25CC4565"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A431B440-7502-470D-A8BC-95395359D3FD",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A44857A0-CE2B-4695-B1D0-AA35DA2574B2",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A45FDBBD-3875-4100-8357-D9B576A0ED05",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A46D17E6-5E7F-42D8-8CBA-D4C800C4E7E8",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A611C0C7-9F0C-4A4E-97D5-CB5B26DAE274",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A6516ECD-EB27-4712-B646-9BC79D7FD113",
+      "type_id" : 18
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A668AA0B-E8B2-45F8-9E16-9B906D39732F",
+      "text" : "All Waitpoints complete?",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A6EC6474-DC80-486C-937D-A6ED206DAE9B",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A724A3A9-4323-4D8E-B76B-E2C958171957",
+      "position_ref" : "E6698869-9500-4AD0-BA05-813FC0CE876D",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A761DC9F-C050-4277-942F-4354BC0DD88C",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A7C0832E-4D00-4E67-A168-404E7A387CF0",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4294966643,
+      "content_tixmap_ref" : "C3C0AB52-E1B3-4E23-B366-C263334D8D37",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "A86C8338-0335-4D69-B572-E7710C1C138B",
+      "origin" : "76,27",
+      "position_refs" : [
+        "96E3D88F-E3FE-4A11-B5E2-C3941AF9D50B",
+        "56D3103C-F681-43F4-8BC6-2F47EA6E1E92",
+        "FEFF07F0-0D3A-4CCE-B4D2-45C4EB951365",
+        "FD7FC36A-7576-4AC4-9621-D73179475822"
+      ],
+      "segment_end_refs" : [
+        "96E3D88F-E3FE-4A11-B5E2-C3941AF9D50B",
+        "56D3103C-F681-43F4-8BC6-2F47EA6E1E92"
+      ],
+      "segment_refs" : [
+        "1F3FD34F-89DA-4D82-85AC-A256D89562F3"
+      ],
+      "type_id" : 5
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A8BD65F3-E402-4CFF-97AC-DA7ED435BFE9",
+      "text" : "Has delay\/debounce?",
+      "type_id" : 27
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "E2E37DAF-1D27-41B2-8777-2A59E58B2509",
+      "content_offset" : "6,0",
+      "content_tixels" : "B55A3FCF-130C-4C20-8560-22A96D6894D5",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "13119978-2754-4B35-BA99-41824CE7C40F",
+      "frame_corner" : 5,
+      "frame_size" : "17,1",
+      "model_text" : "09CE0196-EB93-46DF-A12D-A84FDC0338BE",
+      "name" : "Yes",
+      "object_id" : "A8D3BC1E-25F1-49F5-87DE-776F99870F67",
+      "origin" : "14,40",
+      "position_refs" : [
+        "13119978-2754-4B35-BA99-41824CE7C40F",
+        "BB1A5BA1-509B-424E-A5DB-1D8930BB1D97",
+        "D2290634-CF61-4562-A41B-F66BD3394454",
+        "ED7584A1-BCBC-4193-96E5-CEE9C1543F41"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A9389928-1941-477B-B053-4D53DD5B21E6",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A9CD62E5-3F99-413D-9C98-0D2A3B8B8D9F",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "A9E11E96-8500-4FEE-AB92-A75515528B77",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AA00A388-301E-49A5-972C-70E7E7DFE300",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AA0D777D-A84A-488B-AB5E-81F8C747EC76",
+      "point" : "123,14",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AA8389E9-4BBB-40B2-8EC8-8B4761442D67",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AB436F11-971E-495D-94CE-C3090551A158",
+      "text" : "Attempt failure",
+      "type_id" : 27
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "ABB4ABC8-6A3A-4FB0-AF54-0A667CA18662",
+      "text" : "User cancels a run",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AC04F11E-AE03-402A-A8A2-D8FB0956EC82",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AC0AAB7F-0AB8-40F4-B6CE-BD1862AB5368",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AC419C4C-6981-44A2-92E8-807ABCFDE36F",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "ADE330B0-A1B6-459E-9F09-211D6D18B3D8",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AE0A1A44-2926-4F59-BDF3-8D1BBE10A541",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "AE3295F3-E261-4A5E-8F54-1D516FF96061",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AEBA5891-E068-406E-BDC4-31CAA91BC86C",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "AF689118-DCF2-4C05-BE0A-DAC9BE410770",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "A611C0C7-9F0C-4A4E-97D5-CB5B26DAE274",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 3",
+      "object_id" : "B01D24F9-10B2-444F-AE95-E9DA9B829C76",
+      "origin" : "30,67",
+      "position_refs" : [
+        "1FAB2CC0-F161-406F-8E41-E3B7CD7A77DE",
+        "2B9D7887-B7F4-44B6-83CC-99CBE6818B40",
+        "57EDF807-5283-4EF6-B81F-6A4278EC39E2"
+      ],
+      "segment_end_refs" : [
+        "1FAB2CC0-F161-406F-8E41-E3B7CD7A77DE",
+        "2B9D7887-B7F4-44B6-83CC-99CBE6818B40"
+      ],
+      "segment_refs" : [
+        "0D05510C-E817-4E96-AC39-4C2930808C71"
+      ],
+      "type_id" : 5
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.61111111111111116,
+      "object_id" : "B04AC561-CC3E-431B-8CA0-7FA5AC3FFF33",
+      "type_id" : 24
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "AF689118-DCF2-4C05-BE0A-DAC9BE410770",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "C318B29A-B218-462E-B00C-620FC2D3CB61",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "A42CA60B-0AA3-44A5-A591-F834AEC89D04",
+      "frame_corner" : 5,
+      "frame_size" : "23,3",
+      "model_text" : "79BA29CA-9B8C-4CAC-840A-73F7D58F55F5",
+      "name" : "No",
+      "object_id" : "B0B0C84A-7A41-4DF7-A506-74EFFCC91CCC",
+      "origin" : "0,3",
+      "position_refs" : [
+        "A42CA60B-0AA3-44A5-A591-F834AEC89D04"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B0F57680-86BA-475D-B32C-14FFA920B308",
+      "text" : "All retries used",
+      "type_id" : 27
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B1BEE084-F681-4686-9C36-A2BDDB40DD05",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B359EDBA-7DA6-414E-9DE4-B01774109127",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B44ACC14-D84A-44F8-860F-1F5DC08A43EB",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B4E894F3-FB8D-4CF3-AD1F-46E7E0A00B21",
+      "point" : "91,20",
+      "type_id" : 11
+    },
+    {
+      "content_color" : 4294966643,
+      "content_tixmap_ref" : "70E2C023-CA31-48CA-942A-85D8E4368E5A",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 5",
+      "object_id" : "B50EDE93-4905-4F45-90F2-871B50A100F4",
+      "origin" : "-86,41",
+      "position_refs" : [
+        "8395FC43-6137-4BDC-904C-91044FCBF19C",
+        "E3733850-A7E2-4EE4-ADC6-50AF64791059",
+        "63A9C839-D66F-4E88-81DA-20AEB1ACD766"
+      ],
+      "segment_end_refs" : [
+        "8395FC43-6137-4BDC-904C-91044FCBF19C",
+        "E3733850-A7E2-4EE4-ADC6-50AF64791059"
+      ],
+      "segment_refs" : [
+        "0931A992-31D7-46D5-A794-DD06B7BCEC6B"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B55A3FCF-130C-4C20-8560-22A96D6894D5",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "B5BA051A-820C-4C71-8E74-9EF05E73E4CE",
+      "position_ref" : "B359EDBA-7DA6-414E-9DE4-B01774109127",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "B5BB92EE-86B2-4A75-95A9-54CEF5EDD397",
+      "position_ref" : "F4F19348-2079-41F4-B650-6A62F7AA8768",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B5CDDB1E-E3F5-4484-B4E5-C1976F44F786",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "7B48C438-F85B-409A-A1B1-F0FDDA497B70",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_type" : 4,
+      "name" : "Line 1 Copy 4",
+      "object_id" : "B63689AE-15F0-4BC9-ADFE-BC043FB08391",
+      "origin" : "40,22",
+      "position_refs" : [
+        "5DA6EC85-9D1B-45A1-AD8A-C9162853778A",
+        "0AF1312A-C97F-45BD-947F-32E902EF9D25",
+        "0F1F0B56-28D1-40DA-AE63-F5F8380C3002",
+        "61CD1957-4BB5-4544-B7FE-9F87B1E93F88"
+      ],
+      "segment_end_refs" : [
+        "5DA6EC85-9D1B-45A1-AD8A-C9162853778A",
+        "0AF1312A-C97F-45BD-947F-32E902EF9D25"
+      ],
+      "segment_refs" : [
+        "FEFC7899-1048-4191-AAAB-2846D839C9AF"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "B6ED9A50-BAF5-40A4-AD34-87CB6E77C42C",
+      "position_ref" : "DF2DB3AD-A4C6-44DE-AE9F-ECD4FA6E2884",
+      "type_id" : 10
+    },
+    {
+      "border_tixels" : "CD524670-D496-4B22-A404-965846272A3E",
+      "content_tixels" : "D6E86E48-0102-4F32-A3B3-D636FA713FF6",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "F9BB3DE2-0E7F-4936-8E97-6EC0F74DAC98",
+      "frame_size" : "33,5",
+      "model_text" : "D2D772E5-C792-468B-B2B6-9B838AEAA29D",
+      "mps_border_color" : 4286108927,
+      "name" : "PENDING_EXECUTING",
+      "object_id" : "B7E9F534-AB48-434D-BA14-B40878B5BE0B",
+      "origin" : "57,45",
+      "position_refs" : [
+        "F9BB3DE2-0E7F-4936-8E97-6EC0F74DAC98",
+        "B359EDBA-7DA6-414E-9DE4-B01774109127",
+        "4D71F51C-34CA-4F11-A62D-46E6305200E0",
+        "A0371294-ADC5-4D6A-B32F-8A170CAC516A",
+        "86EF494E-C3C7-41B4-A145-8591D675AD5E"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "content_color" : 4294966643,
+      "content_tixmap_ref" : "F068079D-A8E9-4132-A2FA-F1DAACF5DE4B",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "B7F2E871-BE14-477F-86F9-D72E5FF16609",
+      "origin" : "34,40",
+      "position_refs" : [
+        "89CA5F0E-DAF6-4683-8DAC-4CA84E61AEFB",
+        "564E7239-A7F7-4155-8904-1F4BFB40C85A",
+        "DAD3B29F-B88F-423E-8E08-527AD3C223D5"
+      ],
+      "segment_end_refs" : [
+        "89CA5F0E-DAF6-4683-8DAC-4CA84E61AEFB",
+        "564E7239-A7F7-4155-8904-1F4BFB40C85A"
+      ],
+      "segment_refs" : [
+        "CC6D13C0-E596-49DB-B830-8E7A815EB3ED"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B82904F7-9B67-4E46-B5A7-C8F89E6F7444",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B83A5841-7E36-480B-A19C-A08D3CF180A4",
+      "type_id" : 18
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "B95DD873-1184-4F2A-9AF7-8264A6A96E5B",
+      "text" : "EXECUTING",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BB1A5BA1-509B-424E-A5DB-1D8930BB1D97",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BB47437C-904E-4F3C-A152-F5F18AE81470",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BB599FFE-E6C2-4001-B9F0-5BC4FE5E2024",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BCCED5AD-395F-4CCB-8347-96339FDD1591",
+      "text" : "Hits a Waitpoint",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "BEBA99B0-15F1-425A-98FC-57FDB510E765",
+      "position_ref" : "9AD8F9CB-774F-46DB-8DBC-47780A84A5EE",
+      "type_id" : 10
+    },
+    {
+      "border_tixels" : "A9CD62E5-3F99-413D-9C98-0D2A3B8B8D9F",
+      "content_tixels" : "CBD6A542-25AC-4BC1-ADA0-7D0560656707",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "261945C0-8A87-413B-835D-CD23A28E1A77",
+      "frame_size" : "33,5",
+      "model_text" : "E2498346-603D-4018-A3E5-A1BE3EC45348",
+      "mps_border_color" : 4286108927,
+      "name" : "QUEUED",
+      "object_id" : "BEE7F123-7843-4458-9EBC-D1123E8BF513",
+      "origin" : "57,23",
+      "position_refs" : [
+        "261945C0-8A87-413B-835D-CD23A28E1A77",
+        "2C3DA79C-B51F-4F9E-A32F-8BF89879D523",
+        "46A8612F-9699-4139-9D53-6FA85BC7923B",
+        "C7518EE9-4EB1-4392-8048-AA9C3D68BF67",
+        "DA22D7AA-5AC9-4A83-B7F3-7AA3D4810B26",
+        "2EB68039-3964-4231-A1C1-A6A7E1BEFBD5"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BEF357ED-9FE3-4658-80DD-B323D59C1BF6",
+      "point" : "29,32",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BF480007-B41F-44D5-9729-349D757A1F2A",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "BF526605-3900-4AE2-9B80-D5313C040823",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "BFD136A2-4BA8-4B9E-9C3B-320E5F041E37",
+      "type_id" : 24
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "0304CB72-1D42-4280-B345-29F3A7E93FC4",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "BFD4DBC9-5BE5-4206-85D1-26176BF04DC3",
+      "origin" : "-1,68",
+      "position_refs" : [
+        "81E3CBF3-39A5-4C07-8B01-28930CDD2EEA",
+        "1B0F2973-7D6D-4784-880A-5457A3E383F3",
+        "058B2C77-EA4B-4299-A4DE-C6465F734375"
+      ],
+      "segment_end_refs" : [
+        "81E3CBF3-39A5-4C07-8B01-28930CDD2EEA",
+        "1B0F2973-7D6D-4784-880A-5457A3E383F3"
+      ],
+      "segment_refs" : [
+        "E3AA3EBF-D10F-41CE-9127-5AE13677D3BE"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C122EF43-A812-440B-B126-11CC3381770A",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C1A2CBF8-A868-424B-9C69-FE5327AB9C03",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C213B3CA-646C-43D8-9336-A07E7D4BE165",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 8,
+      "object_id" : "C23606D9-99F1-4384-B2B3-51B3CE4A8FC2",
+      "position_ref" : "C3799A91-0903-4D15-A49B-D9DA7CEB04F9",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C318B29A-B218-462E-B00C-620FC2D3CB61",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C3799A91-0903-4D15-A49B-D9DA7CEB04F9",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C3856D18-BCFF-4D54-8C1E-84585785DEA6",
+      "point" : "70,2",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C3C0AB52-E1B3-4E23-B366-C263334D8D37",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C4D83D4B-806F-4845-9437-CDC62C85EFAE",
+      "type_id" : 18
+    },
+    {
+      "color" : 4294966643,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C5144DEB-F58A-4BE8-B122-086661650F25",
+      "text" : "Start attempt",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C5DED5F9-31C8-49C6-8E5A-376B7698DA2A",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "C62D5AB7-CCDB-4ADB-9511-2A2C1D4FFB9D",
+      "type_id" : 24
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "C63D4669-A41E-41C6-8F0B-548A884E2644",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C6462A11-A6EA-4908-9472-38C98B2C9E05",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C6997D75-5E0D-43E9-8F8B-C500AEF0E7D3",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "letter_font_id" : "com.helftone.monodraw.figlet-font.small",
+      "letter_font_name" : "Standard - Small",
+      "object_id" : "C73B83AE-3AC7-49E5-990F-65275E30FC7E",
+      "text" : "Run Engine",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C7518EE9-4EB1-4392-8048-AA9C3D68BF67",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C8127403-66E4-473F-8CBF-1766F526C1CF",
+      "text" : "Attempt success",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C839A2E4-17D2-42C8-8574-496ED2B774CE",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C848A73B-70E5-429E-B08E-A1CB03DCB736",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "C86507D3-C0A8-4AD5-98B7-73E641B16B2B",
+      "type_id" : 9
+    },
+    {
+      "color" : 4294966643,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CA4E5E51-5D50-4D07-8E41-284583AD0750",
+      "text" : "Complete attempt",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CAAC047E-A15D-4EDE-A30A-4D20EFA2662B",
+      "point" : "123,14",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CBD6A542-25AC-4BC1-ADA0-7D0560656707",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "CBEC7845-3011-450D-A4C2-EDD6944CC894",
+      "type_id" : 24
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CC6D13C0-E596-49DB-B830-8E7A815EB3ED",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CC6F1AE9-608B-45C0-9BA8-AE35A1278A2E",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CC9543C6-05FB-46B1-BAD9-1F4650631AB8",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CD3D110E-BBF1-42AE-B7DE-7D18CA2BDF64",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CD524670-D496-4B22-A404-965846272A3E",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "8EFB8F3B-44EE-406D-A5FE-9A9DF382191D",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 1 Copy 4",
+      "object_id" : "CD76F306-B69A-47C5-87F7-26729E3BA0B9",
+      "origin" : "65,47",
+      "position_refs" : [
+        "E4E5E427-4E48-4006-A892-E09E6845999B",
+        "67641920-F3F8-4282-96C4-4B24CD37E6E0",
+        "743943E8-A2D9-4599-B4A3-8B26831DA02B",
+        "25AD3E71-2F2B-4E47-B489-FB7E065303DC"
+      ],
+      "segment_end_refs" : [
+        "E4E5E427-4E48-4006-A892-E09E6845999B",
+        "67641920-F3F8-4282-96C4-4B24CD37E6E0"
+      ],
+      "segment_refs" : [
+        "CD3D110E-BBF1-42AE-B7DE-7D18CA2BDF64"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CEAF8086-7518-412A-9A01-224999A6BAB0",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "0BED2F7C-D377-4C2F-8FA3-326680C0D951",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "CF628EAD-FDA3-4853-9A42-99F87FF9793E",
+      "origin" : "37,30",
+      "position_refs" : [
+        "8523D6EE-F820-4235-9E63-919135246129",
+        "1F6DC5EA-931F-4872-9518-CD05E8745F97",
+        "FA39209D-213F-4EE3-8E86-F48548F9BFD4",
+        "1F5E4B71-2CC5-4F92-9C17-2BC9C08342C7"
+      ],
+      "segment_end_refs" : [
+        "8523D6EE-F820-4235-9E63-919135246129",
+        "1F6DC5EA-931F-4872-9518-CD05E8745F97"
+      ],
+      "segment_refs" : [
+        "77A43E14-D6C5-46BB-A8D1-68A449EF7AC9"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "CF6C6D62-FEFF-4B4D-8D48-9B5D1DF5B851",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "CFD10BFD-59E6-4671-9F29-666F26892F0F",
+      "position_ref" : "305B8CE7-3FE8-4141-8F6B-0ED78C538551",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D0156743-703F-4B2D-A02D-97A5CAEDFB29",
+      "point" : "199,48",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D097D2A4-697D-4DDE-A627-19E732421418",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D0E26C00-EF01-4B95-97C4-208DC50082DD",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D19A90AA-C448-4401-BAF5-C5905BABC5DA",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D1D7FBE8-50C2-4A3E-847B-9F5CB53A206C",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D22327ED-CDEC-4EB4-8BBD-E826C6E88B50",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D2290634-CF61-4562-A41B-F66BD3394454",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D280C64C-856C-45ED-ADED-C0F419A91BE1",
+      "type_id" : 18
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D2D772E5-C792-468B-B2B6-9B838AEAA29D",
+      "text" : "PENDING_EXECUTING",
+      "type_id" : 27
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D3200457-BF2B-4D38-BEBA-8403119C0F09",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D4CB1CA9-2C22-4D92-93E1-2A062667CCB7",
+      "type_id" : 18
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "FBC8D482-ADB5-4B59-83AF-EFDCED6ABF2A",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 1 Copy 4",
+      "object_id" : "D5146D8D-8B2E-402A-8616-B8A3E9100602",
+      "origin" : "78,42",
+      "position_refs" : [
+        "6EEE60B9-5715-4D52-A8F2-17C1F6259786",
+        "D6FBF73E-A501-4A48-93F3-946982A6695B",
+        "BFD136A2-4BA8-4B9E-9C3B-320E5F041E37",
+        "1703EE8C-7017-4438-8904-2197CFE37FC4"
+      ],
+      "segment_end_refs" : [
+        "6EEE60B9-5715-4D52-A8F2-17C1F6259786",
+        "D6FBF73E-A501-4A48-93F3-946982A6695B"
+      ],
+      "segment_refs" : [
+        "C86507D3-C0A8-4AD5-98B7-73E641B16B2B"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D6E86E48-0102-4F32-A3B3-D636FA713FF6",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D6FBF73E-A501-4A48-93F3-946982A6695B",
+      "position_ref" : "86EF494E-C3C7-41B4-A145-8591D675AD5E",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D77D187A-4765-4760-A074-7C36F7B4F8B5",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "D80AB812-A827-457D-82E7-6637E6849740",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DA22D7AA-5AC9-4A83-B7F3-7AA3D4810B26",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DAB178C0-5D4D-453D-B52D-A572102263AF",
+      "text" : "Attempt failed",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DAB46331-B8CB-4697-B4CF-C6FDD2D3915A",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "DAD3B29F-B88F-423E-8E08-527AD3C223D5",
+      "type_id" : 24
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DBCC428F-EC2B-485C-AC4F-33A0AAAC7B33",
+      "text" : "Is executing on worker",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DBF48E76-9A6D-40B8-8897-CDF9F9837132",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DC0B59E7-D472-4B35-A7A7-BB0A653024B1",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "F03D6F72-8EF9-4B14-9CE0-45671F8E3A5C",
+      "content_offset" : "5,-1",
+      "content_tixels" : "024E1882-EA58-4655-AF81-61F7D1DCBEED",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "BEF357ED-9FE3-4658-80DD-B323D59C1BF6",
+      "frame_size" : "21,4",
+      "model_text" : "3542B8A1-5168-4496-97F5-A123A4D093A6",
+      "name" : "Run maybe executing",
+      "object_id" : "DC987C5D-238F-43FC-917A-FFDD362E6FA2",
+      "origin" : "-3,16",
+      "position_refs" : [
+        "BEF357ED-9FE3-4658-80DD-B323D59C1BF6",
+        "3D10EA2D-D500-4A7B-A4CD-13EC6973FDEC",
+        "AA8389E9-4BBB-40B2-8EC8-8B4761442D67",
+        "A9389928-1941-477B-B053-4D53DD5B21E6",
+        "5A9D3C1C-D2CA-48C4-BB90-91A9C04F94E4"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DD31B6F5-1FCF-4BB5-90A7-32AA18684463",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DD41B632-4B22-41A4-8B7F-74CCF9C4F857",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DDA79879-56C9-4DBB-BBFF-E63294C46AFF",
+      "type_id" : 18
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DDF3DF13-4E44-443D-AD0C-07A2A5163F16",
+      "text" : "All Waitpoints complete?",
+      "type_id" : 27
+    },
+    {
+      "background_enabled" : false,
+      "border_tixels" : "04EB1AD6-462B-46CC-9ABB-DC88DFE2DA70",
+      "content_color" : 4292203989,
+      "content_tixels" : "669EBDF1-424A-459B-8335-FA6614A97A77",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "34030465-3432-4DBB-8321-A1CEBF230847",
+      "frame_corner" : 5,
+      "frame_size" : "13,3",
+      "model_text" : "760098EF-14E3-41AF-83C4-2C03D454A870",
+      "name" : "After delay",
+      "object_id" : "DE6094F4-057D-4D9A-BCFF-67BA7EBB7705",
+      "origin" : "7,8",
+      "position_refs" : [
+        "34030465-3432-4DBB-8321-A1CEBF230847"
+      ],
+      "rectangular_border_enabled" : false,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DE810199-FFC9-45FA-9442-7804CC8C1E3C",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DF2DB3AD-A4C6-44DE-AE9F-ECD4FA6E2884",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.5,
+      "object_id" : "DF3F21FD-E308-48CA-B8EB-C49F9EFC372E",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "DF9B03F8-1242-4722-94D3-F214F2DA372E",
+      "type_id" : 18
+    },
+    {
+      "content_tixmap_ref" : "FA2F1A52-10B4-4C34-AAF6-C8792671334D",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_type" : 1,
+      "name" : "Line 7",
+      "object_id" : "E000EC47-592A-4F5A-B115-0E91560AD77F",
+      "origin" : "7,21",
+      "position_refs" : [
+        "7DF0E6FA-1FCD-48C3-A71A-584CAF0DCF38",
+        "030EE553-C5B4-4671-B4BE-CC1C26A33E72"
+      ],
+      "segment_end_refs" : [
+        "7DF0E6FA-1FCD-48C3-A71A-584CAF0DCF38",
+        "030EE553-C5B4-4671-B4BE-CC1C26A33E72"
+      ],
+      "segment_refs" : [
+        "05CD5A1A-3519-475E-85D3-2275644C12D2"
+      ],
+      "type_id" : 5
+    },
+    {
+      "border_tixels" : "C4D83D4B-806F-4845-9437-CDC62C85EFAE",
+      "content_color" : 4292203989,
+      "content_offset" : "-3,0",
+      "content_tixels" : "9B4402E8-E9D1-4ABC-897E-86FA47CE4ECC",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "A9E11E96-8500-4FEE-AB92-A75515528B77",
+      "frame_corner" : 5,
+      "frame_size" : "33,5",
+      "model_text" : "69129880-7542-4DA6-BF2D-7D6C55A6F4F0",
+      "mps_bckg_color" : 4284374622,
+      "name" : "Run triggered",
+      "object_id" : "E02E7718-B76D-47F9-99F0-B0D45C1172D3",
+      "origin" : "31,-14",
+      "position_refs" : [
+        "A9E11E96-8500-4FEE-AB92-A75515528B77",
+        "099C7E4D-A294-45B1-9043-AF80018B7425",
+        "221C766F-6827-4404-8F24-F888990CB512"
+      ],
+      "rectangular_border" : 6,
+      "shadow_color" : 4286151033,
+      "shadow_enabled" : true,
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "border_tixels" : "DDA79879-56C9-4DBB-BBFF-E63294C46AFF",
+      "content_tixels" : "77D829F6-A8E7-4BE8-9711-C1553267E0F5",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "AC419C4C-6981-44A2-92E8-807ABCFDE36F",
+      "frame_size" : "33,5",
+      "model_text" : "9B8A66ED-6B4A-46F6-B456-EE7A0840931A",
+      "mps_border_color" : 4286108927,
+      "name" : "SUSPENDED",
+      "object_id" : "E0A5CBA3-C6FA-4EB0-A09B-1C7A758393B1",
+      "origin" : "7,31",
+      "position_refs" : [
+        "AC419C4C-6981-44A2-92E8-807ABCFDE36F",
+        "352C6968-FB85-4DAC-BA82-57378A7BB4A9",
+        "2B1919EA-4BD8-4664-BB63-20792FDB1AB2",
+        "61922A36-E1E3-4115-9F4F-8DE0B77F1C40",
+        "EFDAF2B7-3716-40F3-9E53-B9443965548A"
+      ],
+      "rectangular_border" : 6,
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E17F14D4-3AD5-45F2-8E0D-33952AF566C0",
+      "point" : "92,20",
+      "type_id" : 11
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "1A1D76DE-F977-485C-B24F-A57751359FFE",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_dash" : {
+        "o" : 0,
+        "p" : 1,
+        "u" : 1
+      },
+      "line_dash_enabled" : true,
+      "name" : "Line 1 Copy 4",
+      "object_id" : "E1AD9E4E-EA41-4F76-BEE6-E33F45DA8C1F",
+      "origin" : "54,54",
+      "position_refs" : [
+        "F8038D9F-3588-4D55-AAF3-EF013F8F0DF3",
+        "7C8AAC4D-B8EF-4A06-99ED-C1179988D12F",
+        "93F53073-E24E-4ADA-98CF-F061A5CE38E2",
+        "6D56CBBC-140B-456B-B68F-A0474C4C34FA"
+      ],
+      "segment_end_refs" : [
+        "F8038D9F-3588-4D55-AAF3-EF013F8F0DF3",
+        "7C8AAC4D-B8EF-4A06-99ED-C1179988D12F"
+      ],
+      "segment_refs" : [
+        "329D9A77-7F34-4103-8145-83F58DE29D84"
+      ],
+      "type_id" : 5
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E2498346-603D-4018-A3E5-A1BE3EC45348",
+      "text" : "QUEUED",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E27C48FD-C2F1-4BFD-BCD9-40A194D14CED",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E2E37DAF-1D27-41B2-8777-2A59E58B2509",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.46296296296296297,
+      "object_id" : "E32B9AB8-825E-4568-A3EE-66ABEC7BB45D",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 1,
+      "object_id" : "E3733850-A7E2-4EE4-ADC6-50AF64791059",
+      "position_ref" : "EFDAF2B7-3716-40F3-9E53-B9443965548A",
+      "type_id" : 10
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E3AA3EBF-D10F-41CE-9127-5AE13677D3BE",
+      "type_id" : 9
+    },
+    {
+      "border_dash_enabled" : {
+        "o" : 1,
+        "p" : 1,
+        "u" : 1
+      },
+      "border_tixel_bl" : "+",
+      "border_tixel_br" : "+",
+      "border_tixel_bs" : "=",
+      "border_tixel_ls" : "|",
+      "border_tixel_rs" : "|",
+      "border_tixel_tl" : "+",
+      "border_tixel_tr" : "+",
+      "border_tixel_ts" : "=",
+      "border_tixels" : "CEAF8086-7518-412A-9A01-224999A6BAB0",
+      "content_tixels" : "5D660488-252F-4EED-AD84-EDFC694FED41",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "frame_anchor_ref" : "3B4EE80E-AEF6-4651-A5E8-AD1FA2F90FFE",
+      "frame_size" : "33,5",
+      "model_text" : "8359781B-23F8-48CA-AB1B-C630F0211638",
+      "mps_border_color" : 4286086655,
+      "name" : "Run Queue",
+      "object_id" : "E4674D10-BD98-4041-AA78-440FEAF31A8B",
+      "origin" : "57,31",
+      "position_refs" : [
+        "3B4EE80E-AEF6-4651-A5E8-AD1FA2F90FFE",
+        "DF2DB3AD-A4C6-44DE-AE9F-ECD4FA6E2884",
+        "AA00A388-301E-49A5-972C-70E7E7DFE300",
+        "C6462A11-A6EA-4908-9472-38C98B2C9E05",
+        "5E8F0012-51A8-4118-AEB1-A56C5C27105F",
+        "0A3B4947-C6CD-40C4-BAFA-CBA4EE2B323E"
+      ],
+      "shadow_intensity" : 1,
+      "shadow_offset" : "1,1",
+      "type_id" : 20
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E4E5E427-4E48-4006-A892-E09E6845999B",
+      "position_ref" : "25AD3E71-2F2B-4E47-B489-FB7E065303DC",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E6698869-9500-4AD0-BA05-813FC0CE876D",
+      "point" : "32,9",
+      "type_id" : 11
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E689B2D6-CC08-4AF4-8880-EE6420A515DD",
+      "text" : "RUN_CREATED",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "head_type" : 8,
+      "object_id" : "E7BEF7A9-A403-4363-83B4-85B028152517",
+      "position_ref" : "5FCF3E5F-18B2-40F8-AB26-F35E4CD66ECF",
+      "type_id" : 10
+    },
+    {
+      "color" : 4287822336,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E8030752-5278-47FF-B213-75C860FF1113",
+      "text" : "FINISHED",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E83D0E5B-ABF5-4997-8441-C237E0139DB5",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.5,
+      "object_id" : "E94E855B-4E74-4A48-A974-E50A6B2FD50B",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E966926D-1590-4E8F-BA71-624870F049D2",
+      "position_ref" : "84587447-C1DE-46AF-BBC2-002E84B57097",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E978FB9C-7321-48A6-8D65-88F7C0462A51",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "E9A668B9-4912-428A-A6A1-9760CBDB8318",
+      "type_id" : 18
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EC386826-2B8F-4117-83FD-C07D588CC613",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EC920DF0-C4DC-4A1A-9616-C2727B098E43",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "ECD8E365-42A8-4F12-A81A-1F14F2246B7A",
+      "position_ref" : "84E52FAC-959F-40F0-B5EE-1328154051FE",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "ECE104FA-6D00-4568-A0F7-92E130B37823",
+      "rect_position" : 20,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "ED7584A1-BCBC-4193-96E5-CEE9C1543F41",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EE44FBCF-D451-4CA3-A777-863286A87D69",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EEC56D34-7624-4EE6-AE15-8A93446EBECF",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EF81545C-6F7F-403D-B5F7-3D7D44F4BE0A",
+      "position_ref" : "280FEFB3-4B6E-496A-B1FD-C1EA8177F3FC",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EF82D23F-D757-400A-8159-76DC891503F5",
+      "point" : "125,22",
+      "type_id" : 11
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EF909D44-C625-4EFB-B134-15ACE3B8C913",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "EFDAF2B7-3716-40F3-9E53-B9443965548A",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F03D6F72-8EF9-4B14-9CE0-45671F8E3A5C",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F05788FC-EAC4-4E3B-BEE6-3E1129EC1BE0",
+      "point" : "94,20",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F068079D-A8E9-4132-A2FA-F1DAACF5DE4B",
+      "type_id" : 18
+    },
+    {
+      "color" : 4286108927,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F276D10C-284E-4470-B119-77C7BD94CCC9",
+      "text" : "DELAYED",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F2DA4D10-715D-436C-80F2-BBF29898B919",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F4061998-DD69-452D-BC81-261F799034C2",
+      "position_ref" : "D0156743-703F-4B2D-A02D-97A5CAEDFB29",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F40CBAB0-BE5D-413E-9DBD-5A6F83201311",
+      "position_ref" : "38E33C5B-6FD5-492F-9F8B-7A56D55130D1",
+      "type_id" : 10
+    },
+    {
+      "content_color" : 4292203989,
+      "content_tixmap_ref" : "664900DA-7DA3-4D0F-BD1E-F8D4EEF5AA4B",
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "name" : "Line 1 Copy 4",
+      "object_id" : "F4229049-751E-4459-94C0-A6DE9FF09DBE",
+      "origin" : "38,55",
+      "position_refs" : [
+        "F7A11CF7-D99E-4260-B96B-90F91BF41A0D",
+        "0CE3B0B5-2ED3-4CD7-93A6-DA575E38B2B9",
+        "434C5097-DE3B-4817-8A7C-9D2F57D557C6"
+      ],
+      "segment_end_refs" : [
+        "F7A11CF7-D99E-4260-B96B-90F91BF41A0D",
+        "0CE3B0B5-2ED3-4CD7-93A6-DA575E38B2B9"
+      ],
+      "segment_refs" : [
+        "8D4E6A8A-A765-4B8B-A44E-4E5E0FF5C15A"
+      ],
+      "type_id" : 5
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F465F56F-4975-4EC7-8A2C-8E21EC58B6CA",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F49C6867-AF1B-48BE-B405-AD773508A1F4",
+      "rect_position" : 16,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F4E29C50-845C-42DB-B3B9-BBBC44B76C50",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F4F19348-2079-41F4-B650-6A62F7AA8768",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F7A11CF7-D99E-4260-B96B-90F91BF41A0D",
+      "position_ref" : "0FC22524-992E-4A27-B8AE-B254C8C665EA",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F8038D9F-3588-4D55-AAF3-EF013F8F0DF3",
+      "position_ref" : "BB47437C-904E-4F3C-A152-F5F18AE81470",
+      "type_id" : 10
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F8783797-AD8A-481F-B4D9-A8F901624AA4",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F90D0FC8-7097-4E44-9390-88F245E10DD2",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "F9BB3DE2-0E7F-4936-8E97-6EC0F74DAC98",
+      "point" : "50,8",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FA2F1A52-10B4-4C34-AAF6-C8792671334D",
+      "type_id" : 18
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.45454545454545453,
+      "object_id" : "FA39209D-213F-4EE3-8E86-F48548F9BFD4",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FA43E6F4-ADDF-4C02-BA79-CFF11F275A55",
+      "rect_position" : 13,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FA9EB949-3D30-4945-A249-8B9826E0EE93",
+      "point" : "70,59",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FBBAD83B-0F19-4E4B-A408-AAA16493114E",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FBC8D482-ADB5-4B59-83AF-EFDCED6ABF2A",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FC13BD1B-F9D6-425C-A09F-5D05A4ABD176",
+      "point" : "91,20",
+      "type_id" : 11
+    },
+    {
+      "color" : 4292203989,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FC357827-3DD5-49F3-927A-462D8D2704F7",
+      "text" : "Delay\/\ndebounce",
+      "type_id" : 27
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FC8D371A-D317-4A4D-B6E3-1A56DA60B5FC",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FCBA08D5-02A0-4C7A-875C-411E678AFC67",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FCEA7123-2AD0-4563-936A-3DFB06F5739E",
+      "type_id" : 18
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FD5F4C49-5268-4584-AB9C-EC60DE5F21DE",
+      "point" : "66,15",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FD7FC36A-7576-4AC4-9621-D73179475822",
+      "point" : "59,23",
+      "type_id" : 11
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FD9D4EB7-FDEB-44B6-B8BA-499210B14F47",
+      "rect_position" : 12,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FDFCEAA1-416B-45CB-843B-B151C3E5625D",
+      "rect_position" : 19,
+      "type_id" : 12
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FE605DB0-B757-4D29-8D13-946FB7988215",
+      "position_ref" : "D19A90AA-C448-4401-BAF5-C5905BABC5DA",
+      "type_id" : 10
+    },
+    {
+      "direction" : 1,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FE60719A-2605-42D7-AD2A-510BEE132435",
+      "type_id" : 9
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FEB0F91E-2CAE-4F20-BFF8-12C89B0DBA42",
+      "rect_position" : 15,
+      "type_id" : 12
+    },
+    {
+      "direction" : 2,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FEFC7899-1048-4191-AAAB-2846D839C9AF",
+      "type_id" : 9
+    },
+    {
+      "dirset" : 0,
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "line_pt_idx" : -1,
+      "line_pt_rel" : 0.40000000000000002,
+      "object_id" : "FEFF07F0-0D3A-4CCE-B4D2-45C4EB951365",
+      "type_id" : 24
+    },
+    {
+      "doc_ref" : "9C4FA173-1F3C-42DC-91F6-C65051CC9B1D",
+      "object_id" : "FF77AC96-AFF7-4C74-8ACC-A6324ED4702E",
+      "rect_position" : 12,
+      "type_id" : 12
+    }
+  ]
+}
\ No newline at end of file
diff --git a/internal-packages/run-engine/src/batch-queue/completionTracker.ts b/internal-packages/run-engine/src/batch-queue/completionTracker.ts
index f6570cfc54e..05793002fe5 100644
--- a/internal-packages/run-engine/src/batch-queue/completionTracker.ts
+++ b/internal-packages/run-engine/src/batch-queue/completionTracker.ts
@@ -45,9 +45,9 @@ export class BatchCompletionTracker {
   }) {
     this.redis = createRedisClient(options.redis);
     this.logger = options.logger ?? {
-      debug: () => {},
-      info: () => {},
-      error: () => {},
+      debug: () => { },
+      info: () => { },
+      error: () => { },
     };
 
     this.#registerCommands();
diff --git a/internal-packages/run-engine/src/batch-queue/index.ts b/internal-packages/run-engine/src/batch-queue/index.ts
index bf9c15beba2..96a827b53ce 100644
--- a/internal-packages/run-engine/src/batch-queue/index.ts
+++ b/internal-packages/run-engine/src/batch-queue/index.ts
@@ -1,12 +1,26 @@
-import { createRedisClient, type Redis, type RedisOptions } from "@internal/redis";
-import type { Counter, Histogram, Meter } from "@internal/tracing";
+import { createRedisClient, type Redis } from "@internal/redis";
 import {
-  FairQueue,
-  DRRScheduler,
+  startSpan,
+  type Counter,
+  type Histogram,
+  type Meter,
+  type ObservableGauge,
+  type Span,
+  type Tracer,
+} from "@internal/tracing";
+import { Logger } from "@trigger.dev/core/logger";
+import {
+  BatchedSpanManager,
   CallbackFairQueueKeyProducer,
+  DRRScheduler,
+  FairQueue,
+  ExponentialBackoffRetry,
+  isAbortError,
+  WorkerQueueManager,
   type FairQueueOptions,
+  type GlobalRateLimiter,
 } from "@trigger.dev/redis-worker";
-import { Logger } from "@trigger.dev/core/logger";
+import { BatchCompletionTracker } from "./completionTracker.js";
 import type {
   BatchCompletionCallback,
   BatchItem,
@@ -18,10 +32,9 @@ import type {
   ProcessBatchItemCallback,
 } from "./types.js";
 import { BatchItemPayload as BatchItemPayloadSchema } from "./types.js";
-import { BatchCompletionTracker } from "./completionTracker.js";
 
-export type { BatchQueueOptions, InitializeBatchOptions, CompleteBatchResult } from "./types.js";
 export { BatchCompletionTracker } from "./completionTracker.js";
+export type { BatchQueueOptions, CompleteBatchResult, InitializeBatchOptions } from "./types.js";
 
 /**
  * BatchQueue manages batch trigger processing with fair scheduling using
@@ -41,16 +54,32 @@ export { BatchCompletionTracker } from "./completionTracker.js";
 // Redis key for environment concurrency limits
 const ENV_CONCURRENCY_KEY_PREFIX = "batch:env_concurrency";
 
+// Single worker queue ID for all batch items
+// BatchQueue uses a single shared worker queue - FairQueue handles fair scheduling,
+// then all messages are routed to this queue for BatchQueue's own consumer loop.
+const BATCH_WORKER_QUEUE_ID = "batch-worker-queue";
+
 export class BatchQueue {
   private fairQueue: FairQueue<typeof BatchItemPayloadSchema>;
+  private workerQueueManager: WorkerQueueManager;
   private completionTracker: BatchCompletionTracker;
   private logger: Logger;
+  private tracer?: Tracer;
   private concurrencyRedis: Redis;
   private defaultConcurrency: number;
+  private maxAttempts: number;
 
   private processItemCallback?: ProcessBatchItemCallback;
   private completionCallback?: BatchCompletionCallback;
 
+  // Consumer loop state
+  private isRunning = false;
+  private abortController: AbortController;
+  private workerQueueConsumerLoops: Promise<void>[] = [];
+  private workerQueueBlockingTimeoutSeconds: number;
+  private globalRateLimiter?: GlobalRateLimiter;
+  private batchedSpanManager: BatchedSpanManager;
+
   // Metrics
   private batchesEnqueuedCounter?: Counter;
   private itemsEnqueuedCounter?: Counter;
@@ -59,10 +88,17 @@ export class BatchQueue {
   private batchCompletedCounter?: Counter;
   private batchProcessingDurationHistogram?: Histogram;
   private itemQueueTimeHistogram?: Histogram;
+  private workerQueueLengthGauge?: ObservableGauge;
+  private rateLimitDeniedCounter?: Counter;
 
   constructor(private options: BatchQueueOptions) {
     this.logger = options.logger ?? new Logger("BatchQueue", options.logLevel ?? "info");
+    this.tracer = options.tracer;
     this.defaultConcurrency = options.defaultConcurrency ?? 10;
+    this.maxAttempts = options.retry?.maxAttempts ?? 1;
+    this.abortController = new AbortController();
+    this.workerQueueBlockingTimeoutSeconds = options.workerQueueBlockingTimeoutSeconds ?? 10;
+    this.globalRateLimiter = options.globalRateLimiter;
 
     // Initialize metrics if meter is provided
     if (options.meter) {
@@ -99,6 +135,7 @@ export class BatchQueue {
       keys: keyProducer,
       quantum: options.drr.quantum,
       maxDeficit: options.drr.maxDeficit,
+      masterQueueLimit: options.drr.masterQueueLimit,
       logger: {
         debug: (msg, ctx) => this.logger.debug(msg, ctx),
         error: (msg, ctx) => this.logger.error(msg, ctx),
@@ -106,21 +143,26 @@ export class BatchQueue {
     });
 
     // Create FairQueue with telemetry and environment-based concurrency limiting
+    // FairQueue handles fair scheduling and routes messages to the batch worker queue
+    // BatchQueue runs its own consumer loop to process messages from the worker queue
     const fairQueueOptions: FairQueueOptions<typeof BatchItemPayloadSchema> = {
       redis: options.redis,
       keys: keyProducer,
       scheduler,
       payloadSchema: BatchItemPayloadSchema,
       validateOnEnqueue: false, // We control the payload
-      shardCount: 1, // Batches don't need sharding
+      shardCount: options.shardCount ?? 1,
       consumerCount: options.consumerCount,
       consumerIntervalMs: options.consumerIntervalMs,
       visibilityTimeoutMs: 60_000, // 1 minute for batch item processing
       startConsumers: false, // We control when to start
       cooloff: {
-        enabled: true,
-        threshold: 5,
-        periodMs: 5_000,
+        enabled: false,
+      },
+      // Worker queue configuration - FairQueue routes all messages to our single worker queue
+      workerQueue: {
+        // All batch items go to the same worker queue - BatchQueue handles consumption
+        resolveWorkerQueue: () => BATCH_WORKER_QUEUE_ID,
       },
       // Concurrency group based on tenant (environment)
       // This limits how many batch items can be processed concurrently per environment
@@ -136,10 +178,26 @@ export class BatchQueue {
           },
         },
       ],
-      // Optional global rate limiter to limit max items/sec across all consumers
-      globalRateLimiter: options.globalRateLimiter,
-      // No retry for batch items - failures are recorded and batch completes
-      // Omit retry config entirely to disable retry and DLQ
+      // Worker queue depth cap to prevent unbounded growth (protects visibility timeouts)
+      workerQueueMaxDepth: options.workerQueueMaxDepth,
+      workerQueueDepthCheckId: BATCH_WORKER_QUEUE_ID,
+      // Enable retry with DLQ disabled when retry config is provided.
+      // BatchQueue handles the "final failure" in its own processing loop,
+      // so we don't need the DLQ - we just need the retry scheduling.
+      ...(options.retry
+        ? {
+          retry: {
+            strategy: new ExponentialBackoffRetry({
+              maxAttempts: options.retry.maxAttempts,
+              minTimeoutInMs: options.retry.minTimeoutInMs ?? 1_000,
+              maxTimeoutInMs: options.retry.maxTimeoutInMs ?? 30_000,
+              factor: options.retry.factor ?? 2,
+              randomize: options.retry.randomize ?? true,
+            }),
+            deadLetterQueue: false,
+          },
+        }
+        : {}),
       logger: this.logger,
       tracer: options.tracer,
       meter: options.meter,
@@ -148,6 +206,24 @@ export class BatchQueue {
 
     this.fairQueue = new FairQueue(fairQueueOptions);
 
+    // Create worker queue manager for consuming from the batch worker queue
+    this.workerQueueManager = new WorkerQueueManager({
+      redis: options.redis,
+      keys: keyProducer,
+      logger: {
+        debug: (msg, ctx) => this.logger.debug(msg, ctx),
+        error: (msg, ctx) => this.logger.error(msg, ctx),
+      },
+    });
+
+    // Initialize batched span manager for worker queue consumer tracing
+    this.batchedSpanManager = new BatchedSpanManager({
+      tracer: options.tracer,
+      name: "batch-queue-worker",
+      maxIterations: options.consumerTraceMaxIterations ?? 1000,
+      timeoutSeconds: options.consumerTraceTimeoutSeconds ?? 60,
+    });
+
     // Create completion tracker
     this.completionTracker = new BatchCompletionTracker({
       redis: options.redis,
@@ -158,11 +234,6 @@ export class BatchQueue {
       },
     });
 
-    // Set up message handler
-    this.fairQueue.onMessage(async (ctx) => {
-      await this.#handleMessage(ctx);
-    });
-
     // Register telemetry gauge callbacks for observable metrics
     // Note: observedTenants is not provided since tenant list is dynamic
     this.fairQueue.registerTelemetryGauges();
@@ -225,6 +296,7 @@ export class BatchQueue {
       realtimeStreamsVersion: options.realtimeStreamsVersion,
       idempotencyKey: options.idempotencyKey,
       processingConcurrency: options.processingConcurrency,
+      triggerSource: options.triggerSource,
     };
 
     // Store metadata in completion tracker
@@ -238,8 +310,7 @@ export class BatchQueue {
 
     // Record metric
     this.batchesEnqueuedCounter?.add(1, {
-      envId: options.environmentId,
-      itemCount: options.runCount,
+      environment_type: options.environmentType,
       streaming: true,
     });
 
@@ -309,7 +380,7 @@ export class BatchQueue {
     });
 
     // Record metric
-    this.itemsEnqueuedCounter?.add(1, { envId });
+    this.itemsEnqueuedCounter?.add(1, { environment_type: meta.environmentType });
 
     this.logger.debug("Batch item enqueued", {
       batchId,
@@ -401,13 +472,31 @@ export class BatchQueue {
 
   /**
    * Start the consumer loops.
+   * FairQueue runs the master queue consumer loop (claim and push to worker queue).
+   * BatchQueue runs its own worker queue consumer loops to process messages.
    */
   start(): void {
+    if (this.isRunning) {
+      return;
+    }
+
+    this.isRunning = true;
+    this.abortController = new AbortController();
+
+    // Start FairQueue's master queue consumers (routes messages to worker queue)
     this.fairQueue.start();
+
+    // Start worker queue consumer loops
+    for (let consumerId = 0; consumerId < this.options.consumerCount; consumerId++) {
+      const loop = this.#runWorkerQueueConsumerLoop(consumerId);
+      this.workerQueueConsumerLoops.push(loop);
+    }
+
     this.logger.info("BatchQueue consumers started", {
       consumerCount: this.options.consumerCount,
       intervalMs: this.options.consumerIntervalMs,
       drrQuantum: this.options.drr.quantum,
+      workerQueueId: BATCH_WORKER_QUEUE_ID,
     });
   }
 
@@ -415,7 +504,20 @@ export class BatchQueue {
    * Stop the consumer loops gracefully.
    */
   async stop(): Promise<void> {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.isRunning = false;
+    this.abortController.abort();
+
+    // Stop FairQueue's master queue consumers
     await this.fairQueue.stop();
+
+    // Wait for worker queue consumer loops to finish
+    await Promise.allSettled(this.workerQueueConsumerLoops);
+    this.workerQueueConsumerLoops = [];
+
     this.logger.info("BatchQueue consumers stopped");
   }
 
@@ -423,7 +525,13 @@ export class BatchQueue {
    * Close the BatchQueue and all Redis connections.
    */
   async close(): Promise<void> {
+    await this.stop();
+
+    // Clean up any remaining batched spans (safety net for spans not cleaned up by consumer loops)
+    this.batchedSpanManager.cleanupAll();
+
     await this.fairQueue.close();
+    await this.workerQueueManager.close();
     await this.completionTracker.close();
     await this.concurrencyRedis.quit();
   }
@@ -505,196 +613,489 @@ export class BatchQueue {
       description: "Time from item enqueue to processing start",
       unit: "ms",
     });
+
+    this.rateLimitDeniedCounter = meter.createCounter("batch_queue.rate_limit_denied", {
+      description: "Number of times the global rate limiter denied processing",
+      unit: "denials",
+    });
+
+    this.workerQueueLengthGauge = meter.createObservableGauge("batch_queue.worker_queue.length", {
+      description: "Number of items waiting in the batch worker queue",
+      unit: "items",
+    });
+
+    this.workerQueueLengthGauge.addCallback(async (observableResult) => {
+      const length = await this.workerQueueManager.getLength(BATCH_WORKER_QUEUE_ID);
+      observableResult.observe(length);
+    });
   }
 
   // ============================================================================
-  // Private - Message Handling
+  // Private - Worker Queue Consumer Loop
   // ============================================================================
 
-  async #handleMessage(ctx: {
-    message: {
-      id: string;
-      queueId: string;
-      payload: BatchItemPayload;
-      timestamp: number;
-      attempt: number;
-    };
-    queue: { id: string; tenantId: string };
-    consumerId: string;
-    heartbeat: () => Promise<boolean>;
-    complete: () => Promise<void>;
-    release: () => Promise<void>;
-    fail: (error?: Error) => Promise<void>;
-  }): Promise<void> {
-    const { batchId, friendlyId, itemIndex, item } = ctx.message.payload;
-
-    // Record queue time metric (time from enqueue to processing)
-    const queueTimeMs = Date.now() - ctx.message.timestamp;
-    this.itemQueueTimeHistogram?.record(queueTimeMs, { envId: ctx.queue.tenantId });
-
-    this.logger.debug("Processing batch item", {
-      batchId,
-      friendlyId,
-      itemIndex,
-      task: item.task,
-      consumerId: ctx.consumerId,
-      attempt: ctx.message.attempt,
-      queueTimeMs,
-    });
+  /**
+   * Run a worker queue consumer loop.
+   * This pops messages from the batch worker queue and processes them.
+   */
+  async #runWorkerQueueConsumerLoop(consumerId: number): Promise<void> {
+    const loopId = `batch-worker-${consumerId}`;
 
-    if (!this.processItemCallback) {
-      this.logger.error("No process item callback set", { batchId, itemIndex });
-      // Still complete the message to avoid blocking
-      await ctx.complete();
-      return;
+    // Initialize batched span tracking for this loop
+    this.batchedSpanManager.initializeLoop(loopId);
+
+    try {
+      while (this.isRunning) {
+        if (!this.processItemCallback) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          continue;
+        }
+
+        try {
+          // Rate limit per-item at the processing level (1 token per message).
+          // Loop until allowed so multiple consumers don't all rush through after one sleep.
+          if (this.globalRateLimiter) {
+            while (this.isRunning) {
+              const result = await this.globalRateLimiter.limit();
+              if (result.allowed) {
+                break;
+              }
+              this.rateLimitDeniedCounter?.add(1);
+              const waitMs = Math.max(10, (result.resetAt ?? Date.now()) - Date.now());
+              if (waitMs > 0) {
+                await new Promise<void>((resolve, reject) => {
+                  const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(this.abortController.signal.reason);
+                  };
+                  const timer = setTimeout(() => {
+                    // Must remove listener when timeout fires, otherwise listeners accumulate
+                    // (the { once: true } option only removes on abort, not on timeout)
+                    this.abortController.signal.removeEventListener("abort", onAbort);
+                    resolve();
+                  }, waitMs);
+                  if (this.abortController.signal.aborted) {
+                    clearTimeout(timer);
+                    reject(this.abortController.signal.reason);
+                    return;
+                  }
+                  this.abortController.signal.addEventListener("abort", onAbort, { once: true });
+                });
+              }
+            }
+            if (!this.isRunning) {
+              break;
+            }
+          }
+
+          await this.batchedSpanManager.withBatchedSpan(
+            loopId,
+            async (span) => {
+              span.setAttribute("consumer_id", consumerId);
+
+              // Blocking pop from worker queue
+              const messageKey = await this.workerQueueManager.blockingPop(
+                BATCH_WORKER_QUEUE_ID,
+                this.workerQueueBlockingTimeoutSeconds,
+                this.abortController.signal
+              );
+
+              if (!messageKey) {
+                this.batchedSpanManager.incrementStat(loopId, "empty_iterations");
+                return false; // Timeout, no work
+              }
+
+              // Parse message key (format: "messageId:queueId")
+              const colonIndex = messageKey.indexOf(":");
+              if (colonIndex === -1) {
+                this.logger.error("Invalid message key format", { messageKey });
+                this.batchedSpanManager.incrementStat(loopId, "invalid_message_keys");
+                return false;
+              }
+
+              const messageId = messageKey.substring(0, colonIndex);
+              const queueId = messageKey.substring(colonIndex + 1);
+
+              await this.#handleMessage(loopId, messageId, queueId);
+              this.batchedSpanManager.incrementStat(loopId, "messages_processed");
+              return true; // Had work
+            },
+            {
+              iterationSpanName: "processWorkerQueueMessage",
+              attributes: { consumer_id: consumerId },
+            }
+          );
+        } catch (error) {
+          if (this.abortController.signal.aborted) {
+            break;
+          }
+          this.logger.error("Worker queue consumer error", {
+            loopId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          this.batchedSpanManager.markForRotation(loopId);
+        }
+      }
+    } catch (error) {
+      if (isAbortError(error)) {
+        this.logger.debug("Worker queue consumer aborted", { loopId });
+        this.batchedSpanManager.cleanup(loopId);
+        return;
+      }
+      throw error;
+    } finally {
+      this.batchedSpanManager.cleanup(loopId);
     }
+  }
 
-    // Get batch metadata
-    const meta = await this.completionTracker.getMeta(batchId);
-    if (!meta) {
-      this.logger.error("Batch metadata not found", { batchId, itemIndex });
-      await ctx.complete();
+  // ============================================================================
+  // Private - Message Handling
+  // ============================================================================
+
+  async #handleMessage(consumerId: string, messageId: string, queueId: string): Promise<void> {
+    // Get message data from FairQueue's in-flight storage
+    const storedMessage = await this.fairQueue.getMessageData(messageId, queueId);
+
+    if (!storedMessage) {
+      this.logger.error("Message not found in in-flight data", { messageId, queueId });
+      await this.fairQueue.completeMessage(messageId, queueId);
       return;
     }
 
-    let processedCount: number;
+    const { batchId, friendlyId, itemIndex, item } = storedMessage.payload;
 
-    try {
-      const result = await this.processItemCallback({
+    return this.#startSpan("BatchQueue.handleMessage", async (span) => {
+      span?.setAttributes({
+        "batch.id": batchId,
+        "batch.friendlyId": friendlyId,
+        "batch.itemIndex": itemIndex,
+        "batch.task": item.task,
+        "batch.consumerId": consumerId,
+        "batch.attempt": storedMessage.attempt,
+      });
+
+      // Calculate queue time (time from enqueue to processing)
+      const queueTimeMs = Date.now() - storedMessage.timestamp;
+      span?.setAttribute("batch.queueTimeMs", queueTimeMs);
+
+      this.logger.debug("Processing batch item", {
         batchId,
         friendlyId,
         itemIndex,
-        item,
-        meta,
+        task: item.task,
+        consumerId,
+        attempt: storedMessage.attempt,
+        queueTimeMs,
       });
 
-      if (result.success) {
-        // Pass itemIndex for idempotency - prevents double-counting on redelivery
-        processedCount = await this.completionTracker.recordSuccess(
-          batchId,
-          result.runId,
-          itemIndex
+      if (!this.processItemCallback) {
+        this.logger.error("No process item callback set", { batchId, itemIndex });
+        // Still complete the message to avoid blocking
+        await this.fairQueue.completeMessage(messageId, queueId);
+        return;
+      }
+
+      // Get batch metadata
+      const meta = await this.#startSpan("BatchQueue.getMeta", async () => {
+        return this.completionTracker.getMeta(batchId);
+      });
+
+      if (!meta) {
+        this.logger.error("Batch metadata not found", { batchId, itemIndex });
+        await this.fairQueue.completeMessage(messageId, queueId);
+        return;
+      }
+
+      // Record queue time metric (requires meta for environment_type)
+      this.itemQueueTimeHistogram?.record(queueTimeMs, { environment_type: meta.environmentType });
+
+      span?.setAttributes({
+        "batch.runCount": meta.runCount,
+        "batch.environmentId": meta.environmentId,
+      });
+
+      const attempt = storedMessage.attempt;
+      const isFinalAttempt = attempt >= this.maxAttempts;
+
+      let processedCount: number;
+
+      try {
+        const result = await this.#startSpan(
+          "BatchQueue.processItemCallback",
+          async (innerSpan) => {
+            innerSpan?.setAttributes({
+              "batch.id": batchId,
+              "batch.itemIndex": itemIndex,
+              "batch.task": item.task,
+            });
+            return this.processItemCallback!({
+              batchId,
+              friendlyId,
+              itemIndex,
+              item,
+              meta,
+              attempt,
+              isFinalAttempt,
+            });
+          }
+        );
+
+        if (result.success) {
+          span?.setAttribute("batch.result", "success");
+          span?.setAttribute("batch.runId", result.runId);
+
+          // Pass itemIndex for idempotency - prevents double-counting on redelivery
+          processedCount = await this.#startSpan("BatchQueue.recordSuccess", async () => {
+            return this.completionTracker.recordSuccess(batchId, result.runId, itemIndex);
+          });
+
+          this.itemsProcessedCounter?.add(1, { environment_type: meta.environmentType });
+          this.logger.debug("Batch item processed successfully", {
+            batchId,
+            itemIndex,
+            runId: result.runId,
+            processedCount,
+            expectedCount: meta.runCount,
+            attempt,
+          });
+        } else {
+          span?.setAttribute("batch.result", "failure");
+          span?.setAttribute("batch.error", result.error);
+          if (result.errorCode) {
+            span?.setAttribute("batch.errorCode", result.errorCode);
+          }
+
+          // If retries are available, use FairQueue retry scheduling
+          if (!isFinalAttempt) {
+            span?.setAttribute("batch.retry", true);
+            span?.setAttribute("batch.attempt", attempt);
+
+            this.logger.warn("Batch item failed, scheduling retry via FairQueue", {
+              batchId,
+              itemIndex,
+              attempt,
+              maxAttempts: this.maxAttempts,
+              error: result.error,
+            });
+
+            await this.#startSpan("BatchQueue.failMessage", async () => {
+              return this.fairQueue.failMessage(
+                messageId,
+                queueId,
+                new Error(result.error)
+              );
+            });
+
+            // Don't record failure or check completion - message will be retried
+            return;
+          }
+
+          // Final attempt exhausted - record permanent failure
+          const payloadStr = await this.#startSpan(
+            "BatchQueue.serializePayload",
+            async (innerSpan) => {
+              const str =
+                item.payload === undefined || item.payload === null
+                  ? "{}"
+                  : typeof item.payload === "string"
+                    ? item.payload
+                    : JSON.stringify(item.payload);
+              innerSpan?.setAttribute("batch.payloadSize", str.length);
+              return str;
+            }
+          );
+
+          processedCount = await this.#startSpan("BatchQueue.recordFailure", async () => {
+            return this.completionTracker.recordFailure(batchId, {
+              index: itemIndex,
+              taskIdentifier: item.task,
+              payload: payloadStr,
+              options: item.options,
+              error: result.error,
+              errorCode: result.errorCode,
+            });
+          });
+
+          this.itemsFailedCounter?.add(1, {
+            environment_type: meta.environmentType,
+            errorCode: result.errorCode,
+          });
+
+          this.logger.error("Batch item processing failed after all attempts", {
+            batchId,
+            itemIndex,
+            error: result.error,
+            processedCount,
+            expectedCount: meta.runCount,
+            attempts: attempt,
+          });
+        }
+      } catch (error) {
+        span?.setAttribute("batch.result", "unexpected_error");
+        span?.setAttribute("batch.error", error instanceof Error ? error.message : String(error));
+
+        // If retries are available, use FairQueue retry scheduling for unexpected errors too
+        if (!isFinalAttempt) {
+          span?.setAttribute("batch.retry", true);
+          span?.setAttribute("batch.attempt", attempt);
+
+          this.logger.warn("Batch item threw unexpected error, scheduling retry", {
+            batchId,
+            itemIndex,
+            attempt,
+            maxAttempts: this.maxAttempts,
+            error: error instanceof Error ? error.message : String(error),
+          });
+
+          await this.#startSpan("BatchQueue.failMessage", async () => {
+            return this.fairQueue.failMessage(
+              messageId,
+              queueId,
+              error instanceof Error ? error : new Error(String(error))
+            );
+          });
+
+          return;
+        }
+
+        // Final attempt - record permanent failure
+        const payloadStr = await this.#startSpan(
+          "BatchQueue.serializePayload",
+          async (innerSpan) => {
+            const str =
+              item.payload === undefined || item.payload === null
+                ? "{}"
+                : typeof item.payload === "string"
+                  ? item.payload
+                  : JSON.stringify(item.payload);
+            innerSpan?.setAttribute("batch.payloadSize", str.length);
+            return str;
+          }
         );
-        this.itemsProcessedCounter?.add(1, { envId: meta.environmentId });
-        this.logger.debug("Batch item processed successfully", {
+
+        processedCount = await this.#startSpan("BatchQueue.recordFailure", async () => {
+          return this.completionTracker.recordFailure(batchId, {
+            index: itemIndex,
+            taskIdentifier: item.task,
+            payload: payloadStr,
+            options: item.options,
+            error: error instanceof Error ? error.message : String(error),
+            errorCode: "UNEXPECTED_ERROR",
+          });
+        });
+
+        this.itemsFailedCounter?.add(1, {
+          environment_type: meta.environmentType,
+          errorCode: "UNEXPECTED_ERROR",
+        });
+        this.logger.error("Unexpected error processing batch item after all attempts", {
           batchId,
           itemIndex,
-          runId: result.runId,
+          error: error instanceof Error ? error.message : String(error),
           processedCount,
           expectedCount: meta.runCount,
+          attempts: attempt,
         });
-      } else {
-        // For offloaded payloads (payloadType: "application/store"), payload is already an R2 path
-        // For inline payloads, store the full payload - it's under the offload threshold anyway
-        const payloadStr =
-          typeof item.payload === "string" ? item.payload : JSON.stringify(item.payload);
-
-        processedCount = await this.completionTracker.recordFailure(batchId, {
-          index: itemIndex,
-          taskIdentifier: item.task,
-          payload: payloadStr,
-          options: item.options,
-          error: result.error,
-          errorCode: result.errorCode,
-        });
+      }
+
+      span?.setAttribute("batch.processedCount", processedCount);
 
-        this.itemsFailedCounter?.add(1, { envId: meta.environmentId, errorCode: result.errorCode });
+      // Complete the FairQueue message
+      // This must happen after recording success/failure to ensure the counter
+      // is updated before the message is considered done
+      await this.#startSpan("BatchQueue.completeMessage", async () => {
+        return this.fairQueue.completeMessage(messageId, queueId);
+      });
 
-        this.logger.error("Batch item processing failed", {
+      // Check if all items have been processed using atomic counter
+      // This is safe even with multiple concurrent consumers because
+      // the processedCount is atomically incremented and we only trigger
+      // finalization when we see the exact final count
+      if (processedCount === meta.runCount) {
+        this.logger.debug("All items processed, finalizing batch", {
           batchId,
-          itemIndex,
-          error: result.error,
           processedCount,
           expectedCount: meta.runCount,
         });
+        await this.#finalizeBatch(batchId, meta);
       }
-    } catch (error) {
-      // Unexpected error during processing
-      // For offloaded payloads, payload is an R2 path; for inline payloads, store full payload
-      const payloadStr =
-        typeof item.payload === "string" ? item.payload : JSON.stringify(item.payload);
-
-      processedCount = await this.completionTracker.recordFailure(batchId, {
-        index: itemIndex,
-        taskIdentifier: item.task,
-        payload: payloadStr,
-        options: item.options,
-        error: error instanceof Error ? error.message : String(error),
-        errorCode: "UNEXPECTED_ERROR",
-      });
-
-      this.itemsFailedCounter?.add(1, { envId: meta.environmentId, errorCode: "UNEXPECTED_ERROR" });
-      this.logger.error("Unexpected error processing batch item", {
-        batchId,
-        itemIndex,
-        error: error instanceof Error ? error.message : String(error),
-        processedCount,
-        expectedCount: meta.runCount,
-      });
-    }
-
-    // Complete the FairQueue message (no retry for batch items)
-    // This must happen after recording success/failure to ensure the counter
-    // is updated before the message is considered done
-    await ctx.complete();
-
-    // Check if all items have been processed using atomic counter
-    // This is safe even with multiple concurrent consumers because
-    // the processedCount is atomically incremented and we only trigger
-    // finalization when we see the exact final count
-    if (processedCount === meta.runCount) {
-      this.logger.debug("All items processed, finalizing batch", {
-        batchId,
-        processedCount,
-        expectedCount: meta.runCount,
-      });
-      await this.#finalizeBatch(batchId, meta);
-    }
+    });
   }
 
   /**
    * Finalize a completed batch: gather results and call completion callback.
    */
   async #finalizeBatch(batchId: string, meta: BatchMeta): Promise<void> {
-    const result = await this.completionTracker.getCompletionResult(batchId);
+    return this.#startSpan("BatchQueue.finalizeBatch", async (span) => {
+      span?.setAttributes({
+        "batch.id": batchId,
+        "batch.friendlyId": meta.friendlyId,
+        "batch.runCount": meta.runCount,
+        "batch.environmentId": meta.environmentId,
+      });
 
-    // Record metrics
-    this.batchCompletedCounter?.add(1, {
-      envId: meta.environmentId,
-      hasFailures: result.failedRunCount > 0,
-    });
+      const result = await this.#startSpan("BatchQueue.getCompletionResult", async (innerSpan) => {
+        const completionResult = await this.completionTracker.getCompletionResult(batchId);
+        innerSpan?.setAttributes({
+          "batch.successfulRunCount": completionResult.successfulRunCount,
+          "batch.failedRunCount": completionResult.failedRunCount,
+          "batch.runIdsCount": completionResult.runIds.length,
+          "batch.failuresCount": completionResult.failures.length,
+        });
+        return completionResult;
+      });
 
-    const processingDuration = Date.now() - meta.createdAt;
-    this.batchProcessingDurationHistogram?.record(processingDuration, {
-      envId: meta.environmentId,
-      itemCount: meta.runCount,
-    });
+      span?.setAttributes({
+        "batch.successfulRunCount": result.successfulRunCount,
+        "batch.failedRunCount": result.failedRunCount,
+      });
 
-    this.logger.info("Batch completed", {
-      batchId,
-      friendlyId: meta.friendlyId,
-      successfulRunCount: result.successfulRunCount,
-      failedRunCount: result.failedRunCount,
-      processingDurationMs: processingDuration,
-    });
+      // Record metrics
+      this.batchCompletedCounter?.add(1, {
+        environment_type: meta.environmentType,
+        hasFailures: result.failedRunCount > 0,
+      });
 
-    if (this.completionCallback) {
-      try {
-        await this.completionCallback(result);
-        // Only cleanup if callback succeeded - preserves Redis data for retry on failure
-        await this.completionTracker.cleanup(batchId);
-      } catch (error) {
-        this.logger.error("Error in batch completion callback", {
-          batchId,
-          error: error instanceof Error ? error.message : String(error),
+      const processingDuration = Date.now() - meta.createdAt;
+      this.batchProcessingDurationHistogram?.record(processingDuration, {
+        environment_type: meta.environmentType,
+      });
+
+      span?.setAttribute("batch.processingDurationMs", processingDuration);
+
+      this.logger.info("Batch completed", {
+        batchId,
+        friendlyId: meta.friendlyId,
+        successfulRunCount: result.successfulRunCount,
+        failedRunCount: result.failedRunCount,
+        processingDurationMs: processingDuration,
+      });
+
+      if (this.completionCallback) {
+        try {
+          await this.#startSpan("BatchQueue.completionCallback", async () => {
+            return this.completionCallback!(result);
+          });
+
+          // Only cleanup if callback succeeded - preserves Redis data for retry on failure
+          await this.#startSpan("BatchQueue.cleanup", async () => {
+            return this.completionTracker.cleanup(batchId);
+          });
+        } catch (error) {
+          this.logger.error("Error in batch completion callback", {
+            batchId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          // Re-throw to preserve Redis data and signal failure to callers
+          throw error;
+        }
+      } else {
+        // No callback, safe to cleanup
+        await this.#startSpan("BatchQueue.cleanup", async () => {
+          return this.completionTracker.cleanup(batchId);
         });
-        // Re-throw to preserve Redis data and signal failure to callers
-        throw error;
       }
-    } else {
-      // No callback, safe to cleanup
-      await this.completionTracker.cleanup(batchId);
-    }
+    });
   }
 
   // ============================================================================
@@ -708,4 +1109,15 @@ export class BatchQueue {
   #makeQueueId(envId: string, batchId: string): string {
     return `env:${envId}:batch:${batchId}`;
   }
+
+  /**
+   * Helper to start a span if tracer is available.
+   * If no tracer is configured, just executes the callback directly.
+   */
+  async #startSpan<T>(name: string, fn: (span: Span | undefined) => Promise<T>): Promise<T> {
+    if (!this.tracer) {
+      return fn(undefined);
+    }
+    return startSpan(this.tracer, name, fn);
+  }
 }
diff --git a/internal-packages/run-engine/src/batch-queue/tests/index.test.ts b/internal-packages/run-engine/src/batch-queue/tests/index.test.ts
index 98c7b0401f6..a4d4e338089 100644
--- a/internal-packages/run-engine/src/batch-queue/tests/index.test.ts
+++ b/internal-packages/run-engine/src/batch-queue/tests/index.test.ts
@@ -1,6 +1,7 @@
 import { redisTest } from "@internal/testcontainers";
 import { describe, expect, vi } from "vitest";
 import { BatchQueue } from "../index.js";
+import type { GlobalRateLimiter } from "@trigger.dev/redis-worker";
 import type { CompleteBatchResult, InitializeBatchOptions, BatchItem } from "../types.js";
 
 vi.setConfig({ testTimeout: 60_000 });
@@ -658,4 +659,121 @@ describe("BatchQueue", () => {
       }
     );
   });
+
+  describe("global rate limiter at worker queue consumer level", () => {
+    redisTest(
+      "should call rate limiter before each processing attempt",
+      async ({ redisContainer }) => {
+        let limitCallCount = 0;
+        const rateLimiter: GlobalRateLimiter = {
+          async limit() {
+            limitCallCount++;
+            return { allowed: true };
+          },
+        };
+
+        const queue = new BatchQueue({
+          redis: {
+            host: redisContainer.getHost(),
+            port: redisContainer.getPort(),
+            keyPrefix: "test:",
+          },
+          drr: { quantum: 5, maxDeficit: 50 },
+          consumerCount: 1,
+          consumerIntervalMs: 50,
+          startConsumers: true,
+          globalRateLimiter: rateLimiter,
+        });
+
+        let completionResult: CompleteBatchResult | null = null;
+
+        try {
+          queue.onProcessItem(async ({ itemIndex }) => {
+            return { success: true, runId: `run_${itemIndex}` };
+          });
+
+          queue.onBatchComplete(async (result) => {
+            completionResult = result;
+          });
+
+          const itemCount = 5;
+          await queue.initializeBatch(createInitOptions("batch1", "env1", itemCount));
+          await enqueueItems(queue, "batch1", "env1", createBatchItems(itemCount));
+
+          await vi.waitFor(
+            () => {
+              expect(completionResult).not.toBeNull();
+            },
+            { timeout: 10000 }
+          );
+
+          expect(completionResult!.successfulRunCount).toBe(itemCount);
+          // Rate limiter is called before each blockingPop, including iterations
+          // where no message is available, so count >= items processed
+          expect(limitCallCount).toBeGreaterThanOrEqual(itemCount);
+        } finally {
+          await queue.close();
+        }
+      }
+    );
+
+    redisTest(
+      "should delay processing when rate limited",
+      async ({ redisContainer }) => {
+        let limitCallCount = 0;
+        const rateLimiter: GlobalRateLimiter = {
+          async limit() {
+            limitCallCount++;
+            // Rate limit the first 3 calls, then allow
+            if (limitCallCount <= 3) {
+              return { allowed: false, resetAt: Date.now() + 100 };
+            }
+            return { allowed: true };
+          },
+        };
+
+        const queue = new BatchQueue({
+          redis: {
+            host: redisContainer.getHost(),
+            port: redisContainer.getPort(),
+            keyPrefix: "test:",
+          },
+          drr: { quantum: 5, maxDeficit: 50 },
+          consumerCount: 1,
+          consumerIntervalMs: 50,
+          startConsumers: true,
+          globalRateLimiter: rateLimiter,
+        });
+
+        let completionResult: CompleteBatchResult | null = null;
+
+        try {
+          queue.onProcessItem(async ({ itemIndex }) => {
+            return { success: true, runId: `run_${itemIndex}` };
+          });
+
+          queue.onBatchComplete(async (result) => {
+            completionResult = result;
+          });
+
+          await queue.initializeBatch(createInitOptions("batch1", "env1", 3));
+          await enqueueItems(queue, "batch1", "env1", createBatchItems(3));
+
+          // Should still complete despite initial rate limiting
+          await vi.waitFor(
+            () => {
+              expect(completionResult).not.toBeNull();
+            },
+            { timeout: 10000 }
+          );
+
+          expect(completionResult!.successfulRunCount).toBe(3);
+          // Rate limiter was called more times than items due to initial rejections
+          expect(limitCallCount).toBeGreaterThan(3);
+        } finally {
+          await queue.close();
+        }
+      }
+    );
+  });
 });
diff --git a/internal-packages/run-engine/src/batch-queue/types.ts b/internal-packages/run-engine/src/batch-queue/types.ts
index 6e8e8ad1c12..3695faf120e 100644
--- a/internal-packages/run-engine/src/batch-queue/types.ts
+++ b/internal-packages/run-engine/src/batch-queue/types.ts
@@ -79,6 +79,8 @@ export const BatchMeta = z.object({
   processingConcurrency: z.number().optional(),
   /** Plan type for billing (e.g., "free", "paid") - used when skipChecks is enabled */
   planType: z.string().optional(),
+  /** Trigger source for run annotations (e.g., "sdk", "cli", "mcp") */
+  triggerSource: z.string().optional(),
 });
 export type BatchMeta = z.infer<typeof BatchMeta>;
 
@@ -123,6 +125,8 @@ export type DRRConfig = {
   quantum: number;
   /** Maximum accumulated deficit (prevents starvation) */
   maxDeficit: number;
+  /** Maximum queues to fetch from master queue (default: 1000) */
+  masterQueueLimit?: number;
 };
 
 // ============================================================================
@@ -166,6 +170,8 @@ export type InitializeBatchOptions = {
   processingConcurrency?: number;
   /** Plan type for billing (e.g., "free", "paid") - used when skipChecks is enabled */
   planType?: string;
+  /** Trigger source for run annotations (e.g., "sdk", "cli", "mcp") */
+  triggerSource?: string;
 };
 
 /**
@@ -196,6 +202,10 @@ export type BatchQueueOptions = {
   consumerCount: number;
   /** Interval between consumer iterations (ms) */
   consumerIntervalMs: number;
+  /** Number of master queue shards (default: 1) */
+  shardCount?: number;
+  /** Worker queue blocking timeout in seconds (enables two-stage processing) */
+  workerQueueBlockingTimeoutSeconds?: number;
   /** Whether to start consumers on initialization */
   startConsumers?: boolean;
   /**
@@ -207,8 +217,15 @@ export type BatchQueueOptions = {
   /**
    * Optional global rate limiter to limit processing across all consumers.
    * When configured, limits the max items/second processed globally.
+   * Rate limiting happens at the worker queue consumer level (1 token per item).
    */
   globalRateLimiter?: GlobalRateLimiter;
+  /**
+   * Maximum number of items allowed in the worker queue before claiming pauses.
+   * Prevents unbounded worker queue growth which could cause visibility timeouts.
+   * Disabled by default (undefined = no limit).
+   */
+  workerQueueMaxDepth?: number;
   /** Logger instance */
   logger?: Logger;
   logLevel?: LogLevel;
@@ -216,6 +233,26 @@ export type BatchQueueOptions = {
   tracer?: Tracer;
   /** OpenTelemetry meter for metrics */
   meter?: Meter;
+  /** Maximum iterations before rotating consumer loop trace span (default: 1000) */
+  consumerTraceMaxIterations?: number;
+  /** Maximum seconds before rotating consumer loop trace span (default: 60) */
+  consumerTraceTimeoutSeconds?: number;
+  /** Retry configuration for failed batch items.
+   * When set, items that fail to trigger will be retried with exponential backoff.
+   * After exhausting retries, the failure is recorded permanently and the batch
+   * proceeds to completion. */
+  retry?: {
+    /** Maximum number of attempts (including the first). Default: 1 (no retries) */
+    maxAttempts: number;
+    /** Base delay in milliseconds. Default: 1000 */
+    minTimeoutInMs?: number;
+    /** Maximum delay in milliseconds. Default: 30000 */
+    maxTimeoutInMs?: number;
+    /** Exponential backoff factor. Default: 2 */
+    factor?: number;
+    /** Whether to add jitter to retry delays. Default: true */
+    randomize?: boolean;
+  };
 };
 
 /**
@@ -227,6 +264,10 @@ export type ProcessBatchItemCallback = (params: {
   itemIndex: number;
   item: BatchItem;
   meta: BatchMeta;
+  /** Current attempt number (1-indexed). First attempt = 1. */
+  attempt: number;
+  /** Whether this is the final attempt (no more retries after this). */
+  isFinalAttempt: boolean;
 }) => Promise<
   { success: true; runId: string } | { success: false; error: string; errorCode?: string }
 >;
diff --git a/internal-packages/run-engine/src/engine/billingCache.ts b/internal-packages/run-engine/src/engine/billingCache.ts
index 19c67d398e4..b9bf622e755 100644
--- a/internal-packages/run-engine/src/engine/billingCache.ts
+++ b/internal-packages/run-engine/src/engine/billingCache.ts
@@ -1,14 +1,13 @@
 import {
   createCache,
+  createLRUMemoryStore,
   DefaultStatefulContext,
-  MemoryStore,
   Namespace,
   Ok,
   RedisCacheStore,
   type UnkeyCache,
   type CacheError,
   type Result,
-  createMemoryStore,
 } from "@internal/cache";
 import type { RedisOptions } from "@internal/redis";
 import type { Logger } from "@trigger.dev/core/logger";
@@ -21,6 +20,7 @@ const BILLING_STALE_TTL = 60000 * 10; // 10 minutes
 export type BillingPlan = {
   isPaying: boolean;
   type: "free" | "paid" | "enterprise";
+  hasPrivateLink?: boolean;
 };
 
 export type BillingCacheOptions = {
@@ -53,7 +53,7 @@ export class BillingCache {
 
     this.cache = createCache({
       currentPlan: new Namespace<BillingPlan>(ctx, {
-        stores: [createMemoryStore(1000), redisCacheStore],
+        stores: [createLRUMemoryStore(1000), redisCacheStore],
         fresh: BILLING_FRESH_TTL,
         stale: BILLING_STALE_TTL,
       }),
@@ -73,7 +73,11 @@ export class BillingCache {
     return await this.cache.currentPlan.swr(orgId, async () => {
       // This is safe because options can't change at runtime
       const planResult = await this.billingOptions!.getCurrentPlan(orgId);
-      return { isPaying: planResult.isPaying, type: planResult.type };
+      return {
+        isPaying: planResult.isPaying,
+        type: planResult.type,
+        hasPrivateLink: planResult.hasPrivateLink,
+      };
     });
   }
 
diff --git a/internal-packages/run-engine/src/engine/errors.ts b/internal-packages/run-engine/src/engine/errors.ts
index cfc12e1b958..820f0ec4ce6 100644
--- a/internal-packages/run-engine/src/engine/errors.ts
+++ b/internal-packages/run-engine/src/engine/errors.ts
@@ -60,17 +60,23 @@ export function runStatusFromError(
     case "TASK_EXECUTION_FAILED":
     case "TASK_PROCESS_SIGTERM":
     case "TASK_DID_CONCURRENT_WAIT":
+    case "BATCH_ITEM_COULD_NOT_TRIGGER":
+    case "PAYLOAD_TOO_LARGE":
+    case "UNSPECIFIED_ERROR":
       return "SYSTEM_FAILURE";
     default:
       assertExhaustive(error.code);
   }
 }
 
+export type ServiceValidationErrorLevel = "error" | "warn" | "info";
+
 export class ServiceValidationError extends Error {
   constructor(
     message: string,
     public status?: number,
-    public metadata?: Record<string, unknown>
+    public metadata?: Record<string, unknown>,
+    public logLevel?: ServiceValidationErrorLevel
   ) {
     super(message);
     this.name = "ServiceValidationError";
diff --git a/internal-packages/run-engine/src/engine/index.ts b/internal-packages/run-engine/src/engine/index.ts
index 1b53d6378d4..a1446d54b20 100644
--- a/internal-packages/run-engine/src/engine/index.ts
+++ b/internal-packages/run-engine/src/engine/index.ts
@@ -14,7 +14,12 @@ import {
   TaskRunExecutionResult,
   TaskRunInternalError,
 } from "@trigger.dev/core/v3";
-import { RunId, WaitpointId } from "@trigger.dev/core/v3/isomorphic";
+import { TaskRunError } from "@trigger.dev/core/v3/schemas";
+import {
+  parseNaturalLanguageDurationInMs,
+  RunId,
+  WaitpointId,
+} from "@trigger.dev/core/v3/isomorphic";
 import {
   Prisma,
   PrismaClient,
@@ -70,6 +75,7 @@ import {
   RunEngineOptions,
   TriggerParams,
 } from "./types.js";
+import { createTtlWorkerCatalog } from "./ttlWorkerCatalog.js";
 import { workerCatalog } from "./workerCatalog.js";
 import pMap from "p-map";
 
@@ -77,6 +83,7 @@ export class RunEngine {
   private runLockRedis: Redis;
   private runLock: RunLocker;
   private worker: EngineWorker;
+  private ttlWorker: Worker<ReturnType<typeof createTtlWorkerCatalog>>;
   private logger: Logger;
   private tracer: Tracer;
   private meter: Meter;
@@ -182,6 +189,17 @@ export class RunEngine {
       processWorkerQueueDebounceMs: options.queue?.processWorkerQueueDebounceMs,
       dequeueBlockingTimeoutSeconds: options.queue?.dequeueBlockingTimeoutSeconds,
       meter: options.meter,
+      ttlSystem: options.queue?.ttlSystem?.disabled
+        ? undefined
+        : {
+          shardCount: options.queue?.ttlSystem?.shardCount,
+          pollIntervalMs: options.queue?.ttlSystem?.pollIntervalMs,
+          batchSize: options.queue?.ttlSystem?.batchSize,
+          consumersDisabled: options.queue?.ttlSystem?.consumersDisabled,
+          workerQueueSuffix: "ttl-worker:{queue:ttl-expiration:}queue",
+          workerItemsSuffix: "ttl-worker:{queue:ttl-expiration:}items",
+          visibilityTimeoutMs: options.queue?.ttlSystem?.visibilityTimeoutMs ?? 30_000,
+        },
     });
 
     this.worker = new Worker({
@@ -202,9 +220,9 @@ export class RunEngine {
             id: payload.waitpointId,
             output: payload.error
               ? {
-                  value: payload.error,
-                  isError: true,
-                }
+                value: payload.error,
+                isError: true,
+              }
               : undefined,
           });
         },
@@ -268,6 +286,7 @@ export class RunEngine {
 
     const resources: SystemResources = {
       prisma: this.prisma,
+      readOnlyPrisma: this.readOnlyPrisma,
       worker: this.worker,
       eventBus: this.eventBus,
       logger: this.logger,
@@ -323,14 +342,45 @@ export class RunEngine {
       waitpointSystem: this.waitpointSystem,
     });
 
+    const ttlWorkerCatalog = createTtlWorkerCatalog({
+      visibilityTimeoutMs: options.queue?.ttlSystem?.visibilityTimeoutMs,
+      batchMaxSize: options.queue?.ttlSystem?.batchMaxSize,
+      batchMaxWaitMs: options.queue?.ttlSystem?.batchMaxWaitMs,
+    });
+
+    this.ttlWorker = new Worker({
+      name: "ttl-expiration",
+      redisOptions: {
+        ...options.queue.redis,
+        keyPrefix: `${options.queue.redis.keyPrefix}runqueue:ttl-worker:`,
+      },
+      catalog: ttlWorkerCatalog,
+      concurrency: { limit: options.queue?.ttlSystem?.workerConcurrency ?? 1 },
+      pollIntervalMs: options.worker.pollIntervalMs ?? 1000,
+      immediatePollIntervalMs: options.worker.immediatePollIntervalMs ?? 100,
+      shutdownTimeoutMs: options.worker.shutdownTimeoutMs ?? 10_000,
+      logger: new Logger("RunEngineTtlWorker", options.logLevel ?? "info"),
+      jobs: {
+        expireTtlRun: async (items) => {
+          await this.ttlSystem.expireRunsBatch(items.map((i) => i.payload.runId));
+        },
+      },
+    });
+
+    // Start TTL worker whenever TTL system is enabled, so expired runs enqueued by the
+    // Lua script get processed even when the main engine worker is disabled (e.g. in tests).
+    if (options.queue?.ttlSystem && !options.queue.ttlSystem.disabled && !options.queue.ttlSystem.consumersDisabled) {
+      this.ttlWorker.start();
+    }
+
     this.batchSystem = new BatchSystem({
       resources,
       waitpointSystem: this.waitpointSystem,
     });
 
     // Initialize BatchQueue for DRR-based batch processing (if configured)
-    // Only start consumers if worker is not disabled (same as main worker)
-    const startConsumers = !options.worker.disabled;
+    // Only start consumers if consumerDisabled is not set or is false
+    const startBatchQueueConsumers = options.batchQueue?.consumerEnabled ?? true;
 
     this.batchQueue = new BatchQueue({
       redis: {
@@ -340,12 +390,17 @@ export class RunEngine {
       drr: {
         quantum: options.batchQueue?.drr?.quantum ?? 5,
         maxDeficit: options.batchQueue?.drr?.maxDeficit ?? 50,
+        masterQueueLimit: options.batchQueue?.drr?.masterQueueLimit,
       },
+      shardCount: options.batchQueue?.shardCount,
+      workerQueueBlockingTimeoutSeconds: options.batchQueue?.workerQueueBlockingTimeoutSeconds,
       consumerCount: options.batchQueue?.consumerCount ?? 2,
       consumerIntervalMs: options.batchQueue?.consumerIntervalMs ?? 100,
       defaultConcurrency: options.batchQueue?.defaultConcurrency ?? 10,
       globalRateLimiter: options.batchQueue?.globalRateLimiter,
-      startConsumers,
+      workerQueueMaxDepth: options.batchQueue?.workerQueueMaxDepth,
+      startConsumers: startBatchQueueConsumers,
+      retry: options.batchQueue?.retry,
       tracer: options.tracer,
       meter: options.meter,
     });
@@ -354,7 +409,7 @@ export class RunEngine {
       consumerCount: options.batchQueue?.consumerCount ?? 2,
       drrQuantum: options.batchQueue?.drr?.quantum ?? 5,
       defaultConcurrency: options.batchQueue?.defaultConcurrency ?? 10,
-      consumersEnabled: startConsumers,
+      consumersEnabled: startBatchQueueConsumers,
     });
 
     this.runAttemptSystem = new RunAttemptSystem({
@@ -392,6 +447,7 @@ export class RunEngine {
       environment,
       idempotencyKey,
       idempotencyKeyExpiresAt,
+      idempotencyKeyOptions,
       taskIdentifier,
       payload,
       payloadType,
@@ -406,6 +462,7 @@ export class RunEngine {
       cliVersion,
       concurrencyKey,
       workerQueue,
+      enableFastPath,
       queue,
       lockedQueueId,
       isTest,
@@ -439,6 +496,7 @@ export class RunEngine {
       planType,
       realtimeStreamsVersion,
       debounce,
+      annotations,
       onDebounced,
     }: TriggerParams,
     tx?: PrismaClientOrTransaction
@@ -460,18 +518,18 @@ export class RunEngine {
             debounce:
               debounce.mode === "trailing"
                 ? {
-                    ...debounce,
-                    updateData: {
-                      payload,
-                      payloadType,
-                      metadata,
-                      metadataType,
-                      tags,
-                      maxAttempts,
-                      maxDurationInSeconds,
-                      machine,
-                    },
-                  }
+                  ...debounce,
+                  updateData: {
+                    payload,
+                    payloadType,
+                    metadata,
+                    metadataType,
+                    tags,
+                    maxAttempts,
+                    maxDurationInSeconds,
+                    machine,
+                  },
+                }
                 : debounce,
             tx: prisma,
           });
@@ -481,20 +539,30 @@ export class RunEngine {
             span.setAttribute("existingRunId", debounceResult.run.id);
 
             // For triggerAndWait, block the parent run with the existing run's waitpoint
-            if (resumeParentOnCompletion && parentTaskRunId && debounceResult.waitpoint) {
+            if (resumeParentOnCompletion && parentTaskRunId) {
+              // Get or create waitpoint lazily (existing run may not have one if it was standalone)
+              let waitpoint = debounceResult.waitpoint;
+              if (!waitpoint) {
+                waitpoint = await this.waitpointSystem.getOrCreateRunWaitpoint({
+                  runId: debounceResult.run.id,
+                  projectId: environment.project.id,
+                  environmentId: environment.id,
+                });
+              }
+
               // Call the onDebounced callback to create a span and get spanIdToComplete
               let spanIdToComplete: string | undefined;
               if (onDebounced) {
                 spanIdToComplete = await onDebounced({
                   existingRun: debounceResult.run,
-                  waitpoint: debounceResult.waitpoint,
+                  waitpoint,
                   debounceKey: debounce.key,
                 });
               }
 
               await this.waitpointSystem.blockRunWithWaitpoint({
                 runId: parentTaskRunId,
-                waitpoints: debounceResult.waitpoint.id,
+                waitpoints: waitpoint.id,
                 spanIdToComplete,
                 projectId: environment.project.id,
                 organizationId: environment.organization.id,
@@ -522,6 +590,9 @@ export class RunEngine {
 
         const status = delayUntil ? "DELAYED" : "PENDING";
 
+        // Apply defaultMaxTtl: use as default when no TTL is provided, clamp when larger
+        const resolvedTtl = this.#resolveMaxTtl(ttl);
+
         //create run
         let taskRun: TaskRun & { associatedWaitpoint: Waitpoint | null };
         const taskRunId = RunId.fromFriendlyId(friendlyId);
@@ -541,6 +612,7 @@ export class RunEngine {
               projectId: environment.project.id,
               idempotencyKey,
               idempotencyKeyExpiresAt,
+              idempotencyKeyOptions,
               taskIdentifier,
               payload,
               payloadType,
@@ -564,13 +636,13 @@ export class RunEngine {
               taskEventStore,
               priorityMs,
               queueTimestamp: queueTimestamp ?? delayUntil ?? new Date(),
-              ttl,
+              ttl: resolvedTtl,
               tags:
                 tags.length === 0
                   ? undefined
                   : {
-                      connect: tags,
-                    },
+                    connect: tags,
+                  },
               runTags: tags.length === 0 ? undefined : tags.map((tag) => tag.name),
               oneTimeUseToken,
               parentTaskRunId,
@@ -593,11 +665,12 @@ export class RunEngine {
               realtimeStreamsVersion,
               debounce: debounce
                 ? {
-                    key: debounce.key,
-                    delay: debounce.delay,
-                    createdAt: new Date(),
-                  }
+                  key: debounce.key,
+                  delay: debounce.delay,
+                  createdAt: new Date(),
+                }
                 : undefined,
+              annotations,
               executionSnapshots: {
                 create: {
                   engine: "V2",
@@ -612,12 +685,17 @@ export class RunEngine {
                   runnerId,
                 },
               },
-              associatedWaitpoint: {
-                create: this.waitpointSystem.buildRunAssociatedWaitpoint({
-                  projectId: environment.project.id,
-                  environmentId: environment.id,
-                }),
-              },
+              // Only create waitpoint if parent is waiting for this run to complete
+              // For standalone triggers (no waiting parent), waitpoint is created lazily if needed later
+              associatedWaitpoint:
+                resumeParentOnCompletion && parentTaskRunId
+                  ? {
+                    create: this.waitpointSystem.buildRunAssociatedWaitpoint({
+                      projectId: environment.project.id,
+                      environmentId: environment.id,
+                    }),
+                  }
+                  : undefined,
             },
           });
         } catch (error) {
@@ -653,17 +731,32 @@ export class RunEngine {
 
         //triggerAndWait or batchTriggerAndWait
         if (resumeParentOnCompletion && parentTaskRunId && taskRun.associatedWaitpoint) {
-          //this will block the parent run from continuing until this waitpoint is completed (and removed)
-          await this.waitpointSystem.blockRunWithWaitpoint({
-            runId: parentTaskRunId,
-            waitpoints: taskRun.associatedWaitpoint.id,
-            projectId: taskRun.associatedWaitpoint.projectId,
-            organizationId: environment.organization.id,
-            batch,
-            workerId,
-            runnerId,
-            tx: prisma,
-          });
+          if (batch) {
+            // Batch path: lockless insert. The parent is already EXECUTING_WITH_WAITPOINTS
+            // from blockRunWithCreatedBatch, so we only need to insert the TaskRunWaitpoint
+            // row without acquiring the parent run lock. This avoids lock contention when
+            // processing large batches with high concurrency.
+            await this.waitpointSystem.blockRunWithWaitpointLockless({
+              runId: parentTaskRunId,
+              waitpoints: taskRun.associatedWaitpoint.id,
+              projectId: taskRun.associatedWaitpoint.projectId,
+              batch,
+              tx: prisma,
+            });
+          } else {
+            // Single triggerAndWait: acquire the parent run lock to safely transition
+            // the snapshot and insert the waitpoint
+            await this.waitpointSystem.blockRunWithWaitpoint({
+              runId: parentTaskRunId,
+              waitpoints: taskRun.associatedWaitpoint.id,
+              projectId: taskRun.associatedWaitpoint.projectId,
+              organizationId: environment.organization.id,
+              batch,
+              workerId,
+              runnerId,
+              tx: prisma,
+            });
+          }
         }
 
         if (taskRun.delayUntil) {
@@ -694,18 +787,33 @@ export class RunEngine {
             }
           }
         } else {
-          if (taskRun.ttl) {
-            await this.ttlSystem.scheduleExpireRun({ runId: taskRun.id, ttl: taskRun.ttl });
-          }
+          try {
+            if (taskRun.ttl) {
+              await this.ttlSystem.scheduleExpireRun({ runId: taskRun.id, ttl: taskRun.ttl });
+            }
 
-          await this.enqueueSystem.enqueueRun({
-            run: taskRun,
-            env: environment,
-            workerId,
-            runnerId,
-            tx: prisma,
-            skipRunLock: true,
-          });
+            await this.enqueueSystem.enqueueRun({
+              run: taskRun,
+              env: environment,
+              workerId,
+              runnerId,
+              tx: prisma,
+              skipRunLock: true,
+              includeTtl: true,
+              enableFastPath,
+            });
+          } catch (enqueueError) {
+            this.logger.error("engine.trigger(): failed to schedule TTL or enqueue run", {
+              runId: taskRun.id,
+              friendlyId: taskRun.friendlyId,
+              taskIdentifier: taskRun.taskIdentifier,
+              environmentId: environment.id,
+              ttl: taskRun.ttl,
+              error: enqueueError,
+            });
+
+            throw enqueueError;
+          }
         }
 
         this.eventBus.emit("runCreated", {
@@ -726,6 +834,146 @@ export class RunEngine {
     );
   }
 
+  /**
+   * Creates a pre-failed TaskRun in SYSTEM_FAILURE status.
+   *
+   * Used when a batch item fails to trigger (e.g., queue limits, environment not found).
+   * Creates the run record so batch completion can track it, and if the batch has a
+   * waiting parent, creates and immediately completes a RUN waitpoint with the error.
+   */
+  async createFailedTaskRun({
+    friendlyId,
+    environment,
+    taskIdentifier,
+    payload,
+    payloadType,
+    error,
+    parentTaskRunId,
+    rootTaskRunId,
+    depth,
+    resumeParentOnCompletion,
+    batch,
+    traceId,
+    spanId,
+    traceContext,
+    taskEventStore,
+    queue: queueOverride,
+    lockedQueueId: lockedQueueIdOverride,
+  }: {
+    friendlyId: string;
+    environment: {
+      id: string;
+      type: RuntimeEnvironmentType;
+      project: { id: string };
+      organization: { id: string };
+    };
+    taskIdentifier: string;
+    payload?: string;
+    payloadType?: string;
+    error: TaskRunError;
+    parentTaskRunId?: string;
+    /** The root run of the task tree. If the parent is already a child, this is the parent's root. */
+    rootTaskRunId?: string;
+    /** Depth in the task tree (0 for root, parentDepth+1 for children). */
+    depth?: number;
+    resumeParentOnCompletion?: boolean;
+    batch?: { id: string; index: number };
+    traceId?: string;
+    spanId?: string;
+    traceContext?: Record<string, unknown>;
+    taskEventStore?: string;
+    /** Resolved queue name (e.g. custom queue). When provided, used instead of task/${taskIdentifier}. */
+    queue?: string;
+    /** Resolved TaskQueue.id when the task is locked to a specific queue. */
+    lockedQueueId?: string;
+  }): Promise<TaskRun> {
+    return startSpan(
+      this.tracer,
+      "createFailedTaskRun",
+      async (span) => {
+        const taskRunId = RunId.fromFriendlyId(friendlyId);
+
+        // Build associated waitpoint data if parent is waiting for this run
+        const waitpointData =
+          resumeParentOnCompletion && parentTaskRunId
+            ? this.waitpointSystem.buildRunAssociatedWaitpoint({
+              projectId: environment.project.id,
+              environmentId: environment.id,
+            })
+            : undefined;
+
+        // Create the run in terminal SYSTEM_FAILURE status.
+        // No execution snapshot is needed: this run never gets dequeued, executed,
+        // or heartbeated, so nothing will call getLatestExecutionSnapshot on it.
+        const taskRun = await this.prisma.taskRun.create({
+          include: {
+            associatedWaitpoint: true,
+          },
+          data: {
+            id: taskRunId,
+            engine: "V2",
+            status: "SYSTEM_FAILURE",
+            friendlyId,
+            runtimeEnvironmentId: environment.id,
+            environmentType: environment.type,
+            organizationId: environment.organization.id,
+            projectId: environment.project.id,
+            taskIdentifier,
+            payload: payload ?? "",
+            payloadType: payloadType ?? "application/json",
+            context: {},
+            traceContext: (traceContext ?? {}) as Record<string, string | undefined>,
+            traceId: traceId ?? "",
+            spanId: spanId ?? "",
+            queue: queueOverride ?? `task/${taskIdentifier}`,
+            lockedQueueId: lockedQueueIdOverride,
+            isTest: false,
+            completedAt: new Date(),
+            error: error as unknown as Prisma.InputJsonObject,
+            parentTaskRunId,
+            rootTaskRunId,
+            depth: depth ?? 0,
+            batchId: batch?.id,
+            resumeParentOnCompletion,
+            taskEventStore,
+            associatedWaitpoint: waitpointData
+              ? { create: waitpointData }
+              : undefined,
+          },
+        });
+
+        span.setAttribute("runId", taskRun.id);
+
+        // If parent is waiting, block it with the waitpoint then immediately
+        // complete it with the error output so the parent can resume.
+        if (
+          resumeParentOnCompletion &&
+          parentTaskRunId &&
+          taskRun.associatedWaitpoint
+        ) {
+          await this.waitpointSystem.blockRunAndCompleteWaitpoint({
+            runId: parentTaskRunId,
+            waitpointId: taskRun.associatedWaitpoint.id,
+            output: { value: JSON.stringify(error), isError: true },
+            projectId: environment.project.id,
+            organizationId: environment.organization.id,
+            batch,
+          });
+        }
+
+        return taskRun;
+      },
+      {
+        attributes: {
+          friendlyId,
+          environmentId: environment.id,
+          projectId: environment.project.id,
+          taskIdentifier,
+        },
+      }
+    );
+  }
+
   /**
    * Gets a fairly selected run from the specified master queue, returning the information required to run it.
    * @param consumerId: The consumer that is pulling, allows multiple consumers to pull from the same queue
@@ -916,6 +1164,10 @@ export class RunEngine {
     return this.runQueue.lengthOfEnvQueue(environment);
   }
 
+  async lengthOfQueue(environment: MinimalAuthenticatedEnvironment, queue: string): Promise<number> {
+    return this.runQueue.lengthOfQueue(environment, queue);
+  }
+
   async concurrencyOfEnvQueue(environment: MinimalAuthenticatedEnvironment): Promise<number> {
     return this.runQueue.currentConcurrencyOfEnvironment(environment);
   }
@@ -1239,6 +1491,29 @@ export class RunEngine {
     return this.waitpointSystem.completeWaitpoint({ id, output });
   }
 
+  /**
+   * Gets an existing run waitpoint or creates one lazily.
+   * Used for debounce/idempotency when a late-arriving triggerAndWait caller
+   * needs to block on an existing run that was created without a waitpoint.
+   * When the run has already completed, creates the waitpoint and immediately
+   * completes it with the run's output/error so the parent can resume.
+   */
+  async getOrCreateRunWaitpoint({
+    runId,
+    projectId,
+    environmentId,
+  }: {
+    runId: string;
+    projectId: string;
+    environmentId: string;
+  }): Promise<Waitpoint> {
+    return this.waitpointSystem.getOrCreateRunWaitpoint({
+      runId,
+      projectId,
+      environmentId,
+    });
+  }
+
   /**
    * This gets called AFTER the checkpoint has been created
    * The CPU/Memory checkpoint at this point exists in our snapshot storage
@@ -1411,6 +1686,7 @@ export class RunEngine {
       //stop the run queue
       await this.runQueue.quit();
       await this.worker.stop();
+      await this.ttlWorker.stop();
       await this.runLock.quit();
 
       // This is just a failsafe
@@ -1745,17 +2021,17 @@ export class RunEngine {
           const error =
             latestSnapshot.environmentType === "DEVELOPMENT"
               ? ({
-                  type: "INTERNAL_ERROR",
-                  code: taskStalledErrorCode,
-                  message: errorMessage,
-                } satisfies TaskRunInternalError)
+                type: "INTERNAL_ERROR",
+                code: taskStalledErrorCode,
+                message: errorMessage,
+              } satisfies TaskRunInternalError)
               : this.options.treatProductionExecutionStallsAsOOM
-              ? ({
+                ? ({
                   type: "INTERNAL_ERROR",
                   code: "TASK_PROCESS_OOM_KILLED",
                   message: "Run was terminated due to running out of memory",
                 } satisfies TaskRunInternalError)
-              : ({
+                : ({
                   type: "INTERNAL_ERROR",
                   code: taskStalledErrorCode,
                   message: errorMessage,
@@ -1770,10 +2046,10 @@ export class RunEngine {
               error,
               retry: shouldRetry
                 ? {
-                    //250ms in the future
-                    timestamp: Date.now() + retryDelay,
-                    delay: retryDelay,
-                  }
+                  //250ms in the future
+                  timestamp: Date.now() + retryDelay,
+                  delay: retryDelay,
+                }
                 : undefined,
             },
             forceRequeue: true,
@@ -2019,6 +2295,37 @@ export class RunEngine {
     });
   }
 
+  /**
+   * Applies `defaultMaxTtl` to a run's TTL:
+   * - No max configured → pass through as-is.
+   * - No TTL on the run → use the max as the default.
+   * - Both exist → clamp to the smaller value.
+   */
+  #resolveMaxTtl(ttl: string | undefined): string | undefined {
+    const maxTtl = this.options.defaultMaxTtl;
+
+    if (!maxTtl) {
+      return ttl;
+    }
+
+    if (!ttl) {
+      return maxTtl;
+    }
+
+    const ttlMs = parseNaturalLanguageDurationInMs(ttl);
+    const maxTtlMs = parseNaturalLanguageDurationInMs(maxTtl);
+
+    if (maxTtlMs === undefined) {
+      return ttl;
+    }
+
+    if (ttlMs === undefined) {
+      return maxTtl;
+    }
+
+    return ttlMs <= maxTtlMs ? ttl : maxTtl;
+  }
+
   async #concurrencySweeperCallback(
     runIds: string[],
     completedAtOffsetMs: number = 1000 * 60 * 10
diff --git a/internal-packages/run-engine/src/engine/retrying.ts b/internal-packages/run-engine/src/engine/retrying.ts
index 8001c5d8a20..6099d5b649b 100644
--- a/internal-packages/run-engine/src/engine/retrying.ts
+++ b/internal-packages/run-engine/src/engine/retrying.ts
@@ -37,6 +37,10 @@ export type RetryOutcome =
       settings: TaskRunExecutionRetry;
       machine?: string;
       wasOOMError?: boolean;
+      // Current usage values for calculating updated totals
+      usageDurationMs: number;
+      costInCents: number;
+      machinePreset: string | null;
     };
 
 export async function retryOutcomeFromCompletion(
@@ -70,6 +74,9 @@ export async function retryOutcomeFromCompletion(
       machine: oomResult.machine,
       settings: { timestamp: Date.now() + delay, delay },
       wasOOMError: true,
+      usageDurationMs: oomResult.usageDurationMs,
+      costInCents: oomResult.costInCents,
+      machinePreset: oomResult.machinePreset,
     };
   }
 
@@ -87,7 +94,7 @@ export async function retryOutcomeFromCompletion(
     return { outcome: "fail_run", sanitizedError };
   }
 
-  // Get the run settings
+  // Get the run settings and current usage values
   const run = await prisma.taskRun.findFirst({
     where: {
       id: runId,
@@ -95,6 +102,9 @@ export async function retryOutcomeFromCompletion(
     select: {
       maxAttempts: true,
       lockedRetryConfig: true,
+      usageDurationMs: true,
+      costInCents: true,
+      machinePreset: true,
     },
   });
 
@@ -151,6 +161,9 @@ export async function retryOutcomeFromCompletion(
       outcome: "retry",
       method: "queue", // we'll always retry on the queue because usually having no settings means something bad happened
       settings: retrySettings,
+      usageDurationMs: run.usageDurationMs,
+      costInCents: run.costInCents,
+      machinePreset: run.machinePreset,
     };
   }
 
@@ -158,13 +171,22 @@ export async function retryOutcomeFromCompletion(
     outcome: "retry",
     method: retryUsingQueue ? "queue" : "immediate",
     settings: retrySettings,
+    usageDurationMs: run.usageDurationMs,
+    costInCents: run.costInCents,
+    machinePreset: run.machinePreset,
   };
 }
 
 async function retryOOMOnMachine(
   prisma: PrismaClientOrTransaction,
   runId: string
-): Promise<{ machine: string; retrySettings: RetryOptions } | undefined> {
+): Promise<{
+  machine: string;
+  retrySettings: RetryOptions;
+  usageDurationMs: number;
+  costInCents: number;
+  machinePreset: string | null;
+} | undefined> {
   try {
     const run = await prisma.taskRun.findFirst({
       where: {
@@ -173,6 +195,8 @@ async function retryOOMOnMachine(
       select: {
         machinePreset: true,
         lockedRetryConfig: true,
+        usageDurationMs: true,
+        costInCents: true,
       },
     });
 
@@ -201,7 +225,13 @@ async function retryOOMOnMachine(
       return;
     }
 
-    return { machine: retryMachine, retrySettings: parsedRetryConfig.data };
+    return {
+      machine: retryMachine,
+      retrySettings: parsedRetryConfig.data,
+      usageDurationMs: run.usageDurationMs,
+      costInCents: run.costInCents,
+      machinePreset: run.machinePreset,
+    };
   } catch (error) {
     console.error("[FailedTaskRunRetryHelper] Failed to get execution retry", {
       runId,
diff --git a/internal-packages/run-engine/src/engine/systems/debounceSystem.ts b/internal-packages/run-engine/src/engine/systems/debounceSystem.ts
index af25a31552f..8cd06d07732 100644
--- a/internal-packages/run-engine/src/engine/systems/debounceSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/debounceSystem.ts
@@ -6,7 +6,10 @@ import {
   type Result,
 } from "@internal/redis";
 import { startSpan } from "@internal/tracing";
-import { parseNaturalLanguageDuration } from "@trigger.dev/core/v3/isomorphic";
+import {
+  parseNaturalLanguageDuration,
+  parseNaturalLanguageDurationInMs,
+} from "@trigger.dev/core/v3/isomorphic";
 import { PrismaClientOrTransaction, TaskRun, Waitpoint } from "@trigger.dev/database";
 import { nanoid } from "nanoid";
 import { SystemResources } from "./systems.js";
@@ -17,6 +20,12 @@ export type DebounceOptions = {
   key: string;
   delay: string;
   mode?: "leading" | "trailing";
+  /**
+   * Maximum total delay before the run must execute, regardless of subsequent triggers.
+   * This prevents indefinite delays when continuous triggers keep pushing the execution time.
+   * If not specified, falls back to the server's maxDebounceDurationMs config.
+   */
+  maxDelay?: string;
   /** When mode: "trailing", these fields will be used to update the existing run */
   updateData?: {
     payload: string;
@@ -521,8 +530,22 @@ return 0
       }
 
       // Check if max debounce duration would be exceeded
+      // Use per-trigger maxDelay if provided, otherwise use global config
+      let maxDurationMs = this.maxDebounceDurationMs;
+      if (debounce.maxDelay) {
+        const parsedMaxDelay = parseNaturalLanguageDurationInMs(debounce.maxDelay);
+        if (parsedMaxDelay !== undefined) {
+          maxDurationMs = parsedMaxDelay;
+        } else {
+          this.$.logger.warn("handleExistingRun: invalid maxDelay duration, using global config", {
+            maxDelay: debounce.maxDelay,
+            fallbackMs: this.maxDebounceDurationMs,
+          });
+        }
+      }
+
       const runCreatedAt = existingRun.createdAt;
-      const maxDelayUntil = new Date(runCreatedAt.getTime() + this.maxDebounceDurationMs);
+      const maxDelayUntil = new Date(runCreatedAt.getTime() + maxDurationMs);
 
       if (newDelayUntil > maxDelayUntil) {
         this.$.logger.debug("handleExistingRun: max debounce duration would be exceeded", {
@@ -531,7 +554,8 @@ return 0
           runCreatedAt,
           newDelayUntil,
           maxDelayUntil,
-          maxDebounceDurationMs: this.maxDebounceDurationMs,
+          maxDurationMs,
+          maxDelayProvided: debounce.maxDelay,
         });
         // Clean up Redis key since this debounce window is closed
         await this.redis.del(redisKey);
diff --git a/internal-packages/run-engine/src/engine/systems/dequeueSystem.ts b/internal-packages/run-engine/src/engine/systems/dequeueSystem.ts
index 5a951a645cb..a51d12c52ca 100644
--- a/internal-packages/run-engine/src/engine/systems/dequeueSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/dequeueSystem.ts
@@ -1,7 +1,7 @@
 import type { BillingCache } from "../billingCache.js";
 import { startSpan } from "@internal/tracing";
-import { assertExhaustive } from "@trigger.dev/core";
-import { DequeuedMessage, RetryOptions } from "@trigger.dev/core/v3";
+import { assertExhaustive, tryCatch } from "@trigger.dev/core";
+import { DequeuedMessage, RetryOptions, RunAnnotations } from "@trigger.dev/core/v3";
 import { placementTag } from "@trigger.dev/core/v3/serverOnly";
 import { getMaxDuration } from "@trigger.dev/core/v3/isomorphic";
 import {
@@ -495,6 +495,7 @@ export class DequeueSystem {
               const billingResult = await this.options.billingCache.getCurrentPlan(orgId);
 
               let isPaying: boolean;
+              let hasPrivateLink: boolean | undefined;
               if (billingResult.err || !billingResult.val) {
                 // Fallback to stored planType on TaskRun if billing cache fails or returns no value
                 this.$.logger.warn(
@@ -513,6 +514,7 @@ export class DequeueSystem {
                 isPaying = (lockedTaskRun.planType ?? "free") !== "free";
               } else {
                 isPaying = billingResult.val.isPaying;
+                hasPrivateLink = billingResult.val.hasPrivateLink;
               }
 
               const newSnapshot = await this.executionSnapshotSystem.createExecutionSnapshot(
@@ -575,6 +577,7 @@ export class DequeueSystem {
                   // Keeping this for backwards compatibility, but really this should be called workerQueue
                   masterQueue: lockedTaskRun.workerQueue,
                   traceContext: lockedTaskRun.traceContext as Record<string, unknown>,
+                  annotations: RunAnnotations.safeParse(lockedTaskRun.annotations).data,
                 },
                 environment: {
                   id: lockedTaskRun.runtimeEnvironment.id,
@@ -582,6 +585,7 @@ export class DequeueSystem {
                 },
                 organization: {
                   id: orgId,
+                  hasPrivateLink,
                 },
                 project: {
                   id: lockedTaskRun.projectId,
@@ -611,20 +615,24 @@ export class DequeueSystem {
             }
           );
 
-          const run = await prisma.taskRun.findFirst({
-            where: { id: runId },
-            include: {
-              runtimeEnvironment: true,
-            },
-          });
+          // Wrap the Prisma call with tryCatch - if DB is unavailable, we still want to nack via Redis
+          const [findError, run] = await tryCatch(
+            prisma.taskRun.findFirst({
+              where: { id: runId },
+              include: {
+                runtimeEnvironment: true,
+              },
+            })
+          );
 
-          if (!run) {
-            //this isn't ideal because we're not creating a snapshot… but we can't do much else
+          // If DB is unavailable or run not found, just nack directly via Redis
+          if (findError || !run) {
             this.$.logger.error(
-              "RunEngine.dequeueFromWorkerQueue(): Thrown error, then run not found. Nacking.",
+              "RunEngine.dequeueFromWorkerQueue(): Failed to find run, nacking directly via Redis",
               {
                 runId,
                 orgId,
+                findError,
               }
             );
             await this.$.runQueue.nackMessage({ orgId, messageId: runId });
diff --git a/internal-packages/run-engine/src/engine/systems/enqueueSystem.ts b/internal-packages/run-engine/src/engine/systems/enqueueSystem.ts
index 395e44727c0..d899aa7a6f3 100644
--- a/internal-packages/run-engine/src/engine/systems/enqueueSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/enqueueSystem.ts
@@ -4,6 +4,7 @@ import {
   TaskRun,
   TaskRunExecutionStatus,
 } from "@trigger.dev/database";
+import { parseNaturalLanguageDuration } from "@trigger.dev/core/v3/isomorphic";
 import { MinimalAuthenticatedEnvironment } from "../../shared/index.js";
 import { ExecutionSnapshotSystem } from "./executionSnapshotSystem.js";
 import { SystemResources } from "./systems.js";
@@ -34,6 +35,8 @@ export class EnqueueSystem {
     workerId,
     runnerId,
     skipRunLock,
+    includeTtl = false,
+    enableFastPath = false,
   }: {
     run: TaskRun;
     env: MinimalAuthenticatedEnvironment;
@@ -53,6 +56,10 @@ export class EnqueueSystem {
     workerId?: string;
     runnerId?: string;
     skipRunLock?: boolean;
+    /** When true, include TTL in the queued message (only for first enqueue from trigger). Default false. */
+    includeTtl?: boolean;
+    /** When true, allow the queue to push directly to worker queue if concurrency is available. */
+    enableFastPath?: boolean;
   }) {
     const prisma = tx ?? this.$.prisma;
 
@@ -81,9 +88,20 @@ export class EnqueueSystem {
 
       const timestamp = (run.queueTimestamp ?? run.createdAt).getTime() - run.priorityMs;
 
+      // Include TTL only when explicitly requested (first enqueue from trigger).
+      // Re-enqueues (waitpoint, checkpoint, delayed, pending version) must not add TTL.
+      let ttlExpiresAt: number | undefined;
+      if (includeTtl && run.ttl) {
+        const expireAt = parseNaturalLanguageDuration(run.ttl);
+        if (expireAt) {
+          ttlExpiresAt = expireAt.getTime();
+        }
+      }
+
       await this.$.runQueue.enqueueMessage({
         env,
         workerQueue,
+        enableFastPath,
         message: {
           runId: run.id,
           taskIdentifier: run.taskIdentifier,
@@ -95,6 +113,7 @@ export class EnqueueSystem {
           concurrencyKey: run.concurrencyKey ?? undefined,
           timestamp,
           attempt: 0,
+          ttlExpiresAt,
         },
       });
 
diff --git a/internal-packages/run-engine/src/engine/systems/executionSnapshotSystem.ts b/internal-packages/run-engine/src/engine/systems/executionSnapshotSystem.ts
index b6f31bcffc3..a224e5a86b0 100644
--- a/internal-packages/run-engine/src/engine/systems/executionSnapshotSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/executionSnapshotSystem.ts
@@ -8,10 +8,14 @@ import {
   TaskRunExecutionSnapshot,
   TaskRunExecutionStatus,
   TaskRunStatus,
+  Waitpoint,
 } from "@trigger.dev/database";
 import { HeartbeatTimeouts } from "../types.js";
 import { SystemResources } from "./systems.js";
 
+/** Chunk size for fetching waitpoints to avoid NAPI string conversion limits */
+const WAITPOINT_CHUNK_SIZE = 100;
+
 export type ExecutionSnapshotSystemOptions = {
   resources: SystemResources;
   heartbeatTimeouts: HeartbeatTimeouts;
@@ -31,19 +35,41 @@ type ExecutionSnapshotWithCheckAndWaitpoints = Prisma.TaskRunExecutionSnapshotGe
   };
 }>;
 
+type ExecutionSnapshotWithCheckpoint = Prisma.TaskRunExecutionSnapshotGetPayload<{
+  include: {
+    checkpoint: true;
+  };
+}>;
+
 function enhanceExecutionSnapshot(
   snapshot: ExecutionSnapshotWithCheckAndWaitpoints
+): EnhancedExecutionSnapshot {
+  return enhanceExecutionSnapshotWithWaitpoints(
+    snapshot,
+    snapshot.completedWaitpoints,
+    snapshot.completedWaitpointOrder
+  );
+}
+
+/**
+ * Transforms a snapshot (with checkpoint but without waitpoints) into an EnhancedExecutionSnapshot
+ * by combining it with pre-fetched waitpoints.
+ */
+function enhanceExecutionSnapshotWithWaitpoints(
+  snapshot: ExecutionSnapshotWithCheckpoint,
+  waitpoints: Waitpoint[],
+  completedWaitpointOrder: string[]
 ): EnhancedExecutionSnapshot {
   return {
     ...snapshot,
     friendlyId: SnapshotId.toFriendlyId(snapshot.id),
     runFriendlyId: RunId.toFriendlyId(snapshot.runId),
-    completedWaitpoints: snapshot.completedWaitpoints.flatMap((w) => {
-      //get all indexes of the waitpoint in the completedWaitpointOrder
-      //we do this because the same run can be in a batch multiple times (i.e. same idempotencyKey)
+    completedWaitpoints: waitpoints.flatMap((w) => {
+      // Get all indexes of the waitpoint in the completedWaitpointOrder
+      // We do this because the same run can be in a batch multiple times (i.e. same idempotencyKey)
       let indexes: (number | undefined)[] = [];
-      for (let i = 0; i < snapshot.completedWaitpointOrder.length; i++) {
-        if (snapshot.completedWaitpointOrder[i] === w.id) {
+      for (let i = 0; i < completedWaitpointOrder.length; i++) {
+        if (completedWaitpointOrder[i] === w.id) {
           indexes.push(i);
         }
       }
@@ -60,9 +86,7 @@ function enhanceExecutionSnapshot(
           type: w.type,
           completedAt: w.completedAt ?? new Date(),
           idempotencyKey:
-            w.userProvidedIdempotencyKey && !w.inactiveIdempotencyKey
-              ? w.idempotencyKey
-              : undefined,
+            w.userProvidedIdempotencyKey && !w.inactiveIdempotencyKey ? w.idempotencyKey : undefined,
           completedByTaskRun: w.completedByTaskRunId
             ? {
                 id: w.completedByTaskRunId,
@@ -91,6 +115,42 @@ function enhanceExecutionSnapshot(
   };
 }
 
+/**
+ * Gets the waitpoint IDs linked to a snapshot via the _completedWaitpoints join table.
+ * Uses raw SQL to avoid fetching full waitpoint data.
+ */
+async function getSnapshotWaitpointIds(
+  prisma: PrismaClientOrTransaction,
+  snapshotId: string
+): Promise<string[]> {
+  const result = await prisma.$queryRaw<{ B: string }[]>`
+    SELECT "B" FROM "_completedWaitpoints" WHERE "A" = ${snapshotId}
+  `;
+  return result.map((r) => r.B);
+}
+
+/**
+ * Fetches waitpoints in chunks to avoid NAPI string conversion limits.
+ * This is necessary because waitpoints can have large outputs (100KB+),
+ * and fetching many at once can exceed Node.js string limits.
+ */
+async function fetchWaitpointsInChunks(
+  prisma: PrismaClientOrTransaction,
+  waitpointIds: string[]
+): Promise<Waitpoint[]> {
+  if (waitpointIds.length === 0) return [];
+
+  const allWaitpoints: Waitpoint[] = [];
+  for (let i = 0; i < waitpointIds.length; i += WAITPOINT_CHUNK_SIZE) {
+    const chunk = waitpointIds.slice(i, i + WAITPOINT_CHUNK_SIZE);
+    const waitpoints = await prisma.waitpoint.findMany({
+      where: { id: { in: chunk } },
+    });
+    allWaitpoints.push(...waitpoints);
+  }
+  return allWaitpoints;
+}
+
 /* Gets the most recent valid snapshot for a run */
 export async function getLatestExecutionSnapshot(
   prisma: PrismaClientOrTransaction,
@@ -191,12 +251,27 @@ export function executionDataFromSnapshot(snapshot: EnhancedExecutionSnapshot):
   };
 }
 
+/**
+ * Gets execution snapshots created after the specified snapshot.
+ *
+ * IMPORTANT: This function is optimized to avoid N×M data explosion when runs have many
+ * completed waitpoints. Due to the many-to-many relation, once waitpoints complete,
+ * all subsequent snapshots have the same waitpoints linked. For a run with 24 snapshots
+ * and 236 waitpoints with 100KB outputs each, fetching all waitpoints for all snapshots
+ * would result in ~570MB of data, causing "Failed to convert rust String into napi string" errors.
+ *
+ * Solution: Only the LATEST snapshot's waitpoints are fetched and included. The runner's
+ * SnapshotManager only processes completedWaitpoints from the latest snapshot anyway -
+ * intermediate snapshots' waitpoints are ignored. This reduces data from N×M to just M.
+ *
+ * Waitpoints are fetched in chunks (100 at a time) to handle batches up to 1000 items.
+ */
 export async function getExecutionSnapshotsSince(
   prisma: PrismaClientOrTransaction,
   runId: string,
   sinceSnapshotId: string
 ): Promise<EnhancedExecutionSnapshot[]> {
-  // Find the createdAt of the sinceSnapshotId
+  // Step 1: Find the createdAt of the sinceSnapshotId
   const sinceSnapshot = await prisma.taskRunExecutionSnapshot.findFirst({
     where: { id: sinceSnapshotId },
     select: { createdAt: true },
@@ -206,6 +281,7 @@ export async function getExecutionSnapshotsSince(
     throw new Error(`No execution snapshot found for id ${sinceSnapshotId}`);
   }
 
+  // Step 2: Fetch snapshots WITHOUT waitpoints to avoid N×M data explosion
   const snapshots = await prisma.taskRunExecutionSnapshot.findMany({
     where: {
       runId,
@@ -213,14 +289,32 @@ export async function getExecutionSnapshotsSince(
       createdAt: { gt: sinceSnapshot.createdAt },
     },
     include: {
-      completedWaitpoints: true,
       checkpoint: true,
+      // DO NOT include completedWaitpoints here - this causes the N×M explosion
     },
     orderBy: { createdAt: "desc" },
     take: 50,
   });
 
-  return snapshots.reverse().map(enhanceExecutionSnapshot);
+  if (snapshots.length === 0) return [];
+
+  // Step 3: Get waitpoint IDs for the LATEST snapshot only (first in desc order)
+  const latestSnapshot = snapshots[0];
+  const waitpointIds = await getSnapshotWaitpointIds(prisma, latestSnapshot.id);
+
+  // Step 4: Fetch waitpoints in chunks to avoid NAPI string conversion limits
+  const waitpoints = await fetchWaitpointsInChunks(prisma, waitpointIds);
+
+  // Step 5: Build enhanced snapshots - only latest gets waitpoints, others get empty arrays
+  // The runner only uses completedWaitpoints from the latest snapshot anyway
+  return snapshots.reverse().map((snapshot) => {
+    const isLatest = snapshot.id === latestSnapshot.id;
+    return enhanceExecutionSnapshotWithWaitpoints(
+      snapshot,
+      isLatest ? waitpoints : [],
+      latestSnapshot.completedWaitpointOrder
+    );
+  });
 }
 
 export class ExecutionSnapshotSystem {
diff --git a/internal-packages/run-engine/src/engine/systems/pendingVersionSystem.ts b/internal-packages/run-engine/src/engine/systems/pendingVersionSystem.ts
index 6dcb4f6eb04..c22429ac0c9 100644
--- a/internal-packages/run-engine/src/engine/systems/pendingVersionSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/pendingVersionSystem.ts
@@ -50,7 +50,7 @@ export class PendingVersionSystem {
       queues: backgroundWorker.queues.map((queue) => queue.name),
     });
 
-    const pendingRuns = await this.$.prisma.taskRun.findMany({
+    const pendingRuns = await this.$.readOnlyPrisma.taskRun.findMany({
       where: {
         runtimeEnvironmentId: backgroundWorker.runtimeEnvironmentId,
         projectId: backgroundWorker.projectId,
diff --git a/internal-packages/run-engine/src/engine/systems/runAttemptSystem.ts b/internal-packages/run-engine/src/engine/systems/runAttemptSystem.ts
index 67592ccddba..8e95519241c 100644
--- a/internal-packages/run-engine/src/engine/systems/runAttemptSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/runAttemptSystem.ts
@@ -1,8 +1,7 @@
 import {
   createCache,
-  createMemoryStore,
+  createLRUMemoryStore,
   DefaultStatefulContext,
-  MemoryStore,
   Namespace,
   RedisCacheStore,
   UnkeyCache,
@@ -30,6 +29,10 @@ import {
   TaskRunInternalError,
   TaskRunSuccessfulExecutionResult,
 } from "@trigger.dev/core/v3/schemas";
+import {
+  extractIdempotencyKeyScope,
+  getUserProvidedIdempotencyKey,
+} from "@trigger.dev/core/v3/serverOnly";
 import { parsePacket } from "@trigger.dev/core/v3/utils/ioSerialization";
 import {
   $transaction,
@@ -126,7 +129,7 @@ export class RunAttemptSystem {
     this.delayedRunSystem = options.delayedRunSystem;
 
     const ctx = new DefaultStatefulContext();
-    const memory = createMemoryStore(5000, 0.001);
+    const memory = createLRUMemoryStore(5000);
     const redisCacheStore = new RedisCacheStore({
       name: "run-attempt-system",
       connection: {
@@ -171,7 +174,7 @@ export class RunAttemptSystem {
   }
 
   public async resolveTaskRunContext(runId: string): Promise<TaskRunContext> {
-    const run = await this.$.prisma.taskRun.findFirst({
+    const run = await this.$.readOnlyPrisma.taskRun.findFirst({
       where: {
         id: runId,
       },
@@ -194,6 +197,7 @@ export class RunAttemptSystem {
         runTags: true,
         isTest: true,
         idempotencyKey: true,
+        idempotencyKeyOptions: true,
         startedAt: true,
         maxAttempts: true,
         taskVersion: true,
@@ -228,11 +232,10 @@ export class RunAttemptSystem {
       run.lockedById
         ? this.#resolveTaskRunExecutionTask(run.lockedById)
         : Promise.resolve({
-            id: run.taskIdentifier,
-            filePath: "unknown",
-          }),
+          id: run.taskIdentifier,
+          filePath: "unknown",
+        }),
       this.#resolveTaskRunExecutionQueue({
-        runId,
         lockedQueueId: run.lockedQueueId ?? undefined,
         queueName: run.queue,
         runtimeEnvironmentId: run.runtimeEnvironment.id,
@@ -242,13 +245,13 @@ export class RunAttemptSystem {
       run.lockedById
         ? this.#resolveTaskRunExecutionMachinePreset(run.lockedById, run.machinePreset)
         : Promise.resolve(
-            getMachinePreset({
-              defaultMachine: this.options.machines.defaultMachine,
-              machines: this.options.machines.machines,
-              config: undefined,
-              run,
-            })
-          ),
+          getMachinePreset({
+            defaultMachine: this.options.machines.defaultMachine,
+            machines: this.options.machines.machines,
+            config: undefined,
+            run,
+          })
+        ),
       run.lockedById
         ? this.#resolveTaskRunExecutionDeployment(run.lockedById)
         : Promise.resolve(undefined),
@@ -261,7 +264,8 @@ export class RunAttemptSystem {
         isTest: run.isTest,
         createdAt: run.createdAt,
         startedAt: run.startedAt ?? run.createdAt,
-        idempotencyKey: run.idempotencyKey ?? undefined,
+        idempotencyKey: getUserProvidedIdempotencyKey(run) ?? undefined,
+        idempotencyKeyScope: extractIdempotencyKeyScope(run),
         maxAttempts: run.maxAttempts ?? undefined,
         version: run.taskVersion ?? "unknown",
         maxDuration: run.maxDurationInSeconds ?? undefined,
@@ -331,7 +335,7 @@ export class RunAttemptSystem {
             });
           }
 
-          const taskRun = await prisma.taskRun.findFirst({
+          const taskRun = await this.$.readOnlyPrisma.taskRun.findFirst({
             where: {
               id: runId,
             },
@@ -398,6 +402,7 @@ export class RunAttemptSystem {
                   status: "EXECUTING",
                   attemptNumber: nextAttemptNumber,
                   executedAt: taskRun.attemptNumber === null ? new Date() : undefined,
+                  isWarmStart: isWarmStart ?? false,
                 },
                 select: {
                   id: true,
@@ -422,6 +427,7 @@ export class RunAttemptSystem {
                   runTags: true,
                   isTest: true,
                   idempotencyKey: true,
+                  idempotencyKeyOptions: true,
                   startedAt: true,
                   maxAttempts: true,
                   taskVersion: true,
@@ -453,9 +459,8 @@ export class RunAttemptSystem {
                 run,
                 snapshot: {
                   executionStatus: "EXECUTING",
-                  description: `Attempt created, starting execution${
-                    isWarmStart ? " (warm start)" : ""
-                  }`,
+                  description: `Attempt created, starting execution${isWarmStart ? " (warm start)" : ""
+                    }`,
                 },
                 previousSnapshotId: latestSnapshot.id,
                 environmentId: latestSnapshot.environmentId,
@@ -532,7 +537,6 @@ export class RunAttemptSystem {
               }),
               this.#resolveTaskRunExecutionTask(taskRun.lockedById),
               this.#resolveTaskRunExecutionQueue({
-                runId,
                 lockedQueueId: updatedRun.lockedQueueId ?? undefined,
                 queueName: updatedRun.queue,
                 runtimeEnvironmentId: updatedRun.runtimeEnvironment.id,
@@ -570,7 +574,8 @@ export class RunAttemptSystem {
               createdAt: updatedRun.createdAt,
               tags: updatedRun.runTags,
               isTest: updatedRun.isTest,
-              idempotencyKey: updatedRun.idempotencyKey ?? undefined,
+              idempotencyKey: getUserProvidedIdempotencyKey(updatedRun) ?? undefined,
+              idempotencyKeyScope: extractIdempotencyKeyScope(updatedRun),
               startedAt: updatedRun.startedAt ?? updatedRun.createdAt,
               maxAttempts: updatedRun.maxAttempts ?? undefined,
               version: updatedRun.taskVersion ?? "unknown",
@@ -613,8 +618,8 @@ export class RunAttemptSystem {
             deployment,
             batch: updatedRun.batchId
               ? {
-                  id: BatchId.toFriendlyId(updatedRun.batchId),
-                }
+                id: BatchId.toFriendlyId(updatedRun.batchId),
+              }
               : undefined,
           };
 
@@ -699,9 +704,34 @@ export class RunAttemptSystem {
           }
 
           span.setAttribute("completionStatus", completion.ok);
+          span.setAttribute("runId", runId);
 
           const completedAt = new Date();
 
+          // Read current usage values to calculate new totals (safe under runLock)
+          const currentRun = await this.$.readOnlyPrisma.taskRun.findFirst({
+            where: { id: runId },
+            select: {
+              usageDurationMs: true,
+              costInCents: true,
+              machinePreset: true,
+            },
+          });
+
+          if (!currentRun) {
+            throw new ServiceValidationError("Run not found", 404);
+          }
+
+          // Calculate new usage totals
+          const updatedUsage = this.#calculateUpdatedUsage({
+            runId,
+            currentUsageDurationMs: currentRun.usageDurationMs,
+            currentCostInCents: currentRun.costInCents,
+            attemptDurationMs: completion.usage?.durationMs ?? 0,
+            machinePresetName: currentRun.machinePreset,
+            environmentType: latestSnapshot.environmentType,
+          });
+
           const run = await prisma.taskRun.update({
             where: { id: runId },
             data: {
@@ -709,6 +739,8 @@ export class RunAttemptSystem {
               completedAt,
               output: completion.output,
               outputType: completion.outputType,
+              usageDurationMs: updatedUsage.usageDurationMs,
+              costInCents: updatedUsage.costInCents,
               executionSnapshots: {
                 create: {
                   executionStatus: "FINISHED",
@@ -768,17 +800,16 @@ export class RunAttemptSystem {
             },
           });
 
-          if (!run.associatedWaitpoint) {
-            throw new ServiceValidationError("No associated waitpoint found", 400);
+          // Complete the waitpoint if it exists (runs without waiting parents have no waitpoint)
+          if (run.associatedWaitpoint) {
+            await this.waitpointSystem.completeWaitpoint({
+              id: run.associatedWaitpoint.id,
+              output: completion.output
+                ? { value: completion.output, type: completion.outputType, isError: false }
+                : undefined,
+            });
           }
 
-          await this.waitpointSystem.completeWaitpoint({
-            id: run.associatedWaitpoint.id,
-            output: completion.output
-              ? { value: completion.output, type: completion.outputType, isError: false }
-              : undefined,
-          });
-
           this.$.eventBus.emit("runSucceeded", {
             time: completedAt,
             run: {
@@ -865,7 +896,7 @@ export class RunAttemptSystem {
 
           const failedAt = new Date();
 
-          const retryResult = await retryOutcomeFromCompletion(prisma, {
+          const retryResult = await retryOutcomeFromCompletion(this.$.readOnlyPrisma, {
             runId,
             error: completion.error,
             retryUsingQueue: forceRequeue ?? false,
@@ -875,7 +906,7 @@ export class RunAttemptSystem {
 
           // Force requeue means it was crashed so the attempt span needs to be closed
           if (forceRequeue) {
-            const minimalRun = await prisma.taskRun.findFirst({
+            const minimalRun = await this.$.readOnlyPrisma.taskRun.findFirst({
               where: {
                 id: runId,
               },
@@ -922,6 +953,7 @@ export class RunAttemptSystem {
                 completedAt: failedAt,
                 reason: retryResult.reason,
                 finalizeRun: true,
+                attemptDurationMs: completion.usage?.durationMs,
                 tx: prisma,
               });
               return {
@@ -940,17 +972,31 @@ export class RunAttemptSystem {
                 error: retryResult.sanitizedError,
                 workerId,
                 runnerId,
+                attemptDurationMs: completion.usage?.durationMs,
               });
             }
             case "retry": {
               const retryAt = new Date(retryResult.settings.timestamp);
 
+              // Calculate new usage totals using the current machine's rate
+              // (retryResult includes current usage values from the read in retryOutcomeFromCompletion)
+              const updatedUsage = this.#calculateUpdatedUsage({
+                runId,
+                currentUsageDurationMs: retryResult.usageDurationMs,
+                currentCostInCents: retryResult.costInCents,
+                attemptDurationMs: completion.usage?.durationMs ?? 0,
+                machinePresetName: retryResult.machinePreset,
+                environmentType: latestSnapshot.environmentType,
+              });
+
               const run = await prisma.taskRun.update({
                 where: {
                   id: runId,
                 },
                 data: {
                   machinePreset: retryResult.machine,
+                  usageDurationMs: updatedUsage.usageDurationMs,
+                  costInCents: updatedUsage.costInCents,
                 },
                 include: {
                   runtimeEnvironment: {
@@ -1240,6 +1286,7 @@ export class RunAttemptSystem {
   If the run is in-progress it will change it's state to PENDING_CANCEL and notify the worker.
   If the run is not in-progress it will finish it.
   You can pass `finalizeRun` in if you know it's no longer running, e.g. the worker has messaged to say it's done.
+  You can optionally pass `attemptDurationMs` if you have completion data with usage info.
   */
   async cancelRun({
     runId,
@@ -1249,6 +1296,7 @@ export class RunAttemptSystem {
     reason,
     finalizeRun,
     bulkActionId,
+    attemptDurationMs,
     tx,
   }: {
     runId: string;
@@ -1258,6 +1306,7 @@ export class RunAttemptSystem {
     reason?: string;
     finalizeRun?: boolean;
     bulkActionId?: string;
+    attemptDurationMs?: number;
     tx?: PrismaClientOrTransaction;
   }): Promise<ExecutionResult & { alreadyFinished: boolean }> {
     const prisma = tx ?? this.$.prisma;
@@ -1304,6 +1353,32 @@ export class RunAttemptSystem {
           raw: reason,
         };
 
+        // Calculate updated usage if we have attempt duration data
+        let usageUpdate: { usageDurationMs: number; costInCents: number } | undefined;
+        if (attemptDurationMs !== undefined) {
+          const currentRun = await this.$.readOnlyPrisma.taskRun.findFirst({
+            where: { id: runId },
+            select: {
+              usageDurationMs: true,
+              costInCents: true,
+              machinePreset: true,
+            },
+          });
+
+          if (!currentRun) {
+            throw new ServiceValidationError("Run not found", 404);
+          }
+
+          usageUpdate = this.#calculateUpdatedUsage({
+            runId,
+            currentUsageDurationMs: currentRun.usageDurationMs,
+            currentCostInCents: currentRun.costInCents,
+            attemptDurationMs,
+            machinePresetName: currentRun.machinePreset,
+            environmentType: latestSnapshot.environmentType,
+          });
+        }
+
         const run = await prisma.taskRun.update({
           where: { id: runId },
           data: {
@@ -1312,9 +1387,13 @@ export class RunAttemptSystem {
             error,
             bulkActionGroupIds: bulkActionId
               ? {
-                  push: bulkActionId,
-                }
+                push: bulkActionId,
+              }
               : undefined,
+            ...(usageUpdate && {
+              usageDurationMs: usageUpdate.usageDurationMs,
+              costInCents: usageUpdate.costInCents,
+            }),
           },
           select: {
             id: true,
@@ -1358,35 +1437,39 @@ export class RunAttemptSystem {
         });
 
         //if executing, we need to message the worker to cancel the run and put it into `PENDING_CANCEL` status
+        //unless finalizeRun is true (worker is known to be dead), in which case skip straight to FINISHED
         if (
           isExecuting(latestSnapshot.executionStatus) ||
           isPendingExecuting(latestSnapshot.executionStatus)
         ) {
-          const newSnapshot = await this.executionSnapshotSystem.createExecutionSnapshot(prisma, {
-            run,
-            snapshot: {
-              executionStatus: "PENDING_CANCEL",
-              description: "Run was cancelled",
-            },
-            previousSnapshotId: latestSnapshot.id,
-            environmentId: latestSnapshot.environmentId,
-            environmentType: latestSnapshot.environmentType,
-            projectId: latestSnapshot.projectId,
-            organizationId: latestSnapshot.organizationId,
-            workerId,
-            runnerId,
-          });
+          if (!finalizeRun) {
+            const newSnapshot = await this.executionSnapshotSystem.createExecutionSnapshot(prisma, {
+              run,
+              snapshot: {
+                executionStatus: "PENDING_CANCEL",
+                description: "Run was cancelled",
+              },
+              previousSnapshotId: latestSnapshot.id,
+              environmentId: latestSnapshot.environmentId,
+              environmentType: latestSnapshot.environmentType,
+              projectId: latestSnapshot.projectId,
+              organizationId: latestSnapshot.organizationId,
+              workerId,
+              runnerId,
+            });
 
-          //the worker needs to be notified so it can kill the run and complete the attempt
-          await sendNotificationToWorker({
-            runId,
-            snapshot: newSnapshot,
-            eventBus: this.$.eventBus,
-          });
-          return {
-            alreadyFinished: false,
-            ...executionResultFromSnapshot(newSnapshot),
-          };
+            //the worker needs to be notified so it can kill the run and complete the attempt
+            await sendNotificationToWorker({
+              runId,
+              snapshot: newSnapshot,
+              eventBus: this.$.eventBus,
+            });
+            return {
+              alreadyFinished: false,
+              ...executionResultFromSnapshot(newSnapshot),
+            };
+          }
+          // finalizeRun is true — fall through to finish the run immediately
         }
 
         //not executing, so we will actually finish the run
@@ -1405,16 +1488,14 @@ export class RunAttemptSystem {
           runnerId,
         });
 
-        if (!run.associatedWaitpoint) {
-          throw new ServiceValidationError("No associated waitpoint found", 400);
+        // Complete the waitpoint if it exists (runs without waiting parents have no waitpoint)
+        if (run.associatedWaitpoint) {
+          await this.waitpointSystem.completeWaitpoint({
+            id: run.associatedWaitpoint.id,
+            output: { value: JSON.stringify(error), isError: true },
+          });
         }
 
-        //complete the waitpoint so the parent run can continue
-        await this.waitpointSystem.completeWaitpoint({
-          id: run.associatedWaitpoint.id,
-          output: { value: JSON.stringify(error), isError: true },
-        });
-
         await this.#finalizeRun(run);
 
         this.$.eventBus.emit("runCancelled", {
@@ -1470,6 +1551,7 @@ export class RunAttemptSystem {
     error,
     workerId,
     runnerId,
+    attemptDurationMs,
   }: {
     runId: string;
     latestSnapshot: EnhancedExecutionSnapshot;
@@ -1477,6 +1559,7 @@ export class RunAttemptSystem {
     error: TaskRunError;
     workerId?: string;
     runnerId?: string;
+    attemptDurationMs?: number;
   }): Promise<CompleteRunAttemptResult> {
     const prisma = this.$.prisma;
 
@@ -1485,6 +1568,30 @@ export class RunAttemptSystem {
 
       const truncatedError = this.#truncateTaskRunError(error);
 
+      // Read current usage values to calculate new totals
+      const currentRun = await this.$.readOnlyPrisma.taskRun.findFirst({
+        where: { id: runId },
+        select: {
+          usageDurationMs: true,
+          costInCents: true,
+          machinePreset: true,
+        },
+      });
+
+      if (!currentRun) {
+        throw new ServiceValidationError("Run not found", 404);
+      }
+
+      // Calculate new usage totals
+      const updatedUsage = this.#calculateUpdatedUsage({
+        runId,
+        currentUsageDurationMs: currentRun.usageDurationMs,
+        currentCostInCents: currentRun.costInCents,
+        attemptDurationMs: attemptDurationMs ?? 0,
+        machinePresetName: currentRun.machinePreset,
+        environmentType: latestSnapshot.environmentType,
+      });
+
       //run permanently failed
       const run = await prisma.taskRun.update({
         where: {
@@ -1494,6 +1601,8 @@ export class RunAttemptSystem {
           status,
           completedAt: failedAt,
           error: truncatedError,
+          usageDurationMs: updatedUsage.usageDurationMs,
+          costInCents: updatedUsage.costInCents,
         },
         select: {
           id: true,
@@ -1545,18 +1654,17 @@ export class RunAttemptSystem {
         runnerId,
       });
 
-      if (!run.associatedWaitpoint) {
-        throw new ServiceValidationError("No associated waitpoint found", 400);
-      }
-
       await this.$.runQueue.acknowledgeMessage(run.runtimeEnvironment.organizationId, runId, {
         removeFromWorkerQueue: true,
       });
 
-      await this.waitpointSystem.completeWaitpoint({
-        id: run.associatedWaitpoint.id,
-        output: { value: JSON.stringify(truncatedError), isError: true },
-      });
+      // Complete the waitpoint if it exists (runs without waiting parents have no waitpoint)
+      if (run.associatedWaitpoint) {
+        await this.waitpointSystem.completeWaitpoint({
+          id: run.associatedWaitpoint.id,
+          output: { value: JSON.stringify(truncatedError), isError: true },
+        });
+      }
 
       this.$.eventBus.emit("runFailed", {
         time: failedAt,
@@ -1610,7 +1718,7 @@ export class RunAttemptSystem {
     backgroundWorkerTaskId: string
   ): Promise<BackwardsCompatibleTaskRunExecution["task"]> {
     const result = await this.cache.tasks.swr(backgroundWorkerTaskId, async () => {
-      const task = await this.$.prisma.backgroundWorkerTask.findFirstOrThrow({
+      const task = await this.$.readOnlyPrisma.backgroundWorkerTask.findFirstOrThrow({
         where: {
           id: backgroundWorkerTaskId,
         },
@@ -1646,7 +1754,7 @@ export class RunAttemptSystem {
     organizationId: string
   ): Promise<TaskRunExecutionOrganization> {
     const result = await this.cache.orgs.swr(organizationId, async () => {
-      const organization = await this.$.prisma.organization.findFirstOrThrow({
+      const organization = await this.$.readOnlyPrisma.organization.findFirstOrThrow({
         where: { id: organizationId },
         select: {
           id: true,
@@ -1679,7 +1787,7 @@ export class RunAttemptSystem {
     runtimeEnvironmentId: string
   ): Promise<TaskRunExecutionProject> {
     const result = await this.cache.projects.swr(runtimeEnvironmentId, async () => {
-      const { project } = await this.$.prisma.runtimeEnvironment.findFirstOrThrow({
+      const { project } = await this.$.readOnlyPrisma.runtimeEnvironment.findFirstOrThrow({
         where: { id: runtimeEnvironmentId },
         select: {
           id: true,
@@ -1727,7 +1835,7 @@ export class RunAttemptSystem {
     }
 
     const result = await this.cache.machinePresets.swr(backgroundWorkerTaskId, async () => {
-      const { machineConfig } = await this.$.prisma.backgroundWorkerTask.findFirstOrThrow({
+      const { machineConfig } = await this.$.readOnlyPrisma.backgroundWorkerTask.findFirstOrThrow({
         where: {
           id: backgroundWorkerTaskId,
         },
@@ -1758,40 +1866,43 @@ export class RunAttemptSystem {
   }
 
   async #resolveTaskRunExecutionQueue(params: {
-    runId: string;
     lockedQueueId?: string;
     queueName: string;
     runtimeEnvironmentId: string;
   }): Promise<TaskRunExecutionQueue> {
-    const result = await this.cache.queues.swr(params.runId, async () => {
+    // Cache key should be based on queue identity, not run ID
+    // Using lockedQueueId if available, otherwise environment + queue name
+    const cacheKey = params.lockedQueueId ?? `${params.runtimeEnvironmentId}:${params.queueName}`;
+    const result = await this.cache.queues.swr(cacheKey, async () => {
       const queue = params.lockedQueueId
-        ? await this.$.prisma.taskQueue.findFirst({
-            where: {
-              id: params.lockedQueueId,
-            },
-            select: {
-              id: true,
-              friendlyId: true,
-              name: true,
-            },
-          })
-        : await this.$.prisma.taskQueue.findFirst({
-            where: {
-              runtimeEnvironmentId: params.runtimeEnvironmentId,
-              name: params.queueName,
-            },
-            select: {
-              id: true,
-              friendlyId: true,
-              name: true,
-            },
-          });
+        ? await this.$.readOnlyPrisma.taskQueue.findFirst({
+          where: {
+            id: params.lockedQueueId,
+          },
+          select: {
+            id: true,
+            friendlyId: true,
+            name: true,
+          },
+        })
+        : await this.$.readOnlyPrisma.taskQueue.findFirst({
+          where: {
+            runtimeEnvironmentId: params.runtimeEnvironmentId,
+            name: params.queueName,
+          },
+          select: {
+            id: true,
+            friendlyId: true,
+            name: true,
+          },
+        });
 
       if (!queue) {
-        throw new ServiceValidationError(
-          `Could not resolve queue data for queue ${params.queueName}`,
-          404
-        );
+        // Return synthetic queue so run/span view still loads (e.g. createFailedTaskRun with fallback queue)
+        return {
+          id: params.queueName,
+          name: params.queueName,
+        };
       }
 
       return {
@@ -1818,7 +1929,7 @@ export class RunAttemptSystem {
     backgroundWorkerTaskId: string
   ): Promise<TaskRunExecutionDeployment | undefined> {
     const result = await this.cache.deployments.swr(backgroundWorkerTaskId, async () => {
-      const { worker } = await this.$.prisma.backgroundWorkerTask.findFirstOrThrow({
+      const { worker } = await this.$.readOnlyPrisma.backgroundWorkerTask.findFirstOrThrow({
         where: { id: backgroundWorkerTaskId },
         select: {
           worker: {
@@ -1914,6 +2025,66 @@ export class RunAttemptSystem {
       stackTrace: truncateString(error.stackTrace, 1024 * 16), // 16kb
     };
   }
+
+  // PostgreSQL int4 max value (~24.85 days in milliseconds)
+  static readonly MAX_INT4 = 2_147_483_647;
+
+  /**
+   * Calculates the updated usage values for a run by adding the attempt's usage to the current totals.
+   * This should be called under the runLock to ensure safe read-modify-write.
+   * Cost is only calculated for non-dev environments.
+   */
+  #calculateUpdatedUsage({
+    runId,
+    currentUsageDurationMs,
+    currentCostInCents,
+    attemptDurationMs,
+    machinePresetName,
+    environmentType,
+  }: {
+    runId: string;
+    currentUsageDurationMs: number;
+    currentCostInCents: number;
+    attemptDurationMs: number;
+    machinePresetName: string | null;
+    environmentType: RuntimeEnvironmentType;
+  }): { usageDurationMs: number; costInCents: number } {
+    let usageDurationMs = currentUsageDurationMs + attemptDurationMs;
+
+    // Overflow protection: cap at PostgreSQL int4 max value
+    if (usageDurationMs > RunAttemptSystem.MAX_INT4) {
+      this.$.logger.error("usageDurationMs overflow detected, capping at max int4 value", {
+        runId,
+        currentUsageDurationMs,
+        attemptDurationMs,
+        calculatedTotal: usageDurationMs,
+        cappedAt: RunAttemptSystem.MAX_INT4,
+      });
+      usageDurationMs = RunAttemptSystem.MAX_INT4;
+    }
+
+    // Only calculate cost for non-dev environments
+    let costInCents = currentCostInCents;
+    if (environmentType !== "DEVELOPMENT") {
+      const machinePreset = machinePresetName
+        ? machinePresetFromName(
+          this.options.machines.machines,
+          machinePresetName as MachinePresetName
+        )
+        : machinePresetFromName(
+          this.options.machines.machines,
+          this.options.machines.defaultMachine
+        );
+
+      costInCents = currentCostInCents + attemptDurationMs * machinePreset.centsPerMs;
+    }
+
+    return {
+      usageDurationMs,
+      costInCents,
+    };
+  }
+
 }
 
 export function safeParseGitMeta(git: unknown): GitMeta | undefined {
diff --git a/internal-packages/run-engine/src/engine/systems/systems.ts b/internal-packages/run-engine/src/engine/systems/systems.ts
index 35790259b44..909df712105 100644
--- a/internal-packages/run-engine/src/engine/systems/systems.ts
+++ b/internal-packages/run-engine/src/engine/systems/systems.ts
@@ -1,6 +1,6 @@
 import { Meter, Tracer } from "@internal/tracing";
 import { Logger } from "@trigger.dev/core/logger";
-import { PrismaClient } from "@trigger.dev/database";
+import { PrismaClient, PrismaReplicaClient } from "@trigger.dev/database";
 import { RunQueue } from "../../run-queue/index.js";
 import { EventBus } from "../eventBus.js";
 import { RunLocker } from "../locking.js";
@@ -9,6 +9,7 @@ import { RaceSimulationSystem } from "./raceSimulationSystem.js";
 
 export type SystemResources = {
   prisma: PrismaClient;
+  readOnlyPrisma: PrismaReplicaClient;
   worker: EngineWorker;
   eventBus: EventBus;
   logger: Logger;
diff --git a/internal-packages/run-engine/src/engine/systems/ttlSystem.ts b/internal-packages/run-engine/src/engine/systems/ttlSystem.ts
index cbed7b98ad3..8d078c88890 100644
--- a/internal-packages/run-engine/src/engine/systems/ttlSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/ttlSystem.ts
@@ -1,11 +1,12 @@
 import { parseNaturalLanguageDuration } from "@trigger.dev/core/v3/isomorphic";
 import { TaskRunError } from "@trigger.dev/core/v3/schemas";
-import { PrismaClientOrTransaction } from "@trigger.dev/database";
-import { ServiceValidationError } from "../errors.js";
+import { Prisma, PrismaClientOrTransaction, TaskRunStatus } from "@trigger.dev/database";
 import { isExecuting } from "../statuses.js";
 import { getLatestExecutionSnapshot } from "./executionSnapshotSystem.js";
 import { SystemResources } from "./systems.js";
 import { WaitpointSystem } from "./waitpointSystem.js";
+import { startSpan } from "@internal/tracing";
+import pMap from "p-map";
 
 export type TtlSystemOptions = {
   resources: SystemResources;
@@ -114,15 +115,14 @@ export class TtlSystem {
         }
       );
 
-      if (!updatedRun.associatedWaitpoint) {
-        throw new ServiceValidationError("No associated waitpoint found", 400);
+      // Complete the waitpoint if it exists (runs without waiting parents have no waitpoint)
+      if (updatedRun.associatedWaitpoint) {
+        await this.waitpointSystem.completeWaitpoint({
+          id: updatedRun.associatedWaitpoint.id,
+          output: { value: JSON.stringify(error), isError: true },
+        });
       }
 
-      await this.waitpointSystem.completeWaitpoint({
-        id: updatedRun.associatedWaitpoint.id,
-        output: { value: JSON.stringify(error), isError: true },
-      });
-
       this.$.eventBus.emit("runExpired", {
         run: updatedRun,
         time: new Date(),
@@ -145,4 +145,156 @@ export class TtlSystem {
       });
     }
   }
+
+  /**
+   * Efficiently expire a batch of runs that were already atomically removed from
+   * the queue by the TTL Lua script. This method:
+   * - Does NOT use run locks (the Lua script already claimed these atomically)
+   * - Does NOT call acknowledgeMessage (the Lua script already removed from queue)
+   * - Batches database operations where possible
+   */
+  async expireRunsBatch(runIds: string[]): Promise<{
+    expired: string[];
+    skipped: { runId: string; reason: string }[];
+  }> {
+    return startSpan(
+      this.$.tracer,
+      "TtlSystem.expireRunsBatch",
+      async (span) => {
+        span.setAttribute("runCount", runIds.length);
+
+        if (runIds.length === 0) {
+          return { expired: [], skipped: [] };
+        }
+
+        const expired: string[] = [];
+        const skipped: { runId: string; reason: string }[] = [];
+
+        // Fetch all runs in a single query (no snapshot data needed)
+        const runs = await this.$.readOnlyPrisma.taskRun.findMany({
+          where: { id: { in: runIds } },
+          select: {
+            id: true,
+            spanId: true,
+            status: true,
+            lockedAt: true,
+            ttl: true,
+            taskEventStore: true,
+            createdAt: true,
+            associatedWaitpoint: { select: { id: true } },
+            organizationId: true,
+            projectId: true,
+            runtimeEnvironmentId: true,
+          },
+        });
+
+        // Filter runs that can be expired
+        const runsToExpire: typeof runs = [];
+
+        for (const run of runs) {
+          if (run.status !== "PENDING") {
+            skipped.push({ runId: run.id, reason: `status_${run.status}` });
+            continue;
+          }
+
+          if (run.lockedAt) {
+            skipped.push({ runId: run.id, reason: "locked" });
+            continue;
+          }
+
+          runsToExpire.push(run);
+        }
+
+        // Track runs that weren't found
+        const foundRunIds = new Set(runs.map((r) => r.id));
+        for (const runId of runIds) {
+          if (!foundRunIds.has(runId)) {
+            skipped.push({ runId, reason: "not_found" });
+          }
+        }
+
+        if (runsToExpire.length === 0) {
+          span.setAttribute("expiredCount", 0);
+          span.setAttribute("skippedCount", skipped.length);
+          return { expired, skipped };
+        }
+
+        // Update all runs in a single SQL call (status, dates, and error JSON)
+        const now = new Date();
+        const runIdsToExpire = runsToExpire.map((r) => r.id);
+
+        const error: TaskRunError = {
+          type: "STRING_ERROR",
+          raw: "Run expired because the TTL was reached",
+        };
+
+        await this.$.prisma.$executeRaw`
+          UPDATE "TaskRun"
+          SET "status" = 'EXPIRED'::"TaskRunStatus",
+              "completedAt" = ${now},
+              "expiredAt" = ${now},
+              "updatedAt" = ${now},
+              "error" = ${JSON.stringify(error)}::jsonb
+          WHERE "id" IN (${Prisma.join(runIdsToExpire)})
+        `;
+
+        // Process each run: enqueue waitpoint completion jobs and emit events
+        await pMap(
+          runsToExpire,
+          async (run) => {
+            try {
+              // Enqueue a finishWaitpoint worker job for resilient waitpoint completion
+              if (run.associatedWaitpoint) {
+                await this.$.worker.enqueue({
+                  id: `finishWaitpoint.ttl.${run.associatedWaitpoint.id}`,
+                  job: "finishWaitpoint",
+                  payload: {
+                    waitpointId: run.associatedWaitpoint.id,
+                    error: JSON.stringify(error),
+                  },
+                });
+              }
+
+              // This should really never happen
+              if (!run.organizationId) {
+                return;
+              }
+
+              // Emit event
+              this.$.eventBus.emit("runExpired", {
+                run: {
+                  id: run.id,
+                  spanId: run.spanId,
+                  ttl: run.ttl,
+                  taskEventStore: run.taskEventStore,
+                  createdAt: run.createdAt,
+                  updatedAt: now,
+                  completedAt: now,
+                  expiredAt: now,
+                  status: "EXPIRED" as TaskRunStatus,
+                },
+                time: now,
+                organization: { id: run.organizationId },
+                project: { id: run.projectId },
+                environment: { id: run.runtimeEnvironmentId },
+              });
+
+              expired.push(run.id);
+            } catch (e) {
+              this.$.logger.error("Failed to process expired run", {
+                runId: run.id,
+                error: e,
+              });
+            }
+          },
+          { concurrency: 10, stopOnError: false }
+        );
+
+        span.setAttribute("expiredCount", expired.length);
+        span.setAttribute("skippedCount", skipped.length);
+
+        return { expired, skipped };
+      }
+    );
+  }
 }
diff --git a/internal-packages/run-engine/src/engine/systems/waitpointSystem.ts b/internal-packages/run-engine/src/engine/systems/waitpointSystem.ts
index 40a92abb550..d650c1c6d08 100644
--- a/internal-packages/run-engine/src/engine/systems/waitpointSystem.ts
+++ b/internal-packages/run-engine/src/engine/systems/waitpointSystem.ts
@@ -4,6 +4,7 @@ import {
   Prisma,
   PrismaClientOrTransaction,
   TaskQueue,
+  TaskRun,
   TaskRunExecutionSnapshot,
   TaskRunExecutionStatus,
   Waitpoint,
@@ -14,6 +15,7 @@ import { sendNotificationToWorker } from "../eventBus.js";
 import { EnqueueSystem } from "./enqueueSystem.js";
 import { ExecutionSnapshotSystem, getLatestExecutionSnapshot } from "./executionSnapshotSystem.js";
 import { SystemResources } from "./systems.js";
+import { isFinalRunStatus } from "../statuses.js";
 
 export type WaitpointSystemOptions = {
   resources: SystemResources;
@@ -364,6 +366,22 @@ export class WaitpointSystem {
 
   /**
    * Prevents a run from continuing until the waitpoint is completed.
+   *
+   * This method uses two separate SQL statements intentionally:
+   *
+   * 1. A CTE that INSERTs TaskRunWaitpoint rows (blocking connections) and
+   *    _WaitpointRunConnections rows (historical connections).
+   *
+   * 2. A separate SELECT that checks if any of the requested waitpoints are still PENDING.
+   *
+   * These MUST be separate statements because of PostgreSQL MVCC in READ COMMITTED isolation:
+   * each statement gets its own snapshot. If a concurrent `completeWaitpoint` commits between
+   * the CTE starting and finishing, the CTE's snapshot won't see the COMPLETED status. By using
+   * a separate SELECT, we get a fresh snapshot that reflects the latest committed state.
+   *
+   * The pending check queries ALL requested waitpoint IDs (not just the ones actually inserted
+   * by the CTE). This is intentional: if a TaskRunWaitpoint row already existed (ON CONFLICT
+   * DO NOTHING skipped the insert), a still-PENDING waitpoint should still count as blocking.
    */
   async blockRunWithWaitpoint({
     runId,
@@ -397,8 +415,10 @@ export class WaitpointSystem {
     return await this.$.runLock.lock("blockRunWithWaitpoint", [runId], async () => {
       let snapshot: TaskRunExecutionSnapshot = await getLatestExecutionSnapshot(prisma, runId);
 
-      //block the run with the waitpoints, returning how many waitpoints are pending
-      const insert = await prisma.$queryRaw<{ pending_count: BigInt }[]>`
+      // Insert the blocking connections and the historical run connections.
+      // We use a CTE to do both inserts atomically. Data-modifying CTEs are
+      // always executed regardless of whether they're referenced in the outer query.
+      await prisma.$queryRaw`
         WITH inserted AS (
           INSERT INTO "TaskRunWaitpoint" ("id", "taskRunId", "waitpointId", "projectId", "createdAt", "updatedAt", "spanIdToComplete", "batchId", "batchIndex")
           SELECT
@@ -423,12 +443,21 @@ export class WaitpointSystem {
           WHERE w.id IN (${Prisma.join($waitpoints)})
           ON CONFLICT DO NOTHING
         )
+        SELECT COUNT(*) FROM inserted`;
+
+      // Check if the run is actually blocked using a separate query.
+      // This MUST be a separate statement from the CTE above because in READ COMMITTED
+      // isolation, each statement gets its own snapshot. The CTE's snapshot is taken when
+      // it starts, so if a concurrent completeWaitpoint commits during the CTE, the CTE
+      // won't see it. This fresh query gets a new snapshot that reflects the latest commits.
+      const pendingCheck = await prisma.$queryRaw<{ pending_count: BigInt }[]>`
         SELECT COUNT(*) as pending_count
-        FROM inserted i
-        JOIN "Waitpoint" w ON w.id = i."waitpointId"
-        WHERE w.status = 'PENDING';`;
+        FROM "Waitpoint"
+        WHERE id IN (${Prisma.join($waitpoints)})
+        AND status = 'PENDING'
+      `;
 
-      const isRunBlocked = Number(insert.at(0)?.pending_count ?? 0) > 0;
+      const isRunBlocked = Number(pendingCheck.at(0)?.pending_count ?? 0) > 0;
 
       let newStatus: TaskRunExecutionStatus = "SUSPENDED";
       if (
@@ -496,6 +525,121 @@ export class WaitpointSystem {
     });
   }
 
+  /**
+   * Lockless version of blockRunWithWaitpoint for batch item processing.
+   *
+   * When processing batchTriggerAndWait items, blockRunWithCreatedBatch has already
+   * transitioned the parent run to EXECUTING_WITH_WAITPOINTS before any items are
+   * processed. Per-item calls to blockRunWithWaitpoint would all compete for the same
+   * parent run lock just to insert a TaskRunWaitpoint row — causing lock contention
+   * and LockAcquisitionTimeoutError with large batches.
+   *
+   * This method performs only the CTE insert (which is idempotent via ON CONFLICT DO
+   * NOTHING) and timeout scheduling, without acquiring the parent run lock.
+   */
+  async blockRunWithWaitpointLockless({
+    runId,
+    waitpoints,
+    projectId,
+    timeout,
+    spanIdToComplete,
+    batch,
+    tx,
+  }: {
+    runId: string;
+    waitpoints: string | string[];
+    projectId: string;
+    timeout?: Date;
+    spanIdToComplete?: string;
+    batch: { id: string; index?: number };
+    tx?: PrismaClientOrTransaction;
+  }): Promise<void> {
+    const prisma = tx ?? this.$.prisma;
+    const $waitpoints = typeof waitpoints === "string" ? [waitpoints] : waitpoints;
+
+    // Insert the blocking connections and the historical run connections.
+    // No lock needed: ON CONFLICT DO NOTHING makes concurrent inserts safe,
+    // and the parent snapshot is already EXECUTING_WITH_WAITPOINTS from
+    // blockRunWithCreatedBatch.
+    await prisma.$queryRaw`
+      WITH inserted AS (
+        INSERT INTO "TaskRunWaitpoint" ("id", "taskRunId", "waitpointId", "projectId", "createdAt", "updatedAt", "spanIdToComplete", "batchId", "batchIndex")
+        SELECT
+          gen_random_uuid(),
+          ${runId},
+          w.id,
+          ${projectId},
+          NOW(),
+          NOW(),
+          ${spanIdToComplete ?? null},
+          ${batch.id},
+          ${batch.index ?? null}
+        FROM "Waitpoint" w
+        WHERE w.id IN (${Prisma.join($waitpoints)})
+        ON CONFLICT DO NOTHING
+        RETURNING "waitpointId"
+      ),
+      connected_runs AS (
+        INSERT INTO "_WaitpointRunConnections" ("A", "B")
+        SELECT ${runId}, w.id
+        FROM "Waitpoint" w
+        WHERE w.id IN (${Prisma.join($waitpoints)})
+        ON CONFLICT DO NOTHING
+      )
+      SELECT COUNT(*) FROM inserted`;
+
+    // Schedule timeout jobs if needed
+    if (timeout) {
+      for (const waitpoint of $waitpoints) {
+        await this.$.worker.enqueue({
+          id: `finishWaitpoint.${waitpoint}`,
+          job: "finishWaitpoint",
+          payload: {
+            waitpointId: waitpoint,
+            error: JSON.stringify(timeoutError(timeout)),
+          },
+          availableAt: timeout,
+        });
+      }
+    }
+  }
+
+  /**
+   * Blocks a run with a waitpoint and immediately completes the waitpoint.
+   *
+   * Used when creating a pre-failed child run: the parent needs to be blocked
+   * by the waitpoint so it can receive the error output, but the waitpoint is
+   * already resolved because the child run is terminal from the start.
+   */
+  async blockRunAndCompleteWaitpoint({
+    runId,
+    waitpointId,
+    output,
+    projectId,
+    organizationId,
+    batch,
+  }: {
+    runId: string;
+    waitpointId: string;
+    output: { value: string; type?: string; isError: boolean };
+    projectId: string;
+    organizationId: string;
+    batch?: { id: string; index?: number };
+  }): Promise<void> {
+    await this.blockRunWithWaitpoint({
+      runId,
+      waitpoints: waitpointId,
+      projectId,
+      organizationId,
+      batch,
+    });
+
+    await this.completeWaitpoint({
+      id: waitpointId,
+      output,
+    });
+  }
+
   public async continueRunIfUnblocked({
     runId,
   }: {
@@ -771,4 +915,104 @@ export class WaitpointSystem {
       environmentId,
     };
   }
+
+  /**
+   * Builds the waitpoint output payload from a completed run's stored output/error.
+   */
+  #buildWaitpointOutputFromRun(
+    run: Pick<TaskRun, "status" | "output" | "outputType" | "error">
+  ): { value: string; type?: string; isError: boolean } | undefined {
+    if (run.status === "COMPLETED_SUCCESSFULLY") {
+      if (run.output == null) {
+        return undefined;
+      }
+      return {
+        value: run.output,
+        type: run.outputType ?? undefined,
+        isError: false,
+      };
+    }
+    if (isFinalRunStatus(run.status)) {
+      return {
+        value: JSON.stringify(run.error ?? {}),
+        isError: true,
+      };
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets an existing run waitpoint or creates one lazily.
+   * Used for debounce/idempotency when a late-arriving triggerAndWait caller
+   * needs to block on an existing run that was created without a waitpoint.
+   * When the run has already completed, creates the waitpoint and immediately
+   * completes it with the run's output/error so the parent can resume.
+   */
+  public async getOrCreateRunWaitpoint({
+    runId,
+    projectId,
+    environmentId,
+  }: {
+    runId: string;
+    projectId: string;
+    environmentId: string;
+  }): Promise<Waitpoint> {
+    // Fast path: check if waitpoint already exists
+    const run = await this.$.prisma.taskRun.findFirst({
+      where: { id: runId },
+      include: { associatedWaitpoint: true },
+    });
+
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    if (run.associatedWaitpoint) {
+      return run.associatedWaitpoint;
+    }
+
+    // Need to create - use run lock to prevent races (operational decisions use latest snapshot inside lock)
+    return this.$.runLock.lock("getOrCreateRunWaitpoint", [runId], async () => {
+      const prisma = this.$.prisma;
+
+      // Double-check after acquiring lock
+      const runAfterLock = await prisma.taskRun.findFirst({
+        where: { id: runId },
+        include: { associatedWaitpoint: true },
+      });
+
+      if (!runAfterLock) {
+        throw new Error(`Run not found: ${runId}`);
+      }
+
+      if (runAfterLock.associatedWaitpoint) {
+        return runAfterLock.associatedWaitpoint;
+      }
+
+      // Operational decision: use latest execution snapshot, not TaskRun status
+      const snapshot = await getLatestExecutionSnapshot(prisma, runId);
+
+      // Create waitpoint and link to run atomically
+      const waitpointData = this.buildRunAssociatedWaitpoint({ projectId, environmentId });
+
+      const waitpoint = await prisma.waitpoint.create({
+        data: {
+          ...waitpointData,
+          completedByTaskRunId: runId,
+        },
+      });
+
+      // If run has already finished (per snapshot), complete the waitpoint immediately so the parent can resume
+      if (snapshot.executionStatus === "FINISHED") {
+        const output = this.#buildWaitpointOutputFromRun(runAfterLock);
+        const completed = await this.completeWaitpoint({
+          id: waitpoint.id,
+          output,
+        });
+        return completed;
+      }
+
+      return waitpoint;
+    });
+  }
 }
diff --git a/internal-packages/run-engine/src/engine/tests/attemptFailures.test.ts b/internal-packages/run-engine/src/engine/tests/attemptFailures.test.ts
index 55c0c8996d9..8a628148912 100644
--- a/internal-packages/run-engine/src/engine/tests/attemptFailures.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/attemptFailures.test.ts
@@ -139,16 +139,13 @@ describe("RunEngine attempt failures", () => {
       expect(result2.run.attemptNumber).toBe(2);
       expect(result2.run.status).toBe("COMPLETED_SUCCESSFULLY");
 
-      //waitpoint should have been completed, with the output
+      //standalone triggers don't create waitpoints, so none should exist
       const runWaitpointAfter = await prisma.waitpoint.findMany({
         where: {
           completedByTaskRunId: run.id,
         },
       });
-      expect(runWaitpointAfter.length).toBe(1);
-      expect(runWaitpointAfter[0].type).toBe("RUN");
-      expect(runWaitpointAfter[0].output).toBe(`{"foo":"bar"}`);
-      expect(runWaitpointAfter[0].outputIsError).toBe(false);
+      expect(runWaitpointAfter.length).toBe(0);
 
       //state should be completed
       const executionData4 = await engine.getRunExecutionData({ runId: run.id });
@@ -631,16 +628,13 @@ describe("RunEngine attempt failures", () => {
       expect(result2.run.attemptNumber).toBe(2);
       expect(result2.run.status).toBe("COMPLETED_SUCCESSFULLY");
 
-      //waitpoint should have been completed, with the output
+      //standalone triggers don't create waitpoints, so none should exist
       const runWaitpointAfter = await prisma.waitpoint.findMany({
         where: {
           completedByTaskRunId: run.id,
         },
       });
-      expect(runWaitpointAfter.length).toBe(1);
-      expect(runWaitpointAfter[0].type).toBe("RUN");
-      expect(runWaitpointAfter[0].output).toBe(`{"foo":"bar"}`);
-      expect(runWaitpointAfter[0].outputIsError).toBe(false);
+      expect(runWaitpointAfter.length).toBe(0);
 
       //state should be completed
       const executionData4 = await engine.getRunExecutionData({ runId: run.id });
diff --git a/internal-packages/run-engine/src/engine/tests/batchTrigger.test.ts b/internal-packages/run-engine/src/engine/tests/batchTrigger.test.ts
index a2936c36657..24dd062985d 100644
--- a/internal-packages/run-engine/src/engine/tests/batchTrigger.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/batchTrigger.test.ts
@@ -1,5 +1,6 @@
 import { containerTest } from "@internal/testcontainers";
 import { trace } from "@internal/tracing";
+import { TaskRunErrorCodes } from "@trigger.dev/core/v3";
 import { generateFriendlyId } from "@trigger.dev/core/v3/isomorphic";
 import { expect } from "vitest";
 import { RunEngine } from "../index.js";
@@ -182,4 +183,147 @@ describe("RunEngine batchTrigger", () => {
       await engine.quit();
     }
   });
+
+  containerTest(
+    "Batch completes when one run is triggered and one is pre-failed (simulates per-item trigger failure)",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0005,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        const batch = await prisma.batchTaskRun.create({
+          data: {
+            friendlyId: generateFriendlyId("batch"),
+            runtimeEnvironmentId: authenticatedEnvironment.id,
+            runCount: 2,
+            processingJobsCount: 2,
+            batchVersion: "runengine:v1",
+          },
+        });
+
+        const triggeredRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_batchok1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            batch: { id: batch.id, index: 0 },
+          },
+          prisma
+        );
+        expect(triggeredRun).toBeDefined();
+        expect(triggeredRun.batchId).toBe(batch.id);
+
+        const preFailedRunFriendlyId = generateFriendlyId("run");
+        const preFailedRun = await engine.createFailedTaskRun({
+          friendlyId: preFailedRunFriendlyId,
+          environment: {
+            id: authenticatedEnvironment.id,
+            type: authenticatedEnvironment.type,
+            project: { id: authenticatedEnvironment.project.id },
+            organization: { id: authenticatedEnvironment.organization.id },
+          },
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          error: {
+            type: "INTERNAL_ERROR",
+            code: TaskRunErrorCodes.BATCH_ITEM_COULD_NOT_TRIGGER,
+            message: "Queue size limit exceeded",
+          },
+          batch: { id: batch.id, index: 1 },
+        });
+        expect(preFailedRun).toBeDefined();
+        expect(preFailedRun.friendlyId).toBe(preFailedRunFriendlyId);
+        expect(preFailedRun.status).toBe("SYSTEM_FAILURE");
+        expect(preFailedRun.batchId).toBe(batch.id);
+
+        const queueLength = await engine.runQueue.lengthOfEnvQueue(authenticatedEnvironment);
+        expect(queueLength).toBe(1);
+
+        await setTimeout(500);
+        const [dequeued] = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_consumer",
+          workerQueue: "main",
+        });
+        expect(dequeued).toBeDefined();
+        const attempt = await engine.startRunAttempt({
+          runId: dequeued.run.id,
+          snapshotId: dequeued.snapshot.id,
+        });
+        await engine.completeRunAttempt({
+          runId: attempt.run.id,
+          snapshotId: attempt.snapshot.id,
+          completion: {
+            ok: true,
+            id: attempt.run.id,
+            output: `{"done":true}`,
+            outputType: "application/json",
+          },
+        });
+
+        await engine.tryCompleteBatch({ batchId: batch.id });
+        await setTimeout(3_000);
+
+        const batchAfter = await prisma.batchTaskRun.findUnique({
+          where: { id: batch.id },
+        });
+        expect(batchAfter?.status).toBe("COMPLETED");
+
+        const runs = await prisma.taskRun.findMany({
+          where: { batchId: batch.id },
+          orderBy: { createdAt: "asc" },
+        });
+        expect(runs).toHaveLength(2);
+        expect(runs[0].status).toBe("COMPLETED_SUCCESSFULLY");
+        expect(runs[1].status).toBe("SYSTEM_FAILURE");
+        expect(runs[1].friendlyId).toBe(preFailedRunFriendlyId);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
 });
diff --git a/internal-packages/run-engine/src/engine/tests/debounce.test.ts b/internal-packages/run-engine/src/engine/tests/debounce.test.ts
index 0c3d09d887c..1c201c4b4c4 100644
--- a/internal-packages/run-engine/src/engine/tests/debounce.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/debounce.test.ts
@@ -2170,5 +2170,332 @@ describe("RunEngine debounce", () => {
       }
     }
   );
+
+  containerTest(
+    "Debounce: per-trigger maxDelay overrides global maxDebounceDuration",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      // Set a long global max debounce duration (1 minute)
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        debounce: {
+          maxDebounceDurationMs: 60_000, // 1 minute global max
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // First trigger with a very short per-trigger maxDelay (1 second)
+        const run1 = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_maxwait1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "first"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "maxwait-key",
+              delay: "5s",
+              maxDelay: "1s", // Very short per-trigger maxDelay (1 second)
+            },
+          },
+          prisma
+        );
+
+        expect(run1.friendlyId).toBe("run_maxwait1");
+
+        // Wait for the per-trigger maxDelay to be exceeded (1.5s > 1s)
+        await setTimeout(1500);
+
+        // Second trigger should create a new run because per-trigger maxDelay exceeded
+        // (even though global maxDebounceDurationMs is 60 seconds)
+        const run2 = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_maxwait2",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "second"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "maxwait-key",
+              delay: "5s",
+              maxDelay: "1s",
+            },
+          },
+          prisma
+        );
+
+        // Should be a different run because per-trigger maxDelay was exceeded
+        expect(run2.id).not.toBe(run1.id);
+        expect(run2.friendlyId).toBe("run_maxwait2");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Debounce: falls back to global config when maxDelay not specified",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      // Set a very short global max debounce duration (1 second)
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        debounce: {
+          maxDebounceDurationMs: 1000, // 1 second global max
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // First trigger without maxDelay - should use global config
+        const run1 = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_noglobal1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "first"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "global-fallback-key",
+              delay: "5s",
+              // No maxDelay specified - should use global maxDebounceDurationMs
+            },
+          },
+          prisma
+        );
+
+        // Wait for global maxDebounceDurationMs to be exceeded (1.5s > 1s)
+        await setTimeout(1500);
+
+        // Second trigger should create a new run because global max exceeded
+        const run2 = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_noglobal2",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "second"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "global-fallback-key",
+              delay: "5s",
+            },
+          },
+          prisma
+        );
+
+        // Should be a different run because global max exceeded
+        expect(run2.id).not.toBe(run1.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Debounce: long maxDelay allows more debounce time than global config",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      // Set a short global max debounce duration (1 second)
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        debounce: {
+          maxDebounceDurationMs: 1000, // 1 second global max
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // First trigger with long maxDelay that overrides the short global config
+        const run1 = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_longmax1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "first"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 2000),
+            debounce: {
+              key: "long-maxwait-key",
+              delay: "2s",
+              maxDelay: "60s", // Long per-trigger maxDelay overrides short global config
+            },
+          },
+          prisma
+        );
+
+        // Wait past the global maxDebounceDurationMs (1s) but within our per-trigger maxDelay (60s)
+        await setTimeout(1500);
+
+        // Second trigger should return SAME run because per-trigger maxDelay is 60s
+        const run2 = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_longmax2",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: '{"data": "second"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 2000),
+            debounce: {
+              key: "long-maxwait-key",
+              delay: "2s",
+              maxDelay: "60s",
+            },
+          },
+          prisma
+        );
+
+        // Should be the SAME run because per-trigger maxDelay allows it
+        expect(run2.id).toBe(run1.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
 });
 
diff --git a/internal-packages/run-engine/src/engine/tests/dequeuing.test.ts b/internal-packages/run-engine/src/engine/tests/dequeuing.test.ts
index 8ea142f630a..5871bee832b 100644
--- a/internal-packages/run-engine/src/engine/tests/dequeuing.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/dequeuing.test.ts
@@ -1,9 +1,10 @@
-import { containerTest } from "@internal/testcontainers";
+import { assertNonNullable, containerTest } from "@internal/testcontainers";
 import { trace } from "@internal/tracing";
 import { DequeuedMessage } from "@trigger.dev/core/v3";
 import { generateFriendlyId } from "@trigger.dev/core/v3/isomorphic";
 import { PrismaClientOrTransaction } from "@trigger.dev/database";
 import { expect } from "vitest";
+import { setTimeout } from "node:timers/promises";
 import { MinimalAuthenticatedEnvironment } from "../../shared/index.js";
 import { RunEngine } from "../index.js";
 import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "./setup.js";
@@ -79,6 +80,137 @@ describe("RunEngine dequeuing", () => {
       await engine.quit();
     }
   });
+
+  containerTest(
+    "Direct nack after dequeue clears concurrency and allows recovery",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      // Use a short heartbeat timeout so the stalled system recovers the run quickly
+      const pendingExecutingTimeout = 1000;
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0005,
+        },
+        heartbeatTimeoutsMs: {
+          PENDING_EXECUTING: pendingExecutingTimeout,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        // Setup background worker
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a single run
+        const runs = await triggerRuns({
+          engine,
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          prisma,
+          count: 1,
+        });
+        expect(runs.length).toBe(1);
+        const run = runs[0];
+
+        // Process master queue to move run to worker queue
+        await engine.runQueue.processMasterQueueForEnvironment(authenticatedEnvironment.id, 1);
+
+        // Wait for processing
+        await setTimeout(500);
+
+        // Dequeue from worker queue - this puts run in concurrency sets and creates PENDING_EXECUTING snapshot
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        expect(dequeued.length).toBe(1);
+        assertNonNullable(dequeued[0]);
+
+        // Verify run is in PENDING_EXECUTING state
+        const executionDataBefore = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionDataBefore);
+        expect(executionDataBefore.snapshot.executionStatus).toBe("PENDING_EXECUTING");
+
+        // Verify run is in concurrency
+        const envConcurrencyBefore = await engine.runQueue.currentConcurrencyOfEnvironment(
+          authenticatedEnvironment
+        );
+        expect(envConcurrencyBefore).toBe(1);
+
+        // Simulate DB failure fallback: call nackMessage directly via Redis
+        // This is what happens when the catch block can't read from Postgres
+        await engine.runQueue.nackMessage({
+          orgId: authenticatedEnvironment.organization.id,
+          messageId: run.id,
+        });
+
+        // Verify concurrency is cleared - this is the key fix!
+        // Without this fix, the run would stay in concurrency sets forever
+        const envConcurrencyAfter = await engine.runQueue.currentConcurrencyOfEnvironment(
+          authenticatedEnvironment
+        );
+        expect(envConcurrencyAfter).toBe(0);
+
+        // Verify the message is back in the queue
+        const envQueueLength = await engine.runQueue.lengthOfEnvQueue(authenticatedEnvironment);
+        expect(envQueueLength).toBe(1);
+
+        // Wait for the stalled system to detect and recover the PENDING_EXECUTING run
+        // The stalled system will call tryNackAndRequeue which updates Postgres state to QUEUED
+        await setTimeout(pendingExecutingTimeout * 5);
+
+        // Verify the stalled system recovered the run to QUEUED state
+        const executionDataAfterStall = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionDataAfterStall);
+        expect(executionDataAfterStall.snapshot.executionStatus).toBe("QUEUED");
+
+        // Process master queue to move the run from env queue to worker queue
+        await engine.runQueue.processMasterQueueForEnvironment(authenticatedEnvironment.id, 1);
+
+        // Wait for processing
+        await setTimeout(500);
+
+        // Dequeue from worker queue - the run should now be available
+        const dequeuedAgain = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        expect(dequeuedAgain.length).toBe(1);
+        assertNonNullable(dequeuedAgain[0]);
+        expect(dequeuedAgain[0].run.id).toBe(run.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
 });
 
 async function triggerRuns({
diff --git a/internal-packages/run-engine/src/engine/tests/getSnapshotsSince.test.ts b/internal-packages/run-engine/src/engine/tests/getSnapshotsSince.test.ts
new file mode 100644
index 00000000000..77867b1b1b1
--- /dev/null
+++ b/internal-packages/run-engine/src/engine/tests/getSnapshotsSince.test.ts
@@ -0,0 +1,682 @@
+import { containerTest } from "@internal/testcontainers";
+import { trace } from "@internal/tracing";
+import { expect, describe } from "vitest";
+import { RunEngine } from "../index.js";
+import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "./setup.js";
+import { setTimeout } from "node:timers/promises";
+import {
+  generateTestScenarios,
+  type SnapshotTestScenario,
+} from "./helpers/executionStateMachine.js";
+import {
+  createWaitpointsWithOutput,
+  setupTestScenario,
+  generateLargeOutput,
+} from "./helpers/snapshotTestHelpers.js";
+import { generateFriendlyId } from "@trigger.dev/core/v3/isomorphic";
+
+vi.setConfig({ testTimeout: 120_000 });
+
+describe("RunEngine getSnapshotsSince", () => {
+  containerTest(
+    "returns empty array when querying from latest snapshot",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        const runFriendlyId = generateFriendlyId("run");
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: runFriendlyId,
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t_empty",
+            spanId: "s_empty",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_empty",
+          workerQueue: "main",
+        });
+
+        // Get all snapshots
+        const allSnapshots = await prisma.taskRunExecutionSnapshot.findMany({
+          where: { runId: run.id, isValid: true },
+          orderBy: { createdAt: "asc" },
+        });
+
+        expect(allSnapshots.length).toBeGreaterThan(0);
+
+        // Query from the last snapshot
+        const lastSnapshot = allSnapshots[allSnapshots.length - 1];
+        const result = await engine.getSnapshotsSince({
+          runId: run.id,
+          snapshotId: lastSnapshot.id,
+        });
+
+        expect(result).not.toBeNull();
+        expect(result!.length).toBe(0);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "returns snapshots after the specified one with waitpoints only on latest",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        const runFriendlyId = generateFriendlyId("run");
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: runFriendlyId,
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t_wp",
+            spanId: "s_wp",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_wp",
+          workerQueue: "main",
+        });
+
+        // Start attempt
+        await engine.startRunAttempt({
+          runId: dequeued[0].run.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+
+        // Create and block with a waitpoint
+        const { waitpoint } = await engine.createDateTimeWaitpoint({
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+          completedAfter: new Date(Date.now() + 50),
+        });
+
+        await engine.blockRunWithWaitpoint({
+          runId: run.id,
+          waitpoints: [waitpoint.id],
+          projectId: authenticatedEnvironment.project.id,
+          organizationId: authenticatedEnvironment.organization.id,
+        });
+
+        // Poll until the waitpoint is completed by the background worker
+        for (let i = 0; i < 50; i++) {
+          await setTimeout(100);
+          const wp = await prisma.waitpoint.findFirst({
+            where: { id: waitpoint.id },
+            select: { status: true },
+          });
+          if (wp?.status === "COMPLETED") break;
+        }
+
+        // Allow time for the snapshot to be created after waitpoint completion
+        await setTimeout(200);
+
+        // Get all snapshots
+        const allSnapshots = await prisma.taskRunExecutionSnapshot.findMany({
+          where: { runId: run.id, isValid: true },
+          orderBy: { createdAt: "asc" },
+        });
+
+        expect(allSnapshots.length).toBeGreaterThanOrEqual(3);
+
+        // Query from the first snapshot
+        const result = await engine.getSnapshotsSince({
+          runId: run.id,
+          snapshotId: allSnapshots[0].id,
+        });
+
+        expect(result).not.toBeNull();
+        expect(result!.length).toBeGreaterThanOrEqual(2);
+
+        // The latest snapshot should have completedWaitpoints if the waitpoint was completed.
+        // Note: This depends on timing - the finishWaitpoint job needs to have processed.
+        const latest = result![result!.length - 1];
+        // completedWaitpoints may be empty if the waitpoint hasn't been processed yet
+        // This is acceptable as the test is primarily about snapshot ordering
+
+        // Earlier snapshots should have empty waitpoints (optimization)
+        for (let i = 0; i < result!.length - 1; i++) {
+          expect(result![i].completedWaitpoints.length).toBe(0);
+        }
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "handles multiple waitpoints correctly - only latest has them",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        const runFriendlyId = generateFriendlyId("run");
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: runFriendlyId,
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t_mwp",
+            spanId: "s_mwp",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_mwp",
+          workerQueue: "main",
+        });
+
+        await engine.startRunAttempt({
+          runId: dequeued[0].run.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+
+        // Create multiple waitpoints
+        const waitpointCount = 5;
+        const waitpointPromises = Array.from({ length: waitpointCount }).map(() =>
+          engine.createManualWaitpoint({
+            environmentId: authenticatedEnvironment.id,
+            projectId: authenticatedEnvironment.projectId,
+          })
+        );
+        const waitpoints = await Promise.all(waitpointPromises);
+
+        // Block the run with all waitpoints
+        for (const { waitpoint } of waitpoints) {
+          await engine.blockRunWithWaitpoint({
+            runId: run.id,
+            waitpoints: waitpoint.id,
+            projectId: authenticatedEnvironment.projectId,
+            organizationId: authenticatedEnvironment.organizationId,
+          });
+        }
+
+        // Complete all waitpoints
+        for (const { waitpoint } of waitpoints) {
+          await engine.completeWaitpoint({ id: waitpoint.id });
+        }
+
+        await setTimeout(500);
+
+        // Get all snapshots
+        const allSnapshots = await prisma.taskRunExecutionSnapshot.findMany({
+          where: { runId: run.id, isValid: true },
+          orderBy: { createdAt: "asc" },
+        });
+
+        // Query from early in the sequence
+        const result = await engine.getSnapshotsSince({
+          runId: run.id,
+          snapshotId: allSnapshots[0].id,
+        });
+
+        expect(result).not.toBeNull();
+        expect(result!.length).toBeGreaterThan(0);
+
+        // Only the latest should have waitpoints
+        const latest = result![result!.length - 1];
+
+        // Earlier snapshots must have empty completedWaitpoints
+        for (let i = 0; i < result!.length - 1; i++) {
+          expect(result![i].completedWaitpoints.length).toBe(0);
+        }
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest("returns null for invalid snapshot ID", async ({ prisma, redisOptions }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      const runFriendlyId = generateFriendlyId("run");
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: runFriendlyId,
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t_invalid",
+          spanId: "s_invalid",
+          workerQueue: "main",
+          queue: "task/test-task",
+          isTest: false,
+          tags: [],
+        },
+        prisma
+      );
+
+      // Query with invalid snapshot ID
+      const result = await engine.getSnapshotsSince({
+        runId: run.id,
+        snapshotId: "invalid-snapshot-id",
+      });
+
+      // Should return null (caught by getSnapshotsSince error handler)
+      expect(result).toBeNull();
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  // Direct database tests for the core function
+  containerTest(
+    "direct test: large waitpoint scenario - 100 waitpoints with 10KB outputs",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        // Create scenario directly in database
+        const scenario = await setupTestScenario(prisma, authenticatedEnvironment, {
+          totalWaitpoints: 100,
+          outputSizeKB: 10,
+          snapshotConfigs: [
+            { status: "RUN_CREATED", completedWaitpointCount: 0 },
+            { status: "QUEUED", completedWaitpointCount: 0 },
+            { status: "PENDING_EXECUTING", completedWaitpointCount: 0 },
+            { status: "EXECUTING", completedWaitpointCount: 0 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 50 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+            { status: "EXECUTING", completedWaitpointCount: 100 },
+            { status: "FINISHED", completedWaitpointCount: 100 },
+          ],
+        });
+
+        // Query from early snapshot
+        const result = await engine.getSnapshotsSince({
+          runId: scenario.run.id,
+          snapshotId: scenario.snapshots[2].id, // After PENDING_EXECUTING
+        });
+
+        expect(result).not.toBeNull();
+        expect(result!.length).toBe(6); // EXECUTING through FINISHED
+
+        // Latest should have all 100 waitpoints
+        const latest = result![result!.length - 1];
+        expect(latest.completedWaitpoints.length).toBe(100);
+
+        // Verify all earlier snapshots have empty waitpoints
+        for (let i = 0; i < result!.length - 1; i++) {
+          expect(result![i].completedWaitpoints.length).toBe(0);
+        }
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "direct test: zombie run scenario - 236 waitpoints with 100KB outputs, 24 snapshots",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        // This scenario matches the exact conditions that caused the NAPI error
+        // 24 snapshots × 236 waitpoints × 100KB = ~570MB if not optimized
+        const scenario = await setupTestScenario(prisma, authenticatedEnvironment, {
+          totalWaitpoints: 236,
+          outputSizeKB: 100,
+          snapshotConfigs: [
+            { status: "RUN_CREATED", completedWaitpointCount: 0 },
+            { status: "QUEUED", completedWaitpointCount: 0 },
+            { status: "PENDING_EXECUTING", completedWaitpointCount: 0 },
+            { status: "EXECUTING", completedWaitpointCount: 0 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 200 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+            { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+            { status: "QUEUED", completedWaitpointCount: 236 },
+            { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+            { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+            { status: "QUEUED", completedWaitpointCount: 236 },
+            { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+            { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+            { status: "QUEUED", completedWaitpointCount: 236 },
+            { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING", completedWaitpointCount: 236 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+            { status: "EXECUTING", completedWaitpointCount: 236 },
+          ],
+        });
+
+        expect(scenario.snapshots.length).toBe(24);
+        expect(scenario.waitpoints.length).toBe(236);
+
+        // Query from the 6th snapshot (after waitpoints start completing)
+        const queryFromIndex = 5;
+        const result = await engine.getSnapshotsSince({
+          runId: scenario.run.id,
+          snapshotId: scenario.snapshots[queryFromIndex].id,
+        });
+
+        expect(result).not.toBeNull();
+        // Should return snapshots after index 5, which is 24 - 6 = 18 snapshots
+        expect(result!.length).toBe(24 - queryFromIndex - 1);
+
+        // Latest should have all 236 waitpoints
+        const latest = result![result!.length - 1];
+        expect(latest.completedWaitpoints.length).toBe(236);
+
+        // All other snapshots should have 0 waitpoints (optimization)
+        for (let i = 0; i < result!.length - 1; i++) {
+          expect(result![i].completedWaitpoints.length).toBe(0);
+        }
+
+        // Verify the outputs are present and correct size
+        for (const wp of latest.completedWaitpoints) {
+          expect(wp.output).toBeDefined();
+          // ~100KB output as JSON string
+          expect(typeof wp.output).toBe("string");
+        }
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "direct test: verifies chunked fetching works with 500+ waitpoints",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        // 500 waitpoints requires 5 chunks (100 per chunk)
+        const scenario = await setupTestScenario(prisma, authenticatedEnvironment, {
+          totalWaitpoints: 500,
+          outputSizeKB: 10, // Smaller outputs for faster test
+          snapshotConfigs: [
+            { status: "RUN_CREATED", completedWaitpointCount: 0 },
+            { status: "QUEUED", completedWaitpointCount: 0 },
+            { status: "EXECUTING", completedWaitpointCount: 0 },
+            { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 500 },
+            { status: "EXECUTING", completedWaitpointCount: 500 },
+          ],
+        });
+
+        const result = await engine.getSnapshotsSince({
+          runId: scenario.run.id,
+          snapshotId: scenario.snapshots[0].id,
+        });
+
+        expect(result).not.toBeNull();
+        expect(result!.length).toBe(4);
+
+        const latest = result![result!.length - 1];
+        expect(latest.completedWaitpoints.length).toBe(500);
+
+        // All other snapshots should be empty
+        for (let i = 0; i < result!.length - 1; i++) {
+          expect(result![i].completedWaitpoints.length).toBe(0);
+        }
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+});
diff --git a/internal-packages/run-engine/src/engine/tests/helpers/executionStateMachine.ts b/internal-packages/run-engine/src/engine/tests/helpers/executionStateMachine.ts
new file mode 100644
index 00000000000..4dd92cdbd41
--- /dev/null
+++ b/internal-packages/run-engine/src/engine/tests/helpers/executionStateMachine.ts
@@ -0,0 +1,257 @@
+import { TaskRunExecutionStatus } from "@trigger.dev/database";
+
+/**
+ * Defines valid execution status transitions for the Run Engine 2.0.
+ * This is a model of the state machine that governs run execution.
+ */
+export const EXECUTION_STATUS_TRANSITIONS: Record<
+  TaskRunExecutionStatus,
+  TaskRunExecutionStatus[]
+> = {
+  RUN_CREATED: ["QUEUED", "DELAYED"],
+  DELAYED: ["QUEUED"],
+  QUEUED: ["PENDING_EXECUTING", "QUEUED_EXECUTING"],
+  QUEUED_EXECUTING: ["PENDING_EXECUTING", "QUEUED"],
+  PENDING_EXECUTING: ["EXECUTING", "PENDING_CANCEL", "FINISHED", "QUEUED"],
+  EXECUTING: ["EXECUTING_WITH_WAITPOINTS", "FINISHED", "PENDING_CANCEL", "QUEUED"],
+  EXECUTING_WITH_WAITPOINTS: ["EXECUTING", "SUSPENDED", "FINISHED", "PENDING_CANCEL"],
+  SUSPENDED: ["QUEUED", "PENDING_CANCEL", "FINISHED"],
+  PENDING_CANCEL: ["FINISHED"],
+  FINISHED: ["QUEUED"], // Retry case
+};
+
+/**
+ * Validates if a transition from one status to another is valid.
+ */
+export function isValidTransition(
+  from: TaskRunExecutionStatus,
+  to: TaskRunExecutionStatus
+): boolean {
+  return EXECUTION_STATUS_TRANSITIONS[from]?.includes(to) ?? false;
+}
+
+/**
+ * Configuration for a snapshot in a test scenario.
+ */
+export interface SnapshotConfig {
+  /** The execution status for this snapshot */
+  status: TaskRunExecutionStatus;
+  /** Number of waitpoints completed at this snapshot (cumulative) */
+  completedWaitpointCount: number;
+  /** Whether this snapshot has a checkpoint */
+  hasCheckpoint?: boolean;
+  /** Description for the snapshot */
+  description?: string;
+}
+
+/**
+ * A test scenario for getSnapshotsSince testing.
+ */
+export interface SnapshotTestScenario {
+  /** Unique name for the scenario */
+  name: string;
+  /** Description of what this scenario tests */
+  description: string;
+  /** Total number of waitpoints to create */
+  totalWaitpoints: number;
+  /** Size of each waitpoint's output in KB */
+  outputSizeKB: number;
+  /** Configuration for each snapshot to create */
+  snapshots: SnapshotConfig[];
+  /** Which snapshot index to query "since" (0-based) */
+  queryFromIndex: number;
+  /** Expected number of waitpoints on the latest snapshot returned */
+  expectedWaitpointsOnLatest: number;
+}
+
+/**
+ * Generates test scenarios for comprehensive getSnapshotsSince testing.
+ * These scenarios cover various edge cases and stress tests.
+ */
+export function generateTestScenarios(): SnapshotTestScenario[] {
+  return [
+    {
+      name: "simple_no_waitpoints",
+      description: "Basic run without any waitpoints",
+      totalWaitpoints: 0,
+      outputSizeKB: 0,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "FINISHED", completedWaitpointCount: 0 },
+      ],
+      queryFromIndex: 0,
+      expectedWaitpointsOnLatest: 0,
+    },
+    {
+      name: "single_small_waitpoint",
+      description: "Single waitpoint with small output",
+      totalWaitpoints: 1,
+      outputSizeKB: 1,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 1 },
+      ],
+      queryFromIndex: 2,
+      expectedWaitpointsOnLatest: 1,
+    },
+    {
+      name: "batch_100_medium",
+      description: "Medium batch with 100 waitpoints and medium outputs",
+      totalWaitpoints: 100,
+      outputSizeKB: 10,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 50 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+        { status: "SUSPENDED", completedWaitpointCount: 100, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 100 },
+        { status: "EXECUTING", completedWaitpointCount: 100 },
+        { status: "FINISHED", completedWaitpointCount: 100 },
+      ],
+      queryFromIndex: 3,
+      expectedWaitpointsOnLatest: 100,
+    },
+    {
+      name: "batch_236_large_zombie_scenario",
+      description:
+        "Matches the zombie run scenario: 24 snapshots, 236 waitpoints, 100KB outputs each",
+      totalWaitpoints: 236,
+      outputSizeKB: 100,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 50 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 150 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 200 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+      ],
+      queryFromIndex: 6,
+      expectedWaitpointsOnLatest: 236,
+    },
+    {
+      name: "batch_500_large",
+      description: "Large batch requiring chunked fetching",
+      totalWaitpoints: 500,
+      outputSizeKB: 50,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 250 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 400 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 500 },
+        { status: "SUSPENDED", completedWaitpointCount: 500, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 500 },
+        { status: "EXECUTING", completedWaitpointCount: 500 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 500 },
+        { status: "SUSPENDED", completedWaitpointCount: 500, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 500 },
+        { status: "EXECUTING", completedWaitpointCount: 500 },
+      ],
+      queryFromIndex: 5,
+      expectedWaitpointsOnLatest: 500,
+    },
+    {
+      name: "system_failure_finished",
+      description: "Latest snapshot is FINISHED status with completed waitpoints",
+      totalWaitpoints: 100,
+      outputSizeKB: 50,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 50 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 100 },
+        { status: "EXECUTING", completedWaitpointCount: 100 },
+        { status: "FINISHED", completedWaitpointCount: 100 },
+      ],
+      queryFromIndex: 3,
+      expectedWaitpointsOnLatest: 100,
+    },
+    {
+      name: "query_from_latest",
+      description: "Querying from the latest snapshot should return empty array",
+      totalWaitpoints: 10,
+      outputSizeKB: 10,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 10 },
+      ],
+      queryFromIndex: 4, // The last snapshot
+      expectedWaitpointsOnLatest: 0, // No snapshots returned, so no waitpoints
+    },
+    {
+      name: "requeue_loop",
+      description: "Multiple QUEUED->PENDING_EXECUTING cycles with waitpoints",
+      totalWaitpoints: 236,
+      outputSizeKB: 100,
+      snapshots: [
+        { status: "RUN_CREATED", completedWaitpointCount: 0 },
+        { status: "QUEUED", completedWaitpointCount: 0 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 0 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "QUEUED", completedWaitpointCount: 236 }, // Requeued
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "QUEUED", completedWaitpointCount: 236 }, // Requeued again
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "QUEUED", completedWaitpointCount: 236 }, // Requeued
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "QUEUED", completedWaitpointCount: 236 }, // Requeued again
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING_WITH_WAITPOINTS", completedWaitpointCount: 236 },
+        { status: "SUSPENDED", completedWaitpointCount: 236, hasCheckpoint: true },
+        { status: "QUEUED", completedWaitpointCount: 236 },
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "QUEUED", completedWaitpointCount: 236 }, // Requeued
+        { status: "PENDING_EXECUTING", completedWaitpointCount: 236 },
+        { status: "EXECUTING", completedWaitpointCount: 236 },
+      ],
+      queryFromIndex: 7,
+      expectedWaitpointsOnLatest: 236,
+    },
+  ];
+}
diff --git a/internal-packages/run-engine/src/engine/tests/helpers/snapshotTestHelpers.ts b/internal-packages/run-engine/src/engine/tests/helpers/snapshotTestHelpers.ts
new file mode 100644
index 00000000000..f981f35145f
--- /dev/null
+++ b/internal-packages/run-engine/src/engine/tests/helpers/snapshotTestHelpers.ts
@@ -0,0 +1,322 @@
+import { generateFriendlyId, WaitpointId } from "@trigger.dev/core/v3/isomorphic";
+import {
+  PrismaClient,
+  TaskRunExecutionSnapshot,
+  TaskRunExecutionStatus,
+  Waitpoint,
+  WaitpointStatus,
+} from "@trigger.dev/database";
+import type { AuthenticatedEnvironment } from "../setup.js";
+
+/**
+ * Generates a large output string of the specified size in KB.
+ * The output is a valid JSON string to simulate realistic waitpoint output.
+ */
+export function generateLargeOutput(sizeKB: number): string {
+  if (sizeKB <= 0) return JSON.stringify({ data: "" });
+
+  // Create a string that's approximately the target size
+  // Account for JSON wrapper overhead
+  const targetBytes = sizeKB * 1024;
+  const overhead = JSON.stringify({ data: "" }).length;
+  const payloadSize = Math.max(0, targetBytes - overhead);
+
+  // Generate a payload of repeating 'x' characters
+  const payload = "x".repeat(payloadSize);
+  return JSON.stringify({ data: payload });
+}
+
+/**
+ * Creates waitpoints with specified output sizes for testing.
+ */
+export async function createWaitpointsWithOutput(
+  prisma: PrismaClient,
+  count: number,
+  outputSizeKB: number,
+  environmentId: string,
+  projectId: string
+): Promise<Waitpoint[]> {
+  if (count === 0) return [];
+
+  const output = generateLargeOutput(outputSizeKB);
+  const waitpoints: Waitpoint[] = [];
+
+  // Create waitpoints in batches to avoid overwhelming the database
+  const batchSize = 50;
+  for (let i = 0; i < count; i += batchSize) {
+    const batchCount = Math.min(batchSize, count - i);
+    const batch = await Promise.all(
+      Array.from({ length: batchCount }).map(async (_, j) => {
+        const waitpointIds = WaitpointId.generate();
+        return prisma.waitpoint.create({
+          data: {
+            id: waitpointIds.id,
+            friendlyId: waitpointIds.friendlyId,
+            type: "MANUAL",
+            status: "COMPLETED" as WaitpointStatus,
+            idempotencyKey: `test-idempotency-${waitpointIds.id}`,
+            userProvidedIdempotencyKey: false,
+            completedAt: new Date(),
+            output,
+            outputType: "application/json",
+            outputIsError: false,
+            environmentId,
+            projectId,
+          },
+        });
+      })
+    );
+    waitpoints.push(...batch);
+  }
+
+  return waitpoints;
+}
+
+/**
+ * Creates a snapshot directly in the database for testing purposes.
+ * This bypasses the normal engine flow to allow creating specific test scenarios.
+ */
+export async function createTestSnapshot(
+  prisma: PrismaClient,
+  {
+    runId,
+    status,
+    environmentId,
+    environmentType,
+    projectId,
+    organizationId,
+    completedWaitpointIds,
+    checkpointId,
+    previousSnapshotId,
+    batchId,
+    workerId,
+    runnerId,
+    attemptNumber,
+  }: {
+    runId: string;
+    status: TaskRunExecutionStatus;
+    environmentId: string;
+    environmentType: "PRODUCTION" | "STAGING" | "DEVELOPMENT" | "PREVIEW";
+    projectId: string;
+    organizationId: string;
+    completedWaitpointIds?: string[];
+    checkpointId?: string;
+    previousSnapshotId?: string;
+    batchId?: string;
+    workerId?: string;
+    runnerId?: string;
+    attemptNumber?: number;
+  }
+): Promise<TaskRunExecutionSnapshot> {
+  // Determine run status based on execution status
+  const runStatus = getRunStatusFromExecutionStatus(status);
+
+  const snapshot = await prisma.taskRunExecutionSnapshot.create({
+    data: {
+      engine: "V2",
+      executionStatus: status,
+      description: `Test snapshot: ${status}`,
+      previousSnapshotId,
+      runId,
+      runStatus,
+      attemptNumber,
+      batchId,
+      environmentId,
+      environmentType,
+      projectId,
+      organizationId,
+      checkpointId,
+      workerId,
+      runnerId,
+      isValid: true,
+      completedWaitpoints: completedWaitpointIds
+        ? {
+            connect: completedWaitpointIds.map((id) => ({ id })),
+          }
+        : undefined,
+      completedWaitpointOrder: completedWaitpointIds ?? [],
+    },
+  });
+
+  // Small delay to ensure different createdAt timestamps
+  await new Promise((resolve) => setTimeout(resolve, 5));
+
+  return snapshot;
+}
+
+/**
+ * Maps execution status to run status for test snapshot creation.
+ */
+function getRunStatusFromExecutionStatus(
+  status: TaskRunExecutionStatus
+): "PENDING" | "EXECUTING" | "WAITING_FOR_DEPLOY" | "COMPLETED_SUCCESSFULLY" | "SYSTEM_FAILURE" {
+  switch (status) {
+    case "RUN_CREATED":
+    case "QUEUED":
+    case "QUEUED_EXECUTING":
+    case "PENDING_EXECUTING":
+    case "DELAYED":
+      return "PENDING";
+    case "EXECUTING":
+    case "EXECUTING_WITH_WAITPOINTS":
+    case "SUSPENDED":
+    case "PENDING_CANCEL":
+      return "EXECUTING";
+    case "FINISHED":
+      return "COMPLETED_SUCCESSFULLY";
+    default:
+      return "PENDING";
+  }
+}
+
+/**
+ * Creates a checkpoint for testing suspended snapshots.
+ */
+export async function createTestCheckpoint(
+  prisma: PrismaClient,
+  {
+    runId,
+    environmentId,
+    projectId,
+  }: {
+    runId: string;
+    environmentId: string;
+    projectId: string;
+  }
+) {
+  return prisma.taskRunCheckpoint.create({
+    data: {
+      friendlyId: generateFriendlyId("checkpoint"),
+      type: "DOCKER",
+      location: `s3://test-bucket/checkpoints/${runId}`,
+      imageRef: `test-image:${runId}`,
+      reason: "WAIT_FOR_DURATION",
+      runtimeEnvironment: {
+        connect: { id: environmentId },
+      },
+      project: {
+        connect: { id: projectId },
+      },
+    },
+  });
+}
+
+/**
+ * Interface for a complete test scenario setup result.
+ */
+export interface TestScenarioResult {
+  run: {
+    id: string;
+    friendlyId: string;
+  };
+  snapshots: TaskRunExecutionSnapshot[];
+  waitpoints: Waitpoint[];
+  checkpoints: Array<{ id: string }>;
+}
+
+/**
+ * Sets up a complete test scenario with run, snapshots, waitpoints, and checkpoints.
+ * This creates the full database state needed for testing getSnapshotsSince.
+ */
+export async function setupTestScenario(
+  prisma: PrismaClient,
+  environment: AuthenticatedEnvironment,
+  {
+    totalWaitpoints,
+    outputSizeKB,
+    snapshotConfigs,
+  }: {
+    totalWaitpoints: number;
+    outputSizeKB: number;
+    snapshotConfigs: Array<{
+      status: TaskRunExecutionStatus;
+      completedWaitpointCount: number;
+      hasCheckpoint?: boolean;
+    }>;
+  }
+): Promise<TestScenarioResult> {
+  // Create waitpoints first
+  const waitpoints = await createWaitpointsWithOutput(
+    prisma,
+    totalWaitpoints,
+    outputSizeKB,
+    environment.id,
+    environment.project.id
+  );
+
+  // Create the run
+  const runFriendlyId = generateFriendlyId("run");
+  const run = await prisma.taskRun.create({
+    data: {
+      friendlyId: runFriendlyId,
+      engine: "V2",
+      status: "PENDING",
+      runtimeEnvironmentId: environment.id,
+      environmentType: environment.type,
+      organizationId: environment.organization.id,
+      projectId: environment.project.id,
+      taskIdentifier: "test-task",
+      payload: "{}",
+      payloadType: "application/json",
+      traceId: `trace_${runFriendlyId}`,
+      spanId: `span_${runFriendlyId}`,
+      context: {},
+      traceContext: {},
+      isTest: false,
+      queue: "task/test-task",
+      workerQueue: "main",
+    },
+  });
+
+  // Create snapshots in order
+  const snapshots: TaskRunExecutionSnapshot[] = [];
+  const checkpoints: Array<{ id: string }> = [];
+  let previousSnapshotId: string | undefined;
+  let attemptNumber = 0;
+
+  for (const config of snapshotConfigs) {
+    // Create checkpoint if needed
+    let checkpointId: string | undefined;
+    if (config.hasCheckpoint) {
+      const checkpoint = await createTestCheckpoint(prisma, {
+        runId: run.id,
+        environmentId: environment.id,
+        projectId: environment.project.id,
+      });
+      checkpointId = checkpoint.id;
+      checkpoints.push({ id: checkpoint.id });
+    }
+
+    // Increment attempt number when entering a new execution attempt
+    // PENDING_EXECUTING is the entry point - EXECUTING follows within the same attempt
+    if (config.status === "PENDING_EXECUTING") {
+      attemptNumber++;
+    }
+
+    // Get the waitpoint IDs that should be "completed" at this snapshot
+    const completedWaitpointIds = waitpoints.slice(0, config.completedWaitpointCount).map((w) => w.id);
+
+    const snapshot = await createTestSnapshot(prisma, {
+      runId: run.id,
+      status: config.status,
+      environmentId: environment.id,
+      environmentType: environment.type,
+      projectId: environment.project.id,
+      organizationId: environment.organization.id,
+      completedWaitpointIds,
+      checkpointId,
+      previousSnapshotId,
+      attemptNumber,
+    });
+
+    snapshots.push(snapshot);
+    previousSnapshotId = snapshot.id;
+  }
+
+  return {
+    run: { id: run.id, friendlyId: runFriendlyId },
+    snapshots,
+    waitpoints,
+    checkpoints,
+  };
+}
diff --git a/internal-packages/run-engine/src/engine/tests/lazyWaitpoint.test.ts b/internal-packages/run-engine/src/engine/tests/lazyWaitpoint.test.ts
new file mode 100644
index 00000000000..bc24f9b6f1a
--- /dev/null
+++ b/internal-packages/run-engine/src/engine/tests/lazyWaitpoint.test.ts
@@ -0,0 +1,1342 @@
+import { containerTest, assertNonNullable } from "@internal/testcontainers";
+import { trace } from "@internal/tracing";
+import { expect } from "vitest";
+import { RunEngine } from "../index.js";
+import { setTimeout } from "node:timers/promises";
+import { setupAuthenticatedEnvironment, setupBackgroundWorker } from "./setup.js";
+
+vi.setConfig({ testTimeout: 60_000 });
+
+describe("RunEngine lazy waitpoint creation", () => {
+  containerTest(
+    "No waitpoint for standalone trigger (no parent)",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a run WITHOUT resumeParentOnCompletion
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_standalone1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+            // No resumeParentOnCompletion, no parentTaskRunId
+          },
+          prisma
+        );
+
+        // Verify run was created
+        expect(run.friendlyId).toBe("run_standalone1");
+
+        // Verify NO associated waitpoint was created
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.associatedWaitpoint).toBeNull();
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest("Waitpoint created for triggerAndWait", async ({ prisma, redisOptions }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        masterQueueConsumersDisabled: true,
+        processWorkerQueueDebounceMs: 50,
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const parentTask = "parent-task";
+      const childTask = "child-task";
+
+      await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+      // Trigger parent run
+      const parentRun = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_parent1",
+          environment: authenticatedEnvironment,
+          taskIdentifier: parentTask,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t12345",
+          spanId: "s12345",
+          queue: `task/${parentTask}`,
+          isTest: false,
+          tags: [],
+          workerQueue: "main",
+        },
+        prisma
+      );
+
+      // Dequeue parent and start attempt
+      await setTimeout(500);
+      const dequeued = await engine.dequeueFromWorkerQueue({
+        consumerId: "test_12345",
+        workerQueue: "main",
+      });
+      await engine.startRunAttempt({
+        runId: parentRun.id,
+        snapshotId: dequeued[0].snapshot.id,
+      });
+
+      // Trigger child with triggerAndWait
+      const childRun = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_child1",
+          environment: authenticatedEnvironment,
+          taskIdentifier: childTask,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t12346",
+          spanId: "s12346",
+          queue: `task/${childTask}`,
+          isTest: false,
+          tags: [],
+          resumeParentOnCompletion: true,
+          parentTaskRunId: parentRun.id,
+          workerQueue: "main",
+        },
+        prisma
+      );
+
+      // Verify child run has associated waitpoint
+      const dbChildRun = await prisma.taskRun.findFirst({
+        where: { id: childRun.id },
+        include: { associatedWaitpoint: true },
+      });
+      assertNonNullable(dbChildRun);
+      assertNonNullable(dbChildRun.associatedWaitpoint);
+      expect(dbChildRun.associatedWaitpoint.type).toBe("RUN");
+      expect(dbChildRun.associatedWaitpoint.completedByTaskRunId).toBe(childRun.id);
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest(
+    "Completion without waitpoint succeeds",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a standalone run (no waitpoint)
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_complete1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Verify no waitpoint
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.associatedWaitpoint).toBeNull();
+
+        // Dequeue and start the run
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        const attemptResult = await engine.startRunAttempt({
+          runId: run.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+
+        // Complete the run - should NOT throw even without waitpoint
+        const completeResult = await engine.completeRunAttempt({
+          runId: run.id,
+          snapshotId: attemptResult.snapshot.id,
+          completion: {
+            id: run.id,
+            ok: true,
+            output: '{"result":"success"}',
+            outputType: "application/json",
+          },
+        });
+
+        // Verify run completed successfully
+        expect(completeResult.attemptStatus).toBe("RUN_FINISHED");
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.run.status).toBe("COMPLETED_SUCCESSFULLY");
+        expect(executionData.snapshot.executionStatus).toBe("FINISHED");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Cancellation without waitpoint succeeds",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a standalone run (no waitpoint)
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_cancel1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Verify no waitpoint
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.associatedWaitpoint).toBeNull();
+
+        // Cancel the run - should NOT throw even without waitpoint
+        const cancelResult = await engine.cancelRun({
+          runId: run.id,
+          reason: "Test cancellation",
+        });
+
+        // Verify run was cancelled
+        expect(cancelResult.alreadyFinished).toBe(false);
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.run.status).toBe("CANCELED");
+        expect(executionData.snapshot.executionStatus).toBe("FINISHED");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "TTL expiration without waitpoint succeeds",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+          ttlSystem: {
+            pollIntervalMs: 100,
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a standalone run with TTL (no waitpoint)
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_ttl1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Verify no waitpoint
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.associatedWaitpoint).toBeNull();
+
+        // Wait for TTL to expire
+        await setTimeout(1_500);
+
+        // Verify run expired successfully (no throw)
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.run.status).toBe("EXPIRED");
+        expect(executionData.snapshot.executionStatus).toBe("FINISHED");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "getOrCreateRunWaitpoint: returns existing waitpoint",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const parentTask = "parent-task";
+        const childTask = "child-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+        // Create parent run
+        const parentRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_parent1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: parentTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            queue: `task/${parentTask}`,
+            isTest: false,
+            tags: [],
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        // Dequeue and start parent
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        await engine.startRunAttempt({
+          runId: parentRun.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+
+        // Create child with triggerAndWait (waitpoint created at trigger time)
+        const childRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_child1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            resumeParentOnCompletion: true,
+            parentTaskRunId: parentRun.id,
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        // Get the existing waitpoint
+        const dbChildRun = await prisma.taskRun.findFirst({
+          where: { id: childRun.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbChildRun);
+        assertNonNullable(dbChildRun.associatedWaitpoint);
+        const existingWaitpointId = dbChildRun.associatedWaitpoint.id;
+
+        // Call getOrCreateRunWaitpoint - should return the existing one
+        const waitpoint = await engine.getOrCreateRunWaitpoint({
+          runId: childRun.id,
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+        });
+
+        assertNonNullable(waitpoint);
+        expect(waitpoint.id).toBe(existingWaitpointId);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "getOrCreateRunWaitpoint: creates waitpoint lazily",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Create a standalone run (no waitpoint)
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_lazy1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Verify no waitpoint initially
+        const dbRunBefore = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRunBefore);
+        expect(dbRunBefore.associatedWaitpoint).toBeNull();
+
+        // Call getOrCreateRunWaitpoint - should create one
+        const waitpoint = await engine.getOrCreateRunWaitpoint({
+          runId: run.id,
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+        });
+
+        assertNonNullable(waitpoint);
+        expect(waitpoint.type).toBe("RUN");
+        expect(waitpoint.status).toBe("PENDING");
+
+        // Verify waitpoint is now linked to the run
+        const dbRunAfter = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRunAfter);
+        assertNonNullable(dbRunAfter.associatedWaitpoint);
+        expect(dbRunAfter.associatedWaitpoint.id).toBe(waitpoint.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "getOrCreateRunWaitpoint: returns completed waitpoint for completed run",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Create a standalone run
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_completed1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Dequeue and complete the run
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        const attemptResult = await engine.startRunAttempt({
+          runId: run.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+        await engine.completeRunAttempt({
+          runId: run.id,
+          snapshotId: attemptResult.snapshot.id,
+          completion: {
+            id: run.id,
+            ok: true,
+            output: '{"result":"done"}',
+            outputType: "application/json",
+          },
+        });
+
+        // Verify run is completed
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.status).toBe("COMPLETED_SUCCESSFULLY");
+
+        // Call getOrCreateRunWaitpoint - should create and return a completed waitpoint with run output
+        const waitpoint = await engine.getOrCreateRunWaitpoint({
+          runId: run.id,
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+        });
+
+        assertNonNullable(waitpoint);
+        expect(waitpoint.status).toBe("COMPLETED");
+        expect(waitpoint.output).toBe('{"result":"done"}');
+        expect(waitpoint.outputType).toBe("application/json");
+        expect(waitpoint.outputIsError).toBe(false);
+
+        // Verify waitpoint is linked to run
+        const runWithWaitpoint = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(runWithWaitpoint);
+        assertNonNullable(runWithWaitpoint.associatedWaitpoint);
+        expect(runWithWaitpoint.associatedWaitpoint.id).toBe(waitpoint.id);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "getOrCreateRunWaitpoint: creates completed waitpoint for failed run",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Create a standalone run
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_failed1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Dequeue and fail the run
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        const attemptResult = await engine.startRunAttempt({
+          runId: run.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+        const errorPayload = {
+          type: "BUILT_IN_ERROR" as const,
+          name: "Error",
+          message: "Something broke",
+          stackTrace: "Error: Something broke",
+        };
+        await engine.completeRunAttempt({
+          runId: run.id,
+          snapshotId: attemptResult.snapshot.id,
+          completion: {
+            id: run.id,
+            ok: false,
+            error: errorPayload,
+          },
+        });
+
+        const dbRun = await prisma.taskRun.findFirst({
+          where: { id: run.id },
+        });
+        assertNonNullable(dbRun);
+        expect(dbRun.status).toBe("COMPLETED_WITH_ERRORS");
+
+        const waitpoint = await engine.getOrCreateRunWaitpoint({
+          runId: run.id,
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+        });
+
+        assertNonNullable(waitpoint);
+        expect(waitpoint.status).toBe("COMPLETED");
+        expect(waitpoint.outputIsError).toBe(true);
+        const parsedOutput = JSON.parse(waitpoint.output ?? "{}");
+        expect(parsedOutput.type).toBe("BUILT_IN_ERROR");
+        expect(parsedOutput.message).toBe("Something broke");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "getOrCreateRunWaitpoint: concurrent calls create only one waitpoint",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Create a standalone run (no waitpoint)
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_concurrent1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${taskIdentifier}`,
+            isTest: false,
+            tags: [],
+          },
+          prisma
+        );
+
+        // Call getOrCreateRunWaitpoint concurrently from multiple "callers"
+        const [waitpoint1, waitpoint2, waitpoint3] = await Promise.all([
+          engine.getOrCreateRunWaitpoint({
+            runId: run.id,
+            projectId: authenticatedEnvironment.project.id,
+            environmentId: authenticatedEnvironment.id,
+          }),
+          engine.getOrCreateRunWaitpoint({
+            runId: run.id,
+            projectId: authenticatedEnvironment.project.id,
+            environmentId: authenticatedEnvironment.id,
+          }),
+          engine.getOrCreateRunWaitpoint({
+            runId: run.id,
+            projectId: authenticatedEnvironment.project.id,
+            environmentId: authenticatedEnvironment.id,
+          }),
+        ]);
+
+        // All should return the same waitpoint
+        assertNonNullable(waitpoint1);
+        assertNonNullable(waitpoint2);
+        assertNonNullable(waitpoint3);
+        expect(waitpoint2.id).toBe(waitpoint1.id);
+        expect(waitpoint3.id).toBe(waitpoint1.id);
+
+        // Verify only one waitpoint exists for this run
+        const waitpoints = await prisma.waitpoint.findMany({
+          where: { completedByTaskRunId: run.id },
+        });
+        expect(waitpoints.length).toBe(1);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Debounce lazy creation: first trigger (no parent) -> second trigger (with parent)",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        debounce: {
+          maxDebounceDurationMs: 60_000,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const parentTask = "parent-task";
+        const childTask = "child-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+        // First trigger: standalone (no parent waiting) with debounce
+        const run1 = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_debounce1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: '{"data": "first"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "lazy-test",
+              delay: "5s",
+            },
+            // No resumeParentOnCompletion, no parentTaskRunId
+          },
+          prisma
+        );
+
+        // Verify no waitpoint initially
+        const dbRunBefore = await prisma.taskRun.findFirst({
+          where: { id: run1.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRunBefore);
+        expect(dbRunBefore.associatedWaitpoint).toBeNull();
+
+        // Create and start parent run
+        const parentRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_parent1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: parentTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12347",
+            spanId: "s12347",
+            queue: `task/${parentTask}`,
+            isTest: false,
+            tags: [],
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        await engine.startRunAttempt({
+          runId: parentRun.id,
+          snapshotId: dequeued[0].snapshot.id,
+        });
+
+        // Second trigger: with parent waiting (triggerAndWait)
+        const run2 = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_debounce2",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: '{"data": "second"}',
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            workerQueue: "main",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            delayUntil: new Date(Date.now() + 5000),
+            debounce: {
+              key: "lazy-test",
+              delay: "5s",
+            },
+            resumeParentOnCompletion: true,
+            parentTaskRunId: parentRun.id,
+          },
+          prisma
+        );
+
+        // Should return the same debounced run
+        expect(run2.id).toBe(run1.id);
+
+        // Verify waitpoint was lazily created
+        const dbRunAfter = await prisma.taskRun.findFirst({
+          where: { id: run1.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(dbRunAfter);
+        assertNonNullable(dbRunAfter.associatedWaitpoint);
+        expect(dbRunAfter.associatedWaitpoint.type).toBe("RUN");
+
+        // Verify parent is blocked by the waitpoint
+        const parentExecData = await engine.getRunExecutionData({ runId: parentRun.id });
+        assertNonNullable(parentExecData);
+        expect(parentExecData.snapshot.executionStatus).toBe("EXECUTING_WITH_WAITPOINTS");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Lazy waitpoint for already-completed child: parent blocks then resumes with child output",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const parentTask = "parent-task";
+        const childTask = "child-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+        // Create parent run and start it (EXECUTING)
+        const parentRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_plazy1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: parentTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            queue: `task/${parentTask}`,
+            isTest: false,
+            tags: [],
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeuedParent = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        await engine.startRunAttempt({
+          runId: parentRun.id,
+          snapshotId: dequeuedParent[0].snapshot.id,
+        });
+
+        // Create child run standalone (no waitpoint), then complete it
+        const childRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_clazy1",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        await setTimeout(500);
+        const dequeuedChild = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+        const childAttemptResult = await engine.startRunAttempt({
+          runId: childRun.id,
+          snapshotId: dequeuedChild[0].snapshot.id,
+        });
+        await engine.completeRunAttempt({
+          runId: childRun.id,
+          snapshotId: childAttemptResult.snapshot.id,
+          completion: {
+            id: childRun.id,
+            ok: true,
+            output: '{"idempotent":"result"}',
+            outputType: "application/json",
+          },
+        });
+
+        const childAfter = await prisma.taskRun.findFirst({
+          where: { id: childRun.id },
+          include: { associatedWaitpoint: true },
+        });
+        assertNonNullable(childAfter);
+        expect(childAfter.status).toBe("COMPLETED_SUCCESSFULLY");
+        expect(childAfter.associatedWaitpoint).toBeNull();
+
+        // Simulate idempotency/debounce path: getOrCreateRunWaitpoint for completed child, then block parent
+        const waitpoint = await engine.getOrCreateRunWaitpoint({
+          runId: childRun.id,
+          projectId: authenticatedEnvironment.project.id,
+          environmentId: authenticatedEnvironment.id,
+        });
+
+        assertNonNullable(waitpoint);
+        expect(waitpoint.status).toBe("COMPLETED");
+        expect(waitpoint.output).toBe('{"idempotent":"result"}');
+
+        await engine.blockRunWithWaitpoint({
+          runId: parentRun.id,
+          waitpoints: waitpoint.id,
+          spanIdToComplete: "span-to-complete",
+          projectId: authenticatedEnvironment.project.id,
+          organizationId: authenticatedEnvironment.organizationId,
+          tx: prisma,
+        });
+
+        // Worker will process continueRunIfUnblocked (waitpoint already completed)
+        await setTimeout(500);
+
+        const parentExecData = await engine.getRunExecutionData({ runId: parentRun.id });
+        assertNonNullable(parentExecData);
+        expect(parentExecData.snapshot.executionStatus).toBe("EXECUTING");
+        expect(parentExecData.completedWaitpoints?.length).toBe(1);
+        expect(parentExecData.completedWaitpoints![0].id).toBe(waitpoint.id);
+        expect(parentExecData.completedWaitpoints![0].output).toBe('{"idempotent":"result"}');
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+});
diff --git a/internal-packages/run-engine/src/engine/tests/locking.test.ts b/internal-packages/run-engine/src/engine/tests/locking.test.ts
index 04b43fd19ae..53b59ddced0 100644
--- a/internal-packages/run-engine/src/engine/tests/locking.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/locking.test.ts
@@ -6,7 +6,7 @@ import { trace } from "@internal/tracing";
 import { Logger } from "@trigger.dev/core/logger";
 
 describe("RunLocker", () => {
-  redisTest("Test acquiring a lock works", { timeout: 15_000 }, async ({ redisOptions }) => {
+  redisTest("Test acquiring a lock works", { timeout: 60_000 }, async ({ redisOptions }) => {
     const redis = createRedisClient(redisOptions);
     const logger = new Logger("RunLockTest", "debug");
     const runLock = new RunLocker({
diff --git a/internal-packages/run-engine/src/engine/tests/trigger.test.ts b/internal-packages/run-engine/src/engine/tests/trigger.test.ts
index 0fd5921f100..a4f500e72aa 100644
--- a/internal-packages/run-engine/src/engine/tests/trigger.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/trigger.test.ts
@@ -90,14 +90,13 @@ describe("RunEngine trigger()", () => {
       assertNonNullable(executionData);
       expect(executionData.snapshot.executionStatus).toBe("QUEUED");
 
-      //check the waitpoint is created
+      //standalone triggers don't create waitpoints eagerly (lazy creation when needed)
       const runWaitpoint = await prisma.waitpoint.findMany({
         where: {
           completedByTaskRunId: run.id,
         },
       });
-      expect(runWaitpoint.length).toBe(1);
-      expect(runWaitpoint[0].type).toBe("RUN");
+      expect(runWaitpoint.length).toBe(0);
 
       //check the queue length
       const queueLength = await engine.runQueue.lengthOfQueue(authenticatedEnvironment, run.queue);
@@ -192,15 +191,13 @@ describe("RunEngine trigger()", () => {
       );
       expect(envConcurrencyCompleted).toBe(0);
 
-      //waitpoint should have been completed, with the output
+      //standalone triggers don't create waitpoints, so none should exist
       const runWaitpointAfter = await prisma.waitpoint.findMany({
         where: {
           completedByTaskRunId: run.id,
         },
       });
-      expect(runWaitpointAfter.length).toBe(1);
-      expect(runWaitpointAfter[0].type).toBe("RUN");
-      expect(runWaitpointAfter[0].output).toBe(`{"foo":"bar"}`);
+      expect(runWaitpointAfter.length).toBe(0);
     } finally {
       await engine.quit();
     }
@@ -320,19 +317,214 @@ describe("RunEngine trigger()", () => {
       );
       expect(envConcurrencyCompleted).toBe(0);
 
-      //waitpoint should have been completed, with the output
+      //standalone triggers don't create waitpoints, so none should exist
       const runWaitpointAfter = await prisma.waitpoint.findMany({
         where: {
           completedByTaskRunId: run.id,
         },
       });
-      expect(runWaitpointAfter.length).toBe(1);
-      expect(runWaitpointAfter[0].type).toBe("RUN");
-      const output = JSON.parse(runWaitpointAfter[0].output as string);
-      expect(output.type).toBe(error.type);
-      expect(runWaitpointAfter[0].outputIsError).toBe(true);
+      expect(runWaitpointAfter.length).toBe(0);
     } finally {
       await engine.quit();
     }
   });
+
+  containerTest("Annotations are stored on the run", async ({ prisma, redisOptions }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        masterQueueConsumersDisabled: true,
+        processWorkerQueueDebounceMs: 50,
+      },
+      runLock: { redis: redisOptions },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": { name: "small-1x" as const, cpu: 0.5, memory: 0.5, centsPerMs: 0.0001 },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_ann1234",
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t12345",
+          spanId: "s12345",
+          workerQueue: "main",
+          queue: `task/${taskIdentifier}`,
+          isTest: false,
+          tags: [],
+          annotations: {
+            triggerSource: "schedule",
+            triggerAction: "trigger",
+            rootTriggerSource: "schedule",
+            rootScheduleId: "sched_abc123",
+          },
+        },
+        prisma
+      );
+
+      const runFromDb = await prisma.taskRun.findUnique({
+        where: { id: run.id },
+      });
+
+      expect(runFromDb).toBeDefined();
+      expect(runFromDb?.annotations).toEqual({
+        triggerSource: "schedule",
+        triggerAction: "trigger",
+        rootTriggerSource: "schedule",
+        rootScheduleId: "sched_abc123",
+      });
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest(
+    "Annotations propagation pattern (parent → child)",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          masterQueueConsumersDisabled: true,
+          processWorkerQueueDebounceMs: 50,
+        },
+        runLock: { redis: redisOptions },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const parentTask = "parent-task";
+        const childTask = "child-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+        // Trigger parent with schedule annotations
+        const parentRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_p1234ann",
+            environment: authenticatedEnvironment,
+            taskIdentifier: parentTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            workerQueue: "main",
+            queue: `task/${parentTask}`,
+            isTest: false,
+            tags: [],
+            annotations: {
+              triggerSource: "schedule",
+              triggerAction: "trigger",
+              rootTriggerSource: "schedule",
+              rootScheduleId: "sched_abc123",
+            },
+          },
+          prisma
+        );
+
+        // Trigger child — simulating what RunEngineTriggerTaskService builds:
+        // triggerSource is "sdk" (child triggered from within parent),
+        // but rootTriggerSource and rootScheduleId are propagated from parent
+        const childRun = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_c1234ann",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12346",
+            workerQueue: "main",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            parentTaskRunId: parentRun.id,
+            resumeParentOnCompletion: true,
+            annotations: {
+              triggerSource: "sdk",
+              triggerAction: "trigger",
+              rootTriggerSource: "schedule",
+              rootScheduleId: "sched_abc123",
+            },
+          },
+          prisma
+        );
+
+        const parentFromDb = await prisma.taskRun.findUnique({
+          where: { id: parentRun.id },
+        });
+        const childFromDb = await prisma.taskRun.findUnique({
+          where: { id: childRun.id },
+        });
+
+        // Parent: schedule-triggered
+        expect(parentFromDb?.annotations).toEqual({
+          triggerSource: "schedule",
+          triggerAction: "trigger",
+          rootTriggerSource: "schedule",
+          rootScheduleId: "sched_abc123",
+        });
+
+        // Child: sdk-triggered but root is still schedule
+        expect(childFromDb?.annotations).toEqual({
+          triggerSource: "sdk",
+          triggerAction: "trigger",
+          rootTriggerSource: "schedule",
+          rootScheduleId: "sched_abc123",
+        });
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
 });
diff --git a/internal-packages/run-engine/src/engine/tests/ttl.test.ts b/internal-packages/run-engine/src/engine/tests/ttl.test.ts
index 737fd6fbade..c1df00bf13f 100644
--- a/internal-packages/run-engine/src/engine/tests/ttl.test.ts
+++ b/internal-packages/run-engine/src/engine/tests/ttl.test.ts
@@ -25,6 +25,10 @@ describe("RunEngine ttl", () => {
         redis: redisOptions,
         processWorkerQueueDebounceMs: 50,
         masterQueueConsumersDisabled: true,
+        ttlSystem: {
+          pollIntervalMs: 100,
+          batchSize: 10,
+        },
       },
       runLock: {
         redis: redisOptions,
@@ -92,19 +96,1342 @@ describe("RunEngine ttl", () => {
       const assertedExpiredEventData = expiredEventData as EventBusEventArgs<"runExpired">[0];
       expect(assertedExpiredEventData.run.spanId).toBe(run.spanId);
 
-      const executionData2 = await engine.getRunExecutionData({ runId: run.id });
-      assertNonNullable(executionData2);
-      expect(executionData2.snapshot.executionStatus).toBe("FINISHED");
-      expect(executionData2.run.attemptNumber).toBe(undefined);
-      expect(executionData2.run.status).toBe("EXPIRED");
+      // Check the run status directly from the database (the batch TTL path
+      // does not create execution snapshots, so getRunExecutionData may not reflect it)
+      const expiredRun = await prisma.taskRun.findUnique({
+        where: { id: run.id },
+        select: { status: true },
+      });
+      expect(expiredRun?.status).toBe("EXPIRED");
 
       //concurrency should have been released
       const envConcurrencyCompleted = await engine.runQueue.currentConcurrencyOfEnvironment(
         authenticatedEnvironment
       );
       expect(envConcurrencyCompleted).toBe(0);
+
+      // Queue sorted set should be empty (run removed from queue)
+      const queueLength = await engine.runQueue.lengthOfQueue(
+        authenticatedEnvironment,
+        "task/test-task"
+      );
+      expect(queueLength).toBe(0);
+
+      // Env queue sorted set should be empty
+      const envQueueLength = await engine.runQueue.lengthOfEnvQueue(authenticatedEnvironment);
+      expect(envQueueLength).toBe(0);
+
+      // Message key should be deleted
+      const messageExists = await engine.runQueue.messageExists(
+        authenticatedEnvironment.organization.id,
+        run.id
+      );
+      expect(messageExists).toBe(0);
     } finally {
       await engine.quit();
     }
   });
+
+  containerTest("First enqueue from trigger includes ttlExpiresAt in message", async ({
+    prisma,
+    redisOptions,
+  }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        processWorkerQueueDebounceMs: 50,
+        masterQueueConsumersDisabled: true,
+        ttlSystem: {
+          pollIntervalMs: 100,
+          batchSize: 10,
+        },
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_ttlmsg1",
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t_ttl",
+          spanId: "s_ttl",
+          workerQueue: "main",
+          queue: "task/test-task",
+          isTest: false,
+          tags: [],
+          ttl: "1s",
+        },
+        prisma
+      );
+
+      const message = await engine.runQueue.readMessage(
+        authenticatedEnvironment.organization.id,
+        run.id
+      );
+      assertNonNullable(message);
+      expect(message.ttlExpiresAt).toBeDefined();
+      expect(typeof message.ttlExpiresAt).toBe("number");
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest("Re-enqueue with includeTtl false does not set ttlExpiresAt", async ({
+    prisma,
+    redisOptions,
+  }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        processWorkerQueueDebounceMs: 50,
+        masterQueueConsumersDisabled: true,
+        ttlSystem: {
+          pollIntervalMs: 100,
+          batchSize: 10,
+        },
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_reenq01",
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t_re",
+          spanId: "s_re",
+          workerQueue: "main",
+          queue: "task/test-task",
+          isTest: false,
+          tags: [],
+          ttl: "1s",
+        },
+        prisma
+      );
+
+      const messageAfterTrigger = await engine.runQueue.readMessage(
+        authenticatedEnvironment.organization.id,
+        run.id
+      );
+      assertNonNullable(messageAfterTrigger);
+      expect(messageAfterTrigger.ttlExpiresAt).toBeDefined();
+
+      await engine.enqueueSystem.enqueueRun({
+        run,
+        env: authenticatedEnvironment,
+        tx: prisma,
+        skipRunLock: true,
+        includeTtl: false,
+      });
+
+      const messageAfterReenqueue = await engine.runQueue.readMessage(
+        authenticatedEnvironment.organization.id,
+        run.id
+      );
+      assertNonNullable(messageAfterReenqueue);
+      expect(messageAfterReenqueue.ttlExpiresAt).toBeUndefined();
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest("Multiple runs expiring via TTL batch", async ({ prisma, redisOptions }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const expiredEvents: EventBusEventArgs<"runExpired">[0][] = [];
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        processWorkerQueueDebounceMs: 50,
+        masterQueueConsumersDisabled: true,
+        ttlSystem: {
+          pollIntervalMs: 100,
+          batchSize: 10,
+        },
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      engine.eventBus.on("runExpired", (result) => {
+        expiredEvents.push(result);
+      });
+
+      // Trigger multiple runs with short TTL
+      const runs = await Promise.all(
+        [1, 2, 3].map((n) =>
+          engine.trigger(
+            {
+              number: n,
+              friendlyId: `run_b${n}234`,
+              environment: authenticatedEnvironment,
+              taskIdentifier,
+              payload: "{}",
+              payloadType: "application/json",
+              context: {},
+              traceContext: {},
+              traceId: `t${n}`,
+              spanId: `s${n}`,
+              workerQueue: "main",
+              queue: "task/test-task",
+              isTest: false,
+              tags: [],
+              ttl: "1s",
+            },
+            prisma
+          )
+        )
+      );
+
+      // Verify all runs are queued
+      for (const run of runs) {
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.snapshot.executionStatus).toBe("QUEUED");
+      }
+
+      // Wait for TTL to expire
+      await setTimeout(1_500);
+
+      // All runs should be expired
+      expect(expiredEvents.length).toBe(3);
+
+      // Check the run status directly from the database (the batch TTL path
+      // does not create execution snapshots, so getRunExecutionData may not reflect it)
+      for (const run of runs) {
+        const expiredRun = await prisma.taskRun.findUnique({
+          where: { id: run.id },
+          select: { status: true },
+        });
+        expect(expiredRun?.status).toBe("EXPIRED");
+      }
+
+      // Concurrency should be released for all
+      const envConcurrency = await engine.runQueue.currentConcurrencyOfEnvironment(
+        authenticatedEnvironment
+      );
+      expect(envConcurrency).toBe(0);
+
+      // Queue sorted set should be empty (all runs removed from queue)
+      const queueLength = await engine.runQueue.lengthOfQueue(
+        authenticatedEnvironment,
+        "task/test-task"
+      );
+      expect(queueLength).toBe(0);
+
+      // Env queue sorted set should be empty
+      const envQueueLength = await engine.runQueue.lengthOfEnvQueue(authenticatedEnvironment);
+      expect(envQueueLength).toBe(0);
+
+      // All message keys should be deleted
+      for (const run of runs) {
+        const messageExists = await engine.runQueue.messageExists(
+          authenticatedEnvironment.organization.id,
+          run.id
+        );
+        expect(messageExists).toBe(0);
+      }
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest("Run without TTL does not expire", async ({ prisma, redisOptions }) => {
+    const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+    const expiredEvents: EventBusEventArgs<"runExpired">[0][] = [];
+
+    const engine = new RunEngine({
+      prisma,
+      worker: {
+        redis: redisOptions,
+        workers: 1,
+        tasksPerWorker: 10,
+        pollIntervalMs: 100,
+      },
+      queue: {
+        redis: redisOptions,
+        processWorkerQueueDebounceMs: 50,
+        masterQueueConsumersDisabled: true,
+        ttlSystem: {
+          pollIntervalMs: 100,
+          batchSize: 10,
+        },
+      },
+      runLock: {
+        redis: redisOptions,
+      },
+      machines: {
+        defaultMachine: "small-1x",
+        machines: {
+          "small-1x": {
+            name: "small-1x" as const,
+            cpu: 0.5,
+            memory: 0.5,
+            centsPerMs: 0.0001,
+          },
+        },
+        baseCostInCents: 0.0001,
+      },
+      tracer: trace.getTracer("test", "0.0.0"),
+    });
+
+    try {
+      const taskIdentifier = "test-task";
+
+      await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+      engine.eventBus.on("runExpired", (result) => {
+        expiredEvents.push(result);
+      });
+
+      // Trigger a run WITHOUT TTL
+      const run = await engine.trigger(
+        {
+          number: 1,
+          friendlyId: "run_n1234",
+          environment: authenticatedEnvironment,
+          taskIdentifier,
+          payload: "{}",
+          payloadType: "application/json",
+          context: {},
+          traceContext: {},
+          traceId: "t1",
+          spanId: "s1",
+          workerQueue: "main",
+          queue: "task/test-task",
+          isTest: false,
+          tags: [],
+          // No TTL specified
+        },
+        prisma
+      );
+
+      // Wait a bit
+      await setTimeout(500);
+
+      // Run should still be queued, not expired
+      expect(expiredEvents.length).toBe(0);
+
+      const executionData = await engine.getRunExecutionData({ runId: run.id });
+      assertNonNullable(executionData);
+      expect(executionData.snapshot.executionStatus).toBe("QUEUED");
+      expect(executionData.run.status).toBe("PENDING");
+    } finally {
+      await engine.quit();
+    }
+  });
+
+  containerTest(
+    "TTL consumer expires runs before they can be dequeued",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const expiredEvents: EventBusEventArgs<"runExpired">[0][] = [];
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            pollIntervalMs: 100,
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        engine.eventBus.on("runExpired", (result) => {
+          expiredEvents.push(result);
+        });
+
+        // Trigger a run with short TTL
+        const expiredRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_e1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s", // Short TTL
+          },
+          prisma
+        );
+
+        // Wait for TTL to expire and TTL consumer to process it
+        await setTimeout(1500);
+
+        // The run should have been expired by the TTL consumer
+        expect(expiredEvents.length).toBe(1);
+        expect(expiredEvents[0]?.run.id).toBe(expiredRun.id);
+
+        // Check the run status directly from the database (the batch TTL path
+        // does not create execution snapshots, so getRunExecutionData may not reflect it)
+        const expiredRunData = await prisma.taskRun.findUnique({
+          where: { id: expiredRun.id },
+          select: { status: true },
+        });
+        expect(expiredRunData?.status).toBe("EXPIRED");
+
+        // The run should have been removed from the queue by the TTL Lua script
+        // So dequeue should return nothing
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test-consumer",
+          workerQueue: "main",
+          maxRunCount: 1,
+          backgroundWorkerId: (
+            await prisma.backgroundWorker.findFirst({
+              where: { runtimeEnvironmentId: authenticatedEnvironment.id },
+            })
+          )!.id,
+        });
+
+        expect(dequeued.length).toBe(0);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Dequeue skips TTL-expired runs and TTL consumer expires them",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const expiredEvents: EventBusEventArgs<"runExpired">[0][] = [];
+
+      // Disable worker to prevent the scheduleExpireRun job from firing before
+      // we can test the dequeue path. Use masterQueueConsumersDisabled so we can
+      // manually trigger dequeue via processMasterQueueForEnvironment.
+      // TTL consumers start independently and will expire the run after their poll interval.
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          disabled: true,
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            pollIntervalMs: 5000,
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        engine.eventBus.on("runExpired", (result) => {
+          expiredEvents.push(result);
+        });
+
+        // Trigger a run with short TTL
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_dq1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Verify run is queued
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.snapshot.executionStatus).toBe("QUEUED");
+
+        // Wait for TTL to expire
+        await setTimeout(1_500);
+
+        // Manually process the master queue - the dequeue Lua script should
+        // encounter the expired message and skip it (removing from queue sorted
+        // sets but leaving messageKey and ttlQueueKey for TTL consumer)
+        await engine.runQueue.processMasterQueueForEnvironment(
+          authenticatedEnvironment.id,
+          10
+        );
+
+        // Try to dequeue from worker queue - nothing should be there since
+        // the expired message was skipped by the Lua script
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test-consumer",
+          workerQueue: "main",
+          blockingPopTimeoutSeconds: 1,
+        });
+        expect(dequeued.length).toBe(0);
+
+        // The run should still be PENDING in the database (not yet expired by TTL consumer)
+        const executionData2 = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData2);
+        expect(executionData2.run.status).toBe("PENDING");
+
+        // Now wait for the TTL consumer to poll and expire the run
+        // (pollIntervalMs is 5000 for TTL scan + up to 5000ms batch maxWaitMs + processing)
+        await setTimeout(13_000);
+
+        // The TTL consumer should have found and expired the run
+        expect(expiredEvents.length).toBe(1);
+        expect(expiredEvents[0]?.run.id).toBe(run.id);
+
+        // Check the run status directly from the database (the batch TTL path
+        // does not create execution snapshots, so getRunExecutionData may not reflect it)
+        const expiredRunData = await prisma.taskRun.findUnique({
+          where: { id: run.id },
+          select: { status: true },
+        });
+        expect(expiredRunData?.status).toBe("EXPIRED");
+
+        // Concurrency should be released
+        const envConcurrency = await engine.runQueue.currentConcurrencyOfEnvironment(
+          authenticatedEnvironment
+        );
+        expect(envConcurrency).toBe(0);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "TTL expiration clears env concurrency keys with proj segment",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment =
+        await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          disabled: true,
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            pollIntervalMs: 5000,
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_envkeys",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        const queue = engine.runQueue.keys.queueKey(
+          authenticatedEnvironment,
+          "task/test-task"
+        );
+        const envConcurrencyKey =
+          engine.runQueue.keys.envCurrentConcurrencyKeyFromQueue(queue);
+        const envDequeuedKey =
+          engine.runQueue.keys.envCurrentDequeuedKeyFromQueue(queue);
+
+        await engine.runQueue.redis.sadd(envConcurrencyKey, run.id);
+        await engine.runQueue.redis.sadd(envDequeuedKey, run.id);
+
+        const concurrencyBefore = await engine.runQueue.getCurrentConcurrencyOfEnvironment(
+          authenticatedEnvironment
+        );
+        expect(concurrencyBefore).toContain(run.id);
+
+        await setTimeout(1_500);
+        await engine.runQueue.processMasterQueueForEnvironment(
+          authenticatedEnvironment.id,
+          10
+        );
+        // Wait for TTL scan (5000ms) + batch maxWaitMs (5000ms) + processing buffer
+        await setTimeout(13_000);
+
+        const expiredRun = await prisma.taskRun.findUnique({
+          where: { id: run.id },
+          select: { status: true },
+        });
+        expect(expiredRun?.status).toBe("EXPIRED");
+
+        const concurrencyAfter = await engine.runQueue.getCurrentConcurrencyOfEnvironment(
+          authenticatedEnvironment
+        );
+        expect(concurrencyAfter).not.toContain(run.id);
+
+        const stillInDequeued = await engine.runQueue.redis.sismember(
+          envDequeuedKey,
+          run.id
+        );
+        expect(stillInDequeued).toBe(0);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "Dequeue returns non-expired runs while skipping expired ones",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      // Disable worker to prevent the scheduleExpireRun job from firing.
+      // Use masterQueueConsumersDisabled so we can manually trigger dequeue.
+      // Very long TTL consumer interval so it doesn't interfere.
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          disabled: true,
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            pollIntervalMs: 30000, // Very long so TTL consumer doesn't interfere
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a run with short TTL (will expire)
+        const expiringRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_exp1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Wait for first run's TTL to expire
+        await setTimeout(1_500);
+
+        // Trigger a second run WITHOUT TTL (should be dequeued normally)
+        const normalRun = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_norm1",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t2",
+            spanId: "s2",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            // No TTL
+          },
+          prisma
+        );
+
+        // Manually process the master queue - the Lua script should skip the
+        // expired message and dequeue only the non-expired one to the worker queue
+        await engine.runQueue.processMasterQueueForEnvironment(
+          authenticatedEnvironment.id,
+          10
+        );
+
+        // Dequeue from worker queue - only the non-expired run should be there
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test-consumer",
+          workerQueue: "main",
+        });
+        expect(dequeued.length).toBe(1);
+        expect(dequeued[0]?.run.id).toBe(normalRun.id);
+
+        // The expired run should still be PENDING (waiting for TTL consumer)
+        const expiringRunData = await engine.getRunExecutionData({ runId: expiringRun.id });
+        assertNonNullable(expiringRunData);
+        expect(expiringRunData.run.status).toBe("PENDING");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "expireRunsBatch skips runs that are locked",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            disabled: true, // We'll manually test the batch function
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a run with TTL
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_l1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Manually lock the run (simulating it being about to execute)
+        await prisma.taskRun.update({
+          where: { id: run.id },
+          data: { lockedAt: new Date() },
+        });
+
+        // Try to expire the run via batch
+        const result = await engine.ttlSystem.expireRunsBatch([run.id]);
+
+        // Should be skipped because it's locked
+        expect(result.expired.length).toBe(0);
+        expect(result.skipped.length).toBe(1);
+        expect(result.skipped[0]?.reason).toBe("locked");
+
+        // Run should still be PENDING
+        const executionData = await engine.getRunExecutionData({ runId: run.id });
+        assertNonNullable(executionData);
+        expect(executionData.run.status).toBe("PENDING");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "expireRunsBatch skips runs with non-PENDING status",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            disabled: true,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const taskIdentifier = "test-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, taskIdentifier);
+
+        // Trigger a run with TTL
+        const run = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_x1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t1",
+            spanId: "s1",
+            workerQueue: "main",
+            queue: "task/test-task",
+            isTest: false,
+            tags: [],
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Manually change status to EXECUTING (simulating the run started)
+        await prisma.taskRun.update({
+          where: { id: run.id },
+          data: { status: "EXECUTING" },
+        });
+
+        // Try to expire the run via batch
+        const result = await engine.ttlSystem.expireRunsBatch([run.id]);
+
+        // Should be skipped because it's not PENDING
+        expect(result.expired.length).toBe(0);
+        expect(result.skipped.length).toBe(1);
+        expect(result.skipped[0]?.reason).toBe("status_EXECUTING");
+
+        // Run should still be EXECUTING
+        const dbRun = await prisma.taskRun.findUnique({ where: { id: run.id } });
+        expect(dbRun?.status).toBe("EXECUTING");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "expireRunsBatch handles non-existent runs",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            disabled: true,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        // Try to expire a non-existent run
+        const result = await engine.ttlSystem.expireRunsBatch(["non_existent_run_id"]);
+
+        // Should be skipped as not found
+        expect(result.expired.length).toBe(0);
+        expect(result.skipped.length).toBe(1);
+        expect(result.skipped[0]?.reason).toBe("not_found");
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "TTL-expired child run completes waitpoint and resumes parent",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            pollIntervalMs: 100,
+            batchSize: 10,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        const parentTask = "parent-task";
+        const childTask = "child-task";
+
+        await setupBackgroundWorker(engine, authenticatedEnvironment, [parentTask, childTask]);
+
+        // Trigger the parent run
+        const parentRun = await engine.trigger(
+          {
+            number: 1,
+            friendlyId: "run_p1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier: parentTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12345",
+            spanId: "s12345",
+            queue: `task/${parentTask}`,
+            isTest: false,
+            tags: [],
+            workerQueue: "main",
+          },
+          prisma
+        );
+
+        // Dequeue and start parent
+        await setTimeout(500);
+        const dequeued = await engine.dequeueFromWorkerQueue({
+          consumerId: "test_12345",
+          workerQueue: "main",
+        });
+
+        const initialExecutionData = await engine.getRunExecutionData({ runId: parentRun.id });
+        assertNonNullable(initialExecutionData);
+        await engine.startRunAttempt({
+          runId: parentRun.id,
+          snapshotId: initialExecutionData.snapshot.id,
+        });
+
+        // Trigger child run with TTL and resumeParentOnCompletion
+        const childRun = await engine.trigger(
+          {
+            number: 2,
+            friendlyId: "run_c1234",
+            environment: authenticatedEnvironment,
+            taskIdentifier: childTask,
+            payload: "{}",
+            payloadType: "application/json",
+            context: {},
+            traceContext: {},
+            traceId: "t12346",
+            spanId: "s12346",
+            queue: `task/${childTask}`,
+            isTest: false,
+            tags: [],
+            resumeParentOnCompletion: true,
+            parentTaskRunId: parentRun.id,
+            workerQueue: "main",
+            ttl: "1s",
+          },
+          prisma
+        );
+
+        // Verify parent is waiting on child
+        const parentExecutionData = await engine.getRunExecutionData({ runId: parentRun.id });
+        assertNonNullable(parentExecutionData);
+        expect(parentExecutionData.snapshot.executionStatus).toBe("EXECUTING_WITH_WAITPOINTS");
+
+        const runWaitpoint = await prisma.taskRunWaitpoint.findFirst({
+          where: { taskRunId: parentRun.id },
+          include: { waitpoint: true },
+        });
+        assertNonNullable(runWaitpoint);
+        expect(runWaitpoint.waitpoint.type).toBe("RUN");
+        expect(runWaitpoint.waitpoint.completedByTaskRunId).toBe(childRun.id);
+
+        // Wait for TTL to expire + finishWaitpoint worker job to process
+        await setTimeout(3_000);
+
+        // Child run should be EXPIRED
+        const expiredChild = await prisma.taskRun.findUnique({
+          where: { id: childRun.id },
+          select: { status: true },
+        });
+        expect(expiredChild?.status).toBe("EXPIRED");
+
+        // Waitpoint should be completed with error output
+        const waitpointAfter = await prisma.waitpoint.findFirst({
+          where: { id: runWaitpoint.waitpointId },
+        });
+        assertNonNullable(waitpointAfter);
+        expect(waitpointAfter.status).toBe("COMPLETED");
+        expect(waitpointAfter.completedAt).not.toBeNull();
+        expect(waitpointAfter.outputIsError).toBe(true);
+
+        // TaskRunWaitpoint linking parent to child should be removed
+        const runWaitpointAfter = await prisma.taskRunWaitpoint.findFirst({
+          where: { taskRunId: parentRun.id },
+        });
+        expect(runWaitpointAfter).toBeNull();
+
+        // Parent should be back to EXECUTING
+        const parentExecutionDataAfter = await engine.getRunExecutionData({ runId: parentRun.id });
+        assertNonNullable(parentExecutionDataAfter);
+        expect(parentExecutionDataAfter.snapshot.executionStatus).toBe("EXECUTING");
+
+        // Parent's completedWaitpoints should contain the waitpoint with error output
+        expect(parentExecutionDataAfter.completedWaitpoints?.length).toBe(1);
+        expect(parentExecutionDataAfter.completedWaitpoints![0].id).toBe(runWaitpoint.waitpointId);
+        expect(parentExecutionDataAfter.completedWaitpoints![0].outputIsError).toBe(true);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
+
+  containerTest(
+    "expireRunsBatch handles empty array",
+    async ({ prisma, redisOptions }) => {
+      const authenticatedEnvironment = await setupAuthenticatedEnvironment(prisma, "PRODUCTION");
+
+      const engine = new RunEngine({
+        prisma,
+        worker: {
+          redis: redisOptions,
+          workers: 1,
+          tasksPerWorker: 10,
+          pollIntervalMs: 100,
+        },
+        queue: {
+          redis: redisOptions,
+          processWorkerQueueDebounceMs: 50,
+          masterQueueConsumersDisabled: true,
+          ttlSystem: {
+            disabled: true,
+          },
+        },
+        runLock: {
+          redis: redisOptions,
+        },
+        machines: {
+          defaultMachine: "small-1x",
+          machines: {
+            "small-1x": {
+              name: "small-1x" as const,
+              cpu: 0.5,
+              memory: 0.5,
+              centsPerMs: 0.0001,
+            },
+          },
+          baseCostInCents: 0.0001,
+        },
+        tracer: trace.getTracer("test", "0.0.0"),
+      });
+
+      try {
+        // Try to expire an empty array
+        const result = await engine.ttlSystem.expireRunsBatch([]);
+
+        expect(result.expired.length).toBe(0);
+        expect(result.skipped.length).toBe(0);
+      } finally {
+        await engine.quit();
+      }
+    }
+  );
 });
diff --git a/internal-packages/run-engine/src/engine/ttlWorkerCatalog.ts b/internal-packages/run-engine/src/engine/ttlWorkerCatalog.ts
new file mode 100644
index 00000000000..e571d809d98
--- /dev/null
+++ b/internal-packages/run-engine/src/engine/ttlWorkerCatalog.ts
@@ -0,0 +1,26 @@
+import { z } from "zod";
+
+export type TtlWorkerCatalogOptions = {
+  visibilityTimeoutMs?: number;
+  batchMaxSize?: number;
+  batchMaxWaitMs?: number;
+};
+
+export function createTtlWorkerCatalog(options?: TtlWorkerCatalogOptions) {
+  return {
+    expireTtlRun: {
+      schema: z.object({
+        runId: z.string(),
+        orgId: z.string(),
+        queueKey: z.string(),
+      }),
+      visibilityTimeoutMs: options?.visibilityTimeoutMs ?? 120_000,
+      batch: {
+        maxSize: options?.batchMaxSize ?? 50,
+        maxWaitMs: options?.batchMaxWaitMs ?? 5_000,
+      },
+    },
+  };
+}
+
+export const ttlWorkerCatalog = createTtlWorkerCatalog();
diff --git a/internal-packages/run-engine/src/engine/types.ts b/internal-packages/run-engine/src/engine/types.ts
index 3b2ae8c9a19..6ecb726e3af 100644
--- a/internal-packages/run-engine/src/engine/types.ts
+++ b/internal-packages/run-engine/src/engine/types.ts
@@ -63,6 +63,28 @@ export type RunEngineOptions = {
       scanJitterInMs?: number;
       processMarkedJitterInMs?: number;
     };
+    /** TTL system options for automatic run expiration */
+    ttlSystem?: {
+      /** Number of shards for TTL sorted sets (default: same as queue shards) */
+      shardCount?: number;
+      /** How often to poll each shard for expired runs (ms, default: 1000) */
+      pollIntervalMs?: number;
+      /** Max number of runs to expire per poll per shard (default: 100) */
+      batchSize?: number;
+      /** Whether the entire TTL system is disabled (default: false) */
+      disabled?: boolean;
+      /** Whether TTL consumers + worker are disabled on this instance (default: false).
+       *  When true, ZADD on enqueue still happens but polling loops and the TTL worker don't run. */
+      consumersDisabled?: boolean;
+      /** Visibility timeout for TTL worker jobs (ms, default: 120000) */
+      visibilityTimeoutMs?: number;
+      /** Concurrency limit for the TTL redis-worker (default: 1) */
+      workerConcurrency?: number;
+      /** Max items to accumulate before flushing a batch (default: 500) */
+      batchMaxSize?: number;
+      /** Max time (ms) to wait for more items before flushing a batch (default: 5000) */
+      batchMaxWaitMs?: number;
+    };
   };
   runLock: {
     redis: RedisOptions;
@@ -76,12 +98,32 @@ export type RunEngineOptions = {
   batchQueue?: {
     redis: RedisOptions;
     drr?: Partial<DRRConfig>;
+    /** Number of master queue shards (default: 1) */
+    shardCount?: number;
+    /** Worker queue blocking timeout in seconds (enables two-stage processing) */
+    workerQueueBlockingTimeoutSeconds?: number;
+    consumerEnabled?: boolean;
     consumerCount?: number;
     consumerIntervalMs?: number;
     /** Default processing concurrency per environment when no specific limit is set */
     defaultConcurrency?: number;
     /** Optional global rate limiter to limit processing across all consumers */
     globalRateLimiter?: GlobalRateLimiter;
+    /** Maximum worker queue depth before claiming pauses (protects visibility timeouts) */
+    workerQueueMaxDepth?: number;
+    /** Retry configuration for failed batch items */
+    retry?: {
+      /** Maximum number of attempts (including the first). Default: 1 (no retries) */
+      maxAttempts: number;
+      /** Base delay in milliseconds. Default: 1000 */
+      minTimeoutInMs?: number;
+      /** Maximum delay in milliseconds. Default: 30000 */
+      maxTimeoutInMs?: number;
+      /** Exponential backoff factor. Default: 2 */
+      factor?: number;
+      /** Whether to add jitter to retry delays. Default: true */
+      randomize?: boolean;
+    };
   };
   debounce?: {
     redis?: RedisOptions;
@@ -100,6 +142,9 @@ export type RunEngineOptions = {
     factor?: number;
   };
   queueRunsWaitingForWorkerBatchSize?: number;
+  /** Optional maximum TTL for all runs (e.g. "14d"). If set, runs without an explicit TTL
+   *  will use this as their TTL, and runs with a TTL larger than this will be clamped. */
+  defaultMaxTtl?: string;
   tracer: Tracer;
   meter?: Meter;
   logger?: Logger;
@@ -120,6 +165,8 @@ export type TriggerParams = {
   environment: MinimalAuthenticatedEnvironment;
   idempotencyKey?: string;
   idempotencyKeyExpiresAt?: Date;
+  /** The original user-provided idempotency key and scope */
+  idempotencyKeyOptions?: { key: string; scope: "run" | "attempt" | "global" };
   taskIdentifier: string;
   payload: string;
   payloadType: string;
@@ -134,6 +181,9 @@ export type TriggerParams = {
   cliVersion?: string;
   concurrencyKey?: string;
   workerQueue?: string;
+  /** When true, the run queue may push directly to the worker queue if concurrency is available.
+   *  Gated per WorkerInstanceGroup (production) or always true (development). */
+  enableFastPath?: boolean;
   queue: string;
   lockedQueueId?: string;
   isTest: boolean;
@@ -173,6 +223,13 @@ export type TriggerParams = {
     key: string;
     delay: string;
     mode?: "leading" | "trailing";
+    maxDelay?: string;
+  };
+  annotations?: {
+    triggerSource: string;
+    triggerAction: string;
+    rootTriggerSource: string;
+    rootScheduleId?: string;
   };
   /**
    * Called when a run is debounced (existing delayed run found with triggerAndWait).
diff --git a/internal-packages/run-engine/src/run-queue/fairQueueSelectionStrategy.ts b/internal-packages/run-engine/src/run-queue/fairQueueSelectionStrategy.ts
index 46396fda41f..0e2205e413a 100644
--- a/internal-packages/run-engine/src/run-queue/fairQueueSelectionStrategy.ts
+++ b/internal-packages/run-engine/src/run-queue/fairQueueSelectionStrategy.ts
@@ -2,11 +2,10 @@ import { createRedisClient, Redis, type RedisOptions } from "@internal/redis";
 import { startSpan, type Tracer } from "@internal/tracing";
 import {
   createCache,
+  createLRUMemoryStore,
   DefaultStatefulContext,
   Namespace,
   type UnkeyCache,
-  MemoryStore,
-  createMemoryStore,
 } from "@internal/cache";
 import { randomUUID } from "crypto";
 import seedrandom from "seedrandom";
@@ -107,7 +106,7 @@ export class FairQueueSelectionStrategy implements RunQueueSelectionStrategy {
 
   constructor(private options: FairQueueSelectionStrategyOptions) {
     const ctx = new DefaultStatefulContext();
-    const memory = createMemoryStore(1000);
+    const memory = createLRUMemoryStore(1000);
 
     this._cache = createCache({
       concurrencyLimit: new Namespace<number>(ctx, {
diff --git a/internal-packages/run-engine/src/run-queue/index.ts b/internal-packages/run-engine/src/run-queue/index.ts
index 5127ec3c756..de0df73ad05 100644
--- a/internal-packages/run-engine/src/run-queue/index.ts
+++ b/internal-packages/run-engine/src/run-queue/index.ts
@@ -92,6 +92,23 @@ export type RunQueueOptions = {
     processMarkedJitterInMs?: number;
     callback: ConcurrencySweeperCallback;
   };
+  /** TTL system for automatic run expiration */
+  ttlSystem?: {
+    /** Number of shards for TTL sorted sets (default: same as queue shards) */
+    shardCount?: number;
+    /** How often to poll each shard for expired runs (ms, default: 1000) */
+    pollIntervalMs?: number;
+    /** Max number of runs to expire per poll per shard (default: 100) */
+    batchSize?: number;
+    /** Whether TTL consumers (polling loops) are disabled on this instance (default: false) */
+    consumersDisabled?: boolean;
+    /** Key suffix for TTL worker's queue sorted set (relative to RunQueue keyPrefix) */
+    workerQueueSuffix: string;
+    /** Key suffix for TTL worker's items hash (relative to RunQueue keyPrefix) */
+    workerItemsSuffix: string;
+    /** Visibility timeout for TTL worker jobs (ms, default: 30000) */
+    visibilityTimeoutMs?: number;
+  };
 };
 
 export interface ConcurrencySweeperCallback {
@@ -271,6 +288,7 @@ export class RunQueue {
     this.#setupSubscriber();
     this.#setupLuaLogSubscriber();
     this.#startMasterQueueConsumers();
+    this.#startTtlConsumers();
     this.#registerCommands();
   }
 
@@ -600,16 +618,40 @@ export class RunQueue {
     );
   }
 
+  /**
+   * Enqueue a run message for execution.
+   *
+   * The Lua script atomically decides between two paths:
+   *
+   * **Fast path** (when `enableFastPath` is true and conditions are met):
+   * Skips the queue sorted set and pushes directly to the worker queue (Redis list).
+   * This eliminates the ~500ms debounce delay from the processQueueForWorkerQueue job.
+   * Conditions: no available messages in the queue, env concurrency available, queue concurrency available.
+   *
+   * **Slow path** (default, or when fast-path conditions aren't met):
+   * Adds to the queue sorted set, then a debounced processQueueForWorkerQueue job moves it
+   * to the worker queue after checking concurrency limits.
+   *
+   * Both paths are atomic within their respective Lua scripts. The fast path claims concurrency
+   * slots (SADD to currentConcurrency sets) identically to how the dequeue Lua does, so
+   * ack/nack/release operations work the same regardless of which path was taken.
+   *
+   * @param enableFastPath - Gated per WorkerInstanceGroup. Dev environments always true.
+   *   Production regions opt in via the `enableFastPath` flag on WorkerInstanceGroup.
+   */
   public async enqueueMessage({
     env,
     message,
     workerQueue,
     skipDequeueProcessing = false,
+    enableFastPath = false,
   }: {
     env: MinimalAuthenticatedEnvironment;
     message: InputPayload;
     workerQueue: string;
     skipDequeueProcessing?: boolean;
+    /** When true, the Lua script may push directly to the worker queue if concurrency is available. */
+    enableFastPath?: boolean;
   }) {
     return await this.#trace(
       "enqueueMessage",
@@ -618,6 +660,9 @@ export class RunQueue {
 
         const queueKey = this.keys.queueKey(env, message.queue, concurrencyKey);
 
+        // For CK queues, use wildcard dedup so all CKs share one worker queue processing job
+        const dedupQueueKey = concurrencyKey ? this.keys.toCkWildcard(queueKey) : queueKey;
+
         propagation.inject(context.active(), message);
 
         span.setAttributes({
@@ -635,13 +680,33 @@ export class RunQueue {
           attempt: 0,
         };
 
-        if (!skipDequeueProcessing) {
-          // This will move the message to the worker queue so it can be dequeued
+        // Pass TTL info to enqueue so it can be added atomically
+        const ttlInfo =
+          message.ttlExpiresAt && this.options.ttlSystem
+            ? {
+                ttlExpiresAt: message.ttlExpiresAt,
+                ttlQueueKey: this.keys.ttlQueueKeyForShard(this.#getTtlShardForQueue(queueKey)),
+                ttlMember: `${queueKey}|${message.runId}|${message.orgId}`,
+              }
+            : undefined;
+
+        // Enqueue the message. The Lua script atomically decides whether to fast-path
+        // (push directly to worker queue) or slow-path (add to queue sorted set).
+        const fastPathTaken = await this.#callEnqueueMessage(
+          messagePayload,
+          ttlInfo,
+          enableFastPath
+        );
+
+        span.setAttribute("fastPath", fastPathTaken);
+
+        if (!fastPathTaken && !skipDequeueProcessing) {
+          // Slow path: schedule the dequeue job to move the message from queue to worker queue
           await this.worker.enqueueOnce({
-            id: queueKey, // dedupe by environment, queue, and concurrency key
+            id: dedupQueueKey, // dedupe by environment and base queue (CK wildcard for CK queues)
             job: "processQueueForWorkerQueue",
             payload: {
-              queueKey,
+              queueKey: dedupQueueKey,
               environmentId: env.id,
             },
             // Add a small delay to dedupe messages so at most one of these will processed,
@@ -649,8 +714,6 @@ export class RunQueue {
             availableAt: new Date(Date.now() + (this.options.processWorkerQueueDebounceMs ?? 500)), // 500ms from now
           });
         }
-
-        return await this.#callEnqueueMessage(messagePayload);
       },
       {
         kind: SpanKind.PRODUCER,
@@ -740,12 +803,17 @@ export class RunQueue {
         });
 
         if (!options?.skipDequeueProcessing) {
+          // For CK queues, use wildcard dedup so all CKs share one worker queue processing job
+          const dedupQueueKey = message.concurrencyKey
+            ? this.keys.toCkWildcard(message.queue)
+            : message.queue;
+
           // This will move the message to the worker queue so it can be dequeued
           await this.worker.enqueueOnce({
-            id: message.queue, // dedupe by environment, queue, and concurrency key
+            id: dedupQueueKey, // dedupe by environment and base queue
             job: "processQueueForWorkerQueue",
             payload: {
-              queueKey: message.queue,
+              queueKey: dedupQueueKey,
               environmentId: message.environmentId,
             },
             // Add a small delay to dedupe messages so at most one of these will processed,
@@ -820,12 +888,17 @@ export class RunQueue {
         }
 
         if (!skipDequeueProcessing) {
+          // For CK queues, use wildcard dedup so all CKs share one worker queue processing job
+          const dedupQueueKey = message.concurrencyKey
+            ? this.keys.toCkWildcard(message.queue)
+            : message.queue;
+
           // This will move the message to the worker queue so it can be dequeued
           await this.worker.enqueueOnce({
-            id: message.queue, // dedupe by environment, queue, and concurrency key
+            id: dedupQueueKey, // dedupe by environment and base queue
             job: "processQueueForWorkerQueue",
             payload: {
-              queueKey: message.queue,
+              queueKey: dedupQueueKey,
               environmentId: message.environmentId,
             },
             // Add a small delay to dedupe messages so at most one of these will processed,
@@ -1209,6 +1282,169 @@ export class RunQueue {
     }
   }
 
+  // TTL System Methods
+
+  #startTtlConsumers() {
+    if (!this.options.ttlSystem) {
+      this.logger.debug("TTL system disabled (no ttlSystem config)");
+      return;
+    }
+
+    if (this.options.ttlSystem.consumersDisabled) {
+      this.logger.debug("TTL consumers disabled on this instance");
+      return;
+    }
+
+    const shardCount = this.options.ttlSystem.shardCount ?? this.shardCount;
+
+    for (let i = 0; i < shardCount; i++) {
+      this.logger.debug(`Starting TTL consumer ${i}`);
+      this.#startTtlConsumer(i).catch((err) => {
+        this.logger.error(`Failed to start TTL consumer ${i}`, { error: err });
+      });
+    }
+
+    this.logger.debug(`Started ${shardCount} TTL consumers`);
+  }
+
+  async #startTtlConsumer(shard: number) {
+    if (!this.options.ttlSystem) {
+      return;
+    }
+
+    const pollIntervalMs = this.options.ttlSystem.pollIntervalMs ?? 1000;
+    const batchSize = this.options.ttlSystem.batchSize ?? 100;
+    let processedCount = 0;
+
+    try {
+      for await (const _ of setInterval(pollIntervalMs, null, {
+        signal: this.abortController.signal,
+      })) {
+        const now = Date.now();
+
+        const [error, expiredRuns] = await tryCatch(
+          this.#expireTtlRuns(shard, now, batchSize)
+        );
+
+        if (error) {
+          this.logger.error(`Failed to expire TTL runs for shard ${shard}`, {
+            error,
+            service: this.name,
+            shard,
+          });
+          continue;
+        }
+
+        if (expiredRuns.length > 0) {
+          this.logger.debug(`Expired ${expiredRuns.length} TTL runs in shard ${shard}`, {
+            service: this.name,
+            shard,
+            count: expiredRuns.length,
+          });
+          processedCount += expiredRuns.length;
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        throw error;
+      }
+
+      this.logger.debug(`TTL consumer ${shard} stopped`, {
+        service: this.name,
+        shard,
+        processedCount,
+      });
+    }
+  }
+
+  /**
+   * Atomically expire TTL runs: removes from TTL set, acknowledges from normal queue,
+   * and enqueues each run to the TTL worker for DB updates.
+   */
+  async #expireTtlRuns(
+    shard: number,
+    now: number,
+    batchSize: number
+  ): Promise<Array<{ queueKey: string; runId: string; orgId: string }>> {
+    const ttlSystem = this.options.ttlSystem;
+    if (!ttlSystem) {
+      return [];
+    }
+
+    const shardCount = ttlSystem.shardCount ?? this.shardCount;
+    const ttlQueueKey = this.keys.ttlQueueKeyForShard(shard);
+    const keyPrefix = this.options.redis.keyPrefix ?? "";
+    const workerQueueKey = keyPrefix + ttlSystem.workerQueueSuffix;
+    const workerItemsKey = keyPrefix + ttlSystem.workerItemsSuffix;
+    const visibilityTimeoutMs = (ttlSystem.visibilityTimeoutMs ?? 30_000).toString();
+
+    // Atomically get and remove expired runs from TTL set, ack them from normal queues, and enqueue to TTL worker
+    const results = await this.redis.expireTtlRuns(
+      ttlQueueKey,
+      keyPrefix,
+      now.toString(),
+      batchSize.toString(),
+      shardCount.toString(),
+      workerQueueKey,
+      workerItemsKey,
+      visibilityTimeoutMs
+    );
+
+    if (!results || results.length === 0) {
+      return [];
+    }
+
+    // Parse the results: each item is "queueKey|runId|orgId"
+    const expiredRuns = results.map((member: string) => {
+      const [queueKey, runId, orgId] = member.split("|");
+      return { queueKey, runId, orgId };
+    });
+
+    // Rebalance master queues for all affected queues.
+    // Group by master queue key (derived from environment) since different queues
+    // may belong to different master queue shards.
+    const queuesByMasterKey = new Map<string, string[]>();
+
+    for (const { queueKey } of expiredRuns) {
+      const envId = this.keys.envIdFromQueue(queueKey);
+      const masterQueueKey = this.keys.masterQueueKeyForEnvironment(envId, this.shardCount);
+
+      const queues = queuesByMasterKey.get(masterQueueKey) ?? [];
+      queues.push(queueKey);
+      queuesByMasterKey.set(masterQueueKey, queues);
+    }
+
+    if (queuesByMasterKey.size > 0) {
+      const pipeline = this.redis.pipeline();
+      const keyPrefix = this.options.redis.keyPrefix ?? "";
+
+      for (const [masterQueueKey, queueNames] of queuesByMasterKey) {
+        // For CK queues, skip the legacy rebalance — the CK index was already
+        // updated inside the Lua script, and migrateLegacyMasterQueues would
+        // re-add the concrete :ck:bar member to the master queue.
+        // Only rebalance non-CK queues here.
+        const nonCkQueues = queueNames.filter((q) => !q.includes(":ck:"));
+        if (nonCkQueues.length > 0) {
+          const uniqueQueueNames = [...new Set(nonCkQueues)];
+          pipeline.migrateLegacyMasterQueues(masterQueueKey, keyPrefix, ...uniqueQueueNames);
+        }
+      }
+
+      await pipeline.exec();
+    }
+
+    return expiredRuns;
+  }
+
+  /**
+   * Get the TTL shard for a queue key
+   */
+  #getTtlShardForQueue(queueKey: string): number {
+    const { envId } = this.keys.descriptorFromQueue(queueKey);
+    const shardCount = this.options.ttlSystem?.shardCount ?? this.shardCount;
+    return this.keys.masterQueueShardForEnvironment(envId, shardCount);
+  }
+
   async migrateLegacyMasterQueue(legacyMasterQueue: string) {
     const legacyMasterQueueKey = this.keys.legacyMasterQueueKey(legacyMasterQueue);
 
@@ -1268,6 +1504,40 @@ export class RunQueue {
     return this.#processMasterQueueShard(shard, environmentId, maxCount);
   }
 
+  // Test-only: directly dequeue from a queue (CK or non-CK) without enqueuing to worker queue
+  async testDequeueFromMasterQueue(
+    shard: number,
+    environmentId: string,
+    maxCount: number = 10
+  ): Promise<DequeuedMessage[]> {
+    const masterQueueKey = this.keys.masterQueueKeyForShard(shard);
+    const envQueues = await this.queueSelectionStrategy.distributeFairQueuesFromParentQueue(
+      masterQueueKey,
+      environmentId
+    );
+
+    const allMessages: DequeuedMessage[] = [];
+
+    for (const env of envQueues) {
+      for (const queue of env.queues) {
+        const messages = this.keys.isCkWildcard(queue)
+          ? await this.#callDequeueMessagesFromCkQueue({
+              ckWildcardQueue: queue,
+              shard,
+              maxCount,
+            })
+          : await this.#callDequeueMessagesFromQueue({
+              messageQueue: queue,
+              shard,
+              maxCount,
+            });
+        allMessages.push(...messages);
+      }
+    }
+
+    return allMessages;
+  }
+
   async #processMasterQueueShard(shard: number, consumerId: string, maxCount: number = 10) {
     return this.#trace(
       "processMasterQueueShard",
@@ -1313,14 +1583,20 @@ export class RunQueue {
             attemptedQueues++;
 
             // Attempt to dequeue from this queue
-            const [error, messages] = await tryCatch(
-              this.#callDequeueMessagesFromQueue({
-                messageQueue: queue,
-                shard,
-                // TODO: make this configurable
-                maxCount,
-              })
-            );
+            // Dispatch CK wildcard queues to the CK-aware dequeue path
+            const dequeuePromise = this.keys.isCkWildcard(queue)
+              ? this.#callDequeueMessagesFromCkQueue({
+                  ckWildcardQueue: queue,
+                  shard,
+                  maxCount,
+                })
+              : this.#callDequeueMessagesFromQueue({
+                  messageQueue: queue,
+                  shard,
+                  maxCount,
+                });
+
+            const [error, messages] = await tryCatch(dequeuePromise);
 
             if (error) {
               this.logger.error(
@@ -1334,6 +1610,11 @@ export class RunQueue {
               continue;
             }
 
+            if (messages.length > 0) {
+              // Reset cooloff state on successful dequeue
+              this._queueCooloffStates.delete(queue);
+            }
+
             if (messages.length === 0) {
               if (cooloffState._tag === "normal") {
                 const cooloffCountThreshold = Math.max(
@@ -1404,11 +1685,18 @@ export class RunQueue {
       service: this.name,
     });
 
-    const messages = await this.#callDequeueMessagesFromQueue({
-      messageQueue: queueKey,
-      shard,
-      maxCount: 10,
-    });
+    // Dispatch CK wildcard queues to the CK-aware dequeue path
+    const messages = this.keys.isCkWildcard(queueKey)
+      ? await this.#callDequeueMessagesFromCkQueue({
+          ckWildcardQueue: queueKey,
+          shard,
+          maxCount: 10,
+        })
+      : await this.#callDequeueMessagesFromQueue({
+          messageQueue: queueKey,
+          shard,
+          maxCount: 10,
+        });
 
     if (messages.length === 0) {
       return;
@@ -1455,7 +1743,38 @@ export class RunQueue {
     });
   }
 
-  async #callEnqueueMessage(message: OutputPayloadV2) {
+  /**
+   * Calls the appropriate Lua enqueue script variant (plain, TTL, CK, or TTL+CK).
+   *
+   * Each variant receives the same fast-path keys/args in addition to its own specific keys.
+   * The Lua script returns 1 (fast path taken) or 0 (slow path taken).
+   *
+   * All four variants share this KEYS layout:
+   *   KEYS[1..N]  = variant-specific keys (queue, message, concurrency, env, master, TTL, CK index)
+   *   KEYS[N+1]   = workerQueueKey        (fast-path: RPUSH target)
+   *   KEYS[N+2]   = queueConcurrencyLimitKey
+   *   KEYS[N+3]   = envConcurrencyLimitKey
+   *   KEYS[N+4]   = envConcurrencyLimitBurstFactorKey
+   *
+   * And this ARGV layout (appended after variant-specific args):
+   *   messageKeyValue              (fast-path: value to RPUSH into worker queue)
+   *   defaultEnvConcurrencyLimit   (fallback if no Redis key set)
+   *   defaultEnvConcurrencyBurstFactor
+   *   currentTime                  (ms timestamp for ZRANGEBYSCORE availability check)
+   *   enableFastPath               ('1' or '0')
+   *
+   * @returns true if the fast path was taken (message pushed directly to worker queue)
+   */
+  async #callEnqueueMessage(
+    message: OutputPayloadV2,
+    ttlInfo?: {
+      ttlExpiresAt: number;
+      ttlQueueKey: string;
+      ttlMember: string;
+    },
+    enableFastPath: boolean = false
+  ): Promise<boolean> {
+    // --- Slow-path keys (used by all variants) ---
     const queueKey = message.queue;
     const messageKey = this.keys.messageKey(message.orgId, message.runId);
     const queueCurrentConcurrencyKey = this.keys.queueCurrentConcurrencyKeyFromQueue(message.queue);
@@ -1468,10 +1787,25 @@ export class RunQueue {
       this.shardCount
     );
 
+    // --- Fast-path keys (appended to each variant's KEYS) ---
+    const workerQueueKey = this.keys.workerQueueKey(message.workerQueue);
+    const queueConcurrencyLimitKey = this.keys.queueConcurrencyLimitKeyFromQueue(message.queue);
+    const envConcurrencyLimitKey = this.keys.envConcurrencyLimitKeyFromQueue(message.queue);
+    const envConcurrencyLimitBurstFactorKey =
+      this.keys.envConcurrencyLimitBurstFactorKeyFromQueue(message.queue);
+    // The value stored in the worker queue list — used to look up the message payload on dequeue
+    const messageKeyValue = messageKey;
+
     const queueName = message.queue;
     const messageId = message.runId;
     const messageData = JSON.stringify(message);
     const messageScore = String(message.timestamp);
+    const currentTime = String(Date.now());
+    const enableFastPathArg = enableFastPath ? "1" : "0";
+    const defaultEnvConcurrencyLimit = String(this.options.defaultEnvConcurrency);
+    const defaultEnvConcurrencyBurstFactor = String(
+      this.options.defaultEnvConcurrencyBurstFactor ?? 1.0
+    );
 
     this.logger.debug("Calling enqueueMessage", {
       queueKey,
@@ -1486,23 +1820,137 @@ export class RunQueue {
       messageData,
       messageScore,
       masterQueueKey,
+      enableFastPath,
+      ttlInfo,
       service: this.name,
     });
 
-    await this.redis.enqueueMessage(
-      masterQueueKey,
-      queueKey,
-      messageKey,
-      queueCurrentConcurrencyKey,
-      envCurrentConcurrencyKey,
-      queueCurrentDequeuedKey,
-      envCurrentDequeuedKey,
-      envQueueKey,
-      queueName,
-      messageId,
-      messageData,
-      messageScore
-    );
+    let result: number;
+
+    // Use CK-aware enqueue for messages with concurrency keys
+    if (message.concurrencyKey) {
+      const ckIndexKey = this.keys.ckIndexKeyFromQueue(message.queue);
+      const ckWildcardName = this.keys.toCkWildcard(message.queue);
+
+      if (ttlInfo) {
+        result = await this.redis.enqueueMessageWithTtlCk(
+          // keys
+          masterQueueKey,
+          queueKey,
+          messageKey,
+          queueCurrentConcurrencyKey,
+          envCurrentConcurrencyKey,
+          queueCurrentDequeuedKey,
+          envCurrentDequeuedKey,
+          envQueueKey,
+          ttlInfo.ttlQueueKey,
+          ckIndexKey,
+          workerQueueKey,
+          queueConcurrencyLimitKey,
+          envConcurrencyLimitKey,
+          envConcurrencyLimitBurstFactorKey,
+          // args
+          queueName,
+          messageId,
+          messageData,
+          messageScore,
+          ttlInfo.ttlMember,
+          String(ttlInfo.ttlExpiresAt),
+          ckWildcardName,
+          messageKeyValue,
+          defaultEnvConcurrencyLimit,
+          defaultEnvConcurrencyBurstFactor,
+          currentTime,
+          enableFastPathArg
+        );
+      } else {
+        result = await this.redis.enqueueMessageCk(
+          // keys
+          masterQueueKey,
+          queueKey,
+          messageKey,
+          queueCurrentConcurrencyKey,
+          envCurrentConcurrencyKey,
+          queueCurrentDequeuedKey,
+          envCurrentDequeuedKey,
+          envQueueKey,
+          ckIndexKey,
+          workerQueueKey,
+          queueConcurrencyLimitKey,
+          envConcurrencyLimitKey,
+          envConcurrencyLimitBurstFactorKey,
+          // args
+          queueName,
+          messageId,
+          messageData,
+          messageScore,
+          ckWildcardName,
+          messageKeyValue,
+          defaultEnvConcurrencyLimit,
+          defaultEnvConcurrencyBurstFactor,
+          currentTime,
+          enableFastPathArg
+        );
+      }
+    } else if (ttlInfo) {
+      // Use the TTL-aware enqueue that atomically adds to both queues
+      result = await this.redis.enqueueMessageWithTtl(
+        // keys
+        masterQueueKey,
+        queueKey,
+        messageKey,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        ttlInfo.ttlQueueKey,
+        workerQueueKey,
+        queueConcurrencyLimitKey,
+        envConcurrencyLimitKey,
+        envConcurrencyLimitBurstFactorKey,
+        // args
+        queueName,
+        messageId,
+        messageData,
+        messageScore,
+        ttlInfo.ttlMember,
+        String(ttlInfo.ttlExpiresAt),
+        messageKeyValue,
+        defaultEnvConcurrencyLimit,
+        defaultEnvConcurrencyBurstFactor,
+        currentTime,
+        enableFastPathArg
+      );
+    } else {
+      result = await this.redis.enqueueMessage(
+        // keys
+        masterQueueKey,
+        queueKey,
+        messageKey,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        workerQueueKey,
+        queueConcurrencyLimitKey,
+        envConcurrencyLimitKey,
+        envConcurrencyLimitBurstFactorKey,
+        // args
+        queueName,
+        messageId,
+        messageData,
+        messageScore,
+        messageKeyValue,
+        defaultEnvConcurrencyLimit,
+        defaultEnvConcurrencyBurstFactor,
+        currentTime,
+        enableFastPathArg
+      );
+    }
+
+    return result === 1;
   }
 
   async #callDequeueMessagesFromQueue({
@@ -1532,6 +1980,16 @@ export class RunQueue {
       const envQueueKey = this.keys.envQueueKeyFromQueue(messageQueue);
       const masterQueueKey = this.keys.masterQueueKeyForShard(shard);
 
+      // Get TTL queue key if TTL system is enabled
+      const ttlShardCount = this.options.ttlSystem?.shardCount ?? this.shardCount;
+      const ttlShard = this.keys.masterQueueShardForEnvironment(
+        this.keys.envIdFromQueue(messageQueue),
+        ttlShardCount
+      );
+      const ttlQueueKey = this.options.ttlSystem
+        ? this.keys.ttlQueueKeyForShard(ttlShard)
+        : "";
+
       this.logger.debug("#callDequeueMessagesFromQueue", {
         messageQueue,
         queueConcurrencyLimitKey,
@@ -1542,6 +2000,7 @@ export class RunQueue {
         messageKeyPrefix,
         envQueueKey,
         masterQueueKey,
+        ttlQueueKey,
         shard,
         maxCount,
       });
@@ -1557,6 +2016,7 @@ export class RunQueue {
         messageKeyPrefix,
         envQueueKey,
         masterQueueKey,
+        ttlQueueKey,
         //args
         messageQueue,
         String(Date.now()),
@@ -1617,6 +2077,117 @@ export class RunQueue {
     });
   }
 
+  async #callDequeueMessagesFromCkQueue({
+    ckWildcardQueue,
+    shard,
+    maxCount,
+  }: {
+    ckWildcardQueue: string;
+    shard: number;
+    maxCount: number;
+  }): Promise<DequeuedMessage[]> {
+    return this.#trace("callDequeueMessagesFromCkQueue", async (span) => {
+      span.setAttributes({
+        ckWildcardQueue,
+        shard,
+        maxCount,
+      });
+
+      const ckIndexKey = this.keys.ckIndexKeyFromQueue(ckWildcardQueue);
+      const queueConcurrencyLimitKey =
+        this.keys.queueConcurrencyLimitKeyFromQueue(ckWildcardQueue);
+      const envConcurrencyLimitKey = this.keys.envConcurrencyLimitKeyFromQueue(ckWildcardQueue);
+      const envConcurrencyLimitBurstFactorKey =
+        this.keys.envConcurrencyLimitBurstFactorKeyFromQueue(ckWildcardQueue);
+      const envCurrentConcurrencyKey =
+        this.keys.envCurrentConcurrencyKeyFromQueue(ckWildcardQueue);
+      const messageKeyPrefix = this.keys.messageKeyPrefixFromQueue(ckWildcardQueue);
+      const envQueueKey = this.keys.envQueueKeyFromQueue(ckWildcardQueue);
+      const masterQueueKey = this.keys.masterQueueKeyForShard(shard);
+
+      // Get TTL queue key if TTL system is enabled
+      const ttlShardCount = this.options.ttlSystem?.shardCount ?? this.shardCount;
+      const ttlShard = this.keys.masterQueueShardForEnvironment(
+        this.keys.envIdFromQueue(ckWildcardQueue),
+        ttlShardCount
+      );
+      const ttlQueueKey = this.options.ttlSystem
+        ? this.keys.ttlQueueKeyForShard(ttlShard)
+        : "";
+
+      this.logger.debug("#callDequeueMessagesFromCkQueue", {
+        ckWildcardQueue,
+        ckIndexKey,
+        queueConcurrencyLimitKey,
+        envConcurrencyLimitKey,
+        envCurrentConcurrencyKey,
+        messageKeyPrefix,
+        envQueueKey,
+        masterQueueKey,
+        ttlQueueKey,
+        shard,
+        maxCount,
+      });
+
+      const result = await this.redis.dequeueMessagesFromCkQueue(
+        //keys
+        ckIndexKey,
+        queueConcurrencyLimitKey,
+        envConcurrencyLimitKey,
+        envConcurrencyLimitBurstFactorKey,
+        envCurrentConcurrencyKey,
+        messageKeyPrefix,
+        envQueueKey,
+        masterQueueKey,
+        ttlQueueKey,
+        //args
+        ckWildcardQueue,
+        String(Date.now()),
+        String(this.options.defaultEnvConcurrency),
+        String(this.options.defaultEnvConcurrencyBurstFactor ?? 1),
+        this.options.redis.keyPrefix ?? "",
+        String(maxCount)
+      );
+
+      if (!result) {
+        span.setAttribute("message_count", 0);
+        return [];
+      }
+
+      this.logger.debug("dequeueMessagesFromCkQueue raw result", {
+        result,
+        service: this.name,
+      });
+
+      const messages = [];
+      for (let i = 0; i < result.length; i += 3) {
+        const messageId = result[i];
+        const messageScore = result[i + 1];
+        const rawMessage = result[i + 2];
+
+        const parsedMessage = OutputPayload.safeParse(JSON.parse(rawMessage));
+        if (!parsedMessage.success) {
+          this.logger.error(`[${this.name}] Failed to parse CK message`, {
+            messageId,
+            error: parsedMessage.error,
+            service: this.name,
+          });
+          continue;
+        }
+
+        messages.push({
+          messageId,
+          messageScore,
+          message: parsedMessage.data,
+        });
+      }
+
+      const filteredMessages = messages.filter(Boolean) as DequeuedMessage[];
+      span.setAttribute("message_count", filteredMessages.length);
+      return filteredMessages;
+    });
+  }
+
   async #callDequeueMessageFromWorkerQueue({
     workerQueue,
     blockingPop,
@@ -1800,7 +2371,30 @@ export class RunQueue {
       service: this.name,
     });
 
-    return this.redis.acknowledgeMessage(
+    if (message.concurrencyKey) {
+      const ckIndexKey = this.keys.ckIndexKeyFromQueue(message.queue);
+      const ckWildcardName = this.keys.toCkWildcard(message.queue);
+
+      return this.redis.acknowledgeMessageCk(
+        masterQueueKey,
+        messageKey,
+        messageQueue,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        workerQueueKey,
+        ckIndexKey,
+        messageId,
+        messageQueue,
+        messageKeyValue,
+        removeFromWorkerQueue ? "1" : "0",
+        ckWildcardName
+      );
+    }
+
+    return this.redis.acknowledgeMessage(
       masterQueueKey,
       messageKey,
       messageQueue,
@@ -1888,22 +2482,46 @@ export class RunQueue {
       service: this.name,
     });
 
-    await this.redis.nackMessage(
-      //keys
-      masterQueueKey,
-      messageKey,
-      messageQueue,
-      queueCurrentConcurrencyKey,
-      envCurrentConcurrencyKey,
-      queueCurrentDequeuedKey,
-      envCurrentDequeuedKey,
-      envQueueKey,
-      //args
-      messageId,
-      messageQueue,
-      JSON.stringify(message),
-      String(messageScore)
-    );
+    if (message.concurrencyKey) {
+      const ckIndexKey = this.keys.ckIndexKeyFromQueue(message.queue);
+      const ckWildcardName = this.keys.toCkWildcard(message.queue);
+
+      await this.redis.nackMessageCk(
+        //keys
+        masterQueueKey,
+        messageKey,
+        messageQueue,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        ckIndexKey,
+        //args
+        messageId,
+        messageQueue,
+        JSON.stringify(message),
+        String(messageScore),
+        ckWildcardName
+      );
+    } else {
+      await this.redis.nackMessage(
+        //keys
+        masterQueueKey,
+        messageKey,
+        messageQueue,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        //args
+        messageId,
+        messageQueue,
+        JSON.stringify(message),
+        String(messageScore)
+      );
+    }
   }
 
   async #callMoveToDeadLetterQueue({ message }: { message: OutputPayload }) {
@@ -1921,19 +2539,40 @@ export class RunQueue {
       this.shardCount
     );
 
-    await this.redis.moveToDeadLetterQueue(
-      masterQueueKey,
-      messageKey,
-      messageQueue,
-      queueCurrentConcurrencyKey,
-      envCurrentConcurrencyKey,
-      queueCurrentDequeuedKey,
-      envCurrentDequeuedKey,
-      envQueueKey,
-      deadLetterQueueKey,
-      messageId,
-      messageQueue
-    );
+    if (message.concurrencyKey) {
+      const ckIndexKey = this.keys.ckIndexKeyFromQueue(message.queue);
+      const ckWildcardName = this.keys.toCkWildcard(message.queue);
+
+      await this.redis.moveToDeadLetterQueueCk(
+        masterQueueKey,
+        messageKey,
+        messageQueue,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        deadLetterQueueKey,
+        ckIndexKey,
+        messageId,
+        messageQueue,
+        ckWildcardName
+      );
+    } else {
+      await this.redis.moveToDeadLetterQueue(
+        masterQueueKey,
+        messageKey,
+        messageQueue,
+        queueCurrentConcurrencyKey,
+        envCurrentConcurrencyKey,
+        queueCurrentDequeuedKey,
+        envCurrentDequeuedKey,
+        envQueueKey,
+        deadLetterQueueKey,
+        messageId,
+        messageQueue
+      );
+    }
   }
 
   #callUpdateEnvironmentConcurrencyLimits({
@@ -1973,7 +2612,7 @@ export class RunQueue {
       return;
     }
 
-    this.logger.info("Scanning concurrency sets for completed runs");
+    this.logger.debug("Scanning concurrency sets for completed runs");
 
     const stats = {
       streamCallbacks: 0,
@@ -2026,7 +2665,7 @@ export class RunQueue {
         return;
       }
 
-      this.logger.info("Processing concurrency keys from stream", {
+      this.logger.debug("Processing concurrency keys from stream", {
         keys: uniqueKeys,
       });
 
@@ -2096,9 +2735,9 @@ export class RunQueue {
   }
 
   private async processCurrentConcurrencyRunIds(concurrencyKey: string, runIds: string[]) {
-    this.logger.info("Processing concurrency set with runs", {
+    this.logger.debug("Processing concurrency set with runs", {
       concurrencyKey,
-      runIds: runIds.slice(0, 5), // Log first 5 for debugging,
+      runIds: runIds.slice(0, 5),
       runIdsLength: runIds.length,
     });
 
@@ -2106,12 +2745,12 @@ export class RunQueue {
     const completedRuns = await this.options.concurrencySweeper?.callback(runIds);
 
     if (!completedRuns) {
-      this.logger.info("No completed runs found in concurrency set", { concurrencyKey });
+      this.logger.debug("No completed runs found in concurrency set", { concurrencyKey });
       return;
     }
 
     if (completedRuns.length === 0) {
-      this.logger.info("No completed runs found in concurrency set", { concurrencyKey });
+      this.logger.debug("No completed runs found in concurrency set", { concurrencyKey });
       return;
     }
 
@@ -2275,8 +2914,112 @@ end
       `,
     });
 
+    // Enqueue message with optional fast path.
+    //
+    // Returns 1 (fast path: message pushed directly to worker queue) or 0 (slow path: message
+    // added to queue sorted set, needs processQueueForWorkerQueue to move it later).
+    //
+    // Fast-path conditions (all must be true):
+    //   1. enableFastPath == '1' (gated per WorkerInstanceGroup)
+    //   2. No available messages in the queue (ZRANGEBYSCORE finds nothing with score <= now)
+    //   3. Env concurrency has capacity (SCARD < limit * burstFactor)
+    //   4. Queue concurrency has capacity (SCARD < min(queueLimit, envLimit))
+    //
+    // The fast path performs the same concurrency bookkeeping (SADD to currentConcurrency sets)
+    // as dequeueMessagesFromQueue, so ack/nack/release work identically for both paths.
+    //
+    // When enableFastPath == '0', the script skips the fast-path check entirely and behaves
+    // identically to the pre-fast-path version (with the addition of returning 0).
     this.redis.defineCommand("enqueueMessage", {
-      numberOfKeys: 8,
+      numberOfKeys: 12,
+      lua: `
+local masterQueueKey = KEYS[1]
+local queueKey = KEYS[2]
+local messageKey = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+-- Fast-path keys (KEYS 9-12)
+local workerQueueKey = KEYS[9]
+local queueConcurrencyLimitKey = KEYS[10]
+local envConcurrencyLimitKey = KEYS[11]
+local envConcurrencyLimitBurstFactorKey = KEYS[12]
+
+local queueName = ARGV[1]
+local messageId = ARGV[2]
+local messageData = ARGV[3]
+local messageScore = ARGV[4]
+-- Fast-path args (ARGV 5-9)
+local messageKeyValue = ARGV[5]
+local defaultEnvConcurrencyLimit = ARGV[6]
+local defaultEnvConcurrencyBurstFactor = ARGV[7]
+local currentTime = ARGV[8]
+local enableFastPath = ARGV[9]
+
+-- Fast path: check if we can skip the queue and go directly to worker queue
+if enableFastPath == '1' then
+  local available = redis.call('ZRANGEBYSCORE', queueKey, '-inf', currentTime, 'LIMIT', 0, 1)
+  if #available == 0 then
+    local envCurrent = tonumber(redis.call('SCARD', envCurrentConcurrencyKey) or '0')
+    local envLimit = tonumber(redis.call('GET', envConcurrencyLimitKey) or defaultEnvConcurrencyLimit)
+    local envBurstFactor = tonumber(redis.call('GET', envConcurrencyLimitBurstFactorKey) or defaultEnvConcurrencyBurstFactor)
+    local envLimitWithBurst = math.floor(envLimit * envBurstFactor)
+
+    if envCurrent < envLimitWithBurst then
+      local queueCurrent = tonumber(redis.call('SCARD', queueCurrentConcurrencyKey) or '0')
+      local queueLimit = math.min(
+        tonumber(redis.call('GET', queueConcurrencyLimitKey) or '1000000'),
+        envLimit
+      )
+
+      if queueCurrent < queueLimit then
+        redis.call('SET', messageKey, messageData)
+        redis.call('SADD', queueCurrentConcurrencyKey, messageId)
+        redis.call('SADD', envCurrentConcurrencyKey, messageId)
+        redis.call('RPUSH', workerQueueKey, messageKeyValue)
+        return 1
+      end
+    end
+  end
+end
+
+-- Slow path: normal enqueue
+-- Write the message to the message key
+redis.call('SET', messageKey, messageData)
+
+-- Add the message to the queue
+redis.call('ZADD', queueKey, messageScore, messageId)
+
+-- Add the message to the env queue
+redis.call('ZADD', envQueueKey, messageScore, messageId)
+
+-- Rebalance the parent queues
+local earliestMessage = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+
+if #earliestMessage == 0 then
+  redis.call('ZREM', masterQueueKey, queueName)
+else
+  redis.call('ZADD', masterQueueKey, earliestMessage[2], queueName)
+end
+
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+return 0
+      `,
+    });
+
+    // Enqueue with TTL tracking. Same fast-path logic as enqueueMessage.
+    // On fast path, the TTL sorted set is intentionally skipped — the expireRun worker job
+    // (scheduled independently before enqueue) handles TTL expiry. This mirrors what
+    // dequeueMessagesFromQueue does: it removes from the TTL set when dequeuing.
+    this.redis.defineCommand("enqueueMessageWithTtl", {
+      numberOfKeys: 13,
       lua: `
 local masterQueueKey = KEYS[1]
 local queueKey = KEYS[2]
@@ -2286,12 +3029,55 @@ local envCurrentConcurrencyKey = KEYS[5]
 local queueCurrentDequeuedKey = KEYS[6]
 local envCurrentDequeuedKey = KEYS[7]
 local envQueueKey = KEYS[8]
+local ttlQueueKey = KEYS[9]
+-- Fast-path keys (KEYS 10-13)
+local workerQueueKey = KEYS[10]
+local queueConcurrencyLimitKey = KEYS[11]
+local envConcurrencyLimitKey = KEYS[12]
+local envConcurrencyLimitBurstFactorKey = KEYS[13]
 
 local queueName = ARGV[1]
 local messageId = ARGV[2]
 local messageData = ARGV[3]
 local messageScore = ARGV[4]
+local ttlMember = ARGV[5]
+local ttlScore = ARGV[6]
+-- Fast-path args (ARGV 7-11)
+local messageKeyValue = ARGV[7]
+local defaultEnvConcurrencyLimit = ARGV[8]
+local defaultEnvConcurrencyBurstFactor = ARGV[9]
+local currentTime = ARGV[10]
+local enableFastPath = ARGV[11]
+
+-- Fast path: check if we can skip the queue and go directly to worker queue
+if enableFastPath == '1' then
+  local available = redis.call('ZRANGEBYSCORE', queueKey, '-inf', currentTime, 'LIMIT', 0, 1)
+  if #available == 0 then
+    local envCurrent = tonumber(redis.call('SCARD', envCurrentConcurrencyKey) or '0')
+    local envLimit = tonumber(redis.call('GET', envConcurrencyLimitKey) or defaultEnvConcurrencyLimit)
+    local envBurstFactor = tonumber(redis.call('GET', envConcurrencyLimitBurstFactorKey) or defaultEnvConcurrencyBurstFactor)
+    local envLimitWithBurst = math.floor(envLimit * envBurstFactor)
+
+    if envCurrent < envLimitWithBurst then
+      local queueCurrent = tonumber(redis.call('SCARD', queueCurrentConcurrencyKey) or '0')
+      local queueLimit = math.min(
+        tonumber(redis.call('GET', queueConcurrencyLimitKey) or '1000000'),
+        envLimit
+      )
+
+      if queueCurrent < queueLimit then
+        redis.call('SET', messageKey, messageData)
+        redis.call('SADD', queueCurrentConcurrencyKey, messageId)
+        redis.call('SADD', envCurrentConcurrencyKey, messageId)
+        redis.call('RPUSH', workerQueueKey, messageKeyValue)
+        -- Skip TTL sorted set: the expireRun worker job handles TTL expiry independently
+        return 1
+      end
+    end
+  end
+end
 
+-- Slow path: normal enqueue
 -- Write the message to the message key
 redis.call('SET', messageKey, messageData)
 
@@ -2301,6 +3087,9 @@ redis.call('ZADD', queueKey, messageScore, messageId)
 -- Add the message to the env queue
 redis.call('ZADD', envQueueKey, messageScore, messageId)
 
+-- Add to TTL sorted set
+redis.call('ZADD', ttlQueueKey, ttlScore, ttlMember)
+
 -- Rebalance the parent queues
 local earliestMessage = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
 
@@ -2315,11 +3104,319 @@ redis.call('SREM', queueCurrentConcurrencyKey, messageId)
 redis.call('SREM', envCurrentConcurrencyKey, messageId)
 redis.call('SREM', queueCurrentDequeuedKey, messageId)
 redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+return 0
+      `,
+    });
+
+    // CK-aware enqueue: adds to CK index + master queue with :ck:* member.
+    // Same fast-path logic as enqueueMessage. For CK queues, the fast-path checks the
+    // per-CK sub-queue for available messages and the per-CK concurrency limit.
+    this.redis.defineCommand("enqueueMessageCk", {
+      numberOfKeys: 13,
+      lua: `
+local masterQueueKey = KEYS[1]
+local queueKey = KEYS[2]
+local messageKey = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+local ckIndexKey = KEYS[9]
+-- Fast-path keys (KEYS 10-13)
+local workerQueueKey = KEYS[10]
+local queueConcurrencyLimitKey = KEYS[11]
+local envConcurrencyLimitKey = KEYS[12]
+local envConcurrencyLimitBurstFactorKey = KEYS[13]
+
+local queueName = ARGV[1]
+local messageId = ARGV[2]
+local messageData = ARGV[3]
+local messageScore = ARGV[4]
+local ckWildcardName = ARGV[5]
+-- Fast-path args (ARGV 6-10)
+local messageKeyValue = ARGV[6]
+local defaultEnvConcurrencyLimit = ARGV[7]
+local defaultEnvConcurrencyBurstFactor = ARGV[8]
+local currentTime = ARGV[9]
+local enableFastPath = ARGV[10]
+
+-- Fast path: check if we can skip the queue and go directly to worker queue
+if enableFastPath == '1' then
+  local available = redis.call('ZRANGEBYSCORE', queueKey, '-inf', currentTime, 'LIMIT', 0, 1)
+  if #available == 0 then
+    local envCurrent = tonumber(redis.call('SCARD', envCurrentConcurrencyKey) or '0')
+    local envLimit = tonumber(redis.call('GET', envConcurrencyLimitKey) or defaultEnvConcurrencyLimit)
+    local envBurstFactor = tonumber(redis.call('GET', envConcurrencyLimitBurstFactorKey) or defaultEnvConcurrencyBurstFactor)
+    local envLimitWithBurst = math.floor(envLimit * envBurstFactor)
+
+    if envCurrent < envLimitWithBurst then
+      -- For CK queues, check per-CK concurrency (same key as queue concurrency)
+      local queueCurrent = tonumber(redis.call('SCARD', queueCurrentConcurrencyKey) or '0')
+      local queueLimit = math.min(
+        tonumber(redis.call('GET', queueConcurrencyLimitKey) or '1000000'),
+        envLimit
+      )
+
+      if queueCurrent < queueLimit then
+        redis.call('SET', messageKey, messageData)
+        redis.call('SADD', queueCurrentConcurrencyKey, messageId)
+        redis.call('SADD', envCurrentConcurrencyKey, messageId)
+        redis.call('RPUSH', workerQueueKey, messageKeyValue)
+        return 1
+      end
+    end
+  end
+end
+
+-- Slow path: normal enqueue
+-- Write the message to the message key
+redis.call('SET', messageKey, messageData)
+
+-- Add the message to the CK-specific queue
+redis.call('ZADD', queueKey, messageScore, messageId)
+
+-- Add the message to the env queue
+redis.call('ZADD', envQueueKey, messageScore, messageId)
+
+-- Rebalance CK index
+local earliest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+if #earliest > 0 then
+  redis.call('ZADD', ckIndexKey, earliest[2], queueName)
+end
+
+-- Rebalance master queue with ck:* member
+local earliestIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestIdx > 0 then
+  redis.call('ZADD', masterQueueKey, earliestIdx[2], ckWildcardName)
+end
+
+-- Remove old-format entry from master queue (transition cleanup)
+redis.call('ZREM', masterQueueKey, queueName)
+
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+return 0
+      `,
+    });
+
+    // CK-aware enqueue with TTL tracking. Combines CK and TTL behavior with fast path.
+    // On fast path: skips both the CK sub-queue and TTL sorted set.
+    this.redis.defineCommand("enqueueMessageWithTtlCk", {
+      numberOfKeys: 14,
+      lua: `
+local masterQueueKey = KEYS[1]
+local queueKey = KEYS[2]
+local messageKey = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+local ttlQueueKey = KEYS[9]
+local ckIndexKey = KEYS[10]
+-- Fast-path keys (KEYS 11-14)
+local workerQueueKey = KEYS[11]
+local queueConcurrencyLimitKey = KEYS[12]
+local envConcurrencyLimitKey = KEYS[13]
+local envConcurrencyLimitBurstFactorKey = KEYS[14]
+
+local queueName = ARGV[1]
+local messageId = ARGV[2]
+local messageData = ARGV[3]
+local messageScore = ARGV[4]
+local ttlMember = ARGV[5]
+local ttlScore = ARGV[6]
+local ckWildcardName = ARGV[7]
+-- Fast-path args (ARGV 8-12)
+local messageKeyValue = ARGV[8]
+local defaultEnvConcurrencyLimit = ARGV[9]
+local defaultEnvConcurrencyBurstFactor = ARGV[10]
+local currentTime = ARGV[11]
+local enableFastPath = ARGV[12]
+
+-- Fast path: check if we can skip the queue and go directly to worker queue
+if enableFastPath == '1' then
+  local available = redis.call('ZRANGEBYSCORE', queueKey, '-inf', currentTime, 'LIMIT', 0, 1)
+  if #available == 0 then
+    local envCurrent = tonumber(redis.call('SCARD', envCurrentConcurrencyKey) or '0')
+    local envLimit = tonumber(redis.call('GET', envConcurrencyLimitKey) or defaultEnvConcurrencyLimit)
+    local envBurstFactor = tonumber(redis.call('GET', envConcurrencyLimitBurstFactorKey) or defaultEnvConcurrencyBurstFactor)
+    local envLimitWithBurst = math.floor(envLimit * envBurstFactor)
+
+    if envCurrent < envLimitWithBurst then
+      local queueCurrent = tonumber(redis.call('SCARD', queueCurrentConcurrencyKey) or '0')
+      local queueLimit = math.min(
+        tonumber(redis.call('GET', queueConcurrencyLimitKey) or '1000000'),
+        envLimit
+      )
+
+      if queueCurrent < queueLimit then
+        redis.call('SET', messageKey, messageData)
+        redis.call('SADD', queueCurrentConcurrencyKey, messageId)
+        redis.call('SADD', envCurrentConcurrencyKey, messageId)
+        redis.call('RPUSH', workerQueueKey, messageKeyValue)
+        -- Skip TTL sorted set: the expireRun worker job handles TTL expiry independently
+        return 1
+      end
+    end
+  end
+end
+
+-- Slow path: normal enqueue
+-- Write the message to the message key
+redis.call('SET', messageKey, messageData)
+
+-- Add the message to the CK-specific queue
+redis.call('ZADD', queueKey, messageScore, messageId)
+
+-- Add the message to the env queue
+redis.call('ZADD', envQueueKey, messageScore, messageId)
+
+-- Add to TTL sorted set
+redis.call('ZADD', ttlQueueKey, ttlScore, ttlMember)
+
+-- Rebalance CK index
+local earliest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+if #earliest > 0 then
+  redis.call('ZADD', ckIndexKey, earliest[2], queueName)
+end
+
+-- Rebalance master queue with ck:* member
+local earliestIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestIdx > 0 then
+  redis.call('ZADD', masterQueueKey, earliestIdx[2], ckWildcardName)
+end
+
+-- Remove old-format entry from master queue (transition cleanup)
+redis.call('ZREM', masterQueueKey, queueName)
+
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+return 0
+      `,
+    });
+
+    // Expire TTL runs - atomically removes from TTL set, acknowledges from normal queue, and enqueues to TTL worker
+    this.redis.defineCommand("expireTtlRuns", {
+      numberOfKeys: 1,
+      lua: `
+local ttlQueueKey = KEYS[1]
+local keyPrefix = ARGV[1]
+local currentTime = tonumber(ARGV[2])
+local batchSize = tonumber(ARGV[3])
+local shardCount = tonumber(ARGV[4])
+local workerQueueKey = ARGV[5]
+local workerItemsKey = ARGV[6]
+local visibilityTimeoutMs = tonumber(ARGV[7])
+
+-- Get expired runs from TTL sorted set (score <= currentTime)
+local expiredMembers = redis.call('ZRANGEBYSCORE', ttlQueueKey, '-inf', currentTime, 'LIMIT', 0, batchSize)
+
+if #expiredMembers == 0 then
+  return {}
+end
+
+local time = redis.call('TIME')
+local nowMs = tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000)
+
+local results = {}
+
+for i, member in ipairs(expiredMembers) do
+  -- Parse member format: "queueKey|runId|orgId"
+  local pipePos1 = string.find(member, "|", 1, true)
+  if pipePos1 then
+    local pipePos2 = string.find(member, "|", pipePos1 + 1, true)
+    if pipePos2 then
+      local rawQueueKey = string.sub(member, 1, pipePos1 - 1)
+      local runId = string.sub(member, pipePos1 + 1, pipePos2 - 1)
+      local orgId = string.sub(member, pipePos2 + 1)
+
+      -- Prefix the queue key so it matches the actual Redis keys
+      local queueKey = keyPrefix .. rawQueueKey
+
+      -- Remove from TTL set
+      redis.call('ZREM', ttlQueueKey, member)
+
+      -- Construct keys for acknowledging the run from normal queue
+      -- Extract org from rawQueueKey: {org:orgId}:proj:...
+      local orgKeyStart = string.find(rawQueueKey, "{org:", 1, true)
+      local orgKeyEnd = string.find(rawQueueKey, "}", orgKeyStart, true)
+      local orgFromQueue = string.sub(rawQueueKey, orgKeyStart + 5, orgKeyEnd - 1)
+
+      local messageKey = keyPrefix .. "{org:" .. orgFromQueue .. "}:message:" .. runId
+
+      -- Delete message key
+      redis.call('DEL', messageKey)
+
+      -- Remove from queue sorted set
+      redis.call('ZREM', queueKey, runId)
+
+      -- Remove from env queue (derive from rawQueueKey)
+      -- rawQueueKey format: {org:X}:proj:Y:env:Z:queue:Q[:ck:C]
+      local envMatch = string.match(rawQueueKey, ":env:([^:]+)")
+      if envMatch then
+        local envQueueKey = keyPrefix .. "{org:" .. orgFromQueue .. "}:env:" .. envMatch
+        redis.call('ZREM', envQueueKey, runId)
+      end
+
+      -- Remove from concurrency sets
+      local concurrencyKey = queueKey .. ":currentConcurrency"
+      local dequeuedKey = queueKey .. ":currentDequeued"
+      redis.call('SREM', concurrencyKey, runId)
+      redis.call('SREM', dequeuedKey, runId)
+
+      -- Env concurrency (derive from rawQueueKey; must match RunQueueKeyProducer: org + proj + env)
+      -- rawQueueKey format: {org:X}:proj:Y:env:Z:queue:Q[:ck:C]
+      local projMatch = string.match(rawQueueKey, ":proj:([^:]+):env:")
+      local envConcurrencyKey = keyPrefix .. "{org:" .. orgFromQueue .. "}:proj:" .. (projMatch or "") .. ":env:" .. (envMatch or "") .. ":currentConcurrency"
+      local envDequeuedKey = keyPrefix .. "{org:" .. orgFromQueue .. "}:proj:" .. (projMatch or "") .. ":env:" .. (envMatch or "") .. ":currentDequeued"
+      redis.call('SREM', envConcurrencyKey, runId)
+      redis.call('SREM', envDequeuedKey, runId)
+
+      -- Rebalance CK index if this is a CK queue
+      local ckMatch = string.match(rawQueueKey, "^(.+):ck:.+$")
+      if ckMatch then
+        local ckIndexKey = keyPrefix .. ckMatch .. ":ckIndex"
+        local earliest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+        if #earliest == 0 then
+          redis.call('ZREM', ckIndexKey, rawQueueKey)
+        else
+          redis.call('ZADD', ckIndexKey, earliest[2], rawQueueKey)
+        end
+      end
+
+      -- Enqueue to TTL worker (runId is natural dedup key)
+      local serializedItem = cjson.encode({
+        job = "expireTtlRun",
+        item = { runId = runId, orgId = orgId, queueKey = rawQueueKey },
+        visibilityTimeoutMs = visibilityTimeoutMs,
+        attempt = 0
+      })
+      redis.call('ZADD', workerQueueKey, nowMs, runId)
+      redis.call('HSET', workerItemsKey, runId, serializedItem)
+
+      -- Add to results
+      table.insert(results, member)
+    end
+  end
+end
+
+return results
       `,
     });
 
     this.redis.defineCommand("dequeueMessagesFromQueue", {
-      numberOfKeys: 9,
+      numberOfKeys: 10,
       lua: `
 local queueKey = KEYS[1]
 local queueConcurrencyLimitKey = KEYS[2]
@@ -2330,6 +3427,7 @@ local envCurrentConcurrencyKey = KEYS[6]
 local messageKeyPrefix = KEYS[7]
 local envQueueKey = KEYS[8]
 local masterQueueKey = KEYS[9]
+local ttlQueueKey = KEYS[10]  -- Optional: TTL sorted set key (empty string if not used)
 
 local queueName = ARGV[1]
 local currentTime = tonumber(ARGV[2])
@@ -2381,24 +3479,49 @@ local dequeuedCount = 0
 for i = 1, #messages, 2 do
     local messageId = messages[i]
     local messageScore = tonumber(messages[i + 1])
-    
+
     -- Get the message payload
     local messageKey = messageKeyPrefix .. messageId
     local messagePayload = redis.call('GET', messageKey)
-    
+
     if messagePayload then
-        -- Update concurrency
+        -- Parse the message to check for TTL expiration
+        local messageData = cjson.decode(messagePayload)
+        local ttlExpiresAt = messageData and messageData.ttlExpiresAt
+
+        -- Check if TTL has expired
+        if ttlExpiresAt and ttlExpiresAt <= currentTime then
+            -- TTL expired - remove from dequeue queues so it won't be retried,
+            -- but leave messageKey and ttlQueueKey intact for the TTL consumer
+            -- to discover and properly expire the run.
+            redis.call('ZREM', queueKey, messageId)
+            redis.call('ZREM', envQueueKey, messageId)
+        else
+            -- Not expired - process normally
+            redis.call('ZREM', queueKey, messageId)
+            redis.call('ZREM', envQueueKey, messageId)
+            redis.call('SADD', queueCurrentConcurrencyKey, messageId)
+            redis.call('SADD', envCurrentConcurrencyKey, messageId)
+
+            -- Remove from TTL set if provided (run is being executed, not expired)
+            if ttlQueueKey and ttlQueueKey ~= '' and ttlExpiresAt then
+                local ttlMember = queueName .. '|' .. messageId .. '|' .. (messageData.orgId or '')
+                redis.call('ZREM', ttlQueueKey, ttlMember)
+            end
+
+            -- Add to results
+            table.insert(results, messageId)
+            table.insert(results, messageScore)
+            table.insert(results, messagePayload)
+
+            dequeuedCount = dequeuedCount + 1
+        end
+    else
+        -- Stale entry: message key was already deleted (e.g. acknowledged),
+        -- but the sorted set member was not cleaned up. Remove it so it
+        -- doesn't block newer messages from being dequeued.
         redis.call('ZREM', queueKey, messageId)
         redis.call('ZREM', envQueueKey, messageId)
-        redis.call('SADD', queueCurrentConcurrencyKey, messageId)
-        redis.call('SADD', envCurrentConcurrencyKey, messageId)
-        
-        -- Add to results
-        table.insert(results, messageId)
-        table.insert(results, messageScore)
-        table.insert(results, messagePayload)
-        
-        dequeuedCount = dequeuedCount + 1
     end
 end
 
@@ -2416,13 +3539,158 @@ return results
       `,
     });
 
-    this.redis.defineCommand("dequeueMessageFromWorkerQueueNonBlocking", {
-      numberOfKeys: 1,
+    // CK-aware dequeue: iterates CK sub-queues from CK index
+    this.redis.defineCommand("dequeueMessagesFromCkQueue", {
+      numberOfKeys: 9,
       lua: `
-local workerQueueKey = KEYS[1]
-
--- lpop the first message from the worker queue
-local messageId = redis.call('LPOP', workerQueueKey)
+local ckIndexKey = KEYS[1]
+local queueConcurrencyLimitKey = KEYS[2]
+local envConcurrencyLimitKey = KEYS[3]
+local envConcurrencyLimitBurstFactorKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local messageKeyPrefix = KEYS[6]
+local envQueueKey = KEYS[7]
+local masterQueueKey = KEYS[8]
+local ttlQueueKey = KEYS[9]
+
+local ckWildcardName = ARGV[1]
+local currentTime = tonumber(ARGV[2])
+local defaultEnvConcurrencyLimit = ARGV[3]
+local defaultEnvConcurrencyBurstFactor = ARGV[4]
+local keyPrefix = ARGV[5]
+local maxCount = tonumber(ARGV[6] or '1')
+
+-- Check env concurrency
+local envCurrentConcurrency = tonumber(redis.call('SCARD', envCurrentConcurrencyKey) or '0')
+local envConcurrencyLimit = tonumber(redis.call('GET', envConcurrencyLimitKey) or defaultEnvConcurrencyLimit)
+local envConcurrencyLimitBurstFactor = tonumber(redis.call('GET', envConcurrencyLimitBurstFactorKey) or defaultEnvConcurrencyBurstFactor)
+local envConcurrencyLimitWithBurstFactor = math.floor(envConcurrencyLimit * envConcurrencyLimitBurstFactor)
+
+if envCurrentConcurrency >= envConcurrencyLimitWithBurstFactor then
+  return nil
+end
+
+-- Get base queue concurrency limit
+local queueConcurrencyLimit = math.min(tonumber(redis.call('GET', queueConcurrencyLimitKey) or '1000000'), envConcurrencyLimit)
+
+-- Calculate env available capacity
+local envAvailableCapacity = envConcurrencyLimitWithBurstFactor - envCurrentConcurrency
+local actualMaxCount = math.min(maxCount, envAvailableCapacity)
+
+if actualMaxCount <= 0 then
+  return nil
+end
+
+-- Get CK sub-queues from CK index with scores <= currentTime
+local ckQueues = redis.call('ZRANGEBYSCORE', ckIndexKey, '-inf', tostring(currentTime), 'LIMIT', 0, actualMaxCount * 3)
+
+if #ckQueues == 0 then
+  -- Rebalance master queue in case CK index has future-scored entries
+  local anyIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+  if #anyIdx == 0 then
+    redis.call('ZREM', masterQueueKey, ckWildcardName)
+  else
+    redis.call('ZADD', masterQueueKey, anyIdx[2], ckWildcardName)
+  end
+  return nil
+end
+
+local results = {}
+local dequeuedCount = 0
+
+for _, ckQueueName in ipairs(ckQueues) do
+  if dequeuedCount >= actualMaxCount then
+    break
+  end
+
+  local fullQueueKey = keyPrefix .. ckQueueName
+
+  -- Check CK-specific concurrency
+  local ckConcurrencyKey = fullQueueKey .. ':currentConcurrency'
+  local ckCurrentConcurrency = tonumber(redis.call('SCARD', ckConcurrencyKey) or '0')
+
+  if ckCurrentConcurrency < queueConcurrencyLimit then
+    -- Try to dequeue one message from this CK sub-queue
+    local messages = redis.call('ZRANGEBYSCORE', fullQueueKey, '-inf', tostring(currentTime), 'WITHSCORES', 'LIMIT', 0, 1)
+
+    if #messages >= 2 then
+      local messageId = messages[1]
+      local messageScore = messages[2]
+
+      local messageKey = messageKeyPrefix .. messageId
+      local messagePayload = redis.call('GET', messageKey)
+
+      if messagePayload then
+        local messageData = cjson.decode(messagePayload)
+        local ttlExpiresAt = messageData and messageData.ttlExpiresAt
+
+        if ttlExpiresAt and ttlExpiresAt <= currentTime then
+          -- TTL expired - remove from queues
+          redis.call('ZREM', fullQueueKey, messageId)
+          redis.call('ZREM', envQueueKey, messageId)
+        else
+          -- Dequeue normally
+          redis.call('ZREM', fullQueueKey, messageId)
+          redis.call('ZREM', envQueueKey, messageId)
+          redis.call('SADD', ckConcurrencyKey, messageId)
+          redis.call('SADD', envCurrentConcurrencyKey, messageId)
+
+          -- Remove from TTL set if applicable
+          if ttlQueueKey and ttlQueueKey ~= '' and ttlExpiresAt then
+            local ttlMember = ckQueueName .. '|' .. messageId .. '|' .. (messageData.orgId or '')
+            redis.call('ZREM', ttlQueueKey, ttlMember)
+          end
+
+          table.insert(results, messageId)
+          table.insert(results, messageScore)
+          table.insert(results, messagePayload)
+
+          dequeuedCount = dequeuedCount + 1
+        end
+      else
+        -- Stale entry
+        redis.call('ZREM', fullQueueKey, messageId)
+        redis.call('ZREM', envQueueKey, messageId)
+      end
+
+      -- Rebalance CK index for this sub-queue
+      local earliest = redis.call('ZRANGE', fullQueueKey, 0, 0, 'WITHSCORES')
+      if #earliest == 0 then
+        redis.call('ZREM', ckIndexKey, ckQueueName)
+      else
+        redis.call('ZADD', ckIndexKey, earliest[2], ckQueueName)
+      end
+    else
+      -- No messages available in score range, update CK index
+      local any = redis.call('ZRANGE', fullQueueKey, 0, 0, 'WITHSCORES')
+      if #any == 0 then
+        redis.call('ZREM', ckIndexKey, ckQueueName)
+      else
+        redis.call('ZADD', ckIndexKey, any[2], ckQueueName)
+      end
+    end
+  end
+end
+
+-- Rebalance master queue
+local earliestIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestIdx == 0 then
+  redis.call('ZREM', masterQueueKey, ckWildcardName)
+else
+  redis.call('ZADD', masterQueueKey, earliestIdx[2], ckWildcardName)
+end
+
+return results
+      `,
+    });
+
+    this.redis.defineCommand("dequeueMessageFromWorkerQueueNonBlocking", {
+      numberOfKeys: 1,
+      lua: `
+local workerQueueKey = KEYS[1]
+
+-- lpop the first message from the worker queue
+local messageId = redis.call('LPOP', workerQueueKey)
 
 -- if there is no messageId, return nil
 if not messageId then
@@ -2591,6 +3859,177 @@ end
 -- Add the message to the dead letter queue
 redis.call('ZADD', deadLetterQueueKey, tonumber(redis.call('TIME')[1]), messageId)
 
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+`,
+    });
+
+    // CK-aware acknowledge: rebalances CK index and master queue with :ck:* member
+    this.redis.defineCommand("acknowledgeMessageCk", {
+      numberOfKeys: 10,
+      lua: `
+-- Keys:
+local masterQueueKey = KEYS[1]
+local messageKey = KEYS[2]
+local messageQueueKey = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+local workerQueueKey = KEYS[9]
+local ckIndexKey = KEYS[10]
+
+-- Args:
+local messageId = ARGV[1]
+local messageQueueName = ARGV[2]
+local messageKeyValue = ARGV[3]
+local removeFromWorkerQueue = ARGV[4]
+local ckWildcardName = ARGV[5]
+
+-- Remove the message from the message key
+redis.call('DEL', messageKey)
+
+-- Remove the message from the CK-specific queue
+redis.call('ZREM', messageQueueKey, messageId)
+redis.call('ZREM', envQueueKey, messageId)
+
+-- Rebalance CK index
+local earliestInCkQueue = redis.call('ZRANGE', messageQueueKey, 0, 0, 'WITHSCORES')
+if #earliestInCkQueue == 0 then
+  redis.call('ZREM', ckIndexKey, messageQueueName)
+else
+  redis.call('ZADD', ckIndexKey, earliestInCkQueue[2], messageQueueName)
+end
+
+-- Rebalance master queue with ck:* member
+local earliestInCkIndex = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestInCkIndex == 0 then
+  redis.call('ZREM', masterQueueKey, ckWildcardName)
+else
+  redis.call('ZADD', masterQueueKey, earliestInCkIndex[2], ckWildcardName)
+end
+
+-- Remove old-format entry from master queue (transition cleanup)
+redis.call('ZREM', masterQueueKey, messageQueueName)
+
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+-- Remove the message from the worker queue
+if removeFromWorkerQueue == '1' then
+  redis.call('LREM', workerQueueKey, 0, messageKeyValue)
+end
+`,
+    });
+
+    // CK-aware nack: rebalances CK index and master queue with :ck:* member
+    this.redis.defineCommand("nackMessageCk", {
+      numberOfKeys: 9,
+      lua: `
+-- Keys:
+local masterQueueKey = KEYS[1]
+local messageKey = KEYS[2]
+local messageQueueKey = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+local ckIndexKey = KEYS[9]
+
+-- Args:
+local messageId = ARGV[1]
+local messageQueueName = ARGV[2]
+local messageData = ARGV[3]
+local messageScore = tonumber(ARGV[4])
+local ckWildcardName = ARGV[5]
+
+-- Update the message data
+redis.call('SET', messageKey, messageData)
+
+-- Update the concurrency keys
+redis.call('SREM', queueCurrentConcurrencyKey, messageId)
+redis.call('SREM', envCurrentConcurrencyKey, messageId)
+redis.call('SREM', queueCurrentDequeuedKey, messageId)
+redis.call('SREM', envCurrentDequeuedKey, messageId)
+
+-- Enqueue the message back into the CK-specific queue
+redis.call('ZADD', messageQueueKey, messageScore, messageId)
+redis.call('ZADD', envQueueKey, messageScore, messageId)
+
+-- Rebalance CK index
+local earliest = redis.call('ZRANGE', messageQueueKey, 0, 0, 'WITHSCORES')
+if #earliest > 0 then
+  redis.call('ZADD', ckIndexKey, earliest[2], messageQueueName)
+end
+
+-- Rebalance master queue with ck:* member
+local earliestIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestIdx == 0 then
+  redis.call('ZREM', masterQueueKey, ckWildcardName)
+else
+  redis.call('ZADD', masterQueueKey, earliestIdx[2], ckWildcardName)
+end
+
+-- Remove old-format entry from master queue (transition cleanup)
+redis.call('ZREM', masterQueueKey, messageQueueName)
+`,
+    });
+
+    // CK-aware move to dead letter queue
+    this.redis.defineCommand("moveToDeadLetterQueueCk", {
+      numberOfKeys: 10,
+      lua: `
+-- Keys:
+local masterQueueKey = KEYS[1]
+local messageKey = KEYS[2]
+local messageQueue = KEYS[3]
+local queueCurrentConcurrencyKey = KEYS[4]
+local envCurrentConcurrencyKey = KEYS[5]
+local queueCurrentDequeuedKey = KEYS[6]
+local envCurrentDequeuedKey = KEYS[7]
+local envQueueKey = KEYS[8]
+local deadLetterQueueKey = KEYS[9]
+local ckIndexKey = KEYS[10]
+
+-- Args:
+local messageId = ARGV[1]
+local messageQueueName = ARGV[2]
+local ckWildcardName = ARGV[3]
+
+-- Remove the message from the CK-specific queue
+redis.call('ZREM', messageQueue, messageId)
+redis.call('ZREM', envQueueKey, messageId)
+
+-- Rebalance CK index
+local earliest = redis.call('ZRANGE', messageQueue, 0, 0, 'WITHSCORES')
+if #earliest == 0 then
+  redis.call('ZREM', ckIndexKey, messageQueueName)
+else
+  redis.call('ZADD', ckIndexKey, earliest[2], messageQueueName)
+end
+
+-- Rebalance master queue with ck:* member
+local earliestIdx = redis.call('ZRANGE', ckIndexKey, 0, 0, 'WITHSCORES')
+if #earliestIdx == 0 then
+  redis.call('ZREM', masterQueueKey, ckWildcardName)
+else
+  redis.call('ZADD', masterQueueKey, earliestIdx[2], ckWildcardName)
+end
+
+-- Remove old-format entry from master queue (transition cleanup)
+redis.call('ZREM', masterQueueKey, messageQueueName)
+
+-- Add the message to the dead letter queue
+redis.call('ZADD', deadLetterQueueKey, tonumber(redis.call('TIME')[1]), messageId)
+
 -- Update the concurrency keys
 redis.call('SREM', queueCurrentConcurrencyKey, messageId)
 redis.call('SREM', envCurrentConcurrencyKey, messageId)
@@ -2740,13 +4179,66 @@ declare module "@internal/redis" {
       queueCurrentDequeuedKey: string,
       envCurrentDequeuedKey: string,
       envQueueKey: string,
+      workerQueueKey: string,
+      queueConcurrencyLimitKey: string,
+      envConcurrencyLimitKey: string,
+      envConcurrencyLimitBurstFactorKey: string,
       //args
       queueName: string,
       messageId: string,
       messageData: string,
       messageScore: string,
-      callback?: Callback<void>
-    ): Result<void, Context>;
+      messageKeyValue: string,
+      defaultEnvConcurrencyLimit: string,
+      defaultEnvConcurrencyBurstFactor: string,
+      currentTime: string,
+      enableFastPath: string,
+      callback?: Callback<number>
+    ): Result<number, Context>;
+
+    enqueueMessageWithTtl(
+      //keys
+      masterQueueKey: string,
+      queue: string,
+      messageKey: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      ttlQueueKey: string,
+      workerQueueKey: string,
+      queueConcurrencyLimitKey: string,
+      envConcurrencyLimitKey: string,
+      envConcurrencyLimitBurstFactorKey: string,
+      //args
+      queueName: string,
+      messageId: string,
+      messageData: string,
+      messageScore: string,
+      ttlMember: string,
+      ttlScore: string,
+      messageKeyValue: string,
+      defaultEnvConcurrencyLimit: string,
+      defaultEnvConcurrencyBurstFactor: string,
+      currentTime: string,
+      enableFastPath: string,
+      callback?: Callback<number>
+    ): Result<number, Context>;
+
+    expireTtlRuns(
+      //keys
+      ttlQueueKey: string,
+      //args
+      keyPrefix: string,
+      currentTime: string,
+      batchSize: string,
+      shardCount: string,
+      workerQueueKey: string,
+      workerItemsKey: string,
+      visibilityTimeoutMs: string,
+      callback?: Callback<string[]>
+    ): Result<string[], Context>;
 
     dequeueMessagesFromQueue(
       //keys
@@ -2759,6 +4251,7 @@ declare module "@internal/redis" {
       messageKeyPrefix: string,
       envQueueKey: string,
       masterQueueKey: string,
+      ttlQueueKey: string,
       //args
       childQueueName: string,
       currentTime: string,
@@ -2878,6 +4371,149 @@ declare module "@internal/redis" {
       maxCount: string,
       callback?: Callback<string[]>
     ): Result<string[], Context>;
+
+    // CK-aware commands
+    enqueueMessageCk(
+      //keys
+      masterQueueKey: string,
+      queue: string,
+      messageKey: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      ckIndexKey: string,
+      workerQueueKey: string,
+      queueConcurrencyLimitKey: string,
+      envConcurrencyLimitKey: string,
+      envConcurrencyLimitBurstFactorKey: string,
+      //args
+      queueName: string,
+      messageId: string,
+      messageData: string,
+      messageScore: string,
+      ckWildcardName: string,
+      messageKeyValue: string,
+      defaultEnvConcurrencyLimit: string,
+      defaultEnvConcurrencyBurstFactor: string,
+      currentTime: string,
+      enableFastPath: string,
+      callback?: Callback<number>
+    ): Result<number, Context>;
+
+    enqueueMessageWithTtlCk(
+      //keys
+      masterQueueKey: string,
+      queue: string,
+      messageKey: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      ttlQueueKey: string,
+      ckIndexKey: string,
+      workerQueueKey: string,
+      queueConcurrencyLimitKey: string,
+      envConcurrencyLimitKey: string,
+      envConcurrencyLimitBurstFactorKey: string,
+      //args
+      queueName: string,
+      messageId: string,
+      messageData: string,
+      messageScore: string,
+      ttlMember: string,
+      ttlScore: string,
+      ckWildcardName: string,
+      messageKeyValue: string,
+      defaultEnvConcurrencyLimit: string,
+      defaultEnvConcurrencyBurstFactor: string,
+      currentTime: string,
+      enableFastPath: string,
+      callback?: Callback<number>
+    ): Result<number, Context>;
+
+    dequeueMessagesFromCkQueue(
+      //keys
+      ckIndexKey: string,
+      queueConcurrencyLimitKey: string,
+      envConcurrencyLimitKey: string,
+      envConcurrencyLimitBurstFactorKey: string,
+      envCurrentConcurrencyKey: string,
+      messageKeyPrefix: string,
+      envQueueKey: string,
+      masterQueueKey: string,
+      ttlQueueKey: string,
+      //args
+      ckWildcardName: string,
+      currentTime: string,
+      defaultEnvConcurrencyLimit: string,
+      defaultEnvConcurrencyBurstFactor: string,
+      keyPrefix: string,
+      maxCount: string,
+      callback?: Callback<string[]>
+    ): Result<string[], Context>;
+
+    acknowledgeMessageCk(
+      // keys
+      masterQueueKey: string,
+      messageKey: string,
+      messageQueue: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      workerQueueKey: string,
+      ckIndexKey: string,
+      // args
+      messageId: string,
+      messageQueueName: string,
+      messageKeyValue: string,
+      removeFromWorkerQueue: string,
+      ckWildcardName: string,
+      callback?: Callback<void>
+    ): Result<void, Context>;
+
+    nackMessageCk(
+      // keys
+      masterQueueKey: string,
+      messageKey: string,
+      messageQueue: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      ckIndexKey: string,
+      // args
+      messageId: string,
+      messageQueueName: string,
+      messageData: string,
+      messageScore: string,
+      ckWildcardName: string,
+      callback?: Callback<void>
+    ): Result<void, Context>;
+
+    moveToDeadLetterQueueCk(
+      // keys
+      masterQueueKey: string,
+      messageKey: string,
+      messageQueue: string,
+      queueCurrentConcurrencyKey: string,
+      envCurrentConcurrencyKey: string,
+      queueCurrentDequeuedKey: string,
+      envCurrentDequeuedKey: string,
+      envQueueKey: string,
+      deadLetterQueueKey: string,
+      ckIndexKey: string,
+      // args
+      messageId: string,
+      messageQueueName: string,
+      ckWildcardName: string,
+      callback?: Callback<void>
+    ): Result<void, Context>;
   }
 }
 
diff --git a/internal-packages/run-engine/src/run-queue/keyProducer.ts b/internal-packages/run-engine/src/run-queue/keyProducer.ts
index cff3b78af7d..a85dfc393e9 100644
--- a/internal-packages/run-engine/src/run-queue/keyProducer.ts
+++ b/internal-packages/run-engine/src/run-queue/keyProducer.ts
@@ -17,6 +17,7 @@ const constants = {
   DEAD_LETTER_QUEUE_PART: "deadLetter",
   MASTER_QUEUE_PART: "masterQueue",
   WORKER_QUEUE_PART: "workerQueue",
+  CK_INDEX_PART: "ckIndex",
 } as const;
 
 export class RunQueueFullKeyProducer implements RunQueueKeyProducer {
@@ -301,6 +302,27 @@ export class RunQueueFullKeyProducer implements RunQueueKeyProducer {
     return `*:${constants.ENV_PART}:*:queue:*:${constants.CURRENT_CONCURRENCY_PART}`;
   }
 
+  ttlQueueKeyForShard(shard: number): string {
+    return ["ttl", "shard", shard.toString()].join(":");
+  }
+
+  ckIndexKeyFromQueue(queue: string): string {
+    const baseQueue = queue.replace(/:ck:.+$/, "");
+    return `${baseQueue}:${constants.CK_INDEX_PART}`;
+  }
+
+  baseQueueKeyFromQueue(queue: string): string {
+    return queue.replace(/:ck:.+$/, "");
+  }
+
+  isCkWildcard(queue: string): boolean {
+    return queue.endsWith(":ck:*");
+  }
+
+  toCkWildcard(queue: string): string {
+    return queue.replace(/:ck:.+$/, ":ck:*");
+  }
+
   descriptorFromQueue(queue: string): QueueDescriptor {
     const parts = queue.split(":");
     return {
diff --git a/internal-packages/run-engine/src/run-queue/tests/ckIndex.test.ts b/internal-packages/run-engine/src/run-queue/tests/ckIndex.test.ts
new file mode 100644
index 00000000000..3945b455a07
--- /dev/null
+++ b/internal-packages/run-engine/src/run-queue/tests/ckIndex.test.ts
@@ -0,0 +1,521 @@
+import { assertNonNullable, redisTest } from "@internal/testcontainers";
+import { trace } from "@internal/tracing";
+import { Logger } from "@trigger.dev/core/logger";
+import { describe } from "node:test";
+import { setTimeout } from "node:timers/promises";
+import { FairQueueSelectionStrategy } from "../fairQueueSelectionStrategy.js";
+import { RunQueue } from "../index.js";
+import { RunQueueFullKeyProducer } from "../keyProducer.js";
+import { InputPayload } from "../types.js";
+import { Decimal } from "@trigger.dev/database";
+
+const testOptions = {
+  name: "rq",
+  tracer: trace.getTracer("rq"),
+  workers: 1,
+  defaultEnvConcurrency: 25,
+  logger: new Logger("RunQueue", "warn"),
+  retryOptions: {
+    maxAttempts: 5,
+    factor: 1.1,
+    minTimeoutInMs: 100,
+    maxTimeoutInMs: 1_000,
+    randomize: true,
+  },
+  keys: new RunQueueFullKeyProducer(),
+};
+
+const authenticatedEnvDev = {
+  id: "e1234",
+  type: "DEVELOPMENT" as const,
+  maximumConcurrencyLimit: 10,
+  concurrencyLimitBurstFactor: new Decimal(2.0),
+  project: { id: "p1234" },
+  organization: { id: "o1234" },
+};
+
+function createQueue(redisContainer: any) {
+  return new RunQueue({
+    ...testOptions,
+    queueSelectionStrategy: new FairQueueSelectionStrategy({
+      redis: {
+        keyPrefix: "runqueue:test:",
+        host: redisContainer.getHost(),
+        port: redisContainer.getPort(),
+      },
+      keys: testOptions.keys,
+    }),
+    redis: {
+      keyPrefix: "runqueue:test:",
+      host: redisContainer.getHost(),
+      port: redisContainer.getPort(),
+    },
+  });
+}
+
+function makeMessage(overrides: Partial<InputPayload> = {}): InputPayload {
+  return {
+    runId: "r1",
+    taskIdentifier: "task/my-task",
+    orgId: "o1234",
+    projectId: "p1234",
+    environmentId: "e1234",
+    environmentType: "DEVELOPMENT",
+    queue: "task/my-task",
+    timestamp: Date.now(),
+    attempt: 0,
+    ...overrides,
+  };
+}
+
+vi.setConfig({ testTimeout: 60_000 });
+
+describe("CK Index", () => {
+  redisTest(
+    "enqueue with CK creates CK index entry and :ck:* master queue entry",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const msg = makeMessage({ runId: "r1", concurrencyKey: "ck-a" });
+
+        await queue.enqueueMessage({
+          env: authenticatedEnvDev,
+          message: msg,
+          workerQueue: authenticatedEnvDev.id,
+          skipDequeueProcessing: true,
+        });
+
+        // Check that the CK-specific sorted set has the message
+        const queueLength = await queue.lengthOfQueue(
+          authenticatedEnvDev,
+          msg.queue,
+          msg.concurrencyKey
+        );
+        expect(queueLength).toBe(1);
+
+        // Check master queue: should have :ck:* entry, not :ck:ck-a
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(
+          testOptions.keys.masterQueueShardForEnvironment(msg.environmentId, 2)
+        );
+        const masterMembers = await queue.redis.zrange(
+          masterQueueKey,
+          0,
+          -1,
+          "WITHSCORES"
+        );
+        // Should have exactly one member ending with :ck:*
+        const ckWildcardMembers = masterMembers.filter(
+          (m, i) => i % 2 === 0 && m.endsWith(":ck:*")
+        );
+        expect(ckWildcardMembers.length).toBe(1);
+
+        // Should NOT have :ck:ck-a member
+        const oldFormatMembers = masterMembers.filter(
+          (m, i) => i % 2 === 0 && m.endsWith(":ck:ck-a")
+        );
+        expect(oldFormatMembers.length).toBe(0);
+
+        // Check CK index has the CK queue
+        const ckIndexKey = testOptions.keys.ckIndexKeyFromQueue(
+          testOptions.keys.queueKey(authenticatedEnvDev, msg.queue, msg.concurrencyKey)
+        );
+        const ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(1);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "multiple CKs result in single master queue entry",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now();
+        const msg1 = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+        const msg2 = makeMessage({
+          runId: "r2",
+          concurrencyKey: "ck-b",
+          timestamp: now + 100,
+        });
+        const msg3 = makeMessage({
+          runId: "r3",
+          concurrencyKey: "ck-c",
+          timestamp: now + 200,
+        });
+
+        for (const msg of [msg1, msg2, msg3]) {
+          await queue.enqueueMessage({
+            env: authenticatedEnvDev,
+            message: msg,
+            workerQueue: authenticatedEnvDev.id,
+            skipDequeueProcessing: true,
+          });
+        }
+
+        // Master queue should have exactly ONE entry (the :ck:* wildcard)
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(
+          testOptions.keys.masterQueueShardForEnvironment(msg1.environmentId, 2)
+        );
+        const masterMembers = await queue.redis.zrange(
+          masterQueueKey,
+          0,
+          -1
+        );
+        // Filter to only members for our queue
+        const ourMembers = masterMembers.filter((m) =>
+          m.includes("queue:task/my-task")
+        );
+        expect(ourMembers.length).toBe(1);
+        expect(ourMembers[0]).toContain(":ck:*");
+
+        // CK index should have 3 entries
+        const ckIndexKey = testOptions.keys.ckIndexKeyFromQueue(
+          testOptions.keys.queueKey(authenticatedEnvDev, msg1.queue, msg1.concurrencyKey)
+        );
+        const ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(3);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "dequeue from CK queue distributes across sub-queues",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000; // In the past so they're ready
+        const msg1 = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+        const msg2 = makeMessage({
+          runId: "r2",
+          concurrencyKey: "ck-b",
+          timestamp: now + 1,
+        });
+        const msg3 = makeMessage({
+          runId: "r3",
+          concurrencyKey: "ck-a",
+          timestamp: now + 2,
+        });
+
+        for (const msg of [msg1, msg2, msg3]) {
+          await queue.enqueueMessage({
+            env: authenticatedEnvDev,
+            message: msg,
+            workerQueue: authenticatedEnvDev.id,
+            skipDequeueProcessing: true,
+          });
+        }
+
+        // Dequeue via the master queue consumer
+        const shard = testOptions.keys.masterQueueShardForEnvironment(
+          msg1.environmentId,
+          2
+        );
+        const messages = await queue.testDequeueFromMasterQueue(shard, msg1.environmentId, 10);
+
+        // Should dequeue messages from both CK sub-queues
+        expect(messages).toBeDefined();
+        // We should get at least 2 messages (one from each CK)
+        // The exact order depends on CK index scoring
+        expect(messages!.length).toBeGreaterThanOrEqual(2);
+
+        const dequeuedRunIds = messages!.map((m: any) => m.messageId);
+        // r1 (ck-a, oldest) and r2 (ck-b) should be dequeued
+        expect(dequeuedRunIds).toContain("r1");
+        expect(dequeuedRunIds).toContain("r2");
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "empty CK sub-queue is removed from CK index",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000;
+        const msg1 = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+        const msg2 = makeMessage({
+          runId: "r2",
+          concurrencyKey: "ck-b",
+          timestamp: now + 1,
+        });
+
+        for (const msg of [msg1, msg2]) {
+          await queue.enqueueMessage({
+            env: authenticatedEnvDev,
+            message: msg,
+            workerQueue: authenticatedEnvDev.id,
+            skipDequeueProcessing: true,
+          });
+        }
+
+        // CK index should have 2 entries initially
+        const ckIndexKey = testOptions.keys.ckIndexKeyFromQueue(
+          testOptions.keys.queueKey(authenticatedEnvDev, msg1.queue, msg1.concurrencyKey)
+        );
+        let ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(2);
+
+        // Dequeue both messages
+        const shard = testOptions.keys.masterQueueShardForEnvironment(
+          msg1.environmentId,
+          2
+        );
+        await queue.testDequeueFromMasterQueue(shard, msg1.environmentId, 10);
+
+        // CK index should be empty (both sub-queues drained)
+        ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(0);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "empty CK index removes :ck:* from master queue",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000;
+        const msg = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+
+        await queue.enqueueMessage({
+          env: authenticatedEnvDev,
+          message: msg,
+          workerQueue: authenticatedEnvDev.id,
+          skipDequeueProcessing: true,
+        });
+
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(
+          testOptions.keys.masterQueueShardForEnvironment(msg.environmentId, 2)
+        );
+
+        // Master queue should have :ck:* entry
+        let masterMembers = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers.length).toBe(1);
+
+        // Dequeue the message
+        const shard = testOptions.keys.masterQueueShardForEnvironment(
+          msg.environmentId,
+          2
+        );
+        await queue.testDequeueFromMasterQueue(shard, msg.environmentId, 10);
+
+        // Master queue should be empty
+        masterMembers = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers.length).toBe(0);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "mixed CK and non-CK queues in same shard",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000;
+
+        // Non-CK message
+        const msgNoCk = makeMessage({
+          runId: "r-no-ck",
+          timestamp: now,
+        });
+
+        // CK messages
+        const msgCk1 = makeMessage({
+          runId: "r-ck-1",
+          concurrencyKey: "ck-a",
+          timestamp: now + 1,
+        });
+        const msgCk2 = makeMessage({
+          runId: "r-ck-2",
+          concurrencyKey: "ck-b",
+          timestamp: now + 2,
+        });
+
+        for (const msg of [msgNoCk, msgCk1, msgCk2]) {
+          await queue.enqueueMessage({
+            env: authenticatedEnvDev,
+            message: msg,
+            workerQueue: authenticatedEnvDev.id,
+            skipDequeueProcessing: true,
+          });
+        }
+
+        // Master queue should have 2 entries: one non-CK queue and one :ck:*
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(
+          testOptions.keys.masterQueueShardForEnvironment(msgNoCk.environmentId, 2)
+        );
+        const masterMembers = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers.length).toBe(2);
+
+        // One should be the non-CK queue, one should be :ck:*
+        const ckWildcard = masterMembers.filter((m) => m.endsWith(":ck:*"));
+        const nonCk = masterMembers.filter(
+          (m) => !m.includes(":ck:")
+        );
+        expect(ckWildcard.length).toBe(1);
+        expect(nonCk.length).toBe(1);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "acknowledge CK message rebalances CK index and master queue",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000;
+        const msg1 = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+        const msg2 = makeMessage({
+          runId: "r2",
+          concurrencyKey: "ck-a",
+          timestamp: now + 100,
+        });
+
+        for (const msg of [msg1, msg2]) {
+          await queue.enqueueMessage({
+            env: authenticatedEnvDev,
+            message: msg,
+            workerQueue: authenticatedEnvDev.id,
+            skipDequeueProcessing: true,
+          });
+        }
+
+        // Dequeue one message
+        const shard = testOptions.keys.masterQueueShardForEnvironment(
+          msg1.environmentId,
+          2
+        );
+        const messages = await queue.testDequeueFromMasterQueue(shard, msg1.environmentId, 1);
+        expect(messages!.length).toBe(1);
+        expect(messages![0].messageId).toBe("r1");
+
+        // Acknowledge the dequeued message
+        await queue.acknowledgeMessage(msg1.orgId, "r1", {
+          skipDequeueProcessing: true,
+        });
+
+        // CK index should still have the ck-a entry (r2 is still queued)
+        const ckIndexKey = testOptions.keys.ckIndexKeyFromQueue(
+          testOptions.keys.queueKey(authenticatedEnvDev, msg1.queue, msg1.concurrencyKey)
+        );
+        const ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(1);
+
+        // Master queue should still have the :ck:* entry
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(shard);
+        const masterMembers = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers.length).toBe(1);
+        expect(masterMembers[0]).toContain(":ck:*");
+
+        // Dequeue and ack the last message
+        const messages2 = await queue.testDequeueFromMasterQueue(shard, msg1.environmentId, 1);
+        expect(messages2!.length).toBe(1);
+        await queue.acknowledgeMessage(msg2.orgId, "r2", {
+          skipDequeueProcessing: true,
+        });
+
+        // CK index should be empty
+        const ckIndexMembers2 = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers2.length).toBe(0);
+
+        // Master queue should be empty
+        const masterMembers2 = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers2.length).toBe(0);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+
+  redisTest(
+    "nack CK message rebalances CK index",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        const now = Date.now() - 1000;
+        const msg = makeMessage({
+          runId: "r1",
+          concurrencyKey: "ck-a",
+          timestamp: now,
+        });
+
+        await queue.enqueueMessage({
+          env: authenticatedEnvDev,
+          message: msg,
+          workerQueue: authenticatedEnvDev.id,
+          skipDequeueProcessing: true,
+        });
+
+        // Dequeue the message
+        const shard = testOptions.keys.masterQueueShardForEnvironment(
+          msg.environmentId,
+          2
+        );
+        const messages = await queue.testDequeueFromMasterQueue(shard, msg.environmentId, 1);
+        expect(messages!.length).toBe(1);
+
+        // Nack the message (re-enqueue)
+        await queue.nackMessage({
+          orgId: msg.orgId,
+          messageId: "r1",
+          retryAt: Date.now() + 5000,
+          incrementAttemptCount: false,
+          skipDequeueProcessing: true,
+        });
+
+        // CK index should have the ck-a entry (message re-enqueued)
+        const ckIndexKey = testOptions.keys.ckIndexKeyFromQueue(
+          testOptions.keys.queueKey(authenticatedEnvDev, msg.queue, msg.concurrencyKey)
+        );
+        const ckIndexMembers = await queue.redis.zrange(ckIndexKey, 0, -1);
+        expect(ckIndexMembers.length).toBe(1);
+
+        // Master queue should have the :ck:* entry
+        const masterQueueKey = testOptions.keys.masterQueueKeyForShard(shard);
+        const masterMembers = await queue.redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers.length).toBe(1);
+        expect(masterMembers[0]).toContain(":ck:*");
+
+        // No old-format entries
+        const oldFormatMembers = masterMembers.filter(
+          (m) => m.includes(":ck:") && !m.endsWith(":ck:*")
+        );
+        expect(oldFormatMembers.length).toBe(0);
+      } finally {
+        await queue.quit();
+      }
+    }
+  );
+});
diff --git a/internal-packages/run-engine/src/run-queue/tests/enqueueMessage.test.ts b/internal-packages/run-engine/src/run-queue/tests/enqueueMessage.test.ts
index bf4ed87f295..8ce2d68d5de 100644
--- a/internal-packages/run-engine/src/run-queue/tests/enqueueMessage.test.ts
+++ b/internal-packages/run-engine/src/run-queue/tests/enqueueMessage.test.ts
@@ -1,7 +1,7 @@
 import { assertNonNullable, redisTest } from "@internal/testcontainers";
 import { trace } from "@internal/tracing";
 import { Logger } from "@trigger.dev/core/logger";
-import { describe } from "node:test";
+import { describe } from "vitest";
 import { setTimeout } from "node:timers/promises";
 import { FairQueueSelectionStrategy } from "../fairQueueSelectionStrategy.js";
 import { RunQueue } from "../index.js";
@@ -39,7 +39,7 @@ const messageDev: InputPayload = {
   taskIdentifier: "task/my-task",
   orgId: "o1234",
   projectId: "p1234",
-  environmentId: "e4321",
+  environmentId: "e1234",
   environmentType: "DEVELOPMENT",
   queue: "task/my-task",
   timestamp: Date.now(),
@@ -48,24 +48,28 @@ const messageDev: InputPayload = {
 
 vi.setConfig({ testTimeout: 60_000 });
 
-describe("RunQueue.enqueueMessage", () => {
-  redisTest("should add the message to the queue", async ({ redisContainer }) => {
-    const queue = new RunQueue({
-      ...testOptions,
-      queueSelectionStrategy: new FairQueueSelectionStrategy({
-        redis: {
-          keyPrefix: "runqueue:test:",
-          host: redisContainer.getHost(),
-          port: redisContainer.getPort(),
-        },
-        keys: testOptions.keys,
-      }),
+function createQueue(redisContainer: { getHost: () => string; getPort: () => number }, prefix = "runqueue:test:") {
+  return new RunQueue({
+    ...testOptions,
+    queueSelectionStrategy: new FairQueueSelectionStrategy({
       redis: {
-        keyPrefix: "runqueue:test:",
+        keyPrefix: prefix,
         host: redisContainer.getHost(),
         port: redisContainer.getPort(),
       },
-    });
+      keys: testOptions.keys,
+    }),
+    redis: {
+      keyPrefix: prefix,
+      host: redisContainer.getHost(),
+      port: redisContainer.getPort(),
+    },
+  });
+}
+
+describe("RunQueue.enqueueMessage", () => {
+  redisTest("should add the message to the queue", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer);
 
     try {
       //initial queue length
@@ -127,3 +131,326 @@ describe("RunQueue.enqueueMessage", () => {
     }
   });
 });
+
+describe("RunQueue.enqueueMessage fast path", () => {
+  redisTest("should fast-path to worker queue when queue is empty and concurrency available", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp1:");
+
+    try {
+      // Set concurrency limits
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      // Enqueue with fast path enabled
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: messageDev,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
+
+      // Queue sorted set should be empty (fast path skips it)
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength).toBe(0);
+
+      // Queue concurrency should be claimed (operational concurrency)
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(1);
+
+      // Message should be directly in worker queue - dequeue it
+      const dequeued = await queue.dequeueMessageFromWorkerQueue(
+        "test_12345",
+        authenticatedEnvDev.id,
+        { blockingPop: false }
+      );
+      assertNonNullable(dequeued);
+      expect(dequeued.messageId).toEqual(messageDev.runId);
+      expect(dequeued.message.version).toEqual("2");
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("should take slow path when enableFastPath is false", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp2:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: messageDev,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: false,
+      });
+
+      // Message should be in the queue sorted set (slow path)
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength).toBe(1);
+
+      // No concurrency claimed yet
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(0);
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("should take slow path when queue has available messages", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp3:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      // Enqueue a first message (slow path to populate the queue)
+      const message1: InputPayload = {
+        ...messageDev,
+        runId: "r1111",
+        timestamp: Date.now() - 1000, // in the past, so it's "available"
+      };
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: message1,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: false,
+      });
+
+      // Now enqueue a second message with fast path
+      const message2: InputPayload = {
+        ...messageDev,
+        runId: "r2222",
+        timestamp: Date.now(),
+      };
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: message2,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
+
+      // Both messages should be in the queue sorted set (slow path for both)
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength).toBe(2);
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("should fast-path when queue only has future-scored messages", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp4:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      // Enqueue a message with a future timestamp (simulating a nacked retry)
+      const futureMessage: InputPayload = {
+        ...messageDev,
+        runId: "r_future",
+        timestamp: Date.now() + 60_000, // 60 seconds in the future
+      };
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: futureMessage,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: false,
+      });
+
+      // Queue has 1 message but it's not available (future score)
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength).toBe(1);
+
+      // Now enqueue a new message with fast path
+      const newMessage: InputPayload = {
+        ...messageDev,
+        runId: "r_new",
+        timestamp: Date.now(),
+      };
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: newMessage,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
+
+      // The future message stays in queue, new message went to worker queue
+      const queueLength2 = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength2).toBe(1); // Only the future message
+
+      // Queue concurrency claimed for the fast-pathed message
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(1);
+
+      // Can dequeue the fast-pathed message from worker queue
+      const dequeued = await queue.dequeueMessageFromWorkerQueue(
+        "test_12345",
+        authenticatedEnvDev.id,
+        { blockingPop: false }
+      );
+      assertNonNullable(dequeued);
+      expect(dequeued.messageId).toEqual("r_new");
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("should take slow path when env concurrency is full", async ({ redisContainer }) => {
+    // Use a low concurrency limit
+    const lowConcurrencyEnv = {
+      ...authenticatedEnvDev,
+      maximumConcurrencyLimit: 1,
+      concurrencyLimitBurstFactor: new Decimal(1.0),
+    };
+
+    const queue = createQueue(redisContainer, "runqueue:fp5:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(lowConcurrencyEnv);
+
+      // First message takes fast path
+      const message1: InputPayload = {
+        ...messageDev,
+        runId: "r_first",
+        timestamp: Date.now(),
+      };
+      await queue.enqueueMessage({
+        env: lowConcurrencyEnv,
+        message: message1,
+        workerQueue: lowConcurrencyEnv.id,
+        enableFastPath: true,
+      });
+
+      // Queue concurrency is now 1 (fast path claimed it)
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        lowConcurrencyEnv,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(1);
+
+      // Second message should take slow path (env concurrency full)
+      const message2: InputPayload = {
+        ...messageDev,
+        runId: "r_second",
+        timestamp: Date.now(),
+      };
+      await queue.enqueueMessage({
+        env: lowConcurrencyEnv,
+        message: message2,
+        workerQueue: lowConcurrencyEnv.id,
+        enableFastPath: true,
+      });
+
+      // Second message should be in queue sorted set
+      const queueLength = await queue.lengthOfQueue(lowConcurrencyEnv, messageDev.queue);
+      expect(queueLength).toBe(1);
+
+      // Queue concurrency unchanged (still 1 from first message)
+      const queueConcurrency2 = await queue.currentConcurrencyOfQueue(
+        lowConcurrencyEnv,
+        messageDev.queue
+      );
+      expect(queueConcurrency2).toBe(1);
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("fast-path message can be acknowledged correctly", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp6:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: messageDev,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
+
+      // Verify fast path was taken
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(1);
+
+      // Dequeue from worker queue
+      const dequeued = await queue.dequeueMessageFromWorkerQueue(
+        "test_12345",
+        authenticatedEnvDev.id,
+        { blockingPop: false }
+      );
+      assertNonNullable(dequeued);
+
+      // Acknowledge the message
+      await queue.acknowledgeMessage(messageDev.orgId, dequeued.messageId);
+
+      // Queue concurrency should be released
+      const queueConcurrencyAfter = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrencyAfter).toBe(0);
+    } finally {
+      await queue.quit();
+    }
+  });
+
+  redisTest("fast-path message can be nacked and re-enqueued", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp7:");
+
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: messageDev,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
+
+      // Verify fast path was taken
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrency).toBe(1);
+
+      // Dequeue from worker queue
+      const dequeued = await queue.dequeueMessageFromWorkerQueue(
+        "test_12345",
+        authenticatedEnvDev.id,
+        { blockingPop: false }
+      );
+      assertNonNullable(dequeued);
+
+      // Nack the message (re-enqueue it)
+      await queue.nackMessage({
+        orgId: messageDev.orgId,
+        messageId: dequeued.messageId,
+        retryAt: Date.now() + 1000,
+      });
+
+      // Queue concurrency should be released
+      const queueConcurrencyAfter = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        messageDev.queue
+      );
+      expect(queueConcurrencyAfter).toBe(0);
+
+      // Message should now be in the queue sorted set
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, messageDev.queue);
+      expect(queueLength).toBe(1);
+    } finally {
+      await queue.quit();
+    }
+  });
+});
diff --git a/internal-packages/run-engine/src/run-queue/tests/keyProducer.test.ts b/internal-packages/run-engine/src/run-queue/tests/keyProducer.test.ts
index 8b980749eab..0f65b020885 100644
--- a/internal-packages/run-engine/src/run-queue/tests/keyProducer.test.ts
+++ b/internal-packages/run-engine/src/run-queue/tests/keyProducer.test.ts
@@ -359,4 +359,73 @@ describe("KeyProducer", () => {
       concurrencyKey: "c1234",
     });
   });
+
+  it("ckIndexKeyFromQueue", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    const queueKey = keyProducer.queueKey(
+      {
+        id: "e1234",
+        type: "PRODUCTION",
+        project: { id: "p1234" },
+        organization: { id: "o1234" },
+      },
+      "task/task-name",
+      "c1234"
+    );
+    const key = keyProducer.ckIndexKeyFromQueue(queueKey);
+    expect(key).toBe("{org:o1234}:proj:p1234:env:e1234:queue:task/task-name:ckIndex");
+  });
+
+  it("ckIndexKeyFromQueue (from wildcard)", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    const key = keyProducer.ckIndexKeyFromQueue(
+      "{org:o1234}:proj:p1234:env:e1234:queue:task/task-name:ck:*"
+    );
+    expect(key).toBe("{org:o1234}:proj:p1234:env:e1234:queue:task/task-name:ckIndex");
+  });
+
+  it("baseQueueKeyFromQueue (with CK)", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    const queueKey = keyProducer.queueKey(
+      {
+        id: "e1234",
+        type: "PRODUCTION",
+        project: { id: "p1234" },
+        organization: { id: "o1234" },
+      },
+      "task/task-name",
+      "c1234"
+    );
+    const key = keyProducer.baseQueueKeyFromQueue(queueKey);
+    expect(key).toBe("{org:o1234}:proj:p1234:env:e1234:queue:task/task-name");
+  });
+
+  it("baseQueueKeyFromQueue (no CK)", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    const queueKey = keyProducer.queueKey(
+      {
+        id: "e1234",
+        type: "PRODUCTION",
+        project: { id: "p1234" },
+        organization: { id: "o1234" },
+      },
+      "task/task-name"
+    );
+    const key = keyProducer.baseQueueKeyFromQueue(queueKey);
+    expect(key).toBe("{org:o1234}:proj:p1234:env:e1234:queue:task/task-name");
+  });
+
+  it("isCkWildcard", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    expect(keyProducer.isCkWildcard("{org:o1234}:proj:p1234:env:e1234:queue:task/foo:ck:*")).toBe(true);
+    expect(keyProducer.isCkWildcard("{org:o1234}:proj:p1234:env:e1234:queue:task/foo:ck:bar")).toBe(false);
+    expect(keyProducer.isCkWildcard("{org:o1234}:proj:p1234:env:e1234:queue:task/foo")).toBe(false);
+  });
+
+  it("toCkWildcard", () => {
+    const keyProducer = new RunQueueFullKeyProducer();
+    expect(keyProducer.toCkWildcard("{org:o1234}:proj:p1234:env:e1234:queue:task/foo:ck:bar")).toBe(
+      "{org:o1234}:proj:p1234:env:e1234:queue:task/foo:ck:*"
+    );
+  });
 });
diff --git a/internal-packages/run-engine/src/run-queue/types.ts b/internal-packages/run-engine/src/run-queue/types.ts
index ee1ce41b79e..1f16ccfa57a 100644
--- a/internal-packages/run-engine/src/run-queue/types.ts
+++ b/internal-packages/run-engine/src/run-queue/types.ts
@@ -13,6 +13,8 @@ export const InputPayload = z.object({
   concurrencyKey: z.string().optional(),
   timestamp: z.number(),
   attempt: z.number(),
+  /** TTL expiration timestamp (unix ms). If set, run will be expired when this time is reached. */
+  ttlExpiresAt: z.number().optional(),
 });
 export type InputPayload = z.infer<typeof InputPayload>;
 
@@ -120,6 +122,15 @@ export interface RunQueueKeyProducer {
   // Concurrency sweeper methods
   markedForAckKey(): string;
   currentConcurrencySetKeyScanPattern(): string;
+
+  // TTL system methods
+  ttlQueueKeyForShard(shard: number): string;
+
+  // CK index methods
+  ckIndexKeyFromQueue(queue: string): string;
+  baseQueueKeyFromQueue(queue: string): string;
+  isCkWildcard(queue: string): boolean;
+  toCkWildcard(queue: string): string;
 }
 
 export type EnvQueues = {
diff --git a/internal-packages/schedule-engine/src/engine/index.ts b/internal-packages/schedule-engine/src/engine/index.ts
index 47dc1e31e19..4eb641176b2 100644
--- a/internal-packages/schedule-engine/src/engine/index.ts
+++ b/internal-packages/schedule-engine/src/engine/index.ts
@@ -497,17 +497,28 @@ export class ScheduleEngine {
 
               span.setAttribute("trigger_success", true);
             } else {
-              this.logger.error("Failed to trigger scheduled task", {
-                instanceId: params.instanceId,
-                taskIdentifier: instance.taskSchedule.taskIdentifier,
-                durationMs: triggerDuration,
-                error: result.error,
-              });
+              const isQueueLimit = result.errorType === "QUEUE_LIMIT";
+
+              if (isQueueLimit) {
+                this.logger.warn("Scheduled task trigger skipped due to queue limit", {
+                  instanceId: params.instanceId,
+                  taskIdentifier: instance.taskSchedule.taskIdentifier,
+                  durationMs: triggerDuration,
+                  error: result.error,
+                });
+              } else {
+                this.logger.error("Failed to trigger scheduled task", {
+                  instanceId: params.instanceId,
+                  taskIdentifier: instance.taskSchedule.taskIdentifier,
+                  durationMs: triggerDuration,
+                  error: result.error,
+                });
+              }
 
               this.scheduleExecutionFailureCounter.add(1, {
                 environment_type: environmentType,
                 schedule_type: scheduleType,
-                error_type: "task_failure",
+                error_type: isQueueLimit ? "queue_limit" : "task_failure",
               });
 
               span.setAttribute("trigger_success", false);
diff --git a/internal-packages/schedule-engine/src/engine/types.ts b/internal-packages/schedule-engine/src/engine/types.ts
index 8cad80c3033..f4888c447ae 100644
--- a/internal-packages/schedule-engine/src/engine/types.ts
+++ b/internal-packages/schedule-engine/src/engine/types.ts
@@ -24,8 +24,14 @@ export type TriggerScheduledTaskParams = {
   exactScheduleTime?: Date;
 };
 
+export type TriggerScheduledTaskErrorType = "QUEUE_LIMIT" | "SYSTEM_ERROR";
+
 export interface TriggerScheduledTaskCallback {
-  (params: TriggerScheduledTaskParams): Promise<{ success: boolean; error?: string }>;
+  (params: TriggerScheduledTaskParams): Promise<{
+    success: boolean;
+    error?: string;
+    errorType?: TriggerScheduledTaskErrorType;
+  }>;
 }
 
 export interface ScheduleEngineOptions {
diff --git a/internal-packages/schedule-engine/src/index.ts b/internal-packages/schedule-engine/src/index.ts
index 22f6c07b30c..6c96f2cd54b 100644
--- a/internal-packages/schedule-engine/src/index.ts
+++ b/internal-packages/schedule-engine/src/index.ts
@@ -3,4 +3,5 @@ export type {
   ScheduleEngineOptions,
   TriggerScheduleParams,
   TriggerScheduledTaskCallback,
+  TriggerScheduledTaskErrorType,
 } from "./engine/types.js";
diff --git a/internal-packages/schedule-engine/test/scheduleEngine.test.ts b/internal-packages/schedule-engine/test/scheduleEngine.test.ts
index fdc05e25747..99bac0936df 100644
--- a/internal-packages/schedule-engine/test/scheduleEngine.test.ts
+++ b/internal-packages/schedule-engine/test/scheduleEngine.test.ts
@@ -93,6 +93,7 @@ describe("ScheduleEngine Integration", () => {
           data: {
             taskScheduleId: taskSchedule.id,
             environmentId: environment.id,
+            projectId: project.id,
             active: true,
           },
         });
diff --git a/internal-packages/schedule-engine/test/scheduleRecovery.test.ts b/internal-packages/schedule-engine/test/scheduleRecovery.test.ts
index 9ad345101ec..99a3351aed7 100644
--- a/internal-packages/schedule-engine/test/scheduleRecovery.test.ts
+++ b/internal-packages/schedule-engine/test/scheduleRecovery.test.ts
@@ -79,6 +79,7 @@ describe("Schedule Recovery", () => {
           data: {
             taskScheduleId: taskSchedule.id,
             environmentId: environment.id,
+            projectId: project.id,
             active: true,
           },
         });
@@ -184,6 +185,7 @@ describe("Schedule Recovery", () => {
           data: {
             taskScheduleId: taskSchedule.id,
             environmentId: environment.id,
+            projectId: project.id,
             active: true,
           },
         });
@@ -293,6 +295,7 @@ describe("Schedule Recovery", () => {
             data: {
               taskScheduleId: taskSchedule.id,
               environmentId: environment.id,
+              projectId: project.id,
               active: true,
             },
           });
diff --git a/internal-packages/sdk-compat-tests/package.json b/internal-packages/sdk-compat-tests/package.json
new file mode 100644
index 00000000000..e903e69f3f1
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@internal/sdk-compat-tests",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "test": "vitest",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@trigger.dev/sdk": "workspace:*"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0",
+    "execa": "^9.3.0",
+    "typescript": "^5.5.0",
+    "vitest": "3.1.4"
+  }
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/bun/package.json b/internal-packages/sdk-compat-tests/src/fixtures/bun/package.json
new file mode 100644
index 00000000000..c69e2dd23e3
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/bun/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "bun-fixture",
+  "private": true,
+  "type": "module"
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/bun/test.ts b/internal-packages/sdk-compat-tests/src/fixtures/bun/test.ts
new file mode 100644
index 00000000000..853869304f4
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/bun/test.ts
@@ -0,0 +1,62 @@
+/**
+ * Bun Import Test Fixture
+ *
+ * Tests that the SDK works correctly with Bun runtime.
+ * Bun has high Node.js compatibility but uses its own module resolver.
+ */
+
+import { task, logger, schedules, runs, configure, queue, retry, wait } from "@trigger.dev/sdk";
+
+// Validate exports exist
+const checks: [string, boolean][] = [
+  ["task", typeof task === "function"],
+  ["logger", typeof logger === "object" && typeof logger.info === "function"],
+  ["schedules", typeof schedules === "object"],
+  ["runs", typeof runs === "object"],
+  ["configure", typeof configure === "function"],
+  ["queue", typeof queue === "function"],
+  ["retry", typeof retry === "object"],
+  ["wait", typeof wait === "object"],
+];
+
+let failed = false;
+for (const [name, passed] of checks) {
+  if (!passed) {
+    console.error(`FAIL: ${name} export check failed`);
+    failed = true;
+  }
+}
+
+// Test task definition with types
+interface Payload {
+  message: string;
+}
+
+const myTask = task({
+  id: "bun-test-task",
+  run: async (payload: Payload) => {
+    return { received: payload.message };
+  },
+});
+
+if (myTask.id !== "bun-test-task") {
+  console.error(`FAIL: task.id mismatch`);
+  failed = true;
+}
+
+// Test queue definition
+const myQueue = queue({
+  name: "bun-test-queue",
+  concurrencyLimit: 5,
+});
+
+if (!myQueue) {
+  console.error(`FAIL: queue creation failed`);
+  failed = true;
+}
+
+if (failed) {
+  process.exit(1);
+}
+
+console.log("SUCCESS: Bun imports validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/package.json b/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/package.json
new file mode 100644
index 00000000000..953ed7d2db7
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "cjs-require-fixture",
+  "private": true
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/test.cjs b/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/test.cjs
new file mode 100644
index 00000000000..447d03970aa
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/cjs-require/test.cjs
@@ -0,0 +1,57 @@
+/**
+ * CJS Require Test Fixture
+ *
+ * This file validates that the SDK can be required using CommonJS syntax.
+ * This is critical for:
+ * - Node.js < 22.12.0 (where require(ESM) is not enabled by default)
+ * - AWS Lambda (intentionally disables require(ESM))
+ * - Legacy Node.js applications
+ */
+
+// Test main export
+const sdk = require("@trigger.dev/sdk");
+
+// Test /v3 subpath
+const sdkV3 = require("@trigger.dev/sdk/v3");
+
+// Validate exports exist
+const checks = [
+  ["task", typeof sdk.task === "function"],
+  ["taskV3", typeof sdkV3.task === "function"],
+  ["logger", typeof sdk.logger === "object" && typeof sdk.logger.info === "function"],
+  ["schedules", typeof sdk.schedules === "object"],
+  ["runs", typeof sdk.runs === "object"],
+  ["configure", typeof sdk.configure === "function"],
+  ["queue", typeof sdk.queue === "function"],
+  ["retry", typeof sdk.retry === "object"],
+  ["wait", typeof sdk.wait === "object"],
+  ["metadata", typeof sdk.metadata === "object"],
+  ["tags", typeof sdk.tags === "object"],
+];
+
+let failed = false;
+for (const [name, passed] of checks) {
+  if (!passed) {
+    console.error(`FAIL: ${name} export check failed`);
+    failed = true;
+  }
+}
+
+// Test task definition works
+const myTask = sdk.task({
+  id: "cjs-test-task",
+  run: async (payload) => {
+    return { received: payload };
+  },
+});
+
+if (myTask.id !== "cjs-test-task") {
+  console.error(`FAIL: task.id mismatch: expected "cjs-test-task", got "${myTask.id}"`);
+  failed = true;
+}
+
+if (failed) {
+  process.exit(1);
+}
+
+console.log("SUCCESS: All CJS requires validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/package.json b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/package.json
new file mode 100644
index 00000000000..d9fca987c33
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "cloudflare-worker-fixture",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "wrangler deploy --dry-run --outdir dist"
+  },
+  "devDependencies": {
+    "wrangler": "^3.0.0"
+  }
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/src/index.ts b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/src/index.ts
new file mode 100644
index 00000000000..30b5fcc79ef
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/src/index.ts
@@ -0,0 +1,41 @@
+/**
+ * Cloudflare Worker Test Fixture
+ *
+ * Tests that the SDK can be bundled for Cloudflare Workers (workerd runtime).
+ * This validates the bundling process works - actual execution would require
+ * a Trigger.dev API connection.
+ */
+
+import { task, runs, configure } from "@trigger.dev/sdk";
+
+// Define a task (won't execute in worker, but validates import)
+const myTask = task({
+  id: "cloudflare-test-task",
+  run: async (payload: { message: string }) => {
+    return { received: payload.message };
+  },
+});
+
+export default {
+  async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
+    // Validate SDK imports work
+    const checks = {
+      taskDefined: typeof task === "function",
+      runsDefined: typeof runs === "object",
+      configureDefined: typeof configure === "function",
+      taskIdCorrect: myTask.id === "cloudflare-test-task",
+    };
+
+    const allPassed = Object.values(checks).every((v) => v === true);
+
+    return new Response(
+      JSON.stringify({
+        success: allPassed,
+        checks,
+      }),
+      {
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  },
+};
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/wrangler.toml b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/wrangler.toml
new file mode 100644
index 00000000000..f038e47bb6f
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/cloudflare-worker/wrangler.toml
@@ -0,0 +1,4 @@
+name = "sdk-compat-test"
+main = "src/index.ts"
+compatibility_date = "2024-01-01"
+compatibility_flags = ["nodejs_compat"]
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/deno/deno.json b/internal-packages/sdk-compat-tests/src/fixtures/deno/deno.json
new file mode 100644
index 00000000000..4525b34d3e2
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/deno/deno.json
@@ -0,0 +1,6 @@
+{
+  "tasks": {
+    "test": "deno run --allow-read --allow-env --allow-sys test.ts"
+  },
+  "nodeModulesDir": "manual"
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/deno/test.ts b/internal-packages/sdk-compat-tests/src/fixtures/deno/test.ts
new file mode 100644
index 00000000000..6894606fd0a
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/deno/test.ts
@@ -0,0 +1,65 @@
+/**
+ * Deno Import Test Fixture
+ *
+ * Tests that the SDK can be imported in Deno using Node.js compatibility.
+ * The CI workflow installs the SDK into node_modules via npm for local resolution.
+ */
+
+// Use bare specifier - resolved via node_modules when nodeModulesDir is enabled
+import { task, logger, schedules, runs, configure, queue, retry, wait, metadata, tags } from "@trigger.dev/sdk";
+
+// Validate exports exist
+const checks: [string, boolean][] = [
+  ["task", typeof task === "function"],
+  ["logger", typeof logger === "object" && typeof logger.info === "function"],
+  ["schedules", typeof schedules === "object"],
+  ["runs", typeof runs === "object"],
+  ["configure", typeof configure === "function"],
+  ["queue", typeof queue === "function"],
+  ["retry", typeof retry === "object"],
+  ["wait", typeof wait === "object"],
+  ["metadata", typeof metadata === "object"],
+  ["tags", typeof tags === "object"],
+];
+
+let failed = false;
+for (const [name, passed] of checks) {
+  if (!passed) {
+    console.error(`FAIL: ${name} export check failed`);
+    failed = true;
+  }
+}
+
+// Test task definition with types
+interface Payload {
+  message: string;
+}
+
+const myTask = task({
+  id: "deno-test-task",
+  run: async (payload: Payload) => {
+    return { received: payload.message };
+  },
+});
+
+if (myTask.id !== "deno-test-task") {
+  console.error(`FAIL: task.id mismatch`);
+  failed = true;
+}
+
+// Test queue definition
+const myQueue = queue({
+  name: "deno-test-queue",
+  concurrencyLimit: 5,
+});
+
+if (!myQueue) {
+  console.error(`FAIL: queue creation failed`);
+  failed = true;
+}
+
+if (failed) {
+  Deno.exit(1);
+}
+
+console.log("SUCCESS: Deno imports validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/esm-import/package.json b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/package.json
new file mode 100644
index 00000000000..c0d56cd02fa
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "esm-import-fixture",
+  "private": true,
+  "type": "module"
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/esm-import/superjson-test.mjs b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/superjson-test.mjs
new file mode 100644
index 00000000000..fc034de19e0
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/superjson-test.mjs
@@ -0,0 +1,59 @@
+/**
+ * SuperJSON Serialization Test
+ *
+ * This validates the fix for #2937 - ESM/CJS compatibility with superjson.
+ * Tests that complex types (Date, Set, Map, BigInt) serialize correctly.
+ */
+
+import { task, logger } from "@trigger.dev/sdk";
+
+// The SDK uses superjson internally for serialization
+// This test ensures the vendored superjson works correctly
+
+const complexData = {
+  date: new Date("2024-01-15T12:00:00Z"),
+  set: new Set([1, 2, 3]),
+  map: new Map([
+    ["key1", "value1"],
+    ["key2", "value2"],
+  ]),
+  bigint: BigInt("9007199254740991"),
+  nested: {
+    innerDate: new Date("2024-06-01"),
+    innerSet: new Set(["a", "b"]),
+  },
+};
+
+// Create a task that uses complex types
+const complexTask = task({
+  id: "superjson-test-task",
+  run: async (payload) => {
+    // Just verify the payload structure matches expectations
+    return {
+      hasDate: payload.date instanceof Date,
+      hasSet: payload.set instanceof Set,
+      hasMap: payload.map instanceof Map,
+      hasBigInt: typeof payload.bigint === "bigint",
+      hasNestedDate: payload.nested?.innerDate instanceof Date,
+    };
+  },
+});
+
+// Verify task was created successfully
+if (!complexTask.id) {
+  console.error("FAIL: Task creation failed");
+  process.exit(1);
+}
+
+// Test that logger works (it uses superjson for structured logging)
+try {
+  logger.info("Testing superjson serialization", {
+    complexData,
+    timestamp: new Date(),
+  });
+} catch (error) {
+  console.error("FAIL: Logger with complex data failed:", error);
+  process.exit(1);
+}
+
+console.log("SUCCESS: SuperJSON serialization validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/esm-import/test.mjs b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/test.mjs
new file mode 100644
index 00000000000..70b055aaa2f
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/esm-import/test.mjs
@@ -0,0 +1,54 @@
+/**
+ * ESM Import Test Fixture
+ *
+ * This file validates that the SDK can be imported using ESM syntax.
+ * It tests all major export paths and verifies runtime functionality.
+ */
+
+// Test main export
+import { task, logger, schedules, runs, configure, queue, retry, wait, metadata, tags } from "@trigger.dev/sdk";
+
+// Test /v3 subpath (legacy, but should still work)
+import { task as taskV3 } from "@trigger.dev/sdk/v3";
+
+// Validate exports are functions/objects
+const checks = [
+  ["task", typeof task === "function"],
+  ["taskV3", typeof taskV3 === "function"],
+  ["logger", typeof logger === "object" && typeof logger.info === "function"],
+  ["schedules", typeof schedules === "object"],
+  ["runs", typeof runs === "object"],
+  ["configure", typeof configure === "function"],
+  ["queue", typeof queue === "function"],
+  ["retry", typeof retry === "object"],
+  ["wait", typeof wait === "object"],
+  ["metadata", typeof metadata === "object"],
+  ["tags", typeof tags === "object"],
+];
+
+let failed = false;
+for (const [name, passed] of checks) {
+  if (!passed) {
+    console.error(`FAIL: ${name} export check failed`);
+    failed = true;
+  }
+}
+
+// Test task definition works
+const myTask = task({
+  id: "esm-test-task",
+  run: async (payload) => {
+    return { received: payload };
+  },
+});
+
+if (myTask.id !== "esm-test-task") {
+  console.error(`FAIL: task.id mismatch: expected "esm-test-task", got "${myTask.id}"`);
+  failed = true;
+}
+
+if (failed) {
+  process.exit(1);
+}
+
+console.log("SUCCESS: All ESM imports validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/typescript/package.json b/internal-packages/sdk-compat-tests/src/fixtures/typescript/package.json
new file mode 100644
index 00000000000..7663bc7aca3
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/typescript/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "typescript-fixture",
+  "private": true,
+  "type": "module"
+}
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/typescript/test.ts b/internal-packages/sdk-compat-tests/src/fixtures/typescript/test.ts
new file mode 100644
index 00000000000..bfcb4892abe
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/typescript/test.ts
@@ -0,0 +1,74 @@
+/**
+ * TypeScript Import Test Fixture
+ *
+ * This file validates that the SDK types work correctly with TypeScript.
+ * It tests type inference, generics, and type-only imports.
+ */
+
+import {
+  task,
+  logger,
+  schedules,
+  runs,
+  configure,
+  queue,
+  retry,
+  wait,
+  metadata,
+  tags,
+  type Context,
+  type RetryOptions,
+} from "@trigger.dev/sdk";
+
+// Type-only import test
+import type { ApiClientConfiguration } from "@trigger.dev/sdk";
+
+// Test typed task with payload
+interface MyPayload {
+  message: string;
+  count: number;
+}
+
+interface MyOutput {
+  processed: boolean;
+  result: string;
+}
+
+const typedTask = task({
+  id: "typescript-test-task",
+  run: async (payload: MyPayload, { ctx }): Promise<MyOutput> => {
+    // Verify context type
+    const runId: string = ctx.run.id;
+
+    return {
+      processed: true,
+      result: `Processed ${payload.message} with count ${payload.count}`,
+    };
+  },
+});
+
+// Verify task type inference
+type TaskPayload = Parameters<typeof typedTask.trigger>[0];
+type _PayloadCheck = TaskPayload extends MyPayload ? true : never;
+
+// Test queue definition
+const myQueue = queue({
+  name: "test-queue",
+  concurrencyLimit: 10,
+});
+
+// Test retry options type
+const retryOpts: RetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1000,
+  maxTimeoutInMs: 30000,
+};
+
+// Validate runtime
+if (typedTask.id !== "typescript-test-task") {
+  console.error(`FAIL: task.id mismatch`);
+  process.exit(1);
+}
+
+console.log("SUCCESS: TypeScript types validated");
diff --git a/internal-packages/sdk-compat-tests/src/fixtures/typescript/tsconfig.json b/internal-packages/sdk-compat-tests/src/fixtures/typescript/tsconfig.json
new file mode 100644
index 00000000000..432fff32ade
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/fixtures/typescript/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["test.ts"]
+}
diff --git a/internal-packages/sdk-compat-tests/src/tests/bundler.test.ts b/internal-packages/sdk-compat-tests/src/tests/bundler.test.ts
new file mode 100644
index 00000000000..e3e18c49f37
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/tests/bundler.test.ts
@@ -0,0 +1,117 @@
+/**
+ * Bundler Compatibility Tests
+ *
+ * These tests validate that the SDK can be bundled correctly using
+ * common bundlers like esbuild.
+ */
+
+import { describe, it, expect } from "vitest";
+import * as esbuild from "esbuild";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturesDir = resolve(__dirname, "../fixtures");
+
+describe("esbuild Bundling Tests", () => {
+  it("should bundle ESM entrypoint without errors", async () => {
+    const result = await esbuild.build({
+      entryPoints: [resolve(fixturesDir, "esm-import/test.mjs")],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node18",
+      write: false,
+      external: ["@trigger.dev/sdk", "@trigger.dev/sdk/*"],
+      logLevel: "silent",
+    });
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.outputFiles).toHaveLength(1);
+  });
+
+  it("should bundle CJS entrypoint without errors", async () => {
+    const result = await esbuild.build({
+      entryPoints: [resolve(fixturesDir, "cjs-require/test.cjs")],
+      bundle: true,
+      format: "cjs",
+      platform: "node",
+      target: "node18",
+      write: false,
+      external: ["@trigger.dev/sdk", "@trigger.dev/sdk/*"],
+      logLevel: "silent",
+    });
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.outputFiles).toHaveLength(1);
+  });
+
+  it("should bundle SDK inline (simulating production build)", async () => {
+    // This simulates what happens when a user bundles their app with the SDK included
+    const entryContent = `
+      import { task, logger } from "@trigger.dev/sdk";
+
+      export const myTask = task({
+        id: "bundled-task",
+        run: async (payload) => {
+          logger.info("Processing", { payload });
+          return { success: true };
+        },
+      });
+    `;
+
+    const result = await esbuild.build({
+      stdin: {
+        contents: entryContent,
+        loader: "ts",
+        resolveDir: resolve(__dirname, "../../"),
+      },
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node18",
+      write: false,
+      // Don't externalize SDK - bundle it inline
+      logLevel: "silent",
+      metafile: true,
+    });
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.outputFiles).toHaveLength(1);
+
+    // Verify the bundle contains the SDK code
+    const bundleContent = result.outputFiles[0].text;
+    expect(bundleContent).toBeTruthy();
+    expect(bundleContent.length).toBeGreaterThan(1000); // Should be substantial
+  });
+
+  it("should handle tree-shaking correctly", async () => {
+    // Import only specific functions to test tree-shaking
+    const entryContent = `
+      import { task } from "@trigger.dev/sdk";
+
+      export const myTask = task({
+        id: "tree-shake-task",
+        run: async () => ({ done: true }),
+      });
+    `;
+
+    const result = await esbuild.build({
+      stdin: {
+        contents: entryContent,
+        loader: "ts",
+        resolveDir: resolve(__dirname, "../../"),
+      },
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node18",
+      write: false,
+      treeShaking: true,
+      logLevel: "silent",
+    });
+
+    expect(result.errors).toHaveLength(0);
+    expect(result.outputFiles).toHaveLength(1);
+  });
+});
diff --git a/internal-packages/sdk-compat-tests/src/tests/import.test.ts b/internal-packages/sdk-compat-tests/src/tests/import.test.ts
new file mode 100644
index 00000000000..7d81ccce259
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/src/tests/import.test.ts
@@ -0,0 +1,84 @@
+/**
+ * Import Validation Tests
+ *
+ * These tests validate that the SDK can be imported correctly across
+ * different module systems (ESM and CJS).
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { execa, type Options as ExecaOptions } from "execa";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturesDir = resolve(__dirname, "../fixtures");
+
+// Find the SDK package in the monorepo
+const sdkDir = resolve(__dirname, "../../../../packages/trigger-sdk");
+
+// Common execa options
+const execaOpts: ExecaOptions = {
+  env: {
+    ...process.env,
+    // Ensure Node.js can resolve workspace packages
+    NODE_PATH: resolve(__dirname, "../../../../node_modules"),
+  },
+  timeout: 30_000,
+};
+
+describe("ESM Import Tests", () => {
+  it("should import SDK using ESM syntax", async () => {
+    const result = await execa("node", ["test.mjs"], {
+      ...execaOpts,
+      cwd: resolve(fixturesDir, "esm-import"),
+    });
+
+    expect(result.stdout).toContain("SUCCESS");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("should validate superjson serialization in ESM", async () => {
+    const result = await execa("node", ["superjson-test.mjs"], {
+      ...execaOpts,
+      cwd: resolve(fixturesDir, "esm-import"),
+    });
+
+    expect(result.stdout).toContain("SUCCESS");
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+describe("CJS Require Tests", () => {
+  it("should require SDK using CommonJS syntax", async () => {
+    const result = await execa("node", ["test.cjs"], {
+      ...execaOpts,
+      cwd: resolve(fixturesDir, "cjs-require"),
+    });
+
+    expect(result.stdout).toContain("SUCCESS");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("should work with --experimental-require-module flag on older Node", async () => {
+    // This flag is needed for Node < 22.12.0 to require ESM modules
+    // On newer Node.js, it's a no-op
+    const result = await execa("node", ["--experimental-require-module", "test.cjs"], {
+      ...execaOpts,
+      cwd: resolve(fixturesDir, "cjs-require"),
+    });
+
+    expect(result.stdout).toContain("SUCCESS");
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+describe("TypeScript Compilation Tests", () => {
+  it("should typecheck SDK imports successfully", async () => {
+    const result = await execa("npx", ["tsc", "--noEmit"], {
+      ...execaOpts,
+      cwd: resolve(fixturesDir, "typescript"),
+    });
+
+    expect(result.exitCode).toBe(0);
+  });
+});
diff --git a/internal-packages/sdk-compat-tests/tsconfig.json b/internal-packages/sdk-compat-tests/tsconfig.json
new file mode 100644
index 00000000000..05afb6f355a
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": false,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/fixtures"]
+}
diff --git a/internal-packages/sdk-compat-tests/vitest.config.ts b/internal-packages/sdk-compat-tests/vitest.config.ts
new file mode 100644
index 00000000000..2617dd10185
--- /dev/null
+++ b/internal-packages/sdk-compat-tests/vitest.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/tests/**/*.test.ts"],
+    globals: true,
+    isolate: true,
+    testTimeout: 120_000, // Some framework builds can take time
+    hookTimeout: 60_000,
+  },
+});
diff --git a/internal-packages/testcontainers/src/index.ts b/internal-packages/testcontainers/src/index.ts
index cae66dcbd80..e9c8067de4c 100644
--- a/internal-packages/testcontainers/src/index.ts
+++ b/internal-packages/testcontainers/src/index.ts
@@ -9,15 +9,18 @@ import {
   createElectricContainer,
   createPostgresContainer,
   createRedisContainer,
+  createMinIOContainer,
   useContainer,
   withContainerSetup,
 } from "./utils";
 import { getTaskMetadata, logCleanup, logSetup } from "./logs";
 import { StartedClickHouseContainer } from "./clickhouse";
+import { StartedMinIOContainer, type MinIOConnectionConfig } from "./minio";
 import { ClickHouseClient, createClient } from "@clickhouse/client";
 
 export { assertNonNullable } from "./utils";
 export { logCleanup };
+export type { MinIOConnectionConfig };
 
 type NetworkContext = { network: StartedNetwork };
 
@@ -40,11 +43,17 @@ export type PostgresAndRedisContext = NetworkContext & PostgresContext & RedisCo
 export type ContainerWithElectricAndRedisContext = ContainerContext & ElectricContext;
 export type ContainerWithElectricContext = NetworkContext & PostgresContext & ElectricContext;
 
+type MinIOContext = NetworkContext & {
+  minioContainer: StartedMinIOContainer;
+  minioConfig: MinIOConnectionConfig;
+};
+
 export type {
   StartedNetwork,
   StartedPostgreSqlContainer,
   StartedRedisContainer,
   StartedClickHouseContainer,
+  StartedMinIOContainer,
 };
 
 type Use<T> = (value: T) => Promise<void>;
@@ -257,3 +266,39 @@ export const containerWithElectricAndRedisTest = test.extend<ContainerWithElectr
   clickhouseContainer,
   clickhouseClient,
 });
+
+const minioContainer = async (
+  { network, task }: { network: StartedNetwork } & TaskContext,
+  use: Use<StartedMinIOContainer>
+) => {
+  const { container, metadata } = await withContainerSetup({
+    name: "minioContainer",
+    task,
+    setup: createMinIOContainer(network),
+  });
+
+  await useContainer("minioContainer", { container, task, use: () => use(container) });
+};
+
+const minioConfig = async (
+  { minioContainer }: { minioContainer: StartedMinIOContainer },
+  use: Use<MinIOConnectionConfig>
+) => {
+  await use(minioContainer.getConnectionConfig());
+};
+
+export const minioTest = test.extend<MinIOContext>({
+  network,
+  minioContainer,
+  minioConfig,
+});
+
+type PostgresAndMinIOContext = NetworkContext & PostgresContext & MinIOContext;
+
+export const postgresAndMinioTest = test.extend<PostgresAndMinIOContext>({
+  network,
+  postgresContainer,
+  prisma,
+  minioContainer,
+  minioConfig,
+});
diff --git a/internal-packages/testcontainers/src/minio.ts b/internal-packages/testcontainers/src/minio.ts
new file mode 100644
index 00000000000..4f85149b7a4
--- /dev/null
+++ b/internal-packages/testcontainers/src/minio.ts
@@ -0,0 +1,134 @@
+import {
+  AbstractStartedContainer,
+  GenericContainer,
+  StartedTestContainer,
+  Wait,
+} from "testcontainers";
+import { x } from "tinyexec";
+
+const MINIO_PORT = 9000;
+
+export type MinIOConnectionConfig = {
+  baseUrl: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  region: string;
+};
+
+export class MinIOContainer extends GenericContainer {
+  private accessKeyId = "minioadmin";
+  private secretAccessKey = "minioadmin";
+  private region = "us-east-1";
+
+  constructor(image = "minio/minio:latest") {
+    super(image);
+    this.withExposedPorts(MINIO_PORT);
+    this.withCommand(["server", "/data"]);
+    this.withWaitStrategy(Wait.forLogMessage(/API:/));
+    this.withStartupTimeout(120_000);
+  }
+
+  public withAccessKeyId(accessKeyId: string): this {
+    this.accessKeyId = accessKeyId;
+    return this;
+  }
+
+  public withSecretAccessKey(secretAccessKey: string): this {
+    this.secretAccessKey = secretAccessKey;
+    return this;
+  }
+
+  public withRegion(region: string): this {
+    this.region = region;
+    return this;
+  }
+
+  public override async start(): Promise<StartedMinIOContainer> {
+    this.withEnvironment({
+      MINIO_ROOT_USER: this.accessKeyId,
+      MINIO_ROOT_PASSWORD: this.secretAccessKey,
+    });
+
+    const startedContainer = await super.start();
+
+    // Create the "packets" bucket using MinIO client
+    await x(
+      "docker",
+      [
+        "exec",
+        startedContainer.getId(),
+        "mc",
+        "alias",
+        "set",
+        "local",
+        "http://localhost:9000",
+        this.accessKeyId,
+        this.secretAccessKey,
+      ],
+      { throwOnError: true }
+    );
+
+    await x(
+      "docker",
+      ["exec", startedContainer.getId(), "mc", "mb", "local/packets"],
+      { throwOnError: true }
+    );
+
+    return new StartedMinIOContainer(
+      startedContainer,
+      this.accessKeyId,
+      this.secretAccessKey,
+      this.region
+    );
+  }
+}
+
+export class StartedMinIOContainer extends AbstractStartedContainer {
+  constructor(
+    startedTestContainer: StartedTestContainer,
+    private readonly accessKeyId: string,
+    private readonly secretAccessKey: string,
+    private readonly region: string
+  ) {
+    super(startedTestContainer);
+  }
+
+  public getPort(): number {
+    return super.getMappedPort(MINIO_PORT);
+  }
+
+  public getAccessKeyId(): string {
+    return this.accessKeyId;
+  }
+
+  public getSecretAccessKey(): string {
+    return this.secretAccessKey;
+  }
+
+  public getRegion(): string {
+    return this.region;
+  }
+
+  /**
+   * Gets the base URL (protocol, host and mapped port) for the MinIO container.
+   * Example: `http://localhost:32768`
+   */
+  public getBaseUrl(): string {
+    const protocol = "http";
+    const host = this.getHost();
+    const port = this.getPort();
+    return `${protocol}://${host}:${port}`;
+  }
+
+  /**
+   * Gets connection configuration suitable for object storage clients.
+   */
+  public getConnectionConfig(): MinIOConnectionConfig {
+    return {
+      baseUrl: this.getBaseUrl(),
+      accessKeyId: this.getAccessKeyId(),
+      secretAccessKey: this.getSecretAccessKey(),
+      region: this.getRegion(),
+    };
+  }
+}
diff --git a/internal-packages/testcontainers/src/utils.ts b/internal-packages/testcontainers/src/utils.ts
index 11bedef1fdd..ea344e63f65 100644
--- a/internal-packages/testcontainers/src/utils.ts
+++ b/internal-packages/testcontainers/src/utils.ts
@@ -9,6 +9,7 @@ import { GenericContainer, StartedNetwork, StartedTestContainer, Wait } from "te
 import { x } from "tinyexec";
 import { expect, TaskContext } from "vitest";
 import { ClickHouseContainer, runClickhouseMigrations } from "./clickhouse";
+import { MinIOContainer } from "./minio";
 import { getContainerMetadata, getTaskMetadata, logCleanup, logSetup } from "./logs";
 
 export async function createPostgresContainer(network: StartedNetwork) {
@@ -170,6 +171,18 @@ export async function createElectricContainer(
   };
 }
 
+export async function createMinIOContainer(network: StartedNetwork) {
+  const container = await new MinIOContainer()
+    .withNetwork(network)
+    .withNetworkAliases("minio")
+    .start();
+
+  return {
+    container,
+    network,
+  };
+}
+
 export function assertNonNullable<T>(value: T): asserts value is NonNullable<T> {
   expect(value).toBeDefined();
   expect(value).not.toBeNull();
diff --git a/internal-packages/tracing/src/index.ts b/internal-packages/tracing/src/index.ts
index 8d01bdaed5c..d6795091886 100644
--- a/internal-packages/tracing/src/index.ts
+++ b/internal-packages/tracing/src/index.ts
@@ -25,7 +25,16 @@ export type {
   ObservableResult,
 } from "@opentelemetry/api";
 
-import { trace, context, propagation, SpanKind, metrics, ValueType } from "@opentelemetry/api";
+import {
+  trace,
+  context,
+  propagation,
+  SpanKind,
+  metrics,
+  ValueType,
+  ROOT_CONTEXT,
+} from "@opentelemetry/api";
+import type { Context } from "@opentelemetry/api";
 export {
   trace,
   context,
@@ -36,6 +45,8 @@ export {
   SpanStatusCode,
   metrics,
   ValueType,
+  ROOT_CONTEXT,
+  type Context,
 };
 
 export function getTracer(name: string): Tracer {
diff --git a/internal-packages/tsql/.gitignore b/internal-packages/tsql/.gitignore
new file mode 100644
index 00000000000..05262c5eda7
--- /dev/null
+++ b/internal-packages/tsql/.gitignore
@@ -0,0 +1,3 @@
+# ANTLR intermediate build files
+src/grammar/.antlr/
+
diff --git a/internal-packages/tsql/NOTICE.md b/internal-packages/tsql/NOTICE.md
new file mode 100644
index 00000000000..efb4563d7b8
--- /dev/null
+++ b/internal-packages/tsql/NOTICE.md
@@ -0,0 +1,22 @@
+Portions of this package are derived from PostHog (MIT License).
+Copyright (c) 2020-2025 PostHog Inc.
+
+The original license is reproduced below:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/internal-packages/tsql/README.md b/internal-packages/tsql/README.md
new file mode 100644
index 00000000000..2e4992c6cb2
--- /dev/null
+++ b/internal-packages/tsql/README.md
@@ -0,0 +1,19 @@
+# TSQL (TriggerSQL)
+
+TriggerSQL is a DSL that is safely converted into ClickHouse SQL queries with protection against SQL injection and it's tenant-safe (users can only query their own data).
+
+## Attribution
+
+This package is derived from [PostHog's HogQL](https://github.com/PostHog/posthog/tree/master/posthog/hogql) (MIT License). See [NOTICE.md](./NOTICE.md) for the full copyright notice.
+
+## ANTLR Grammar
+
+The ANTLR grammar is heavily inspired by PostHog's HogQL.
+
+These are found in [./src/grammar](./src/grammar) and are the `.g4` files.
+
+## Generating the source code
+
+```sh
+pnpm run grammar:build
+```
diff --git a/internal-packages/tsql/package.json b/internal-packages/tsql/package.json
new file mode 100644
index 00000000000..0cac36e7b27
--- /dev/null
+++ b/internal-packages/tsql/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "@internal/tsql",
+  "private": true,
+  "version": "0.0.1",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "type": "module",
+  "dependencies": {
+    "@trigger.dev/core": "workspace:*",
+    "antlr4ts": "0.5.0-alpha.4",
+    "zod": "3.25.76"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "grammar:build": "pnpm grammar:build:typescript",
+    "grammar:build:typescript": "cat src/grammar/TSQLLexer.typescript.g4 > src/grammar/TSQLLexer.g4 && tail -n +2 src/grammar/TSQLLexer.common.g4 |sed s/isOpeningTag/self.isOpeningTag/ >> src/grammar/TSQLLexer.g4 && antlr4ts src/grammar/TSQLLexer.g4 && rm src/grammar/TSQLLexer.g4 && antlr4ts -visitor -no-listener -Dlanguage=TypeScript src/grammar/TSQLParser.g4",
+    "test": "vitest --sequence.concurrent=false --no-file-parallelism",
+    "test:coverage": "vitest --sequence.concurrent=false --no-file-parallelism --coverage.enabled"
+  },
+  "devDependencies": {
+    "antlr4ts-cli": "0.5.0-alpha.4"
+  }
+}
diff --git a/internal-packages/tsql/src/grammar/TSQLLexer.common.g4 b/internal-packages/tsql/src/grammar/TSQLLexer.common.g4
new file mode 100644
index 00000000000..7988b54eba5
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLLexer.common.g4
@@ -0,0 +1,288 @@
+lexer grammar TSQLLexer;
+
+// NB! We cat TSQLLexter.typescript.g4 when generating the grammar.
+
+// NOTE: don't forget to add new keywords to the parser rule "keyword"!
+
+// Keywords
+
+ALL: A L L;
+AND: A N D;
+ANTI: A N T I;
+ANY: A N Y;
+ARRAY: A R R A Y;
+AS: A S;
+ASCENDING: A S C | A S C E N D I N G;
+ASOF: A S O F;
+BETWEEN: B E T W E E N;
+BOTH: B O T H;
+BY: B Y;
+CASE: C A S E;
+CAST: C A S T;
+CATCH: C A T C H;
+COHORT: C O H O R T;
+COLLATE: C O L L A T E;
+CROSS: C R O S S;
+CUBE: C U B E;
+CURRENT: C U R R E N T;
+DATE: D A T E;
+DAY: D A Y;
+DESC: D E S C;
+DESCENDING: D E S C E N D I N G;
+DISTINCT: D I S T I N C T;
+ELSE: E L S E;
+END: E N D;
+EXCEPT: E X C E P T;
+EXTRACT: E X T R A C T;
+FINAL: F I N A L;
+FINALLY: F I N A L L Y;
+FIRST: F I R S T;
+FN: F N;
+FOLLOWING: F O L L O W I N G;
+FOR: F O R;
+FROM: F R O M;
+FULL: F U L L;
+FUN: F U N;
+GROUP: G R O U P;
+HAVING: H A V I N G;
+HOUR: H O U R;
+ID: I D;
+IF: I F;
+ILIKE: I L I K E;
+IN: I N;
+INF: I N F | I N F I N I T Y;
+INNER: I N N E R;
+INTERSECT: I N T E R S E C T;
+INTERVAL: I N T E R V A L;
+IS: I S;
+JOIN: J O I N;
+KEY: K E Y;
+LAST: L A S T;
+LEADING: L E A D I N G;
+LEFT: L E F T;
+LET: L E T;
+LIKE: L I K E;
+LIMIT: L I M I T;
+MINUTE: M I N U T E;
+MONTH: M O N T H;
+NAN_SQL: N A N; // conflicts with macro NAN
+NOT: N O T;
+NULL_SQL: N U L L; // conflicts with macro NULL
+NULLS: N U L L S;
+OFFSET: O F F S E T;
+ON: O N;
+OR: O R;
+ORDER: O R D E R;
+OUTER: O U T E R;
+OVER: O V E R;
+PARTITION: P A R T I T I O N;
+PRECEDING: P R E C E D I N G;
+PREWHERE: P R E W H E R E;
+QUARTER: Q U A R T E R;
+RANGE: R A N G E;
+RETURN: R E T U R N;
+RIGHT: R I G H T;
+ROLLUP: R O L L U P;
+ROW: R O W;
+ROWS: R O W S;
+SAMPLE: S A M P L E;
+SECOND: S E C O N D;
+SELECT: S E L E C T;
+SEMI: S E M I;
+SETTINGS: S E T T I N G S;
+SUBSTRING: S U B S T R I N G;
+THEN: T H E N;
+THROW: T H R O W;
+TIES: T I E S;
+TIMESTAMP: T I M E S T A M P;
+TO: T O;
+TOP: T O P;
+TOTALS: T O T A L S;
+TRAILING: T R A I L I N G;
+TRIM: T R I M;
+TRUNCATE: T R U N C A T E;
+TRY: T R Y;
+UNBOUNDED: U N B O U N D E D;
+UNION: U N I O N;
+USING: U S I N G;
+WEEK: W E E K;
+WHEN: W H E N;
+WHERE: W H E R E;
+WHILE: W H I L E;
+WINDOW: W I N D O W;
+WITH: W I T H;
+YEAR: Y E A R | Y Y Y Y;
+
+// Tokens
+
+// copied from clickhouse_driver/util/escape.py
+ESCAPE_CHAR_COMMON
+    : BACKSLASH B
+    | BACKSLASH F
+    | BACKSLASH R
+    | BACKSLASH N
+    | BACKSLASH T
+    | BACKSLASH '0'
+    | BACKSLASH A
+    | BACKSLASH V
+    | BACKSLASH BACKSLASH;
+
+IDENTIFIER
+    : (LETTER | UNDERSCORE | DOLLAR) (LETTER | UNDERSCORE | DEC_DIGIT | DOLLAR)*
+    | BACKQUOTE ( ~([\\`]) | ESCAPE_CHAR_COMMON | BACKSLASH QUOTE_SINGLE | (BACKQUOTE BACKQUOTE) )* BACKQUOTE
+    | QUOTE_DOUBLE ( ~([\\"]) | ESCAPE_CHAR_COMMON | BACKSLASH QUOTE_DOUBLE | (QUOTE_DOUBLE QUOTE_DOUBLE) )* QUOTE_DOUBLE
+    ;
+FLOATING_LITERAL
+    : HEXADECIMAL_LITERAL DOT HEX_DIGIT* (P | E) (PLUS | DASH)? DEC_DIGIT+
+    | HEXADECIMAL_LITERAL (P | E) (PLUS | DASH)? DEC_DIGIT+
+    | DECIMAL_LITERAL DOT DEC_DIGIT* E (PLUS | DASH)? DEC_DIGIT+
+    | DOT DECIMAL_LITERAL E (PLUS | DASH)? DEC_DIGIT+
+    | DECIMAL_LITERAL E (PLUS | DASH)? DEC_DIGIT+
+    ;
+OCTAL_LITERAL: '0' OCT_DIGIT+;
+DECIMAL_LITERAL: DEC_DIGIT+;
+HEXADECIMAL_LITERAL: '0' X HEX_DIGIT+;
+
+// It's important that quote-symbol is a single character.
+STRING_LITERAL: QUOTE_SINGLE ( ~([\\']) | ESCAPE_CHAR_COMMON | BACKSLASH QUOTE_SINGLE | (QUOTE_SINGLE QUOTE_SINGLE) )* QUOTE_SINGLE;
+
+
+// Alphabet and allowed symbols
+
+fragment A: [aA];
+fragment B: [bB];
+fragment C: [cC];
+fragment D: [dD];
+fragment E: [eE];
+fragment F: [fF];
+fragment G: [gG];
+fragment H: [hH];
+fragment I: [iI];
+fragment J: [jJ];
+fragment K: [kK];
+fragment L: [lL];
+fragment M: [mM];
+fragment N: [nN];
+fragment O: [oO];
+fragment P: [pP];
+fragment Q: [qQ];
+fragment R: [rR];
+fragment S: [sS];
+fragment T: [tT];
+fragment U: [uU];
+fragment V: [vV];
+fragment W: [wW];
+fragment X: [xX];
+fragment Y: [yY];
+fragment Z: [zZ];
+
+fragment LETTER: [a-zA-Z];
+fragment OCT_DIGIT: [0-7];
+fragment DEC_DIGIT: [0-9];
+fragment HEX_DIGIT: [0-9a-fA-F];
+
+ARROW: '->';
+ASTERISK: '*';
+BACKQUOTE: '`';
+BACKSLASH: '\\';
+COLON: ':';
+COMMA: ',';
+CONCAT: '||';
+DASH: '-';
+DOLLAR: '$';
+DOT: '.';
+EQ_DOUBLE: '==';
+EQ_SINGLE: '=';
+GT_EQ: '>=';
+GT: '>';
+HASH: '#';
+IREGEX_SINGLE: '~*';
+IREGEX_DOUBLE: '=~*';
+LBRACE: '{' -> pushMode(DEFAULT_MODE);
+LBRACKET: '[';
+LPAREN: '(';
+LT_EQ: '<=';
+TAG_LT_SLASH: '</' -> type(LT_SLASH), pushMode(TSQLX_TAG_CLOSE);
+TAG_LT_OPEN: '<' {isOpeningTag()}? -> type(LT), pushMode(TSQLX_TAG_OPEN);
+LT: '<';
+LT_SLASH: '</';
+NOT_EQ: '!=' | '<>';
+NOT_IREGEX: '!~*';
+NOT_REGEX: '!~';
+NULL_PROPERTY: '?.';
+NULLISH: '??';
+PERCENT: '%';
+PLUS: '+';
+QUERY: '?';
+QUOTE_DOUBLE: '"';
+QUOTE_SINGLE_TEMPLATE: 'f\'' -> pushMode(IN_TEMPLATE_STRING); // start of regular f'' template strings
+QUOTE_SINGLE_TEMPLATE_FULL: 'F\'' -> pushMode(IN_FULL_TEMPLATE_STRING); // magic F' symbol used to parse "full text" templates
+QUOTE_SINGLE: '\'';
+REGEX_SINGLE: '~';
+REGEX_DOUBLE: '=~';
+RBRACE: '}' -> popMode;
+RBRACKET: ']';
+RPAREN: ')';
+SEMICOLON: ';';
+SLASH: '/';
+SLASH_GT: '/>';
+UNDERSCORE: '_';
+
+// Comments and whitespace
+MULTI_LINE_COMMENT: '/*' .*? '*/' -> skip;
+SINGLE_LINE_COMMENT: ('--' | '//') ~('\n'|'\r')* ('\n' | '\r' | EOF) -> skip;
+// whitespace is hidden and not skipped so that it's preserved in ANTLR errors like "no viable alternative"
+WHITESPACE: [ \u000B\u000C\t\r\n] -> channel(HIDDEN);
+
+// ───────── f' TEMPLATE STRING MODE ─────────
+mode IN_TEMPLATE_STRING;
+STRING_TEXT: ((~([\\'{])) | ESCAPE_CHAR_COMMON | BACKSLASH QUOTE_SINGLE | (BACKSLASH LBRACE) | (QUOTE_SINGLE QUOTE_SINGLE))+;
+STRING_ESCAPE_TRIGGER: LBRACE -> pushMode(DEFAULT_MODE);
+STRING_QUOTE_SINGLE: QUOTE_SINGLE -> type(QUOTE_SINGLE), popMode;
+
+// ───────── F' FULL TEMPLATE STRING MODE ─────────
+// a magic F' takes us to "full template strings" mode, where we don't need to escape single quotes and parse until EOF
+// this can't be used within a normal columnExpr, but has to be parsed for separately
+mode IN_FULL_TEMPLATE_STRING;
+FULL_STRING_TEXT: ((~([{])) | ESCAPE_CHAR_COMMON | (BACKSLASH LBRACE))+;
+FULL_STRING_ESCAPE_TRIGGER: LBRACE -> pushMode(DEFAULT_MODE);
+
+// ───────── TSQLX TAG MODE for opening/self-closing tags ─────────
+mode TSQLX_TAG_OPEN;
+
+TAG_SELF_CLOSE_GT : '/>' -> type(SLASH_GT), popMode;   // <tag …/>
+TAG_OPEN_GT       :  '>' -> type(GT), popMode, pushMode(TSQLX_TEXT);   // <tag …>
+
+// minimal token set; map everything back to the default token types
+TAG_IDENT   : [a-zA-Z_][a-zA-Z0-9_-]* -> type(IDENTIFIER);
+TAG_EQ      : '='                     -> type(EQ_SINGLE);
+TAG_STRING  : STRING_LITERAL          -> type(STRING_LITERAL);
+TAG_WS      : [ \t\r\n]+              -> channel(HIDDEN);
+TAG_LBRACE  : '{'                     -> type(LBRACE), pushMode(DEFAULT_MODE);
+
+
+// ───────── TSQLX TAG MODE for closing tags ─────────
+mode TSQLX_TAG_CLOSE;
+
+TAGC_GT     :  '>' -> type(GT), popMode;                // *** no TEXT push ***
+TAGC_IDENT  : [a-zA-Z_][a-zA-Z0-9_-]* -> type(IDENTIFIER);
+TAGC_WS     : [ \t\r\n]+              -> channel(HIDDEN);
+
+
+// ───────── TSQLX TEXT MODE ─────────
+mode TSQLX_TEXT;
+
+TSQLX_TEXT_TEXT
+    : ~[<{]+ ; // everything except “{” or “<”
+
+TSQLX_TEXT_LBRACE
+    : '{' -> type(LBRACE), pushMode(DEFAULT_MODE);
+
+TSQLX_TEXT_LT_SLASH
+    : '</' -> type(LT_SLASH), popMode, pushMode(TSQLX_TAG_CLOSE);
+
+TSQLX_TEXT_LT
+    : '<' -> type(LT), pushMode(TSQLX_TAG_OPEN);
+
+TSQLX_TEXT_WS
+    : [ \t\r\n]+ -> channel(HIDDEN);
diff --git a/internal-packages/tsql/src/grammar/TSQLLexer.interp b/internal-packages/tsql/src/grammar/TSQLLexer.interp
new file mode 100644
index 00000000000..21517b3322f
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLLexer.interp
@@ -0,0 +1,570 @@
+token literal names:
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+'->'
+'*'
+'`'
+'\\'
+':'
+','
+'||'
+'-'
+'$'
+'.'
+'=='
+null
+'>='
+null
+'#'
+'~*'
+'=~*'
+'{'
+'['
+'('
+'<='
+'<'
+'</'
+null
+'!~*'
+'!~'
+'?.'
+'??'
+'%'
+'+'
+'?'
+'"'
+'f\''
+'F\''
+'\''
+'~'
+'=~'
+'}'
+']'
+')'
+';'
+'/'
+null
+'_'
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+ALL
+AND
+ANTI
+ANY
+ARRAY
+AS
+ASCENDING
+ASOF
+BETWEEN
+BOTH
+BY
+CASE
+CAST
+CATCH
+COHORT
+COLLATE
+CROSS
+CUBE
+CURRENT
+DATE
+DAY
+DESC
+DESCENDING
+DISTINCT
+ELSE
+END
+EXCEPT
+EXTRACT
+FINAL
+FINALLY
+FIRST
+FN
+FOLLOWING
+FOR
+FROM
+FULL
+FUN
+GROUP
+HAVING
+HOUR
+ID
+IF
+ILIKE
+IN
+INF
+INNER
+INTERSECT
+INTERVAL
+IS
+JOIN
+KEY
+LAST
+LEADING
+LEFT
+LET
+LIKE
+LIMIT
+MINUTE
+MONTH
+NAN_SQL
+NOT
+NULL_SQL
+NULLS
+OFFSET
+ON
+OR
+ORDER
+OUTER
+OVER
+PARTITION
+PRECEDING
+PREWHERE
+QUARTER
+RANGE
+RETURN
+RIGHT
+ROLLUP
+ROW
+ROWS
+SAMPLE
+SECOND
+SELECT
+SEMI
+SETTINGS
+SUBSTRING
+THEN
+THROW
+TIES
+TIMESTAMP
+TO
+TOP
+TOTALS
+TRAILING
+TRIM
+TRUNCATE
+TRY
+UNBOUNDED
+UNION
+USING
+WEEK
+WHEN
+WHERE
+WHILE
+WINDOW
+WITH
+YEAR
+ESCAPE_CHAR_COMMON
+IDENTIFIER
+FLOATING_LITERAL
+OCTAL_LITERAL
+DECIMAL_LITERAL
+HEXADECIMAL_LITERAL
+STRING_LITERAL
+ARROW
+ASTERISK
+BACKQUOTE
+BACKSLASH
+COLON
+COMMA
+CONCAT
+DASH
+DOLLAR
+DOT
+EQ_DOUBLE
+EQ_SINGLE
+GT_EQ
+GT
+HASH
+IREGEX_SINGLE
+IREGEX_DOUBLE
+LBRACE
+LBRACKET
+LPAREN
+LT_EQ
+LT
+LT_SLASH
+NOT_EQ
+NOT_IREGEX
+NOT_REGEX
+NULL_PROPERTY
+NULLISH
+PERCENT
+PLUS
+QUERY
+QUOTE_DOUBLE
+QUOTE_SINGLE_TEMPLATE
+QUOTE_SINGLE_TEMPLATE_FULL
+QUOTE_SINGLE
+REGEX_SINGLE
+REGEX_DOUBLE
+RBRACE
+RBRACKET
+RPAREN
+SEMICOLON
+SLASH
+SLASH_GT
+UNDERSCORE
+MULTI_LINE_COMMENT
+SINGLE_LINE_COMMENT
+WHITESPACE
+STRING_TEXT
+STRING_ESCAPE_TRIGGER
+FULL_STRING_TEXT
+FULL_STRING_ESCAPE_TRIGGER
+TAG_WS
+TAGC_WS
+TSQLX_TEXT_TEXT
+TSQLX_TEXT_WS
+
+rule names:
+ALL
+AND
+ANTI
+ANY
+ARRAY
+AS
+ASCENDING
+ASOF
+BETWEEN
+BOTH
+BY
+CASE
+CAST
+CATCH
+COHORT
+COLLATE
+CROSS
+CUBE
+CURRENT
+DATE
+DAY
+DESC
+DESCENDING
+DISTINCT
+ELSE
+END
+EXCEPT
+EXTRACT
+FINAL
+FINALLY
+FIRST
+FN
+FOLLOWING
+FOR
+FROM
+FULL
+FUN
+GROUP
+HAVING
+HOUR
+ID
+IF
+ILIKE
+IN
+INF
+INNER
+INTERSECT
+INTERVAL
+IS
+JOIN
+KEY
+LAST
+LEADING
+LEFT
+LET
+LIKE
+LIMIT
+MINUTE
+MONTH
+NAN_SQL
+NOT
+NULL_SQL
+NULLS
+OFFSET
+ON
+OR
+ORDER
+OUTER
+OVER
+PARTITION
+PRECEDING
+PREWHERE
+QUARTER
+RANGE
+RETURN
+RIGHT
+ROLLUP
+ROW
+ROWS
+SAMPLE
+SECOND
+SELECT
+SEMI
+SETTINGS
+SUBSTRING
+THEN
+THROW
+TIES
+TIMESTAMP
+TO
+TOP
+TOTALS
+TRAILING
+TRIM
+TRUNCATE
+TRY
+UNBOUNDED
+UNION
+USING
+WEEK
+WHEN
+WHERE
+WHILE
+WINDOW
+WITH
+YEAR
+ESCAPE_CHAR_COMMON
+IDENTIFIER
+FLOATING_LITERAL
+OCTAL_LITERAL
+DECIMAL_LITERAL
+HEXADECIMAL_LITERAL
+STRING_LITERAL
+A
+B
+C
+D
+E
+F
+G
+H
+I
+J
+K
+L
+M
+N
+O
+P
+Q
+R
+S
+T
+U
+V
+W
+X
+Y
+Z
+LETTER
+OCT_DIGIT
+DEC_DIGIT
+HEX_DIGIT
+ARROW
+ASTERISK
+BACKQUOTE
+BACKSLASH
+COLON
+COMMA
+CONCAT
+DASH
+DOLLAR
+DOT
+EQ_DOUBLE
+EQ_SINGLE
+GT_EQ
+GT
+HASH
+IREGEX_SINGLE
+IREGEX_DOUBLE
+LBRACE
+LBRACKET
+LPAREN
+LT_EQ
+TAG_LT_SLASH
+TAG_LT_OPEN
+LT
+LT_SLASH
+NOT_EQ
+NOT_IREGEX
+NOT_REGEX
+NULL_PROPERTY
+NULLISH
+PERCENT
+PLUS
+QUERY
+QUOTE_DOUBLE
+QUOTE_SINGLE_TEMPLATE
+QUOTE_SINGLE_TEMPLATE_FULL
+QUOTE_SINGLE
+REGEX_SINGLE
+REGEX_DOUBLE
+RBRACE
+RBRACKET
+RPAREN
+SEMICOLON
+SLASH
+SLASH_GT
+UNDERSCORE
+MULTI_LINE_COMMENT
+SINGLE_LINE_COMMENT
+WHITESPACE
+STRING_TEXT
+STRING_ESCAPE_TRIGGER
+STRING_QUOTE_SINGLE
+FULL_STRING_TEXT
+FULL_STRING_ESCAPE_TRIGGER
+TAG_SELF_CLOSE_GT
+TAG_OPEN_GT
+TAG_IDENT
+TAG_EQ
+TAG_STRING
+TAG_WS
+TAG_LBRACE
+TAGC_GT
+TAGC_IDENT
+TAGC_WS
+TSQLX_TEXT_TEXT
+TSQLX_TEXT_LBRACE
+TSQLX_TEXT_LT_SLASH
+TSQLX_TEXT_LT
+TSQLX_TEXT_WS
+
+channel names:
+DEFAULT_TOKEN_CHANNEL
+HIDDEN
+
+mode names:
+DEFAULT_MODE
+IN_TEMPLATE_STRING
+IN_FULL_TEMPLATE_STRING
+TSQLX_TAG_OPEN
+TSQLX_TAG_CLOSE
+TSQLX_TEXT
+
+atn:
+[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 2, 170, 1628, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 473, 10, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 5, 46, 701, 10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 1085, 10, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 1114, 10, 108, 3, 109, 3, 109, 3, 109, 5, 109, 1119, 10, 109, 3, 109, 3, 109, 3, 109, 3, 109, 7, 109, 1125, 10, 109, 12, 109, 14, 109, 1128, 11, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 7, 109, 1139, 10, 109, 12, 109, 14, 109, 1142, 11, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 7, 109, 1155, 10, 109, 12, 109, 14, 109, 1158, 11, 109, 3, 109, 3, 109, 5, 109, 1162, 10, 109, 3, 110, 3, 110, 3, 110, 7, 110, 1167, 10, 110, 12, 110, 14, 110, 1170, 11, 110, 3, 110, 3, 110, 5, 110, 1174, 10, 110, 3, 110, 3, 110, 5, 110, 1178, 10, 110, 3, 110, 6, 110, 1181, 10, 110, 13, 110, 14, 110, 1182, 3, 110, 3, 110, 3, 110, 5, 110, 1188, 10, 110, 3, 110, 3, 110, 5, 110, 1192, 10, 110, 3, 110, 6, 110, 1195, 10, 110, 13, 110, 14, 110, 1196, 3, 110, 3, 110, 3, 110, 7, 110, 1202, 10, 110, 12, 110, 14, 110, 1205, 11, 110, 3, 110, 3, 110, 3, 110, 5, 110, 1210, 10, 110, 3, 110, 6, 110, 1213, 10, 110, 13, 110, 14, 110, 1214, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 5, 110, 1222, 10, 110, 3, 110, 6, 110, 1225, 10, 110, 13, 110, 14, 110, 1226, 3, 110, 3, 110, 3, 110, 3, 110, 5, 110, 1233, 10, 110, 3, 110, 6, 110, 1236, 10, 110, 13, 110, 14, 110, 1237, 5, 110, 1240, 10, 110, 3, 111, 3, 111, 6, 111, 1244, 10, 111, 13, 111, 14, 111, 1245, 3, 112, 6, 112, 1249, 10, 112, 13, 112, 14, 112, 1250, 3, 113, 3, 113, 3, 113, 6, 113, 1256, 10, 113, 13, 113, 14, 113, 1257, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 7, 114, 1269, 10, 114, 12, 114, 14, 114, 1272, 11, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 116, 3, 116, 3, 117, 3, 117, 3, 118, 3, 118, 3, 119, 3, 119, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 3, 124, 3, 125, 3, 125, 3, 126, 3, 126, 3, 127, 3, 127, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 132, 3, 132, 3, 133, 3, 133, 3, 134, 3, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 3, 140, 3, 140, 3, 141, 3, 141, 3, 142, 3, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 153, 3, 153, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 163, 3, 163, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 1409, 10, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 176, 3, 176, 3, 177, 3, 177, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 185, 3, 185, 3, 186, 3, 186, 3, 187, 3, 187, 3, 188, 3, 188, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 3, 191, 7, 191, 1470, 10, 191, 12, 191, 14, 191, 1473, 11, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 5, 192, 1484, 10, 192, 3, 192, 7, 192, 1487, 10, 192, 12, 192, 14, 192, 1490, 11, 192, 3, 192, 5, 192, 1493, 10, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 6, 194, 1512, 10, 194, 13, 194, 14, 194, 1513, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 6, 197, 1530, 10, 197, 13, 197, 14, 197, 1531, 3, 198, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 7, 201, 1552, 10, 201, 12, 201, 14, 201, 1555, 11, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 6, 204, 1568, 10, 204, 13, 204, 14, 204, 1569, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 7, 207, 1586, 10, 207, 12, 207, 14, 207, 1589, 11, 207, 3, 207, 3, 207, 3, 208, 6, 208, 1594, 10, 208, 13, 208, 14, 208, 1595, 3, 208, 3, 208, 3, 209, 6, 209, 1601, 10, 209, 13, 209, 14, 209, 1602, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 213, 6, 213, 1623, 10, 213, 13, 213, 14, 213, 1624, 3, 213, 3, 213, 3, 1471, 2, 2, 214, 8, 2, 3, 10, 2, 4, 12, 2, 5, 14, 2, 6, 16, 2, 7, 18, 2, 8, 20, 2, 9, 22, 2, 10, 24, 2, 11, 26, 2, 12, 28, 2, 13, 30, 2, 14, 32, 2, 15, 34, 2, 16, 36, 2, 17, 38, 2, 18, 40, 2, 19, 42, 2, 20, 44, 2, 21, 46, 2, 22, 48, 2, 23, 50, 2, 24, 52, 2, 25, 54, 2, 26, 56, 2, 27, 58, 2, 28, 60, 2, 29, 62, 2, 30, 64, 2, 31, 66, 2, 32, 68, 2, 33, 70, 2, 34, 72, 2, 35, 74, 2, 36, 76, 2, 37, 78, 2, 38, 80, 2, 39, 82, 2, 40, 84, 2, 41, 86, 2, 42, 88, 2, 43, 90, 2, 44, 92, 2, 45, 94, 2, 46, 96, 2, 47, 98, 2, 48, 100, 2, 49, 102, 2, 50, 104, 2, 51, 106, 2, 52, 108, 2, 53, 110, 2, 54, 112, 2, 55, 114, 2, 56, 116, 2, 57, 118, 2, 58, 120, 2, 59, 122, 2, 60, 124, 2, 61, 126, 2, 62, 128, 2, 63, 130, 2, 64, 132, 2, 65, 134, 2, 66, 136, 2, 67, 138, 2, 68, 140, 2, 69, 142, 2, 70, 144, 2, 71, 146, 2, 72, 148, 2, 73, 150, 2, 74, 152, 2, 75, 154, 2, 76, 156, 2, 77, 158, 2, 78, 160, 2, 79, 162, 2, 80, 164, 2, 81, 166, 2, 82, 168, 2, 83, 170, 2, 84, 172, 2, 85, 174, 2, 86, 176, 2, 87, 178, 2, 88, 180, 2, 89, 182, 2, 90, 184, 2, 91, 186, 2, 92, 188, 2, 93, 190, 2, 94, 192, 2, 95, 194, 2, 96, 196, 2, 97, 198, 2, 98, 200, 2, 99, 202, 2, 100, 204, 2, 101, 206, 2, 102, 208, 2, 103, 210, 2, 104, 212, 2, 105, 214, 2, 106, 216, 2, 107, 218, 2, 108, 220, 2, 109, 222, 2, 110, 224, 2, 111, 226, 2, 112, 228, 2, 113, 230, 2, 114, 232, 2, 115, 234, 2, 2, 236, 2, 2, 238, 2, 2, 240, 2, 2, 242, 2, 2, 244, 2, 2, 246, 2, 2, 248, 2, 2, 250, 2, 2, 252, 2, 2, 254, 2, 2, 256, 2, 2, 258, 2, 2, 260, 2, 2, 262, 2, 2, 264, 2, 2, 266, 2, 2, 268, 2, 2, 270, 2, 2, 272, 2, 2, 274, 2, 2, 276, 2, 2, 278, 2, 2, 280, 2, 2, 282, 2, 2, 284, 2, 2, 286, 2, 2, 288, 2, 2, 290, 2, 2, 292, 2, 2, 294, 2, 116, 296, 2, 117, 298, 2, 118, 300, 2, 119, 302, 2, 120, 304, 2, 121, 306, 2, 122, 308, 2, 123, 310, 2, 124, 312, 2, 125, 314, 2, 126, 316, 2, 127, 318, 2, 128, 320, 2, 129, 322, 2, 130, 324, 2, 131, 326, 2, 132, 328, 2, 133, 330, 2, 134, 332, 2, 135, 334, 2, 136, 336, 2, 2, 338, 2, 2, 340, 2, 137, 342, 2, 138, 344, 2, 139, 346, 2, 140, 348, 2, 141, 350, 2, 142, 352, 2, 143, 354, 2, 144, 356, 2, 145, 358, 2, 146, 360, 2, 147, 362, 2, 148, 364, 2, 149, 366, 2, 150, 368, 2, 151, 370, 2, 152, 372, 2, 153, 374, 2, 154, 376, 2, 155, 378, 2, 156, 380, 2, 157, 382, 2, 158, 384, 2, 159, 386, 2, 160, 388, 2, 161, 390, 2, 162, 392, 2, 163, 394, 2, 164, 396, 2, 2, 398, 2, 165, 400, 2, 166, 402, 2, 2, 404, 2, 2, 406, 2, 2, 408, 2, 2, 410, 2, 2, 412, 2, 167, 414, 2, 2, 416, 2, 2, 418, 2, 2, 420, 2, 168, 422, 2, 169, 424, 2, 2, 426, 2, 2, 428, 2, 2, 430, 2, 170, 8, 2, 3, 4, 5, 6, 7, 44, 4, 2, 94, 94, 98, 98, 4, 2, 36, 36, 94, 94, 4, 2, 41, 41, 94, 94, 4, 2, 67, 67, 99, 99, 4, 2, 68, 68, 100, 100, 4, 2, 69, 69, 101, 101, 4, 2, 70, 70, 102, 102, 4, 2, 71, 71, 103, 103, 4, 2, 72, 72, 104, 104, 4, 2, 73, 73, 105, 105, 4, 2, 74, 74, 106, 106, 4, 2, 75, 75, 107, 107, 4, 2, 76, 76, 108, 108, 4, 2, 77, 77, 109, 109, 4, 2, 78, 78, 110, 110, 4, 2, 79, 79, 111, 111, 4, 2, 80, 80, 112, 112, 4, 2, 81, 81, 113, 113, 4, 2, 82, 82, 114, 114, 4, 2, 83, 83, 115, 115, 4, 2, 84, 84, 116, 116, 4, 2, 85, 85, 117, 117, 4, 2, 86, 86, 118, 118, 4, 2, 87, 87, 119, 119, 4, 2, 88, 88, 120, 120, 4, 2, 89, 89, 121, 121, 4, 2, 90, 90, 122, 122, 4, 2, 91, 91, 123, 123, 4, 2, 92, 92, 124, 124, 4, 2, 67, 92, 99, 124, 3, 2, 50, 57, 3, 2, 50, 59, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 12, 12, 15, 15, 4, 3, 12, 12, 15, 15, 4, 2, 11, 15, 34, 34, 5, 2, 41, 41, 94, 94, 125, 125, 3, 2, 125, 125, 5, 2, 67, 92, 97, 97, 99, 124, 7, 2, 47, 47, 50, 59, 67, 92, 97, 97, 99, 124, 5, 2, 11, 12, 15, 15, 34, 34, 4, 2, 62, 62, 125, 125, 2, 1667, 2, 8, 3, 2, 2, 2, 2, 10, 3, 2, 2, 2, 2, 12, 3, 2, 2, 2, 2, 14, 3, 2, 2, 2, 2, 16, 3, 2, 2, 2, 2, 18, 3, 2, 2, 2, 2, 20, 3, 2, 2, 2, 2, 22, 3, 2, 2, 2, 2, 24, 3, 2, 2, 2, 2, 26, 3, 2, 2, 2, 2, 28, 3, 2, 2, 2, 2, 30, 3, 2, 2, 2, 2, 32, 3, 2, 2, 2, 2, 34, 3, 2, 2, 2, 2, 36, 3, 2, 2, 2, 2, 38, 3, 2, 2, 2, 2, 40, 3, 2, 2, 2, 2, 42, 3, 2, 2, 2, 2, 44, 3, 2, 2, 2, 2, 46, 3, 2, 2, 2, 2, 48, 3, 2, 2, 2, 2, 50, 3, 2, 2, 2, 2, 52, 3, 2, 2, 2, 2, 54, 3, 2, 2, 2, 2, 56, 3, 2, 2, 2, 2, 58, 3, 2, 2, 2, 2, 60, 3, 2, 2, 2, 2, 62, 3, 2, 2, 2, 2, 64, 3, 2, 2, 2, 2, 66, 3, 2, 2, 2, 2, 68, 3, 2, 2, 2, 2, 70, 3, 2, 2, 2, 2, 72, 3, 2, 2, 2, 2, 74, 3, 2, 2, 2, 2, 76, 3, 2, 2, 2, 2, 78, 3, 2, 2, 2, 2, 80, 3, 2, 2, 2, 2, 82, 3, 2, 2, 2, 2, 84, 3, 2, 2, 2, 2, 86, 3, 2, 2, 2, 2, 88, 3, 2, 2, 2, 2, 90, 3, 2, 2, 2, 2, 92, 3, 2, 2, 2, 2, 94, 3, 2, 2, 2, 2, 96, 3, 2, 2, 2, 2, 98, 3, 2, 2, 2, 2, 100, 3, 2, 2, 2, 2, 102, 3, 2, 2, 2, 2, 104, 3, 2, 2, 2, 2, 106, 3, 2, 2, 2, 2, 108, 3, 2, 2, 2, 2, 110, 3, 2, 2, 2, 2, 112, 3, 2, 2, 2, 2, 114, 3, 2, 2, 2, 2, 116, 3, 2, 2, 2, 2, 118, 3, 2, 2, 2, 2, 120, 3, 2, 2, 2, 2, 122, 3, 2, 2, 2, 2, 124, 3, 2, 2, 2, 2, 126, 3, 2, 2, 2, 2, 128, 3, 2, 2, 2, 2, 130, 3, 2, 2, 2, 2, 132, 3, 2, 2, 2, 2, 134, 3, 2, 2, 2, 2, 136, 3, 2, 2, 2, 2, 138, 3, 2, 2, 2, 2, 140, 3, 2, 2, 2, 2, 142, 3, 2, 2, 2, 2, 144, 3, 2, 2, 2, 2, 146, 3, 2, 2, 2, 2, 148, 3, 2, 2, 2, 2, 150, 3, 2, 2, 2, 2, 152, 3, 2, 2, 2, 2, 154, 3, 2, 2, 2, 2, 156, 3, 2, 2, 2, 2, 158, 3, 2, 2, 2, 2, 160, 3, 2, 2, 2, 2, 162, 3, 2, 2, 2, 2, 164, 3, 2, 2, 2, 2, 166, 3, 2, 2, 2, 2, 168, 3, 2, 2, 2, 2, 170, 3, 2, 2, 2, 2, 172, 3, 2, 2, 2, 2, 174, 3, 2, 2, 2, 2, 176, 3, 2, 2, 2, 2, 178, 3, 2, 2, 2, 2, 180, 3, 2, 2, 2, 2, 182, 3, 2, 2, 2, 2, 184, 3, 2, 2, 2, 2, 186, 3, 2, 2, 2, 2, 188, 3, 2, 2, 2, 2, 190, 3, 2, 2, 2, 2, 192, 3, 2, 2, 2, 2, 194, 3, 2, 2, 2, 2, 196, 3, 2, 2, 2, 2, 198, 3, 2, 2, 2, 2, 200, 3, 2, 2, 2, 2, 202, 3, 2, 2, 2, 2, 204, 3, 2, 2, 2, 2, 206, 3, 2, 2, 2, 2, 208, 3, 2, 2, 2, 2, 210, 3, 2, 2, 2, 2, 212, 3, 2, 2, 2, 2, 214, 3, 2, 2, 2, 2, 216, 3, 2, 2, 2, 2, 218, 3, 2, 2, 2, 2, 220, 3, 2, 2, 2, 2, 222, 3, 2, 2, 2, 2, 224, 3, 2, 2, 2, 2, 226, 3, 2, 2, 2, 2, 228, 3, 2, 2, 2, 2, 230, 3, 2, 2, 2, 2, 232, 3, 2, 2, 2, 2, 294, 3, 2, 2, 2, 2, 296, 3, 2, 2, 2, 2, 298, 3, 2, 2, 2, 2, 300, 3, 2, 2, 2, 2, 302, 3, 2, 2, 2, 2, 304, 3, 2, 2, 2, 2, 306, 3, 2, 2, 2, 2, 308, 3, 2, 2, 2, 2, 310, 3, 2, 2, 2, 2, 312, 3, 2, 2, 2, 2, 314, 3, 2, 2, 2, 2, 316, 3, 2, 2, 2, 2, 318, 3, 2, 2, 2, 2, 320, 3, 2, 2, 2, 2, 322, 3, 2, 2, 2, 2, 324, 3, 2, 2, 2, 2, 326, 3, 2, 2, 2, 2, 328, 3, 2, 2, 2, 2, 330, 3, 2, 2, 2, 2, 332, 3, 2, 2, 2, 2, 334, 3, 2, 2, 2, 2, 336, 3, 2, 2, 2, 2, 338, 3, 2, 2, 2, 2, 340, 3, 2, 2, 2, 2, 342, 3, 2, 2, 2, 2, 344, 3, 2, 2, 2, 2, 346, 3, 2, 2, 2, 2, 348, 3, 2, 2, 2, 2, 350, 3, 2, 2, 2, 2, 352, 3, 2, 2, 2, 2, 354, 3, 2, 2, 2, 2, 356, 3, 2, 2, 2, 2, 358, 3, 2, 2, 2, 2, 360, 3, 2, 2, 2, 2, 362, 3, 2, 2, 2, 2, 364, 3, 2, 2, 2, 2, 366, 3, 2, 2, 2, 2, 368, 3, 2, 2, 2, 2, 370, 3, 2, 2, 2, 2, 372, 3, 2, 2, 2, 2, 374, 3, 2, 2, 2, 2, 376, 3, 2, 2, 2, 2, 378, 3, 2, 2, 2, 2, 380, 3, 2, 2, 2, 2, 382, 3, 2, 2, 2, 2, 384, 3, 2, 2, 2, 2, 386, 3, 2, 2, 2, 2, 388, 3, 2, 2, 2, 2, 390, 3, 2, 2, 2, 3, 392, 3, 2, 2, 2, 3, 394, 3, 2, 2, 2, 3, 396, 3, 2, 2, 2, 4, 398, 3, 2, 2, 2, 4, 400, 3, 2, 2, 2, 5, 402, 3, 2, 2, 2, 5, 404, 3, 2, 2, 2, 5, 406, 3, 2, 2, 2, 5, 408, 3, 2, 2, 2, 5, 410, 3, 2, 2, 2, 5, 412, 3, 2, 2, 2, 5, 414, 3, 2, 2, 2, 6, 416, 3, 2, 2, 2, 6, 418, 3, 2, 2, 2, 6, 420, 3, 2, 2, 2, 7, 422, 3, 2, 2, 2, 7, 424, 3, 2, 2, 2, 7, 426, 3, 2, 2, 2, 7, 428, 3, 2, 2, 2, 7, 430, 3, 2, 2, 2, 8, 432, 3, 2, 2, 2, 10, 436, 3, 2, 2, 2, 12, 440, 3, 2, 2, 2, 14, 445, 3, 2, 2, 2, 16, 449, 3, 2, 2, 2, 18, 455, 3, 2, 2, 2, 20, 472, 3, 2, 2, 2, 22, 474, 3, 2, 2, 2, 24, 479, 3, 2, 2, 2, 26, 487, 3, 2, 2, 2, 28, 492, 3, 2, 2, 2, 30, 495, 3, 2, 2, 2, 32, 500, 3, 2, 2, 2, 34, 505, 3, 2, 2, 2, 36, 511, 3, 2, 2, 2, 38, 518, 3, 2, 2, 2, 40, 526, 3, 2, 2, 2, 42, 532, 3, 2, 2, 2, 44, 537, 3, 2, 2, 2, 46, 545, 3, 2, 2, 2, 48, 550, 3, 2, 2, 2, 50, 554, 3, 2, 2, 2, 52, 559, 3, 2, 2, 2, 54, 570, 3, 2, 2, 2, 56, 579, 3, 2, 2, 2, 58, 584, 3, 2, 2, 2, 60, 588, 3, 2, 2, 2, 62, 595, 3, 2, 2, 2, 64, 603, 3, 2, 2, 2, 66, 609, 3, 2, 2, 2, 68, 617, 3, 2, 2, 2, 70, 623, 3, 2, 2, 2, 72, 626, 3, 2, 2, 2, 74, 636, 3, 2, 2, 2, 76, 640, 3, 2, 2, 2, 78, 645, 3, 2, 2, 2, 80, 650, 3, 2, 2, 2, 82, 654, 3, 2, 2, 2, 84, 660, 3, 2, 2, 2, 86, 667, 3, 2, 2, 2, 88, 672, 3, 2, 2, 2, 90, 675, 3, 2, 2, 2, 92, 678, 3, 2, 2, 2, 94, 684, 3, 2, 2, 2, 96, 700, 3, 2, 2, 2, 98, 702, 3, 2, 2, 2, 100, 708, 3, 2, 2, 2, 102, 718, 3, 2, 2, 2, 104, 727, 3, 2, 2, 2, 106, 730, 3, 2, 2, 2, 108, 735, 3, 2, 2, 2, 110, 739, 3, 2, 2, 2, 112, 744, 3, 2, 2, 2, 114, 752, 3, 2, 2, 2, 116, 757, 3, 2, 2, 2, 118, 761, 3, 2, 2, 2, 120, 766, 3, 2, 2, 2, 122, 772, 3, 2, 2, 2, 124, 779, 3, 2, 2, 2, 126, 785, 3, 2, 2, 2, 128, 789, 3, 2, 2, 2, 130, 793, 3, 2, 2, 2, 132, 798, 3, 2, 2, 2, 134, 804, 3, 2, 2, 2, 136, 811, 3, 2, 2, 2, 138, 814, 3, 2, 2, 2, 140, 817, 3, 2, 2, 2, 142, 823, 3, 2, 2, 2, 144, 829, 3, 2, 2, 2, 146, 834, 3, 2, 2, 2, 148, 844, 3, 2, 2, 2, 150, 854, 3, 2, 2, 2, 152, 863, 3, 2, 2, 2, 154, 871, 3, 2, 2, 2, 156, 877, 3, 2, 2, 2, 158, 884, 3, 2, 2, 2, 160, 890, 3, 2, 2, 2, 162, 897, 3, 2, 2, 2, 164, 901, 3, 2, 2, 2, 166, 906, 3, 2, 2, 2, 168, 913, 3, 2, 2, 2, 170, 920, 3, 2, 2, 2, 172, 927, 3, 2, 2, 2, 174, 932, 3, 2, 2, 2, 176, 941, 3, 2, 2, 2, 178, 951, 3, 2, 2, 2, 180, 956, 3, 2, 2, 2, 182, 962, 3, 2, 2, 2, 184, 967, 3, 2, 2, 2, 186, 977, 3, 2, 2, 2, 188, 980, 3, 2, 2, 2, 190, 984, 3, 2, 2, 2, 192, 991, 3, 2, 2, 2, 194, 1000, 3, 2, 2, 2, 196, 1005, 3, 2, 2, 2, 198, 1014, 3, 2, 2, 2, 200, 1018, 3, 2, 2, 2, 202, 1028, 3, 2, 2, 2, 204, 1034, 3, 2, 2, 2, 206, 1040, 3, 2, 2, 2, 208, 1045, 3, 2, 2, 2, 210, 1050, 3, 2, 2, 2, 212, 1056, 3, 2, 2, 2, 214, 1062, 3, 2, 2, 2, 216, 1069, 3, 2, 2, 2, 218, 1084, 3, 2, 2, 2, 220, 1113, 3, 2, 2, 2, 222, 1161, 3, 2, 2, 2, 224, 1239, 3, 2, 2, 2, 226, 1241, 3, 2, 2, 2, 228, 1248, 3, 2, 2, 2, 230, 1252, 3, 2, 2, 2, 232, 1259, 3, 2, 2, 2, 234, 1275, 3, 2, 2, 2, 236, 1277, 3, 2, 2, 2, 238, 1279, 3, 2, 2, 2, 240, 1281, 3, 2, 2, 2, 242, 1283, 3, 2, 2, 2, 244, 1285, 3, 2, 2, 2, 246, 1287, 3, 2, 2, 2, 248, 1289, 3, 2, 2, 2, 250, 1291, 3, 2, 2, 2, 252, 1293, 3, 2, 2, 2, 254, 1295, 3, 2, 2, 2, 256, 1297, 3, 2, 2, 2, 258, 1299, 3, 2, 2, 2, 260, 1301, 3, 2, 2, 2, 262, 1303, 3, 2, 2, 2, 264, 1305, 3, 2, 2, 2, 266, 1307, 3, 2, 2, 2, 268, 1309, 3, 2, 2, 2, 270, 1311, 3, 2, 2, 2, 272, 1313, 3, 2, 2, 2, 274, 1315, 3, 2, 2, 2, 276, 1317, 3, 2, 2, 2, 278, 1319, 3, 2, 2, 2, 280, 1321, 3, 2, 2, 2, 282, 1323, 3, 2, 2, 2, 284, 1325, 3, 2, 2, 2, 286, 1327, 3, 2, 2, 2, 288, 1329, 3, 2, 2, 2, 290, 1331, 3, 2, 2, 2, 292, 1333, 3, 2, 2, 2, 294, 1335, 3, 2, 2, 2, 296, 1338, 3, 2, 2, 2, 298, 1340, 3, 2, 2, 2, 300, 1342, 3, 2, 2, 2, 302, 1344, 3, 2, 2, 2, 304, 1346, 3, 2, 2, 2, 306, 1348, 3, 2, 2, 2, 308, 1351, 3, 2, 2, 2, 310, 1353, 3, 2, 2, 2, 312, 1355, 3, 2, 2, 2, 314, 1357, 3, 2, 2, 2, 316, 1360, 3, 2, 2, 2, 318, 1362, 3, 2, 2, 2, 320, 1365, 3, 2, 2, 2, 322, 1367, 3, 2, 2, 2, 324, 1369, 3, 2, 2, 2, 326, 1372, 3, 2, 2, 2, 328, 1376, 3, 2, 2, 2, 330, 1380, 3, 2, 2, 2, 332, 1382, 3, 2, 2, 2, 334, 1384, 3, 2, 2, 2, 336, 1387, 3, 2, 2, 2, 338, 1393, 3, 2, 2, 2, 340, 1399, 3, 2, 2, 2, 342, 1401, 3, 2, 2, 2, 344, 1408, 3, 2, 2, 2, 346, 1410, 3, 2, 2, 2, 348, 1414, 3, 2, 2, 2, 350, 1417, 3, 2, 2, 2, 352, 1420, 3, 2, 2, 2, 354, 1423, 3, 2, 2, 2, 356, 1425, 3, 2, 2, 2, 358, 1427, 3, 2, 2, 2, 360, 1429, 3, 2, 2, 2, 362, 1431, 3, 2, 2, 2, 364, 1436, 3, 2, 2, 2, 366, 1441, 3, 2, 2, 2, 368, 1443, 3, 2, 2, 2, 370, 1445, 3, 2, 2, 2, 372, 1448, 3, 2, 2, 2, 374, 1452, 3, 2, 2, 2, 376, 1454, 3, 2, 2, 2, 378, 1456, 3, 2, 2, 2, 380, 1458, 3, 2, 2, 2, 382, 1460, 3, 2, 2, 2, 384, 1463, 3, 2, 2, 2, 386, 1465, 3, 2, 2, 2, 388, 1483, 3, 2, 2, 2, 390, 1496, 3, 2, 2, 2, 392, 1511, 3, 2, 2, 2, 394, 1515, 3, 2, 2, 2, 396, 1519, 3, 2, 2, 2, 398, 1529, 3, 2, 2, 2, 400, 1533, 3, 2, 2, 2, 402, 1537, 3, 2, 2, 2, 404, 1543, 3, 2, 2, 2, 406, 1549, 3, 2, 2, 2, 408, 1558, 3, 2, 2, 2, 410, 1562, 3, 2, 2, 2, 412, 1567, 3, 2, 2, 2, 414, 1573, 3, 2, 2, 2, 416, 1578, 3, 2, 2, 2, 418, 1583, 3, 2, 2, 2, 420, 1593, 3, 2, 2, 2, 422, 1600, 3, 2, 2, 2, 424, 1604, 3, 2, 2, 2, 426, 1609, 3, 2, 2, 2, 428, 1616, 3, 2, 2, 2, 430, 1622, 3, 2, 2, 2, 432, 433, 5, 234, 115, 2, 433, 434, 5, 256, 126, 2, 434, 435, 5, 256, 126, 2, 435, 9, 3, 2, 2, 2, 436, 437, 5, 234, 115, 2, 437, 438, 5, 260, 128, 2, 438, 439, 5, 240, 118, 2, 439, 11, 3, 2, 2, 2, 440, 441, 5, 234, 115, 2, 441, 442, 5, 260, 128, 2, 442, 443, 5, 272, 134, 2, 443, 444, 5, 250, 123, 2, 444, 13, 3, 2, 2, 2, 445, 446, 5, 234, 115, 2, 446, 447, 5, 260, 128, 2, 447, 448, 5, 282, 139, 2, 448, 15, 3, 2, 2, 2, 449, 450, 5, 234, 115, 2, 450, 451, 5, 268, 132, 2, 451, 452, 5, 268, 132, 2, 452, 453, 5, 234, 115, 2, 453, 454, 5, 282, 139, 2, 454, 17, 3, 2, 2, 2, 455, 456, 5, 234, 115, 2, 456, 457, 5, 270, 133, 2, 457, 19, 3, 2, 2, 2, 458, 459, 5, 234, 115, 2, 459, 460, 5, 270, 133, 2, 460, 461, 5, 238, 117, 2, 461, 473, 3, 2, 2, 2, 462, 463, 5, 234, 115, 2, 463, 464, 5, 270, 133, 2, 464, 465, 5, 238, 117, 2, 465, 466, 5, 242, 119, 2, 466, 467, 5, 260, 128, 2, 467, 468, 5, 240, 118, 2, 468, 469, 5, 250, 123, 2, 469, 470, 5, 260, 128, 2, 470, 471, 5, 246, 121, 2, 471, 473, 3, 2, 2, 2, 472, 458, 3, 2, 2, 2, 472, 462, 3, 2, 2, 2, 473, 21, 3, 2, 2, 2, 474, 475, 5, 234, 115, 2, 475, 476, 5, 270, 133, 2, 476, 477, 5, 262, 129, 2, 477, 478, 5, 244, 120, 2, 478, 23, 3, 2, 2, 2, 479, 480, 5, 236, 116, 2, 480, 481, 5, 242, 119, 2, 481, 482, 5, 272, 134, 2, 482, 483, 5, 278, 137, 2, 483, 484, 5, 242, 119, 2, 484, 485, 5, 242, 119, 2, 485, 486, 5, 260, 128, 2, 486, 25, 3, 2, 2, 2, 487, 488, 5, 236, 116, 2, 488, 489, 5, 262, 129, 2, 489, 490, 5, 272, 134, 2, 490, 491, 5, 248, 122, 2, 491, 27, 3, 2, 2, 2, 492, 493, 5, 236, 116, 2, 493, 494, 5, 282, 139, 2, 494, 29, 3, 2, 2, 2, 495, 496, 5, 238, 117, 2, 496, 497, 5, 234, 115, 2, 497, 498, 5, 270, 133, 2, 498, 499, 5, 242, 119, 2, 499, 31, 3, 2, 2, 2, 500, 501, 5, 238, 117, 2, 501, 502, 5, 234, 115, 2, 502, 503, 5, 270, 133, 2, 503, 504, 5, 272, 134, 2, 504, 33, 3, 2, 2, 2, 505, 506, 5, 238, 117, 2, 506, 507, 5, 234, 115, 2, 507, 508, 5, 272, 134, 2, 508, 509, 5, 238, 117, 2, 509, 510, 5, 248, 122, 2, 510, 35, 3, 2, 2, 2, 511, 512, 5, 238, 117, 2, 512, 513, 5, 262, 129, 2, 513, 514, 5, 248, 122, 2, 514, 515, 5, 262, 129, 2, 515, 516, 5, 268, 132, 2, 516, 517, 5, 272, 134, 2, 517, 37, 3, 2, 2, 2, 518, 519, 5, 238, 117, 2, 519, 520, 5, 262, 129, 2, 520, 521, 5, 256, 126, 2, 521, 522, 5, 256, 126, 2, 522, 523, 5, 234, 115, 2, 523, 524, 5, 272, 134, 2, 524, 525, 5, 242, 119, 2, 525, 39, 3, 2, 2, 2, 526, 527, 5, 238, 117, 2, 527, 528, 5, 268, 132, 2, 528, 529, 5, 262, 129, 2, 529, 530, 5, 270, 133, 2, 530, 531, 5, 270, 133, 2, 531, 41, 3, 2, 2, 2, 532, 533, 5, 238, 117, 2, 533, 534, 5, 274, 135, 2, 534, 535, 5, 236, 116, 2, 535, 536, 5, 242, 119, 2, 536, 43, 3, 2, 2, 2, 537, 538, 5, 238, 117, 2, 538, 539, 5, 274, 135, 2, 539, 540, 5, 268, 132, 2, 540, 541, 5, 268, 132, 2, 541, 542, 5, 242, 119, 2, 542, 543, 5, 260, 128, 2, 543, 544, 5, 272, 134, 2, 544, 45, 3, 2, 2, 2, 545, 546, 5, 240, 118, 2, 546, 547, 5, 234, 115, 2, 547, 548, 5, 272, 134, 2, 548, 549, 5, 242, 119, 2, 549, 47, 3, 2, 2, 2, 550, 551, 5, 240, 118, 2, 551, 552, 5, 234, 115, 2, 552, 553, 5, 282, 139, 2, 553, 49, 3, 2, 2, 2, 554, 555, 5, 240, 118, 2, 555, 556, 5, 242, 119, 2, 556, 557, 5, 270, 133, 2, 557, 558, 5, 238, 117, 2, 558, 51, 3, 2, 2, 2, 559, 560, 5, 240, 118, 2, 560, 561, 5, 242, 119, 2, 561, 562, 5, 270, 133, 2, 562, 563, 5, 238, 117, 2, 563, 564, 5, 242, 119, 2, 564, 565, 5, 260, 128, 2, 565, 566, 5, 240, 118, 2, 566, 567, 5, 250, 123, 2, 567, 568, 5, 260, 128, 2, 568, 569, 5, 246, 121, 2, 569, 53, 3, 2, 2, 2, 570, 571, 5, 240, 118, 2, 571, 572, 5, 250, 123, 2, 572, 573, 5, 270, 133, 2, 573, 574, 5, 272, 134, 2, 574, 575, 5, 250, 123, 2, 575, 576, 5, 260, 128, 2, 576, 577, 5, 238, 117, 2, 577, 578, 5, 272, 134, 2, 578, 55, 3, 2, 2, 2, 579, 580, 5, 242, 119, 2, 580, 581, 5, 256, 126, 2, 581, 582, 5, 270, 133, 2, 582, 583, 5, 242, 119, 2, 583, 57, 3, 2, 2, 2, 584, 585, 5, 242, 119, 2, 585, 586, 5, 260, 128, 2, 586, 587, 5, 240, 118, 2, 587, 59, 3, 2, 2, 2, 588, 589, 5, 242, 119, 2, 589, 590, 5, 280, 138, 2, 590, 591, 5, 238, 117, 2, 591, 592, 5, 242, 119, 2, 592, 593, 5, 264, 130, 2, 593, 594, 5, 272, 134, 2, 594, 61, 3, 2, 2, 2, 595, 596, 5, 242, 119, 2, 596, 597, 5, 280, 138, 2, 597, 598, 5, 272, 134, 2, 598, 599, 5, 268, 132, 2, 599, 600, 5, 234, 115, 2, 600, 601, 5, 238, 117, 2, 601, 602, 5, 272, 134, 2, 602, 63, 3, 2, 2, 2, 603, 604, 5, 244, 120, 2, 604, 605, 5, 250, 123, 2, 605, 606, 5, 260, 128, 2, 606, 607, 5, 234, 115, 2, 607, 608, 5, 256, 126, 2, 608, 65, 3, 2, 2, 2, 609, 610, 5, 244, 120, 2, 610, 611, 5, 250, 123, 2, 611, 612, 5, 260, 128, 2, 612, 613, 5, 234, 115, 2, 613, 614, 5, 256, 126, 2, 614, 615, 5, 256, 126, 2, 615, 616, 5, 282, 139, 2, 616, 67, 3, 2, 2, 2, 617, 618, 5, 244, 120, 2, 618, 619, 5, 250, 123, 2, 619, 620, 5, 268, 132, 2, 620, 621, 5, 270, 133, 2, 621, 622, 5, 272, 134, 2, 622, 69, 3, 2, 2, 2, 623, 624, 5, 244, 120, 2, 624, 625, 5, 260, 128, 2, 625, 71, 3, 2, 2, 2, 626, 627, 5, 244, 120, 2, 627, 628, 5, 262, 129, 2, 628, 629, 5, 256, 126, 2, 629, 630, 5, 256, 126, 2, 630, 631, 5, 262, 129, 2, 631, 632, 5, 278, 137, 2, 632, 633, 5, 250, 123, 2, 633, 634, 5, 260, 128, 2, 634, 635, 5, 246, 121, 2, 635, 73, 3, 2, 2, 2, 636, 637, 5, 244, 120, 2, 637, 638, 5, 262, 129, 2, 638, 639, 5, 268, 132, 2, 639, 75, 3, 2, 2, 2, 640, 641, 5, 244, 120, 2, 641, 642, 5, 268, 132, 2, 642, 643, 5, 262, 129, 2, 643, 644, 5, 258, 127, 2, 644, 77, 3, 2, 2, 2, 645, 646, 5, 244, 120, 2, 646, 647, 5, 274, 135, 2, 647, 648, 5, 256, 126, 2, 648, 649, 5, 256, 126, 2, 649, 79, 3, 2, 2, 2, 650, 651, 5, 244, 120, 2, 651, 652, 5, 274, 135, 2, 652, 653, 5, 260, 128, 2, 653, 81, 3, 2, 2, 2, 654, 655, 5, 246, 121, 2, 655, 656, 5, 268, 132, 2, 656, 657, 5, 262, 129, 2, 657, 658, 5, 274, 135, 2, 658, 659, 5, 264, 130, 2, 659, 83, 3, 2, 2, 2, 660, 661, 5, 248, 122, 2, 661, 662, 5, 234, 115, 2, 662, 663, 5, 276, 136, 2, 663, 664, 5, 250, 123, 2, 664, 665, 5, 260, 128, 2, 665, 666, 5, 246, 121, 2, 666, 85, 3, 2, 2, 2, 667, 668, 5, 248, 122, 2, 668, 669, 5, 262, 129, 2, 669, 670, 5, 274, 135, 2, 670, 671, 5, 268, 132, 2, 671, 87, 3, 2, 2, 2, 672, 673, 5, 250, 123, 2, 673, 674, 5, 240, 118, 2, 674, 89, 3, 2, 2, 2, 675, 676, 5, 250, 123, 2, 676, 677, 5, 244, 120, 2, 677, 91, 3, 2, 2, 2, 678, 679, 5, 250, 123, 2, 679, 680, 5, 256, 126, 2, 680, 681, 5, 250, 123, 2, 681, 682, 5, 254, 125, 2, 682, 683, 5, 242, 119, 2, 683, 93, 3, 2, 2, 2, 684, 685, 5, 250, 123, 2, 685, 686, 5, 260, 128, 2, 686, 95, 3, 2, 2, 2, 687, 688, 5, 250, 123, 2, 688, 689, 5, 260, 128, 2, 689, 690, 5, 244, 120, 2, 690, 701, 3, 2, 2, 2, 691, 692, 5, 250, 123, 2, 692, 693, 5, 260, 128, 2, 693, 694, 5, 244, 120, 2, 694, 695, 5, 250, 123, 2, 695, 696, 5, 260, 128, 2, 696, 697, 5, 250, 123, 2, 697, 698, 5, 272, 134, 2, 698, 699, 5, 282, 139, 2, 699, 701, 3, 2, 2, 2, 700, 687, 3, 2, 2, 2, 700, 691, 3, 2, 2, 2, 701, 97, 3, 2, 2, 2, 702, 703, 5, 250, 123, 2, 703, 704, 5, 260, 128, 2, 704, 705, 5, 260, 128, 2, 705, 706, 5, 242, 119, 2, 706, 707, 5, 268, 132, 2, 707, 99, 3, 2, 2, 2, 708, 709, 5, 250, 123, 2, 709, 710, 5, 260, 128, 2, 710, 711, 5, 272, 134, 2, 711, 712, 5, 242, 119, 2, 712, 713, 5, 268, 132, 2, 713, 714, 5, 270, 133, 2, 714, 715, 5, 242, 119, 2, 715, 716, 5, 238, 117, 2, 716, 717, 5, 272, 134, 2, 717, 101, 3, 2, 2, 2, 718, 719, 5, 250, 123, 2, 719, 720, 5, 260, 128, 2, 720, 721, 5, 272, 134, 2, 721, 722, 5, 242, 119, 2, 722, 723, 5, 268, 132, 2, 723, 724, 5, 276, 136, 2, 724, 725, 5, 234, 115, 2, 725, 726, 5, 256, 126, 2, 726, 103, 3, 2, 2, 2, 727, 728, 5, 250, 123, 2, 728, 729, 5, 270, 133, 2, 729, 105, 3, 2, 2, 2, 730, 731, 5, 252, 124, 2, 731, 732, 5, 262, 129, 2, 732, 733, 5, 250, 123, 2, 733, 734, 5, 260, 128, 2, 734, 107, 3, 2, 2, 2, 735, 736, 5, 254, 125, 2, 736, 737, 5, 242, 119, 2, 737, 738, 5, 282, 139, 2, 738, 109, 3, 2, 2, 2, 739, 740, 5, 256, 126, 2, 740, 741, 5, 234, 115, 2, 741, 742, 5, 270, 133, 2, 742, 743, 5, 272, 134, 2, 743, 111, 3, 2, 2, 2, 744, 745, 5, 256, 126, 2, 745, 746, 5, 242, 119, 2, 746, 747, 5, 234, 115, 2, 747, 748, 5, 240, 118, 2, 748, 749, 5, 250, 123, 2, 749, 750, 5, 260, 128, 2, 750, 751, 5, 246, 121, 2, 751, 113, 3, 2, 2, 2, 752, 753, 5, 256, 126, 2, 753, 754, 5, 242, 119, 2, 754, 755, 5, 244, 120, 2, 755, 756, 5, 272, 134, 2, 756, 115, 3, 2, 2, 2, 757, 758, 5, 256, 126, 2, 758, 759, 5, 242, 119, 2, 759, 760, 5, 272, 134, 2, 760, 117, 3, 2, 2, 2, 761, 762, 5, 256, 126, 2, 762, 763, 5, 250, 123, 2, 763, 764, 5, 254, 125, 2, 764, 765, 5, 242, 119, 2, 765, 119, 3, 2, 2, 2, 766, 767, 5, 256, 126, 2, 767, 768, 5, 250, 123, 2, 768, 769, 5, 258, 127, 2, 769, 770, 5, 250, 123, 2, 770, 771, 5, 272, 134, 2, 771, 121, 3, 2, 2, 2, 772, 773, 5, 258, 127, 2, 773, 774, 5, 250, 123, 2, 774, 775, 5, 260, 128, 2, 775, 776, 5, 274, 135, 2, 776, 777, 5, 272, 134, 2, 777, 778, 5, 242, 119, 2, 778, 123, 3, 2, 2, 2, 779, 780, 5, 258, 127, 2, 780, 781, 5, 262, 129, 2, 781, 782, 5, 260, 128, 2, 782, 783, 5, 272, 134, 2, 783, 784, 5, 248, 122, 2, 784, 125, 3, 2, 2, 2, 785, 786, 5, 260, 128, 2, 786, 787, 5, 234, 115, 2, 787, 788, 5, 260, 128, 2, 788, 127, 3, 2, 2, 2, 789, 790, 5, 260, 128, 2, 790, 791, 5, 262, 129, 2, 791, 792, 5, 272, 134, 2, 792, 129, 3, 2, 2, 2, 793, 794, 5, 260, 128, 2, 794, 795, 5, 274, 135, 2, 795, 796, 5, 256, 126, 2, 796, 797, 5, 256, 126, 2, 797, 131, 3, 2, 2, 2, 798, 799, 5, 260, 128, 2, 799, 800, 5, 274, 135, 2, 800, 801, 5, 256, 126, 2, 801, 802, 5, 256, 126, 2, 802, 803, 5, 270, 133, 2, 803, 133, 3, 2, 2, 2, 804, 805, 5, 262, 129, 2, 805, 806, 5, 244, 120, 2, 806, 807, 5, 244, 120, 2, 807, 808, 5, 270, 133, 2, 808, 809, 5, 242, 119, 2, 809, 810, 5, 272, 134, 2, 810, 135, 3, 2, 2, 2, 811, 812, 5, 262, 129, 2, 812, 813, 5, 260, 128, 2, 813, 137, 3, 2, 2, 2, 814, 815, 5, 262, 129, 2, 815, 816, 5, 268, 132, 2, 816, 139, 3, 2, 2, 2, 817, 818, 5, 262, 129, 2, 818, 819, 5, 268, 132, 2, 819, 820, 5, 240, 118, 2, 820, 821, 5, 242, 119, 2, 821, 822, 5, 268, 132, 2, 822, 141, 3, 2, 2, 2, 823, 824, 5, 262, 129, 2, 824, 825, 5, 274, 135, 2, 825, 826, 5, 272, 134, 2, 826, 827, 5, 242, 119, 2, 827, 828, 5, 268, 132, 2, 828, 143, 3, 2, 2, 2, 829, 830, 5, 262, 129, 2, 830, 831, 5, 276, 136, 2, 831, 832, 5, 242, 119, 2, 832, 833, 5, 268, 132, 2, 833, 145, 3, 2, 2, 2, 834, 835, 5, 264, 130, 2, 835, 836, 5, 234, 115, 2, 836, 837, 5, 268, 132, 2, 837, 838, 5, 272, 134, 2, 838, 839, 5, 250, 123, 2, 839, 840, 5, 272, 134, 2, 840, 841, 5, 250, 123, 2, 841, 842, 5, 262, 129, 2, 842, 843, 5, 260, 128, 2, 843, 147, 3, 2, 2, 2, 844, 845, 5, 264, 130, 2, 845, 846, 5, 268, 132, 2, 846, 847, 5, 242, 119, 2, 847, 848, 5, 238, 117, 2, 848, 849, 5, 242, 119, 2, 849, 850, 5, 240, 118, 2, 850, 851, 5, 250, 123, 2, 851, 852, 5, 260, 128, 2, 852, 853, 5, 246, 121, 2, 853, 149, 3, 2, 2, 2, 854, 855, 5, 264, 130, 2, 855, 856, 5, 268, 132, 2, 856, 857, 5, 242, 119, 2, 857, 858, 5, 278, 137, 2, 858, 859, 5, 248, 122, 2, 859, 860, 5, 242, 119, 2, 860, 861, 5, 268, 132, 2, 861, 862, 5, 242, 119, 2, 862, 151, 3, 2, 2, 2, 863, 864, 5, 266, 131, 2, 864, 865, 5, 274, 135, 2, 865, 866, 5, 234, 115, 2, 866, 867, 5, 268, 132, 2, 867, 868, 5, 272, 134, 2, 868, 869, 5, 242, 119, 2, 869, 870, 5, 268, 132, 2, 870, 153, 3, 2, 2, 2, 871, 872, 5, 268, 132, 2, 872, 873, 5, 234, 115, 2, 873, 874, 5, 260, 128, 2, 874, 875, 5, 246, 121, 2, 875, 876, 5, 242, 119, 2, 876, 155, 3, 2, 2, 2, 877, 878, 5, 268, 132, 2, 878, 879, 5, 242, 119, 2, 879, 880, 5, 272, 134, 2, 880, 881, 5, 274, 135, 2, 881, 882, 5, 268, 132, 2, 882, 883, 5, 260, 128, 2, 883, 157, 3, 2, 2, 2, 884, 885, 5, 268, 132, 2, 885, 886, 5, 250, 123, 2, 886, 887, 5, 246, 121, 2, 887, 888, 5, 248, 122, 2, 888, 889, 5, 272, 134, 2, 889, 159, 3, 2, 2, 2, 890, 891, 5, 268, 132, 2, 891, 892, 5, 262, 129, 2, 892, 893, 5, 256, 126, 2, 893, 894, 5, 256, 126, 2, 894, 895, 5, 274, 135, 2, 895, 896, 5, 264, 130, 2, 896, 161, 3, 2, 2, 2, 897, 898, 5, 268, 132, 2, 898, 899, 5, 262, 129, 2, 899, 900, 5, 278, 137, 2, 900, 163, 3, 2, 2, 2, 901, 902, 5, 268, 132, 2, 902, 903, 5, 262, 129, 2, 903, 904, 5, 278, 137, 2, 904, 905, 5, 270, 133, 2, 905, 165, 3, 2, 2, 2, 906, 907, 5, 270, 133, 2, 907, 908, 5, 234, 115, 2, 908, 909, 5, 258, 127, 2, 909, 910, 5, 264, 130, 2, 910, 911, 5, 256, 126, 2, 911, 912, 5, 242, 119, 2, 912, 167, 3, 2, 2, 2, 913, 914, 5, 270, 133, 2, 914, 915, 5, 242, 119, 2, 915, 916, 5, 238, 117, 2, 916, 917, 5, 262, 129, 2, 917, 918, 5, 260, 128, 2, 918, 919, 5, 240, 118, 2, 919, 169, 3, 2, 2, 2, 920, 921, 5, 270, 133, 2, 921, 922, 5, 242, 119, 2, 922, 923, 5, 256, 126, 2, 923, 924, 5, 242, 119, 2, 924, 925, 5, 238, 117, 2, 925, 926, 5, 272, 134, 2, 926, 171, 3, 2, 2, 2, 927, 928, 5, 270, 133, 2, 928, 929, 5, 242, 119, 2, 929, 930, 5, 258, 127, 2, 930, 931, 5, 250, 123, 2, 931, 173, 3, 2, 2, 2, 932, 933, 5, 270, 133, 2, 933, 934, 5, 242, 119, 2, 934, 935, 5, 272, 134, 2, 935, 936, 5, 272, 134, 2, 936, 937, 5, 250, 123, 2, 937, 938, 5, 260, 128, 2, 938, 939, 5, 246, 121, 2, 939, 940, 5, 270, 133, 2, 940, 175, 3, 2, 2, 2, 941, 942, 5, 270, 133, 2, 942, 943, 5, 274, 135, 2, 943, 944, 5, 236, 116, 2, 944, 945, 5, 270, 133, 2, 945, 946, 5, 272, 134, 2, 946, 947, 5, 268, 132, 2, 947, 948, 5, 250, 123, 2, 948, 949, 5, 260, 128, 2, 949, 950, 5, 246, 121, 2, 950, 177, 3, 2, 2, 2, 951, 952, 5, 272, 134, 2, 952, 953, 5, 248, 122, 2, 953, 954, 5, 242, 119, 2, 954, 955, 5, 260, 128, 2, 955, 179, 3, 2, 2, 2, 956, 957, 5, 272, 134, 2, 957, 958, 5, 248, 122, 2, 958, 959, 5, 268, 132, 2, 959, 960, 5, 262, 129, 2, 960, 961, 5, 278, 137, 2, 961, 181, 3, 2, 2, 2, 962, 963, 5, 272, 134, 2, 963, 964, 5, 250, 123, 2, 964, 965, 5, 242, 119, 2, 965, 966, 5, 270, 133, 2, 966, 183, 3, 2, 2, 2, 967, 968, 5, 272, 134, 2, 968, 969, 5, 250, 123, 2, 969, 970, 5, 258, 127, 2, 970, 971, 5, 242, 119, 2, 971, 972, 5, 270, 133, 2, 972, 973, 5, 272, 134, 2, 973, 974, 5, 234, 115, 2, 974, 975, 5, 258, 127, 2, 975, 976, 5, 264, 130, 2, 976, 185, 3, 2, 2, 2, 977, 978, 5, 272, 134, 2, 978, 979, 5, 262, 129, 2, 979, 187, 3, 2, 2, 2, 980, 981, 5, 272, 134, 2, 981, 982, 5, 262, 129, 2, 982, 983, 5, 264, 130, 2, 983, 189, 3, 2, 2, 2, 984, 985, 5, 272, 134, 2, 985, 986, 5, 262, 129, 2, 986, 987, 5, 272, 134, 2, 987, 988, 5, 234, 115, 2, 988, 989, 5, 256, 126, 2, 989, 990, 5, 270, 133, 2, 990, 191, 3, 2, 2, 2, 991, 992, 5, 272, 134, 2, 992, 993, 5, 268, 132, 2, 993, 994, 5, 234, 115, 2, 994, 995, 5, 250, 123, 2, 995, 996, 5, 256, 126, 2, 996, 997, 5, 250, 123, 2, 997, 998, 5, 260, 128, 2, 998, 999, 5, 246, 121, 2, 999, 193, 3, 2, 2, 2, 1000, 1001, 5, 272, 134, 2, 1001, 1002, 5, 268, 132, 2, 1002, 1003, 5, 250, 123, 2, 1003, 1004, 5, 258, 127, 2, 1004, 195, 3, 2, 2, 2, 1005, 1006, 5, 272, 134, 2, 1006, 1007, 5, 268, 132, 2, 1007, 1008, 5, 274, 135, 2, 1008, 1009, 5, 260, 128, 2, 1009, 1010, 5, 238, 117, 2, 1010, 1011, 5, 234, 115, 2, 1011, 1012, 5, 272, 134, 2, 1012, 1013, 5, 242, 119, 2, 1013, 197, 3, 2, 2, 2, 1014, 1015, 5, 272, 134, 2, 1015, 1016, 5, 268, 132, 2, 1016, 1017, 5, 282, 139, 2, 1017, 199, 3, 2, 2, 2, 1018, 1019, 5, 274, 135, 2, 1019, 1020, 5, 260, 128, 2, 1020, 1021, 5, 236, 116, 2, 1021, 1022, 5, 262, 129, 2, 1022, 1023, 5, 274, 135, 2, 1023, 1024, 5, 260, 128, 2, 1024, 1025, 5, 240, 118, 2, 1025, 1026, 5, 242, 119, 2, 1026, 1027, 5, 240, 118, 2, 1027, 201, 3, 2, 2, 2, 1028, 1029, 5, 274, 135, 2, 1029, 1030, 5, 260, 128, 2, 1030, 1031, 5, 250, 123, 2, 1031, 1032, 5, 262, 129, 2, 1032, 1033, 5, 260, 128, 2, 1033, 203, 3, 2, 2, 2, 1034, 1035, 5, 274, 135, 2, 1035, 1036, 5, 270, 133, 2, 1036, 1037, 5, 250, 123, 2, 1037, 1038, 5, 260, 128, 2, 1038, 1039, 5, 246, 121, 2, 1039, 205, 3, 2, 2, 2, 1040, 1041, 5, 278, 137, 2, 1041, 1042, 5, 242, 119, 2, 1042, 1043, 5, 242, 119, 2, 1043, 1044, 5, 254, 125, 2, 1044, 207, 3, 2, 2, 2, 1045, 1046, 5, 278, 137, 2, 1046, 1047, 5, 248, 122, 2, 1047, 1048, 5, 242, 119, 2, 1048, 1049, 5, 260, 128, 2, 1049, 209, 3, 2, 2, 2, 1050, 1051, 5, 278, 137, 2, 1051, 1052, 5, 248, 122, 2, 1052, 1053, 5, 242, 119, 2, 1053, 1054, 5, 268, 132, 2, 1054, 1055, 5, 242, 119, 2, 1055, 211, 3, 2, 2, 2, 1056, 1057, 5, 278, 137, 2, 1057, 1058, 5, 248, 122, 2, 1058, 1059, 5, 250, 123, 2, 1059, 1060, 5, 256, 126, 2, 1060, 1061, 5, 242, 119, 2, 1061, 213, 3, 2, 2, 2, 1062, 1063, 5, 278, 137, 2, 1063, 1064, 5, 250, 123, 2, 1064, 1065, 5, 260, 128, 2, 1065, 1066, 5, 240, 118, 2, 1066, 1067, 5, 262, 129, 2, 1067, 1068, 5, 278, 137, 2, 1068, 215, 3, 2, 2, 2, 1069, 1070, 5, 278, 137, 2, 1070, 1071, 5, 250, 123, 2, 1071, 1072, 5, 272, 134, 2, 1072, 1073, 5, 248, 122, 2, 1073, 217, 3, 2, 2, 2, 1074, 1075, 5, 282, 139, 2, 1075, 1076, 5, 242, 119, 2, 1076, 1077, 5, 234, 115, 2, 1077, 1078, 5, 268, 132, 2, 1078, 1085, 3, 2, 2, 2, 1079, 1080, 5, 282, 139, 2, 1080, 1081, 5, 282, 139, 2, 1081, 1082, 5, 282, 139, 2, 1082, 1083, 5, 282, 139, 2, 1083, 1085, 3, 2, 2, 2, 1084, 1074, 3, 2, 2, 2, 1084, 1079, 3, 2, 2, 2, 1085, 219, 3, 2, 2, 2, 1086, 1087, 5, 300, 148, 2, 1087, 1088, 5, 236, 116, 2, 1088, 1114, 3, 2, 2, 2, 1089, 1090, 5, 300, 148, 2, 1090, 1091, 5, 244, 120, 2, 1091, 1114, 3, 2, 2, 2, 1092, 1093, 5, 300, 148, 2, 1093, 1094, 5, 268, 132, 2, 1094, 1114, 3, 2, 2, 2, 1095, 1096, 5, 300, 148, 2, 1096, 1097, 5, 260, 128, 2, 1097, 1114, 3, 2, 2, 2, 1098, 1099, 5, 300, 148, 2, 1099, 1100, 5, 272, 134, 2, 1100, 1114, 3, 2, 2, 2, 1101, 1102, 5, 300, 148, 2, 1102, 1103, 7, 50, 2, 2, 1103, 1114, 3, 2, 2, 2, 1104, 1105, 5, 300, 148, 2, 1105, 1106, 5, 234, 115, 2, 1106, 1114, 3, 2, 2, 2, 1107, 1108, 5, 300, 148, 2, 1108, 1109, 5, 276, 136, 2, 1109, 1114, 3, 2, 2, 2, 1110, 1111, 5, 300, 148, 2, 1111, 1112, 5, 300, 148, 2, 1112, 1114, 3, 2, 2, 2, 1113, 1086, 3, 2, 2, 2, 1113, 1089, 3, 2, 2, 2, 1113, 1092, 3, 2, 2, 2, 1113, 1095, 3, 2, 2, 2, 1113, 1098, 3, 2, 2, 2, 1113, 1101, 3, 2, 2, 2, 1113, 1104, 3, 2, 2, 2, 1113, 1107, 3, 2, 2, 2, 1113, 1110, 3, 2, 2, 2, 1114, 221, 3, 2, 2, 2, 1115, 1119, 5, 286, 141, 2, 1116, 1119, 5, 384, 190, 2, 1117, 1119, 5, 310, 153, 2, 1118, 1115, 3, 2, 2, 2, 1118, 1116, 3, 2, 2, 2, 1118, 1117, 3, 2, 2, 2, 1119, 1126, 3, 2, 2, 2, 1120, 1125, 5, 286, 141, 2, 1121, 1125, 5, 384, 190, 2, 1122, 1125, 5, 290, 143, 2, 1123, 1125, 5, 310, 153, 2, 1124, 1120, 3, 2, 2, 2, 1124, 1121, 3, 2, 2, 2, 1124, 1122, 3, 2, 2, 2, 1124, 1123, 3, 2, 2, 2, 1125, 1128, 3, 2, 2, 2, 1126, 1124, 3, 2, 2, 2, 1126, 1127, 3, 2, 2, 2, 1127, 1162, 3, 2, 2, 2, 1128, 1126, 3, 2, 2, 2, 1129, 1140, 5, 298, 147, 2, 1130, 1139, 10, 2, 2, 2, 1131, 1139, 5, 220, 108, 2, 1132, 1133, 5, 300, 148, 2, 1133, 1134, 5, 366, 181, 2, 1134, 1139, 3, 2, 2, 2, 1135, 1136, 5, 298, 147, 2, 1136, 1137, 5, 298, 147, 2, 1137, 1139, 3, 2, 2, 2, 1138, 1130, 3, 2, 2, 2, 1138, 1131, 3, 2, 2, 2, 1138, 1132, 3, 2, 2, 2, 1138, 1135, 3, 2, 2, 2, 1139, 1142, 3, 2, 2, 2, 1140, 1138, 3, 2, 2, 2, 1140, 1141, 3, 2, 2, 2, 1141, 1143, 3, 2, 2, 2, 1142, 1140, 3, 2, 2, 2, 1143, 1144, 5, 298, 147, 2, 1144, 1162, 3, 2, 2, 2, 1145, 1156, 5, 360, 178, 2, 1146, 1155, 10, 3, 2, 2, 1147, 1155, 5, 220, 108, 2, 1148, 1149, 5, 300, 148, 2, 1149, 1150, 5, 360, 178, 2, 1150, 1155, 3, 2, 2, 2, 1151, 1152, 5, 360, 178, 2, 1152, 1153, 5, 360, 178, 2, 1153, 1155, 3, 2, 2, 2, 1154, 1146, 3, 2, 2, 2, 1154, 1147, 3, 2, 2, 2, 1154, 1148, 3, 2, 2, 2, 1154, 1151, 3, 2, 2, 2, 1155, 1158, 3, 2, 2, 2, 1156, 1154, 3, 2, 2, 2, 1156, 1157, 3, 2, 2, 2, 1157, 1159, 3, 2, 2, 2, 1158, 1156, 3, 2, 2, 2, 1159, 1160, 5, 360, 178, 2, 1160, 1162, 3, 2, 2, 2, 1161, 1118, 3, 2, 2, 2, 1161, 1129, 3, 2, 2, 2, 1161, 1145, 3, 2, 2, 2, 1162, 223, 3, 2, 2, 2, 1163, 1164, 5, 230, 113, 2, 1164, 1168, 5, 312, 154, 2, 1165, 1167, 5, 292, 144, 2, 1166, 1165, 3, 2, 2, 2, 1167, 1170, 3, 2, 2, 2, 1168, 1166, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 1173, 3, 2, 2, 2, 1170, 1168, 3, 2, 2, 2, 1171, 1174, 5, 264, 130, 2, 1172, 1174, 5, 242, 119, 2, 1173, 1171, 3, 2, 2, 2, 1173, 1172, 3, 2, 2, 2, 1174, 1177, 3, 2, 2, 2, 1175, 1178, 5, 356, 176, 2, 1176, 1178, 5, 308, 152, 2, 1177, 1175, 3, 2, 2, 2, 1177, 1176, 3, 2, 2, 2, 1177, 1178, 3, 2, 2, 2, 1178, 1180, 3, 2, 2, 2, 1179, 1181, 5, 290, 143, 2, 1180, 1179, 3, 2, 2, 2, 1181, 1182, 3, 2, 2, 2, 1182, 1180, 3, 2, 2, 2, 1182, 1183, 3, 2, 2, 2, 1183, 1240, 3, 2, 2, 2, 1184, 1187, 5, 230, 113, 2, 1185, 1188, 5, 264, 130, 2, 1186, 1188, 5, 242, 119, 2, 1187, 1185, 3, 2, 2, 2, 1187, 1186, 3, 2, 2, 2, 1188, 1191, 3, 2, 2, 2, 1189, 1192, 5, 356, 176, 2, 1190, 1192, 5, 308, 152, 2, 1191, 1189, 3, 2, 2, 2, 1191, 1190, 3, 2, 2, 2, 1191, 1192, 3, 2, 2, 2, 1192, 1194, 3, 2, 2, 2, 1193, 1195, 5, 290, 143, 2, 1194, 1193, 3, 2, 2, 2, 1195, 1196, 3, 2, 2, 2, 1196, 1194, 3, 2, 2, 2, 1196, 1197, 3, 2, 2, 2, 1197, 1240, 3, 2, 2, 2, 1198, 1199, 5, 228, 112, 2, 1199, 1203, 5, 312, 154, 2, 1200, 1202, 5, 290, 143, 2, 1201, 1200, 3, 2, 2, 2, 1202, 1205, 3, 2, 2, 2, 1203, 1201, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 1206, 3, 2, 2, 2, 1205, 1203, 3, 2, 2, 2, 1206, 1209, 5, 242, 119, 2, 1207, 1210, 5, 356, 176, 2, 1208, 1210, 5, 308, 152, 2, 1209, 1207, 3, 2, 2, 2, 1209, 1208, 3, 2, 2, 2, 1209, 1210, 3, 2, 2, 2, 1210, 1212, 3, 2, 2, 2, 1211, 1213, 5, 290, 143, 2, 1212, 1211, 3, 2, 2, 2, 1213, 1214, 3, 2, 2, 2, 1214, 1212, 3, 2, 2, 2, 1214, 1215, 3, 2, 2, 2, 1215, 1240, 3, 2, 2, 2, 1216, 1217, 5, 312, 154, 2, 1217, 1218, 5, 228, 112, 2, 1218, 1221, 5, 242, 119, 2, 1219, 1222, 5, 356, 176, 2, 1220, 1222, 5, 308, 152, 2, 1221, 1219, 3, 2, 2, 2, 1221, 1220, 3, 2, 2, 2, 1221, 1222, 3, 2, 2, 2, 1222, 1224, 3, 2, 2, 2, 1223, 1225, 5, 290, 143, 2, 1224, 1223, 3, 2, 2, 2, 1225, 1226, 3, 2, 2, 2, 1226, 1224, 3, 2, 2, 2, 1226, 1227, 3, 2, 2, 2, 1227, 1240, 3, 2, 2, 2, 1228, 1229, 5, 228, 112, 2, 1229, 1232, 5, 242, 119, 2, 1230, 1233, 5, 356, 176, 2, 1231, 1233, 5, 308, 152, 2, 1232, 1230, 3, 2, 2, 2, 1232, 1231, 3, 2, 2, 2, 1232, 1233, 3, 2, 2, 2, 1233, 1235, 3, 2, 2, 2, 1234, 1236, 5, 290, 143, 2, 1235, 1234, 3, 2, 2, 2, 1236, 1237, 3, 2, 2, 2, 1237, 1235, 3, 2, 2, 2, 1237, 1238, 3, 2, 2, 2, 1238, 1240, 3, 2, 2, 2, 1239, 1163, 3, 2, 2, 2, 1239, 1184, 3, 2, 2, 2, 1239, 1198, 3, 2, 2, 2, 1239, 1216, 3, 2, 2, 2, 1239, 1228, 3, 2, 2, 2, 1240, 225, 3, 2, 2, 2, 1241, 1243, 7, 50, 2, 2, 1242, 1244, 5, 288, 142, 2, 1243, 1242, 3, 2, 2, 2, 1244, 1245, 3, 2, 2, 2, 1245, 1243, 3, 2, 2, 2, 1245, 1246, 3, 2, 2, 2, 1246, 227, 3, 2, 2, 2, 1247, 1249, 5, 290, 143, 2, 1248, 1247, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1248, 3, 2, 2, 2, 1250, 1251, 3, 2, 2, 2, 1251, 229, 3, 2, 2, 2, 1252, 1253, 7, 50, 2, 2, 1253, 1255, 5, 280, 138, 2, 1254, 1256, 5, 292, 144, 2, 1255, 1254, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1255, 3, 2, 2, 2, 1257, 1258, 3, 2, 2, 2, 1258, 231, 3, 2, 2, 2, 1259, 1270, 5, 366, 181, 2, 1260, 1269, 10, 4, 2, 2, 1261, 1269, 5, 220, 108, 2, 1262, 1263, 5, 300, 148, 2, 1263, 1264, 5, 366, 181, 2, 1264, 1269, 3, 2, 2, 2, 1265, 1266, 5, 366, 181, 2, 1266, 1267, 5, 366, 181, 2, 1267, 1269, 3, 2, 2, 2, 1268, 1260, 3, 2, 2, 2, 1268, 1261, 3, 2, 2, 2, 1268, 1262, 3, 2, 2, 2, 1268, 1265, 3, 2, 2, 2, 1269, 1272, 3, 2, 2, 2, 1270, 1268, 3, 2, 2, 2, 1270, 1271, 3, 2, 2, 2, 1271, 1273, 3, 2, 2, 2, 1272, 1270, 3, 2, 2, 2, 1273, 1274, 5, 366, 181, 2, 1274, 233, 3, 2, 2, 2, 1275, 1276, 9, 5, 2, 2, 1276, 235, 3, 2, 2, 2, 1277, 1278, 9, 6, 2, 2, 1278, 237, 3, 2, 2, 2, 1279, 1280, 9, 7, 2, 2, 1280, 239, 3, 2, 2, 2, 1281, 1282, 9, 8, 2, 2, 1282, 241, 3, 2, 2, 2, 1283, 1284, 9, 9, 2, 2, 1284, 243, 3, 2, 2, 2, 1285, 1286, 9, 10, 2, 2, 1286, 245, 3, 2, 2, 2, 1287, 1288, 9, 11, 2, 2, 1288, 247, 3, 2, 2, 2, 1289, 1290, 9, 12, 2, 2, 1290, 249, 3, 2, 2, 2, 1291, 1292, 9, 13, 2, 2, 1292, 251, 3, 2, 2, 2, 1293, 1294, 9, 14, 2, 2, 1294, 253, 3, 2, 2, 2, 1295, 1296, 9, 15, 2, 2, 1296, 255, 3, 2, 2, 2, 1297, 1298, 9, 16, 2, 2, 1298, 257, 3, 2, 2, 2, 1299, 1300, 9, 17, 2, 2, 1300, 259, 3, 2, 2, 2, 1301, 1302, 9, 18, 2, 2, 1302, 261, 3, 2, 2, 2, 1303, 1304, 9, 19, 2, 2, 1304, 263, 3, 2, 2, 2, 1305, 1306, 9, 20, 2, 2, 1306, 265, 3, 2, 2, 2, 1307, 1308, 9, 21, 2, 2, 1308, 267, 3, 2, 2, 2, 1309, 1310, 9, 22, 2, 2, 1310, 269, 3, 2, 2, 2, 1311, 1312, 9, 23, 2, 2, 1312, 271, 3, 2, 2, 2, 1313, 1314, 9, 24, 2, 2, 1314, 273, 3, 2, 2, 2, 1315, 1316, 9, 25, 2, 2, 1316, 275, 3, 2, 2, 2, 1317, 1318, 9, 26, 2, 2, 1318, 277, 3, 2, 2, 2, 1319, 1320, 9, 27, 2, 2, 1320, 279, 3, 2, 2, 2, 1321, 1322, 9, 28, 2, 2, 1322, 281, 3, 2, 2, 2, 1323, 1324, 9, 29, 2, 2, 1324, 283, 3, 2, 2, 2, 1325, 1326, 9, 30, 2, 2, 1326, 285, 3, 2, 2, 2, 1327, 1328, 9, 31, 2, 2, 1328, 287, 3, 2, 2, 2, 1329, 1330, 9, 32, 2, 2, 1330, 289, 3, 2, 2, 2, 1331, 1332, 9, 33, 2, 2, 1332, 291, 3, 2, 2, 2, 1333, 1334, 9, 34, 2, 2, 1334, 293, 3, 2, 2, 2, 1335, 1336, 7, 47, 2, 2, 1336, 1337, 7, 64, 2, 2, 1337, 295, 3, 2, 2, 2, 1338, 1339, 7, 44, 2, 2, 1339, 297, 3, 2, 2, 2, 1340, 1341, 7, 98, 2, 2, 1341, 299, 3, 2, 2, 2, 1342, 1343, 7, 94, 2, 2, 1343, 301, 3, 2, 2, 2, 1344, 1345, 7, 60, 2, 2, 1345, 303, 3, 2, 2, 2, 1346, 1347, 7, 46, 2, 2, 1347, 305, 3, 2, 2, 2, 1348, 1349, 7, 126, 2, 2, 1349, 1350, 7, 126, 2, 2, 1350, 307, 3, 2, 2, 2, 1351, 1352, 7, 47, 2, 2, 1352, 309, 3, 2, 2, 2, 1353, 1354, 7, 38, 2, 2, 1354, 311, 3, 2, 2, 2, 1355, 1356, 7, 48, 2, 2, 1356, 313, 3, 2, 2, 2, 1357, 1358, 7, 63, 2, 2, 1358, 1359, 7, 63, 2, 2, 1359, 315, 3, 2, 2, 2, 1360, 1361, 7, 63, 2, 2, 1361, 317, 3, 2, 2, 2, 1362, 1363, 7, 64, 2, 2, 1363, 1364, 7, 63, 2, 2, 1364, 319, 3, 2, 2, 2, 1365, 1366, 7, 64, 2, 2, 1366, 321, 3, 2, 2, 2, 1367, 1368, 7, 37, 2, 2, 1368, 323, 3, 2, 2, 2, 1369, 1370, 7, 128, 2, 2, 1370, 1371, 7, 44, 2, 2, 1371, 325, 3, 2, 2, 2, 1372, 1373, 7, 63, 2, 2, 1373, 1374, 7, 128, 2, 2, 1374, 1375, 7, 44, 2, 2, 1375, 327, 3, 2, 2, 2, 1376, 1377, 7, 125, 2, 2, 1377, 1378, 3, 2, 2, 2, 1378, 1379, 8, 162, 2, 2, 1379, 329, 3, 2, 2, 2, 1380, 1381, 7, 93, 2, 2, 1381, 331, 3, 2, 2, 2, 1382, 1383, 7, 42, 2, 2, 1383, 333, 3, 2, 2, 2, 1384, 1385, 7, 62, 2, 2, 1385, 1386, 7, 63, 2, 2, 1386, 335, 3, 2, 2, 2, 1387, 1388, 7, 62, 2, 2, 1388, 1389, 7, 49, 2, 2, 1389, 1390, 3, 2, 2, 2, 1390, 1391, 8, 166, 3, 2, 1391, 1392, 8, 166, 4, 2, 1392, 337, 3, 2, 2, 2, 1393, 1394, 7, 62, 2, 2, 1394, 1395, 6, 167, 2, 2, 1395, 1396, 3, 2, 2, 2, 1396, 1397, 8, 167, 5, 2, 1397, 1398, 8, 167, 6, 2, 1398, 339, 3, 2, 2, 2, 1399, 1400, 7, 62, 2, 2, 1400, 341, 3, 2, 2, 2, 1401, 1402, 7, 62, 2, 2, 1402, 1403, 7, 49, 2, 2, 1403, 343, 3, 2, 2, 2, 1404, 1405, 7, 35, 2, 2, 1405, 1409, 7, 63, 2, 2, 1406, 1407, 7, 62, 2, 2, 1407, 1409, 7, 64, 2, 2, 1408, 1404, 3, 2, 2, 2, 1408, 1406, 3, 2, 2, 2, 1409, 345, 3, 2, 2, 2, 1410, 1411, 7, 35, 2, 2, 1411, 1412, 7, 128, 2, 2, 1412, 1413, 7, 44, 2, 2, 1413, 347, 3, 2, 2, 2, 1414, 1415, 7, 35, 2, 2, 1415, 1416, 7, 128, 2, 2, 1416, 349, 3, 2, 2, 2, 1417, 1418, 7, 65, 2, 2, 1418, 1419, 7, 48, 2, 2, 1419, 351, 3, 2, 2, 2, 1420, 1421, 7, 65, 2, 2, 1421, 1422, 7, 65, 2, 2, 1422, 353, 3, 2, 2, 2, 1423, 1424, 7, 39, 2, 2, 1424, 355, 3, 2, 2, 2, 1425, 1426, 7, 45, 2, 2, 1426, 357, 3, 2, 2, 2, 1427, 1428, 7, 65, 2, 2, 1428, 359, 3, 2, 2, 2, 1429, 1430, 7, 36, 2, 2, 1430, 361, 3, 2, 2, 2, 1431, 1432, 7, 104, 2, 2, 1432, 1433, 7, 41, 2, 2, 1433, 1434, 3, 2, 2, 2, 1434, 1435, 8, 179, 7, 2, 1435, 363, 3, 2, 2, 2, 1436, 1437, 7, 72, 2, 2, 1437, 1438, 7, 41, 2, 2, 1438, 1439, 3, 2, 2, 2, 1439, 1440, 8, 180, 8, 2, 1440, 365, 3, 2, 2, 2, 1441, 1442, 7, 41, 2, 2, 1442, 367, 3, 2, 2, 2, 1443, 1444, 7, 128, 2, 2, 1444, 369, 3, 2, 2, 2, 1445, 1446, 7, 63, 2, 2, 1446, 1447, 7, 128, 2, 2, 1447, 371, 3, 2, 2, 2, 1448, 1449, 7, 127, 2, 2, 1449, 1450, 3, 2, 2, 2, 1450, 1451, 8, 184, 9, 2, 1451, 373, 3, 2, 2, 2, 1452, 1453, 7, 95, 2, 2, 1453, 375, 3, 2, 2, 2, 1454, 1455, 7, 43, 2, 2, 1455, 377, 3, 2, 2, 2, 1456, 1457, 7, 61, 2, 2, 1457, 379, 3, 2, 2, 2, 1458, 1459, 7, 49, 2, 2, 1459, 381, 3, 2, 2, 2, 1460, 1461, 7, 49, 2, 2, 1461, 1462, 7, 64, 2, 2, 1462, 383, 3, 2, 2, 2, 1463, 1464, 7, 97, 2, 2, 1464, 385, 3, 2, 2, 2, 1465, 1466, 7, 49, 2, 2, 1466, 1467, 7, 44, 2, 2, 1467, 1471, 3, 2, 2, 2, 1468, 1470, 11, 2, 2, 2, 1469, 1468, 3, 2, 2, 2, 1470, 1473, 3, 2, 2, 2, 1471, 1472, 3, 2, 2, 2, 1471, 1469, 3, 2, 2, 2, 1472, 1474, 3, 2, 2, 2, 1473, 1471, 3, 2, 2, 2, 1474, 1475, 7, 44, 2, 2, 1475, 1476, 7, 49, 2, 2, 1476, 1477, 3, 2, 2, 2, 1477, 1478, 8, 191, 10, 2, 1478, 387, 3, 2, 2, 2, 1479, 1480, 7, 47, 2, 2, 1480, 1484, 7, 47, 2, 2, 1481, 1482, 7, 49, 2, 2, 1482, 1484, 7, 49, 2, 2, 1483, 1479, 3, 2, 2, 2, 1483, 1481, 3, 2, 2, 2, 1484, 1488, 3, 2, 2, 2, 1485, 1487, 10, 35, 2, 2, 1486, 1485, 3, 2, 2, 2, 1487, 1490, 3, 2, 2, 2, 1488, 1486, 3, 2, 2, 2, 1488, 1489, 3, 2, 2, 2, 1489, 1492, 3, 2, 2, 2, 1490, 1488, 3, 2, 2, 2, 1491, 1493, 9, 36, 2, 2, 1492, 1491, 3, 2, 2, 2, 1493, 1494, 3, 2, 2, 2, 1494, 1495, 8, 192, 10, 2, 1495, 389, 3, 2, 2, 2, 1496, 1497, 9, 37, 2, 2, 1497, 1498, 3, 2, 2, 2, 1498, 1499, 8, 193, 11, 2, 1499, 391, 3, 2, 2, 2, 1500, 1512, 10, 38, 2, 2, 1501, 1512, 5, 220, 108, 2, 1502, 1503, 5, 300, 148, 2, 1503, 1504, 5, 366, 181, 2, 1504, 1512, 3, 2, 2, 2, 1505, 1506, 5, 300, 148, 2, 1506, 1507, 5, 328, 162, 2, 1507, 1512, 3, 2, 2, 2, 1508, 1509, 5, 366, 181, 2, 1509, 1510, 5, 366, 181, 2, 1510, 1512, 3, 2, 2, 2, 1511, 1500, 3, 2, 2, 2, 1511, 1501, 3, 2, 2, 2, 1511, 1502, 3, 2, 2, 2, 1511, 1505, 3, 2, 2, 2, 1511, 1508, 3, 2, 2, 2, 1512, 1513, 3, 2, 2, 2, 1513, 1511, 3, 2, 2, 2, 1513, 1514, 3, 2, 2, 2, 1514, 393, 3, 2, 2, 2, 1515, 1516, 5, 328, 162, 2, 1516, 1517, 3, 2, 2, 2, 1517, 1518, 8, 195, 2, 2, 1518, 395, 3, 2, 2, 2, 1519, 1520, 5, 366, 181, 2, 1520, 1521, 3, 2, 2, 2, 1521, 1522, 8, 196, 12, 2, 1522, 1523, 8, 196, 9, 2, 1523, 397, 3, 2, 2, 2, 1524, 1530, 10, 39, 2, 2, 1525, 1530, 5, 220, 108, 2, 1526, 1527, 5, 300, 148, 2, 1527, 1528, 5, 328, 162, 2, 1528, 1530, 3, 2, 2, 2, 1529, 1524, 3, 2, 2, 2, 1529, 1525, 3, 2, 2, 2, 1529, 1526, 3, 2, 2, 2, 1530, 1531, 3, 2, 2, 2, 1531, 1529, 3, 2, 2, 2, 1531, 1532, 3, 2, 2, 2, 1532, 399, 3, 2, 2, 2, 1533, 1534, 5, 328, 162, 2, 1534, 1535, 3, 2, 2, 2, 1535, 1536, 8, 198, 2, 2, 1536, 401, 3, 2, 2, 2, 1537, 1538, 7, 49, 2, 2, 1538, 1539, 7, 64, 2, 2, 1539, 1540, 3, 2, 2, 2, 1540, 1541, 8, 199, 13, 2, 1541, 1542, 8, 199, 9, 2, 1542, 403, 3, 2, 2, 2, 1543, 1544, 7, 64, 2, 2, 1544, 1545, 3, 2, 2, 2, 1545, 1546, 8, 200, 14, 2, 1546, 1547, 8, 200, 9, 2, 1547, 1548, 8, 200, 15, 2, 1548, 405, 3, 2, 2, 2, 1549, 1553, 9, 40, 2, 2, 1550, 1552, 9, 41, 2, 2, 1551, 1550, 3, 2, 2, 2, 1552, 1555, 3, 2, 2, 2, 1553, 1551, 3, 2, 2, 2, 1553, 1554, 3, 2, 2, 2, 1554, 1556, 3, 2, 2, 2, 1555, 1553, 3, 2, 2, 2, 1556, 1557, 8, 201, 16, 2, 1557, 407, 3, 2, 2, 2, 1558, 1559, 7, 63, 2, 2, 1559, 1560, 3, 2, 2, 2, 1560, 1561, 8, 202, 17, 2, 1561, 409, 3, 2, 2, 2, 1562, 1563, 5, 232, 114, 2, 1563, 1564, 3, 2, 2, 2, 1564, 1565, 8, 203, 18, 2, 1565, 411, 3, 2, 2, 2, 1566, 1568, 9, 42, 2, 2, 1567, 1566, 3, 2, 2, 2, 1568, 1569, 3, 2, 2, 2, 1569, 1567, 3, 2, 2, 2, 1569, 1570, 3, 2, 2, 2, 1570, 1571, 3, 2, 2, 2, 1571, 1572, 8, 204, 11, 2, 1572, 413, 3, 2, 2, 2, 1573, 1574, 7, 125, 2, 2, 1574, 1575, 3, 2, 2, 2, 1575, 1576, 8, 205, 19, 2, 1576, 1577, 8, 205, 2, 2, 1577, 415, 3, 2, 2, 2, 1578, 1579, 7, 64, 2, 2, 1579, 1580, 3, 2, 2, 2, 1580, 1581, 8, 206, 14, 2, 1581, 1582, 8, 206, 9, 2, 1582, 417, 3, 2, 2, 2, 1583, 1587, 9, 40, 2, 2, 1584, 1586, 9, 41, 2, 2, 1585, 1584, 3, 2, 2, 2, 1586, 1589, 3, 2, 2, 2, 1587, 1585, 3, 2, 2, 2, 1587, 1588, 3, 2, 2, 2, 1588, 1590, 3, 2, 2, 2, 1589, 1587, 3, 2, 2, 2, 1590, 1591, 8, 207, 16, 2, 1591, 419, 3, 2, 2, 2, 1592, 1594, 9, 42, 2, 2, 1593, 1592, 3, 2, 2, 2, 1594, 1595, 3, 2, 2, 2, 1595, 1593, 3, 2, 2, 2, 1595, 1596, 3, 2, 2, 2, 1596, 1597, 3, 2, 2, 2, 1597, 1598, 8, 208, 11, 2, 1598, 421, 3, 2, 2, 2, 1599, 1601, 10, 43, 2, 2, 1600, 1599, 3, 2, 2, 2, 1601, 1602, 3, 2, 2, 2, 1602, 1600, 3, 2, 2, 2, 1602, 1603, 3, 2, 2, 2, 1603, 423, 3, 2, 2, 2, 1604, 1605, 7, 125, 2, 2, 1605, 1606, 3, 2, 2, 2, 1606, 1607, 8, 210, 19, 2, 1607, 1608, 8, 210, 2, 2, 1608, 425, 3, 2, 2, 2, 1609, 1610, 7, 62, 2, 2, 1610, 1611, 7, 49, 2, 2, 1611, 1612, 3, 2, 2, 2, 1612, 1613, 8, 211, 3, 2, 1613, 1614, 8, 211, 9, 2, 1614, 1615, 8, 211, 4, 2, 1615, 427, 3, 2, 2, 2, 1616, 1617, 7, 62, 2, 2, 1617, 1618, 3, 2, 2, 2, 1618, 1619, 8, 212, 5, 2, 1619, 1620, 8, 212, 6, 2, 1620, 429, 3, 2, 2, 2, 1621, 1623, 9, 42, 2, 2, 1622, 1621, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 1622, 3, 2, 2, 2, 1624, 1625, 3, 2, 2, 2, 1625, 1626, 3, 2, 2, 2, 1626, 1627, 8, 213, 11, 2, 1627, 431, 3, 2, 2, 2, 55, 2, 3, 4, 5, 6, 7, 472, 700, 1084, 1113, 1118, 1124, 1126, 1138, 1140, 1154, 1156, 1161, 1168, 1173, 1177, 1182, 1187, 1191, 1196, 1203, 1209, 1214, 1221, 1226, 1232, 1237, 1239, 1245, 1250, 1257, 1268, 1270, 1408, 1471, 1483, 1488, 1492, 1511, 1513, 1529, 1531, 1553, 1569, 1587, 1595, 1602, 1624, 20, 7, 2, 2, 9, 138, 2, 7, 6, 2, 9, 137, 2, 7, 5, 2, 7, 3, 2, 7, 4, 2, 6, 2, 2, 8, 2, 2, 2, 3, 2, 9, 150, 2, 9, 158, 2, 9, 129, 2, 7, 7, 2, 9, 110, 2, 9, 127, 2, 9, 115, 2, 9, 133, 2]
\ No newline at end of file
diff --git a/internal-packages/tsql/src/grammar/TSQLLexer.tokens b/internal-packages/tsql/src/grammar/TSQLLexer.tokens
new file mode 100644
index 00000000000..f94f7b27168
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLLexer.tokens
@@ -0,0 +1,208 @@
+ALL=1
+AND=2
+ANTI=3
+ANY=4
+ARRAY=5
+AS=6
+ASCENDING=7
+ASOF=8
+BETWEEN=9
+BOTH=10
+BY=11
+CASE=12
+CAST=13
+CATCH=14
+COHORT=15
+COLLATE=16
+CROSS=17
+CUBE=18
+CURRENT=19
+DATE=20
+DAY=21
+DESC=22
+DESCENDING=23
+DISTINCT=24
+ELSE=25
+END=26
+EXCEPT=27
+EXTRACT=28
+FINAL=29
+FINALLY=30
+FIRST=31
+FN=32
+FOLLOWING=33
+FOR=34
+FROM=35
+FULL=36
+FUN=37
+GROUP=38
+HAVING=39
+HOUR=40
+ID=41
+IF=42
+ILIKE=43
+IN=44
+INF=45
+INNER=46
+INTERSECT=47
+INTERVAL=48
+IS=49
+JOIN=50
+KEY=51
+LAST=52
+LEADING=53
+LEFT=54
+LET=55
+LIKE=56
+LIMIT=57
+MINUTE=58
+MONTH=59
+NAN_SQL=60
+NOT=61
+NULL_SQL=62
+NULLS=63
+OFFSET=64
+ON=65
+OR=66
+ORDER=67
+OUTER=68
+OVER=69
+PARTITION=70
+PRECEDING=71
+PREWHERE=72
+QUARTER=73
+RANGE=74
+RETURN=75
+RIGHT=76
+ROLLUP=77
+ROW=78
+ROWS=79
+SAMPLE=80
+SECOND=81
+SELECT=82
+SEMI=83
+SETTINGS=84
+SUBSTRING=85
+THEN=86
+THROW=87
+TIES=88
+TIMESTAMP=89
+TO=90
+TOP=91
+TOTALS=92
+TRAILING=93
+TRIM=94
+TRUNCATE=95
+TRY=96
+UNBOUNDED=97
+UNION=98
+USING=99
+WEEK=100
+WHEN=101
+WHERE=102
+WHILE=103
+WINDOW=104
+WITH=105
+YEAR=106
+ESCAPE_CHAR_COMMON=107
+IDENTIFIER=108
+FLOATING_LITERAL=109
+OCTAL_LITERAL=110
+DECIMAL_LITERAL=111
+HEXADECIMAL_LITERAL=112
+STRING_LITERAL=113
+ARROW=114
+ASTERISK=115
+BACKQUOTE=116
+BACKSLASH=117
+COLON=118
+COMMA=119
+CONCAT=120
+DASH=121
+DOLLAR=122
+DOT=123
+EQ_DOUBLE=124
+EQ_SINGLE=125
+GT_EQ=126
+GT=127
+HASH=128
+IREGEX_SINGLE=129
+IREGEX_DOUBLE=130
+LBRACE=131
+LBRACKET=132
+LPAREN=133
+LT_EQ=134
+LT=135
+LT_SLASH=136
+NOT_EQ=137
+NOT_IREGEX=138
+NOT_REGEX=139
+NULL_PROPERTY=140
+NULLISH=141
+PERCENT=142
+PLUS=143
+QUERY=144
+QUOTE_DOUBLE=145
+QUOTE_SINGLE_TEMPLATE=146
+QUOTE_SINGLE_TEMPLATE_FULL=147
+QUOTE_SINGLE=148
+REGEX_SINGLE=149
+REGEX_DOUBLE=150
+RBRACE=151
+RBRACKET=152
+RPAREN=153
+SEMICOLON=154
+SLASH=155
+SLASH_GT=156
+UNDERSCORE=157
+MULTI_LINE_COMMENT=158
+SINGLE_LINE_COMMENT=159
+WHITESPACE=160
+STRING_TEXT=161
+STRING_ESCAPE_TRIGGER=162
+FULL_STRING_TEXT=163
+FULL_STRING_ESCAPE_TRIGGER=164
+TAG_WS=165
+TAGC_WS=166
+TSQLX_TEXT_TEXT=167
+TSQLX_TEXT_WS=168
+'->'=114
+'*'=115
+'`'=116
+'\\'=117
+':'=118
+','=119
+'||'=120
+'-'=121
+'$'=122
+'.'=123
+'=='=124
+'>='=126
+'#'=128
+'~*'=129
+'=~*'=130
+'{'=131
+'['=132
+'('=133
+'<='=134
+'<'=135
+'</'=136
+'!~*'=138
+'!~'=139
+'?.'=140
+'??'=141
+'%'=142
+'+'=143
+'?'=144
+'"'=145
+'f\''=146
+'F\''=147
+'\''=148
+'~'=149
+'=~'=150
+'}'=151
+']'=152
+')'=153
+';'=154
+'/'=155
+'_'=157
diff --git a/internal-packages/tsql/src/grammar/TSQLLexer.ts b/internal-packages/tsql/src/grammar/TSQLLexer.ts
new file mode 100644
index 00000000000..df2a081794a
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLLexer.ts
@@ -0,0 +1,1730 @@
+// Generated from src/grammar/TSQLLexer.g4 by ANTLR 4.9.0-SNAPSHOT
+
+// put any global imports you need here
+
+import { ATN } from "antlr4ts/atn/ATN";
+import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
+import { CharStream } from "antlr4ts/CharStream";
+import { Lexer } from "antlr4ts/Lexer";
+import { LexerATNSimulator } from "antlr4ts/atn/LexerATNSimulator";
+import { NotNull } from "antlr4ts/Decorators";
+import { Override } from "antlr4ts/Decorators";
+import { RuleContext } from "antlr4ts/RuleContext";
+import { Vocabulary } from "antlr4ts/Vocabulary";
+import { VocabularyImpl } from "antlr4ts/VocabularyImpl";
+
+import * as Utils from "antlr4ts/misc/Utils";
+
+export class TSQLLexer extends Lexer {
+  public static readonly ALL = 1;
+  public static readonly AND = 2;
+  public static readonly ANTI = 3;
+  public static readonly ANY = 4;
+  public static readonly ARRAY = 5;
+  public static readonly AS = 6;
+  public static readonly ASCENDING = 7;
+  public static readonly ASOF = 8;
+  public static readonly BETWEEN = 9;
+  public static readonly BOTH = 10;
+  public static readonly BY = 11;
+  public static readonly CASE = 12;
+  public static readonly CAST = 13;
+  public static readonly CATCH = 14;
+  public static readonly COHORT = 15;
+  public static readonly COLLATE = 16;
+  public static readonly CROSS = 17;
+  public static readonly CUBE = 18;
+  public static readonly CURRENT = 19;
+  public static readonly DATE = 20;
+  public static readonly DAY = 21;
+  public static readonly DESC = 22;
+  public static readonly DESCENDING = 23;
+  public static readonly DISTINCT = 24;
+  public static readonly ELSE = 25;
+  public static readonly END = 26;
+  public static readonly EXCEPT = 27;
+  public static readonly EXTRACT = 28;
+  public static readonly FINAL = 29;
+  public static readonly FINALLY = 30;
+  public static readonly FIRST = 31;
+  public static readonly FN = 32;
+  public static readonly FOLLOWING = 33;
+  public static readonly FOR = 34;
+  public static readonly FROM = 35;
+  public static readonly FULL = 36;
+  public static readonly FUN = 37;
+  public static readonly GROUP = 38;
+  public static readonly HAVING = 39;
+  public static readonly HOUR = 40;
+  public static readonly ID = 41;
+  public static readonly IF = 42;
+  public static readonly ILIKE = 43;
+  public static readonly IN = 44;
+  public static readonly INF = 45;
+  public static readonly INNER = 46;
+  public static readonly INTERSECT = 47;
+  public static readonly INTERVAL = 48;
+  public static readonly IS = 49;
+  public static readonly JOIN = 50;
+  public static readonly KEY = 51;
+  public static readonly LAST = 52;
+  public static readonly LEADING = 53;
+  public static readonly LEFT = 54;
+  public static readonly LET = 55;
+  public static readonly LIKE = 56;
+  public static readonly LIMIT = 57;
+  public static readonly MINUTE = 58;
+  public static readonly MONTH = 59;
+  public static readonly NAN_SQL = 60;
+  public static readonly NOT = 61;
+  public static readonly NULL_SQL = 62;
+  public static readonly NULLS = 63;
+  public static readonly OFFSET = 64;
+  public static readonly ON = 65;
+  public static readonly OR = 66;
+  public static readonly ORDER = 67;
+  public static readonly OUTER = 68;
+  public static readonly OVER = 69;
+  public static readonly PARTITION = 70;
+  public static readonly PRECEDING = 71;
+  public static readonly PREWHERE = 72;
+  public static readonly QUARTER = 73;
+  public static readonly RANGE = 74;
+  public static readonly RETURN = 75;
+  public static readonly RIGHT = 76;
+  public static readonly ROLLUP = 77;
+  public static readonly ROW = 78;
+  public static readonly ROWS = 79;
+  public static readonly SAMPLE = 80;
+  public static readonly SECOND = 81;
+  public static readonly SELECT = 82;
+  public static readonly SEMI = 83;
+  public static readonly SETTINGS = 84;
+  public static readonly SUBSTRING = 85;
+  public static readonly THEN = 86;
+  public static readonly THROW = 87;
+  public static readonly TIES = 88;
+  public static readonly TIMESTAMP = 89;
+  public static readonly TO = 90;
+  public static readonly TOP = 91;
+  public static readonly TOTALS = 92;
+  public static readonly TRAILING = 93;
+  public static readonly TRIM = 94;
+  public static readonly TRUNCATE = 95;
+  public static readonly TRY = 96;
+  public static readonly UNBOUNDED = 97;
+  public static readonly UNION = 98;
+  public static readonly USING = 99;
+  public static readonly WEEK = 100;
+  public static readonly WHEN = 101;
+  public static readonly WHERE = 102;
+  public static readonly WHILE = 103;
+  public static readonly WINDOW = 104;
+  public static readonly WITH = 105;
+  public static readonly YEAR = 106;
+  public static readonly ESCAPE_CHAR_COMMON = 107;
+  public static readonly IDENTIFIER = 108;
+  public static readonly FLOATING_LITERAL = 109;
+  public static readonly OCTAL_LITERAL = 110;
+  public static readonly DECIMAL_LITERAL = 111;
+  public static readonly HEXADECIMAL_LITERAL = 112;
+  public static readonly STRING_LITERAL = 113;
+  public static readonly ARROW = 114;
+  public static readonly ASTERISK = 115;
+  public static readonly BACKQUOTE = 116;
+  public static readonly BACKSLASH = 117;
+  public static readonly COLON = 118;
+  public static readonly COMMA = 119;
+  public static readonly CONCAT = 120;
+  public static readonly DASH = 121;
+  public static readonly DOLLAR = 122;
+  public static readonly DOT = 123;
+  public static readonly EQ_DOUBLE = 124;
+  public static readonly EQ_SINGLE = 125;
+  public static readonly GT_EQ = 126;
+  public static readonly GT = 127;
+  public static readonly HASH = 128;
+  public static readonly IREGEX_SINGLE = 129;
+  public static readonly IREGEX_DOUBLE = 130;
+  public static readonly LBRACE = 131;
+  public static readonly LBRACKET = 132;
+  public static readonly LPAREN = 133;
+  public static readonly LT_EQ = 134;
+  public static readonly LT = 135;
+  public static readonly LT_SLASH = 136;
+  public static readonly NOT_EQ = 137;
+  public static readonly NOT_IREGEX = 138;
+  public static readonly NOT_REGEX = 139;
+  public static readonly NULL_PROPERTY = 140;
+  public static readonly NULLISH = 141;
+  public static readonly PERCENT = 142;
+  public static readonly PLUS = 143;
+  public static readonly QUERY = 144;
+  public static readonly QUOTE_DOUBLE = 145;
+  public static readonly QUOTE_SINGLE_TEMPLATE = 146;
+  public static readonly QUOTE_SINGLE_TEMPLATE_FULL = 147;
+  public static readonly QUOTE_SINGLE = 148;
+  public static readonly REGEX_SINGLE = 149;
+  public static readonly REGEX_DOUBLE = 150;
+  public static readonly RBRACE = 151;
+  public static readonly RBRACKET = 152;
+  public static readonly RPAREN = 153;
+  public static readonly SEMICOLON = 154;
+  public static readonly SLASH = 155;
+  public static readonly SLASH_GT = 156;
+  public static readonly UNDERSCORE = 157;
+  public static readonly MULTI_LINE_COMMENT = 158;
+  public static readonly SINGLE_LINE_COMMENT = 159;
+  public static readonly WHITESPACE = 160;
+  public static readonly STRING_TEXT = 161;
+  public static readonly STRING_ESCAPE_TRIGGER = 162;
+  public static readonly FULL_STRING_TEXT = 163;
+  public static readonly FULL_STRING_ESCAPE_TRIGGER = 164;
+  public static readonly TAG_WS = 165;
+  public static readonly TAGC_WS = 166;
+  public static readonly TSQLX_TEXT_TEXT = 167;
+  public static readonly TSQLX_TEXT_WS = 168;
+  public static readonly IN_TEMPLATE_STRING = 1;
+  public static readonly IN_FULL_TEMPLATE_STRING = 2;
+  public static readonly TSQLX_TAG_OPEN = 3;
+  public static readonly TSQLX_TAG_CLOSE = 4;
+  public static readonly TSQLX_TEXT = 5;
+
+  // tslint:disable:no-trailing-whitespace
+  public static readonly channelNames: string[] = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"];
+
+  // tslint:disable:no-trailing-whitespace
+  public static readonly modeNames: string[] = [
+    "DEFAULT_MODE",
+    "IN_TEMPLATE_STRING",
+    "IN_FULL_TEMPLATE_STRING",
+    "TSQLX_TAG_OPEN",
+    "TSQLX_TAG_CLOSE",
+    "TSQLX_TEXT",
+  ];
+
+  public static readonly ruleNames: string[] = [
+    "ALL",
+    "AND",
+    "ANTI",
+    "ANY",
+    "ARRAY",
+    "AS",
+    "ASCENDING",
+    "ASOF",
+    "BETWEEN",
+    "BOTH",
+    "BY",
+    "CASE",
+    "CAST",
+    "CATCH",
+    "COHORT",
+    "COLLATE",
+    "CROSS",
+    "CUBE",
+    "CURRENT",
+    "DATE",
+    "DAY",
+    "DESC",
+    "DESCENDING",
+    "DISTINCT",
+    "ELSE",
+    "END",
+    "EXCEPT",
+    "EXTRACT",
+    "FINAL",
+    "FINALLY",
+    "FIRST",
+    "FN",
+    "FOLLOWING",
+    "FOR",
+    "FROM",
+    "FULL",
+    "FUN",
+    "GROUP",
+    "HAVING",
+    "HOUR",
+    "ID",
+    "IF",
+    "ILIKE",
+    "IN",
+    "INF",
+    "INNER",
+    "INTERSECT",
+    "INTERVAL",
+    "IS",
+    "JOIN",
+    "KEY",
+    "LAST",
+    "LEADING",
+    "LEFT",
+    "LET",
+    "LIKE",
+    "LIMIT",
+    "MINUTE",
+    "MONTH",
+    "NAN_SQL",
+    "NOT",
+    "NULL_SQL",
+    "NULLS",
+    "OFFSET",
+    "ON",
+    "OR",
+    "ORDER",
+    "OUTER",
+    "OVER",
+    "PARTITION",
+    "PRECEDING",
+    "PREWHERE",
+    "QUARTER",
+    "RANGE",
+    "RETURN",
+    "RIGHT",
+    "ROLLUP",
+    "ROW",
+    "ROWS",
+    "SAMPLE",
+    "SECOND",
+    "SELECT",
+    "SEMI",
+    "SETTINGS",
+    "SUBSTRING",
+    "THEN",
+    "THROW",
+    "TIES",
+    "TIMESTAMP",
+    "TO",
+    "TOP",
+    "TOTALS",
+    "TRAILING",
+    "TRIM",
+    "TRUNCATE",
+    "TRY",
+    "UNBOUNDED",
+    "UNION",
+    "USING",
+    "WEEK",
+    "WHEN",
+    "WHERE",
+    "WHILE",
+    "WINDOW",
+    "WITH",
+    "YEAR",
+    "ESCAPE_CHAR_COMMON",
+    "IDENTIFIER",
+    "FLOATING_LITERAL",
+    "OCTAL_LITERAL",
+    "DECIMAL_LITERAL",
+    "HEXADECIMAL_LITERAL",
+    "STRING_LITERAL",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "LETTER",
+    "OCT_DIGIT",
+    "DEC_DIGIT",
+    "HEX_DIGIT",
+    "ARROW",
+    "ASTERISK",
+    "BACKQUOTE",
+    "BACKSLASH",
+    "COLON",
+    "COMMA",
+    "CONCAT",
+    "DASH",
+    "DOLLAR",
+    "DOT",
+    "EQ_DOUBLE",
+    "EQ_SINGLE",
+    "GT_EQ",
+    "GT",
+    "HASH",
+    "IREGEX_SINGLE",
+    "IREGEX_DOUBLE",
+    "LBRACE",
+    "LBRACKET",
+    "LPAREN",
+    "LT_EQ",
+    "TAG_LT_SLASH",
+    "TAG_LT_OPEN",
+    "LT",
+    "LT_SLASH",
+    "NOT_EQ",
+    "NOT_IREGEX",
+    "NOT_REGEX",
+    "NULL_PROPERTY",
+    "NULLISH",
+    "PERCENT",
+    "PLUS",
+    "QUERY",
+    "QUOTE_DOUBLE",
+    "QUOTE_SINGLE_TEMPLATE",
+    "QUOTE_SINGLE_TEMPLATE_FULL",
+    "QUOTE_SINGLE",
+    "REGEX_SINGLE",
+    "REGEX_DOUBLE",
+    "RBRACE",
+    "RBRACKET",
+    "RPAREN",
+    "SEMICOLON",
+    "SLASH",
+    "SLASH_GT",
+    "UNDERSCORE",
+    "MULTI_LINE_COMMENT",
+    "SINGLE_LINE_COMMENT",
+    "WHITESPACE",
+    "STRING_TEXT",
+    "STRING_ESCAPE_TRIGGER",
+    "STRING_QUOTE_SINGLE",
+    "FULL_STRING_TEXT",
+    "FULL_STRING_ESCAPE_TRIGGER",
+    "TAG_SELF_CLOSE_GT",
+    "TAG_OPEN_GT",
+    "TAG_IDENT",
+    "TAG_EQ",
+    "TAG_STRING",
+    "TAG_WS",
+    "TAG_LBRACE",
+    "TAGC_GT",
+    "TAGC_IDENT",
+    "TAGC_WS",
+    "TSQLX_TEXT_TEXT",
+    "TSQLX_TEXT_LBRACE",
+    "TSQLX_TEXT_LT_SLASH",
+    "TSQLX_TEXT_LT",
+    "TSQLX_TEXT_WS",
+  ];
+
+  private static readonly _LITERAL_NAMES: Array<string | undefined> = [
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    "'->'",
+    "'*'",
+    "'`'",
+    "'\\'",
+    "':'",
+    "','",
+    "'||'",
+    "'-'",
+    "'$'",
+    "'.'",
+    "'=='",
+    undefined,
+    "'>='",
+    undefined,
+    "'#'",
+    "'~*'",
+    "'=~*'",
+    "'{'",
+    "'['",
+    "'('",
+    "'<='",
+    "'<'",
+    "'</'",
+    undefined,
+    "'!~*'",
+    "'!~'",
+    "'?.'",
+    "'??'",
+    "'%'",
+    "'+'",
+    "'?'",
+    "'\"'",
+    "'f''",
+    "'F''",
+    "'''",
+    "'~'",
+    "'=~'",
+    "'}'",
+    "']'",
+    "')'",
+    "';'",
+    "'/'",
+    undefined,
+    "'_'",
+  ];
+  private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
+    undefined,
+    "ALL",
+    "AND",
+    "ANTI",
+    "ANY",
+    "ARRAY",
+    "AS",
+    "ASCENDING",
+    "ASOF",
+    "BETWEEN",
+    "BOTH",
+    "BY",
+    "CASE",
+    "CAST",
+    "CATCH",
+    "COHORT",
+    "COLLATE",
+    "CROSS",
+    "CUBE",
+    "CURRENT",
+    "DATE",
+    "DAY",
+    "DESC",
+    "DESCENDING",
+    "DISTINCT",
+    "ELSE",
+    "END",
+    "EXCEPT",
+    "EXTRACT",
+    "FINAL",
+    "FINALLY",
+    "FIRST",
+    "FN",
+    "FOLLOWING",
+    "FOR",
+    "FROM",
+    "FULL",
+    "FUN",
+    "GROUP",
+    "HAVING",
+    "HOUR",
+    "ID",
+    "IF",
+    "ILIKE",
+    "IN",
+    "INF",
+    "INNER",
+    "INTERSECT",
+    "INTERVAL",
+    "IS",
+    "JOIN",
+    "KEY",
+    "LAST",
+    "LEADING",
+    "LEFT",
+    "LET",
+    "LIKE",
+    "LIMIT",
+    "MINUTE",
+    "MONTH",
+    "NAN_SQL",
+    "NOT",
+    "NULL_SQL",
+    "NULLS",
+    "OFFSET",
+    "ON",
+    "OR",
+    "ORDER",
+    "OUTER",
+    "OVER",
+    "PARTITION",
+    "PRECEDING",
+    "PREWHERE",
+    "QUARTER",
+    "RANGE",
+    "RETURN",
+    "RIGHT",
+    "ROLLUP",
+    "ROW",
+    "ROWS",
+    "SAMPLE",
+    "SECOND",
+    "SELECT",
+    "SEMI",
+    "SETTINGS",
+    "SUBSTRING",
+    "THEN",
+    "THROW",
+    "TIES",
+    "TIMESTAMP",
+    "TO",
+    "TOP",
+    "TOTALS",
+    "TRAILING",
+    "TRIM",
+    "TRUNCATE",
+    "TRY",
+    "UNBOUNDED",
+    "UNION",
+    "USING",
+    "WEEK",
+    "WHEN",
+    "WHERE",
+    "WHILE",
+    "WINDOW",
+    "WITH",
+    "YEAR",
+    "ESCAPE_CHAR_COMMON",
+    "IDENTIFIER",
+    "FLOATING_LITERAL",
+    "OCTAL_LITERAL",
+    "DECIMAL_LITERAL",
+    "HEXADECIMAL_LITERAL",
+    "STRING_LITERAL",
+    "ARROW",
+    "ASTERISK",
+    "BACKQUOTE",
+    "BACKSLASH",
+    "COLON",
+    "COMMA",
+    "CONCAT",
+    "DASH",
+    "DOLLAR",
+    "DOT",
+    "EQ_DOUBLE",
+    "EQ_SINGLE",
+    "GT_EQ",
+    "GT",
+    "HASH",
+    "IREGEX_SINGLE",
+    "IREGEX_DOUBLE",
+    "LBRACE",
+    "LBRACKET",
+    "LPAREN",
+    "LT_EQ",
+    "LT",
+    "LT_SLASH",
+    "NOT_EQ",
+    "NOT_IREGEX",
+    "NOT_REGEX",
+    "NULL_PROPERTY",
+    "NULLISH",
+    "PERCENT",
+    "PLUS",
+    "QUERY",
+    "QUOTE_DOUBLE",
+    "QUOTE_SINGLE_TEMPLATE",
+    "QUOTE_SINGLE_TEMPLATE_FULL",
+    "QUOTE_SINGLE",
+    "REGEX_SINGLE",
+    "REGEX_DOUBLE",
+    "RBRACE",
+    "RBRACKET",
+    "RPAREN",
+    "SEMICOLON",
+    "SLASH",
+    "SLASH_GT",
+    "UNDERSCORE",
+    "MULTI_LINE_COMMENT",
+    "SINGLE_LINE_COMMENT",
+    "WHITESPACE",
+    "STRING_TEXT",
+    "STRING_ESCAPE_TRIGGER",
+    "FULL_STRING_TEXT",
+    "FULL_STRING_ESCAPE_TRIGGER",
+    "TAG_WS",
+    "TAGC_WS",
+    "TSQLX_TEXT_TEXT",
+    "TSQLX_TEXT_WS",
+  ];
+  public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(
+    TSQLLexer._LITERAL_NAMES,
+    TSQLLexer._SYMBOLIC_NAMES,
+    []
+  );
+
+  // @Override
+  // @NotNull
+  public get vocabulary(): Vocabulary {
+    return TSQLLexer.VOCABULARY;
+  }
+  // tslint:enable:no-trailing-whitespace
+
+  private _peekChar(k: number): string {
+    // Return the k-th look-ahead as a *single-char string* or '\0' at EOF.
+    const c = this._input.LA(k); // int code point or IntStream.EOF (-1)
+    if (c < 0 || c > 0x10ffff) {
+      // EOF or out-of-range → sentinel
+      return "\0";
+    }
+    return String.fromCharCode(c);
+  }
+
+  private _skipWsAndComments(idx: number): number {
+    // Return the first index ≥ idx that is *not* whitespace / single-line comment.
+    while (true) {
+      const ch = this._peekChar(idx);
+      if (/\s/.test(ch)) {
+        // spaces, newlines, tabs …
+        idx++;
+        continue;
+      }
+
+      // single-line comments
+      if (ch === "/" && this._peekChar(idx + 1) === "/") {
+        // //
+        idx += 2;
+      } else if (ch === "-" && this._peekChar(idx + 1) === "-") {
+        // --
+        idx += 2;
+      } else if (ch === "#") {
+        // #
+        idx++;
+      } else {
+        break; // no ws / comment
+      }
+      // consume until EOL / EOF
+      while (!["\0", "\n", "\r"].includes(this._peekChar(idx))) {
+        idx++;
+      }
+    }
+    return idx;
+  }
+
+  // ───── opening tag test ─────
+  isOpeningTag(): boolean {
+    const ch1 = this._peekChar(1);
+    if (!(/[a-zA-Z]/.test(ch1) || ch1 === "_")) {
+      return false; // not a tag name start
+    }
+
+    // skip tag name
+    let i = 2;
+    while (true) {
+      const ch = this._peekChar(i);
+      if (/[a-zA-Z0-9]/.test(ch) || ch === "_" || ch === "-") {
+        i++;
+      } else {
+        break;
+      }
+    }
+
+    let ch = this._peekChar(i);
+
+    // immediate delimiter → tag
+    if (ch === ">" || ch === "/") {
+      return true;
+    }
+
+    // need to look beyond whitespace
+    if (/\s/.test(ch)) {
+      i = this._skipWsAndComments(i + 1);
+      ch = this._peekChar(i);
+      return ch === ">" || ch === "/" || /[a-zA-Z0-9]/.test(ch) || ch === "_";
+    }
+
+    // anything else → not a tag
+    return false;
+  }
+
+  constructor(input: CharStream) {
+    super(input);
+    this._interp = new LexerATNSimulator(TSQLLexer._ATN, this);
+  }
+
+  // @Override
+  public get grammarFileName(): string {
+    return "TSQLLexer.g4";
+  }
+
+  // @Override
+  public get ruleNames(): string[] {
+    return TSQLLexer.ruleNames;
+  }
+
+  // @Override
+  public get serializedATN(): string {
+    return TSQLLexer._serializedATN;
+  }
+
+  // @Override
+  public get channelNames(): string[] {
+    return TSQLLexer.channelNames;
+  }
+
+  // @Override
+  public get modeNames(): string[] {
+    return TSQLLexer.modeNames;
+  }
+
+  // @Override
+  public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
+    switch (ruleIndex) {
+      case 165:
+        return this.TAG_LT_OPEN_sempred(_localctx, predIndex);
+    }
+    return true;
+  }
+  private TAG_LT_OPEN_sempred(_localctx: RuleContext, predIndex: number): boolean {
+    switch (predIndex) {
+      case 0:
+        return this.isOpeningTag();
+    }
+    return true;
+  }
+
+  private static readonly _serializedATNSegments: number = 3;
+  private static readonly _serializedATNSegment0: string =
+    "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x02\xAA\u065C\b\x01" +
+    "\b\x01\b\x01\b\x01\b\x01\b\x01\x04\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04" +
+    "\x04\x05\t\x05\x04\x06\t\x06\x04\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t" +
+    "\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t" +
+    "\x10\x04\x11\t\x11\x04\x12\t\x12\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t" +
+    "\x15\x04\x16\t\x16\x04\x17\t\x17\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t" +
+    "\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t" +
+    '\x1F\x04 \t \x04!\t!\x04"\t"\x04#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t' +
+    "'\x04(\t(\x04)\t)\x04*\t*\x04+\t+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x04" +
+    "0\t0\x041\t1\x042\t2\x043\t3\x044\t4\x045\t5\x046\t6\x047\t7\x048\t8\x04" +
+    "9\t9\x04:\t:\x04;\t;\x04<\t<\x04=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04" +
+    "B\tB\x04C\tC\x04D\tD\x04E\tE\x04F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04" +
+    "K\tK\x04L\tL\x04M\tM\x04N\tN\x04O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04" +
+    "T\tT\x04U\tU\x04V\tV\x04W\tW\x04X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x04\\\t\\" +
+    "\x04]\t]\x04^\t^\x04_\t_\x04`\t`\x04a\ta\x04b\tb\x04c\tc\x04d\td\x04e" +
+    "\te\x04f\tf\x04g\tg\x04h\th\x04i\ti\x04j\tj\x04k\tk\x04l\tl\x04m\tm\x04" +
+    "n\tn\x04o\to\x04p\tp\x04q\tq\x04r\tr\x04s\ts\x04t\tt\x04u\tu\x04v\tv\x04" +
+    "w\tw\x04x\tx\x04y\ty\x04z\tz\x04{\t{\x04|\t|\x04}\t}\x04~\t~\x04\x7F\t" +
+    "\x7F\x04\x80\t\x80\x04\x81\t\x81\x04\x82\t\x82\x04\x83\t\x83\x04\x84\t" +
+    "\x84\x04\x85\t\x85\x04\x86\t\x86\x04\x87\t\x87\x04\x88\t\x88\x04\x89\t" +
+    "\x89\x04\x8A\t\x8A\x04\x8B\t\x8B\x04\x8C\t\x8C\x04\x8D\t\x8D\x04\x8E\t" +
+    "\x8E\x04\x8F\t\x8F\x04\x90\t\x90\x04\x91\t\x91\x04\x92\t\x92\x04\x93\t" +
+    "\x93\x04\x94\t\x94\x04\x95\t\x95\x04\x96\t\x96\x04\x97\t\x97\x04\x98\t" +
+    "\x98\x04\x99\t\x99\x04\x9A\t\x9A\x04\x9B\t\x9B\x04\x9C\t\x9C\x04\x9D\t" +
+    "\x9D\x04\x9E\t\x9E\x04\x9F\t\x9F\x04\xA0\t\xA0\x04\xA1\t\xA1\x04\xA2\t" +
+    "\xA2\x04\xA3\t\xA3\x04\xA4\t\xA4\x04\xA5\t\xA5\x04\xA6\t\xA6\x04\xA7\t" +
+    "\xA7\x04\xA8\t\xA8\x04\xA9\t\xA9\x04\xAA\t\xAA\x04\xAB\t\xAB\x04\xAC\t" +
+    "\xAC\x04\xAD\t\xAD\x04\xAE\t\xAE\x04\xAF\t\xAF\x04\xB0\t\xB0\x04\xB1\t" +
+    "\xB1\x04\xB2\t\xB2\x04\xB3\t\xB3\x04\xB4\t\xB4\x04\xB5\t\xB5\x04\xB6\t" +
+    "\xB6\x04\xB7\t\xB7\x04\xB8\t\xB8\x04\xB9\t\xB9\x04\xBA\t\xBA\x04\xBB\t" +
+    "\xBB\x04\xBC\t\xBC\x04\xBD\t\xBD\x04\xBE\t\xBE\x04\xBF\t\xBF\x04\xC0\t" +
+    "\xC0\x04\xC1\t\xC1\x04\xC2\t\xC2\x04\xC3\t\xC3\x04\xC4\t\xC4\x04\xC5\t" +
+    "\xC5\x04\xC6\t\xC6\x04\xC7\t\xC7\x04\xC8\t\xC8\x04\xC9\t\xC9\x04\xCA\t" +
+    "\xCA\x04\xCB\t\xCB\x04\xCC\t\xCC\x04\xCD\t\xCD\x04\xCE\t\xCE\x04\xCF\t" +
+    "\xCF\x04\xD0\t\xD0\x04\xD1\t\xD1\x04\xD2\t\xD2\x04\xD3\t\xD3\x04\xD4\t" +
+    "\xD4\x04\xD5\t\xD5\x03\x02\x03\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03" +
+    "\x03\x03\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05\x03\x05\x03" +
+    "\x05\x03\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x07\x03" +
+    "\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
+    "\b\x03\b\x03\b\x03\b\x03\b\x05\b\u01D9\n\b\x03\t\x03\t\x03\t\x03\t\x03" +
+    "\t\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03" +
+    "\v\x03\v\x03\f\x03\f\x03\f\x03\r\x03\r\x03\r\x03\r\x03\r\x03\x0E\x03\x0E" +
+    "\x03\x0E\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F" +
+    "\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x11\x03\x11" +
+    "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x12\x03\x12\x03\x12" +
+    "\x03\x12\x03\x12\x03\x12\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x14" +
+    "\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15" +
+    "\x03\x15\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03\x17\x03\x17" +
+    "\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18" +
+    "\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18\x03\x19\x03\x19\x03\x19\x03\x19" +
+    "\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1A" +
+    "\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C" +
+    "\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D" +
+    "\x03\x1D\x03\x1D\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1F" +
+    "\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03 \x03 \x03" +
+    ' \x03 \x03 \x03 \x03!\x03!\x03!\x03"\x03"\x03"\x03"\x03"\x03"\x03' +
+    '"\x03"\x03"\x03"\x03#\x03#\x03#\x03#\x03$\x03$\x03$\x03$\x03$\x03' +
+    "%\x03%\x03%\x03%\x03%\x03&\x03&\x03&\x03&\x03'\x03'\x03'\x03'\x03" +
+    "'\x03'\x03(\x03(\x03(\x03(\x03(\x03(\x03(\x03)\x03)\x03)\x03)\x03)\x03" +
+    "*\x03*\x03*\x03+\x03+\x03+\x03,\x03,\x03,\x03,\x03,\x03,\x03-\x03-\x03" +
+    "-\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x05" +
+    ".\u02BD\n.\x03/\x03/\x03/\x03/\x03/\x03/\x030\x030\x030\x030\x030\x03" +
+    "0\x030\x030\x030\x030\x031\x031\x031\x031\x031\x031\x031\x031\x031\x03" +
+    "2\x032\x032\x033\x033\x033\x033\x033\x034\x034\x034\x034\x035\x035\x03" +
+    "5\x035\x035\x036\x036\x036\x036\x036\x036\x036\x036\x037\x037\x037\x03" +
+    "7\x037\x038\x038\x038\x038\x039\x039\x039\x039\x039\x03:\x03:\x03:\x03" +
+    ":\x03:\x03:\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03<\x03" +
+    "<\x03<\x03=\x03=\x03=\x03=\x03>\x03>\x03>\x03>\x03?\x03?\x03?\x03?\x03" +
+    "?\x03@\x03@\x03@\x03@\x03@\x03@\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03" +
+    "B\x03B\x03B\x03C\x03C\x03C\x03D\x03D\x03D\x03D\x03D\x03D\x03E\x03E\x03" +
+    "E\x03E\x03E\x03E\x03F\x03F\x03F\x03F\x03F\x03G\x03G\x03G\x03G\x03G\x03" +
+    "G\x03G\x03G\x03G\x03G\x03H\x03H\x03H\x03H\x03H\x03H\x03H\x03H\x03H\x03" +
+    "H\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03J\x03J\x03J\x03J\x03" +
+    "J\x03J\x03J\x03J\x03K\x03K\x03K\x03K\x03K\x03K\x03L\x03L\x03L\x03L\x03" +
+    "L\x03L\x03L\x03M\x03M\x03M\x03M\x03M\x03M\x03N\x03N\x03N\x03N\x03N\x03" +
+    "N\x03N\x03O\x03O\x03O\x03O\x03P\x03P\x03P\x03P\x03P\x03Q\x03Q\x03Q\x03" +
+    "Q\x03Q\x03Q\x03Q\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x03S\x03S\x03S\x03" +
+    "S\x03S\x03S\x03S\x03T\x03T\x03T\x03T\x03T\x03U\x03U\x03U\x03U\x03U\x03" +
+    "U\x03U\x03U\x03U\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03" +
+    "W\x03W\x03W\x03W\x03W\x03X\x03X\x03X\x03X\x03X\x03X\x03Y\x03Y\x03Y\x03" +
+    "Y\x03Y\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03[\x03[\x03" +
+    "[\x03\\\x03\\\x03\\\x03\\\x03]\x03]\x03]\x03]\x03]\x03]\x03]\x03^\x03" +
+    "^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03_\x03_\x03_\x03_\x03_\x03`\x03" +
+    "`\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03a\x03a\x03a\x03a\x03b\x03b\x03" +
+    "b\x03b\x03b\x03b\x03b\x03b\x03b\x03b\x03c\x03c\x03c\x03c\x03c\x03c\x03" +
+    "d\x03d\x03d\x03d\x03d\x03d\x03e\x03e\x03e\x03e\x03e\x03f\x03f\x03f\x03" +
+    "f\x03f\x03g\x03g\x03g\x03g\x03g\x03g\x03h\x03h\x03h\x03h\x03h\x03h\x03" +
+    "i\x03i\x03i\x03i\x03i\x03i\x03i\x03j\x03j\x03j\x03j\x03j\x03k\x03k\x03" +
+    "k\x03k\x03k\x03k\x03k\x03k\x03k\x03k\x05k\u043D\nk\x03l\x03l\x03l\x03" +
+    "l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03" +
+    "l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x05l\u045A\nl\x03m\x03" +
+    "m\x03m\x05m\u045F\nm\x03m\x03m\x03m\x03m\x07m\u0465\nm\fm\x0Em\u0468\v" +
+    "m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x07m\u0473\nm\fm\x0Em\u0476" +
+    "\vm\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x07m\u0483" +
+    "\nm\fm\x0Em\u0486\vm\x03m\x03m\x05m\u048A\nm\x03n\x03n\x03n\x07n\u048F" +
+    "\nn\fn\x0En\u0492\vn\x03n\x03n\x05n\u0496\nn\x03n\x03n\x05n\u049A\nn\x03" +
+    "n\x06n\u049D\nn\rn\x0En\u049E\x03n\x03n\x03n\x05n\u04A4\nn\x03n\x03n\x05" +
+    "n\u04A8\nn\x03n\x06n\u04AB\nn\rn\x0En\u04AC\x03n\x03n\x03n\x07n\u04B2" +
+    "\nn\fn\x0En\u04B5\vn\x03n\x03n\x03n\x05n\u04BA\nn\x03n\x06n\u04BD\nn\r" +
+    "n\x0En\u04BE\x03n\x03n\x03n\x03n\x03n\x05n\u04C6\nn\x03n\x06n\u04C9\n" +
+    "n\rn\x0En\u04CA\x03n\x03n\x03n\x03n\x05n\u04D1\nn\x03n\x06n\u04D4\nn\r" +
+    "n\x0En\u04D5\x05n\u04D8\nn\x03o\x03o\x06o\u04DC\no\ro\x0Eo\u04DD\x03p" +
+    "\x06p\u04E1\np\rp\x0Ep\u04E2\x03q\x03q\x03q\x06q\u04E8\nq\rq\x0Eq\u04E9" +
+    "\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x07r\u04F5\nr\fr\x0Er\u04F8" +
+    "\vr\x03r\x03r\x03s\x03s\x03t\x03t\x03u\x03u\x03v\x03v\x03w\x03w\x03x\x03" +
+    "x\x03y\x03y\x03z\x03z\x03{\x03{\x03|\x03|\x03}\x03}\x03~\x03~\x03\x7F" +
+    "\x03\x7F\x03\x80\x03\x80\x03\x81\x03\x81\x03\x82\x03\x82\x03\x83\x03\x83" +
+    "\x03\x84\x03\x84\x03\x85\x03\x85\x03\x86\x03\x86\x03\x87\x03\x87\x03\x88" +
+    "\x03\x88\x03\x89\x03\x89\x03\x8A\x03\x8A\x03\x8B\x03\x8B\x03\x8C\x03\x8C" +
+    "\x03\x8D\x03\x8D\x03\x8E\x03\x8E\x03\x8F\x03\x8F\x03\x90\x03\x90\x03\x91" +
+    "\x03\x91\x03\x91\x03\x92\x03\x92\x03\x93\x03\x93\x03\x94\x03\x94\x03\x95" +
+    "\x03\x95\x03\x96\x03\x96\x03\x97\x03\x97\x03\x97\x03\x98\x03\x98\x03\x99" +
+    "\x03\x99\x03\x9A\x03\x9A\x03\x9B\x03\x9B\x03\x9B\x03\x9C\x03\x9C\x03\x9D" +
+    "\x03\x9D\x03\x9D\x03\x9E\x03\x9E\x03\x9F\x03\x9F\x03\xA0\x03\xA0\x03\xA0" +
+    "\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA3" +
+    "\x03\xA3\x03\xA4\x03\xA4\x03\xA5\x03\xA5\x03\xA5\x03\xA6\x03\xA6\x03\xA6" +
+    "\x03\xA6\x03\xA6\x03\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" +
+    "\x03\xA8\x03\xA8\x03\xA9\x03\xA9\x03\xA9\x03\xAA\x03\xAA\x03\xAA\x03\xAA" +
+    "\x05\xAA\u0581\n\xAA\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAC\x03\xAC\x03" +
+    "\xAC\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03\xAE\x03\xAE\x03\xAF\x03\xAF\x03" +
+    "\xB0\x03\xB0\x03\xB1\x03\xB1\x03\xB2\x03\xB2\x03\xB3\x03\xB3\x03\xB3\x03" +
+    "\xB3\x03\xB3\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB5\x03\xB5\x03" +
+    "\xB6\x03\xB6\x03\xB7\x03\xB7\x03\xB7\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" +
+    "\xB9\x03\xB9\x03\xBA\x03\xBA\x03\xBB\x03\xBB\x03\xBC\x03\xBC\x03\xBD\x03" +
+    "\xBD\x03\xBD\x03\xBE\x03\xBE\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x07\xBF\u05BE" +
+    "\n\xBF\f\xBF\x0E\xBF\u05C1\v\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF" +
+    "\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x05\xC0\u05CC\n\xC0\x03\xC0\x07\xC0\u05CF" +
+    "\n\xC0\f\xC0\x0E\xC0\u05D2\v\xC0\x03\xC0\x05\xC0\u05D5\n\xC0\x03\xC0\x03" +
+    "\xC0\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03" +
+    "\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x06\xC2\u05E8\n\xC2" +
+    "\r\xC2\x0E\xC2\u05E9\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC4\x03\xC4\x03" +
+    "\xC4\x03\xC4\x03\xC4\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x06\xC5\u05FA" +
+    "\n\xC5\r\xC5\x0E\xC5\u05FB\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC7\x03" +
+    "\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03" +
+    "\xC8\x03\xC8\x03\xC9\x03\xC9\x07\xC9\u0610\n\xC9\f\xC9\x0E\xC9\u0613\v" +
+    "\xC9\x03\xC9\x03\xC9\x03\xCA\x03\xCA\x03\xCA\x03\xCA\x03\xCB\x03\xCB\x03" +
+    "\xCB\x03\xCB\x03\xCC\x06\xCC\u0620\n\xCC\r\xCC\x0E\xCC\u0621\x03\xCC\x03" +
+    "\xCC\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCE\x03\xCE\x03\xCE\x03" +
+    "\xCE\x03\xCE\x03\xCF\x03\xCF\x07\xCF\u0632\n\xCF\f\xCF\x0E\xCF\u0635\v" +
+    "\xCF\x03\xCF\x03\xCF\x03\xD0\x06\xD0\u063A\n\xD0\r\xD0\x0E\xD0\u063B\x03" +
+    "\xD0\x03\xD0\x03\xD1\x06\xD1\u0641\n\xD1\r\xD1\x0E\xD1\u0642\x03\xD2\x03" +
+    "\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03" +
+    "\xD3\x03\xD3\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD5\x06\xD5\u0657" +
+    "\n\xD5\r\xD5\x0E\xD5\u0658\x03\xD5\x03\xD5\x03\u05BF\x02\x02\xD6\b\x02" +
+    "\x03\n\x02\x04\f\x02\x05\x0E\x02\x06\x10\x02\x07\x12\x02\b\x14\x02\t\x16" +
+    '\x02\n\x18\x02\v\x1A\x02\f\x1C\x02\r\x1E\x02\x0E \x02\x0F"\x02\x10$\x02' +
+    "\x11&\x02\x12(\x02\x13*\x02\x14,\x02\x15.\x02\x160\x02\x172\x02\x184\x02" +
+    "\x196\x02\x1A8\x02\x1B:\x02\x1C<\x02\x1D>\x02\x1E@\x02\x1FB\x02 D\x02" +
+    "!F\x02\"H\x02#J\x02$L\x02%N\x02&P\x02'R\x02(T\x02)V\x02*X\x02+Z\x02," +
+    "\\\x02-^\x02.`\x02/b\x020d\x021f\x022h\x023j\x024l\x025n\x026p\x027r\x02" +
+    "8t\x029v\x02:x\x02;z\x02<|\x02=~\x02>\x80\x02?\x82\x02@\x84\x02A\x86\x02" +
+    "B\x88\x02C\x8A\x02D\x8C\x02E\x8E\x02F\x90\x02G\x92\x02H\x94\x02I\x96\x02" +
+    "J\x98\x02K\x9A\x02L\x9C\x02M\x9E\x02N\xA0\x02O\xA2\x02P\xA4\x02Q\xA6\x02" +
+    "R\xA8\x02S\xAA\x02T\xAC\x02U\xAE\x02V\xB0\x02W\xB2\x02X\xB4\x02Y\xB6\x02" +
+    "Z\xB8\x02[\xBA\x02\\\xBC\x02]\xBE\x02^\xC0\x02_\xC2\x02`\xC4\x02a\xC6" +
+    "\x02b\xC8\x02c\xCA\x02d\xCC\x02e\xCE\x02f\xD0\x02g\xD2\x02h\xD4\x02i\xD6" +
+    "\x02j\xD8\x02k\xDA\x02l\xDC\x02m\xDE\x02n\xE0\x02o\xE2\x02p\xE4\x02q\xE6" +
+    "\x02r\xE8\x02s\xEA\x02\x02\xEC\x02\x02\xEE\x02\x02\xF0\x02\x02\xF2\x02" +
+    "\x02\xF4\x02\x02\xF6\x02\x02\xF8\x02\x02\xFA\x02\x02\xFC\x02\x02\xFE\x02" +
+    "\x02\u0100\x02\x02\u0102\x02\x02\u0104\x02\x02\u0106\x02\x02\u0108\x02" +
+    "\x02\u010A\x02\x02\u010C\x02\x02\u010E\x02\x02\u0110\x02\x02\u0112\x02" +
+    "\x02\u0114\x02\x02\u0116\x02\x02\u0118\x02\x02\u011A\x02\x02\u011C\x02" +
+    "\x02\u011E\x02\x02\u0120\x02\x02\u0122\x02\x02\u0124\x02\x02\u0126\x02" +
+    "t\u0128\x02u\u012A\x02v\u012C\x02w\u012E\x02x\u0130\x02y\u0132\x02z\u0134" +
+    "\x02{\u0136\x02|\u0138\x02}\u013A\x02~\u013C\x02\x7F\u013E\x02\x80\u0140" +
+    "\x02\x81\u0142\x02\x82\u0144\x02\x83\u0146\x02\x84\u0148\x02\x85\u014A" +
+    "\x02\x86\u014C\x02\x87\u014E\x02\x88\u0150\x02\x02\u0152\x02\x02\u0154" +
+    "\x02\x89\u0156\x02\x8A\u0158\x02\x8B\u015A\x02\x8C\u015C\x02\x8D\u015E" +
+    "\x02\x8E\u0160\x02\x8F\u0162\x02\x90\u0164\x02\x91\u0166\x02\x92\u0168" +
+    "\x02\x93\u016A\x02\x94\u016C\x02\x95\u016E\x02\x96\u0170\x02\x97\u0172" +
+    "\x02\x98\u0174\x02\x99\u0176\x02\x9A\u0178\x02\x9B\u017A\x02\x9C\u017C" +
+    "\x02\x9D\u017E\x02\x9E\u0180\x02\x9F\u0182\x02\xA0\u0184\x02\xA1\u0186" +
+    "\x02\xA2\u0188\x02\xA3\u018A\x02\xA4\u018C\x02\x02\u018E\x02\xA5\u0190" +
+    "\x02\xA6\u0192\x02\x02\u0194\x02\x02\u0196\x02\x02\u0198\x02\x02\u019A" +
+    "\x02\x02\u019C\x02\xA7\u019E\x02\x02\u01A0\x02\x02\u01A2\x02\x02\u01A4" +
+    "\x02\xA8\u01A6\x02\xA9\u01A8\x02\x02\u01AA\x02\x02\u01AC\x02\x02\u01AE" +
+    "\x02\xAA\b\x02\x03\x04\x05\x06\x07,\x04\x02^^bb\x04\x02$$^^\x04\x02))" +
+    "^^\x04\x02CCcc\x04\x02DDdd\x04\x02EEee\x04\x02FFff\x04\x02GGgg\x04\x02" +
+    "HHhh\x04\x02IIii\x04\x02JJjj\x04\x02KKkk\x04\x02LLll\x04\x02MMmm\x04\x02" +
+    "NNnn\x04\x02OOoo\x04\x02PPpp\x04\x02QQqq\x04\x02RRrr\x04\x02SSss\x04\x02" +
+    "TTtt\x04\x02UUuu\x04\x02VVvv\x04\x02WWww\x04\x02XXxx\x04\x02YYyy\x04\x02" +
+    "ZZzz\x04\x02[[{{\x04\x02\\\\||\x04\x02C\\c|\x03\x0229\x03\x022;\x05\x02" +
+    '2;CHch\x04\x02\f\f\x0F\x0F\x04\x03\f\f\x0F\x0F\x04\x02\v\x0F""\x05\x02' +
+    "))^^}}\x03\x02}}\x05\x02C\\aac|\x07\x02//2;C\\aac|\x05\x02\v\f\x0F\x0F" +
+    '""\x04\x02>>}}\x02\u0683\x02\b\x03\x02\x02\x02\x02\n\x03\x02\x02\x02' +
+    "\x02\f\x03\x02\x02\x02\x02\x0E\x03\x02\x02\x02\x02\x10\x03\x02\x02\x02" +
+    "\x02\x12\x03\x02\x02\x02\x02\x14\x03\x02\x02\x02\x02\x16\x03\x02\x02\x02" +
+    "\x02\x18\x03\x02\x02\x02\x02\x1A\x03\x02\x02\x02\x02\x1C\x03\x02\x02\x02" +
+    '\x02\x1E\x03\x02\x02\x02\x02 \x03\x02\x02\x02\x02"\x03\x02\x02\x02\x02' +
+    "$\x03\x02\x02\x02\x02&\x03\x02\x02\x02\x02(\x03\x02\x02\x02\x02*\x03\x02" +
+    "\x02\x02\x02,\x03\x02\x02\x02\x02.\x03\x02\x02\x02\x020\x03\x02\x02\x02" +
+    "\x022\x03\x02\x02\x02\x024\x03\x02\x02\x02\x026\x03\x02\x02\x02\x028\x03" +
+    "\x02\x02\x02\x02:\x03\x02\x02\x02\x02<\x03\x02\x02\x02\x02>\x03\x02\x02" +
+    "\x02\x02@\x03\x02\x02\x02\x02B\x03\x02\x02\x02\x02D\x03\x02\x02\x02\x02" +
+    "F\x03\x02\x02\x02\x02H\x03\x02\x02\x02\x02J\x03\x02\x02\x02\x02L\x03\x02" +
+    "\x02\x02\x02N\x03\x02\x02\x02\x02P\x03\x02\x02\x02\x02R\x03\x02\x02\x02" +
+    "\x02T\x03\x02\x02\x02\x02V\x03\x02\x02\x02\x02X\x03\x02\x02\x02\x02Z\x03" +
+    "\x02\x02\x02\x02\\\x03\x02\x02\x02\x02^\x03\x02\x02\x02\x02`\x03\x02\x02" +
+    "\x02\x02b\x03\x02\x02\x02\x02d\x03\x02\x02\x02\x02f\x03\x02\x02\x02\x02" +
+    "h\x03\x02\x02\x02\x02j\x03\x02\x02\x02\x02l\x03\x02\x02\x02\x02n\x03\x02" +
+    "\x02\x02\x02p\x03\x02\x02\x02\x02r\x03\x02\x02\x02\x02t\x03\x02\x02\x02" +
+    "\x02v\x03\x02\x02\x02\x02x\x03\x02\x02\x02\x02z\x03\x02\x02\x02\x02|\x03" +
+    "\x02\x02\x02\x02~\x03\x02\x02\x02\x02\x80\x03\x02\x02\x02\x02\x82\x03" +
+    "\x02\x02\x02\x02\x84\x03\x02\x02\x02\x02\x86\x03\x02\x02\x02\x02\x88\x03" +
+    "\x02\x02\x02\x02\x8A\x03\x02\x02\x02\x02\x8C\x03\x02\x02\x02\x02\x8E\x03" +
+    "\x02\x02\x02\x02\x90\x03\x02\x02\x02\x02\x92\x03\x02\x02\x02\x02\x94\x03" +
+    "\x02\x02\x02\x02\x96\x03\x02\x02\x02\x02\x98\x03\x02\x02\x02\x02\x9A\x03" +
+    "\x02\x02\x02\x02\x9C\x03\x02\x02\x02\x02\x9E\x03\x02\x02\x02\x02\xA0\x03" +
+    "\x02\x02\x02\x02\xA2\x03\x02\x02\x02\x02\xA4\x03\x02\x02\x02\x02\xA6\x03" +
+    "\x02\x02\x02\x02\xA8\x03\x02\x02\x02\x02\xAA\x03\x02\x02\x02\x02\xAC\x03" +
+    "\x02\x02\x02\x02\xAE\x03\x02\x02\x02\x02\xB0\x03\x02\x02\x02\x02\xB2\x03" +
+    "\x02\x02\x02\x02\xB4\x03\x02\x02\x02\x02\xB6\x03\x02\x02\x02\x02\xB8\x03" +
+    "\x02\x02\x02\x02\xBA\x03\x02\x02\x02\x02\xBC\x03\x02\x02\x02\x02\xBE\x03" +
+    "\x02\x02\x02\x02\xC0\x03\x02\x02\x02\x02\xC2\x03\x02\x02\x02\x02\xC4\x03" +
+    "\x02\x02\x02\x02\xC6\x03\x02\x02\x02\x02\xC8\x03\x02\x02\x02\x02\xCA\x03" +
+    "\x02\x02\x02\x02\xCC\x03\x02\x02\x02\x02\xCE\x03\x02\x02\x02\x02\xD0\x03" +
+    "\x02\x02\x02\x02\xD2\x03\x02\x02\x02\x02\xD4\x03\x02\x02\x02\x02\xD6\x03" +
+    "\x02\x02\x02\x02\xD8\x03\x02\x02\x02\x02\xDA\x03\x02\x02\x02\x02\xDC\x03" +
+    "\x02\x02\x02\x02\xDE\x03\x02\x02\x02\x02\xE0\x03\x02\x02\x02\x02\xE2\x03" +
+    "\x02\x02\x02\x02\xE4\x03\x02\x02\x02\x02\xE6\x03\x02\x02\x02\x02\xE8\x03" +
+    "\x02\x02\x02\x02\u0126\x03\x02\x02\x02\x02\u0128\x03\x02\x02\x02\x02\u012A" +
+    "\x03\x02\x02\x02\x02\u012C\x03\x02\x02\x02\x02\u012E\x03\x02\x02\x02\x02" +
+    "\u0130\x03\x02\x02\x02\x02\u0132\x03\x02\x02\x02\x02\u0134\x03\x02\x02" +
+    "\x02\x02\u0136\x03\x02\x02\x02\x02\u0138\x03\x02\x02\x02\x02\u013A\x03" +
+    "\x02\x02\x02\x02\u013C\x03\x02\x02\x02\x02\u013E\x03\x02\x02\x02\x02\u0140" +
+    "\x03\x02";
+  private static readonly _serializedATNSegment1: string =
+    "\x02\x02\x02\u0142\x03\x02\x02\x02\x02\u0144\x03\x02\x02\x02\x02\u0146" +
+    "\x03\x02\x02\x02\x02\u0148\x03\x02\x02\x02\x02\u014A\x03\x02\x02\x02\x02" +
+    "\u014C\x03\x02\x02\x02\x02\u014E\x03\x02\x02\x02\x02\u0150\x03\x02\x02" +
+    "\x02\x02\u0152\x03\x02\x02\x02\x02\u0154\x03\x02\x02\x02\x02\u0156\x03" +
+    "\x02\x02\x02\x02\u0158\x03\x02\x02\x02\x02\u015A\x03\x02\x02\x02\x02\u015C" +
+    "\x03\x02\x02\x02\x02\u015E\x03\x02\x02\x02\x02\u0160\x03\x02\x02\x02\x02" +
+    "\u0162\x03\x02\x02\x02\x02\u0164\x03\x02\x02\x02\x02\u0166\x03\x02\x02" +
+    "\x02\x02\u0168\x03\x02\x02\x02\x02\u016A\x03\x02\x02\x02\x02\u016C\x03" +
+    "\x02\x02\x02\x02\u016E\x03\x02\x02\x02\x02\u0170\x03\x02\x02\x02\x02\u0172" +
+    "\x03\x02\x02\x02\x02\u0174\x03\x02\x02\x02\x02\u0176\x03\x02\x02\x02\x02" +
+    "\u0178\x03\x02\x02\x02\x02\u017A\x03\x02\x02\x02\x02\u017C\x03\x02\x02" +
+    "\x02\x02\u017E\x03\x02\x02\x02\x02\u0180\x03\x02\x02\x02\x02\u0182\x03" +
+    "\x02\x02\x02\x02\u0184\x03\x02\x02\x02\x02\u0186\x03\x02\x02\x02\x03\u0188" +
+    "\x03\x02\x02\x02\x03\u018A\x03\x02\x02\x02\x03\u018C\x03\x02\x02\x02\x04" +
+    "\u018E\x03\x02\x02\x02\x04\u0190\x03\x02\x02\x02\x05\u0192\x03\x02\x02" +
+    "\x02\x05\u0194\x03\x02\x02\x02\x05\u0196\x03\x02\x02\x02\x05\u0198\x03" +
+    "\x02\x02\x02\x05\u019A\x03\x02\x02\x02\x05\u019C\x03\x02\x02\x02\x05\u019E" +
+    "\x03\x02\x02\x02\x06\u01A0\x03\x02\x02\x02\x06\u01A2\x03\x02\x02\x02\x06" +
+    "\u01A4\x03\x02\x02\x02\x07\u01A6\x03\x02\x02\x02\x07\u01A8\x03\x02\x02" +
+    "\x02\x07\u01AA\x03\x02\x02\x02\x07\u01AC\x03\x02\x02\x02\x07\u01AE\x03" +
+    "\x02\x02\x02\b\u01B0\x03\x02\x02\x02\n\u01B4\x03\x02\x02\x02\f\u01B8\x03" +
+    "\x02\x02\x02\x0E\u01BD\x03\x02\x02\x02\x10\u01C1\x03\x02\x02\x02\x12\u01C7" +
+    "\x03\x02\x02\x02\x14\u01D8\x03\x02\x02\x02\x16\u01DA\x03\x02\x02\x02\x18" +
+    "\u01DF\x03\x02\x02\x02\x1A\u01E7\x03\x02\x02\x02\x1C\u01EC\x03\x02\x02" +
+    '\x02\x1E\u01EF\x03\x02\x02\x02 \u01F4\x03\x02\x02\x02"\u01F9\x03\x02' +
+    "\x02\x02$\u01FF\x03\x02\x02\x02&\u0206\x03\x02\x02\x02(\u020E\x03\x02" +
+    "\x02\x02*\u0214\x03\x02\x02\x02,\u0219\x03\x02\x02\x02.\u0221\x03\x02" +
+    "\x02\x020\u0226\x03\x02\x02\x022\u022A\x03\x02\x02\x024\u022F\x03\x02" +
+    "\x02\x026\u023A\x03\x02\x02\x028\u0243\x03\x02\x02\x02:\u0248\x03\x02" +
+    "\x02\x02<\u024C\x03\x02\x02\x02>\u0253\x03\x02\x02\x02@\u025B\x03\x02" +
+    "\x02\x02B\u0261\x03\x02\x02\x02D\u0269\x03\x02\x02\x02F\u026F\x03\x02" +
+    "\x02\x02H\u0272\x03\x02\x02\x02J\u027C\x03\x02\x02\x02L\u0280\x03\x02" +
+    "\x02\x02N\u0285\x03\x02\x02\x02P\u028A\x03\x02\x02\x02R\u028E\x03\x02" +
+    "\x02\x02T\u0294\x03\x02\x02\x02V\u029B\x03\x02\x02\x02X\u02A0\x03\x02" +
+    "\x02\x02Z\u02A3\x03\x02\x02\x02\\\u02A6\x03\x02\x02\x02^\u02AC\x03\x02" +
+    "\x02\x02`\u02BC\x03\x02\x02\x02b\u02BE\x03\x02\x02\x02d\u02C4\x03\x02" +
+    "\x02\x02f\u02CE\x03\x02\x02\x02h\u02D7\x03\x02\x02\x02j\u02DA\x03\x02" +
+    "\x02\x02l\u02DF\x03\x02\x02\x02n\u02E3\x03\x02\x02\x02p\u02E8\x03\x02" +
+    "\x02\x02r\u02F0\x03\x02\x02\x02t\u02F5\x03\x02\x02\x02v\u02F9\x03\x02" +
+    "\x02\x02x\u02FE\x03\x02\x02\x02z\u0304\x03\x02\x02\x02|\u030B\x03\x02" +
+    "\x02\x02~\u0311\x03\x02\x02\x02\x80\u0315\x03\x02\x02\x02\x82\u0319\x03" +
+    "\x02\x02\x02\x84\u031E\x03\x02\x02\x02\x86\u0324\x03\x02\x02\x02\x88\u032B" +
+    "\x03\x02\x02\x02\x8A\u032E\x03\x02\x02\x02\x8C\u0331\x03\x02\x02\x02\x8E" +
+    "\u0337\x03\x02\x02\x02\x90\u033D\x03\x02\x02\x02\x92\u0342\x03\x02\x02" +
+    "\x02\x94\u034C\x03\x02\x02\x02\x96\u0356\x03\x02\x02\x02\x98\u035F\x03" +
+    "\x02\x02\x02\x9A\u0367\x03\x02\x02\x02\x9C\u036D\x03\x02\x02\x02\x9E\u0374" +
+    "\x03\x02\x02\x02\xA0\u037A\x03\x02\x02\x02\xA2\u0381\x03\x02\x02\x02\xA4" +
+    "\u0385\x03\x02\x02\x02\xA6\u038A\x03\x02\x02\x02\xA8\u0391\x03\x02\x02" +
+    "\x02\xAA\u0398\x03\x02\x02\x02\xAC\u039F\x03\x02\x02\x02\xAE\u03A4\x03" +
+    "\x02\x02\x02\xB0\u03AD\x03\x02\x02\x02\xB2\u03B7\x03\x02\x02\x02\xB4\u03BC" +
+    "\x03\x02\x02\x02\xB6\u03C2\x03\x02\x02\x02\xB8\u03C7\x03\x02\x02\x02\xBA" +
+    "\u03D1\x03\x02\x02\x02\xBC\u03D4\x03\x02\x02\x02\xBE\u03D8\x03\x02\x02" +
+    "\x02\xC0\u03DF\x03\x02\x02\x02\xC2\u03E8\x03\x02\x02\x02\xC4\u03ED\x03" +
+    "\x02\x02\x02\xC6\u03F6\x03\x02\x02\x02\xC8\u03FA\x03\x02\x02\x02\xCA\u0404" +
+    "\x03\x02\x02\x02\xCC\u040A\x03\x02\x02\x02\xCE\u0410\x03\x02\x02\x02\xD0" +
+    "\u0415\x03\x02\x02\x02\xD2\u041A\x03\x02\x02\x02\xD4\u0420\x03\x02\x02" +
+    "\x02\xD6\u0426\x03\x02\x02\x02\xD8\u042D\x03\x02\x02\x02\xDA\u043C\x03" +
+    "\x02\x02\x02\xDC\u0459\x03\x02\x02\x02\xDE\u0489\x03\x02\x02\x02\xE0\u04D7" +
+    "\x03\x02\x02\x02\xE2\u04D9\x03\x02\x02\x02\xE4\u04E0\x03\x02\x02\x02\xE6" +
+    "\u04E4\x03\x02\x02\x02\xE8\u04EB\x03\x02\x02\x02\xEA\u04FB\x03\x02\x02" +
+    "\x02\xEC\u04FD\x03\x02\x02\x02\xEE\u04FF\x03\x02\x02\x02\xF0\u0501\x03" +
+    "\x02\x02\x02\xF2\u0503\x03\x02\x02\x02\xF4\u0505\x03\x02\x02\x02\xF6\u0507" +
+    "\x03\x02\x02\x02\xF8\u0509\x03\x02\x02\x02\xFA\u050B\x03\x02\x02\x02\xFC" +
+    "\u050D\x03\x02\x02\x02\xFE\u050F\x03\x02\x02\x02\u0100\u0511\x03\x02\x02" +
+    "\x02\u0102\u0513\x03\x02\x02\x02\u0104\u0515\x03\x02\x02\x02\u0106\u0517" +
+    "\x03\x02\x02\x02\u0108\u0519\x03\x02\x02\x02\u010A\u051B\x03\x02\x02\x02" +
+    "\u010C\u051D\x03\x02\x02\x02\u010E\u051F\x03\x02\x02\x02\u0110\u0521\x03" +
+    "\x02\x02\x02\u0112\u0523\x03\x02\x02\x02\u0114\u0525\x03\x02\x02\x02\u0116" +
+    "\u0527\x03\x02\x02\x02\u0118\u0529\x03\x02\x02\x02\u011A\u052B\x03\x02" +
+    "\x02\x02\u011C\u052D\x03\x02\x02\x02\u011E\u052F\x03\x02\x02\x02\u0120" +
+    "\u0531\x03\x02\x02\x02\u0122\u0533\x03\x02\x02\x02\u0124\u0535\x03\x02" +
+    "\x02\x02\u0126\u0537\x03\x02\x02\x02\u0128\u053A\x03\x02\x02\x02\u012A" +
+    "\u053C\x03\x02\x02\x02\u012C\u053E\x03\x02\x02\x02\u012E\u0540\x03\x02" +
+    "\x02\x02\u0130\u0542\x03\x02\x02\x02\u0132\u0544\x03\x02\x02\x02\u0134" +
+    "\u0547\x03\x02\x02\x02\u0136\u0549\x03\x02\x02\x02\u0138\u054B\x03\x02" +
+    "\x02\x02\u013A\u054D\x03\x02\x02\x02\u013C\u0550\x03\x02\x02\x02\u013E" +
+    "\u0552\x03\x02\x02\x02\u0140\u0555\x03\x02\x02\x02\u0142\u0557\x03\x02" +
+    "\x02\x02\u0144\u0559\x03\x02\x02\x02\u0146\u055C\x03\x02\x02\x02\u0148" +
+    "\u0560\x03\x02\x02\x02\u014A\u0564\x03\x02\x02\x02\u014C\u0566\x03\x02" +
+    "\x02\x02\u014E\u0568\x03\x02\x02\x02\u0150\u056B\x03\x02\x02\x02\u0152" +
+    "\u0571\x03\x02\x02\x02\u0154\u0577\x03\x02\x02\x02\u0156\u0579\x03\x02" +
+    "\x02\x02\u0158\u0580\x03\x02\x02\x02\u015A\u0582\x03\x02\x02\x02\u015C" +
+    "\u0586\x03\x02\x02\x02\u015E\u0589\x03\x02\x02\x02\u0160\u058C\x03\x02" +
+    "\x02\x02\u0162\u058F\x03\x02\x02\x02\u0164\u0591\x03\x02\x02\x02\u0166" +
+    "\u0593\x03\x02\x02\x02\u0168\u0595\x03\x02\x02\x02\u016A\u0597\x03\x02" +
+    "\x02\x02\u016C\u059C\x03\x02\x02\x02\u016E\u05A1\x03\x02\x02\x02\u0170" +
+    "\u05A3\x03\x02\x02\x02\u0172\u05A5\x03\x02\x02\x02\u0174\u05A8\x03\x02" +
+    "\x02\x02\u0176\u05AC\x03\x02\x02\x02\u0178\u05AE\x03\x02\x02\x02\u017A" +
+    "\u05B0\x03\x02\x02\x02\u017C\u05B2\x03\x02\x02\x02\u017E\u05B4\x03\x02" +
+    "\x02\x02\u0180\u05B7\x03\x02\x02\x02\u0182\u05B9\x03\x02\x02\x02\u0184" +
+    "\u05CB\x03\x02\x02\x02\u0186\u05D8\x03\x02\x02\x02\u0188\u05E7\x03\x02" +
+    "\x02\x02\u018A\u05EB\x03\x02\x02\x02\u018C\u05EF\x03\x02\x02\x02\u018E" +
+    "\u05F9\x03\x02\x02\x02\u0190\u05FD\x03\x02\x02\x02\u0192\u0601\x03\x02" +
+    "\x02\x02\u0194\u0607\x03\x02\x02\x02\u0196\u060D\x03\x02\x02\x02\u0198" +
+    "\u0616\x03\x02\x02\x02\u019A\u061A\x03\x02\x02\x02\u019C\u061F\x03\x02" +
+    "\x02\x02\u019E\u0625\x03\x02\x02\x02\u01A0\u062A\x03\x02\x02\x02\u01A2" +
+    "\u062F\x03\x02\x02\x02\u01A4\u0639\x03\x02\x02\x02\u01A6\u0640\x03\x02" +
+    "\x02\x02\u01A8\u0644\x03\x02\x02\x02\u01AA\u0649\x03\x02\x02\x02\u01AC" +
+    "\u0650\x03\x02\x02\x02\u01AE\u0656\x03\x02\x02\x02\u01B0\u01B1\x05\xEA" +
+    "s\x02\u01B1\u01B2\x05\u0100~\x02\u01B2\u01B3\x05\u0100~\x02\u01B3\t\x03" +
+    "\x02\x02\x02\u01B4\u01B5\x05\xEAs\x02\u01B5\u01B6\x05\u0104\x80\x02\u01B6" +
+    "\u01B7\x05\xF0v\x02\u01B7\v\x03\x02\x02\x02\u01B8\u01B9\x05\xEAs\x02\u01B9" +
+    "\u01BA\x05\u0104\x80\x02\u01BA\u01BB\x05\u0110\x86\x02\u01BB\u01BC\x05" +
+    "\xFA{\x02\u01BC\r\x03\x02\x02\x02\u01BD\u01BE\x05\xEAs\x02\u01BE\u01BF" +
+    "\x05\u0104\x80\x02\u01BF\u01C0\x05\u011A\x8B\x02\u01C0\x0F\x03\x02\x02" +
+    "\x02\u01C1\u01C2\x05\xEAs\x02\u01C2\u01C3\x05\u010C\x84\x02\u01C3\u01C4" +
+    "\x05\u010C\x84\x02\u01C4\u01C5\x05\xEAs\x02\u01C5\u01C6\x05\u011A\x8B" +
+    "\x02\u01C6\x11\x03\x02\x02\x02\u01C7\u01C8\x05\xEAs\x02\u01C8\u01C9\x05" +
+    "\u010E\x85\x02\u01C9\x13\x03\x02\x02\x02\u01CA\u01CB\x05\xEAs\x02\u01CB" +
+    "\u01CC\x05\u010E\x85\x02\u01CC\u01CD\x05\xEEu\x02\u01CD\u01D9\x03\x02" +
+    "\x02\x02\u01CE\u01CF\x05\xEAs\x02\u01CF\u01D0\x05\u010E\x85\x02\u01D0" +
+    "\u01D1\x05\xEEu\x02\u01D1\u01D2\x05\xF2w\x02\u01D2\u01D3\x05\u0104\x80" +
+    "\x02\u01D3\u01D4\x05\xF0v\x02\u01D4\u01D5\x05\xFA{\x02\u01D5\u01D6\x05" +
+    "\u0104\x80\x02\u01D6\u01D7\x05\xF6y\x02\u01D7\u01D9\x03\x02\x02\x02\u01D8" +
+    "\u01CA\x03\x02\x02\x02\u01D8\u01CE\x03\x02\x02\x02\u01D9\x15\x03\x02\x02" +
+    "\x02\u01DA\u01DB\x05\xEAs\x02\u01DB\u01DC\x05\u010E\x85\x02\u01DC\u01DD" +
+    "\x05\u0106\x81\x02\u01DD\u01DE\x05\xF4x\x02\u01DE\x17\x03\x02\x02\x02" +
+    "\u01DF\u01E0\x05\xECt\x02\u01E0\u01E1\x05\xF2w\x02\u01E1\u01E2\x05\u0110" +
+    "\x86\x02\u01E2\u01E3\x05\u0116\x89\x02\u01E3\u01E4\x05\xF2w\x02\u01E4" +
+    "\u01E5\x05\xF2w\x02\u01E5\u01E6\x05\u0104\x80\x02\u01E6\x19\x03\x02\x02" +
+    "\x02\u01E7\u01E8\x05\xECt\x02\u01E8\u01E9\x05\u0106\x81\x02\u01E9\u01EA" +
+    "\x05\u0110\x86\x02\u01EA\u01EB\x05\xF8z\x02\u01EB\x1B\x03\x02\x02\x02" +
+    "\u01EC\u01ED\x05\xECt\x02\u01ED\u01EE\x05\u011A\x8B\x02\u01EE\x1D\x03" +
+    "\x02\x02\x02\u01EF\u01F0\x05\xEEu\x02\u01F0\u01F1\x05\xEAs\x02\u01F1\u01F2" +
+    "\x05\u010E\x85\x02\u01F2\u01F3\x05\xF2w\x02\u01F3\x1F\x03\x02\x02\x02" +
+    "\u01F4\u01F5\x05\xEEu\x02\u01F5\u01F6\x05\xEAs\x02\u01F6\u01F7\x05\u010E" +
+    "\x85\x02\u01F7\u01F8\x05\u0110\x86\x02\u01F8!\x03\x02\x02\x02\u01F9\u01FA" +
+    "\x05\xEEu\x02\u01FA\u01FB\x05\xEAs\x02\u01FB\u01FC\x05\u0110\x86\x02\u01FC" +
+    "\u01FD\x05\xEEu\x02\u01FD\u01FE\x05\xF8z\x02\u01FE#\x03\x02\x02\x02\u01FF" +
+    "\u0200\x05\xEEu\x02\u0200\u0201\x05\u0106\x81\x02\u0201\u0202\x05\xF8" +
+    "z\x02\u0202\u0203\x05\u0106\x81\x02\u0203\u0204\x05\u010C\x84\x02\u0204" +
+    "\u0205\x05\u0110\x86\x02\u0205%\x03\x02\x02\x02\u0206\u0207\x05\xEEu\x02" +
+    "\u0207\u0208\x05\u0106\x81\x02\u0208\u0209\x05\u0100~\x02\u0209\u020A" +
+    "\x05\u0100~\x02\u020A\u020B\x05\xEAs\x02\u020B\u020C\x05\u0110\x86\x02" +
+    "\u020C\u020D\x05\xF2w\x02\u020D'\x03\x02\x02\x02\u020E\u020F\x05\xEE" +
+    "u\x02\u020F\u0210\x05\u010C\x84\x02\u0210\u0211\x05\u0106\x81\x02\u0211" +
+    "\u0212\x05\u010E\x85\x02\u0212\u0213\x05\u010E\x85\x02\u0213)\x03\x02" +
+    "\x02\x02\u0214\u0215\x05\xEEu\x02\u0215\u0216\x05\u0112\x87\x02\u0216" +
+    "\u0217\x05\xECt\x02\u0217\u0218\x05\xF2w\x02\u0218+\x03\x02\x02\x02\u0219" +
+    "\u021A\x05\xEEu\x02\u021A\u021B\x05\u0112\x87\x02\u021B\u021C\x05\u010C" +
+    "\x84\x02\u021C\u021D\x05\u010C\x84\x02\u021D\u021E\x05\xF2w\x02\u021E" +
+    "\u021F\x05\u0104\x80\x02\u021F\u0220\x05\u0110\x86\x02\u0220-\x03\x02" +
+    "\x02\x02\u0221\u0222\x05\xF0v\x02\u0222\u0223\x05\xEAs\x02\u0223\u0224" +
+    "\x05\u0110\x86\x02\u0224\u0225\x05\xF2w\x02\u0225/\x03\x02\x02\x02\u0226" +
+    "\u0227\x05\xF0v\x02\u0227\u0228\x05\xEAs\x02\u0228\u0229\x05\u011A\x8B" +
+    "\x02\u02291\x03\x02\x02\x02\u022A\u022B\x05\xF0v\x02\u022B\u022C\x05\xF2" +
+    "w\x02\u022C\u022D\x05\u010E\x85\x02\u022D\u022E\x05\xEEu\x02\u022E3\x03" +
+    "\x02\x02\x02\u022F\u0230\x05\xF0v\x02\u0230\u0231\x05\xF2w\x02\u0231\u0232" +
+    "\x05\u010E\x85\x02\u0232\u0233\x05\xEEu\x02\u0233\u0234\x05\xF2w\x02\u0234" +
+    "\u0235\x05\u0104\x80\x02\u0235\u0236\x05\xF0v\x02\u0236\u0237\x05\xFA" +
+    "{\x02\u0237\u0238\x05\u0104\x80\x02\u0238\u0239\x05\xF6y\x02\u02395\x03" +
+    "\x02\x02\x02\u023A\u023B\x05\xF0v\x02\u023B\u023C\x05\xFA{\x02\u023C\u023D" +
+    "\x05\u010E\x85\x02\u023D\u023E\x05\u0110\x86\x02\u023E\u023F\x05\xFA{" +
+    "\x02\u023F\u0240\x05\u0104\x80\x02\u0240\u0241\x05\xEEu\x02\u0241\u0242" +
+    "\x05\u0110\x86\x02\u02427\x03\x02\x02\x02\u0243\u0244\x05\xF2w\x02\u0244" +
+    "\u0245\x05\u0100~\x02\u0245\u0246\x05\u010E\x85\x02\u0246\u0247\x05\xF2" +
+    "w\x02\u02479\x03\x02\x02\x02\u0248\u0249\x05\xF2w\x02\u0249\u024A\x05" +
+    "\u0104\x80\x02\u024A\u024B\x05\xF0v\x02\u024B;\x03\x02\x02\x02\u024C\u024D" +
+    "\x05\xF2w\x02\u024D\u024E\x05\u0118\x8A\x02\u024E\u024F\x05\xEEu\x02\u024F" +
+    "\u0250\x05\xF2w\x02\u0250\u0251\x05\u0108\x82\x02\u0251\u0252\x05\u0110" +
+    "\x86\x02\u0252=\x03\x02\x02\x02\u0253\u0254\x05\xF2w\x02\u0254\u0255\x05" +
+    "\u0118\x8A\x02\u0255\u0256\x05\u0110\x86\x02\u0256\u0257\x05\u010C\x84" +
+    "\x02\u0257\u0258\x05\xEAs\x02\u0258\u0259\x05\xEEu\x02\u0259\u025A\x05" +
+    "\u0110\x86\x02\u025A?\x03\x02\x02\x02\u025B\u025C\x05\xF4x\x02\u025C\u025D" +
+    "\x05\xFA{\x02\u025D\u025E\x05\u0104\x80\x02\u025E\u025F\x05\xEAs\x02\u025F" +
+    "\u0260\x05\u0100~\x02\u0260A\x03\x02\x02\x02\u0261\u0262\x05\xF4x\x02" +
+    "\u0262\u0263\x05\xFA{\x02\u0263\u0264\x05\u0104\x80\x02\u0264\u0265\x05" +
+    "\xEAs\x02\u0265\u0266\x05\u0100~\x02\u0266\u0267\x05\u0100~\x02\u0267" +
+    "\u0268\x05\u011A\x8B\x02\u0268C\x03\x02\x02\x02\u0269\u026A\x05\xF4x\x02" +
+    "\u026A\u026B\x05\xFA{\x02\u026B\u026C\x05\u010C\x84\x02\u026C\u026D\x05" +
+    "\u010E\x85\x02\u026D\u026E\x05\u0110\x86\x02\u026EE\x03\x02\x02\x02\u026F" +
+    "\u0270\x05\xF4x\x02\u0270\u0271\x05\u0104\x80\x02\u0271G\x03\x02\x02\x02" +
+    "\u0272\u0273\x05\xF4x\x02\u0273\u0274\x05\u0106\x81\x02\u0274\u0275\x05" +
+    "\u0100~\x02\u0275\u0276\x05\u0100~\x02\u0276\u0277\x05\u0106\x81\x02\u0277" +
+    "\u0278\x05\u0116\x89\x02\u0278\u0279\x05\xFA{\x02\u0279\u027A\x05\u0104" +
+    "\x80\x02\u027A\u027B\x05\xF6y\x02\u027BI\x03\x02\x02\x02\u027C\u027D\x05" +
+    "\xF4x\x02\u027D\u027E\x05\u0106\x81\x02\u027E\u027F\x05\u010C\x84\x02" +
+    "\u027FK\x03\x02\x02\x02\u0280\u0281\x05\xF4x\x02\u0281\u0282\x05\u010C" +
+    "\x84\x02\u0282\u0283\x05\u0106\x81\x02\u0283\u0284\x05\u0102\x7F\x02\u0284" +
+    "M\x03\x02\x02\x02\u0285\u0286\x05\xF4x\x02\u0286\u0287\x05\u0112\x87\x02" +
+    "\u0287\u0288\x05\u0100~\x02\u0288\u0289\x05\u0100~\x02\u0289O\x03\x02" +
+    "\x02\x02\u028A\u028B\x05\xF4x\x02\u028B\u028C\x05\u0112\x87\x02\u028C" +
+    "\u028D\x05\u0104\x80\x02\u028DQ\x03\x02\x02\x02\u028E\u028F\x05\xF6y\x02" +
+    "\u028F\u0290\x05\u010C\x84\x02\u0290\u0291\x05\u0106\x81\x02\u0291\u0292" +
+    "\x05\u0112\x87\x02\u0292\u0293\x05\u0108\x82\x02\u0293S\x03\x02\x02\x02" +
+    "\u0294\u0295\x05\xF8z\x02\u0295\u0296\x05\xEAs\x02\u0296\u0297\x05\u0114" +
+    "\x88\x02\u0297\u0298\x05\xFA{\x02\u0298\u0299\x05\u0104\x80\x02\u0299" +
+    "\u029A\x05\xF6y\x02\u029AU\x03\x02\x02\x02\u029B\u029C\x05\xF8z\x02\u029C" +
+    "\u029D\x05\u0106\x81\x02\u029D\u029E\x05\u0112\x87\x02\u029E\u029F\x05" +
+    "\u010C\x84\x02\u029FW\x03\x02\x02\x02\u02A0\u02A1\x05\xFA{\x02\u02A1\u02A2" +
+    "\x05\xF0v\x02\u02A2Y\x03\x02\x02\x02\u02A3\u02A4\x05\xFA{\x02\u02A4\u02A5" +
+    "\x05\xF4x\x02\u02A5[\x03\x02\x02\x02\u02A6\u02A7\x05\xFA{\x02\u02A7\u02A8" +
+    "\x05\u0100~\x02\u02A8\u02A9\x05\xFA{\x02\u02A9\u02AA\x05\xFE}\x02\u02AA" +
+    "\u02AB\x05\xF2w\x02\u02AB]\x03\x02\x02\x02\u02AC\u02AD\x05\xFA{\x02\u02AD" +
+    "\u02AE\x05\u0104\x80\x02\u02AE_\x03\x02\x02\x02\u02AF\u02B0\x05\xFA{\x02" +
+    "\u02B0\u02B1\x05\u0104\x80\x02\u02B1\u02B2\x05\xF4x\x02\u02B2\u02BD\x03" +
+    "\x02\x02\x02\u02B3\u02B4\x05\xFA{\x02\u02B4\u02B5\x05\u0104\x80\x02\u02B5" +
+    "\u02B6\x05\xF4x\x02\u02B6\u02B7\x05\xFA{\x02\u02B7\u02B8\x05\u0104\x80" +
+    "\x02\u02B8\u02B9\x05\xFA{\x02\u02B9\u02BA\x05\u0110\x86\x02\u02BA\u02BB" +
+    "\x05\u011A\x8B\x02\u02BB\u02BD\x03\x02\x02\x02\u02BC\u02AF\x03\x02\x02" +
+    "\x02\u02BC\u02B3\x03\x02\x02\x02\u02BDa\x03\x02\x02\x02\u02BE\u02BF\x05" +
+    "\xFA{\x02\u02BF\u02C0\x05\u0104\x80\x02\u02C0\u02C1\x05\u0104\x80\x02" +
+    "\u02C1\u02C2\x05\xF2w\x02\u02C2\u02C3\x05\u010C\x84\x02\u02C3c\x03\x02" +
+    "\x02\x02\u02C4\u02C5\x05\xFA{\x02\u02C5\u02C6\x05\u0104\x80\x02\u02C6" +
+    "\u02C7\x05\u0110\x86\x02\u02C7\u02C8\x05\xF2w\x02\u02C8\u02C9\x05\u010C" +
+    "\x84\x02\u02C9\u02CA\x05\u010E\x85\x02\u02CA\u02CB\x05\xF2w\x02\u02CB" +
+    "\u02CC\x05\xEEu\x02\u02CC\u02CD\x05\u0110\x86\x02\u02CDe\x03\x02\x02\x02" +
+    "\u02CE\u02CF\x05\xFA{\x02\u02CF\u02D0\x05\u0104\x80\x02\u02D0\u02D1\x05" +
+    "\u0110\x86\x02\u02D1\u02D2\x05\xF2w\x02\u02D2\u02D3\x05\u010C\x84\x02" +
+    "\u02D3\u02D4\x05\u0114\x88\x02\u02D4\u02D5\x05\xEAs\x02\u02D5\u02D6\x05" +
+    "\u0100~\x02\u02D6g\x03\x02\x02\x02\u02D7\u02D8\x05\xFA{\x02\u02D8\u02D9" +
+    "\x05\u010E\x85\x02\u02D9i\x03\x02\x02\x02\u02DA\u02DB\x05\xFC|\x02\u02DB" +
+    "\u02DC\x05\u0106\x81\x02\u02DC\u02DD\x05\xFA{\x02\u02DD\u02DE\x05\u0104" +
+    "\x80\x02\u02DEk\x03\x02\x02\x02\u02DF\u02E0\x05\xFE}\x02\u02E0\u02E1\x05" +
+    "\xF2w\x02\u02E1\u02E2\x05\u011A\x8B\x02\u02E2m\x03\x02\x02\x02\u02E3\u02E4" +
+    "\x05\u0100~\x02\u02E4\u02E5\x05\xEAs\x02\u02E5\u02E6\x05\u010E\x85\x02" +
+    "\u02E6\u02E7\x05\u0110\x86\x02\u02E7o\x03\x02\x02\x02\u02E8\u02E9\x05" +
+    "\u0100~\x02\u02E9\u02EA\x05\xF2w\x02\u02EA\u02EB\x05\xEAs\x02\u02EB\u02EC" +
+    "\x05\xF0v\x02\u02EC\u02ED\x05\xFA{\x02\u02ED\u02EE\x05\u0104\x80\x02\u02EE" +
+    "\u02EF\x05\xF6y\x02\u02EFq\x03\x02\x02\x02\u02F0\u02F1\x05\u0100~\x02" +
+    "\u02F1\u02F2\x05\xF2w\x02\u02F2\u02F3\x05\xF4x\x02\u02F3\u02F4\x05\u0110" +
+    "\x86\x02\u02F4s\x03\x02\x02\x02\u02F5\u02F6\x05\u0100~\x02\u02F6\u02F7" +
+    "\x05\xF2w\x02\u02F7\u02F8\x05\u0110\x86\x02\u02F8u\x03\x02\x02\x02\u02F9" +
+    "\u02FA\x05\u0100~\x02\u02FA\u02FB\x05\xFA{\x02\u02FB\u02FC\x05\xFE}\x02" +
+    "\u02FC\u02FD\x05\xF2w\x02\u02FDw\x03\x02\x02\x02\u02FE\u02FF\x05\u0100" +
+    "~\x02\u02FF\u0300\x05\xFA{\x02\u0300\u0301\x05\u0102\x7F\x02\u0301\u0302" +
+    "\x05\xFA{\x02\u0302\u0303\x05\u0110\x86\x02\u0303y\x03\x02\x02\x02\u0304" +
+    "\u0305\x05\u0102\x7F\x02\u0305\u0306\x05\xFA{\x02\u0306\u0307\x05\u0104" +
+    "\x80\x02\u0307\u0308\x05\u0112\x87\x02\u0308\u0309\x05\u0110\x86\x02\u0309" +
+    "\u030A\x05\xF2w\x02\u030A{\x03\x02\x02\x02\u030B\u030C\x05\u0102\x7F\x02" +
+    "\u030C\u030D\x05\u0106\x81\x02\u030D\u030E\x05\u0104\x80\x02\u030E\u030F" +
+    "\x05\u0110\x86\x02\u030F\u0310\x05\xF8z\x02\u0310}\x03\x02\x02\x02\u0311" +
+    "\u0312\x05\u0104\x80\x02\u0312\u0313\x05\xEAs\x02\u0313\u0314\x05\u0104" +
+    "\x80\x02\u0314\x7F\x03\x02\x02\x02\u0315\u0316\x05\u0104\x80\x02\u0316" +
+    "\u0317\x05\u0106\x81\x02\u0317\u0318\x05\u0110\x86\x02\u0318\x81\x03\x02" +
+    "\x02\x02\u0319\u031A\x05\u0104\x80\x02\u031A\u031B\x05\u0112\x87\x02\u031B" +
+    "\u031C\x05\u0100~\x02\u031C\u031D\x05\u0100~\x02\u031D\x83\x03\x02\x02" +
+    "\x02\u031E\u031F\x05\u0104\x80\x02\u031F\u0320\x05\u0112\x87\x02\u0320" +
+    "\u0321\x05\u0100~\x02\u0321\u0322\x05\u0100~\x02\u0322\u0323\x05\u010E" +
+    "\x85\x02\u0323\x85\x03\x02\x02\x02\u0324\u0325\x05\u0106\x81\x02\u0325" +
+    "\u0326\x05\xF4x\x02\u0326\u0327\x05\xF4x\x02\u0327\u0328\x05\u010E\x85" +
+    "\x02\u0328\u0329\x05\xF2w\x02\u0329\u032A\x05\u0110\x86\x02\u032A\x87" +
+    "\x03\x02\x02\x02\u032B\u032C\x05\u0106\x81\x02\u032C\u032D\x05\u0104\x80" +
+    "\x02\u032D\x89\x03\x02\x02\x02\u032E\u032F\x05\u0106\x81\x02\u032F\u0330" +
+    "\x05\u010C\x84\x02\u0330\x8B\x03\x02\x02\x02\u0331\u0332\x05\u0106\x81" +
+    "\x02\u0332\u0333\x05\u010C\x84\x02\u0333\u0334\x05\xF0v\x02\u0334\u0335" +
+    "\x05\xF2w\x02\u0335\u0336\x05\u010C\x84\x02\u0336\x8D\x03\x02\x02\x02" +
+    "\u0337\u0338\x05\u0106\x81\x02\u0338\u0339\x05\u0112\x87\x02\u0339\u033A" +
+    "\x05\u0110\x86\x02\u033A\u033B\x05\xF2w\x02\u033B\u033C\x05\u010C\x84" +
+    "\x02\u033C\x8F\x03\x02\x02\x02\u033D\u033E\x05\u0106\x81\x02\u033E\u033F" +
+    "\x05\u0114\x88\x02\u033F\u0340\x05\xF2w\x02\u0340\u0341\x05\u010C\x84" +
+    "\x02\u0341\x91\x03\x02\x02\x02\u0342\u0343\x05\u0108\x82\x02\u0343\u0344" +
+    "\x05\xEAs\x02\u0344\u0345\x05\u010C\x84\x02\u0345\u0346\x05\u0110\x86" +
+    "\x02\u0346\u0347\x05\xFA{\x02\u0347\u0348\x05\u0110\x86\x02\u0348\u0349" +
+    "\x05\xFA{\x02\u0349\u034A\x05\u0106\x81\x02\u034A\u034B\x05\u0104\x80" +
+    "\x02\u034B\x93\x03\x02\x02\x02\u034C\u034D\x05\u0108\x82\x02\u034D\u034E" +
+    "\x05\u010C\x84\x02\u034E\u034F\x05\xF2w\x02\u034F\u0350\x05\xEEu\x02\u0350" +
+    "\u0351\x05\xF2w\x02\u0351\u0352\x05\xF0v\x02\u0352\u0353\x05\xFA{\x02" +
+    "\u0353\u0354\x05\u0104\x80\x02\u0354\u0355\x05\xF6y\x02\u0355\x95\x03" +
+    "\x02\x02\x02\u0356\u0357\x05\u0108\x82\x02\u0357\u0358\x05\u010C\x84\x02" +
+    "\u0358\u0359\x05\xF2w\x02\u0359\u035A\x05\u0116\x89\x02\u035A\u035B\x05" +
+    "\xF8z\x02\u035B\u035C\x05\xF2w\x02\u035C\u035D\x05\u010C\x84\x02\u035D" +
+    "\u035E\x05\xF2w\x02\u035E\x97\x03\x02\x02\x02\u035F\u0360\x05\u010A\x83" +
+    "\x02\u0360\u0361\x05\u0112\x87\x02\u0361\u0362\x05\xEAs\x02\u0362\u0363" +
+    "\x05\u010C\x84\x02\u0363\u0364\x05\u0110\x86\x02\u0364\u0365\x05\xF2w" +
+    "\x02\u0365\u0366\x05\u010C\x84\x02\u0366\x99\x03\x02\x02\x02\u0367\u0368" +
+    "\x05\u010C\x84\x02\u0368\u0369\x05\xEAs\x02\u0369\u036A\x05\u0104\x80" +
+    "\x02\u036A\u036B\x05\xF6y\x02\u036B\u036C\x05\xF2w\x02\u036C\x9B\x03\x02" +
+    "\x02\x02\u036D\u036E\x05\u010C\x84\x02\u036E\u036F\x05\xF2w\x02\u036F" +
+    "\u0370\x05\u0110\x86\x02\u0370\u0371\x05\u0112\x87\x02\u0371\u0372\x05" +
+    "\u010C\x84\x02\u0372\u0373\x05\u0104\x80\x02\u0373\x9D\x03\x02\x02\x02" +
+    "\u0374\u0375\x05\u010C\x84\x02\u0375\u0376\x05\xFA{\x02\u0376\u0377\x05" +
+    "\xF6y\x02\u0377\u0378\x05\xF8z\x02\u0378\u0379\x05\u0110\x86\x02\u0379" +
+    "\x9F\x03\x02\x02\x02\u037A\u037B\x05\u010C\x84\x02\u037B\u037C\x05\u0106" +
+    "\x81\x02\u037C\u037D\x05\u0100~\x02\u037D\u037E\x05\u0100~\x02\u037E\u037F" +
+    "\x05\u0112\x87\x02\u037F\u0380\x05\u0108\x82\x02\u0380\xA1\x03\x02\x02" +
+    "\x02\u0381\u0382\x05\u010C\x84\x02\u0382\u0383\x05\u0106\x81\x02\u0383" +
+    "\u0384\x05\u0116\x89\x02\u0384\xA3\x03\x02\x02\x02\u0385\u0386\x05\u010C" +
+    "\x84\x02\u0386\u0387\x05\u0106\x81\x02\u0387\u0388\x05\u0116\x89\x02\u0388" +
+    "\u0389\x05\u010E\x85\x02\u0389\xA5\x03\x02\x02\x02\u038A\u038B\x05\u010E" +
+    "\x85\x02\u038B\u038C\x05\xEAs\x02\u038C\u038D\x05\u0102\x7F\x02\u038D" +
+    "\u038E\x05\u0108\x82\x02\u038E\u038F\x05\u0100~\x02\u038F\u0390\x05\xF2" +
+    "w\x02\u0390\xA7\x03\x02\x02\x02\u0391\u0392\x05\u010E\x85\x02\u0392\u0393" +
+    "\x05\xF2w\x02\u0393\u0394\x05\xEEu\x02\u0394\u0395\x05\u0106\x81\x02\u0395" +
+    "\u0396\x05\u0104\x80\x02\u0396\u0397\x05\xF0v\x02\u0397\xA9\x03\x02\x02" +
+    "\x02\u0398\u0399\x05\u010E\x85\x02\u0399\u039A\x05\xF2w\x02\u039A\u039B" +
+    "\x05\u0100~\x02\u039B\u039C\x05\xF2w\x02\u039C\u039D\x05\xEEu\x02\u039D" +
+    "\u039E\x05\u0110\x86\x02\u039E\xAB\x03\x02\x02\x02\u039F\u03A0\x05\u010E" +
+    "\x85\x02\u03A0\u03A1\x05\xF2w\x02\u03A1\u03A2\x05\u0102\x7F\x02\u03A2" +
+    "\u03A3\x05\xFA{\x02\u03A3\xAD\x03\x02\x02\x02\u03A4\u03A5\x05\u010E\x85" +
+    "\x02\u03A5\u03A6\x05\xF2w\x02\u03A6\u03A7\x05\u0110\x86\x02\u03A7\u03A8" +
+    "\x05\u0110\x86\x02\u03A8\u03A9\x05\xFA{\x02\u03A9\u03AA\x05\u0104\x80" +
+    "\x02\u03AA\u03AB\x05\xF6y\x02\u03AB\u03AC\x05\u010E\x85\x02\u03AC\xAF" +
+    "\x03\x02\x02\x02\u03AD\u03AE\x05\u010E\x85\x02\u03AE\u03AF\x05\u0112\x87" +
+    "\x02\u03AF\u03B0\x05\xECt\x02\u03B0\u03B1\x05\u010E\x85\x02\u03B1\u03B2" +
+    "\x05\u0110\x86\x02\u03B2\u03B3\x05\u010C\x84\x02\u03B3\u03B4\x05\xFA{" +
+    "\x02\u03B4\u03B5\x05\u0104\x80\x02\u03B5\u03B6\x05\xF6y\x02\u03B6\xB1" +
+    "\x03\x02\x02\x02\u03B7\u03B8\x05\u0110\x86\x02\u03B8\u03B9\x05\xF8z\x02" +
+    "\u03B9\u03BA\x05\xF2w\x02\u03BA\u03BB\x05\u0104\x80\x02\u03BB\xB3\x03" +
+    "\x02\x02\x02\u03BC\u03BD\x05\u0110\x86\x02\u03BD\u03BE\x05\xF8z\x02\u03BE" +
+    "\u03BF\x05\u010C\x84\x02\u03BF\u03C0\x05\u0106\x81\x02\u03C0\u03C1\x05" +
+    "\u0116\x89\x02\u03C1\xB5\x03\x02\x02\x02\u03C2\u03C3\x05\u0110\x86\x02" +
+    "\u03C3\u03C4\x05\xFA{\x02\u03C4\u03C5\x05\xF2w\x02\u03C5\u03C6\x05\u010E" +
+    "\x85\x02\u03C6\xB7\x03\x02\x02\x02\u03C7\u03C8\x05\u0110\x86\x02\u03C8" +
+    "\u03C9\x05\xFA{\x02\u03C9\u03CA\x05\u0102\x7F\x02\u03CA\u03CB\x05\xF2" +
+    "w\x02\u03CB\u03CC\x05\u010E\x85\x02\u03CC\u03CD\x05\u0110\x86\x02\u03CD" +
+    "\u03CE\x05\xEAs\x02\u03CE\u03CF\x05\u0102\x7F\x02\u03CF\u03D0\x05\u0108" +
+    "\x82\x02\u03D0\xB9\x03\x02\x02\x02\u03D1\u03D2\x05\u0110\x86\x02\u03D2" +
+    "\u03D3\x05\u0106\x81\x02\u03D3\xBB\x03\x02\x02\x02\u03D4\u03D5\x05\u0110" +
+    "\x86\x02\u03D5\u03D6\x05\u0106\x81\x02\u03D6\u03D7\x05\u0108\x82\x02\u03D7" +
+    "\xBD\x03\x02\x02\x02\u03D8\u03D9\x05\u0110\x86\x02\u03D9\u03DA\x05\u0106" +
+    "\x81\x02\u03DA\u03DB\x05\u0110\x86\x02\u03DB\u03DC\x05\xEAs\x02\u03DC" +
+    "\u03DD\x05\u0100~\x02\u03DD\u03DE\x05\u010E\x85\x02\u03DE\xBF\x03\x02" +
+    "\x02\x02\u03DF\u03E0\x05\u0110\x86\x02\u03E0\u03E1\x05\u010C\x84\x02\u03E1" +
+    "\u03E2\x05\xEAs\x02\u03E2\u03E3\x05\xFA{\x02\u03E3\u03E4\x05\u0100~\x02";
+  private static readonly _serializedATNSegment2: string =
+    "\u03E4\u03E5\x05\xFA{\x02\u03E5\u03E6\x05\u0104\x80\x02\u03E6\u03E7\x05" +
+    "\xF6y\x02\u03E7\xC1\x03\x02\x02\x02\u03E8\u03E9\x05\u0110\x86\x02\u03E9" +
+    "\u03EA\x05\u010C\x84\x02\u03EA\u03EB\x05\xFA{\x02\u03EB\u03EC\x05\u0102" +
+    "\x7F\x02\u03EC\xC3\x03\x02\x02\x02\u03ED\u03EE\x05\u0110\x86\x02\u03EE" +
+    "\u03EF\x05\u010C\x84\x02\u03EF\u03F0\x05\u0112\x87\x02\u03F0\u03F1\x05" +
+    "\u0104\x80\x02\u03F1\u03F2\x05\xEEu\x02\u03F2\u03F3\x05\xEAs\x02\u03F3" +
+    "\u03F4\x05\u0110\x86\x02\u03F4\u03F5\x05\xF2w\x02\u03F5\xC5\x03\x02\x02" +
+    "\x02\u03F6\u03F7\x05\u0110\x86\x02\u03F7\u03F8\x05\u010C\x84\x02\u03F8" +
+    "\u03F9\x05\u011A\x8B\x02\u03F9\xC7\x03\x02\x02\x02\u03FA\u03FB\x05\u0112" +
+    "\x87\x02\u03FB\u03FC\x05\u0104\x80\x02\u03FC\u03FD\x05\xECt\x02\u03FD" +
+    "\u03FE\x05\u0106\x81\x02\u03FE\u03FF\x05\u0112\x87\x02\u03FF\u0400\x05" +
+    "\u0104\x80\x02\u0400\u0401\x05\xF0v\x02\u0401\u0402\x05\xF2w\x02\u0402" +
+    "\u0403\x05\xF0v\x02\u0403\xC9\x03\x02\x02\x02\u0404\u0405\x05\u0112\x87" +
+    "\x02\u0405\u0406\x05\u0104\x80\x02\u0406\u0407\x05\xFA{\x02\u0407\u0408" +
+    "\x05\u0106\x81\x02\u0408\u0409\x05\u0104\x80\x02\u0409\xCB\x03\x02\x02" +
+    "\x02\u040A\u040B\x05\u0112\x87\x02\u040B\u040C\x05\u010E\x85\x02\u040C" +
+    "\u040D\x05\xFA{\x02\u040D\u040E\x05\u0104\x80\x02\u040E\u040F\x05\xF6" +
+    "y\x02\u040F\xCD\x03\x02\x02\x02\u0410\u0411\x05\u0116\x89\x02\u0411\u0412" +
+    "\x05\xF2w\x02\u0412\u0413\x05\xF2w\x02\u0413\u0414\x05\xFE}\x02\u0414" +
+    "\xCF\x03\x02\x02\x02\u0415\u0416\x05\u0116\x89\x02\u0416\u0417\x05\xF8" +
+    "z\x02\u0417\u0418\x05\xF2w\x02\u0418\u0419\x05\u0104\x80\x02\u0419\xD1" +
+    "\x03\x02\x02\x02\u041A\u041B\x05\u0116\x89\x02\u041B\u041C\x05\xF8z\x02" +
+    "\u041C\u041D\x05\xF2w\x02\u041D\u041E\x05\u010C\x84\x02\u041E\u041F\x05" +
+    "\xF2w\x02\u041F\xD3\x03\x02\x02\x02\u0420\u0421\x05\u0116\x89\x02\u0421" +
+    "\u0422\x05\xF8z\x02\u0422\u0423\x05\xFA{\x02\u0423\u0424\x05\u0100~\x02" +
+    "\u0424\u0425\x05\xF2w\x02\u0425\xD5\x03\x02\x02\x02\u0426\u0427\x05\u0116" +
+    "\x89\x02\u0427\u0428\x05\xFA{\x02\u0428\u0429\x05\u0104\x80\x02\u0429" +
+    "\u042A\x05\xF0v\x02\u042A\u042B\x05\u0106\x81\x02\u042B\u042C\x05\u0116" +
+    "\x89\x02\u042C\xD7\x03\x02\x02\x02\u042D\u042E\x05\u0116\x89\x02\u042E" +
+    "\u042F\x05\xFA{\x02\u042F\u0430\x05\u0110\x86\x02\u0430\u0431\x05\xF8" +
+    "z\x02\u0431\xD9\x03\x02\x02\x02\u0432\u0433\x05\u011A\x8B\x02\u0433\u0434" +
+    "\x05\xF2w\x02\u0434\u0435\x05\xEAs\x02\u0435\u0436\x05\u010C\x84\x02\u0436" +
+    "\u043D\x03\x02\x02\x02\u0437\u0438\x05\u011A\x8B\x02\u0438\u0439\x05\u011A" +
+    "\x8B\x02\u0439\u043A\x05\u011A\x8B\x02\u043A\u043B\x05\u011A\x8B\x02\u043B" +
+    "\u043D\x03\x02\x02\x02\u043C\u0432\x03\x02\x02\x02\u043C\u0437\x03\x02" +
+    "\x02\x02\u043D\xDB\x03\x02\x02\x02\u043E\u043F\x05\u012C\x94\x02\u043F" +
+    "\u0440\x05\xECt\x02\u0440\u045A\x03\x02\x02\x02\u0441\u0442\x05\u012C" +
+    "\x94\x02\u0442\u0443\x05\xF4x\x02\u0443\u045A\x03\x02\x02\x02\u0444\u0445" +
+    "\x05\u012C\x94\x02\u0445\u0446\x05\u010C\x84\x02\u0446\u045A\x03\x02\x02" +
+    "\x02\u0447\u0448\x05\u012C\x94\x02\u0448\u0449\x05\u0104\x80\x02\u0449" +
+    "\u045A\x03\x02\x02\x02\u044A\u044B\x05\u012C\x94\x02\u044B\u044C\x05\u0110" +
+    "\x86\x02\u044C\u045A\x03\x02\x02\x02\u044D\u044E\x05\u012C\x94\x02\u044E" +
+    "\u044F\x072\x02\x02\u044F\u045A\x03\x02\x02\x02\u0450\u0451\x05\u012C" +
+    "\x94\x02\u0451\u0452\x05\xEAs\x02\u0452\u045A\x03\x02\x02\x02\u0453\u0454" +
+    "\x05\u012C\x94\x02\u0454\u0455\x05\u0114\x88\x02\u0455\u045A\x03\x02\x02" +
+    "\x02\u0456\u0457\x05\u012C\x94\x02\u0457\u0458\x05\u012C\x94\x02\u0458" +
+    "\u045A\x03\x02\x02\x02\u0459\u043E\x03\x02\x02\x02\u0459\u0441\x03\x02" +
+    "\x02\x02\u0459\u0444\x03\x02\x02\x02\u0459\u0447\x03\x02\x02\x02\u0459" +
+    "\u044A\x03\x02\x02\x02\u0459\u044D\x03\x02\x02\x02\u0459\u0450\x03\x02" +
+    "\x02\x02\u0459\u0453\x03\x02\x02\x02\u0459\u0456\x03\x02\x02\x02\u045A" +
+    "\xDD\x03\x02\x02\x02\u045B\u045F\x05\u011E\x8D\x02\u045C\u045F\x05\u0180" +
+    "\xBE\x02\u045D\u045F\x05\u0136\x99\x02\u045E\u045B\x03\x02\x02\x02\u045E" +
+    "\u045C\x03\x02\x02\x02\u045E\u045D\x03\x02\x02\x02\u045F\u0466\x03\x02" +
+    "\x02\x02\u0460\u0465\x05\u011E\x8D\x02\u0461\u0465\x05\u0180\xBE\x02\u0462" +
+    "\u0465\x05\u0122\x8F\x02\u0463\u0465\x05\u0136\x99\x02\u0464\u0460\x03" +
+    "\x02\x02\x02\u0464\u0461\x03\x02\x02\x02\u0464\u0462\x03\x02\x02\x02\u0464" +
+    "\u0463\x03\x02\x02\x02\u0465\u0468\x03\x02\x02\x02\u0466\u0464\x03\x02" +
+    "\x02\x02\u0466\u0467\x03\x02\x02\x02\u0467\u048A\x03\x02\x02\x02\u0468" +
+    "\u0466\x03\x02\x02\x02\u0469\u0474\x05\u012A\x93\x02\u046A\u0473\n\x02" +
+    "\x02\x02\u046B\u0473\x05\xDCl\x02\u046C\u046D\x05\u012C\x94\x02\u046D" +
+    "\u046E\x05\u016E\xB5\x02\u046E\u0473\x03\x02\x02\x02\u046F\u0470\x05\u012A" +
+    "\x93\x02\u0470\u0471\x05\u012A\x93\x02\u0471\u0473\x03\x02\x02\x02\u0472" +
+    "\u046A\x03\x02\x02\x02\u0472\u046B\x03\x02\x02\x02\u0472\u046C\x03\x02" +
+    "\x02\x02\u0472\u046F\x03\x02\x02\x02\u0473\u0476\x03\x02\x02\x02\u0474" +
+    "\u0472\x03\x02\x02\x02\u0474\u0475\x03\x02\x02\x02\u0475\u0477\x03\x02" +
+    "\x02\x02\u0476\u0474\x03\x02\x02\x02\u0477\u0478\x05\u012A\x93\x02\u0478" +
+    "\u048A\x03\x02\x02\x02\u0479\u0484\x05\u0168\xB2\x02\u047A\u0483\n\x03" +
+    "\x02\x02\u047B\u0483\x05\xDCl\x02\u047C\u047D\x05\u012C\x94\x02\u047D" +
+    "\u047E\x05\u0168\xB2\x02\u047E\u0483\x03\x02\x02\x02\u047F\u0480\x05\u0168" +
+    "\xB2\x02\u0480\u0481\x05\u0168\xB2\x02\u0481\u0483\x03\x02\x02\x02\u0482" +
+    "\u047A\x03\x02\x02\x02\u0482\u047B\x03\x02\x02\x02\u0482\u047C\x03\x02" +
+    "\x02\x02\u0482\u047F\x03\x02\x02\x02\u0483\u0486\x03\x02\x02\x02\u0484" +
+    "\u0482\x03\x02\x02\x02\u0484\u0485\x03\x02\x02\x02\u0485\u0487\x03\x02" +
+    "\x02\x02\u0486\u0484\x03\x02\x02\x02\u0487\u0488\x05\u0168\xB2\x02\u0488" +
+    "\u048A\x03\x02\x02\x02\u0489\u045E\x03\x02\x02\x02\u0489\u0469\x03\x02" +
+    "\x02\x02\u0489\u0479\x03\x02\x02\x02\u048A\xDF\x03\x02\x02\x02\u048B\u048C" +
+    "\x05\xE6q\x02\u048C\u0490\x05\u0138\x9A\x02\u048D\u048F\x05\u0124\x90" +
+    "\x02\u048E\u048D\x03\x02\x02\x02\u048F\u0492\x03\x02\x02\x02\u0490\u048E" +
+    "\x03\x02\x02\x02\u0490\u0491\x03\x02\x02\x02\u0491\u0495\x03\x02\x02\x02" +
+    "\u0492\u0490\x03\x02\x02\x02\u0493\u0496\x05\u0108\x82\x02\u0494\u0496" +
+    "\x05\xF2w\x02\u0495\u0493\x03\x02\x02\x02\u0495\u0494\x03\x02\x02\x02" +
+    "\u0496\u0499\x03\x02\x02\x02\u0497\u049A\x05\u0164\xB0\x02\u0498\u049A" +
+    "\x05\u0134\x98\x02\u0499\u0497\x03\x02\x02\x02\u0499\u0498\x03\x02\x02" +
+    "\x02\u0499\u049A\x03\x02\x02\x02\u049A\u049C\x03\x02\x02\x02\u049B\u049D" +
+    "\x05\u0122\x8F\x02\u049C\u049B\x03\x02\x02\x02\u049D\u049E\x03\x02\x02" +
+    "\x02\u049E\u049C\x03\x02\x02\x02\u049E\u049F\x03\x02\x02\x02\u049F\u04D8" +
+    "\x03\x02\x02\x02\u04A0\u04A3\x05\xE6q\x02\u04A1\u04A4\x05\u0108\x82\x02" +
+    "\u04A2\u04A4\x05\xF2w\x02\u04A3\u04A1\x03\x02\x02\x02\u04A3\u04A2\x03" +
+    "\x02\x02\x02\u04A4\u04A7\x03\x02\x02\x02\u04A5\u04A8\x05\u0164\xB0\x02" +
+    "\u04A6\u04A8\x05\u0134\x98\x02\u04A7\u04A5\x03\x02\x02\x02\u04A7\u04A6" +
+    "\x03\x02\x02\x02\u04A7\u04A8\x03\x02\x02\x02\u04A8\u04AA\x03\x02\x02\x02" +
+    "\u04A9\u04AB\x05\u0122\x8F\x02\u04AA\u04A9\x03\x02\x02\x02\u04AB\u04AC" +
+    "\x03\x02\x02\x02\u04AC\u04AA\x03\x02\x02\x02\u04AC\u04AD\x03\x02\x02\x02" +
+    "\u04AD\u04D8\x03\x02\x02\x02\u04AE\u04AF\x05\xE4p\x02\u04AF\u04B3\x05" +
+    "\u0138\x9A\x02\u04B0\u04B2\x05\u0122\x8F\x02\u04B1\u04B0\x03\x02\x02\x02" +
+    "\u04B2\u04B5\x03\x02\x02\x02\u04B3\u04B1\x03\x02\x02\x02\u04B3\u04B4\x03" +
+    "\x02\x02\x02\u04B4\u04B6\x03\x02\x02\x02\u04B5\u04B3\x03\x02\x02\x02\u04B6" +
+    "\u04B9\x05\xF2w\x02\u04B7\u04BA\x05\u0164\xB0\x02\u04B8\u04BA\x05\u0134" +
+    "\x98\x02\u04B9\u04B7\x03\x02\x02\x02\u04B9\u04B8\x03\x02\x02\x02\u04B9" +
+    "\u04BA\x03\x02\x02\x02\u04BA\u04BC\x03\x02\x02\x02\u04BB\u04BD\x05\u0122" +
+    "\x8F\x02\u04BC\u04BB\x03\x02\x02\x02\u04BD\u04BE\x03\x02\x02\x02\u04BE" +
+    "\u04BC\x03\x02\x02\x02\u04BE\u04BF\x03\x02\x02\x02\u04BF\u04D8\x03\x02" +
+    "\x02\x02\u04C0\u04C1\x05\u0138\x9A\x02\u04C1\u04C2\x05\xE4p\x02\u04C2" +
+    "\u04C5\x05\xF2w\x02\u04C3\u04C6\x05\u0164\xB0\x02\u04C4\u04C6\x05\u0134" +
+    "\x98\x02\u04C5\u04C3\x03\x02\x02\x02\u04C5\u04C4\x03\x02\x02\x02\u04C5" +
+    "\u04C6\x03\x02\x02\x02\u04C6\u04C8\x03\x02\x02\x02\u04C7\u04C9\x05\u0122" +
+    "\x8F\x02\u04C8\u04C7\x03\x02\x02\x02\u04C9\u04CA\x03\x02\x02\x02\u04CA" +
+    "\u04C8\x03\x02\x02\x02\u04CA\u04CB\x03\x02\x02\x02\u04CB\u04D8\x03\x02" +
+    "\x02\x02\u04CC\u04CD\x05\xE4p\x02\u04CD\u04D0\x05\xF2w\x02\u04CE\u04D1" +
+    "\x05\u0164\xB0\x02\u04CF\u04D1\x05\u0134\x98\x02\u04D0\u04CE\x03\x02\x02" +
+    "\x02\u04D0\u04CF\x03\x02\x02\x02\u04D0\u04D1\x03\x02\x02\x02\u04D1\u04D3" +
+    "\x03\x02\x02\x02\u04D2\u04D4\x05\u0122\x8F\x02\u04D3\u04D2\x03\x02\x02" +
+    "\x02\u04D4\u04D5\x03\x02\x02\x02\u04D5\u04D3\x03\x02\x02\x02\u04D5\u04D6" +
+    "\x03\x02\x02\x02\u04D6\u04D8\x03\x02\x02\x02\u04D7\u048B\x03\x02\x02\x02" +
+    "\u04D7\u04A0\x03\x02\x02\x02\u04D7\u04AE\x03\x02\x02\x02\u04D7\u04C0\x03" +
+    "\x02\x02\x02\u04D7\u04CC\x03\x02\x02\x02\u04D8\xE1\x03\x02\x02\x02\u04D9" +
+    "\u04DB\x072\x02\x02\u04DA\u04DC\x05\u0120\x8E\x02\u04DB\u04DA\x03\x02" +
+    "\x02\x02\u04DC\u04DD\x03\x02\x02\x02\u04DD\u04DB\x03\x02\x02\x02\u04DD" +
+    "\u04DE\x03\x02\x02\x02\u04DE\xE3\x03\x02\x02\x02\u04DF\u04E1\x05\u0122" +
+    "\x8F\x02\u04E0\u04DF\x03\x02\x02\x02\u04E1\u04E2\x03\x02\x02\x02\u04E2" +
+    "\u04E0\x03\x02\x02\x02\u04E2\u04E3\x03\x02\x02\x02\u04E3\xE5\x03\x02\x02" +
+    "\x02\u04E4\u04E5\x072\x02\x02\u04E5\u04E7\x05\u0118\x8A\x02\u04E6\u04E8" +
+    "\x05\u0124\x90\x02\u04E7\u04E6\x03\x02\x02\x02\u04E8\u04E9\x03\x02\x02" +
+    "\x02\u04E9\u04E7\x03\x02\x02\x02\u04E9\u04EA\x03\x02\x02\x02\u04EA\xE7" +
+    "\x03\x02\x02\x02\u04EB\u04F6\x05\u016E\xB5\x02\u04EC\u04F5\n\x04\x02\x02" +
+    "\u04ED\u04F5\x05\xDCl\x02\u04EE\u04EF\x05\u012C\x94\x02\u04EF\u04F0\x05" +
+    "\u016E\xB5\x02\u04F0\u04F5\x03\x02\x02\x02\u04F1\u04F2\x05\u016E\xB5\x02" +
+    "\u04F2\u04F3\x05\u016E\xB5\x02\u04F3\u04F5\x03\x02\x02\x02\u04F4\u04EC" +
+    "\x03\x02\x02\x02\u04F4\u04ED\x03\x02\x02\x02\u04F4\u04EE\x03\x02\x02\x02" +
+    "\u04F4\u04F1\x03\x02\x02\x02\u04F5\u04F8\x03\x02\x02\x02\u04F6\u04F4\x03" +
+    "\x02\x02\x02\u04F6\u04F7\x03\x02\x02\x02\u04F7\u04F9\x03\x02\x02\x02\u04F8" +
+    "\u04F6\x03\x02\x02\x02\u04F9\u04FA\x05\u016E\xB5\x02\u04FA\xE9\x03\x02" +
+    "\x02\x02\u04FB\u04FC\t\x05\x02\x02\u04FC\xEB\x03\x02\x02\x02\u04FD\u04FE" +
+    "\t\x06\x02\x02\u04FE\xED\x03\x02\x02\x02\u04FF\u0500\t\x07\x02\x02\u0500" +
+    "\xEF\x03\x02\x02\x02\u0501\u0502\t\b\x02\x02\u0502\xF1\x03\x02\x02\x02" +
+    "\u0503\u0504\t\t\x02\x02\u0504\xF3\x03\x02\x02\x02\u0505\u0506\t\n\x02" +
+    "\x02\u0506\xF5\x03\x02\x02\x02\u0507\u0508\t\v\x02\x02\u0508\xF7\x03\x02" +
+    "\x02\x02\u0509\u050A\t\f\x02\x02\u050A\xF9\x03\x02\x02\x02\u050B\u050C" +
+    "\t\r\x02\x02\u050C\xFB\x03\x02\x02\x02\u050D\u050E\t\x0E\x02\x02\u050E" +
+    "\xFD\x03\x02\x02\x02\u050F\u0510\t\x0F\x02\x02\u0510\xFF\x03\x02\x02\x02" +
+    "\u0511\u0512\t\x10\x02\x02\u0512\u0101\x03\x02\x02\x02\u0513\u0514\t\x11" +
+    "\x02\x02\u0514\u0103\x03\x02\x02\x02\u0515\u0516\t\x12\x02\x02\u0516\u0105" +
+    "\x03\x02\x02\x02\u0517\u0518\t\x13\x02\x02\u0518\u0107\x03\x02\x02\x02" +
+    "\u0519\u051A\t\x14\x02\x02\u051A\u0109\x03\x02\x02\x02\u051B\u051C\t\x15" +
+    "\x02\x02\u051C\u010B\x03\x02\x02\x02\u051D\u051E\t\x16\x02\x02\u051E\u010D" +
+    "\x03\x02\x02\x02\u051F\u0520\t\x17\x02\x02\u0520\u010F\x03\x02\x02\x02" +
+    "\u0521\u0522\t\x18\x02\x02\u0522\u0111\x03\x02\x02\x02\u0523\u0524\t\x19" +
+    "\x02\x02\u0524\u0113\x03\x02\x02\x02\u0525\u0526\t\x1A\x02\x02\u0526\u0115" +
+    "\x03\x02\x02\x02\u0527\u0528\t\x1B\x02\x02\u0528\u0117\x03\x02\x02\x02" +
+    "\u0529\u052A\t\x1C\x02\x02\u052A\u0119\x03\x02\x02\x02\u052B\u052C\t\x1D" +
+    "\x02\x02\u052C\u011B\x03\x02\x02\x02\u052D\u052E\t\x1E\x02\x02\u052E\u011D" +
+    "\x03\x02\x02\x02\u052F\u0530\t\x1F\x02\x02\u0530\u011F\x03\x02\x02\x02" +
+    "\u0531\u0532\t \x02\x02\u0532\u0121\x03\x02\x02\x02\u0533\u0534\t!\x02" +
+    '\x02\u0534\u0123\x03\x02\x02\x02\u0535\u0536\t"\x02\x02\u0536\u0125\x03' +
+    "\x02\x02\x02\u0537\u0538\x07/\x02\x02\u0538\u0539\x07@\x02\x02\u0539\u0127" +
+    "\x03\x02\x02\x02\u053A\u053B\x07,\x02\x02\u053B\u0129\x03\x02\x02\x02" +
+    "\u053C\u053D\x07b\x02\x02\u053D\u012B\x03\x02\x02\x02\u053E\u053F\x07" +
+    "^\x02\x02\u053F\u012D\x03\x02\x02\x02\u0540\u0541\x07<\x02\x02\u0541\u012F" +
+    "\x03\x02\x02\x02\u0542\u0543\x07.\x02\x02\u0543\u0131\x03\x02\x02\x02" +
+    "\u0544\u0545\x07~\x02\x02\u0545\u0546\x07~\x02\x02\u0546\u0133\x03\x02" +
+    "\x02\x02\u0547\u0548\x07/\x02\x02\u0548\u0135\x03\x02\x02\x02\u0549\u054A" +
+    "\x07&\x02\x02\u054A\u0137\x03\x02\x02\x02\u054B\u054C\x070\x02\x02\u054C" +
+    "\u0139\x03\x02\x02\x02\u054D\u054E\x07?\x02\x02\u054E\u054F\x07?\x02\x02" +
+    "\u054F\u013B\x03\x02\x02\x02\u0550\u0551\x07?\x02\x02\u0551\u013D\x03" +
+    "\x02\x02\x02\u0552\u0553\x07@\x02\x02\u0553\u0554\x07?\x02\x02\u0554\u013F" +
+    "\x03\x02\x02\x02\u0555\u0556\x07@\x02\x02\u0556\u0141\x03\x02\x02\x02" +
+    "\u0557\u0558\x07%\x02\x02\u0558\u0143\x03\x02\x02\x02\u0559\u055A\x07" +
+    "\x80\x02\x02\u055A\u055B\x07,\x02\x02\u055B\u0145\x03\x02\x02\x02\u055C" +
+    "\u055D\x07?\x02\x02\u055D\u055E\x07\x80\x02\x02\u055E\u055F\x07,\x02\x02" +
+    "\u055F\u0147\x03\x02\x02\x02\u0560\u0561\x07}\x02\x02\u0561\u0562\x03" +
+    "\x02\x02\x02\u0562\u0563\b\xA2\x02\x02\u0563\u0149\x03\x02\x02\x02\u0564" +
+    "\u0565\x07]\x02\x02\u0565\u014B\x03\x02\x02\x02\u0566\u0567\x07*\x02\x02" +
+    "\u0567\u014D\x03\x02\x02\x02\u0568\u0569\x07>\x02\x02\u0569\u056A\x07" +
+    "?\x02\x02\u056A\u014F\x03\x02\x02\x02\u056B\u056C\x07>\x02\x02\u056C\u056D" +
+    "\x071\x02\x02\u056D\u056E\x03\x02\x02\x02\u056E\u056F\b\xA6\x03\x02\u056F" +
+    "\u0570\b\xA6\x04\x02\u0570\u0151\x03\x02\x02\x02\u0571\u0572\x07>\x02" +
+    "\x02\u0572\u0573\x06\xA7\x02\x02\u0573\u0574\x03\x02\x02\x02\u0574\u0575" +
+    "\b\xA7\x05\x02\u0575\u0576\b\xA7\x06\x02\u0576\u0153\x03\x02\x02\x02\u0577" +
+    "\u0578\x07>\x02\x02\u0578\u0155\x03\x02\x02\x02\u0579\u057A\x07>\x02\x02" +
+    "\u057A\u057B\x071\x02\x02\u057B\u0157\x03\x02\x02\x02\u057C\u057D\x07" +
+    "#\x02\x02\u057D\u0581\x07?\x02\x02\u057E\u057F\x07>\x02\x02\u057F\u0581" +
+    "\x07@\x02\x02\u0580\u057C\x03\x02\x02\x02\u0580\u057E\x03\x02\x02\x02" +
+    "\u0581\u0159\x03\x02\x02\x02\u0582\u0583\x07#\x02\x02\u0583\u0584\x07" +
+    "\x80\x02\x02\u0584\u0585\x07,\x02\x02\u0585\u015B\x03\x02\x02\x02\u0586" +
+    "\u0587\x07#\x02\x02\u0587\u0588\x07\x80\x02\x02\u0588\u015D\x03\x02\x02" +
+    "\x02\u0589\u058A\x07A\x02\x02\u058A\u058B\x070\x02\x02\u058B\u015F\x03" +
+    "\x02\x02\x02\u058C\u058D\x07A\x02\x02\u058D\u058E\x07A\x02\x02\u058E\u0161" +
+    "\x03\x02\x02\x02\u058F\u0590\x07'\x02\x02\u0590\u0163\x03\x02\x02\x02" +
+    "\u0591\u0592\x07-\x02\x02\u0592\u0165\x03\x02\x02\x02\u0593\u0594\x07" +
+    "A\x02\x02\u0594\u0167\x03\x02\x02\x02\u0595\u0596\x07$\x02\x02\u0596\u0169" +
+    "\x03\x02\x02\x02\u0597\u0598\x07h\x02\x02\u0598\u0599\x07)\x02\x02\u0599" +
+    "\u059A\x03\x02\x02\x02\u059A\u059B\b\xB3\x07\x02\u059B\u016B\x03\x02\x02" +
+    "\x02\u059C\u059D\x07H\x02\x02\u059D\u059E\x07)\x02\x02\u059E\u059F\x03" +
+    "\x02\x02\x02\u059F\u05A0\b\xB4\b\x02\u05A0\u016D\x03\x02\x02\x02\u05A1" +
+    "\u05A2\x07)\x02\x02\u05A2\u016F\x03\x02\x02\x02\u05A3\u05A4\x07\x80\x02" +
+    "\x02\u05A4\u0171\x03\x02\x02\x02\u05A5\u05A6\x07?\x02\x02\u05A6\u05A7" +
+    "\x07\x80\x02\x02\u05A7\u0173\x03\x02\x02\x02\u05A8\u05A9\x07\x7F\x02\x02" +
+    "\u05A9\u05AA\x03\x02\x02\x02\u05AA\u05AB\b\xB8\t\x02\u05AB\u0175\x03\x02" +
+    "\x02\x02\u05AC\u05AD\x07_\x02\x02\u05AD\u0177\x03\x02\x02\x02\u05AE\u05AF" +
+    "\x07+\x02\x02\u05AF\u0179\x03\x02\x02\x02\u05B0\u05B1\x07=\x02\x02\u05B1" +
+    "\u017B\x03\x02\x02\x02\u05B2\u05B3\x071\x02\x02\u05B3\u017D\x03\x02\x02" +
+    "\x02\u05B4\u05B5\x071\x02\x02\u05B5\u05B6\x07@\x02\x02\u05B6\u017F\x03" +
+    "\x02\x02\x02\u05B7\u05B8\x07a\x02\x02\u05B8\u0181\x03\x02\x02\x02\u05B9" +
+    "\u05BA\x071\x02\x02\u05BA\u05BB\x07,\x02\x02\u05BB\u05BF\x03\x02\x02\x02" +
+    "\u05BC\u05BE\v\x02\x02\x02\u05BD\u05BC\x03\x02\x02\x02\u05BE\u05C1\x03" +
+    "\x02\x02\x02\u05BF\u05C0\x03\x02\x02\x02\u05BF\u05BD\x03\x02\x02\x02\u05C0" +
+    "\u05C2\x03\x02\x02\x02\u05C1\u05BF\x03\x02\x02\x02\u05C2\u05C3\x07,\x02" +
+    "\x02\u05C3\u05C4\x071\x02\x02\u05C4\u05C5\x03\x02\x02\x02\u05C5\u05C6" +
+    "\b\xBF\n\x02\u05C6\u0183\x03\x02\x02\x02\u05C7\u05C8\x07/\x02\x02\u05C8" +
+    "\u05CC\x07/\x02\x02\u05C9\u05CA\x071\x02\x02\u05CA\u05CC\x071\x02\x02" +
+    "\u05CB\u05C7\x03\x02\x02\x02\u05CB\u05C9\x03\x02\x02\x02\u05CC\u05D0\x03" +
+    "\x02\x02\x02\u05CD\u05CF\n#\x02\x02\u05CE\u05CD\x03\x02\x02\x02\u05CF" +
+    "\u05D2\x03\x02\x02\x02\u05D0\u05CE\x03\x02\x02\x02\u05D0\u05D1\x03\x02" +
+    "\x02\x02\u05D1\u05D4\x03\x02\x02\x02\u05D2\u05D0\x03\x02\x02\x02\u05D3" +
+    "\u05D5\t$\x02\x02\u05D4\u05D3\x03\x02\x02\x02\u05D5\u05D6\x03\x02\x02" +
+    "\x02\u05D6\u05D7\b\xC0\n\x02\u05D7\u0185\x03\x02\x02\x02\u05D8\u05D9\t" +
+    "%\x02\x02\u05D9\u05DA\x03\x02\x02\x02\u05DA\u05DB\b\xC1\v\x02\u05DB\u0187" +
+    "\x03\x02\x02\x02\u05DC\u05E8\n&\x02\x02\u05DD\u05E8\x05\xDCl\x02\u05DE" +
+    "\u05DF\x05\u012C\x94\x02\u05DF\u05E0\x05\u016E\xB5\x02\u05E0\u05E8\x03" +
+    "\x02\x02\x02\u05E1\u05E2\x05\u012C\x94\x02\u05E2\u05E3\x05\u0148\xA2\x02" +
+    "\u05E3\u05E8\x03\x02\x02\x02\u05E4\u05E5\x05\u016E\xB5\x02\u05E5\u05E6" +
+    "\x05\u016E\xB5\x02\u05E6\u05E8\x03\x02\x02\x02\u05E7\u05DC\x03\x02\x02" +
+    "\x02\u05E7\u05DD\x03\x02\x02\x02\u05E7\u05DE\x03\x02\x02\x02\u05E7\u05E1" +
+    "\x03\x02\x02\x02\u05E7\u05E4\x03\x02\x02\x02\u05E8\u05E9\x03\x02\x02\x02" +
+    "\u05E9\u05E7\x03\x02\x02\x02\u05E9\u05EA\x03\x02\x02\x02\u05EA\u0189\x03" +
+    "\x02\x02\x02\u05EB\u05EC\x05\u0148\xA2\x02\u05EC\u05ED\x03\x02\x02\x02" +
+    "\u05ED\u05EE\b\xC3\x02\x02\u05EE\u018B\x03\x02\x02\x02\u05EF\u05F0\x05" +
+    "\u016E\xB5\x02\u05F0\u05F1\x03\x02\x02\x02\u05F1\u05F2\b\xC4\f\x02\u05F2" +
+    "\u05F3\b\xC4\t\x02\u05F3\u018D\x03\x02\x02\x02\u05F4\u05FA\n'\x02\x02" +
+    "\u05F5\u05FA\x05\xDCl\x02\u05F6\u05F7\x05\u012C\x94\x02\u05F7\u05F8\x05" +
+    "\u0148\xA2\x02\u05F8\u05FA\x03\x02\x02\x02\u05F9\u05F4\x03\x02\x02\x02" +
+    "\u05F9\u05F5\x03\x02\x02\x02\u05F9\u05F6\x03\x02\x02\x02\u05FA\u05FB\x03" +
+    "\x02\x02\x02\u05FB\u05F9\x03\x02\x02\x02\u05FB\u05FC\x03\x02\x02\x02\u05FC" +
+    "\u018F\x03\x02\x02\x02\u05FD\u05FE\x05\u0148\xA2\x02\u05FE\u05FF\x03\x02" +
+    "\x02\x02\u05FF\u0600\b\xC6\x02\x02\u0600\u0191\x03\x02\x02\x02\u0601\u0602" +
+    "\x071\x02\x02\u0602\u0603\x07@\x02\x02\u0603\u0604\x03\x02\x02\x02\u0604" +
+    "\u0605\b\xC7\r\x02\u0605\u0606\b\xC7\t\x02\u0606\u0193\x03\x02\x02\x02" +
+    "\u0607\u0608\x07@\x02\x02\u0608\u0609\x03\x02\x02\x02\u0609\u060A\b\xC8" +
+    "\x0E\x02\u060A\u060B\b\xC8\t\x02\u060B\u060C\b\xC8\x0F\x02\u060C\u0195" +
+    "\x03\x02\x02\x02\u060D\u0611\t(\x02\x02\u060E\u0610\t)\x02\x02\u060F\u060E" +
+    "\x03\x02\x02\x02\u0610\u0613\x03\x02\x02\x02\u0611\u060F\x03\x02\x02\x02" +
+    "\u0611\u0612\x03\x02\x02\x02\u0612\u0614\x03\x02\x02\x02\u0613\u0611\x03" +
+    "\x02\x02\x02\u0614\u0615\b\xC9\x10\x02\u0615\u0197\x03\x02\x02\x02\u0616" +
+    "\u0617\x07?\x02\x02\u0617\u0618\x03\x02\x02\x02\u0618\u0619\b\xCA\x11" +
+    "\x02\u0619\u0199\x03\x02\x02\x02\u061A\u061B\x05\xE8r\x02\u061B\u061C" +
+    "\x03\x02\x02\x02\u061C\u061D\b\xCB\x12\x02\u061D\u019B\x03\x02\x02\x02" +
+    "\u061E\u0620\t*\x02\x02\u061F\u061E\x03\x02\x02\x02\u0620\u0621\x03\x02" +
+    "\x02\x02\u0621\u061F\x03\x02\x02\x02\u0621\u0622\x03\x02\x02\x02\u0622" +
+    "\u0623\x03\x02\x02\x02\u0623\u0624\b\xCC\v\x02\u0624\u019D\x03\x02\x02" +
+    "\x02\u0625\u0626\x07}\x02\x02\u0626\u0627\x03\x02\x02\x02\u0627\u0628" +
+    "\b\xCD\x13\x02\u0628\u0629\b\xCD\x02\x02\u0629\u019F\x03\x02\x02\x02\u062A" +
+    "\u062B\x07@\x02\x02\u062B\u062C\x03\x02\x02\x02\u062C\u062D\b\xCE\x0E" +
+    "\x02\u062D\u062E\b\xCE\t\x02\u062E\u01A1\x03\x02\x02\x02\u062F\u0633\t" +
+    "(\x02\x02\u0630\u0632\t)\x02\x02\u0631\u0630\x03\x02\x02\x02\u0632\u0635" +
+    "\x03\x02\x02\x02\u0633\u0631\x03\x02\x02\x02\u0633\u0634\x03\x02\x02\x02" +
+    "\u0634\u0636\x03\x02\x02\x02\u0635\u0633\x03\x02\x02\x02\u0636\u0637\b" +
+    "\xCF\x10\x02\u0637\u01A3\x03\x02\x02\x02\u0638\u063A\t*\x02\x02\u0639" +
+    "\u0638\x03\x02\x02\x02\u063A\u063B\x03\x02\x02\x02\u063B\u0639\x03\x02" +
+    "\x02\x02\u063B\u063C\x03\x02\x02\x02\u063C\u063D\x03\x02\x02\x02\u063D" +
+    "\u063E\b\xD0\v\x02\u063E\u01A5\x03\x02\x02\x02\u063F\u0641\n+\x02\x02" +
+    "\u0640\u063F\x03\x02\x02\x02\u0641\u0642\x03\x02\x02\x02\u0642\u0640\x03" +
+    "\x02\x02\x02\u0642\u0643\x03\x02\x02\x02\u0643\u01A7\x03\x02\x02\x02\u0644" +
+    "\u0645\x07}\x02\x02\u0645\u0646\x03\x02\x02\x02\u0646\u0647\b\xD2\x13" +
+    "\x02\u0647\u0648\b\xD2\x02\x02\u0648\u01A9\x03\x02\x02\x02\u0649\u064A" +
+    "\x07>\x02\x02\u064A\u064B\x071\x02\x02\u064B\u064C\x03\x02\x02\x02\u064C" +
+    "\u064D\b\xD3\x03\x02\u064D\u064E\b\xD3\t\x02\u064E\u064F\b\xD3\x04\x02" +
+    "\u064F\u01AB\x03\x02\x02\x02\u0650\u0651\x07>\x02\x02\u0651\u0652\x03" +
+    "\x02\x02\x02\u0652\u0653\b\xD4\x05\x02\u0653\u0654\b\xD4\x06\x02\u0654" +
+    "\u01AD\x03\x02\x02\x02\u0655\u0657\t*\x02\x02\u0656\u0655\x03\x02\x02" +
+    "\x02\u0657\u0658\x03\x02\x02\x02\u0658\u0656\x03\x02\x02\x02\u0658\u0659" +
+    "\x03\x02\x02\x02\u0659\u065A\x03\x02\x02\x02\u065A\u065B\b\xD5\v\x02\u065B" +
+    "\u01AF\x03\x02\x02\x027\x02\x03\x04\x05\x06\x07\u01D8\u02BC\u043C\u0459" +
+    "\u045E\u0464\u0466\u0472\u0474\u0482\u0484\u0489\u0490\u0495\u0499\u049E" +
+    "\u04A3\u04A7\u04AC\u04B3\u04B9\u04BE\u04C5\u04CA\u04D0\u04D5\u04D7\u04DD" +
+    "\u04E2\u04E9\u04F4\u04F6\u0580\u05BF\u05CB\u05D0\u05D4\u05E7\u05E9\u05F9" +
+    "\u05FB\u0611\u0621\u0633\u063B\u0642\u0658\x14\x07\x02\x02\t\x8A\x02\x07" +
+    "\x06\x02\t\x89\x02\x07\x05\x02\x07\x03\x02\x07\x04\x02\x06\x02\x02\b\x02" +
+    "\x02\x02\x03\x02\t\x96\x02\t\x9E\x02\t\x81\x02\x07\x07\x02\tn\x02\t\x7F" +
+    "\x02\ts\x02\t\x85\x02";
+  public static readonly _serializedATN: string = Utils.join(
+    [
+      TSQLLexer._serializedATNSegment0,
+      TSQLLexer._serializedATNSegment1,
+      TSQLLexer._serializedATNSegment2,
+    ],
+    ""
+  );
+  public static __ATN: ATN;
+  public static get _ATN(): ATN {
+    if (!TSQLLexer.__ATN) {
+      TSQLLexer.__ATN = new ATNDeserializer().deserialize(
+        Utils.toCharArray(TSQLLexer._serializedATN)
+      );
+    }
+
+    return TSQLLexer.__ATN;
+  }
+}
diff --git a/internal-packages/tsql/src/grammar/TSQLLexer.typescript.g4 b/internal-packages/tsql/src/grammar/TSQLLexer.typescript.g4
new file mode 100644
index 00000000000..f09eb2aaae7
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLLexer.typescript.g4
@@ -0,0 +1,81 @@
+lexer grammar TSQLLexer;
+
+@header {
+// put any global imports you need here
+}
+
+@members {
+
+private _peekChar(k: number): string {
+    // Return the k-th look-ahead as a *single-char string* or '\0' at EOF.
+    const c = this._input.LA(k);          // int code point or IntStream.EOF (-1)
+    if (c < 0 || c > 0x10FFFF) {         // EOF or out-of-range → sentinel
+        return '\0';
+    }
+    return String.fromCharCode(c);
+}
+
+private _skipWsAndComments(idx: number): number {
+    // Return the first index ≥ idx that is *not* whitespace / single-line comment.
+    while (true) {
+        const ch = this._peekChar(idx);
+        if (/\s/.test(ch)) {                  // spaces, newlines, tabs …
+            idx++;
+            continue;
+        }
+
+        // single-line comments
+        if (ch === '/' && this._peekChar(idx + 1) === '/') {     // //
+            idx += 2;
+        } else if (ch === '-' && this._peekChar(idx + 1) === '-') {   // --
+            idx += 2;
+        } else if (ch === '#') {                                       // #
+            idx++;
+        } else {
+            break;                                             // no ws / comment
+        }
+        // consume until EOL / EOF
+        while (!['\0', '\n', '\r'].includes(this._peekChar(idx))) {
+            idx++;
+        }
+    }
+    return idx;
+}
+
+// ───── opening tag test ─────
+isOpeningTag(): boolean {
+    const ch1 = this._peekChar(1);
+    if (!(/[a-zA-Z]/.test(ch1) || ch1 === '_')) {
+        return false;                           // not a tag name start
+    }
+
+    // skip tag name
+    let i = 2;
+    while (true) {
+        const ch = this._peekChar(i);
+        if (/[a-zA-Z0-9]/.test(ch) || ch === '_' || ch === '-') {
+            i++;
+        } else {
+            break;
+        }
+    }
+
+    let ch = this._peekChar(i);
+
+    // immediate delimiter → tag
+    if (ch === '>' || ch === '/') {
+        return true;
+    }
+
+    // need to look beyond whitespace
+    if (/\s/.test(ch)) {
+        i = this._skipWsAndComments(i + 1);
+        ch = this._peekChar(i);
+        return ch === '>' || ch === '/' || /[a-zA-Z0-9]/.test(ch) || ch === '_';
+    }
+
+    // anything else → not a tag
+    return false;
+}
+
+}
\ No newline at end of file
diff --git a/internal-packages/tsql/src/grammar/TSQLParser.g4 b/internal-packages/tsql/src/grammar/TSQLParser.g4
new file mode 100644
index 00000000000..62d24d8a366
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLParser.g4
@@ -0,0 +1,315 @@
+parser grammar TSQLParser;
+
+options {
+    tokenVocab = TSQLLexer;
+}
+
+
+program: declaration* EOF;
+
+declaration: varDecl | statement ;
+
+expression: columnExpr;
+
+varDecl: LET identifier ( COLON EQ_SINGLE expression )? ;
+identifierList: identifier (COMMA identifier)* COMMA?;
+
+statement      : returnStmt
+               | throwStmt
+               | tryCatchStmt
+               | ifStmt
+               | whileStmt
+               | forInStmt
+               | forStmt
+               | funcStmt
+               | varAssignment
+               | block
+               | exprStmt
+               | emptyStmt
+               ;
+
+returnStmt     : RETURN expression? SEMICOLON?;
+throwStmt      : THROW expression? SEMICOLON?;
+catchBlock     : CATCH (LPAREN catchVar=identifier (COLON catchType=identifier)? RPAREN)? catchStmt=block;
+tryCatchStmt   : TRY tryStmt=block catchBlock* (FINALLY finallyStmt=block)?;
+ifStmt         : IF LPAREN expression RPAREN statement ( ELSE statement )? ;
+whileStmt      : WHILE LPAREN expression RPAREN statement SEMICOLON?;
+forStmt        : FOR LPAREN
+                 (initializerVarDeclr=varDecl | initializerVarAssignment=varAssignment | initializerExpression=expression)? SEMICOLON
+                 condition=expression? SEMICOLON
+                 (incrementVarDeclr=varDecl | incrementVarAssignment=varAssignment | incrementExpression=expression)?
+                 RPAREN statement SEMICOLON?;
+forInStmt      : FOR LPAREN LET identifier (COMMA identifier)? IN expression RPAREN statement SEMICOLON?;
+funcStmt       : (FN | FUN) identifier LPAREN identifierList? RPAREN block;
+varAssignment  : expression COLON EQ_SINGLE expression ;
+exprStmt       : expression SEMICOLON?;
+emptyStmt      : SEMICOLON ;
+block          : LBRACE declaration* RBRACE ;
+
+kvPair: expression ':' expression ;
+kvPairList: kvPair (COMMA kvPair)* COMMA?;
+
+
+// SELECT statement
+select: (selectSetStmt | selectStmt | tSQLxTagElement) SEMICOLON? EOF;
+
+selectStmtWithParens: selectStmt | LPAREN selectSetStmt RPAREN | placeholder;
+
+subsequentSelectSetClause: (EXCEPT | UNION ALL | UNION DISTINCT | INTERSECT | INTERSECT DISTINCT) selectStmtWithParens;
+selectSetStmt: selectStmtWithParens (subsequentSelectSetClause)*;
+
+selectStmt:
+    with=withClause?
+    SELECT DISTINCT? topClause?
+    columns=columnExprList
+    from=fromClause?
+    arrayJoinClause?
+    prewhereClause?
+    where=whereClause?
+    groupByClause? (WITH (CUBE | ROLLUP))? (WITH TOTALS)?
+    havingClause?
+    windowClause?
+    orderByClause?
+    limitByClause?
+    (limitAndOffsetClause | offsetOnlyClause)?
+    settingsClause?
+    ;
+
+withClause: WITH withExprList;
+topClause: TOP DECIMAL_LITERAL (WITH TIES)?;
+fromClause: FROM joinExpr;
+arrayJoinClause: (LEFT | INNER)? ARRAY JOIN columnExprList;
+windowClause: WINDOW identifier AS LPAREN windowExpr RPAREN (COMMA identifier AS LPAREN windowExpr RPAREN)*;
+prewhereClause: PREWHERE columnExpr;
+whereClause: WHERE columnExpr;
+groupByClause: GROUP BY ((CUBE | ROLLUP) LPAREN columnExprList RPAREN | columnExprList);
+havingClause: HAVING columnExpr;
+orderByClause: ORDER BY orderExprList;
+projectionOrderByClause: ORDER BY columnExprList;
+limitByClause: LIMIT limitExpr BY columnExprList;
+limitAndOffsetClause
+    : LIMIT columnExpr (COMMA columnExpr)? (WITH TIES)? // compact OFFSET-optional form
+    | LIMIT columnExpr (WITH TIES)? OFFSET columnExpr // verbose OFFSET-included form with WITH TIES
+    ;
+offsetOnlyClause: OFFSET columnExpr;
+settingsClause: SETTINGS settingExprList;
+
+joinExpr
+    : joinExpr joinOp? JOIN joinExpr joinConstraintClause  # JoinExprOp
+    | joinExpr joinOpCross joinExpr                                          # JoinExprCrossOp
+    | tableExpr FINAL? sampleClause?                                         # JoinExprTable
+    | LPAREN joinExpr RPAREN                                                 # JoinExprParens
+    ;
+joinOp
+    : ((ALL | ANY | ASOF)? INNER | INNER (ALL | ANY | ASOF)? | (ALL | ANY | ASOF))  # JoinOpInner
+    | ( (SEMI | ALL | ANTI | ANY | ASOF)? (LEFT | RIGHT) OUTER?
+      | (LEFT | RIGHT) OUTER? (SEMI | ALL | ANTI | ANY | ASOF)?
+      )                                                                             # JoinOpLeftRight
+    | ((ALL | ANY)? FULL OUTER? | FULL OUTER? (ALL | ANY)?)                         # JoinOpFull
+    ;
+joinOpCross
+    : CROSS JOIN
+    | COMMA
+    ;
+joinConstraintClause
+    : ON columnExprList
+    | USING LPAREN columnExprList RPAREN
+    | USING columnExprList
+    ;
+
+sampleClause: SAMPLE ratioExpr (OFFSET ratioExpr)?;
+limitExpr: columnExpr ((COMMA | OFFSET) columnExpr)?;
+orderExprList: orderExpr (COMMA orderExpr)*;
+orderExpr: columnExpr (ASCENDING | DESCENDING | DESC)? (NULLS (FIRST | LAST))? (COLLATE STRING_LITERAL)?;
+ratioExpr: placeholder | numberLiteral (SLASH numberLiteral)?;
+settingExprList: settingExpr (COMMA settingExpr)*;
+settingExpr: identifier EQ_SINGLE literal;
+
+windowExpr: winPartitionByClause? winOrderByClause? winFrameClause?;
+winPartitionByClause: PARTITION BY columnExprList;
+winOrderByClause: ORDER BY orderExprList;
+winFrameClause: (ROWS | RANGE) winFrameExtend;
+winFrameExtend
+    : winFrameBound                             # frameStart
+    | BETWEEN winFrameBound AND winFrameBound   # frameBetween
+    ;
+winFrameBound: (CURRENT ROW | UNBOUNDED PRECEDING | UNBOUNDED FOLLOWING | numberLiteral PRECEDING | numberLiteral FOLLOWING);
+//rangeClause: RANGE LPAREN (MIN identifier MAX identifier | MAX identifier MIN identifier) RPAREN;
+
+// Columns
+expr: columnExpr EOF;
+columnTypeExpr
+    : identifier                                                                             # ColumnTypeExprSimple   // UInt64
+    | identifier LPAREN identifier columnTypeExpr (COMMA identifier columnTypeExpr)* COMMA? RPAREN  # ColumnTypeExprNested   // Nested
+    | identifier LPAREN enumValue (COMMA enumValue)* COMMA? RPAREN                                  # ColumnTypeExprEnum     // Enum
+    | identifier LPAREN columnTypeExpr (COMMA columnTypeExpr)* COMMA? RPAREN                        # ColumnTypeExprComplex  // Array, Tuple
+    | identifier LPAREN columnExprList? RPAREN                                               # ColumnTypeExprParam    // FixedString(N)
+    ;
+columnExprList: columnExpr (COMMA columnExpr)* COMMA?;
+columnExpr
+    : CASE caseExpr=columnExpr? (WHEN whenExpr=columnExpr THEN thenExpr=columnExpr)+ (ELSE elseExpr=columnExpr)? END          # ColumnExprCase
+    | CAST LPAREN columnExpr AS columnTypeExpr RPAREN                                     # ColumnExprCast
+    | DATE STRING_LITERAL                                                                 # ColumnExprDate
+//    | EXTRACT LPAREN interval FROM columnExpr RPAREN                                      # ColumnExprExtract   // Interferes with a function call
+    | INTERVAL STRING_LITERAL                                                             # ColumnExprIntervalString
+    | INTERVAL columnExpr interval                                                        # ColumnExprInterval
+    | SUBSTRING LPAREN columnExpr FROM columnExpr (FOR columnExpr)? RPAREN                # ColumnExprSubstring
+    | TIMESTAMP STRING_LITERAL                                                            # ColumnExprTimestamp
+    | TRIM LPAREN (BOTH | LEADING | TRAILING) string FROM columnExpr RPAREN               # ColumnExprTrim
+    | identifier (LPAREN columnExprs=columnExprList? RPAREN) (LPAREN DISTINCT? columnArgList=columnExprList? RPAREN)? OVER LPAREN windowExpr RPAREN # ColumnExprWinFunction
+    | identifier (LPAREN columnExprs=columnExprList? RPAREN) (LPAREN DISTINCT? columnArgList=columnExprList? RPAREN)? OVER identifier               # ColumnExprWinFunctionTarget
+    | identifier (LPAREN columnExprs=columnExprList? RPAREN)? LPAREN DISTINCT? columnArgList=columnExprList? RPAREN                                 # ColumnExprFunction
+    | columnExpr LPAREN selectSetStmt RPAREN                                              # ColumnExprCallSelect
+    | columnExpr LPAREN columnExprList? RPAREN                                            # ColumnExprCall
+    | tSQLxTagElement                                                                    # ColumnExprTagElement
+    | templateString                                                                      # ColumnExprTemplateString
+    | literal                                                                             # ColumnExprLiteral
+
+    // FIXME(ilezhankin): this part looks very ugly, maybe there is another way to express it
+    | columnExpr LBRACKET columnExpr RBRACKET                                             # ColumnExprArrayAccess
+    | columnExpr DOT DECIMAL_LITERAL                                                      # ColumnExprTupleAccess
+    | columnExpr DOT identifier                                                           # ColumnExprPropertyAccess
+    | columnExpr NULL_PROPERTY LBRACKET columnExpr RBRACKET                               # ColumnExprNullArrayAccess
+    | columnExpr NULL_PROPERTY DECIMAL_LITERAL                                            # ColumnExprNullTupleAccess
+    | columnExpr NULL_PROPERTY identifier                                                 # ColumnExprNullPropertyAccess
+    | DASH columnExpr                                                                     # ColumnExprNegate
+    | left=columnExpr ( operator=ASTERISK                                                 // *
+                 | operator=SLASH                                                         // /
+                 | operator=PERCENT                                                       // %
+                 ) right=columnExpr                                                       # ColumnExprPrecedence1
+    | left=columnExpr ( operator=PLUS                                                     // +
+                 | operator=DASH                                                          // -
+                 | operator=CONCAT                                                        // ||
+                 ) right=columnExpr                                                       # ColumnExprPrecedence2
+    | left=columnExpr ( operator=EQ_DOUBLE                                                // =
+                 | operator=EQ_SINGLE                                                     // ==
+                 | operator=NOT_EQ                                                        // !=
+                 | operator=LT_EQ                                                         // <=
+                 | operator=LT                                                            // <
+                 | operator=GT_EQ                                                         // >=
+                 | operator=GT                                                            // >
+                 | operator=NOT? IN COHORT?                                               // in, not in; in cohort; not in cohort
+                 | operator=NOT? (LIKE | ILIKE)                                           // like, not like, ilike, not ilike
+                 | operator=REGEX_SINGLE                                                  // ~
+                 | operator=REGEX_DOUBLE                                                  // =~
+                 | operator=NOT_REGEX                                                     // !~
+                 | operator=IREGEX_SINGLE                                                 // ~*
+                 | operator=IREGEX_DOUBLE                                                 // =~*
+                 | operator=NOT_IREGEX                                                    // !~*
+                 ) right=columnExpr                                                       # ColumnExprPrecedence3
+    | columnExpr IS NOT? NULL_SQL                                                         # ColumnExprIsNull
+    | columnExpr NULLISH columnExpr                                                       # ColumnExprNullish
+    | NOT columnExpr                                                                      # ColumnExprNot
+    | columnExpr AND columnExpr                                                           # ColumnExprAnd
+    | columnExpr OR columnExpr                                                            # ColumnExprOr
+    // TODO(ilezhankin): `BETWEEN a AND b AND c` is parsed in a wrong way: `BETWEEN (a AND b) AND c`
+    | columnExpr NOT? BETWEEN columnExpr AND columnExpr                                   # ColumnExprBetween
+    | <assoc=right> columnExpr QUERY columnExpr COLON columnExpr                          # ColumnExprTernaryOp
+    | columnExpr (AS identifier | AS STRING_LITERAL)                                      # ColumnExprAlias
+    | (tableIdentifier DOT)? ASTERISK                                                     # ColumnExprAsterisk  // single-column only
+    | LPAREN selectSetStmt RPAREN                                                         # ColumnExprSubquery  // single-column only
+    | LPAREN columnExpr RPAREN                                                            # ColumnExprParens    // single-column only
+    | LPAREN columnExprList RPAREN                                                        # ColumnExprTuple
+    | LBRACKET columnExprList? RBRACKET                                                   # ColumnExprArray
+    | LBRACE (kvPairList)? RBRACE                                                         # ColumnExprDict
+    | columnLambdaExpr                                                                    # ColumnExprLambda
+    | columnIdentifier                                                                    # ColumnExprIdentifier
+    ;
+
+columnLambdaExpr:
+    ( LPAREN identifier (COMMA identifier)* COMMA? RPAREN
+    |        identifier (COMMA identifier)* COMMA?
+    | LPAREN RPAREN
+    )
+    ARROW (columnExpr | block)
+    ;
+
+tSQLxChildElement
+    : tSQLxTagElement
+    | TSQLX_TEXT_TEXT
+    | LBRACE columnExpr RBRACE;
+
+tSQLxTagElement
+    : LT identifier tSQLxTagAttribute* SLASH_GT                                          
+    | LT identifier tSQLxTagAttribute* GT tSQLxChildElement* LT_SLASH identifier GT     
+    ;
+tSQLxTagAttribute
+    :   identifier EQ_SINGLE string
+    |   identifier EQ_SINGLE LBRACE columnExpr RBRACE
+    |   identifier
+    ;
+
+withExprList: withExpr (COMMA withExpr)* COMMA?;
+withExpr
+    : identifier AS LPAREN selectSetStmt RPAREN    # WithExprSubquery
+    // NOTE: asterisk and subquery goes before |columnExpr| so that we can mark them as multi-column expressions.
+    | columnExpr AS identifier                       # WithExprColumn
+    ;
+
+
+// This is slightly different in TSQL compared to ClickHouse SQL
+// TSQL allows unlimited ("*") nestedIdentifier-s "properties.b.a.a.w.a.s".
+// We parse and convert "databaseIdentifier.tableIdentifier.columnIdentifier.nestedIdentifier.*"
+// to just one ast.Field(chain=['a','b','columnIdentifier','on','and','on']).
+columnIdentifier: placeholder | ((tableIdentifier DOT)? nestedIdentifier);
+nestedIdentifier: identifier (DOT identifier)*;
+tableExpr
+    : tableIdentifier                    # TableExprIdentifier
+    | tableFunctionExpr                  # TableExprFunction
+    | LPAREN selectSetStmt RPAREN      # TableExprSubquery
+    | tableExpr (alias | AS identifier)  # TableExprAlias
+    | tSQLxTagElement                   # TableExprTag
+    | placeholder                        # TableExprPlaceholder
+    ;
+tableFunctionExpr: identifier LPAREN tableArgList? RPAREN;
+tableIdentifier: (databaseIdentifier DOT)? nestedIdentifier;
+tableArgList: columnExpr (COMMA columnExpr)* COMMA?;
+
+// Databases
+
+databaseIdentifier: identifier;
+
+// Basics
+
+floatingLiteral
+    : FLOATING_LITERAL
+    | DOT (DECIMAL_LITERAL | OCTAL_LITERAL)
+    | DECIMAL_LITERAL DOT (DECIMAL_LITERAL | OCTAL_LITERAL)?  // can't move this to the lexer or it will break nested tuple access: t.1.2
+    ;
+numberLiteral: (PLUS | DASH)? (floatingLiteral | OCTAL_LITERAL | DECIMAL_LITERAL | HEXADECIMAL_LITERAL | INF | NAN_SQL);
+literal
+    : numberLiteral
+    | STRING_LITERAL
+    | NULL_SQL
+    ;
+interval: SECOND | MINUTE | HOUR | DAY | WEEK | MONTH | QUARTER | YEAR;
+keyword
+    // except NULL_SQL, INF, NAN_SQL
+    : ALL | AND | ANTI | ANY | ARRAY | AS | ASCENDING | ASOF | BETWEEN | BOTH | BY | CASE
+    | CAST | COHORT | COLLATE | CROSS | CUBE | CURRENT | DATE | DESC | DESCENDING
+    | DISTINCT | ELSE | END | EXTRACT | FINAL | FIRST
+    | FOR | FOLLOWING | FROM | FULL | GROUP | HAVING | ID | IS
+    | IF | ILIKE | IN | INNER | INTERVAL | JOIN | KEY
+    | LAST | LEADING | LEFT | LIKE | LIMIT
+    | NOT | NULLS | OFFSET | ON | OR | ORDER | OUTER | OVER | PARTITION
+    | PRECEDING | PREWHERE | RANGE | RETURN | RIGHT | ROLLUP | ROW
+    | ROWS | SAMPLE | SELECT | SEMI | SETTINGS | SUBSTRING
+    | THEN | TIES | TIMESTAMP | TOTALS | TRAILING | TRIM | TRUNCATE | TO | TOP
+    | UNBOUNDED | UNION | USING | WHEN | WHERE | WINDOW | WITH
+    ;
+keywordForAlias
+    : DATE | FIRST | ID | KEY
+    ;
+alias: IDENTIFIER | keywordForAlias;  // |interval| can't be an alias, otherwise 'INTERVAL 1 SOMETHING' becomes ambiguous.
+identifier: IDENTIFIER | interval | keyword;
+enumValue: string EQ_SINGLE numberLiteral;
+placeholder: LBRACE columnExpr RBRACE;
+
+string: STRING_LITERAL | templateString;
+templateString : QUOTE_SINGLE_TEMPLATE stringContents* QUOTE_SINGLE ;
+stringContents : STRING_ESCAPE_TRIGGER columnExpr RBRACE | STRING_TEXT;
+
+// These are magic "full template strings", which are used to parse "full text field" templates without the surrounding SQL.
+// We will need to add F' to the start of the string to change the lexer's mode.
+fullTemplateString: QUOTE_SINGLE_TEMPLATE_FULL stringContentsFull* EOF ;
+stringContentsFull : FULL_STRING_ESCAPE_TRIGGER columnExpr RBRACE | FULL_STRING_TEXT;
\ No newline at end of file
diff --git a/internal-packages/tsql/src/grammar/TSQLParser.interp b/internal-packages/tsql/src/grammar/TSQLParser.interp
new file mode 100644
index 00000000000..3ad726c89dd
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLParser.interp
@@ -0,0 +1,437 @@
+token literal names:
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+'->'
+'*'
+'`'
+'\\'
+':'
+','
+'||'
+'-'
+'$'
+'.'
+'=='
+null
+'>='
+null
+'#'
+'~*'
+'=~*'
+'{'
+'['
+'('
+'<='
+'<'
+'</'
+null
+'!~*'
+'!~'
+'?.'
+'??'
+'%'
+'+'
+'?'
+'"'
+'f\''
+'F\''
+'\''
+'~'
+'=~'
+'}'
+']'
+')'
+';'
+'/'
+null
+'_'
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+ALL
+AND
+ANTI
+ANY
+ARRAY
+AS
+ASCENDING
+ASOF
+BETWEEN
+BOTH
+BY
+CASE
+CAST
+CATCH
+COHORT
+COLLATE
+CROSS
+CUBE
+CURRENT
+DATE
+DAY
+DESC
+DESCENDING
+DISTINCT
+ELSE
+END
+EXCEPT
+EXTRACT
+FINAL
+FINALLY
+FIRST
+FN
+FOLLOWING
+FOR
+FROM
+FULL
+FUN
+GROUP
+HAVING
+HOUR
+ID
+IF
+ILIKE
+IN
+INF
+INNER
+INTERSECT
+INTERVAL
+IS
+JOIN
+KEY
+LAST
+LEADING
+LEFT
+LET
+LIKE
+LIMIT
+MINUTE
+MONTH
+NAN_SQL
+NOT
+NULL_SQL
+NULLS
+OFFSET
+ON
+OR
+ORDER
+OUTER
+OVER
+PARTITION
+PRECEDING
+PREWHERE
+QUARTER
+RANGE
+RETURN
+RIGHT
+ROLLUP
+ROW
+ROWS
+SAMPLE
+SECOND
+SELECT
+SEMI
+SETTINGS
+SUBSTRING
+THEN
+THROW
+TIES
+TIMESTAMP
+TO
+TOP
+TOTALS
+TRAILING
+TRIM
+TRUNCATE
+TRY
+UNBOUNDED
+UNION
+USING
+WEEK
+WHEN
+WHERE
+WHILE
+WINDOW
+WITH
+YEAR
+ESCAPE_CHAR_COMMON
+IDENTIFIER
+FLOATING_LITERAL
+OCTAL_LITERAL
+DECIMAL_LITERAL
+HEXADECIMAL_LITERAL
+STRING_LITERAL
+ARROW
+ASTERISK
+BACKQUOTE
+BACKSLASH
+COLON
+COMMA
+CONCAT
+DASH
+DOLLAR
+DOT
+EQ_DOUBLE
+EQ_SINGLE
+GT_EQ
+GT
+HASH
+IREGEX_SINGLE
+IREGEX_DOUBLE
+LBRACE
+LBRACKET
+LPAREN
+LT_EQ
+LT
+LT_SLASH
+NOT_EQ
+NOT_IREGEX
+NOT_REGEX
+NULL_PROPERTY
+NULLISH
+PERCENT
+PLUS
+QUERY
+QUOTE_DOUBLE
+QUOTE_SINGLE_TEMPLATE
+QUOTE_SINGLE_TEMPLATE_FULL
+QUOTE_SINGLE
+REGEX_SINGLE
+REGEX_DOUBLE
+RBRACE
+RBRACKET
+RPAREN
+SEMICOLON
+SLASH
+SLASH_GT
+UNDERSCORE
+MULTI_LINE_COMMENT
+SINGLE_LINE_COMMENT
+WHITESPACE
+STRING_TEXT
+STRING_ESCAPE_TRIGGER
+FULL_STRING_TEXT
+FULL_STRING_ESCAPE_TRIGGER
+TAG_WS
+TAGC_WS
+TSQLX_TEXT_TEXT
+TSQLX_TEXT_WS
+
+rule names:
+program
+declaration
+expression
+varDecl
+identifierList
+statement
+returnStmt
+throwStmt
+catchBlock
+tryCatchStmt
+ifStmt
+whileStmt
+forStmt
+forInStmt
+funcStmt
+varAssignment
+exprStmt
+emptyStmt
+block
+kvPair
+kvPairList
+select
+selectStmtWithParens
+subsequentSelectSetClause
+selectSetStmt
+selectStmt
+withClause
+topClause
+fromClause
+arrayJoinClause
+windowClause
+prewhereClause
+whereClause
+groupByClause
+havingClause
+orderByClause
+projectionOrderByClause
+limitByClause
+limitAndOffsetClause
+offsetOnlyClause
+settingsClause
+joinExpr
+joinOp
+joinOpCross
+joinConstraintClause
+sampleClause
+limitExpr
+orderExprList
+orderExpr
+ratioExpr
+settingExprList
+settingExpr
+windowExpr
+winPartitionByClause
+winOrderByClause
+winFrameClause
+winFrameExtend
+winFrameBound
+expr
+columnTypeExpr
+columnExprList
+columnExpr
+columnLambdaExpr
+tSQLxChildElement
+tSQLxTagElement
+tSQLxTagAttribute
+withExprList
+withExpr
+columnIdentifier
+nestedIdentifier
+tableExpr
+tableFunctionExpr
+tableIdentifier
+tableArgList
+databaseIdentifier
+floatingLiteral
+numberLiteral
+literal
+interval
+keyword
+keywordForAlias
+alias
+identifier
+enumValue
+placeholder
+string
+templateString
+stringContents
+fullTemplateString
+stringContentsFull
+
+
+atn:
+[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 3, 170, 1341, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 3, 2, 7, 2, 184, 10, 2, 12, 2, 14, 2, 187, 11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 5, 3, 193, 10, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 202, 10, 5, 3, 6, 3, 6, 3, 6, 7, 6, 207, 10, 6, 12, 6, 14, 6, 210, 11, 6, 3, 6, 5, 6, 213, 10, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 227, 10, 7, 3, 8, 3, 8, 5, 8, 231, 10, 8, 3, 8, 5, 8, 234, 10, 8, 3, 9, 3, 9, 5, 9, 238, 10, 9, 3, 9, 5, 9, 241, 10, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 248, 10, 10, 3, 10, 3, 10, 5, 10, 252, 10, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 7, 11, 259, 10, 11, 12, 11, 14, 11, 262, 11, 11, 3, 11, 3, 11, 5, 11, 266, 10, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 275, 10, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 283, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 290, 10, 14, 3, 14, 3, 14, 5, 14, 294, 10, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 300, 10, 14, 3, 14, 3, 14, 3, 14, 5, 14, 305, 10, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 313, 10, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 320, 10, 15, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 326, 10, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 5, 18, 338, 10, 18, 3, 19, 3, 19, 3, 20, 3, 20, 7, 20, 344, 10, 20, 12, 20, 14, 20, 347, 11, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 7, 22, 358, 10, 22, 12, 22, 14, 22, 361, 11, 22, 3, 22, 5, 22, 364, 10, 22, 3, 23, 3, 23, 3, 23, 5, 23, 369, 10, 23, 3, 23, 5, 23, 372, 10, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 382, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 392, 10, 25, 3, 25, 3, 25, 3, 26, 3, 26, 7, 26, 398, 10, 26, 12, 26, 14, 26, 401, 11, 26, 3, 27, 5, 27, 404, 10, 27, 3, 27, 3, 27, 5, 27, 408, 10, 27, 3, 27, 5, 27, 411, 10, 27, 3, 27, 3, 27, 5, 27, 415, 10, 27, 3, 27, 5, 27, 418, 10, 27, 3, 27, 5, 27, 421, 10, 27, 3, 27, 5, 27, 424, 10, 27, 3, 27, 5, 27, 427, 10, 27, 3, 27, 3, 27, 5, 27, 431, 10, 27, 3, 27, 3, 27, 5, 27, 435, 10, 27, 3, 27, 5, 27, 438, 10, 27, 3, 27, 5, 27, 441, 10, 27, 3, 27, 5, 27, 444, 10, 27, 3, 27, 5, 27, 447, 10, 27, 3, 27, 3, 27, 5, 27, 451, 10, 27, 3, 27, 5, 27, 454, 10, 27, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 463, 10, 29, 3, 30, 3, 30, 3, 30, 3, 31, 5, 31, 469, 10, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 7, 32, 488, 10, 32, 12, 32, 14, 32, 491, 11, 32, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 507, 10, 35, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 529, 10, 40, 3, 40, 3, 40, 5, 40, 533, 10, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 539, 10, 40, 3, 40, 3, 40, 3, 40, 5, 40, 544, 10, 40, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 5, 43, 555, 10, 43, 3, 43, 5, 43, 558, 10, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 564, 10, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 572, 10, 43, 3, 43, 3, 43, 3, 43, 3, 43, 7, 43, 578, 10, 43, 12, 43, 14, 43, 581, 11, 43, 3, 44, 5, 44, 584, 10, 44, 3, 44, 3, 44, 3, 44, 5, 44, 589, 10, 44, 3, 44, 5, 44, 592, 10, 44, 3, 44, 5, 44, 595, 10, 44, 3, 44, 3, 44, 5, 44, 599, 10, 44, 3, 44, 3, 44, 5, 44, 603, 10, 44, 3, 44, 5, 44, 606, 10, 44, 5, 44, 608, 10, 44, 3, 44, 5, 44, 611, 10, 44, 3, 44, 3, 44, 5, 44, 615, 10, 44, 3, 44, 3, 44, 5, 44, 619, 10, 44, 3, 44, 5, 44, 622, 10, 44, 5, 44, 624, 10, 44, 5, 44, 626, 10, 44, 3, 45, 3, 45, 3, 45, 5, 45, 631, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 5, 46, 642, 10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 648, 10, 47, 3, 48, 3, 48, 3, 48, 5, 48, 653, 10, 48, 3, 49, 3, 49, 3, 49, 7, 49, 658, 10, 49, 12, 49, 14, 49, 661, 11, 49, 3, 50, 3, 50, 5, 50, 665, 10, 50, 3, 50, 3, 50, 5, 50, 669, 10, 50, 3, 50, 3, 50, 5, 50, 673, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 679, 10, 51, 5, 51, 681, 10, 51, 3, 52, 3, 52, 3, 52, 7, 52, 686, 10, 52, 12, 52, 14, 52, 689, 11, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 5, 54, 696, 10, 54, 3, 54, 5, 54, 699, 10, 54, 3, 54, 5, 54, 702, 10, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 721, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 735, 10, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 7, 61, 749, 10, 61, 12, 61, 14, 61, 752, 11, 61, 3, 61, 5, 61, 755, 10, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 7, 61, 764, 10, 61, 12, 61, 14, 61, 767, 11, 61, 3, 61, 5, 61, 770, 10, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 7, 61, 779, 10, 61, 12, 61, 14, 61, 782, 11, 61, 3, 61, 5, 61, 785, 10, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 5, 61, 792, 10, 61, 3, 61, 3, 61, 5, 61, 796, 10, 61, 3, 62, 3, 62, 3, 62, 7, 62, 801, 10, 62, 12, 62, 14, 62, 804, 11, 62, 3, 62, 5, 62, 807, 10, 62, 3, 63, 3, 63, 3, 63, 5, 63, 812, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 6, 63, 819, 10, 63, 13, 63, 14, 63, 820, 3, 63, 3, 63, 5, 63, 825, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 851, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 868, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 874, 10, 63, 3, 63, 5, 63, 877, 10, 63, 3, 63, 5, 63, 880, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 890, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 896, 10, 63, 3, 63, 5, 63, 899, 10, 63, 3, 63, 5, 63, 902, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 910, 10, 63, 3, 63, 5, 63, 913, 10, 63, 3, 63, 3, 63, 5, 63, 917, 10, 63, 3, 63, 5, 63, 920, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 934, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 951, 10, 63, 3, 63, 3, 63, 3, 63, 5, 63, 956, 10, 63, 3, 63, 3, 63, 3, 63, 5, 63, 961, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 967, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 974, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 986, 10, 63, 3, 63, 3, 63, 5, 63, 990, 10, 63, 3, 63, 5, 63, 993, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1002, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1016, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1037, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1066, 10, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1074, 10, 63, 7, 63, 1076, 10, 63, 12, 63, 14, 63, 1079, 11, 63, 3, 64, 3, 64, 3, 64, 3, 64, 7, 64, 1085, 10, 64, 12, 64, 14, 64, 1088, 11, 64, 3, 64, 5, 64, 1091, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 7, 64, 1098, 10, 64, 12, 64, 14, 64, 1101, 11, 64, 3, 64, 5, 64, 1104, 10, 64, 3, 64, 3, 64, 5, 64, 1108, 10, 64, 3, 64, 3, 64, 3, 64, 5, 64, 1113, 10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 1121, 10, 65, 3, 66, 3, 66, 3, 66, 7, 66, 1126, 10, 66, 12, 66, 14, 66, 1129, 11, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 7, 66, 1136, 10, 66, 12, 66, 14, 66, 1139, 11, 66, 3, 66, 3, 66, 7, 66, 1143, 10, 66, 12, 66, 14, 66, 1146, 11, 66, 3, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1152, 10, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 5, 67, 1165, 10, 67, 3, 68, 3, 68, 3, 68, 7, 68, 1170, 10, 68, 12, 68, 14, 68, 1173, 11, 68, 3, 68, 5, 68, 1176, 10, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 1188, 10, 69, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 1194, 10, 70, 3, 70, 5, 70, 1197, 10, 70, 3, 71, 3, 71, 3, 71, 7, 71, 1202, 10, 71, 12, 71, 14, 71, 1205, 11, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 1216, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 1222, 10, 72, 7, 72, 1224, 10, 72, 12, 72, 14, 72, 1227, 11, 72, 3, 73, 3, 73, 3, 73, 5, 73, 1232, 10, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 5, 74, 1239, 10, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 7, 75, 1246, 10, 75, 12, 75, 14, 75, 1249, 11, 75, 3, 75, 5, 75, 1252, 10, 75, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 5, 77, 1262, 10, 77, 5, 77, 1264, 10, 77, 3, 78, 5, 78, 1267, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1275, 10, 78, 3, 79, 3, 79, 3, 79, 5, 79, 1280, 10, 79, 3, 80, 3, 80, 3, 81, 3, 81, 3, 82, 3, 82, 3, 83, 3, 83, 5, 83, 1290, 10, 83, 3, 84, 3, 84, 3, 84, 5, 84, 1295, 10, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 1307, 10, 87, 3, 88, 3, 88, 7, 88, 1311, 10, 88, 12, 88, 14, 88, 1314, 11, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 5, 89, 1323, 10, 89, 3, 90, 3, 90, 7, 90, 1327, 10, 90, 12, 90, 14, 90, 1330, 11, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 5, 91, 1339, 10, 91, 3, 91, 2, 2, 5, 84, 124, 142, 92, 2, 2, 4, 2, 6, 2, 8, 2, 10, 2, 12, 2, 14, 2, 16, 2, 18, 2, 20, 2, 22, 2, 24, 2, 26, 2, 28, 2, 30, 2, 32, 2, 34, 2, 36, 2, 38, 2, 40, 2, 42, 2, 44, 2, 46, 2, 48, 2, 50, 2, 52, 2, 54, 2, 56, 2, 58, 2, 60, 2, 62, 2, 64, 2, 66, 2, 68, 2, 70, 2, 72, 2, 74, 2, 76, 2, 78, 2, 80, 2, 82, 2, 84, 2, 86, 2, 88, 2, 90, 2, 92, 2, 94, 2, 96, 2, 98, 2, 100, 2, 102, 2, 104, 2, 106, 2, 108, 2, 110, 2, 112, 2, 114, 2, 116, 2, 118, 2, 120, 2, 122, 2, 124, 2, 126, 2, 128, 2, 130, 2, 132, 2, 134, 2, 136, 2, 138, 2, 140, 2, 142, 2, 144, 2, 146, 2, 148, 2, 150, 2, 152, 2, 154, 2, 156, 2, 158, 2, 160, 2, 162, 2, 164, 2, 166, 2, 168, 2, 170, 2, 172, 2, 174, 2, 176, 2, 178, 2, 180, 2, 2, 20, 4, 2, 34, 34, 39, 39, 4, 2, 20, 20, 79, 79, 4, 2, 48, 48, 56, 56, 5, 2, 3, 3, 6, 6, 10, 10, 6, 2, 3, 3, 5, 6, 10, 10, 85, 85, 4, 2, 56, 56, 78, 78, 4, 2, 3, 3, 6, 6, 4, 2, 66, 66, 121, 121, 4, 2, 9, 9, 24, 25, 4, 2, 33, 33, 54, 54, 4, 2, 76, 76, 81, 81, 5, 2, 12, 12, 55, 55, 95, 95, 4, 2, 45, 45, 58, 58, 3, 2, 112, 113, 4, 2, 123, 123, 145, 145, 9, 2, 23, 23, 42, 42, 60, 61, 75, 75, 83, 83, 102, 102, 108, 108, 21, 2, 3, 15, 17, 22, 24, 28, 30, 31, 33, 33, 35, 38, 40, 41, 43, 46, 48, 48, 50, 56, 58, 59, 63, 63, 65, 74, 76, 82, 84, 88, 90, 97, 99, 101, 103, 104, 106, 107, 6, 2, 22, 22, 33, 33, 43, 43, 53, 53, 2, 1516, 2, 185, 3, 2, 2, 2, 4, 192, 3, 2, 2, 2, 6, 194, 3, 2, 2, 2, 8, 196, 3, 2, 2, 2, 10, 203, 3, 2, 2, 2, 12, 226, 3, 2, 2, 2, 14, 228, 3, 2, 2, 2, 16, 235, 3, 2, 2, 2, 18, 242, 3, 2, 2, 2, 20, 255, 3, 2, 2, 2, 22, 267, 3, 2, 2, 2, 24, 276, 3, 2, 2, 2, 26, 284, 3, 2, 2, 2, 28, 306, 3, 2, 2, 2, 30, 321, 3, 2, 2, 2, 32, 330, 3, 2, 2, 2, 34, 335, 3, 2, 2, 2, 36, 339, 3, 2, 2, 2, 38, 341, 3, 2, 2, 2, 40, 350, 3, 2, 2, 2, 42, 354, 3, 2, 2, 2, 44, 368, 3, 2, 2, 2, 46, 381, 3, 2, 2, 2, 48, 391, 3, 2, 2, 2, 50, 395, 3, 2, 2, 2, 52, 403, 3, 2, 2, 2, 54, 455, 3, 2, 2, 2, 56, 458, 3, 2, 2, 2, 58, 464, 3, 2, 2, 2, 60, 468, 3, 2, 2, 2, 62, 474, 3, 2, 2, 2, 64, 492, 3, 2, 2, 2, 66, 495, 3, 2, 2, 2, 68, 498, 3, 2, 2, 2, 70, 508, 3, 2, 2, 2, 72, 511, 3, 2, 2, 2, 74, 515, 3, 2, 2, 2, 76, 519, 3, 2, 2, 2, 78, 543, 3, 2, 2, 2, 80, 545, 3, 2, 2, 2, 82, 548, 3, 2, 2, 2, 84, 563, 3, 2, 2, 2, 86, 625, 3, 2, 2, 2, 88, 630, 3, 2, 2, 2, 90, 641, 3, 2, 2, 2, 92, 643, 3, 2, 2, 2, 94, 649, 3, 2, 2, 2, 96, 654, 3, 2, 2, 2, 98, 662, 3, 2, 2, 2, 100, 680, 3, 2, 2, 2, 102, 682, 3, 2, 2, 2, 104, 690, 3, 2, 2, 2, 106, 695, 3, 2, 2, 2, 108, 703, 3, 2, 2, 2, 110, 707, 3, 2, 2, 2, 112, 711, 3, 2, 2, 2, 114, 720, 3, 2, 2, 2, 116, 734, 3, 2, 2, 2, 118, 736, 3, 2, 2, 2, 120, 795, 3, 2, 2, 2, 122, 797, 3, 2, 2, 2, 124, 960, 3, 2, 2, 2, 126, 1107, 3, 2, 2, 2, 128, 1120, 3, 2, 2, 2, 130, 1151, 3, 2, 2, 2, 132, 1164, 3, 2, 2, 2, 134, 1166, 3, 2, 2, 2, 136, 1187, 3, 2, 2, 2, 138, 1196, 3, 2, 2, 2, 140, 1198, 3, 2, 2, 2, 142, 1215, 3, 2, 2, 2, 144, 1228, 3, 2, 2, 2, 146, 1238, 3, 2, 2, 2, 148, 1242, 3, 2, 2, 2, 150, 1253, 3, 2, 2, 2, 152, 1263, 3, 2, 2, 2, 154, 1266, 3, 2, 2, 2, 156, 1279, 3, 2, 2, 2, 158, 1281, 3, 2, 2, 2, 160, 1283, 3, 2, 2, 2, 162, 1285, 3, 2, 2, 2, 164, 1289, 3, 2, 2, 2, 166, 1294, 3, 2, 2, 2, 168, 1296, 3, 2, 2, 2, 170, 1300, 3, 2, 2, 2, 172, 1306, 3, 2, 2, 2, 174, 1308, 3, 2, 2, 2, 176, 1322, 3, 2, 2, 2, 178, 1324, 3, 2, 2, 2, 180, 1338, 3, 2, 2, 2, 182, 184, 5, 4, 3, 2, 183, 182, 3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 185, 186, 3, 2, 2, 2, 186, 188, 3, 2, 2, 2, 187, 185, 3, 2, 2, 2, 188, 189, 7, 2, 2, 3, 189, 3, 3, 2, 2, 2, 190, 193, 5, 8, 5, 2, 191, 193, 5, 12, 7, 2, 192, 190, 3, 2, 2, 2, 192, 191, 3, 2, 2, 2, 193, 5, 3, 2, 2, 2, 194, 195, 5, 124, 63, 2, 195, 7, 3, 2, 2, 2, 196, 197, 7, 57, 2, 2, 197, 201, 5, 166, 84, 2, 198, 199, 7, 120, 2, 2, 199, 200, 7, 127, 2, 2, 200, 202, 5, 6, 4, 2, 201, 198, 3, 2, 2, 2, 201, 202, 3, 2, 2, 2, 202, 9, 3, 2, 2, 2, 203, 208, 5, 166, 84, 2, 204, 205, 7, 121, 2, 2, 205, 207, 5, 166, 84, 2, 206, 204, 3, 2, 2, 2, 207, 210, 3, 2, 2, 2, 208, 206, 3, 2, 2, 2, 208, 209, 3, 2, 2, 2, 209, 212, 3, 2, 2, 2, 210, 208, 3, 2, 2, 2, 211, 213, 7, 121, 2, 2, 212, 211, 3, 2, 2, 2, 212, 213, 3, 2, 2, 2, 213, 11, 3, 2, 2, 2, 214, 227, 5, 14, 8, 2, 215, 227, 5, 16, 9, 2, 216, 227, 5, 20, 11, 2, 217, 227, 5, 22, 12, 2, 218, 227, 5, 24, 13, 2, 219, 227, 5, 28, 15, 2, 220, 227, 5, 26, 14, 2, 221, 227, 5, 30, 16, 2, 222, 227, 5, 32, 17, 2, 223, 227, 5, 38, 20, 2, 224, 227, 5, 34, 18, 2, 225, 227, 5, 36, 19, 2, 226, 214, 3, 2, 2, 2, 226, 215, 3, 2, 2, 2, 226, 216, 3, 2, 2, 2, 226, 217, 3, 2, 2, 2, 226, 218, 3, 2, 2, 2, 226, 219, 3, 2, 2, 2, 226, 220, 3, 2, 2, 2, 226, 221, 3, 2, 2, 2, 226, 222, 3, 2, 2, 2, 226, 223, 3, 2, 2, 2, 226, 224, 3, 2, 2, 2, 226, 225, 3, 2, 2, 2, 227, 13, 3, 2, 2, 2, 228, 230, 7, 77, 2, 2, 229, 231, 5, 6, 4, 2, 230, 229, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 233, 3, 2, 2, 2, 232, 234, 7, 156, 2, 2, 233, 232, 3, 2, 2, 2, 233, 234, 3, 2, 2, 2, 234, 15, 3, 2, 2, 2, 235, 237, 7, 89, 2, 2, 236, 238, 5, 6, 4, 2, 237, 236, 3, 2, 2, 2, 237, 238, 3, 2, 2, 2, 238, 240, 3, 2, 2, 2, 239, 241, 7, 156, 2, 2, 240, 239, 3, 2, 2, 2, 240, 241, 3, 2, 2, 2, 241, 17, 3, 2, 2, 2, 242, 251, 7, 16, 2, 2, 243, 244, 7, 135, 2, 2, 244, 247, 5, 166, 84, 2, 245, 246, 7, 120, 2, 2, 246, 248, 5, 166, 84, 2, 247, 245, 3, 2, 2, 2, 247, 248, 3, 2, 2, 2, 248, 249, 3, 2, 2, 2, 249, 250, 7, 155, 2, 2, 250, 252, 3, 2, 2, 2, 251, 243, 3, 2, 2, 2, 251, 252, 3, 2, 2, 2, 252, 253, 3, 2, 2, 2, 253, 254, 5, 38, 20, 2, 254, 19, 3, 2, 2, 2, 255, 256, 7, 98, 2, 2, 256, 260, 5, 38, 20, 2, 257, 259, 5, 18, 10, 2, 258, 257, 3, 2, 2, 2, 259, 262, 3, 2, 2, 2, 260, 258, 3, 2, 2, 2, 260, 261, 3, 2, 2, 2, 261, 265, 3, 2, 2, 2, 262, 260, 3, 2, 2, 2, 263, 264, 7, 32, 2, 2, 264, 266, 5, 38, 20, 2, 265, 263, 3, 2, 2, 2, 265, 266, 3, 2, 2, 2, 266, 21, 3, 2, 2, 2, 267, 268, 7, 44, 2, 2, 268, 269, 7, 135, 2, 2, 269, 270, 5, 6, 4, 2, 270, 271, 7, 155, 2, 2, 271, 274, 5, 12, 7, 2, 272, 273, 7, 27, 2, 2, 273, 275, 5, 12, 7, 2, 274, 272, 3, 2, 2, 2, 274, 275, 3, 2, 2, 2, 275, 23, 3, 2, 2, 2, 276, 277, 7, 105, 2, 2, 277, 278, 7, 135, 2, 2, 278, 279, 5, 6, 4, 2, 279, 280, 7, 155, 2, 2, 280, 282, 5, 12, 7, 2, 281, 283, 7, 156, 2, 2, 282, 281, 3, 2, 2, 2, 282, 283, 3, 2, 2, 2, 283, 25, 3, 2, 2, 2, 284, 285, 7, 36, 2, 2, 285, 289, 7, 135, 2, 2, 286, 290, 5, 8, 5, 2, 287, 290, 5, 32, 17, 2, 288, 290, 5, 6, 4, 2, 289, 286, 3, 2, 2, 2, 289, 287, 3, 2, 2, 2, 289, 288, 3, 2, 2, 2, 289, 290, 3, 2, 2, 2, 290, 291, 3, 2, 2, 2, 291, 293, 7, 156, 2, 2, 292, 294, 5, 6, 4, 2, 293, 292, 3, 2, 2, 2, 293, 294, 3, 2, 2, 2, 294, 295, 3, 2, 2, 2, 295, 299, 7, 156, 2, 2, 296, 300, 5, 8, 5, 2, 297, 300, 5, 32, 17, 2, 298, 300, 5, 6, 4, 2, 299, 296, 3, 2, 2, 2, 299, 297, 3, 2, 2, 2, 299, 298, 3, 2, 2, 2, 299, 300, 3, 2, 2, 2, 300, 301, 3, 2, 2, 2, 301, 302, 7, 155, 2, 2, 302, 304, 5, 12, 7, 2, 303, 305, 7, 156, 2, 2, 304, 303, 3, 2, 2, 2, 304, 305, 3, 2, 2, 2, 305, 27, 3, 2, 2, 2, 306, 307, 7, 36, 2, 2, 307, 308, 7, 135, 2, 2, 308, 309, 7, 57, 2, 2, 309, 312, 5, 166, 84, 2, 310, 311, 7, 121, 2, 2, 311, 313, 5, 166, 84, 2, 312, 310, 3, 2, 2, 2, 312, 313, 3, 2, 2, 2, 313, 314, 3, 2, 2, 2, 314, 315, 7, 46, 2, 2, 315, 316, 5, 6, 4, 2, 316, 317, 7, 155, 2, 2, 317, 319, 5, 12, 7, 2, 318, 320, 7, 156, 2, 2, 319, 318, 3, 2, 2, 2, 319, 320, 3, 2, 2, 2, 320, 29, 3, 2, 2, 2, 321, 322, 9, 2, 2, 2, 322, 323, 5, 166, 84, 2, 323, 325, 7, 135, 2, 2, 324, 326, 5, 10, 6, 2, 325, 324, 3, 2, 2, 2, 325, 326, 3, 2, 2, 2, 326, 327, 3, 2, 2, 2, 327, 328, 7, 155, 2, 2, 328, 329, 5, 38, 20, 2, 329, 31, 3, 2, 2, 2, 330, 331, 5, 6, 4, 2, 331, 332, 7, 120, 2, 2, 332, 333, 7, 127, 2, 2, 333, 334, 5, 6, 4, 2, 334, 33, 3, 2, 2, 2, 335, 337, 5, 6, 4, 2, 336, 338, 7, 156, 2, 2, 337, 336, 3, 2, 2, 2, 337, 338, 3, 2, 2, 2, 338, 35, 3, 2, 2, 2, 339, 340, 7, 156, 2, 2, 340, 37, 3, 2, 2, 2, 341, 345, 7, 133, 2, 2, 342, 344, 5, 4, 3, 2, 343, 342, 3, 2, 2, 2, 344, 347, 3, 2, 2, 2, 345, 343, 3, 2, 2, 2, 345, 346, 3, 2, 2, 2, 346, 348, 3, 2, 2, 2, 347, 345, 3, 2, 2, 2, 348, 349, 7, 153, 2, 2, 349, 39, 3, 2, 2, 2, 350, 351, 5, 6, 4, 2, 351, 352, 7, 120, 2, 2, 352, 353, 5, 6, 4, 2, 353, 41, 3, 2, 2, 2, 354, 359, 5, 40, 21, 2, 355, 356, 7, 121, 2, 2, 356, 358, 5, 40, 21, 2, 357, 355, 3, 2, 2, 2, 358, 361, 3, 2, 2, 2, 359, 357, 3, 2, 2, 2, 359, 360, 3, 2, 2, 2, 360, 363, 3, 2, 2, 2, 361, 359, 3, 2, 2, 2, 362, 364, 7, 121, 2, 2, 363, 362, 3, 2, 2, 2, 363, 364, 3, 2, 2, 2, 364, 43, 3, 2, 2, 2, 365, 369, 5, 50, 26, 2, 366, 369, 5, 52, 27, 2, 367, 369, 5, 130, 66, 2, 368, 365, 3, 2, 2, 2, 368, 366, 3, 2, 2, 2, 368, 367, 3, 2, 2, 2, 369, 371, 3, 2, 2, 2, 370, 372, 7, 156, 2, 2, 371, 370, 3, 2, 2, 2, 371, 372, 3, 2, 2, 2, 372, 373, 3, 2, 2, 2, 373, 374, 7, 2, 2, 3, 374, 45, 3, 2, 2, 2, 375, 382, 5, 52, 27, 2, 376, 377, 7, 135, 2, 2, 377, 378, 5, 50, 26, 2, 378, 379, 7, 155, 2, 2, 379, 382, 3, 2, 2, 2, 380, 382, 5, 170, 86, 2, 381, 375, 3, 2, 2, 2, 381, 376, 3, 2, 2, 2, 381, 380, 3, 2, 2, 2, 382, 47, 3, 2, 2, 2, 383, 392, 7, 29, 2, 2, 384, 385, 7, 100, 2, 2, 385, 392, 7, 3, 2, 2, 386, 387, 7, 100, 2, 2, 387, 392, 7, 26, 2, 2, 388, 392, 7, 49, 2, 2, 389, 390, 7, 49, 2, 2, 390, 392, 7, 26, 2, 2, 391, 383, 3, 2, 2, 2, 391, 384, 3, 2, 2, 2, 391, 386, 3, 2, 2, 2, 391, 388, 3, 2, 2, 2, 391, 389, 3, 2, 2, 2, 392, 393, 3, 2, 2, 2, 393, 394, 5, 46, 24, 2, 394, 49, 3, 2, 2, 2, 395, 399, 5, 46, 24, 2, 396, 398, 5, 48, 25, 2, 397, 396, 3, 2, 2, 2, 398, 401, 3, 2, 2, 2, 399, 397, 3, 2, 2, 2, 399, 400, 3, 2, 2, 2, 400, 51, 3, 2, 2, 2, 401, 399, 3, 2, 2, 2, 402, 404, 5, 54, 28, 2, 403, 402, 3, 2, 2, 2, 403, 404, 3, 2, 2, 2, 404, 405, 3, 2, 2, 2, 405, 407, 7, 84, 2, 2, 406, 408, 7, 26, 2, 2, 407, 406, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 410, 3, 2, 2, 2, 409, 411, 5, 56, 29, 2, 410, 409, 3, 2, 2, 2, 410, 411, 3, 2, 2, 2, 411, 412, 3, 2, 2, 2, 412, 414, 5, 122, 62, 2, 413, 415, 5, 58, 30, 2, 414, 413, 3, 2, 2, 2, 414, 415, 3, 2, 2, 2, 415, 417, 3, 2, 2, 2, 416, 418, 5, 60, 31, 2, 417, 416, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418, 420, 3, 2, 2, 2, 419, 421, 5, 64, 33, 2, 420, 419, 3, 2, 2, 2, 420, 421, 3, 2, 2, 2, 421, 423, 3, 2, 2, 2, 422, 424, 5, 66, 34, 2, 423, 422, 3, 2, 2, 2, 423, 424, 3, 2, 2, 2, 424, 426, 3, 2, 2, 2, 425, 427, 5, 68, 35, 2, 426, 425, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 430, 3, 2, 2, 2, 428, 429, 7, 107, 2, 2, 429, 431, 9, 3, 2, 2, 430, 428, 3, 2, 2, 2, 430, 431, 3, 2, 2, 2, 431, 434, 3, 2, 2, 2, 432, 433, 7, 107, 2, 2, 433, 435, 7, 94, 2, 2, 434, 432, 3, 2, 2, 2, 434, 435, 3, 2, 2, 2, 435, 437, 3, 2, 2, 2, 436, 438, 5, 70, 36, 2, 437, 436, 3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 440, 3, 2, 2, 2, 439, 441, 5, 62, 32, 2, 440, 439, 3, 2, 2, 2, 440, 441, 3, 2, 2, 2, 441, 443, 3, 2, 2, 2, 442, 444, 5, 72, 37, 2, 443, 442, 3, 2, 2, 2, 443, 444, 3, 2, 2, 2, 444, 446, 3, 2, 2, 2, 445, 447, 5, 76, 39, 2, 446, 445, 3, 2, 2, 2, 446, 447, 3, 2, 2, 2, 447, 450, 3, 2, 2, 2, 448, 451, 5, 78, 40, 2, 449, 451, 5, 80, 41, 2, 450, 448, 3, 2, 2, 2, 450, 449, 3, 2, 2, 2, 450, 451, 3, 2, 2, 2, 451, 453, 3, 2, 2, 2, 452, 454, 5, 82, 42, 2, 453, 452, 3, 2, 2, 2, 453, 454, 3, 2, 2, 2, 454, 53, 3, 2, 2, 2, 455, 456, 7, 107, 2, 2, 456, 457, 5, 134, 68, 2, 457, 55, 3, 2, 2, 2, 458, 459, 7, 93, 2, 2, 459, 462, 7, 113, 2, 2, 460, 461, 7, 107, 2, 2, 461, 463, 7, 90, 2, 2, 462, 460, 3, 2, 2, 2, 462, 463, 3, 2, 2, 2, 463, 57, 3, 2, 2, 2, 464, 465, 7, 37, 2, 2, 465, 466, 5, 84, 43, 2, 466, 59, 3, 2, 2, 2, 467, 469, 9, 4, 2, 2, 468, 467, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 470, 3, 2, 2, 2, 470, 471, 7, 7, 2, 2, 471, 472, 7, 52, 2, 2, 472, 473, 5, 122, 62, 2, 473, 61, 3, 2, 2, 2, 474, 475, 7, 106, 2, 2, 475, 476, 5, 166, 84, 2, 476, 477, 7, 8, 2, 2, 477, 478, 7, 135, 2, 2, 478, 479, 5, 106, 54, 2, 479, 489, 7, 155, 2, 2, 480, 481, 7, 121, 2, 2, 481, 482, 5, 166, 84, 2, 482, 483, 7, 8, 2, 2, 483, 484, 7, 135, 2, 2, 484, 485, 5, 106, 54, 2, 485, 486, 7, 155, 2, 2, 486, 488, 3, 2, 2, 2, 487, 480, 3, 2, 2, 2, 488, 491, 3, 2, 2, 2, 489, 487, 3, 2, 2, 2, 489, 490, 3, 2, 2, 2, 490, 63, 3, 2, 2, 2, 491, 489, 3, 2, 2, 2, 492, 493, 7, 74, 2, 2, 493, 494, 5, 124, 63, 2, 494, 65, 3, 2, 2, 2, 495, 496, 7, 104, 2, 2, 496, 497, 5, 124, 63, 2, 497, 67, 3, 2, 2, 2, 498, 499, 7, 40, 2, 2, 499, 506, 7, 13, 2, 2, 500, 501, 9, 3, 2, 2, 501, 502, 7, 135, 2, 2, 502, 503, 5, 122, 62, 2, 503, 504, 7, 155, 2, 2, 504, 507, 3, 2, 2, 2, 505, 507, 5, 122, 62, 2, 506, 500, 3, 2, 2, 2, 506, 505, 3, 2, 2, 2, 507, 69, 3, 2, 2, 2, 508, 509, 7, 41, 2, 2, 509, 510, 5, 124, 63, 2, 510, 71, 3, 2, 2, 2, 511, 512, 7, 69, 2, 2, 512, 513, 7, 13, 2, 2, 513, 514, 5, 96, 49, 2, 514, 73, 3, 2, 2, 2, 515, 516, 7, 69, 2, 2, 516, 517, 7, 13, 2, 2, 517, 518, 5, 122, 62, 2, 518, 75, 3, 2, 2, 2, 519, 520, 7, 59, 2, 2, 520, 521, 5, 94, 48, 2, 521, 522, 7, 13, 2, 2, 522, 523, 5, 122, 62, 2, 523, 77, 3, 2, 2, 2, 524, 525, 7, 59, 2, 2, 525, 528, 5, 124, 63, 2, 526, 527, 7, 121, 2, 2, 527, 529, 5, 124, 63, 2, 528, 526, 3, 2, 2, 2, 528, 529, 3, 2, 2, 2, 529, 532, 3, 2, 2, 2, 530, 531, 7, 107, 2, 2, 531, 533, 7, 90, 2, 2, 532, 530, 3, 2, 2, 2, 532, 533, 3, 2, 2, 2, 533, 544, 3, 2, 2, 2, 534, 535, 7, 59, 2, 2, 535, 538, 5, 124, 63, 2, 536, 537, 7, 107, 2, 2, 537, 539, 7, 90, 2, 2, 538, 536, 3, 2, 2, 2, 538, 539, 3, 2, 2, 2, 539, 540, 3, 2, 2, 2, 540, 541, 7, 66, 2, 2, 541, 542, 5, 124, 63, 2, 542, 544, 3, 2, 2, 2, 543, 524, 3, 2, 2, 2, 543, 534, 3, 2, 2, 2, 544, 79, 3, 2, 2, 2, 545, 546, 7, 66, 2, 2, 546, 547, 5, 124, 63, 2, 547, 81, 3, 2, 2, 2, 548, 549, 7, 86, 2, 2, 549, 550, 5, 102, 52, 2, 550, 83, 3, 2, 2, 2, 551, 552, 8, 43, 1, 2, 552, 554, 5, 142, 72, 2, 553, 555, 7, 31, 2, 2, 554, 553, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 557, 3, 2, 2, 2, 556, 558, 5, 92, 47, 2, 557, 556, 3, 2, 2, 2, 557, 558, 3, 2, 2, 2, 558, 564, 3, 2, 2, 2, 559, 560, 7, 135, 2, 2, 560, 561, 5, 84, 43, 2, 561, 562, 7, 155, 2, 2, 562, 564, 3, 2, 2, 2, 563, 551, 3, 2, 2, 2, 563, 559, 3, 2, 2, 2, 564, 579, 3, 2, 2, 2, 565, 566, 12, 5, 2, 2, 566, 567, 5, 88, 45, 2, 567, 568, 5, 84, 43, 6, 568, 578, 3, 2, 2, 2, 569, 571, 12, 6, 2, 2, 570, 572, 5, 86, 44, 2, 571, 570, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572, 573, 3, 2, 2, 2, 573, 574, 7, 52, 2, 2, 574, 575, 5, 84, 43, 2, 575, 576, 5, 90, 46, 2, 576, 578, 3, 2, 2, 2, 577, 565, 3, 2, 2, 2, 577, 569, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 579, 580, 3, 2, 2, 2, 580, 85, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 582, 584, 9, 5, 2, 2, 583, 582, 3, 2, 2, 2, 583, 584, 3, 2, 2, 2, 584, 585, 3, 2, 2, 2, 585, 592, 7, 48, 2, 2, 586, 588, 7, 48, 2, 2, 587, 589, 9, 5, 2, 2, 588, 587, 3, 2, 2, 2, 588, 589, 3, 2, 2, 2, 589, 592, 3, 2, 2, 2, 590, 592, 9, 5, 2, 2, 591, 583, 3, 2, 2, 2, 591, 586, 3, 2, 2, 2, 591, 590, 3, 2, 2, 2, 592, 626, 3, 2, 2, 2, 593, 595, 9, 6, 2, 2, 594, 593, 3, 2, 2, 2, 594, 595, 3, 2, 2, 2, 595, 596, 3, 2, 2, 2, 596, 598, 9, 7, 2, 2, 597, 599, 7, 70, 2, 2, 598, 597, 3, 2, 2, 2, 598, 599, 3, 2, 2, 2, 599, 608, 3, 2, 2, 2, 600, 602, 9, 7, 2, 2, 601, 603, 7, 70, 2, 2, 602, 601, 3, 2, 2, 2, 602, 603, 3, 2, 2, 2, 603, 605, 3, 2, 2, 2, 604, 606, 9, 6, 2, 2, 605, 604, 3, 2, 2, 2, 605, 606, 3, 2, 2, 2, 606, 608, 3, 2, 2, 2, 607, 594, 3, 2, 2, 2, 607, 600, 3, 2, 2, 2, 608, 626, 3, 2, 2, 2, 609, 611, 9, 8, 2, 2, 610, 609, 3, 2, 2, 2, 610, 611, 3, 2, 2, 2, 611, 612, 3, 2, 2, 2, 612, 614, 7, 38, 2, 2, 613, 615, 7, 70, 2, 2, 614, 613, 3, 2, 2, 2, 614, 615, 3, 2, 2, 2, 615, 624, 3, 2, 2, 2, 616, 618, 7, 38, 2, 2, 617, 619, 7, 70, 2, 2, 618, 617, 3, 2, 2, 2, 618, 619, 3, 2, 2, 2, 619, 621, 3, 2, 2, 2, 620, 622, 9, 8, 2, 2, 621, 620, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2, 622, 624, 3, 2, 2, 2, 623, 610, 3, 2, 2, 2, 623, 616, 3, 2, 2, 2, 624, 626, 3, 2, 2, 2, 625, 591, 3, 2, 2, 2, 625, 607, 3, 2, 2, 2, 625, 623, 3, 2, 2, 2, 626, 87, 3, 2, 2, 2, 627, 628, 7, 19, 2, 2, 628, 631, 7, 52, 2, 2, 629, 631, 7, 121, 2, 2, 630, 627, 3, 2, 2, 2, 630, 629, 3, 2, 2, 2, 631, 89, 3, 2, 2, 2, 632, 633, 7, 67, 2, 2, 633, 642, 5, 122, 62, 2, 634, 635, 7, 101, 2, 2, 635, 636, 7, 135, 2, 2, 636, 637, 5, 122, 62, 2, 637, 638, 7, 155, 2, 2, 638, 642, 3, 2, 2, 2, 639, 640, 7, 101, 2, 2, 640, 642, 5, 122, 62, 2, 641, 632, 3, 2, 2, 2, 641, 634, 3, 2, 2, 2, 641, 639, 3, 2, 2, 2, 642, 91, 3, 2, 2, 2, 643, 644, 7, 82, 2, 2, 644, 647, 5, 100, 51, 2, 645, 646, 7, 66, 2, 2, 646, 648, 5, 100, 51, 2, 647, 645, 3, 2, 2, 2, 647, 648, 3, 2, 2, 2, 648, 93, 3, 2, 2, 2, 649, 652, 5, 124, 63, 2, 650, 651, 9, 9, 2, 2, 651, 653, 5, 124, 63, 2, 652, 650, 3, 2, 2, 2, 652, 653, 3, 2, 2, 2, 653, 95, 3, 2, 2, 2, 654, 659, 5, 98, 50, 2, 655, 656, 7, 121, 2, 2, 656, 658, 5, 98, 50, 2, 657, 655, 3, 2, 2, 2, 658, 661, 3, 2, 2, 2, 659, 657, 3, 2, 2, 2, 659, 660, 3, 2, 2, 2, 660, 97, 3, 2, 2, 2, 661, 659, 3, 2, 2, 2, 662, 664, 5, 124, 63, 2, 663, 665, 9, 10, 2, 2, 664, 663, 3, 2, 2, 2, 664, 665, 3, 2, 2, 2, 665, 668, 3, 2, 2, 2, 666, 667, 7, 65, 2, 2, 667, 669, 9, 11, 2, 2, 668, 666, 3, 2, 2, 2, 668, 669, 3, 2, 2, 2, 669, 672, 3, 2, 2, 2, 670, 671, 7, 18, 2, 2, 671, 673, 7, 115, 2, 2, 672, 670, 3, 2, 2, 2, 672, 673, 3, 2, 2, 2, 673, 99, 3, 2, 2, 2, 674, 681, 5, 170, 86, 2, 675, 678, 5, 154, 78, 2, 676, 677, 7, 157, 2, 2, 677, 679, 5, 154, 78, 2, 678, 676, 3, 2, 2, 2, 678, 679, 3, 2, 2, 2, 679, 681, 3, 2, 2, 2, 680, 674, 3, 2, 2, 2, 680, 675, 3, 2, 2, 2, 681, 101, 3, 2, 2, 2, 682, 687, 5, 104, 53, 2, 683, 684, 7, 121, 2, 2, 684, 686, 5, 104, 53, 2, 685, 683, 3, 2, 2, 2, 686, 689, 3, 2, 2, 2, 687, 685, 3, 2, 2, 2, 687, 688, 3, 2, 2, 2, 688, 103, 3, 2, 2, 2, 689, 687, 3, 2, 2, 2, 690, 691, 5, 166, 84, 2, 691, 692, 7, 127, 2, 2, 692, 693, 5, 156, 79, 2, 693, 105, 3, 2, 2, 2, 694, 696, 5, 108, 55, 2, 695, 694, 3, 2, 2, 2, 695, 696, 3, 2, 2, 2, 696, 698, 3, 2, 2, 2, 697, 699, 5, 110, 56, 2, 698, 697, 3, 2, 2, 2, 698, 699, 3, 2, 2, 2, 699, 701, 3, 2, 2, 2, 700, 702, 5, 112, 57, 2, 701, 700, 3, 2, 2, 2, 701, 702, 3, 2, 2, 2, 702, 107, 3, 2, 2, 2, 703, 704, 7, 72, 2, 2, 704, 705, 7, 13, 2, 2, 705, 706, 5, 122, 62, 2, 706, 109, 3, 2, 2, 2, 707, 708, 7, 69, 2, 2, 708, 709, 7, 13, 2, 2, 709, 710, 5, 96, 49, 2, 710, 111, 3, 2, 2, 2, 711, 712, 9, 12, 2, 2, 712, 713, 5, 114, 58, 2, 713, 113, 3, 2, 2, 2, 714, 721, 5, 116, 59, 2, 715, 716, 7, 11, 2, 2, 716, 717, 5, 116, 59, 2, 717, 718, 7, 4, 2, 2, 718, 719, 5, 116, 59, 2, 719, 721, 3, 2, 2, 2, 720, 714, 3, 2, 2, 2, 720, 715, 3, 2, 2, 2, 721, 115, 3, 2, 2, 2, 722, 723, 7, 21, 2, 2, 723, 735, 7, 80, 2, 2, 724, 725, 7, 99, 2, 2, 725, 735, 7, 73, 2, 2, 726, 727, 7, 99, 2, 2, 727, 735, 7, 35, 2, 2, 728, 729, 5, 154, 78, 2, 729, 730, 7, 73, 2, 2, 730, 735, 3, 2, 2, 2, 731, 732, 5, 154, 78, 2, 732, 733, 7, 35, 2, 2, 733, 735, 3, 2, 2, 2, 734, 722, 3, 2, 2, 2, 734, 724, 3, 2, 2, 2, 734, 726, 3, 2, 2, 2, 734, 728, 3, 2, 2, 2, 734, 731, 3, 2, 2, 2, 735, 117, 3, 2, 2, 2, 736, 737, 5, 124, 63, 2, 737, 738, 7, 2, 2, 3, 738, 119, 3, 2, 2, 2, 739, 796, 5, 166, 84, 2, 740, 741, 5, 166, 84, 2, 741, 742, 7, 135, 2, 2, 742, 743, 5, 166, 84, 2, 743, 750, 5, 120, 61, 2, 744, 745, 7, 121, 2, 2, 745, 746, 5, 166, 84, 2, 746, 747, 5, 120, 61, 2, 747, 749, 3, 2, 2, 2, 748, 744, 3, 2, 2, 2, 749, 752, 3, 2, 2, 2, 750, 748, 3, 2, 2, 2, 750, 751, 3, 2, 2, 2, 751, 754, 3, 2, 2, 2, 752, 750, 3, 2, 2, 2, 753, 755, 7, 121, 2, 2, 754, 753, 3, 2, 2, 2, 754, 755, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 757, 7, 155, 2, 2, 757, 796, 3, 2, 2, 2, 758, 759, 5, 166, 84, 2, 759, 760, 7, 135, 2, 2, 760, 765, 5, 168, 85, 2, 761, 762, 7, 121, 2, 2, 762, 764, 5, 168, 85, 2, 763, 761, 3, 2, 2, 2, 764, 767, 3, 2, 2, 2, 765, 763, 3, 2, 2, 2, 765, 766, 3, 2, 2, 2, 766, 769, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 768, 770, 7, 121, 2, 2, 769, 768, 3, 2, 2, 2, 769, 770, 3, 2, 2, 2, 770, 771, 3, 2, 2, 2, 771, 772, 7, 155, 2, 2, 772, 796, 3, 2, 2, 2, 773, 774, 5, 166, 84, 2, 774, 775, 7, 135, 2, 2, 775, 780, 5, 120, 61, 2, 776, 777, 7, 121, 2, 2, 777, 779, 5, 120, 61, 2, 778, 776, 3, 2, 2, 2, 779, 782, 3, 2, 2, 2, 780, 778, 3, 2, 2, 2, 780, 781, 3, 2, 2, 2, 781, 784, 3, 2, 2, 2, 782, 780, 3, 2, 2, 2, 783, 785, 7, 121, 2, 2, 784, 783, 3, 2, 2, 2, 784, 785, 3, 2, 2, 2, 785, 786, 3, 2, 2, 2, 786, 787, 7, 155, 2, 2, 787, 796, 3, 2, 2, 2, 788, 789, 5, 166, 84, 2, 789, 791, 7, 135, 2, 2, 790, 792, 5, 122, 62, 2, 791, 790, 3, 2, 2, 2, 791, 792, 3, 2, 2, 2, 792, 793, 3, 2, 2, 2, 793, 794, 7, 155, 2, 2, 794, 796, 3, 2, 2, 2, 795, 739, 3, 2, 2, 2, 795, 740, 3, 2, 2, 2, 795, 758, 3, 2, 2, 2, 795, 773, 3, 2, 2, 2, 795, 788, 3, 2, 2, 2, 796, 121, 3, 2, 2, 2, 797, 802, 5, 124, 63, 2, 798, 799, 7, 121, 2, 2, 799, 801, 5, 124, 63, 2, 800, 798, 3, 2, 2, 2, 801, 804, 3, 2, 2, 2, 802, 800, 3, 2, 2, 2, 802, 803, 3, 2, 2, 2, 803, 806, 3, 2, 2, 2, 804, 802, 3, 2, 2, 2, 805, 807, 7, 121, 2, 2, 806, 805, 3, 2, 2, 2, 806, 807, 3, 2, 2, 2, 807, 123, 3, 2, 2, 2, 808, 809, 8, 63, 1, 2, 809, 811, 7, 14, 2, 2, 810, 812, 5, 124, 63, 2, 811, 810, 3, 2, 2, 2, 811, 812, 3, 2, 2, 2, 812, 818, 3, 2, 2, 2, 813, 814, 7, 103, 2, 2, 814, 815, 5, 124, 63, 2, 815, 816, 7, 88, 2, 2, 816, 817, 5, 124, 63, 2, 817, 819, 3, 2, 2, 2, 818, 813, 3, 2, 2, 2, 819, 820, 3, 2, 2, 2, 820, 818, 3, 2, 2, 2, 820, 821, 3, 2, 2, 2, 821, 824, 3, 2, 2, 2, 822, 823, 7, 27, 2, 2, 823, 825, 5, 124, 63, 2, 824, 822, 3, 2, 2, 2, 824, 825, 3, 2, 2, 2, 825, 826, 3, 2, 2, 2, 826, 827, 7, 28, 2, 2, 827, 961, 3, 2, 2, 2, 828, 829, 7, 15, 2, 2, 829, 830, 7, 135, 2, 2, 830, 831, 5, 124, 63, 2, 831, 832, 7, 8, 2, 2, 832, 833, 5, 120, 61, 2, 833, 834, 7, 155, 2, 2, 834, 961, 3, 2, 2, 2, 835, 836, 7, 22, 2, 2, 836, 961, 7, 115, 2, 2, 837, 838, 7, 50, 2, 2, 838, 961, 7, 115, 2, 2, 839, 840, 7, 50, 2, 2, 840, 841, 5, 124, 63, 2, 841, 842, 5, 158, 80, 2, 842, 961, 3, 2, 2, 2, 843, 844, 7, 87, 2, 2, 844, 845, 7, 135, 2, 2, 845, 846, 5, 124, 63, 2, 846, 847, 7, 37, 2, 2, 847, 850, 5, 124, 63, 2, 848, 849, 7, 36, 2, 2, 849, 851, 5, 124, 63, 2, 850, 848, 3, 2, 2, 2, 850, 851, 3, 2, 2, 2, 851, 852, 3, 2, 2, 2, 852, 853, 7, 155, 2, 2, 853, 961, 3, 2, 2, 2, 854, 855, 7, 91, 2, 2, 855, 961, 7, 115, 2, 2, 856, 857, 7, 96, 2, 2, 857, 858, 7, 135, 2, 2, 858, 859, 9, 13, 2, 2, 859, 860, 5, 172, 87, 2, 860, 861, 7, 37, 2, 2, 861, 862, 5, 124, 63, 2, 862, 863, 7, 155, 2, 2, 863, 961, 3, 2, 2, 2, 864, 865, 5, 166, 84, 2, 865, 867, 7, 135, 2, 2, 866, 868, 5, 122, 62, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 870, 7, 155, 2, 2, 870, 879, 3, 2, 2, 2, 871, 873, 7, 135, 2, 2, 872, 874, 7, 26, 2, 2, 873, 872, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 876, 3, 2, 2, 2, 875, 877, 5, 122, 62, 2, 876, 875, 3, 2, 2, 2, 876, 877, 3, 2, 2, 2, 877, 878, 3, 2, 2, 2, 878, 880, 7, 155, 2, 2, 879, 871, 3, 2, 2, 2, 879, 880, 3, 2, 2, 2, 880, 881, 3, 2, 2, 2, 881, 882, 7, 71, 2, 2, 882, 883, 7, 135, 2, 2, 883, 884, 5, 106, 54, 2, 884, 885, 7, 155, 2, 2, 885, 961, 3, 2, 2, 2, 886, 887, 5, 166, 84, 2, 887, 889, 7, 135, 2, 2, 888, 890, 5, 122, 62, 2, 889, 888, 3, 2, 2, 2, 889, 890, 3, 2, 2, 2, 890, 891, 3, 2, 2, 2, 891, 892, 7, 155, 2, 2, 892, 901, 3, 2, 2, 2, 893, 895, 7, 135, 2, 2, 894, 896, 7, 26, 2, 2, 895, 894, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 898, 3, 2, 2, 2, 897, 899, 5, 122, 62, 2, 898, 897, 3, 2, 2, 2, 898, 899, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 902, 7, 155, 2, 2, 901, 893, 3, 2, 2, 2, 901, 902, 3, 2, 2, 2, 902, 903, 3, 2, 2, 2, 903, 904, 7, 71, 2, 2, 904, 905, 5, 166, 84, 2, 905, 961, 3, 2, 2, 2, 906, 912, 5, 166, 84, 2, 907, 909, 7, 135, 2, 2, 908, 910, 5, 122, 62, 2, 909, 908, 3, 2, 2, 2, 909, 910, 3, 2, 2, 2, 910, 911, 3, 2, 2, 2, 911, 913, 7, 155, 2, 2, 912, 907, 3, 2, 2, 2, 912, 913, 3, 2, 2, 2, 913, 914, 3, 2, 2, 2, 914, 916, 7, 135, 2, 2, 915, 917, 7, 26, 2, 2, 916, 915, 3, 2, 2, 2, 916, 917, 3, 2, 2, 2, 917, 919, 3, 2, 2, 2, 918, 920, 5, 122, 62, 2, 919, 918, 3, 2, 2, 2, 919, 920, 3, 2, 2, 2, 920, 921, 3, 2, 2, 2, 921, 922, 7, 155, 2, 2, 922, 961, 3, 2, 2, 2, 923, 961, 5, 130, 66, 2, 924, 961, 5, 174, 88, 2, 925, 961, 5, 156, 79, 2, 926, 927, 7, 123, 2, 2, 927, 961, 5, 124, 63, 22, 928, 929, 7, 63, 2, 2, 929, 961, 5, 124, 63, 16, 930, 931, 5, 146, 74, 2, 931, 932, 7, 125, 2, 2, 932, 934, 3, 2, 2, 2, 933, 930, 3, 2, 2, 2, 933, 934, 3, 2, 2, 2, 934, 935, 3, 2, 2, 2, 935, 961, 7, 117, 2, 2, 936, 937, 7, 135, 2, 2, 937, 938, 5, 50, 26, 2, 938, 939, 7, 155, 2, 2, 939, 961, 3, 2, 2, 2, 940, 941, 7, 135, 2, 2, 941, 942, 5, 124, 63, 2, 942, 943, 7, 155, 2, 2, 943, 961, 3, 2, 2, 2, 944, 945, 7, 135, 2, 2, 945, 946, 5, 122, 62, 2, 946, 947, 7, 155, 2, 2, 947, 961, 3, 2, 2, 2, 948, 950, 7, 134, 2, 2, 949, 951, 5, 122, 62, 2, 950, 949, 3, 2, 2, 2, 950, 951, 3, 2, 2, 2, 951, 952, 3, 2, 2, 2, 952, 961, 7, 154, 2, 2, 953, 955, 7, 133, 2, 2, 954, 956, 5, 42, 22, 2, 955, 954, 3, 2, 2, 2, 955, 956, 3, 2, 2, 2, 956, 957, 3, 2, 2, 2, 957, 961, 7, 153, 2, 2, 958, 961, 5, 126, 64, 2, 959, 961, 5, 138, 70, 2, 960, 808, 3, 2, 2, 2, 960, 828, 3, 2, 2, 2, 960, 835, 3, 2, 2, 2, 960, 837, 3, 2, 2, 2, 960, 839, 3, 2, 2, 2, 960, 843, 3, 2, 2, 2, 960, 854, 3, 2, 2, 2, 960, 856, 3, 2, 2, 2, 960, 864, 3, 2, 2, 2, 960, 886, 3, 2, 2, 2, 960, 906, 3, 2, 2, 2, 960, 923, 3, 2, 2, 2, 960, 924, 3, 2, 2, 2, 960, 925, 3, 2, 2, 2, 960, 926, 3, 2, 2, 2, 960, 928, 3, 2, 2, 2, 960, 933, 3, 2, 2, 2, 960, 936, 3, 2, 2, 2, 960, 940, 3, 2, 2, 2, 960, 944, 3, 2, 2, 2, 960, 948, 3, 2, 2, 2, 960, 953, 3, 2, 2, 2, 960, 958, 3, 2, 2, 2, 960, 959, 3, 2, 2, 2, 961, 1077, 3, 2, 2, 2, 962, 966, 12, 21, 2, 2, 963, 967, 7, 117, 2, 2, 964, 967, 7, 157, 2, 2, 965, 967, 7, 144, 2, 2, 966, 963, 3, 2, 2, 2, 966, 964, 3, 2, 2, 2, 966, 965, 3, 2, 2, 2, 967, 968, 3, 2, 2, 2, 968, 1076, 5, 124, 63, 22, 969, 973, 12, 20, 2, 2, 970, 974, 7, 145, 2, 2, 971, 974, 7, 123, 2, 2, 972, 974, 7, 122, 2, 2, 973, 970, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 973, 972, 3, 2, 2, 2, 974, 975, 3, 2, 2, 2, 975, 1076, 5, 124, 63, 21, 976, 1001, 12, 19, 2, 2, 977, 1002, 7, 126, 2, 2, 978, 1002, 7, 127, 2, 2, 979, 1002, 7, 139, 2, 2, 980, 1002, 7, 136, 2, 2, 981, 1002, 7, 137, 2, 2, 982, 1002, 7, 128, 2, 2, 983, 1002, 7, 129, 2, 2, 984, 986, 7, 63, 2, 2, 985, 984, 3, 2, 2, 2, 985, 986, 3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 989, 7, 46, 2, 2, 988, 990, 7, 17, 2, 2, 989, 988, 3, 2, 2, 2, 989, 990, 3, 2, 2, 2, 990, 1002, 3, 2, 2, 2, 991, 993, 7, 63, 2, 2, 992, 991, 3, 2, 2, 2, 992, 993, 3, 2, 2, 2, 993, 994, 3, 2, 2, 2, 994, 1002, 9, 14, 2, 2, 995, 1002, 7, 151, 2, 2, 996, 1002, 7, 152, 2, 2, 997, 1002, 7, 141, 2, 2, 998, 1002, 7, 131, 2, 2, 999, 1002, 7, 132, 2, 2, 1000, 1002, 7, 140, 2, 2, 1001, 977, 3, 2, 2, 2, 1001, 978, 3, 2, 2, 2, 1001, 979, 3, 2, 2, 2, 1001, 980, 3, 2, 2, 2, 1001, 981, 3, 2, 2, 2, 1001, 982, 3, 2, 2, 2, 1001, 983, 3, 2, 2, 2, 1001, 985, 3, 2, 2, 2, 1001, 992, 3, 2, 2, 2, 1001, 995, 3, 2, 2, 2, 1001, 996, 3, 2, 2, 2, 1001, 997, 3, 2, 2, 2, 1001, 998, 3, 2, 2, 2, 1001, 999, 3, 2, 2, 2, 1001, 1000, 3, 2, 2, 2, 1002, 1003, 3, 2, 2, 2, 1003, 1076, 5, 124, 63, 20, 1004, 1005, 12, 17, 2, 2, 1005, 1006, 7, 143, 2, 2, 1006, 1076, 5, 124, 63, 18, 1007, 1008, 12, 15, 2, 2, 1008, 1009, 7, 4, 2, 2, 1009, 1076, 5, 124, 63, 16, 1010, 1011, 12, 14, 2, 2, 1011, 1012, 7, 68, 2, 2, 1012, 1076, 5, 124, 63, 15, 1013, 1015, 12, 13, 2, 2, 1014, 1016, 7, 63, 2, 2, 1015, 1014, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 1017, 3, 2, 2, 2, 1017, 1018, 7, 11, 2, 2, 1018, 1019, 5, 124, 63, 2, 1019, 1020, 7, 4, 2, 2, 1020, 1021, 5, 124, 63, 14, 1021, 1076, 3, 2, 2, 2, 1022, 1023, 12, 12, 2, 2, 1023, 1024, 7, 146, 2, 2, 1024, 1025, 5, 124, 63, 2, 1025, 1026, 7, 120, 2, 2, 1026, 1027, 5, 124, 63, 12, 1027, 1076, 3, 2, 2, 2, 1028, 1029, 12, 33, 2, 2, 1029, 1030, 7, 135, 2, 2, 1030, 1031, 5, 50, 26, 2, 1031, 1032, 7, 155, 2, 2, 1032, 1076, 3, 2, 2, 2, 1033, 1034, 12, 32, 2, 2, 1034, 1036, 7, 135, 2, 2, 1035, 1037, 5, 122, 62, 2, 1036, 1035, 3, 2, 2, 2, 1036, 1037, 3, 2, 2, 2, 1037, 1038, 3, 2, 2, 2, 1038, 1076, 7, 155, 2, 2, 1039, 1040, 12, 28, 2, 2, 1040, 1041, 7, 134, 2, 2, 1041, 1042, 5, 124, 63, 2, 1042, 1043, 7, 154, 2, 2, 1043, 1076, 3, 2, 2, 2, 1044, 1045, 12, 27, 2, 2, 1045, 1046, 7, 125, 2, 2, 1046, 1076, 7, 113, 2, 2, 1047, 1048, 12, 26, 2, 2, 1048, 1049, 7, 125, 2, 2, 1049, 1076, 5, 166, 84, 2, 1050, 1051, 12, 25, 2, 2, 1051, 1052, 7, 142, 2, 2, 1052, 1053, 7, 134, 2, 2, 1053, 1054, 5, 124, 63, 2, 1054, 1055, 7, 154, 2, 2, 1055, 1076, 3, 2, 2, 2, 1056, 1057, 12, 24, 2, 2, 1057, 1058, 7, 142, 2, 2, 1058, 1076, 7, 113, 2, 2, 1059, 1060, 12, 23, 2, 2, 1060, 1061, 7, 142, 2, 2, 1061, 1076, 5, 166, 84, 2, 1062, 1063, 12, 18, 2, 2, 1063, 1065, 7, 51, 2, 2, 1064, 1066, 7, 63, 2, 2, 1065, 1064, 3, 2, 2, 2, 1065, 1066, 3, 2, 2, 2, 1066, 1067, 3, 2, 2, 2, 1067, 1076, 7, 64, 2, 2, 1068, 1073, 12, 11, 2, 2, 1069, 1070, 7, 8, 2, 2, 1070, 1074, 5, 166, 84, 2, 1071, 1072, 7, 8, 2, 2, 1072, 1074, 7, 115, 2, 2, 1073, 1069, 3, 2, 2, 2, 1073, 1071, 3, 2, 2, 2, 1074, 1076, 3, 2, 2, 2, 1075, 962, 3, 2, 2, 2, 1075, 969, 3, 2, 2, 2, 1075, 976, 3, 2, 2, 2, 1075, 1004, 3, 2, 2, 2, 1075, 1007, 3, 2, 2, 2, 1075, 1010, 3, 2, 2, 2, 1075, 1013, 3, 2, 2, 2, 1075, 1022, 3, 2, 2, 2, 1075, 1028, 3, 2, 2, 2, 1075, 1033, 3, 2, 2, 2, 1075, 1039, 3, 2, 2, 2, 1075, 1044, 3, 2, 2, 2, 1075, 1047, 3, 2, 2, 2, 1075, 1050, 3, 2, 2, 2, 1075, 1056, 3, 2, 2, 2, 1075, 1059, 3, 2, 2, 2, 1075, 1062, 3, 2, 2, 2, 1075, 1068, 3, 2, 2, 2, 1076, 1079, 3, 2, 2, 2, 1077, 1075, 3, 2, 2, 2, 1077, 1078, 3, 2, 2, 2, 1078, 125, 3, 2, 2, 2, 1079, 1077, 3, 2, 2, 2, 1080, 1081, 7, 135, 2, 2, 1081, 1086, 5, 166, 84, 2, 1082, 1083, 7, 121, 2, 2, 1083, 1085, 5, 166, 84, 2, 1084, 1082, 3, 2, 2, 2, 1085, 1088, 3, 2, 2, 2, 1086, 1084, 3, 2, 2, 2, 1086, 1087, 3, 2, 2, 2, 1087, 1090, 3, 2, 2, 2, 1088, 1086, 3, 2, 2, 2, 1089, 1091, 7, 121, 2, 2, 1090, 1089, 3, 2, 2, 2, 1090, 1091, 3, 2, 2, 2, 1091, 1092, 3, 2, 2, 2, 1092, 1093, 7, 155, 2, 2, 1093, 1108, 3, 2, 2, 2, 1094, 1099, 5, 166, 84, 2, 1095, 1096, 7, 121, 2, 2, 1096, 1098, 5, 166, 84, 2, 1097, 1095, 3, 2, 2, 2, 1098, 1101, 3, 2, 2, 2, 1099, 1097, 3, 2, 2, 2, 1099, 1100, 3, 2, 2, 2, 1100, 1103, 3, 2, 2, 2, 1101, 1099, 3, 2, 2, 2, 1102, 1104, 7, 121, 2, 2, 1103, 1102, 3, 2, 2, 2, 1103, 1104, 3, 2, 2, 2, 1104, 1108, 3, 2, 2, 2, 1105, 1106, 7, 135, 2, 2, 1106, 1108, 7, 155, 2, 2, 1107, 1080, 3, 2, 2, 2, 1107, 1094, 3, 2, 2, 2, 1107, 1105, 3, 2, 2, 2, 1108, 1109, 3, 2, 2, 2, 1109, 1112, 7, 116, 2, 2, 1110, 1113, 5, 124, 63, 2, 1111, 1113, 5, 38, 20, 2, 1112, 1110, 3, 2, 2, 2, 1112, 1111, 3, 2, 2, 2, 1113, 127, 3, 2, 2, 2, 1114, 1121, 5, 130, 66, 2, 1115, 1121, 7, 169, 2, 2, 1116, 1117, 7, 133, 2, 2, 1117, 1118, 5, 124, 63, 2, 1118, 1119, 7, 153, 2, 2, 1119, 1121, 3, 2, 2, 2, 1120, 1114, 3, 2, 2, 2, 1120, 1115, 3, 2, 2, 2, 1120, 1116, 3, 2, 2, 2, 1121, 129, 3, 2, 2, 2, 1122, 1123, 7, 137, 2, 2, 1123, 1127, 5, 166, 84, 2, 1124, 1126, 5, 132, 67, 2, 1125, 1124, 3, 2, 2, 2, 1126, 1129, 3, 2, 2, 2, 1127, 1125, 3, 2, 2, 2, 1127, 1128, 3, 2, 2, 2, 1128, 1130, 3, 2, 2, 2, 1129, 1127, 3, 2, 2, 2, 1130, 1131, 7, 158, 2, 2, 1131, 1152, 3, 2, 2, 2, 1132, 1133, 7, 137, 2, 2, 1133, 1137, 5, 166, 84, 2, 1134, 1136, 5, 132, 67, 2, 1135, 1134, 3, 2, 2, 2, 1136, 1139, 3, 2, 2, 2, 1137, 1135, 3, 2, 2, 2, 1137, 1138, 3, 2, 2, 2, 1138, 1140, 3, 2, 2, 2, 1139, 1137, 3, 2, 2, 2, 1140, 1144, 7, 129, 2, 2, 1141, 1143, 5, 128, 65, 2, 1142, 1141, 3, 2, 2, 2, 1143, 1146, 3, 2, 2, 2, 1144, 1142, 3, 2, 2, 2, 1144, 1145, 3, 2, 2, 2, 1145, 1147, 3, 2, 2, 2, 1146, 1144, 3, 2, 2, 2, 1147, 1148, 7, 138, 2, 2, 1148, 1149, 5, 166, 84, 2, 1149, 1150, 7, 129, 2, 2, 1150, 1152, 3, 2, 2, 2, 1151, 1122, 3, 2, 2, 2, 1151, 1132, 3, 2, 2, 2, 1152, 131, 3, 2, 2, 2, 1153, 1154, 5, 166, 84, 2, 1154, 1155, 7, 127, 2, 2, 1155, 1156, 5, 172, 87, 2, 1156, 1165, 3, 2, 2, 2, 1157, 1158, 5, 166, 84, 2, 1158, 1159, 7, 127, 2, 2, 1159, 1160, 7, 133, 2, 2, 1160, 1161, 5, 124, 63, 2, 1161, 1162, 7, 153, 2, 2, 1162, 1165, 3, 2, 2, 2, 1163, 1165, 5, 166, 84, 2, 1164, 1153, 3, 2, 2, 2, 1164, 1157, 3, 2, 2, 2, 1164, 1163, 3, 2, 2, 2, 1165, 133, 3, 2, 2, 2, 1166, 1171, 5, 136, 69, 2, 1167, 1168, 7, 121, 2, 2, 1168, 1170, 5, 136, 69, 2, 1169, 1167, 3, 2, 2, 2, 1170, 1173, 3, 2, 2, 2, 1171, 1169, 3, 2, 2, 2, 1171, 1172, 3, 2, 2, 2, 1172, 1175, 3, 2, 2, 2, 1173, 1171, 3, 2, 2, 2, 1174, 1176, 7, 121, 2, 2, 1175, 1174, 3, 2, 2, 2, 1175, 1176, 3, 2, 2, 2, 1176, 135, 3, 2, 2, 2, 1177, 1178, 5, 166, 84, 2, 1178, 1179, 7, 8, 2, 2, 1179, 1180, 7, 135, 2, 2, 1180, 1181, 5, 50, 26, 2, 1181, 1182, 7, 155, 2, 2, 1182, 1188, 3, 2, 2, 2, 1183, 1184, 5, 124, 63, 2, 1184, 1185, 7, 8, 2, 2, 1185, 1186, 5, 166, 84, 2, 1186, 1188, 3, 2, 2, 2, 1187, 1177, 3, 2, 2, 2, 1187, 1183, 3, 2, 2, 2, 1188, 137, 3, 2, 2, 2, 1189, 1197, 5, 170, 86, 2, 1190, 1191, 5, 146, 74, 2, 1191, 1192, 7, 125, 2, 2, 1192, 1194, 3, 2, 2, 2, 1193, 1190, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 1195, 3, 2, 2, 2, 1195, 1197, 5, 140, 71, 2, 1196, 1189, 3, 2, 2, 2, 1196, 1193, 3, 2, 2, 2, 1197, 139, 3, 2, 2, 2, 1198, 1203, 5, 166, 84, 2, 1199, 1200, 7, 125, 2, 2, 1200, 1202, 5, 166, 84, 2, 1201, 1199, 3, 2, 2, 2, 1202, 1205, 3, 2, 2, 2, 1203, 1201, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 141, 3, 2, 2, 2, 1205, 1203, 3, 2, 2, 2, 1206, 1207, 8, 72, 1, 2, 1207, 1216, 5, 146, 74, 2, 1208, 1216, 5, 144, 73, 2, 1209, 1210, 7, 135, 2, 2, 1210, 1211, 5, 50, 26, 2, 1211, 1212, 7, 155, 2, 2, 1212, 1216, 3, 2, 2, 2, 1213, 1216, 5, 130, 66, 2, 1214, 1216, 5, 170, 86, 2, 1215, 1206, 3, 2, 2, 2, 1215, 1208, 3, 2, 2, 2, 1215, 1209, 3, 2, 2, 2, 1215, 1213, 3, 2, 2, 2, 1215, 1214, 3, 2, 2, 2, 1216, 1225, 3, 2, 2, 2, 1217, 1221, 12, 5, 2, 2, 1218, 1222, 5, 164, 83, 2, 1219, 1220, 7, 8, 2, 2, 1220, 1222, 5, 166, 84, 2, 1221, 1218, 3, 2, 2, 2, 1221, 1219, 3, 2, 2, 2, 1222, 1224, 3, 2, 2, 2, 1223, 1217, 3, 2, 2, 2, 1224, 1227, 3, 2, 2, 2, 1225, 1223, 3, 2, 2, 2, 1225, 1226, 3, 2, 2, 2, 1226, 143, 3, 2, 2, 2, 1227, 1225, 3, 2, 2, 2, 1228, 1229, 5, 166, 84, 2, 1229, 1231, 7, 135, 2, 2, 1230, 1232, 5, 148, 75, 2, 1231, 1230, 3, 2, 2, 2, 1231, 1232, 3, 2, 2, 2, 1232, 1233, 3, 2, 2, 2, 1233, 1234, 7, 155, 2, 2, 1234, 145, 3, 2, 2, 2, 1235, 1236, 5, 150, 76, 2, 1236, 1237, 7, 125, 2, 2, 1237, 1239, 3, 2, 2, 2, 1238, 1235, 3, 2, 2, 2, 1238, 1239, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1241, 5, 140, 71, 2, 1241, 147, 3, 2, 2, 2, 1242, 1247, 5, 124, 63, 2, 1243, 1244, 7, 121, 2, 2, 1244, 1246, 5, 124, 63, 2, 1245, 1243, 3, 2, 2, 2, 1246, 1249, 3, 2, 2, 2, 1247, 1245, 3, 2, 2, 2, 1247, 1248, 3, 2, 2, 2, 1248, 1251, 3, 2, 2, 2, 1249, 1247, 3, 2, 2, 2, 1250, 1252, 7, 121, 2, 2, 1251, 1250, 3, 2, 2, 2, 1251, 1252, 3, 2, 2, 2, 1252, 149, 3, 2, 2, 2, 1253, 1254, 5, 166, 84, 2, 1254, 151, 3, 2, 2, 2, 1255, 1264, 7, 111, 2, 2, 1256, 1257, 7, 125, 2, 2, 1257, 1264, 9, 15, 2, 2, 1258, 1259, 7, 113, 2, 2, 1259, 1261, 7, 125, 2, 2, 1260, 1262, 9, 15, 2, 2, 1261, 1260, 3, 2, 2, 2, 1261, 1262, 3, 2, 2, 2, 1262, 1264, 3, 2, 2, 2, 1263, 1255, 3, 2, 2, 2, 1263, 1256, 3, 2, 2, 2, 1263, 1258, 3, 2, 2, 2, 1264, 153, 3, 2, 2, 2, 1265, 1267, 9, 16, 2, 2, 1266, 1265, 3, 2, 2, 2, 1266, 1267, 3, 2, 2, 2, 1267, 1274, 3, 2, 2, 2, 1268, 1275, 5, 152, 77, 2, 1269, 1275, 7, 112, 2, 2, 1270, 1275, 7, 113, 2, 2, 1271, 1275, 7, 114, 2, 2, 1272, 1275, 7, 47, 2, 2, 1273, 1275, 7, 62, 2, 2, 1274, 1268, 3, 2, 2, 2, 1274, 1269, 3, 2, 2, 2, 1274, 1270, 3, 2, 2, 2, 1274, 1271, 3, 2, 2, 2, 1274, 1272, 3, 2, 2, 2, 1274, 1273, 3, 2, 2, 2, 1275, 155, 3, 2, 2, 2, 1276, 1280, 5, 154, 78, 2, 1277, 1280, 7, 115, 2, 2, 1278, 1280, 7, 64, 2, 2, 1279, 1276, 3, 2, 2, 2, 1279, 1277, 3, 2, 2, 2, 1279, 1278, 3, 2, 2, 2, 1280, 157, 3, 2, 2, 2, 1281, 1282, 9, 17, 2, 2, 1282, 159, 3, 2, 2, 2, 1283, 1284, 9, 18, 2, 2, 1284, 161, 3, 2, 2, 2, 1285, 1286, 9, 19, 2, 2, 1286, 163, 3, 2, 2, 2, 1287, 1290, 7, 110, 2, 2, 1288, 1290, 5, 162, 82, 2, 1289, 1287, 3, 2, 2, 2, 1289, 1288, 3, 2, 2, 2, 1290, 165, 3, 2, 2, 2, 1291, 1295, 7, 110, 2, 2, 1292, 1295, 5, 158, 80, 2, 1293, 1295, 5, 160, 81, 2, 1294, 1291, 3, 2, 2, 2, 1294, 1292, 3, 2, 2, 2, 1294, 1293, 3, 2, 2, 2, 1295, 167, 3, 2, 2, 2, 1296, 1297, 5, 172, 87, 2, 1297, 1298, 7, 127, 2, 2, 1298, 1299, 5, 154, 78, 2, 1299, 169, 3, 2, 2, 2, 1300, 1301, 7, 133, 2, 2, 1301, 1302, 5, 124, 63, 2, 1302, 1303, 7, 153, 2, 2, 1303, 171, 3, 2, 2, 2, 1304, 1307, 7, 115, 2, 2, 1305, 1307, 5, 174, 88, 2, 1306, 1304, 3, 2, 2, 2, 1306, 1305, 3, 2, 2, 2, 1307, 173, 3, 2, 2, 2, 1308, 1312, 7, 148, 2, 2, 1309, 1311, 5, 176, 89, 2, 1310, 1309, 3, 2, 2, 2, 1311, 1314, 3, 2, 2, 2, 1312, 1310, 3, 2, 2, 2, 1312, 1313, 3, 2, 2, 2, 1313, 1315, 3, 2, 2, 2, 1314, 1312, 3, 2, 2, 2, 1315, 1316, 7, 150, 2, 2, 1316, 175, 3, 2, 2, 2, 1317, 1318, 7, 164, 2, 2, 1318, 1319, 5, 124, 63, 2, 1319, 1320, 7, 153, 2, 2, 1320, 1323, 3, 2, 2, 2, 1321, 1323, 7, 163, 2, 2, 1322, 1317, 3, 2, 2, 2, 1322, 1321, 3, 2, 2, 2, 1323, 177, 3, 2, 2, 2, 1324, 1328, 7, 149, 2, 2, 1325, 1327, 5, 180, 91, 2, 1326, 1325, 3, 2, 2, 2, 1327, 1330, 3, 2, 2, 2, 1328, 1326, 3, 2, 2, 2, 1328, 1329, 3, 2, 2, 2, 1329, 1331, 3, 2, 2, 2, 1330, 1328, 3, 2, 2, 2, 1331, 1332, 7, 2, 2, 3, 1332, 179, 3, 2, 2, 2, 1333, 1334, 7, 166, 2, 2, 1334, 1335, 5, 124, 63, 2, 1335, 1336, 7, 153, 2, 2, 1336, 1339, 3, 2, 2, 2, 1337, 1339, 7, 165, 2, 2, 1338, 1333, 3, 2, 2, 2, 1338, 1337, 3, 2, 2, 2, 1339, 181, 3, 2, 2, 2, 173, 185, 192, 201, 208, 212, 226, 230, 233, 237, 240, 247, 251, 260, 265, 274, 282, 289, 293, 299, 304, 312, 319, 325, 337, 345, 359, 363, 368, 371, 381, 391, 399, 403, 407, 410, 414, 417, 420, 423, 426, 430, 434, 437, 440, 443, 446, 450, 453, 462, 468, 489, 506, 528, 532, 538, 543, 554, 557, 563, 571, 577, 579, 583, 588, 591, 594, 598, 602, 605, 607, 610, 614, 618, 621, 623, 625, 630, 641, 647, 652, 659, 664, 668, 672, 678, 680, 687, 695, 698, 701, 720, 734, 750, 754, 765, 769, 780, 784, 791, 795, 802, 806, 811, 820, 824, 850, 867, 873, 876, 879, 889, 895, 898, 901, 909, 912, 916, 919, 933, 950, 955, 960, 966, 973, 985, 989, 992, 1001, 1015, 1036, 1065, 1073, 1075, 1077, 1086, 1090, 1099, 1103, 1107, 1112, 1120, 1127, 1137, 1144, 1151, 1164, 1171, 1175, 1187, 1193, 1196, 1203, 1215, 1221, 1225, 1231, 1238, 1247, 1251, 1261, 1263, 1266, 1274, 1279, 1289, 1294, 1306, 1312, 1322, 1328, 1338]
\ No newline at end of file
diff --git a/internal-packages/tsql/src/grammar/TSQLParser.tokens b/internal-packages/tsql/src/grammar/TSQLParser.tokens
new file mode 100644
index 00000000000..f94f7b27168
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLParser.tokens
@@ -0,0 +1,208 @@
+ALL=1
+AND=2
+ANTI=3
+ANY=4
+ARRAY=5
+AS=6
+ASCENDING=7
+ASOF=8
+BETWEEN=9
+BOTH=10
+BY=11
+CASE=12
+CAST=13
+CATCH=14
+COHORT=15
+COLLATE=16
+CROSS=17
+CUBE=18
+CURRENT=19
+DATE=20
+DAY=21
+DESC=22
+DESCENDING=23
+DISTINCT=24
+ELSE=25
+END=26
+EXCEPT=27
+EXTRACT=28
+FINAL=29
+FINALLY=30
+FIRST=31
+FN=32
+FOLLOWING=33
+FOR=34
+FROM=35
+FULL=36
+FUN=37
+GROUP=38
+HAVING=39
+HOUR=40
+ID=41
+IF=42
+ILIKE=43
+IN=44
+INF=45
+INNER=46
+INTERSECT=47
+INTERVAL=48
+IS=49
+JOIN=50
+KEY=51
+LAST=52
+LEADING=53
+LEFT=54
+LET=55
+LIKE=56
+LIMIT=57
+MINUTE=58
+MONTH=59
+NAN_SQL=60
+NOT=61
+NULL_SQL=62
+NULLS=63
+OFFSET=64
+ON=65
+OR=66
+ORDER=67
+OUTER=68
+OVER=69
+PARTITION=70
+PRECEDING=71
+PREWHERE=72
+QUARTER=73
+RANGE=74
+RETURN=75
+RIGHT=76
+ROLLUP=77
+ROW=78
+ROWS=79
+SAMPLE=80
+SECOND=81
+SELECT=82
+SEMI=83
+SETTINGS=84
+SUBSTRING=85
+THEN=86
+THROW=87
+TIES=88
+TIMESTAMP=89
+TO=90
+TOP=91
+TOTALS=92
+TRAILING=93
+TRIM=94
+TRUNCATE=95
+TRY=96
+UNBOUNDED=97
+UNION=98
+USING=99
+WEEK=100
+WHEN=101
+WHERE=102
+WHILE=103
+WINDOW=104
+WITH=105
+YEAR=106
+ESCAPE_CHAR_COMMON=107
+IDENTIFIER=108
+FLOATING_LITERAL=109
+OCTAL_LITERAL=110
+DECIMAL_LITERAL=111
+HEXADECIMAL_LITERAL=112
+STRING_LITERAL=113
+ARROW=114
+ASTERISK=115
+BACKQUOTE=116
+BACKSLASH=117
+COLON=118
+COMMA=119
+CONCAT=120
+DASH=121
+DOLLAR=122
+DOT=123
+EQ_DOUBLE=124
+EQ_SINGLE=125
+GT_EQ=126
+GT=127
+HASH=128
+IREGEX_SINGLE=129
+IREGEX_DOUBLE=130
+LBRACE=131
+LBRACKET=132
+LPAREN=133
+LT_EQ=134
+LT=135
+LT_SLASH=136
+NOT_EQ=137
+NOT_IREGEX=138
+NOT_REGEX=139
+NULL_PROPERTY=140
+NULLISH=141
+PERCENT=142
+PLUS=143
+QUERY=144
+QUOTE_DOUBLE=145
+QUOTE_SINGLE_TEMPLATE=146
+QUOTE_SINGLE_TEMPLATE_FULL=147
+QUOTE_SINGLE=148
+REGEX_SINGLE=149
+REGEX_DOUBLE=150
+RBRACE=151
+RBRACKET=152
+RPAREN=153
+SEMICOLON=154
+SLASH=155
+SLASH_GT=156
+UNDERSCORE=157
+MULTI_LINE_COMMENT=158
+SINGLE_LINE_COMMENT=159
+WHITESPACE=160
+STRING_TEXT=161
+STRING_ESCAPE_TRIGGER=162
+FULL_STRING_TEXT=163
+FULL_STRING_ESCAPE_TRIGGER=164
+TAG_WS=165
+TAGC_WS=166
+TSQLX_TEXT_TEXT=167
+TSQLX_TEXT_WS=168
+'->'=114
+'*'=115
+'`'=116
+'\\'=117
+':'=118
+','=119
+'||'=120
+'-'=121
+'$'=122
+'.'=123
+'=='=124
+'>='=126
+'#'=128
+'~*'=129
+'=~*'=130
+'{'=131
+'['=132
+'('=133
+'<='=134
+'<'=135
+'</'=136
+'!~*'=138
+'!~'=139
+'?.'=140
+'??'=141
+'%'=142
+'+'=143
+'?'=144
+'"'=145
+'f\''=146
+'F\''=147
+'\''=148
+'~'=149
+'=~'=150
+'}'=151
+']'=152
+')'=153
+';'=154
+'/'=155
+'_'=157
diff --git a/internal-packages/tsql/src/grammar/TSQLParser.ts b/internal-packages/tsql/src/grammar/TSQLParser.ts
new file mode 100644
index 00000000000..4e2b482a53b
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLParser.ts
@@ -0,0 +1,11732 @@
+// Generated from src/grammar/TSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT
+
+
+import { ATN } from "antlr4ts/atn/ATN";
+import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
+import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
+import { NotNull } from "antlr4ts/Decorators";
+import { NoViableAltException } from "antlr4ts/NoViableAltException";
+import { Override } from "antlr4ts/Decorators";
+import { Parser } from "antlr4ts/Parser";
+import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
+import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
+import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
+import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
+import { RecognitionException } from "antlr4ts/RecognitionException";
+import { RuleContext } from "antlr4ts/RuleContext";
+//import { RuleVersion } from "antlr4ts/RuleVersion";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import { Token } from "antlr4ts/Token";
+import { TokenStream } from "antlr4ts/TokenStream";
+import { Vocabulary } from "antlr4ts/Vocabulary";
+import { VocabularyImpl } from "antlr4ts/VocabularyImpl";
+
+import * as Utils from "antlr4ts/misc/Utils";
+
+import { TSQLParserVisitor } from "./TSQLParserVisitor";
+
+
+export class TSQLParser extends Parser {
+	public static readonly ALL = 1;
+	public static readonly AND = 2;
+	public static readonly ANTI = 3;
+	public static readonly ANY = 4;
+	public static readonly ARRAY = 5;
+	public static readonly AS = 6;
+	public static readonly ASCENDING = 7;
+	public static readonly ASOF = 8;
+	public static readonly BETWEEN = 9;
+	public static readonly BOTH = 10;
+	public static readonly BY = 11;
+	public static readonly CASE = 12;
+	public static readonly CAST = 13;
+	public static readonly CATCH = 14;
+	public static readonly COHORT = 15;
+	public static readonly COLLATE = 16;
+	public static readonly CROSS = 17;
+	public static readonly CUBE = 18;
+	public static readonly CURRENT = 19;
+	public static readonly DATE = 20;
+	public static readonly DAY = 21;
+	public static readonly DESC = 22;
+	public static readonly DESCENDING = 23;
+	public static readonly DISTINCT = 24;
+	public static readonly ELSE = 25;
+	public static readonly END = 26;
+	public static readonly EXCEPT = 27;
+	public static readonly EXTRACT = 28;
+	public static readonly FINAL = 29;
+	public static readonly FINALLY = 30;
+	public static readonly FIRST = 31;
+	public static readonly FN = 32;
+	public static readonly FOLLOWING = 33;
+	public static readonly FOR = 34;
+	public static readonly FROM = 35;
+	public static readonly FULL = 36;
+	public static readonly FUN = 37;
+	public static readonly GROUP = 38;
+	public static readonly HAVING = 39;
+	public static readonly HOUR = 40;
+	public static readonly ID = 41;
+	public static readonly IF = 42;
+	public static readonly ILIKE = 43;
+	public static readonly IN = 44;
+	public static readonly INF = 45;
+	public static readonly INNER = 46;
+	public static readonly INTERSECT = 47;
+	public static readonly INTERVAL = 48;
+	public static readonly IS = 49;
+	public static readonly JOIN = 50;
+	public static readonly KEY = 51;
+	public static readonly LAST = 52;
+	public static readonly LEADING = 53;
+	public static readonly LEFT = 54;
+	public static readonly LET = 55;
+	public static readonly LIKE = 56;
+	public static readonly LIMIT = 57;
+	public static readonly MINUTE = 58;
+	public static readonly MONTH = 59;
+	public static readonly NAN_SQL = 60;
+	public static readonly NOT = 61;
+	public static readonly NULL_SQL = 62;
+	public static readonly NULLS = 63;
+	public static readonly OFFSET = 64;
+	public static readonly ON = 65;
+	public static readonly OR = 66;
+	public static readonly ORDER = 67;
+	public static readonly OUTER = 68;
+	public static readonly OVER = 69;
+	public static readonly PARTITION = 70;
+	public static readonly PRECEDING = 71;
+	public static readonly PREWHERE = 72;
+	public static readonly QUARTER = 73;
+	public static readonly RANGE = 74;
+	public static readonly RETURN = 75;
+	public static readonly RIGHT = 76;
+	public static readonly ROLLUP = 77;
+	public static readonly ROW = 78;
+	public static readonly ROWS = 79;
+	public static readonly SAMPLE = 80;
+	public static readonly SECOND = 81;
+	public static readonly SELECT = 82;
+	public static readonly SEMI = 83;
+	public static readonly SETTINGS = 84;
+	public static readonly SUBSTRING = 85;
+	public static readonly THEN = 86;
+	public static readonly THROW = 87;
+	public static readonly TIES = 88;
+	public static readonly TIMESTAMP = 89;
+	public static readonly TO = 90;
+	public static readonly TOP = 91;
+	public static readonly TOTALS = 92;
+	public static readonly TRAILING = 93;
+	public static readonly TRIM = 94;
+	public static readonly TRUNCATE = 95;
+	public static readonly TRY = 96;
+	public static readonly UNBOUNDED = 97;
+	public static readonly UNION = 98;
+	public static readonly USING = 99;
+	public static readonly WEEK = 100;
+	public static readonly WHEN = 101;
+	public static readonly WHERE = 102;
+	public static readonly WHILE = 103;
+	public static readonly WINDOW = 104;
+	public static readonly WITH = 105;
+	public static readonly YEAR = 106;
+	public static readonly ESCAPE_CHAR_COMMON = 107;
+	public static readonly IDENTIFIER = 108;
+	public static readonly FLOATING_LITERAL = 109;
+	public static readonly OCTAL_LITERAL = 110;
+	public static readonly DECIMAL_LITERAL = 111;
+	public static readonly HEXADECIMAL_LITERAL = 112;
+	public static readonly STRING_LITERAL = 113;
+	public static readonly ARROW = 114;
+	public static readonly ASTERISK = 115;
+	public static readonly BACKQUOTE = 116;
+	public static readonly BACKSLASH = 117;
+	public static readonly COLON = 118;
+	public static readonly COMMA = 119;
+	public static readonly CONCAT = 120;
+	public static readonly DASH = 121;
+	public static readonly DOLLAR = 122;
+	public static readonly DOT = 123;
+	public static readonly EQ_DOUBLE = 124;
+	public static readonly EQ_SINGLE = 125;
+	public static readonly GT_EQ = 126;
+	public static readonly GT = 127;
+	public static readonly HASH = 128;
+	public static readonly IREGEX_SINGLE = 129;
+	public static readonly IREGEX_DOUBLE = 130;
+	public static readonly LBRACE = 131;
+	public static readonly LBRACKET = 132;
+	public static readonly LPAREN = 133;
+	public static readonly LT_EQ = 134;
+	public static readonly LT = 135;
+	public static readonly LT_SLASH = 136;
+	public static readonly NOT_EQ = 137;
+	public static readonly NOT_IREGEX = 138;
+	public static readonly NOT_REGEX = 139;
+	public static readonly NULL_PROPERTY = 140;
+	public static readonly NULLISH = 141;
+	public static readonly PERCENT = 142;
+	public static readonly PLUS = 143;
+	public static readonly QUERY = 144;
+	public static readonly QUOTE_DOUBLE = 145;
+	public static readonly QUOTE_SINGLE_TEMPLATE = 146;
+	public static readonly QUOTE_SINGLE_TEMPLATE_FULL = 147;
+	public static readonly QUOTE_SINGLE = 148;
+	public static readonly REGEX_SINGLE = 149;
+	public static readonly REGEX_DOUBLE = 150;
+	public static readonly RBRACE = 151;
+	public static readonly RBRACKET = 152;
+	public static readonly RPAREN = 153;
+	public static readonly SEMICOLON = 154;
+	public static readonly SLASH = 155;
+	public static readonly SLASH_GT = 156;
+	public static readonly UNDERSCORE = 157;
+	public static readonly MULTI_LINE_COMMENT = 158;
+	public static readonly SINGLE_LINE_COMMENT = 159;
+	public static readonly WHITESPACE = 160;
+	public static readonly STRING_TEXT = 161;
+	public static readonly STRING_ESCAPE_TRIGGER = 162;
+	public static readonly FULL_STRING_TEXT = 163;
+	public static readonly FULL_STRING_ESCAPE_TRIGGER = 164;
+	public static readonly TAG_WS = 165;
+	public static readonly TAGC_WS = 166;
+	public static readonly TSQLX_TEXT_TEXT = 167;
+	public static readonly TSQLX_TEXT_WS = 168;
+	public static readonly RULE_program = 0;
+	public static readonly RULE_declaration = 1;
+	public static readonly RULE_expression = 2;
+	public static readonly RULE_varDecl = 3;
+	public static readonly RULE_identifierList = 4;
+	public static readonly RULE_statement = 5;
+	public static readonly RULE_returnStmt = 6;
+	public static readonly RULE_throwStmt = 7;
+	public static readonly RULE_catchBlock = 8;
+	public static readonly RULE_tryCatchStmt = 9;
+	public static readonly RULE_ifStmt = 10;
+	public static readonly RULE_whileStmt = 11;
+	public static readonly RULE_forStmt = 12;
+	public static readonly RULE_forInStmt = 13;
+	public static readonly RULE_funcStmt = 14;
+	public static readonly RULE_varAssignment = 15;
+	public static readonly RULE_exprStmt = 16;
+	public static readonly RULE_emptyStmt = 17;
+	public static readonly RULE_block = 18;
+	public static readonly RULE_kvPair = 19;
+	public static readonly RULE_kvPairList = 20;
+	public static readonly RULE_select = 21;
+	public static readonly RULE_selectStmtWithParens = 22;
+	public static readonly RULE_subsequentSelectSetClause = 23;
+	public static readonly RULE_selectSetStmt = 24;
+	public static readonly RULE_selectStmt = 25;
+	public static readonly RULE_withClause = 26;
+	public static readonly RULE_topClause = 27;
+	public static readonly RULE_fromClause = 28;
+	public static readonly RULE_arrayJoinClause = 29;
+	public static readonly RULE_windowClause = 30;
+	public static readonly RULE_prewhereClause = 31;
+	public static readonly RULE_whereClause = 32;
+	public static readonly RULE_groupByClause = 33;
+	public static readonly RULE_havingClause = 34;
+	public static readonly RULE_orderByClause = 35;
+	public static readonly RULE_projectionOrderByClause = 36;
+	public static readonly RULE_limitByClause = 37;
+	public static readonly RULE_limitAndOffsetClause = 38;
+	public static readonly RULE_offsetOnlyClause = 39;
+	public static readonly RULE_settingsClause = 40;
+	public static readonly RULE_joinExpr = 41;
+	public static readonly RULE_joinOp = 42;
+	public static readonly RULE_joinOpCross = 43;
+	public static readonly RULE_joinConstraintClause = 44;
+	public static readonly RULE_sampleClause = 45;
+	public static readonly RULE_limitExpr = 46;
+	public static readonly RULE_orderExprList = 47;
+	public static readonly RULE_orderExpr = 48;
+	public static readonly RULE_ratioExpr = 49;
+	public static readonly RULE_settingExprList = 50;
+	public static readonly RULE_settingExpr = 51;
+	public static readonly RULE_windowExpr = 52;
+	public static readonly RULE_winPartitionByClause = 53;
+	public static readonly RULE_winOrderByClause = 54;
+	public static readonly RULE_winFrameClause = 55;
+	public static readonly RULE_winFrameExtend = 56;
+	public static readonly RULE_winFrameBound = 57;
+	public static readonly RULE_expr = 58;
+	public static readonly RULE_columnTypeExpr = 59;
+	public static readonly RULE_columnExprList = 60;
+	public static readonly RULE_columnExpr = 61;
+	public static readonly RULE_columnLambdaExpr = 62;
+	public static readonly RULE_tSQLxChildElement = 63;
+	public static readonly RULE_tSQLxTagElement = 64;
+	public static readonly RULE_tSQLxTagAttribute = 65;
+	public static readonly RULE_withExprList = 66;
+	public static readonly RULE_withExpr = 67;
+	public static readonly RULE_columnIdentifier = 68;
+	public static readonly RULE_nestedIdentifier = 69;
+	public static readonly RULE_tableExpr = 70;
+	public static readonly RULE_tableFunctionExpr = 71;
+	public static readonly RULE_tableIdentifier = 72;
+	public static readonly RULE_tableArgList = 73;
+	public static readonly RULE_databaseIdentifier = 74;
+	public static readonly RULE_floatingLiteral = 75;
+	public static readonly RULE_numberLiteral = 76;
+	public static readonly RULE_literal = 77;
+	public static readonly RULE_interval = 78;
+	public static readonly RULE_keyword = 79;
+	public static readonly RULE_keywordForAlias = 80;
+	public static readonly RULE_alias = 81;
+	public static readonly RULE_identifier = 82;
+	public static readonly RULE_enumValue = 83;
+	public static readonly RULE_placeholder = 84;
+	public static readonly RULE_string = 85;
+	public static readonly RULE_templateString = 86;
+	public static readonly RULE_stringContents = 87;
+	public static readonly RULE_fullTemplateString = 88;
+	public static readonly RULE_stringContentsFull = 89;
+	// tslint:disable:no-trailing-whitespace
+	public static readonly ruleNames: string[] = [
+		"program", "declaration", "expression", "varDecl", "identifierList", "statement", 
+		"returnStmt", "throwStmt", "catchBlock", "tryCatchStmt", "ifStmt", "whileStmt", 
+		"forStmt", "forInStmt", "funcStmt", "varAssignment", "exprStmt", "emptyStmt", 
+		"block", "kvPair", "kvPairList", "select", "selectStmtWithParens", "subsequentSelectSetClause", 
+		"selectSetStmt", "selectStmt", "withClause", "topClause", "fromClause", 
+		"arrayJoinClause", "windowClause", "prewhereClause", "whereClause", "groupByClause", 
+		"havingClause", "orderByClause", "projectionOrderByClause", "limitByClause", 
+		"limitAndOffsetClause", "offsetOnlyClause", "settingsClause", "joinExpr", 
+		"joinOp", "joinOpCross", "joinConstraintClause", "sampleClause", "limitExpr", 
+		"orderExprList", "orderExpr", "ratioExpr", "settingExprList", "settingExpr", 
+		"windowExpr", "winPartitionByClause", "winOrderByClause", "winFrameClause", 
+		"winFrameExtend", "winFrameBound", "expr", "columnTypeExpr", "columnExprList", 
+		"columnExpr", "columnLambdaExpr", "tSQLxChildElement", "tSQLxTagElement", 
+		"tSQLxTagAttribute", "withExprList", "withExpr", "columnIdentifier", "nestedIdentifier", 
+		"tableExpr", "tableFunctionExpr", "tableIdentifier", "tableArgList", "databaseIdentifier", 
+		"floatingLiteral", "numberLiteral", "literal", "interval", "keyword", 
+		"keywordForAlias", "alias", "identifier", "enumValue", "placeholder", 
+		"string", "templateString", "stringContents", "fullTemplateString", "stringContentsFull",
+	];
+
+	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
+		undefined, undefined, "'->'", "'*'", "'`'", "'\\'", "':'", "','", "'||'", 
+		"'-'", "'$'", "'.'", "'=='", undefined, "'>='", undefined, "'#'", "'~*'", 
+		"'=~*'", "'{'", "'['", "'('", "'<='", "'<'", "'</'", undefined, "'!~*'", 
+		"'!~'", "'?.'", "'??'", "'%'", "'+'", "'?'", "'\"'", "'f''", "'F''", "'''", 
+		"'~'", "'=~'", "'}'", "']'", "')'", "';'", "'/'", undefined, "'_'",
+	];
+	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
+		undefined, "ALL", "AND", "ANTI", "ANY", "ARRAY", "AS", "ASCENDING", "ASOF", 
+		"BETWEEN", "BOTH", "BY", "CASE", "CAST", "CATCH", "COHORT", "COLLATE", 
+		"CROSS", "CUBE", "CURRENT", "DATE", "DAY", "DESC", "DESCENDING", "DISTINCT", 
+		"ELSE", "END", "EXCEPT", "EXTRACT", "FINAL", "FINALLY", "FIRST", "FN", 
+		"FOLLOWING", "FOR", "FROM", "FULL", "FUN", "GROUP", "HAVING", "HOUR", 
+		"ID", "IF", "ILIKE", "IN", "INF", "INNER", "INTERSECT", "INTERVAL", "IS", 
+		"JOIN", "KEY", "LAST", "LEADING", "LEFT", "LET", "LIKE", "LIMIT", "MINUTE", 
+		"MONTH", "NAN_SQL", "NOT", "NULL_SQL", "NULLS", "OFFSET", "ON", "OR", 
+		"ORDER", "OUTER", "OVER", "PARTITION", "PRECEDING", "PREWHERE", "QUARTER", 
+		"RANGE", "RETURN", "RIGHT", "ROLLUP", "ROW", "ROWS", "SAMPLE", "SECOND", 
+		"SELECT", "SEMI", "SETTINGS", "SUBSTRING", "THEN", "THROW", "TIES", "TIMESTAMP", 
+		"TO", "TOP", "TOTALS", "TRAILING", "TRIM", "TRUNCATE", "TRY", "UNBOUNDED", 
+		"UNION", "USING", "WEEK", "WHEN", "WHERE", "WHILE", "WINDOW", "WITH", 
+		"YEAR", "ESCAPE_CHAR_COMMON", "IDENTIFIER", "FLOATING_LITERAL", "OCTAL_LITERAL", 
+		"DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "STRING_LITERAL", "ARROW", "ASTERISK", 
+		"BACKQUOTE", "BACKSLASH", "COLON", "COMMA", "CONCAT", "DASH", "DOLLAR", 
+		"DOT", "EQ_DOUBLE", "EQ_SINGLE", "GT_EQ", "GT", "HASH", "IREGEX_SINGLE", 
+		"IREGEX_DOUBLE", "LBRACE", "LBRACKET", "LPAREN", "LT_EQ", "LT", "LT_SLASH", 
+		"NOT_EQ", "NOT_IREGEX", "NOT_REGEX", "NULL_PROPERTY", "NULLISH", "PERCENT", 
+		"PLUS", "QUERY", "QUOTE_DOUBLE", "QUOTE_SINGLE_TEMPLATE", "QUOTE_SINGLE_TEMPLATE_FULL", 
+		"QUOTE_SINGLE", "REGEX_SINGLE", "REGEX_DOUBLE", "RBRACE", "RBRACKET", 
+		"RPAREN", "SEMICOLON", "SLASH", "SLASH_GT", "UNDERSCORE", "MULTI_LINE_COMMENT", 
+		"SINGLE_LINE_COMMENT", "WHITESPACE", "STRING_TEXT", "STRING_ESCAPE_TRIGGER", 
+		"FULL_STRING_TEXT", "FULL_STRING_ESCAPE_TRIGGER", "TAG_WS", "TAGC_WS", 
+		"TSQLX_TEXT_TEXT", "TSQLX_TEXT_WS",
+	];
+	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(TSQLParser._LITERAL_NAMES, TSQLParser._SYMBOLIC_NAMES, []);
+
+	// @Override
+	// @NotNull
+	public get vocabulary(): Vocabulary {
+		return TSQLParser.VOCABULARY;
+	}
+	// tslint:enable:no-trailing-whitespace
+
+	// @Override
+	public get grammarFileName(): string { return "TSQLParser.g4"; }
+
+	// @Override
+	public get ruleNames(): string[] { return TSQLParser.ruleNames; }
+
+	// @Override
+	public get serializedATN(): string { return TSQLParser._serializedATN; }
+
+	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
+		return new FailedPredicateException(this, predicate, message);
+	}
+
+	constructor(input: TokenStream) {
+		super(input);
+		this._interp = new ParserATNSimulator(TSQLParser._ATN, this);
+	}
+	// @RuleVersion(0)
+	public program(): ProgramContext {
+		let _localctx: ProgramContext = new ProgramContext(this._ctx, this.state);
+		this.enterRule(_localctx, 0, TSQLParser.RULE_program);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 183;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (TSQLParser.FN - 32)) | (1 << (TSQLParser.FOLLOWING - 32)) | (1 << (TSQLParser.FOR - 32)) | (1 << (TSQLParser.FROM - 32)) | (1 << (TSQLParser.FULL - 32)) | (1 << (TSQLParser.FUN - 32)) | (1 << (TSQLParser.GROUP - 32)) | (1 << (TSQLParser.HAVING - 32)) | (1 << (TSQLParser.HOUR - 32)) | (1 << (TSQLParser.ID - 32)) | (1 << (TSQLParser.IF - 32)) | (1 << (TSQLParser.ILIKE - 32)) | (1 << (TSQLParser.IN - 32)) | (1 << (TSQLParser.INF - 32)) | (1 << (TSQLParser.INNER - 32)) | (1 << (TSQLParser.INTERVAL - 32)) | (1 << (TSQLParser.IS - 32)) | (1 << (TSQLParser.JOIN - 32)) | (1 << (TSQLParser.KEY - 32)) | (1 << (TSQLParser.LAST - 32)) | (1 << (TSQLParser.LEADING - 32)) | (1 << (TSQLParser.LEFT - 32)) | (1 << (TSQLParser.LET - 32)) | (1 << (TSQLParser.LIKE - 32)) | (1 << (TSQLParser.LIMIT - 32)) | (1 << (TSQLParser.MINUTE - 32)) | (1 << (TSQLParser.MONTH - 32)) | (1 << (TSQLParser.NAN_SQL - 32)) | (1 << (TSQLParser.NOT - 32)) | (1 << (TSQLParser.NULL_SQL - 32)) | (1 << (TSQLParser.NULLS - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (TSQLParser.OFFSET - 64)) | (1 << (TSQLParser.ON - 64)) | (1 << (TSQLParser.OR - 64)) | (1 << (TSQLParser.ORDER - 64)) | (1 << (TSQLParser.OUTER - 64)) | (1 << (TSQLParser.OVER - 64)) | (1 << (TSQLParser.PARTITION - 64)) | (1 << (TSQLParser.PRECEDING - 64)) | (1 << (TSQLParser.PREWHERE - 64)) | (1 << (TSQLParser.QUARTER - 64)) | (1 << (TSQLParser.RANGE - 64)) | (1 << (TSQLParser.RETURN - 64)) | (1 << (TSQLParser.RIGHT - 64)) | (1 << (TSQLParser.ROLLUP - 64)) | (1 << (TSQLParser.ROW - 64)) | (1 << (TSQLParser.ROWS - 64)) | (1 << (TSQLParser.SAMPLE - 64)) | (1 << (TSQLParser.SECOND - 64)) | (1 << (TSQLParser.SELECT - 64)) | (1 << (TSQLParser.SEMI - 64)) | (1 << (TSQLParser.SETTINGS - 64)) | (1 << (TSQLParser.SUBSTRING - 64)) | (1 << (TSQLParser.THEN - 64)) | (1 << (TSQLParser.THROW - 64)) | (1 << (TSQLParser.TIES - 64)) | (1 << (TSQLParser.TIMESTAMP - 64)) | (1 << (TSQLParser.TO - 64)) | (1 << (TSQLParser.TOP - 64)) | (1 << (TSQLParser.TOTALS - 64)) | (1 << (TSQLParser.TRAILING - 64)) | (1 << (TSQLParser.TRIM - 64)) | (1 << (TSQLParser.TRUNCATE - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (TSQLParser.TRY - 96)) | (1 << (TSQLParser.UNBOUNDED - 96)) | (1 << (TSQLParser.UNION - 96)) | (1 << (TSQLParser.USING - 96)) | (1 << (TSQLParser.WEEK - 96)) | (1 << (TSQLParser.WHEN - 96)) | (1 << (TSQLParser.WHERE - 96)) | (1 << (TSQLParser.WHILE - 96)) | (1 << (TSQLParser.WINDOW - 96)) | (1 << (TSQLParser.WITH - 96)) | (1 << (TSQLParser.YEAR - 96)) | (1 << (TSQLParser.IDENTIFIER - 96)) | (1 << (TSQLParser.FLOATING_LITERAL - 96)) | (1 << (TSQLParser.OCTAL_LITERAL - 96)) | (1 << (TSQLParser.DECIMAL_LITERAL - 96)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 96)) | (1 << (TSQLParser.STRING_LITERAL - 96)) | (1 << (TSQLParser.ASTERISK - 96)) | (1 << (TSQLParser.DASH - 96)) | (1 << (TSQLParser.DOT - 96)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)) | (1 << (TSQLParser.SEMICOLON - 131)))) !== 0)) {
+				{
+				{
+				this.state = 180;
+				this.declaration();
+				}
+				}
+				this.state = 185;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 186;
+			this.match(TSQLParser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public declaration(): DeclarationContext {
+		let _localctx: DeclarationContext = new DeclarationContext(this._ctx, this.state);
+		this.enterRule(_localctx, 2, TSQLParser.RULE_declaration);
+		try {
+			this.state = 190;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.LET:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 188;
+				this.varDecl();
+				}
+				break;
+			case TSQLParser.ALL:
+			case TSQLParser.AND:
+			case TSQLParser.ANTI:
+			case TSQLParser.ANY:
+			case TSQLParser.ARRAY:
+			case TSQLParser.AS:
+			case TSQLParser.ASCENDING:
+			case TSQLParser.ASOF:
+			case TSQLParser.BETWEEN:
+			case TSQLParser.BOTH:
+			case TSQLParser.BY:
+			case TSQLParser.CASE:
+			case TSQLParser.CAST:
+			case TSQLParser.COHORT:
+			case TSQLParser.COLLATE:
+			case TSQLParser.CROSS:
+			case TSQLParser.CUBE:
+			case TSQLParser.CURRENT:
+			case TSQLParser.DATE:
+			case TSQLParser.DAY:
+			case TSQLParser.DESC:
+			case TSQLParser.DESCENDING:
+			case TSQLParser.DISTINCT:
+			case TSQLParser.ELSE:
+			case TSQLParser.END:
+			case TSQLParser.EXTRACT:
+			case TSQLParser.FINAL:
+			case TSQLParser.FIRST:
+			case TSQLParser.FN:
+			case TSQLParser.FOLLOWING:
+			case TSQLParser.FOR:
+			case TSQLParser.FROM:
+			case TSQLParser.FULL:
+			case TSQLParser.FUN:
+			case TSQLParser.GROUP:
+			case TSQLParser.HAVING:
+			case TSQLParser.HOUR:
+			case TSQLParser.ID:
+			case TSQLParser.IF:
+			case TSQLParser.ILIKE:
+			case TSQLParser.IN:
+			case TSQLParser.INF:
+			case TSQLParser.INNER:
+			case TSQLParser.INTERVAL:
+			case TSQLParser.IS:
+			case TSQLParser.JOIN:
+			case TSQLParser.KEY:
+			case TSQLParser.LAST:
+			case TSQLParser.LEADING:
+			case TSQLParser.LEFT:
+			case TSQLParser.LIKE:
+			case TSQLParser.LIMIT:
+			case TSQLParser.MINUTE:
+			case TSQLParser.MONTH:
+			case TSQLParser.NAN_SQL:
+			case TSQLParser.NOT:
+			case TSQLParser.NULL_SQL:
+			case TSQLParser.NULLS:
+			case TSQLParser.OFFSET:
+			case TSQLParser.ON:
+			case TSQLParser.OR:
+			case TSQLParser.ORDER:
+			case TSQLParser.OUTER:
+			case TSQLParser.OVER:
+			case TSQLParser.PARTITION:
+			case TSQLParser.PRECEDING:
+			case TSQLParser.PREWHERE:
+			case TSQLParser.QUARTER:
+			case TSQLParser.RANGE:
+			case TSQLParser.RETURN:
+			case TSQLParser.RIGHT:
+			case TSQLParser.ROLLUP:
+			case TSQLParser.ROW:
+			case TSQLParser.ROWS:
+			case TSQLParser.SAMPLE:
+			case TSQLParser.SECOND:
+			case TSQLParser.SELECT:
+			case TSQLParser.SEMI:
+			case TSQLParser.SETTINGS:
+			case TSQLParser.SUBSTRING:
+			case TSQLParser.THEN:
+			case TSQLParser.THROW:
+			case TSQLParser.TIES:
+			case TSQLParser.TIMESTAMP:
+			case TSQLParser.TO:
+			case TSQLParser.TOP:
+			case TSQLParser.TOTALS:
+			case TSQLParser.TRAILING:
+			case TSQLParser.TRIM:
+			case TSQLParser.TRUNCATE:
+			case TSQLParser.TRY:
+			case TSQLParser.UNBOUNDED:
+			case TSQLParser.UNION:
+			case TSQLParser.USING:
+			case TSQLParser.WEEK:
+			case TSQLParser.WHEN:
+			case TSQLParser.WHERE:
+			case TSQLParser.WHILE:
+			case TSQLParser.WINDOW:
+			case TSQLParser.WITH:
+			case TSQLParser.YEAR:
+			case TSQLParser.IDENTIFIER:
+			case TSQLParser.FLOATING_LITERAL:
+			case TSQLParser.OCTAL_LITERAL:
+			case TSQLParser.DECIMAL_LITERAL:
+			case TSQLParser.HEXADECIMAL_LITERAL:
+			case TSQLParser.STRING_LITERAL:
+			case TSQLParser.ASTERISK:
+			case TSQLParser.DASH:
+			case TSQLParser.DOT:
+			case TSQLParser.LBRACE:
+			case TSQLParser.LBRACKET:
+			case TSQLParser.LPAREN:
+			case TSQLParser.LT:
+			case TSQLParser.PLUS:
+			case TSQLParser.QUOTE_SINGLE_TEMPLATE:
+			case TSQLParser.SEMICOLON:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 189;
+				this.statement();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public expression(): ExpressionContext {
+		let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
+		this.enterRule(_localctx, 4, TSQLParser.RULE_expression);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 192;
+			this.columnExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public varDecl(): VarDeclContext {
+		let _localctx: VarDeclContext = new VarDeclContext(this._ctx, this.state);
+		this.enterRule(_localctx, 6, TSQLParser.RULE_varDecl);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 194;
+			this.match(TSQLParser.LET);
+			this.state = 195;
+			this.identifier();
+			this.state = 199;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COLON) {
+				{
+				this.state = 196;
+				this.match(TSQLParser.COLON);
+				this.state = 197;
+				this.match(TSQLParser.EQ_SINGLE);
+				this.state = 198;
+				this.expression();
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public identifierList(): IdentifierListContext {
+		let _localctx: IdentifierListContext = new IdentifierListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 8, TSQLParser.RULE_identifierList);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 201;
+			this.identifier();
+			this.state = 206;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 202;
+					this.match(TSQLParser.COMMA);
+					this.state = 203;
+					this.identifier();
+					}
+					}
+				}
+				this.state = 208;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 3, this._ctx);
+			}
+			this.state = 210;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COMMA) {
+				{
+				this.state = 209;
+				this.match(TSQLParser.COMMA);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public statement(): StatementContext {
+		let _localctx: StatementContext = new StatementContext(this._ctx, this.state);
+		this.enterRule(_localctx, 10, TSQLParser.RULE_statement);
+		try {
+			this.state = 224;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 5, this._ctx) ) {
+			case 1:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 212;
+				this.returnStmt();
+				}
+				break;
+
+			case 2:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 213;
+				this.throwStmt();
+				}
+				break;
+
+			case 3:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 214;
+				this.tryCatchStmt();
+				}
+				break;
+
+			case 4:
+				this.enterOuterAlt(_localctx, 4);
+				{
+				this.state = 215;
+				this.ifStmt();
+				}
+				break;
+
+			case 5:
+				this.enterOuterAlt(_localctx, 5);
+				{
+				this.state = 216;
+				this.whileStmt();
+				}
+				break;
+
+			case 6:
+				this.enterOuterAlt(_localctx, 6);
+				{
+				this.state = 217;
+				this.forInStmt();
+				}
+				break;
+
+			case 7:
+				this.enterOuterAlt(_localctx, 7);
+				{
+				this.state = 218;
+				this.forStmt();
+				}
+				break;
+
+			case 8:
+				this.enterOuterAlt(_localctx, 8);
+				{
+				this.state = 219;
+				this.funcStmt();
+				}
+				break;
+
+			case 9:
+				this.enterOuterAlt(_localctx, 9);
+				{
+				this.state = 220;
+				this.varAssignment();
+				}
+				break;
+
+			case 10:
+				this.enterOuterAlt(_localctx, 10);
+				{
+				this.state = 221;
+				this.block();
+				}
+				break;
+
+			case 11:
+				this.enterOuterAlt(_localctx, 11);
+				{
+				this.state = 222;
+				this.exprStmt();
+				}
+				break;
+
+			case 12:
+				this.enterOuterAlt(_localctx, 12);
+				{
+				this.state = 223;
+				this.emptyStmt();
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public returnStmt(): ReturnStmtContext {
+		let _localctx: ReturnStmtContext = new ReturnStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 12, TSQLParser.RULE_returnStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 226;
+			this.match(TSQLParser.RETURN);
+			this.state = 228;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 6, this._ctx) ) {
+			case 1:
+				{
+				this.state = 227;
+				this.expression();
+				}
+				break;
+			}
+			this.state = 231;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 7, this._ctx) ) {
+			case 1:
+				{
+				this.state = 230;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public throwStmt(): ThrowStmtContext {
+		let _localctx: ThrowStmtContext = new ThrowStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 14, TSQLParser.RULE_throwStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 233;
+			this.match(TSQLParser.THROW);
+			this.state = 235;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 8, this._ctx) ) {
+			case 1:
+				{
+				this.state = 234;
+				this.expression();
+				}
+				break;
+			}
+			this.state = 238;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
+			case 1:
+				{
+				this.state = 237;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public catchBlock(): CatchBlockContext {
+		let _localctx: CatchBlockContext = new CatchBlockContext(this._ctx, this.state);
+		this.enterRule(_localctx, 16, TSQLParser.RULE_catchBlock);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 240;
+			this.match(TSQLParser.CATCH);
+			this.state = 249;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.LPAREN) {
+				{
+				this.state = 241;
+				this.match(TSQLParser.LPAREN);
+				this.state = 242;
+				_localctx._catchVar = this.identifier();
+				this.state = 245;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COLON) {
+					{
+					this.state = 243;
+					this.match(TSQLParser.COLON);
+					this.state = 244;
+					_localctx._catchType = this.identifier();
+					}
+				}
+
+				this.state = 247;
+				this.match(TSQLParser.RPAREN);
+				}
+			}
+
+			this.state = 251;
+			_localctx._catchStmt = this.block();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tryCatchStmt(): TryCatchStmtContext {
+		let _localctx: TryCatchStmtContext = new TryCatchStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 18, TSQLParser.RULE_tryCatchStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 253;
+			this.match(TSQLParser.TRY);
+			this.state = 254;
+			_localctx._tryStmt = this.block();
+			this.state = 258;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.CATCH) {
+				{
+				{
+				this.state = 255;
+				this.catchBlock();
+				}
+				}
+				this.state = 260;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 263;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.FINALLY) {
+				{
+				this.state = 261;
+				this.match(TSQLParser.FINALLY);
+				this.state = 262;
+				_localctx._finallyStmt = this.block();
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public ifStmt(): IfStmtContext {
+		let _localctx: IfStmtContext = new IfStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 20, TSQLParser.RULE_ifStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 265;
+			this.match(TSQLParser.IF);
+			this.state = 266;
+			this.match(TSQLParser.LPAREN);
+			this.state = 267;
+			this.expression();
+			this.state = 268;
+			this.match(TSQLParser.RPAREN);
+			this.state = 269;
+			this.statement();
+			this.state = 272;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 14, this._ctx) ) {
+			case 1:
+				{
+				this.state = 270;
+				this.match(TSQLParser.ELSE);
+				this.state = 271;
+				this.statement();
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public whileStmt(): WhileStmtContext {
+		let _localctx: WhileStmtContext = new WhileStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 22, TSQLParser.RULE_whileStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 274;
+			this.match(TSQLParser.WHILE);
+			this.state = 275;
+			this.match(TSQLParser.LPAREN);
+			this.state = 276;
+			this.expression();
+			this.state = 277;
+			this.match(TSQLParser.RPAREN);
+			this.state = 278;
+			this.statement();
+			this.state = 280;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 15, this._ctx) ) {
+			case 1:
+				{
+				this.state = 279;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public forStmt(): ForStmtContext {
+		let _localctx: ForStmtContext = new ForStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 24, TSQLParser.RULE_forStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 282;
+			this.match(TSQLParser.FOR);
+			this.state = 283;
+			this.match(TSQLParser.LPAREN);
+			this.state = 287;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
+			case 1:
+				{
+				this.state = 284;
+				_localctx._initializerVarDeclr = this.varDecl();
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 285;
+				_localctx._initializerVarAssignment = this.varAssignment();
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 286;
+				_localctx._initializerExpression = this.expression();
+				}
+				break;
+			}
+			this.state = 289;
+			this.match(TSQLParser.SEMICOLON);
+			this.state = 291;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+				{
+				this.state = 290;
+				_localctx._condition = this.expression();
+				}
+			}
+
+			this.state = 293;
+			this.match(TSQLParser.SEMICOLON);
+			this.state = 297;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 18, this._ctx) ) {
+			case 1:
+				{
+				this.state = 294;
+				_localctx._incrementVarDeclr = this.varDecl();
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 295;
+				_localctx._incrementVarAssignment = this.varAssignment();
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 296;
+				_localctx._incrementExpression = this.expression();
+				}
+				break;
+			}
+			this.state = 299;
+			this.match(TSQLParser.RPAREN);
+			this.state = 300;
+			this.statement();
+			this.state = 302;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
+			case 1:
+				{
+				this.state = 301;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public forInStmt(): ForInStmtContext {
+		let _localctx: ForInStmtContext = new ForInStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 26, TSQLParser.RULE_forInStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 304;
+			this.match(TSQLParser.FOR);
+			this.state = 305;
+			this.match(TSQLParser.LPAREN);
+			this.state = 306;
+			this.match(TSQLParser.LET);
+			this.state = 307;
+			this.identifier();
+			this.state = 310;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COMMA) {
+				{
+				this.state = 308;
+				this.match(TSQLParser.COMMA);
+				this.state = 309;
+				this.identifier();
+				}
+			}
+
+			this.state = 312;
+			this.match(TSQLParser.IN);
+			this.state = 313;
+			this.expression();
+			this.state = 314;
+			this.match(TSQLParser.RPAREN);
+			this.state = 315;
+			this.statement();
+			this.state = 317;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 21, this._ctx) ) {
+			case 1:
+				{
+				this.state = 316;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public funcStmt(): FuncStmtContext {
+		let _localctx: FuncStmtContext = new FuncStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 28, TSQLParser.RULE_funcStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 319;
+			_la = this._input.LA(1);
+			if (!(_la === TSQLParser.FN || _la === TSQLParser.FUN)) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			this.state = 320;
+			this.identifier();
+			this.state = 321;
+			this.match(TSQLParser.LPAREN);
+			this.state = 323;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)))) !== 0)) {
+				{
+				this.state = 322;
+				this.identifierList();
+				}
+			}
+
+			this.state = 325;
+			this.match(TSQLParser.RPAREN);
+			this.state = 326;
+			this.block();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public varAssignment(): VarAssignmentContext {
+		let _localctx: VarAssignmentContext = new VarAssignmentContext(this._ctx, this.state);
+		this.enterRule(_localctx, 30, TSQLParser.RULE_varAssignment);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 328;
+			this.expression();
+			this.state = 329;
+			this.match(TSQLParser.COLON);
+			this.state = 330;
+			this.match(TSQLParser.EQ_SINGLE);
+			this.state = 331;
+			this.expression();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public exprStmt(): ExprStmtContext {
+		let _localctx: ExprStmtContext = new ExprStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 32, TSQLParser.RULE_exprStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 333;
+			this.expression();
+			this.state = 335;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 23, this._ctx) ) {
+			case 1:
+				{
+				this.state = 334;
+				this.match(TSQLParser.SEMICOLON);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public emptyStmt(): EmptyStmtContext {
+		let _localctx: EmptyStmtContext = new EmptyStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 34, TSQLParser.RULE_emptyStmt);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 337;
+			this.match(TSQLParser.SEMICOLON);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public block(): BlockContext {
+		let _localctx: BlockContext = new BlockContext(this._ctx, this.state);
+		this.enterRule(_localctx, 36, TSQLParser.RULE_block);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 339;
+			this.match(TSQLParser.LBRACE);
+			this.state = 343;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (TSQLParser.FN - 32)) | (1 << (TSQLParser.FOLLOWING - 32)) | (1 << (TSQLParser.FOR - 32)) | (1 << (TSQLParser.FROM - 32)) | (1 << (TSQLParser.FULL - 32)) | (1 << (TSQLParser.FUN - 32)) | (1 << (TSQLParser.GROUP - 32)) | (1 << (TSQLParser.HAVING - 32)) | (1 << (TSQLParser.HOUR - 32)) | (1 << (TSQLParser.ID - 32)) | (1 << (TSQLParser.IF - 32)) | (1 << (TSQLParser.ILIKE - 32)) | (1 << (TSQLParser.IN - 32)) | (1 << (TSQLParser.INF - 32)) | (1 << (TSQLParser.INNER - 32)) | (1 << (TSQLParser.INTERVAL - 32)) | (1 << (TSQLParser.IS - 32)) | (1 << (TSQLParser.JOIN - 32)) | (1 << (TSQLParser.KEY - 32)) | (1 << (TSQLParser.LAST - 32)) | (1 << (TSQLParser.LEADING - 32)) | (1 << (TSQLParser.LEFT - 32)) | (1 << (TSQLParser.LET - 32)) | (1 << (TSQLParser.LIKE - 32)) | (1 << (TSQLParser.LIMIT - 32)) | (1 << (TSQLParser.MINUTE - 32)) | (1 << (TSQLParser.MONTH - 32)) | (1 << (TSQLParser.NAN_SQL - 32)) | (1 << (TSQLParser.NOT - 32)) | (1 << (TSQLParser.NULL_SQL - 32)) | (1 << (TSQLParser.NULLS - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (TSQLParser.OFFSET - 64)) | (1 << (TSQLParser.ON - 64)) | (1 << (TSQLParser.OR - 64)) | (1 << (TSQLParser.ORDER - 64)) | (1 << (TSQLParser.OUTER - 64)) | (1 << (TSQLParser.OVER - 64)) | (1 << (TSQLParser.PARTITION - 64)) | (1 << (TSQLParser.PRECEDING - 64)) | (1 << (TSQLParser.PREWHERE - 64)) | (1 << (TSQLParser.QUARTER - 64)) | (1 << (TSQLParser.RANGE - 64)) | (1 << (TSQLParser.RETURN - 64)) | (1 << (TSQLParser.RIGHT - 64)) | (1 << (TSQLParser.ROLLUP - 64)) | (1 << (TSQLParser.ROW - 64)) | (1 << (TSQLParser.ROWS - 64)) | (1 << (TSQLParser.SAMPLE - 64)) | (1 << (TSQLParser.SECOND - 64)) | (1 << (TSQLParser.SELECT - 64)) | (1 << (TSQLParser.SEMI - 64)) | (1 << (TSQLParser.SETTINGS - 64)) | (1 << (TSQLParser.SUBSTRING - 64)) | (1 << (TSQLParser.THEN - 64)) | (1 << (TSQLParser.THROW - 64)) | (1 << (TSQLParser.TIES - 64)) | (1 << (TSQLParser.TIMESTAMP - 64)) | (1 << (TSQLParser.TO - 64)) | (1 << (TSQLParser.TOP - 64)) | (1 << (TSQLParser.TOTALS - 64)) | (1 << (TSQLParser.TRAILING - 64)) | (1 << (TSQLParser.TRIM - 64)) | (1 << (TSQLParser.TRUNCATE - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (TSQLParser.TRY - 96)) | (1 << (TSQLParser.UNBOUNDED - 96)) | (1 << (TSQLParser.UNION - 96)) | (1 << (TSQLParser.USING - 96)) | (1 << (TSQLParser.WEEK - 96)) | (1 << (TSQLParser.WHEN - 96)) | (1 << (TSQLParser.WHERE - 96)) | (1 << (TSQLParser.WHILE - 96)) | (1 << (TSQLParser.WINDOW - 96)) | (1 << (TSQLParser.WITH - 96)) | (1 << (TSQLParser.YEAR - 96)) | (1 << (TSQLParser.IDENTIFIER - 96)) | (1 << (TSQLParser.FLOATING_LITERAL - 96)) | (1 << (TSQLParser.OCTAL_LITERAL - 96)) | (1 << (TSQLParser.DECIMAL_LITERAL - 96)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 96)) | (1 << (TSQLParser.STRING_LITERAL - 96)) | (1 << (TSQLParser.ASTERISK - 96)) | (1 << (TSQLParser.DASH - 96)) | (1 << (TSQLParser.DOT - 96)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)) | (1 << (TSQLParser.SEMICOLON - 131)))) !== 0)) {
+				{
+				{
+				this.state = 340;
+				this.declaration();
+				}
+				}
+				this.state = 345;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 346;
+			this.match(TSQLParser.RBRACE);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public kvPair(): KvPairContext {
+		let _localctx: KvPairContext = new KvPairContext(this._ctx, this.state);
+		this.enterRule(_localctx, 38, TSQLParser.RULE_kvPair);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 348;
+			this.expression();
+			this.state = 349;
+			this.match(TSQLParser.COLON);
+			this.state = 350;
+			this.expression();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public kvPairList(): KvPairListContext {
+		let _localctx: KvPairListContext = new KvPairListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 40, TSQLParser.RULE_kvPairList);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 352;
+			this.kvPair();
+			this.state = 357;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 25, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 353;
+					this.match(TSQLParser.COMMA);
+					this.state = 354;
+					this.kvPair();
+					}
+					}
+				}
+				this.state = 359;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 25, this._ctx);
+			}
+			this.state = 361;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COMMA) {
+				{
+				this.state = 360;
+				this.match(TSQLParser.COMMA);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public select(): SelectContext {
+		let _localctx: SelectContext = new SelectContext(this._ctx, this.state);
+		this.enterRule(_localctx, 42, TSQLParser.RULE_select);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 366;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 27, this._ctx) ) {
+			case 1:
+				{
+				this.state = 363;
+				this.selectSetStmt();
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 364;
+				this.selectStmt();
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 365;
+				this.tSQLxTagElement();
+				}
+				break;
+			}
+			this.state = 369;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.SEMICOLON) {
+				{
+				this.state = 368;
+				this.match(TSQLParser.SEMICOLON);
+				}
+			}
+
+			this.state = 371;
+			this.match(TSQLParser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public selectStmtWithParens(): SelectStmtWithParensContext {
+		let _localctx: SelectStmtWithParensContext = new SelectStmtWithParensContext(this._ctx, this.state);
+		this.enterRule(_localctx, 44, TSQLParser.RULE_selectStmtWithParens);
+		try {
+			this.state = 379;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.SELECT:
+			case TSQLParser.WITH:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 373;
+				this.selectStmt();
+				}
+				break;
+			case TSQLParser.LPAREN:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 374;
+				this.match(TSQLParser.LPAREN);
+				this.state = 375;
+				this.selectSetStmt();
+				this.state = 376;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+			case TSQLParser.LBRACE:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 378;
+				this.placeholder();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public subsequentSelectSetClause(): SubsequentSelectSetClauseContext {
+		let _localctx: SubsequentSelectSetClauseContext = new SubsequentSelectSetClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 46, TSQLParser.RULE_subsequentSelectSetClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 389;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 30, this._ctx) ) {
+			case 1:
+				{
+				this.state = 381;
+				this.match(TSQLParser.EXCEPT);
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 382;
+				this.match(TSQLParser.UNION);
+				this.state = 383;
+				this.match(TSQLParser.ALL);
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 384;
+				this.match(TSQLParser.UNION);
+				this.state = 385;
+				this.match(TSQLParser.DISTINCT);
+				}
+				break;
+
+			case 4:
+				{
+				this.state = 386;
+				this.match(TSQLParser.INTERSECT);
+				}
+				break;
+
+			case 5:
+				{
+				this.state = 387;
+				this.match(TSQLParser.INTERSECT);
+				this.state = 388;
+				this.match(TSQLParser.DISTINCT);
+				}
+				break;
+			}
+			this.state = 391;
+			this.selectStmtWithParens();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public selectSetStmt(): SelectSetStmtContext {
+		let _localctx: SelectSetStmtContext = new SelectSetStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 48, TSQLParser.RULE_selectSetStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 393;
+			this.selectStmtWithParens();
+			this.state = 397;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.EXCEPT || _la === TSQLParser.INTERSECT || _la === TSQLParser.UNION) {
+				{
+				{
+				this.state = 394;
+				this.subsequentSelectSetClause();
+				}
+				}
+				this.state = 399;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public selectStmt(): SelectStmtContext {
+		let _localctx: SelectStmtContext = new SelectStmtContext(this._ctx, this.state);
+		this.enterRule(_localctx, 50, TSQLParser.RULE_selectStmt);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 401;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.WITH) {
+				{
+				this.state = 400;
+				_localctx._with = this.withClause();
+				}
+			}
+
+			this.state = 403;
+			this.match(TSQLParser.SELECT);
+			this.state = 405;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 33, this._ctx) ) {
+			case 1:
+				{
+				this.state = 404;
+				this.match(TSQLParser.DISTINCT);
+				}
+				break;
+			}
+			this.state = 408;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 34, this._ctx) ) {
+			case 1:
+				{
+				this.state = 407;
+				this.topClause();
+				}
+				break;
+			}
+			this.state = 410;
+			_localctx._columns = this.columnExprList();
+			this.state = 412;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.FROM) {
+				{
+				this.state = 411;
+				_localctx._from = this.fromClause();
+				}
+			}
+
+			this.state = 415;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.ARRAY || _la === TSQLParser.INNER || _la === TSQLParser.LEFT) {
+				{
+				this.state = 414;
+				this.arrayJoinClause();
+				}
+			}
+
+			this.state = 418;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.PREWHERE) {
+				{
+				this.state = 417;
+				this.prewhereClause();
+				}
+			}
+
+			this.state = 421;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.WHERE) {
+				{
+				this.state = 420;
+				_localctx._where = this.whereClause();
+				}
+			}
+
+			this.state = 424;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.GROUP) {
+				{
+				this.state = 423;
+				this.groupByClause();
+				}
+			}
+
+			this.state = 428;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) {
+			case 1:
+				{
+				this.state = 426;
+				this.match(TSQLParser.WITH);
+				this.state = 427;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.CUBE || _la === TSQLParser.ROLLUP)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+				break;
+			}
+			this.state = 432;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.WITH) {
+				{
+				this.state = 430;
+				this.match(TSQLParser.WITH);
+				this.state = 431;
+				this.match(TSQLParser.TOTALS);
+				}
+			}
+
+			this.state = 435;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.HAVING) {
+				{
+				this.state = 434;
+				this.havingClause();
+				}
+			}
+
+			this.state = 438;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.WINDOW) {
+				{
+				this.state = 437;
+				this.windowClause();
+				}
+			}
+
+			this.state = 441;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.ORDER) {
+				{
+				this.state = 440;
+				this.orderByClause();
+				}
+			}
+
+			this.state = 444;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 45, this._ctx) ) {
+			case 1:
+				{
+				this.state = 443;
+				this.limitByClause();
+				}
+				break;
+			}
+			this.state = 448;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.LIMIT:
+				{
+				this.state = 446;
+				this.limitAndOffsetClause();
+				}
+				break;
+			case TSQLParser.OFFSET:
+				{
+				this.state = 447;
+				this.offsetOnlyClause();
+				}
+				break;
+			case TSQLParser.EOF:
+			case TSQLParser.EXCEPT:
+			case TSQLParser.INTERSECT:
+			case TSQLParser.SETTINGS:
+			case TSQLParser.UNION:
+			case TSQLParser.RPAREN:
+			case TSQLParser.SEMICOLON:
+				break;
+			default:
+				break;
+			}
+			this.state = 451;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.SETTINGS) {
+				{
+				this.state = 450;
+				this.settingsClause();
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public withClause(): WithClauseContext {
+		let _localctx: WithClauseContext = new WithClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 52, TSQLParser.RULE_withClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 453;
+			this.match(TSQLParser.WITH);
+			this.state = 454;
+			this.withExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public topClause(): TopClauseContext {
+		let _localctx: TopClauseContext = new TopClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 54, TSQLParser.RULE_topClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 456;
+			this.match(TSQLParser.TOP);
+			this.state = 457;
+			this.match(TSQLParser.DECIMAL_LITERAL);
+			this.state = 460;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 48, this._ctx) ) {
+			case 1:
+				{
+				this.state = 458;
+				this.match(TSQLParser.WITH);
+				this.state = 459;
+				this.match(TSQLParser.TIES);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public fromClause(): FromClauseContext {
+		let _localctx: FromClauseContext = new FromClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 56, TSQLParser.RULE_fromClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 462;
+			this.match(TSQLParser.FROM);
+			this.state = 463;
+			this.joinExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public arrayJoinClause(): ArrayJoinClauseContext {
+		let _localctx: ArrayJoinClauseContext = new ArrayJoinClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 58, TSQLParser.RULE_arrayJoinClause);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 466;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.INNER || _la === TSQLParser.LEFT) {
+				{
+				this.state = 465;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.INNER || _la === TSQLParser.LEFT)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+			}
+
+			this.state = 468;
+			this.match(TSQLParser.ARRAY);
+			this.state = 469;
+			this.match(TSQLParser.JOIN);
+			this.state = 470;
+			this.columnExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public windowClause(): WindowClauseContext {
+		let _localctx: WindowClauseContext = new WindowClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 60, TSQLParser.RULE_windowClause);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 472;
+			this.match(TSQLParser.WINDOW);
+			this.state = 473;
+			this.identifier();
+			this.state = 474;
+			this.match(TSQLParser.AS);
+			this.state = 475;
+			this.match(TSQLParser.LPAREN);
+			this.state = 476;
+			this.windowExpr();
+			this.state = 477;
+			this.match(TSQLParser.RPAREN);
+			this.state = 487;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.COMMA) {
+				{
+				{
+				this.state = 478;
+				this.match(TSQLParser.COMMA);
+				this.state = 479;
+				this.identifier();
+				this.state = 480;
+				this.match(TSQLParser.AS);
+				this.state = 481;
+				this.match(TSQLParser.LPAREN);
+				this.state = 482;
+				this.windowExpr();
+				this.state = 483;
+				this.match(TSQLParser.RPAREN);
+				}
+				}
+				this.state = 489;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public prewhereClause(): PrewhereClauseContext {
+		let _localctx: PrewhereClauseContext = new PrewhereClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 62, TSQLParser.RULE_prewhereClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 490;
+			this.match(TSQLParser.PREWHERE);
+			this.state = 491;
+			this.columnExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public whereClause(): WhereClauseContext {
+		let _localctx: WhereClauseContext = new WhereClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 64, TSQLParser.RULE_whereClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 493;
+			this.match(TSQLParser.WHERE);
+			this.state = 494;
+			this.columnExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public groupByClause(): GroupByClauseContext {
+		let _localctx: GroupByClauseContext = new GroupByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 66, TSQLParser.RULE_groupByClause);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 496;
+			this.match(TSQLParser.GROUP);
+			this.state = 497;
+			this.match(TSQLParser.BY);
+			this.state = 504;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 51, this._ctx) ) {
+			case 1:
+				{
+				this.state = 498;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.CUBE || _la === TSQLParser.ROLLUP)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				this.state = 499;
+				this.match(TSQLParser.LPAREN);
+				this.state = 500;
+				this.columnExprList();
+				this.state = 501;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 503;
+				this.columnExprList();
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public havingClause(): HavingClauseContext {
+		let _localctx: HavingClauseContext = new HavingClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 68, TSQLParser.RULE_havingClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 506;
+			this.match(TSQLParser.HAVING);
+			this.state = 507;
+			this.columnExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public orderByClause(): OrderByClauseContext {
+		let _localctx: OrderByClauseContext = new OrderByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 70, TSQLParser.RULE_orderByClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 509;
+			this.match(TSQLParser.ORDER);
+			this.state = 510;
+			this.match(TSQLParser.BY);
+			this.state = 511;
+			this.orderExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public projectionOrderByClause(): ProjectionOrderByClauseContext {
+		let _localctx: ProjectionOrderByClauseContext = new ProjectionOrderByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 72, TSQLParser.RULE_projectionOrderByClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 513;
+			this.match(TSQLParser.ORDER);
+			this.state = 514;
+			this.match(TSQLParser.BY);
+			this.state = 515;
+			this.columnExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public limitByClause(): LimitByClauseContext {
+		let _localctx: LimitByClauseContext = new LimitByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 74, TSQLParser.RULE_limitByClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 517;
+			this.match(TSQLParser.LIMIT);
+			this.state = 518;
+			this.limitExpr();
+			this.state = 519;
+			this.match(TSQLParser.BY);
+			this.state = 520;
+			this.columnExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public limitAndOffsetClause(): LimitAndOffsetClauseContext {
+		let _localctx: LimitAndOffsetClauseContext = new LimitAndOffsetClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 76, TSQLParser.RULE_limitAndOffsetClause);
+		let _la: number;
+		try {
+			this.state = 541;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 55, this._ctx) ) {
+			case 1:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 522;
+				this.match(TSQLParser.LIMIT);
+				this.state = 523;
+				this.columnExpr(0);
+				this.state = 526;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 524;
+					this.match(TSQLParser.COMMA);
+					this.state = 525;
+					this.columnExpr(0);
+					}
+				}
+
+				this.state = 530;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.WITH) {
+					{
+					this.state = 528;
+					this.match(TSQLParser.WITH);
+					this.state = 529;
+					this.match(TSQLParser.TIES);
+					}
+				}
+
+				}
+				break;
+
+			case 2:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 532;
+				this.match(TSQLParser.LIMIT);
+				this.state = 533;
+				this.columnExpr(0);
+				this.state = 536;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.WITH) {
+					{
+					this.state = 534;
+					this.match(TSQLParser.WITH);
+					this.state = 535;
+					this.match(TSQLParser.TIES);
+					}
+				}
+
+				this.state = 538;
+				this.match(TSQLParser.OFFSET);
+				this.state = 539;
+				this.columnExpr(0);
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public offsetOnlyClause(): OffsetOnlyClauseContext {
+		let _localctx: OffsetOnlyClauseContext = new OffsetOnlyClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 78, TSQLParser.RULE_offsetOnlyClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 543;
+			this.match(TSQLParser.OFFSET);
+			this.state = 544;
+			this.columnExpr(0);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public settingsClause(): SettingsClauseContext {
+		let _localctx: SettingsClauseContext = new SettingsClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 80, TSQLParser.RULE_settingsClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 546;
+			this.match(TSQLParser.SETTINGS);
+			this.state = 547;
+			this.settingExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+
+	public joinExpr(): JoinExprContext;
+	public joinExpr(_p: number): JoinExprContext;
+	// @RuleVersion(0)
+	public joinExpr(_p?: number): JoinExprContext {
+		if (_p === undefined) {
+			_p = 0;
+		}
+
+		let _parentctx: ParserRuleContext = this._ctx;
+		let _parentState: number = this.state;
+		let _localctx: JoinExprContext = new JoinExprContext(this._ctx, _parentState);
+		let _prevctx: JoinExprContext = _localctx;
+		let _startState: number = 82;
+		this.enterRecursionRule(_localctx, 82, TSQLParser.RULE_joinExpr, _p);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 561;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 58, this._ctx) ) {
+			case 1:
+				{
+				_localctx = new JoinExprTableContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+
+				this.state = 550;
+				this.tableExpr(0);
+				this.state = 552;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 56, this._ctx) ) {
+				case 1:
+					{
+					this.state = 551;
+					this.match(TSQLParser.FINAL);
+					}
+					break;
+				}
+				this.state = 555;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 57, this._ctx) ) {
+				case 1:
+					{
+					this.state = 554;
+					this.sampleClause();
+					}
+					break;
+				}
+				}
+				break;
+
+			case 2:
+				{
+				_localctx = new JoinExprParensContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 557;
+				this.match(TSQLParser.LPAREN);
+				this.state = 558;
+				this.joinExpr(0);
+				this.state = 559;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+			}
+			this._ctx._stop = this._input.tryLT(-1);
+			this.state = 577;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 61, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					if (this._parseListeners != null) {
+						this.triggerExitRuleEvent();
+					}
+					_prevctx = _localctx;
+					{
+					this.state = 575;
+					this._errHandler.sync(this);
+					switch ( this.interpreter.adaptivePredict(this._input, 60, this._ctx) ) {
+					case 1:
+						{
+						_localctx = new JoinExprCrossOpContext(new JoinExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_joinExpr);
+						this.state = 563;
+						if (!(this.precpred(this._ctx, 3))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
+						}
+						this.state = 564;
+						this.joinOpCross();
+						this.state = 565;
+						this.joinExpr(4);
+						}
+						break;
+
+					case 2:
+						{
+						_localctx = new JoinExprOpContext(new JoinExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_joinExpr);
+						this.state = 567;
+						if (!(this.precpred(this._ctx, 4))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
+						}
+						this.state = 569;
+						this._errHandler.sync(this);
+						_la = this._input.LA(1);
+						if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & ((1 << (TSQLParser.FULL - 36)) | (1 << (TSQLParser.INNER - 36)) | (1 << (TSQLParser.LEFT - 36)))) !== 0) || _la === TSQLParser.RIGHT || _la === TSQLParser.SEMI) {
+							{
+							this.state = 568;
+							this.joinOp();
+							}
+						}
+
+						this.state = 571;
+						this.match(TSQLParser.JOIN);
+						this.state = 572;
+						this.joinExpr(0);
+						this.state = 573;
+						this.joinConstraintClause();
+						}
+						break;
+					}
+					}
+				}
+				this.state = 579;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 61, this._ctx);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public joinOp(): JoinOpContext {
+		let _localctx: JoinOpContext = new JoinOpContext(this._ctx, this.state);
+		this.enterRule(_localctx, 84, TSQLParser.RULE_joinOp);
+		let _la: number;
+		try {
+			this.state = 623;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 75, this._ctx) ) {
+			case 1:
+				_localctx = new JoinOpInnerContext(_localctx);
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 589;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 64, this._ctx) ) {
+				case 1:
+					{
+					this.state = 581;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0)) {
+						{
+						this.state = 580;
+						_la = this._input.LA(1);
+						if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0))) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					this.state = 583;
+					this.match(TSQLParser.INNER);
+					}
+					break;
+
+				case 2:
+					{
+					this.state = 584;
+					this.match(TSQLParser.INNER);
+					this.state = 586;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0)) {
+						{
+						this.state = 585;
+						_la = this._input.LA(1);
+						if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0))) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					}
+					break;
+
+				case 3:
+					{
+					this.state = 588;
+					_la = this._input.LA(1);
+					if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0))) {
+					this._errHandler.recoverInline(this);
+					} else {
+						if (this._input.LA(1) === Token.EOF) {
+							this.matchedEOF = true;
+						}
+
+						this._errHandler.reportMatch(this);
+						this.consume();
+					}
+					}
+					break;
+				}
+				}
+				break;
+
+			case 2:
+				_localctx = new JoinOpLeftRightContext(_localctx);
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 605;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 69, this._ctx) ) {
+				case 1:
+					{
+					this.state = 592;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0) || _la === TSQLParser.SEMI) {
+						{
+						this.state = 591;
+						_la = this._input.LA(1);
+						if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0) || _la === TSQLParser.SEMI)) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					this.state = 594;
+					_la = this._input.LA(1);
+					if (!(_la === TSQLParser.LEFT || _la === TSQLParser.RIGHT)) {
+					this._errHandler.recoverInline(this);
+					} else {
+						if (this._input.LA(1) === Token.EOF) {
+							this.matchedEOF = true;
+						}
+
+						this._errHandler.reportMatch(this);
+						this.consume();
+					}
+					this.state = 596;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.OUTER) {
+						{
+						this.state = 595;
+						this.match(TSQLParser.OUTER);
+						}
+					}
+
+					}
+					break;
+
+				case 2:
+					{
+					this.state = 598;
+					_la = this._input.LA(1);
+					if (!(_la === TSQLParser.LEFT || _la === TSQLParser.RIGHT)) {
+					this._errHandler.recoverInline(this);
+					} else {
+						if (this._input.LA(1) === Token.EOF) {
+							this.matchedEOF = true;
+						}
+
+						this._errHandler.reportMatch(this);
+						this.consume();
+					}
+					this.state = 600;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.OUTER) {
+						{
+						this.state = 599;
+						this.match(TSQLParser.OUTER);
+						}
+					}
+
+					this.state = 603;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0) || _la === TSQLParser.SEMI) {
+						{
+						this.state = 602;
+						_la = this._input.LA(1);
+						if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ASOF))) !== 0) || _la === TSQLParser.SEMI)) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					}
+					break;
+				}
+				}
+				break;
+
+			case 3:
+				_localctx = new JoinOpFullContext(_localctx);
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 621;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) {
+				case 1:
+					{
+					this.state = 608;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.ALL || _la === TSQLParser.ANY) {
+						{
+						this.state = 607;
+						_la = this._input.LA(1);
+						if (!(_la === TSQLParser.ALL || _la === TSQLParser.ANY)) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					this.state = 610;
+					this.match(TSQLParser.FULL);
+					this.state = 612;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.OUTER) {
+						{
+						this.state = 611;
+						this.match(TSQLParser.OUTER);
+						}
+					}
+
+					}
+					break;
+
+				case 2:
+					{
+					this.state = 614;
+					this.match(TSQLParser.FULL);
+					this.state = 616;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.OUTER) {
+						{
+						this.state = 615;
+						this.match(TSQLParser.OUTER);
+						}
+					}
+
+					this.state = 619;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if (_la === TSQLParser.ALL || _la === TSQLParser.ANY) {
+						{
+						this.state = 618;
+						_la = this._input.LA(1);
+						if (!(_la === TSQLParser.ALL || _la === TSQLParser.ANY)) {
+						this._errHandler.recoverInline(this);
+						} else {
+							if (this._input.LA(1) === Token.EOF) {
+								this.matchedEOF = true;
+							}
+
+							this._errHandler.reportMatch(this);
+							this.consume();
+						}
+						}
+					}
+
+					}
+					break;
+				}
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public joinOpCross(): JoinOpCrossContext {
+		let _localctx: JoinOpCrossContext = new JoinOpCrossContext(this._ctx, this.state);
+		this.enterRule(_localctx, 86, TSQLParser.RULE_joinOpCross);
+		try {
+			this.state = 628;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.CROSS:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 625;
+				this.match(TSQLParser.CROSS);
+				this.state = 626;
+				this.match(TSQLParser.JOIN);
+				}
+				break;
+			case TSQLParser.COMMA:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 627;
+				this.match(TSQLParser.COMMA);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public joinConstraintClause(): JoinConstraintClauseContext {
+		let _localctx: JoinConstraintClauseContext = new JoinConstraintClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 88, TSQLParser.RULE_joinConstraintClause);
+		try {
+			this.state = 639;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 77, this._ctx) ) {
+			case 1:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 630;
+				this.match(TSQLParser.ON);
+				this.state = 631;
+				this.columnExprList();
+				}
+				break;
+
+			case 2:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 632;
+				this.match(TSQLParser.USING);
+				this.state = 633;
+				this.match(TSQLParser.LPAREN);
+				this.state = 634;
+				this.columnExprList();
+				this.state = 635;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 3:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 637;
+				this.match(TSQLParser.USING);
+				this.state = 638;
+				this.columnExprList();
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public sampleClause(): SampleClauseContext {
+		let _localctx: SampleClauseContext = new SampleClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 90, TSQLParser.RULE_sampleClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 641;
+			this.match(TSQLParser.SAMPLE);
+			this.state = 642;
+			this.ratioExpr();
+			this.state = 645;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 78, this._ctx) ) {
+			case 1:
+				{
+				this.state = 643;
+				this.match(TSQLParser.OFFSET);
+				this.state = 644;
+				this.ratioExpr();
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public limitExpr(): LimitExprContext {
+		let _localctx: LimitExprContext = new LimitExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 92, TSQLParser.RULE_limitExpr);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 647;
+			this.columnExpr(0);
+			this.state = 650;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.OFFSET || _la === TSQLParser.COMMA) {
+				{
+				this.state = 648;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.OFFSET || _la === TSQLParser.COMMA)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				this.state = 649;
+				this.columnExpr(0);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public orderExprList(): OrderExprListContext {
+		let _localctx: OrderExprListContext = new OrderExprListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 94, TSQLParser.RULE_orderExprList);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 652;
+			this.orderExpr();
+			this.state = 657;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.COMMA) {
+				{
+				{
+				this.state = 653;
+				this.match(TSQLParser.COMMA);
+				this.state = 654;
+				this.orderExpr();
+				}
+				}
+				this.state = 659;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public orderExpr(): OrderExprContext {
+		let _localctx: OrderExprContext = new OrderExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 96, TSQLParser.RULE_orderExpr);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 660;
+			this.columnExpr(0);
+			this.state = 662;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ASCENDING) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING))) !== 0)) {
+				{
+				this.state = 661;
+				_la = this._input.LA(1);
+				if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ASCENDING) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING))) !== 0))) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+			}
+
+			this.state = 666;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.NULLS) {
+				{
+				this.state = 664;
+				this.match(TSQLParser.NULLS);
+				this.state = 665;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.FIRST || _la === TSQLParser.LAST)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+			}
+
+			this.state = 670;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COLLATE) {
+				{
+				this.state = 668;
+				this.match(TSQLParser.COLLATE);
+				this.state = 669;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public ratioExpr(): RatioExprContext {
+		let _localctx: RatioExprContext = new RatioExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 98, TSQLParser.RULE_ratioExpr);
+		try {
+			this.state = 678;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.LBRACE:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 672;
+				this.placeholder();
+				}
+				break;
+			case TSQLParser.INF:
+			case TSQLParser.NAN_SQL:
+			case TSQLParser.FLOATING_LITERAL:
+			case TSQLParser.OCTAL_LITERAL:
+			case TSQLParser.DECIMAL_LITERAL:
+			case TSQLParser.HEXADECIMAL_LITERAL:
+			case TSQLParser.DASH:
+			case TSQLParser.DOT:
+			case TSQLParser.PLUS:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 673;
+				this.numberLiteral();
+				this.state = 676;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 84, this._ctx) ) {
+				case 1:
+					{
+					this.state = 674;
+					this.match(TSQLParser.SLASH);
+					this.state = 675;
+					this.numberLiteral();
+					}
+					break;
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public settingExprList(): SettingExprListContext {
+		let _localctx: SettingExprListContext = new SettingExprListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 100, TSQLParser.RULE_settingExprList);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 680;
+			this.settingExpr();
+			this.state = 685;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.COMMA) {
+				{
+				{
+				this.state = 681;
+				this.match(TSQLParser.COMMA);
+				this.state = 682;
+				this.settingExpr();
+				}
+				}
+				this.state = 687;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public settingExpr(): SettingExprContext {
+		let _localctx: SettingExprContext = new SettingExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 102, TSQLParser.RULE_settingExpr);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 688;
+			this.identifier();
+			this.state = 689;
+			this.match(TSQLParser.EQ_SINGLE);
+			this.state = 690;
+			this.literal();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public windowExpr(): WindowExprContext {
+		let _localctx: WindowExprContext = new WindowExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 104, TSQLParser.RULE_windowExpr);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 693;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.PARTITION) {
+				{
+				this.state = 692;
+				this.winPartitionByClause();
+				}
+			}
+
+			this.state = 696;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.ORDER) {
+				{
+				this.state = 695;
+				this.winOrderByClause();
+				}
+			}
+
+			this.state = 699;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.RANGE || _la === TSQLParser.ROWS) {
+				{
+				this.state = 698;
+				this.winFrameClause();
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public winPartitionByClause(): WinPartitionByClauseContext {
+		let _localctx: WinPartitionByClauseContext = new WinPartitionByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 106, TSQLParser.RULE_winPartitionByClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 701;
+			this.match(TSQLParser.PARTITION);
+			this.state = 702;
+			this.match(TSQLParser.BY);
+			this.state = 703;
+			this.columnExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public winOrderByClause(): WinOrderByClauseContext {
+		let _localctx: WinOrderByClauseContext = new WinOrderByClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 108, TSQLParser.RULE_winOrderByClause);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 705;
+			this.match(TSQLParser.ORDER);
+			this.state = 706;
+			this.match(TSQLParser.BY);
+			this.state = 707;
+			this.orderExprList();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public winFrameClause(): WinFrameClauseContext {
+		let _localctx: WinFrameClauseContext = new WinFrameClauseContext(this._ctx, this.state);
+		this.enterRule(_localctx, 110, TSQLParser.RULE_winFrameClause);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 709;
+			_la = this._input.LA(1);
+			if (!(_la === TSQLParser.RANGE || _la === TSQLParser.ROWS)) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			this.state = 710;
+			this.winFrameExtend();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public winFrameExtend(): WinFrameExtendContext {
+		let _localctx: WinFrameExtendContext = new WinFrameExtendContext(this._ctx, this.state);
+		this.enterRule(_localctx, 112, TSQLParser.RULE_winFrameExtend);
+		try {
+			this.state = 718;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.CURRENT:
+			case TSQLParser.INF:
+			case TSQLParser.NAN_SQL:
+			case TSQLParser.UNBOUNDED:
+			case TSQLParser.FLOATING_LITERAL:
+			case TSQLParser.OCTAL_LITERAL:
+			case TSQLParser.DECIMAL_LITERAL:
+			case TSQLParser.HEXADECIMAL_LITERAL:
+			case TSQLParser.DASH:
+			case TSQLParser.DOT:
+			case TSQLParser.PLUS:
+				_localctx = new FrameStartContext(_localctx);
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 712;
+				this.winFrameBound();
+				}
+				break;
+			case TSQLParser.BETWEEN:
+				_localctx = new FrameBetweenContext(_localctx);
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 713;
+				this.match(TSQLParser.BETWEEN);
+				this.state = 714;
+				this.winFrameBound();
+				this.state = 715;
+				this.match(TSQLParser.AND);
+				this.state = 716;
+				this.winFrameBound();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public winFrameBound(): WinFrameBoundContext {
+		let _localctx: WinFrameBoundContext = new WinFrameBoundContext(this._ctx, this.state);
+		this.enterRule(_localctx, 114, TSQLParser.RULE_winFrameBound);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 732;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) {
+			case 1:
+				{
+				this.state = 720;
+				this.match(TSQLParser.CURRENT);
+				this.state = 721;
+				this.match(TSQLParser.ROW);
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 722;
+				this.match(TSQLParser.UNBOUNDED);
+				this.state = 723;
+				this.match(TSQLParser.PRECEDING);
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 724;
+				this.match(TSQLParser.UNBOUNDED);
+				this.state = 725;
+				this.match(TSQLParser.FOLLOWING);
+				}
+				break;
+
+			case 4:
+				{
+				this.state = 726;
+				this.numberLiteral();
+				this.state = 727;
+				this.match(TSQLParser.PRECEDING);
+				}
+				break;
+
+			case 5:
+				{
+				this.state = 729;
+				this.numberLiteral();
+				this.state = 730;
+				this.match(TSQLParser.FOLLOWING);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public expr(): ExprContext {
+		let _localctx: ExprContext = new ExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 116, TSQLParser.RULE_expr);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 734;
+			this.columnExpr(0);
+			this.state = 735;
+			this.match(TSQLParser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public columnTypeExpr(): ColumnTypeExprContext {
+		let _localctx: ColumnTypeExprContext = new ColumnTypeExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 118, TSQLParser.RULE_columnTypeExpr);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.state = 793;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 99, this._ctx) ) {
+			case 1:
+				_localctx = new ColumnTypeExprSimpleContext(_localctx);
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 737;
+				this.identifier();
+				}
+				break;
+
+			case 2:
+				_localctx = new ColumnTypeExprNestedContext(_localctx);
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 738;
+				this.identifier();
+				this.state = 739;
+				this.match(TSQLParser.LPAREN);
+				this.state = 740;
+				this.identifier();
+				this.state = 741;
+				this.columnTypeExpr();
+				this.state = 748;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 92, this._ctx);
+				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+					if (_alt === 1) {
+						{
+						{
+						this.state = 742;
+						this.match(TSQLParser.COMMA);
+						this.state = 743;
+						this.identifier();
+						this.state = 744;
+						this.columnTypeExpr();
+						}
+						}
+					}
+					this.state = 750;
+					this._errHandler.sync(this);
+					_alt = this.interpreter.adaptivePredict(this._input, 92, this._ctx);
+				}
+				this.state = 752;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 751;
+					this.match(TSQLParser.COMMA);
+					}
+				}
+
+				this.state = 754;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 3:
+				_localctx = new ColumnTypeExprEnumContext(_localctx);
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 756;
+				this.identifier();
+				this.state = 757;
+				this.match(TSQLParser.LPAREN);
+				this.state = 758;
+				this.enumValue();
+				this.state = 763;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 94, this._ctx);
+				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+					if (_alt === 1) {
+						{
+						{
+						this.state = 759;
+						this.match(TSQLParser.COMMA);
+						this.state = 760;
+						this.enumValue();
+						}
+						}
+					}
+					this.state = 765;
+					this._errHandler.sync(this);
+					_alt = this.interpreter.adaptivePredict(this._input, 94, this._ctx);
+				}
+				this.state = 767;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 766;
+					this.match(TSQLParser.COMMA);
+					}
+				}
+
+				this.state = 769;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 4:
+				_localctx = new ColumnTypeExprComplexContext(_localctx);
+				this.enterOuterAlt(_localctx, 4);
+				{
+				this.state = 771;
+				this.identifier();
+				this.state = 772;
+				this.match(TSQLParser.LPAREN);
+				this.state = 773;
+				this.columnTypeExpr();
+				this.state = 778;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 96, this._ctx);
+				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+					if (_alt === 1) {
+						{
+						{
+						this.state = 774;
+						this.match(TSQLParser.COMMA);
+						this.state = 775;
+						this.columnTypeExpr();
+						}
+						}
+					}
+					this.state = 780;
+					this._errHandler.sync(this);
+					_alt = this.interpreter.adaptivePredict(this._input, 96, this._ctx);
+				}
+				this.state = 782;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 781;
+					this.match(TSQLParser.COMMA);
+					}
+				}
+
+				this.state = 784;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 5:
+				_localctx = new ColumnTypeExprParamContext(_localctx);
+				this.enterOuterAlt(_localctx, 5);
+				{
+				this.state = 786;
+				this.identifier();
+				this.state = 787;
+				this.match(TSQLParser.LPAREN);
+				this.state = 789;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 788;
+					this.columnExprList();
+					}
+				}
+
+				this.state = 791;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public columnExprList(): ColumnExprListContext {
+		let _localctx: ColumnExprListContext = new ColumnExprListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 120, TSQLParser.RULE_columnExprList);
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 795;
+			this.columnExpr(0);
+			this.state = 800;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 100, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 796;
+					this.match(TSQLParser.COMMA);
+					this.state = 797;
+					this.columnExpr(0);
+					}
+					}
+				}
+				this.state = 802;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 100, this._ctx);
+			}
+			this.state = 804;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 101, this._ctx) ) {
+			case 1:
+				{
+				this.state = 803;
+				this.match(TSQLParser.COMMA);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+
+	public columnExpr(): ColumnExprContext;
+	public columnExpr(_p: number): ColumnExprContext;
+	// @RuleVersion(0)
+	public columnExpr(_p?: number): ColumnExprContext {
+		if (_p === undefined) {
+			_p = 0;
+		}
+
+		let _parentctx: ParserRuleContext = this._ctx;
+		let _parentState: number = this.state;
+		let _localctx: ColumnExprContext = new ColumnExprContext(this._ctx, _parentState);
+		let _prevctx: ColumnExprContext = _localctx;
+		let _startState: number = 122;
+		this.enterRecursionRule(_localctx, 122, TSQLParser.RULE_columnExpr, _p);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 958;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 121, this._ctx) ) {
+			case 1:
+				{
+				_localctx = new ColumnExprCaseContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+
+				this.state = 807;
+				this.match(TSQLParser.CASE);
+				this.state = 809;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 102, this._ctx) ) {
+				case 1:
+					{
+					this.state = 808;
+					(_localctx as ColumnExprCaseContext)._caseExpr = this.columnExpr(0);
+					}
+					break;
+				}
+				this.state = 816;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				do {
+					{
+					{
+					this.state = 811;
+					this.match(TSQLParser.WHEN);
+					this.state = 812;
+					(_localctx as ColumnExprCaseContext)._whenExpr = this.columnExpr(0);
+					this.state = 813;
+					this.match(TSQLParser.THEN);
+					this.state = 814;
+					(_localctx as ColumnExprCaseContext)._thenExpr = this.columnExpr(0);
+					}
+					}
+					this.state = 818;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+				} while (_la === TSQLParser.WHEN);
+				this.state = 822;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.ELSE) {
+					{
+					this.state = 820;
+					this.match(TSQLParser.ELSE);
+					this.state = 821;
+					(_localctx as ColumnExprCaseContext)._elseExpr = this.columnExpr(0);
+					}
+				}
+
+				this.state = 824;
+				this.match(TSQLParser.END);
+				}
+				break;
+
+			case 2:
+				{
+				_localctx = new ColumnExprCastContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 826;
+				this.match(TSQLParser.CAST);
+				this.state = 827;
+				this.match(TSQLParser.LPAREN);
+				this.state = 828;
+				this.columnExpr(0);
+				this.state = 829;
+				this.match(TSQLParser.AS);
+				this.state = 830;
+				this.columnTypeExpr();
+				this.state = 831;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 3:
+				{
+				_localctx = new ColumnExprDateContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 833;
+				this.match(TSQLParser.DATE);
+				this.state = 834;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+				break;
+
+			case 4:
+				{
+				_localctx = new ColumnExprIntervalStringContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 835;
+				this.match(TSQLParser.INTERVAL);
+				this.state = 836;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+				break;
+
+			case 5:
+				{
+				_localctx = new ColumnExprIntervalContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 837;
+				this.match(TSQLParser.INTERVAL);
+				this.state = 838;
+				this.columnExpr(0);
+				this.state = 839;
+				this.interval();
+				}
+				break;
+
+			case 6:
+				{
+				_localctx = new ColumnExprSubstringContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 841;
+				this.match(TSQLParser.SUBSTRING);
+				this.state = 842;
+				this.match(TSQLParser.LPAREN);
+				this.state = 843;
+				this.columnExpr(0);
+				this.state = 844;
+				this.match(TSQLParser.FROM);
+				this.state = 845;
+				this.columnExpr(0);
+				this.state = 848;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.FOR) {
+					{
+					this.state = 846;
+					this.match(TSQLParser.FOR);
+					this.state = 847;
+					this.columnExpr(0);
+					}
+				}
+
+				this.state = 850;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 7:
+				{
+				_localctx = new ColumnExprTimestampContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 852;
+				this.match(TSQLParser.TIMESTAMP);
+				this.state = 853;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+				break;
+
+			case 8:
+				{
+				_localctx = new ColumnExprTrimContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 854;
+				this.match(TSQLParser.TRIM);
+				this.state = 855;
+				this.match(TSQLParser.LPAREN);
+				this.state = 856;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.BOTH || _la === TSQLParser.LEADING || _la === TSQLParser.TRAILING)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				this.state = 857;
+				this.string();
+				this.state = 858;
+				this.match(TSQLParser.FROM);
+				this.state = 859;
+				this.columnExpr(0);
+				this.state = 860;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 9:
+				{
+				_localctx = new ColumnExprWinFunctionContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 862;
+				this.identifier();
+				{
+				this.state = 863;
+				this.match(TSQLParser.LPAREN);
+				this.state = 865;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 864;
+					(_localctx as ColumnExprWinFunctionContext)._columnExprs = this.columnExprList();
+					}
+				}
+
+				this.state = 867;
+				this.match(TSQLParser.RPAREN);
+				}
+				this.state = 877;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.LPAREN) {
+					{
+					this.state = 869;
+					this.match(TSQLParser.LPAREN);
+					this.state = 871;
+					this._errHandler.sync(this);
+					switch ( this.interpreter.adaptivePredict(this._input, 107, this._ctx) ) {
+					case 1:
+						{
+						this.state = 870;
+						this.match(TSQLParser.DISTINCT);
+						}
+						break;
+					}
+					this.state = 874;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+						{
+						this.state = 873;
+						(_localctx as ColumnExprWinFunctionContext)._columnArgList = this.columnExprList();
+						}
+					}
+
+					this.state = 876;
+					this.match(TSQLParser.RPAREN);
+					}
+				}
+
+				this.state = 879;
+				this.match(TSQLParser.OVER);
+				this.state = 880;
+				this.match(TSQLParser.LPAREN);
+				this.state = 881;
+				this.windowExpr();
+				this.state = 882;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 10:
+				{
+				_localctx = new ColumnExprWinFunctionTargetContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 884;
+				this.identifier();
+				{
+				this.state = 885;
+				this.match(TSQLParser.LPAREN);
+				this.state = 887;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 886;
+					(_localctx as ColumnExprWinFunctionTargetContext)._columnExprs = this.columnExprList();
+					}
+				}
+
+				this.state = 889;
+				this.match(TSQLParser.RPAREN);
+				}
+				this.state = 899;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.LPAREN) {
+					{
+					this.state = 891;
+					this.match(TSQLParser.LPAREN);
+					this.state = 893;
+					this._errHandler.sync(this);
+					switch ( this.interpreter.adaptivePredict(this._input, 111, this._ctx) ) {
+					case 1:
+						{
+						this.state = 892;
+						this.match(TSQLParser.DISTINCT);
+						}
+						break;
+					}
+					this.state = 896;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+						{
+						this.state = 895;
+						(_localctx as ColumnExprWinFunctionTargetContext)._columnArgList = this.columnExprList();
+						}
+					}
+
+					this.state = 898;
+					this.match(TSQLParser.RPAREN);
+					}
+				}
+
+				this.state = 901;
+				this.match(TSQLParser.OVER);
+				this.state = 902;
+				this.identifier();
+				}
+				break;
+
+			case 11:
+				{
+				_localctx = new ColumnExprFunctionContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 904;
+				this.identifier();
+				this.state = 910;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 115, this._ctx) ) {
+				case 1:
+					{
+					this.state = 905;
+					this.match(TSQLParser.LPAREN);
+					this.state = 907;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+						{
+						this.state = 906;
+						(_localctx as ColumnExprFunctionContext)._columnExprs = this.columnExprList();
+						}
+					}
+
+					this.state = 909;
+					this.match(TSQLParser.RPAREN);
+					}
+					break;
+				}
+				this.state = 912;
+				this.match(TSQLParser.LPAREN);
+				this.state = 914;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 116, this._ctx) ) {
+				case 1:
+					{
+					this.state = 913;
+					this.match(TSQLParser.DISTINCT);
+					}
+					break;
+				}
+				this.state = 917;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 916;
+					(_localctx as ColumnExprFunctionContext)._columnArgList = this.columnExprList();
+					}
+				}
+
+				this.state = 919;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 12:
+				{
+				_localctx = new ColumnExprTagElementContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 921;
+				this.tSQLxTagElement();
+				}
+				break;
+
+			case 13:
+				{
+				_localctx = new ColumnExprTemplateStringContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 922;
+				this.templateString();
+				}
+				break;
+
+			case 14:
+				{
+				_localctx = new ColumnExprLiteralContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 923;
+				this.literal();
+				}
+				break;
+
+			case 15:
+				{
+				_localctx = new ColumnExprNegateContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 924;
+				this.match(TSQLParser.DASH);
+				this.state = 925;
+				this.columnExpr(20);
+				}
+				break;
+
+			case 16:
+				{
+				_localctx = new ColumnExprNotContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 926;
+				this.match(TSQLParser.NOT);
+				this.state = 927;
+				this.columnExpr(14);
+				}
+				break;
+
+			case 17:
+				{
+				_localctx = new ColumnExprAsteriskContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 931;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)))) !== 0)) {
+					{
+					this.state = 928;
+					this.tableIdentifier();
+					this.state = 929;
+					this.match(TSQLParser.DOT);
+					}
+				}
+
+				this.state = 933;
+				this.match(TSQLParser.ASTERISK);
+				}
+				break;
+
+			case 18:
+				{
+				_localctx = new ColumnExprSubqueryContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 934;
+				this.match(TSQLParser.LPAREN);
+				this.state = 935;
+				this.selectSetStmt();
+				this.state = 936;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 19:
+				{
+				_localctx = new ColumnExprParensContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 938;
+				this.match(TSQLParser.LPAREN);
+				this.state = 939;
+				this.columnExpr(0);
+				this.state = 940;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 20:
+				{
+				_localctx = new ColumnExprTupleContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 942;
+				this.match(TSQLParser.LPAREN);
+				this.state = 943;
+				this.columnExprList();
+				this.state = 944;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 21:
+				{
+				_localctx = new ColumnExprArrayContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 946;
+				this.match(TSQLParser.LBRACKET);
+				this.state = 948;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 947;
+					this.columnExprList();
+					}
+				}
+
+				this.state = 950;
+				this.match(TSQLParser.RBRACKET);
+				}
+				break;
+
+			case 22:
+				{
+				_localctx = new ColumnExprDictContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 951;
+				this.match(TSQLParser.LBRACE);
+				this.state = 953;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+					{
+					this.state = 952;
+					this.kvPairList();
+					}
+				}
+
+				this.state = 955;
+				this.match(TSQLParser.RBRACE);
+				}
+				break;
+
+			case 23:
+				{
+				_localctx = new ColumnExprLambdaContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 956;
+				this.columnLambdaExpr();
+				}
+				break;
+
+			case 24:
+				{
+				_localctx = new ColumnExprIdentifierContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 957;
+				this.columnIdentifier();
+				}
+				break;
+			}
+			this._ctx._stop = this._input.tryLT(-1);
+			this.state = 1075;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 133, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					if (this._parseListeners != null) {
+						this.triggerExitRuleEvent();
+					}
+					_prevctx = _localctx;
+					{
+					this.state = 1073;
+					this._errHandler.sync(this);
+					switch ( this.interpreter.adaptivePredict(this._input, 132, this._ctx) ) {
+					case 1:
+						{
+						_localctx = new ColumnExprPrecedence1Context(new ColumnExprContext(_parentctx, _parentState));
+						(_localctx as ColumnExprPrecedence1Context)._left = _prevctx;
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 960;
+						if (!(this.precpred(this._ctx, 19))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 19)");
+						}
+						this.state = 964;
+						this._errHandler.sync(this);
+						switch (this._input.LA(1)) {
+						case TSQLParser.ASTERISK:
+							{
+							this.state = 961;
+							(_localctx as ColumnExprPrecedence1Context)._operator = this.match(TSQLParser.ASTERISK);
+							}
+							break;
+						case TSQLParser.SLASH:
+							{
+							this.state = 962;
+							(_localctx as ColumnExprPrecedence1Context)._operator = this.match(TSQLParser.SLASH);
+							}
+							break;
+						case TSQLParser.PERCENT:
+							{
+							this.state = 963;
+							(_localctx as ColumnExprPrecedence1Context)._operator = this.match(TSQLParser.PERCENT);
+							}
+							break;
+						default:
+							throw new NoViableAltException(this);
+						}
+						this.state = 966;
+						(_localctx as ColumnExprPrecedence1Context)._right = this.columnExpr(20);
+						}
+						break;
+
+					case 2:
+						{
+						_localctx = new ColumnExprPrecedence2Context(new ColumnExprContext(_parentctx, _parentState));
+						(_localctx as ColumnExprPrecedence2Context)._left = _prevctx;
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 967;
+						if (!(this.precpred(this._ctx, 18))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 18)");
+						}
+						this.state = 971;
+						this._errHandler.sync(this);
+						switch (this._input.LA(1)) {
+						case TSQLParser.PLUS:
+							{
+							this.state = 968;
+							(_localctx as ColumnExprPrecedence2Context)._operator = this.match(TSQLParser.PLUS);
+							}
+							break;
+						case TSQLParser.DASH:
+							{
+							this.state = 969;
+							(_localctx as ColumnExprPrecedence2Context)._operator = this.match(TSQLParser.DASH);
+							}
+							break;
+						case TSQLParser.CONCAT:
+							{
+							this.state = 970;
+							(_localctx as ColumnExprPrecedence2Context)._operator = this.match(TSQLParser.CONCAT);
+							}
+							break;
+						default:
+							throw new NoViableAltException(this);
+						}
+						this.state = 973;
+						(_localctx as ColumnExprPrecedence2Context)._right = this.columnExpr(19);
+						}
+						break;
+
+					case 3:
+						{
+						_localctx = new ColumnExprPrecedence3Context(new ColumnExprContext(_parentctx, _parentState));
+						(_localctx as ColumnExprPrecedence3Context)._left = _prevctx;
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 974;
+						if (!(this.precpred(this._ctx, 17))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 17)");
+						}
+						this.state = 999;
+						this._errHandler.sync(this);
+						switch ( this.interpreter.adaptivePredict(this._input, 127, this._ctx) ) {
+						case 1:
+							{
+							this.state = 975;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.EQ_DOUBLE);
+							}
+							break;
+
+						case 2:
+							{
+							this.state = 976;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.EQ_SINGLE);
+							}
+							break;
+
+						case 3:
+							{
+							this.state = 977;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.NOT_EQ);
+							}
+							break;
+
+						case 4:
+							{
+							this.state = 978;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.LT_EQ);
+							}
+							break;
+
+						case 5:
+							{
+							this.state = 979;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.LT);
+							}
+							break;
+
+						case 6:
+							{
+							this.state = 980;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.GT_EQ);
+							}
+							break;
+
+						case 7:
+							{
+							this.state = 981;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.GT);
+							}
+							break;
+
+						case 8:
+							{
+							this.state = 983;
+							this._errHandler.sync(this);
+							_la = this._input.LA(1);
+							if (_la === TSQLParser.NOT) {
+								{
+								this.state = 982;
+								(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.NOT);
+								}
+							}
+
+							this.state = 985;
+							this.match(TSQLParser.IN);
+							this.state = 987;
+							this._errHandler.sync(this);
+							switch ( this.interpreter.adaptivePredict(this._input, 125, this._ctx) ) {
+							case 1:
+								{
+								this.state = 986;
+								this.match(TSQLParser.COHORT);
+								}
+								break;
+							}
+							}
+							break;
+
+						case 9:
+							{
+							this.state = 990;
+							this._errHandler.sync(this);
+							_la = this._input.LA(1);
+							if (_la === TSQLParser.NOT) {
+								{
+								this.state = 989;
+								(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.NOT);
+								}
+							}
+
+							this.state = 992;
+							_la = this._input.LA(1);
+							if (!(_la === TSQLParser.ILIKE || _la === TSQLParser.LIKE)) {
+							this._errHandler.recoverInline(this);
+							} else {
+								if (this._input.LA(1) === Token.EOF) {
+									this.matchedEOF = true;
+								}
+
+								this._errHandler.reportMatch(this);
+								this.consume();
+							}
+							}
+							break;
+
+						case 10:
+							{
+							this.state = 993;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.REGEX_SINGLE);
+							}
+							break;
+
+						case 11:
+							{
+							this.state = 994;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.REGEX_DOUBLE);
+							}
+							break;
+
+						case 12:
+							{
+							this.state = 995;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.NOT_REGEX);
+							}
+							break;
+
+						case 13:
+							{
+							this.state = 996;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.IREGEX_SINGLE);
+							}
+							break;
+
+						case 14:
+							{
+							this.state = 997;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.IREGEX_DOUBLE);
+							}
+							break;
+
+						case 15:
+							{
+							this.state = 998;
+							(_localctx as ColumnExprPrecedence3Context)._operator = this.match(TSQLParser.NOT_IREGEX);
+							}
+							break;
+						}
+						this.state = 1001;
+						(_localctx as ColumnExprPrecedence3Context)._right = this.columnExpr(18);
+						}
+						break;
+
+					case 4:
+						{
+						_localctx = new ColumnExprNullishContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1002;
+						if (!(this.precpred(this._ctx, 15))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 15)");
+						}
+						this.state = 1003;
+						this.match(TSQLParser.NULLISH);
+						this.state = 1004;
+						this.columnExpr(16);
+						}
+						break;
+
+					case 5:
+						{
+						_localctx = new ColumnExprAndContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1005;
+						if (!(this.precpred(this._ctx, 13))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 13)");
+						}
+						this.state = 1006;
+						this.match(TSQLParser.AND);
+						this.state = 1007;
+						this.columnExpr(14);
+						}
+						break;
+
+					case 6:
+						{
+						_localctx = new ColumnExprOrContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1008;
+						if (!(this.precpred(this._ctx, 12))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 12)");
+						}
+						this.state = 1009;
+						this.match(TSQLParser.OR);
+						this.state = 1010;
+						this.columnExpr(13);
+						}
+						break;
+
+					case 7:
+						{
+						_localctx = new ColumnExprBetweenContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1011;
+						if (!(this.precpred(this._ctx, 11))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 11)");
+						}
+						this.state = 1013;
+						this._errHandler.sync(this);
+						_la = this._input.LA(1);
+						if (_la === TSQLParser.NOT) {
+							{
+							this.state = 1012;
+							this.match(TSQLParser.NOT);
+							}
+						}
+
+						this.state = 1015;
+						this.match(TSQLParser.BETWEEN);
+						this.state = 1016;
+						this.columnExpr(0);
+						this.state = 1017;
+						this.match(TSQLParser.AND);
+						this.state = 1018;
+						this.columnExpr(12);
+						}
+						break;
+
+					case 8:
+						{
+						_localctx = new ColumnExprTernaryOpContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1020;
+						if (!(this.precpred(this._ctx, 10))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 10)");
+						}
+						this.state = 1021;
+						this.match(TSQLParser.QUERY);
+						this.state = 1022;
+						this.columnExpr(0);
+						this.state = 1023;
+						this.match(TSQLParser.COLON);
+						this.state = 1024;
+						this.columnExpr(10);
+						}
+						break;
+
+					case 9:
+						{
+						_localctx = new ColumnExprCallSelectContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1026;
+						if (!(this.precpred(this._ctx, 31))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 31)");
+						}
+						this.state = 1027;
+						this.match(TSQLParser.LPAREN);
+						this.state = 1028;
+						this.selectSetStmt();
+						this.state = 1029;
+						this.match(TSQLParser.RPAREN);
+						}
+						break;
+
+					case 10:
+						{
+						_localctx = new ColumnExprCallContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1031;
+						if (!(this.precpred(this._ctx, 30))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 30)");
+						}
+						this.state = 1032;
+						this.match(TSQLParser.LPAREN);
+						this.state = 1034;
+						this._errHandler.sync(this);
+						_la = this._input.LA(1);
+						if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+							{
+							this.state = 1033;
+							this.columnExprList();
+							}
+						}
+
+						this.state = 1036;
+						this.match(TSQLParser.RPAREN);
+						}
+						break;
+
+					case 11:
+						{
+						_localctx = new ColumnExprArrayAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1037;
+						if (!(this.precpred(this._ctx, 26))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 26)");
+						}
+						this.state = 1038;
+						this.match(TSQLParser.LBRACKET);
+						this.state = 1039;
+						this.columnExpr(0);
+						this.state = 1040;
+						this.match(TSQLParser.RBRACKET);
+						}
+						break;
+
+					case 12:
+						{
+						_localctx = new ColumnExprTupleAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1042;
+						if (!(this.precpred(this._ctx, 25))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 25)");
+						}
+						this.state = 1043;
+						this.match(TSQLParser.DOT);
+						this.state = 1044;
+						this.match(TSQLParser.DECIMAL_LITERAL);
+						}
+						break;
+
+					case 13:
+						{
+						_localctx = new ColumnExprPropertyAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1045;
+						if (!(this.precpred(this._ctx, 24))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 24)");
+						}
+						this.state = 1046;
+						this.match(TSQLParser.DOT);
+						this.state = 1047;
+						this.identifier();
+						}
+						break;
+
+					case 14:
+						{
+						_localctx = new ColumnExprNullArrayAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1048;
+						if (!(this.precpred(this._ctx, 23))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 23)");
+						}
+						this.state = 1049;
+						this.match(TSQLParser.NULL_PROPERTY);
+						this.state = 1050;
+						this.match(TSQLParser.LBRACKET);
+						this.state = 1051;
+						this.columnExpr(0);
+						this.state = 1052;
+						this.match(TSQLParser.RBRACKET);
+						}
+						break;
+
+					case 15:
+						{
+						_localctx = new ColumnExprNullTupleAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1054;
+						if (!(this.precpred(this._ctx, 22))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 22)");
+						}
+						this.state = 1055;
+						this.match(TSQLParser.NULL_PROPERTY);
+						this.state = 1056;
+						this.match(TSQLParser.DECIMAL_LITERAL);
+						}
+						break;
+
+					case 16:
+						{
+						_localctx = new ColumnExprNullPropertyAccessContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1057;
+						if (!(this.precpred(this._ctx, 21))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 21)");
+						}
+						this.state = 1058;
+						this.match(TSQLParser.NULL_PROPERTY);
+						this.state = 1059;
+						this.identifier();
+						}
+						break;
+
+					case 17:
+						{
+						_localctx = new ColumnExprIsNullContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1060;
+						if (!(this.precpred(this._ctx, 16))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 16)");
+						}
+						this.state = 1061;
+						this.match(TSQLParser.IS);
+						this.state = 1063;
+						this._errHandler.sync(this);
+						_la = this._input.LA(1);
+						if (_la === TSQLParser.NOT) {
+							{
+							this.state = 1062;
+							this.match(TSQLParser.NOT);
+							}
+						}
+
+						this.state = 1065;
+						this.match(TSQLParser.NULL_SQL);
+						}
+						break;
+
+					case 18:
+						{
+						_localctx = new ColumnExprAliasContext(new ColumnExprContext(_parentctx, _parentState));
+						this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_columnExpr);
+						this.state = 1066;
+						if (!(this.precpred(this._ctx, 9))) {
+							throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
+						}
+						this.state = 1071;
+						this._errHandler.sync(this);
+						switch ( this.interpreter.adaptivePredict(this._input, 131, this._ctx) ) {
+						case 1:
+							{
+							this.state = 1067;
+							this.match(TSQLParser.AS);
+							this.state = 1068;
+							this.identifier();
+							}
+							break;
+
+						case 2:
+							{
+							this.state = 1069;
+							this.match(TSQLParser.AS);
+							this.state = 1070;
+							this.match(TSQLParser.STRING_LITERAL);
+							}
+							break;
+						}
+						}
+						break;
+					}
+					}
+				}
+				this.state = 1077;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 133, this._ctx);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public columnLambdaExpr(): ColumnLambdaExprContext {
+		let _localctx: ColumnLambdaExprContext = new ColumnLambdaExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 124, TSQLParser.RULE_columnLambdaExpr);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1105;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 138, this._ctx) ) {
+			case 1:
+				{
+				this.state = 1078;
+				this.match(TSQLParser.LPAREN);
+				this.state = 1079;
+				this.identifier();
+				this.state = 1084;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 134, this._ctx);
+				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+					if (_alt === 1) {
+						{
+						{
+						this.state = 1080;
+						this.match(TSQLParser.COMMA);
+						this.state = 1081;
+						this.identifier();
+						}
+						}
+					}
+					this.state = 1086;
+					this._errHandler.sync(this);
+					_alt = this.interpreter.adaptivePredict(this._input, 134, this._ctx);
+				}
+				this.state = 1088;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 1087;
+					this.match(TSQLParser.COMMA);
+					}
+				}
+
+				this.state = 1090;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 1092;
+				this.identifier();
+				this.state = 1097;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 136, this._ctx);
+				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+					if (_alt === 1) {
+						{
+						{
+						this.state = 1093;
+						this.match(TSQLParser.COMMA);
+						this.state = 1094;
+						this.identifier();
+						}
+						}
+					}
+					this.state = 1099;
+					this._errHandler.sync(this);
+					_alt = this.interpreter.adaptivePredict(this._input, 136, this._ctx);
+				}
+				this.state = 1101;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				if (_la === TSQLParser.COMMA) {
+					{
+					this.state = 1100;
+					this.match(TSQLParser.COMMA);
+					}
+				}
+
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 1103;
+				this.match(TSQLParser.LPAREN);
+				this.state = 1104;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+			}
+			this.state = 1107;
+			this.match(TSQLParser.ARROW);
+			this.state = 1110;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 139, this._ctx) ) {
+			case 1:
+				{
+				this.state = 1108;
+				this.columnExpr(0);
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 1109;
+				this.block();
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tSQLxChildElement(): TSQLxChildElementContext {
+		let _localctx: TSQLxChildElementContext = new TSQLxChildElementContext(this._ctx, this.state);
+		this.enterRule(_localctx, 126, TSQLParser.RULE_tSQLxChildElement);
+		try {
+			this.state = 1118;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.LT:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1112;
+				this.tSQLxTagElement();
+				}
+				break;
+			case TSQLParser.TSQLX_TEXT_TEXT:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1113;
+				this.match(TSQLParser.TSQLX_TEXT_TEXT);
+				}
+				break;
+			case TSQLParser.LBRACE:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 1114;
+				this.match(TSQLParser.LBRACE);
+				this.state = 1115;
+				this.columnExpr(0);
+				this.state = 1116;
+				this.match(TSQLParser.RBRACE);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tSQLxTagElement(): TSQLxTagElementContext {
+		let _localctx: TSQLxTagElementContext = new TSQLxTagElementContext(this._ctx, this.state);
+		this.enterRule(_localctx, 128, TSQLParser.RULE_tSQLxTagElement);
+		let _la: number;
+		try {
+			this.state = 1149;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 144, this._ctx) ) {
+			case 1:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1120;
+				this.match(TSQLParser.LT);
+				this.state = 1121;
+				this.identifier();
+				this.state = 1125;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)))) !== 0)) {
+					{
+					{
+					this.state = 1122;
+					this.tSQLxTagAttribute();
+					}
+					}
+					this.state = 1127;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+				}
+				this.state = 1128;
+				this.match(TSQLParser.SLASH_GT);
+				}
+				break;
+
+			case 2:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1130;
+				this.match(TSQLParser.LT);
+				this.state = 1131;
+				this.identifier();
+				this.state = 1135;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)))) !== 0)) {
+					{
+					{
+					this.state = 1132;
+					this.tSQLxTagAttribute();
+					}
+					}
+					this.state = 1137;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+				}
+				this.state = 1138;
+				this.match(TSQLParser.GT);
+				this.state = 1142;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+				while (_la === TSQLParser.LBRACE || _la === TSQLParser.LT || _la === TSQLParser.TSQLX_TEXT_TEXT) {
+					{
+					{
+					this.state = 1139;
+					this.tSQLxChildElement();
+					}
+					}
+					this.state = 1144;
+					this._errHandler.sync(this);
+					_la = this._input.LA(1);
+				}
+				this.state = 1145;
+				this.match(TSQLParser.LT_SLASH);
+				this.state = 1146;
+				this.identifier();
+				this.state = 1147;
+				this.match(TSQLParser.GT);
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tSQLxTagAttribute(): TSQLxTagAttributeContext {
+		let _localctx: TSQLxTagAttributeContext = new TSQLxTagAttributeContext(this._ctx, this.state);
+		this.enterRule(_localctx, 130, TSQLParser.RULE_tSQLxTagAttribute);
+		try {
+			this.state = 1162;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 145, this._ctx) ) {
+			case 1:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1151;
+				this.identifier();
+				this.state = 1152;
+				this.match(TSQLParser.EQ_SINGLE);
+				this.state = 1153;
+				this.string();
+				}
+				break;
+
+			case 2:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1155;
+				this.identifier();
+				this.state = 1156;
+				this.match(TSQLParser.EQ_SINGLE);
+				this.state = 1157;
+				this.match(TSQLParser.LBRACE);
+				this.state = 1158;
+				this.columnExpr(0);
+				this.state = 1159;
+				this.match(TSQLParser.RBRACE);
+				}
+				break;
+
+			case 3:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 1161;
+				this.identifier();
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public withExprList(): WithExprListContext {
+		let _localctx: WithExprListContext = new WithExprListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 132, TSQLParser.RULE_withExprList);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1164;
+			this.withExpr();
+			this.state = 1169;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 146, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 1165;
+					this.match(TSQLParser.COMMA);
+					this.state = 1166;
+					this.withExpr();
+					}
+					}
+				}
+				this.state = 1171;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 146, this._ctx);
+			}
+			this.state = 1173;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COMMA) {
+				{
+				this.state = 1172;
+				this.match(TSQLParser.COMMA);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public withExpr(): WithExprContext {
+		let _localctx: WithExprContext = new WithExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 134, TSQLParser.RULE_withExpr);
+		try {
+			this.state = 1185;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 148, this._ctx) ) {
+			case 1:
+				_localctx = new WithExprSubqueryContext(_localctx);
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1175;
+				this.identifier();
+				this.state = 1176;
+				this.match(TSQLParser.AS);
+				this.state = 1177;
+				this.match(TSQLParser.LPAREN);
+				this.state = 1178;
+				this.selectSetStmt();
+				this.state = 1179;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 2:
+				_localctx = new WithExprColumnContext(_localctx);
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1181;
+				this.columnExpr(0);
+				this.state = 1182;
+				this.match(TSQLParser.AS);
+				this.state = 1183;
+				this.identifier();
+				}
+				break;
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public columnIdentifier(): ColumnIdentifierContext {
+		let _localctx: ColumnIdentifierContext = new ColumnIdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 136, TSQLParser.RULE_columnIdentifier);
+		try {
+			this.state = 1194;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.LBRACE:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1187;
+				this.placeholder();
+				}
+				break;
+			case TSQLParser.ALL:
+			case TSQLParser.AND:
+			case TSQLParser.ANTI:
+			case TSQLParser.ANY:
+			case TSQLParser.ARRAY:
+			case TSQLParser.AS:
+			case TSQLParser.ASCENDING:
+			case TSQLParser.ASOF:
+			case TSQLParser.BETWEEN:
+			case TSQLParser.BOTH:
+			case TSQLParser.BY:
+			case TSQLParser.CASE:
+			case TSQLParser.CAST:
+			case TSQLParser.COHORT:
+			case TSQLParser.COLLATE:
+			case TSQLParser.CROSS:
+			case TSQLParser.CUBE:
+			case TSQLParser.CURRENT:
+			case TSQLParser.DATE:
+			case TSQLParser.DAY:
+			case TSQLParser.DESC:
+			case TSQLParser.DESCENDING:
+			case TSQLParser.DISTINCT:
+			case TSQLParser.ELSE:
+			case TSQLParser.END:
+			case TSQLParser.EXTRACT:
+			case TSQLParser.FINAL:
+			case TSQLParser.FIRST:
+			case TSQLParser.FOLLOWING:
+			case TSQLParser.FOR:
+			case TSQLParser.FROM:
+			case TSQLParser.FULL:
+			case TSQLParser.GROUP:
+			case TSQLParser.HAVING:
+			case TSQLParser.HOUR:
+			case TSQLParser.ID:
+			case TSQLParser.IF:
+			case TSQLParser.ILIKE:
+			case TSQLParser.IN:
+			case TSQLParser.INNER:
+			case TSQLParser.INTERVAL:
+			case TSQLParser.IS:
+			case TSQLParser.JOIN:
+			case TSQLParser.KEY:
+			case TSQLParser.LAST:
+			case TSQLParser.LEADING:
+			case TSQLParser.LEFT:
+			case TSQLParser.LIKE:
+			case TSQLParser.LIMIT:
+			case TSQLParser.MINUTE:
+			case TSQLParser.MONTH:
+			case TSQLParser.NOT:
+			case TSQLParser.NULLS:
+			case TSQLParser.OFFSET:
+			case TSQLParser.ON:
+			case TSQLParser.OR:
+			case TSQLParser.ORDER:
+			case TSQLParser.OUTER:
+			case TSQLParser.OVER:
+			case TSQLParser.PARTITION:
+			case TSQLParser.PRECEDING:
+			case TSQLParser.PREWHERE:
+			case TSQLParser.QUARTER:
+			case TSQLParser.RANGE:
+			case TSQLParser.RETURN:
+			case TSQLParser.RIGHT:
+			case TSQLParser.ROLLUP:
+			case TSQLParser.ROW:
+			case TSQLParser.ROWS:
+			case TSQLParser.SAMPLE:
+			case TSQLParser.SECOND:
+			case TSQLParser.SELECT:
+			case TSQLParser.SEMI:
+			case TSQLParser.SETTINGS:
+			case TSQLParser.SUBSTRING:
+			case TSQLParser.THEN:
+			case TSQLParser.TIES:
+			case TSQLParser.TIMESTAMP:
+			case TSQLParser.TO:
+			case TSQLParser.TOP:
+			case TSQLParser.TOTALS:
+			case TSQLParser.TRAILING:
+			case TSQLParser.TRIM:
+			case TSQLParser.TRUNCATE:
+			case TSQLParser.UNBOUNDED:
+			case TSQLParser.UNION:
+			case TSQLParser.USING:
+			case TSQLParser.WEEK:
+			case TSQLParser.WHEN:
+			case TSQLParser.WHERE:
+			case TSQLParser.WINDOW:
+			case TSQLParser.WITH:
+			case TSQLParser.YEAR:
+			case TSQLParser.IDENTIFIER:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				{
+				this.state = 1191;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 149, this._ctx) ) {
+				case 1:
+					{
+					this.state = 1188;
+					this.tableIdentifier();
+					this.state = 1189;
+					this.match(TSQLParser.DOT);
+					}
+					break;
+				}
+				this.state = 1193;
+				this.nestedIdentifier();
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public nestedIdentifier(): NestedIdentifierContext {
+		let _localctx: NestedIdentifierContext = new NestedIdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 138, TSQLParser.RULE_nestedIdentifier);
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1196;
+			this.identifier();
+			this.state = 1201;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 151, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 1197;
+					this.match(TSQLParser.DOT);
+					this.state = 1198;
+					this.identifier();
+					}
+					}
+				}
+				this.state = 1203;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 151, this._ctx);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+
+	public tableExpr(): TableExprContext;
+	public tableExpr(_p: number): TableExprContext;
+	// @RuleVersion(0)
+	public tableExpr(_p?: number): TableExprContext {
+		if (_p === undefined) {
+			_p = 0;
+		}
+
+		let _parentctx: ParserRuleContext = this._ctx;
+		let _parentState: number = this.state;
+		let _localctx: TableExprContext = new TableExprContext(this._ctx, _parentState);
+		let _prevctx: TableExprContext = _localctx;
+		let _startState: number = 140;
+		this.enterRecursionRule(_localctx, 140, TSQLParser.RULE_tableExpr, _p);
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1213;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 152, this._ctx) ) {
+			case 1:
+				{
+				_localctx = new TableExprIdentifierContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+
+				this.state = 1205;
+				this.tableIdentifier();
+				}
+				break;
+
+			case 2:
+				{
+				_localctx = new TableExprFunctionContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 1206;
+				this.tableFunctionExpr();
+				}
+				break;
+
+			case 3:
+				{
+				_localctx = new TableExprSubqueryContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 1207;
+				this.match(TSQLParser.LPAREN);
+				this.state = 1208;
+				this.selectSetStmt();
+				this.state = 1209;
+				this.match(TSQLParser.RPAREN);
+				}
+				break;
+
+			case 4:
+				{
+				_localctx = new TableExprTagContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 1211;
+				this.tSQLxTagElement();
+				}
+				break;
+
+			case 5:
+				{
+				_localctx = new TableExprPlaceholderContext(_localctx);
+				this._ctx = _localctx;
+				_prevctx = _localctx;
+				this.state = 1212;
+				this.placeholder();
+				}
+				break;
+			}
+			this._ctx._stop = this._input.tryLT(-1);
+			this.state = 1223;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 154, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					if (this._parseListeners != null) {
+						this.triggerExitRuleEvent();
+					}
+					_prevctx = _localctx;
+					{
+					{
+					_localctx = new TableExprAliasContext(new TableExprContext(_parentctx, _parentState));
+					this.pushNewRecursionContext(_localctx, _startState, TSQLParser.RULE_tableExpr);
+					this.state = 1215;
+					if (!(this.precpred(this._ctx, 3))) {
+						throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
+					}
+					this.state = 1219;
+					this._errHandler.sync(this);
+					switch (this._input.LA(1)) {
+					case TSQLParser.DATE:
+					case TSQLParser.FIRST:
+					case TSQLParser.ID:
+					case TSQLParser.KEY:
+					case TSQLParser.IDENTIFIER:
+						{
+						this.state = 1216;
+						this.alias();
+						}
+						break;
+					case TSQLParser.AS:
+						{
+						this.state = 1217;
+						this.match(TSQLParser.AS);
+						this.state = 1218;
+						this.identifier();
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					}
+					}
+				}
+				this.state = 1225;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 154, this._ctx);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tableFunctionExpr(): TableFunctionExprContext {
+		let _localctx: TableFunctionExprContext = new TableFunctionExprContext(this._ctx, this.state);
+		this.enterRule(_localctx, 142, TSQLParser.RULE_tableFunctionExpr);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1226;
+			this.identifier();
+			this.state = 1227;
+			this.match(TSQLParser.LPAREN);
+			this.state = 1229;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DAY) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.HOUR - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INF - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.MINUTE - 33)) | (1 << (TSQLParser.MONTH - 33)) | (1 << (TSQLParser.NAN_SQL - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULL_SQL - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.QUARTER - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SECOND - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WEEK - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)) | (1 << (TSQLParser.YEAR - 97)) | (1 << (TSQLParser.IDENTIFIER - 97)) | (1 << (TSQLParser.FLOATING_LITERAL - 97)) | (1 << (TSQLParser.OCTAL_LITERAL - 97)) | (1 << (TSQLParser.DECIMAL_LITERAL - 97)) | (1 << (TSQLParser.HEXADECIMAL_LITERAL - 97)) | (1 << (TSQLParser.STRING_LITERAL - 97)) | (1 << (TSQLParser.ASTERISK - 97)) | (1 << (TSQLParser.DASH - 97)) | (1 << (TSQLParser.DOT - 97)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (TSQLParser.LBRACE - 131)) | (1 << (TSQLParser.LBRACKET - 131)) | (1 << (TSQLParser.LPAREN - 131)) | (1 << (TSQLParser.LT - 131)) | (1 << (TSQLParser.PLUS - 131)) | (1 << (TSQLParser.QUOTE_SINGLE_TEMPLATE - 131)))) !== 0)) {
+				{
+				this.state = 1228;
+				this.tableArgList();
+				}
+			}
+
+			this.state = 1231;
+			this.match(TSQLParser.RPAREN);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tableIdentifier(): TableIdentifierContext {
+		let _localctx: TableIdentifierContext = new TableIdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 144, TSQLParser.RULE_tableIdentifier);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1236;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 156, this._ctx) ) {
+			case 1:
+				{
+				this.state = 1233;
+				this.databaseIdentifier();
+				this.state = 1234;
+				this.match(TSQLParser.DOT);
+				}
+				break;
+			}
+			this.state = 1238;
+			this.nestedIdentifier();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public tableArgList(): TableArgListContext {
+		let _localctx: TableArgListContext = new TableArgListContext(this._ctx, this.state);
+		this.enterRule(_localctx, 146, TSQLParser.RULE_tableArgList);
+		let _la: number;
+		try {
+			let _alt: number;
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1240;
+			this.columnExpr(0);
+			this.state = 1245;
+			this._errHandler.sync(this);
+			_alt = this.interpreter.adaptivePredict(this._input, 157, this._ctx);
+			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+				if (_alt === 1) {
+					{
+					{
+					this.state = 1241;
+					this.match(TSQLParser.COMMA);
+					this.state = 1242;
+					this.columnExpr(0);
+					}
+					}
+				}
+				this.state = 1247;
+				this._errHandler.sync(this);
+				_alt = this.interpreter.adaptivePredict(this._input, 157, this._ctx);
+			}
+			this.state = 1249;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.COMMA) {
+				{
+				this.state = 1248;
+				this.match(TSQLParser.COMMA);
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public databaseIdentifier(): DatabaseIdentifierContext {
+		let _localctx: DatabaseIdentifierContext = new DatabaseIdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 148, TSQLParser.RULE_databaseIdentifier);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1251;
+			this.identifier();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public floatingLiteral(): FloatingLiteralContext {
+		let _localctx: FloatingLiteralContext = new FloatingLiteralContext(this._ctx, this.state);
+		this.enterRule(_localctx, 150, TSQLParser.RULE_floatingLiteral);
+		let _la: number;
+		try {
+			this.state = 1261;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.FLOATING_LITERAL:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1253;
+				this.match(TSQLParser.FLOATING_LITERAL);
+				}
+				break;
+			case TSQLParser.DOT:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1254;
+				this.match(TSQLParser.DOT);
+				this.state = 1255;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.OCTAL_LITERAL || _la === TSQLParser.DECIMAL_LITERAL)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+				break;
+			case TSQLParser.DECIMAL_LITERAL:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 1256;
+				this.match(TSQLParser.DECIMAL_LITERAL);
+				this.state = 1257;
+				this.match(TSQLParser.DOT);
+				this.state = 1259;
+				this._errHandler.sync(this);
+				switch ( this.interpreter.adaptivePredict(this._input, 159, this._ctx) ) {
+				case 1:
+					{
+					this.state = 1258;
+					_la = this._input.LA(1);
+					if (!(_la === TSQLParser.OCTAL_LITERAL || _la === TSQLParser.DECIMAL_LITERAL)) {
+					this._errHandler.recoverInline(this);
+					} else {
+						if (this._input.LA(1) === Token.EOF) {
+							this.matchedEOF = true;
+						}
+
+						this._errHandler.reportMatch(this);
+						this.consume();
+					}
+					}
+					break;
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public numberLiteral(): NumberLiteralContext {
+		let _localctx: NumberLiteralContext = new NumberLiteralContext(this._ctx, this.state);
+		this.enterRule(_localctx, 152, TSQLParser.RULE_numberLiteral);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1264;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la === TSQLParser.DASH || _la === TSQLParser.PLUS) {
+				{
+				this.state = 1263;
+				_la = this._input.LA(1);
+				if (!(_la === TSQLParser.DASH || _la === TSQLParser.PLUS)) {
+				this._errHandler.recoverInline(this);
+				} else {
+					if (this._input.LA(1) === Token.EOF) {
+						this.matchedEOF = true;
+					}
+
+					this._errHandler.reportMatch(this);
+					this.consume();
+				}
+				}
+			}
+
+			this.state = 1272;
+			this._errHandler.sync(this);
+			switch ( this.interpreter.adaptivePredict(this._input, 162, this._ctx) ) {
+			case 1:
+				{
+				this.state = 1266;
+				this.floatingLiteral();
+				}
+				break;
+
+			case 2:
+				{
+				this.state = 1267;
+				this.match(TSQLParser.OCTAL_LITERAL);
+				}
+				break;
+
+			case 3:
+				{
+				this.state = 1268;
+				this.match(TSQLParser.DECIMAL_LITERAL);
+				}
+				break;
+
+			case 4:
+				{
+				this.state = 1269;
+				this.match(TSQLParser.HEXADECIMAL_LITERAL);
+				}
+				break;
+
+			case 5:
+				{
+				this.state = 1270;
+				this.match(TSQLParser.INF);
+				}
+				break;
+
+			case 6:
+				{
+				this.state = 1271;
+				this.match(TSQLParser.NAN_SQL);
+				}
+				break;
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public literal(): LiteralContext {
+		let _localctx: LiteralContext = new LiteralContext(this._ctx, this.state);
+		this.enterRule(_localctx, 154, TSQLParser.RULE_literal);
+		try {
+			this.state = 1277;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.INF:
+			case TSQLParser.NAN_SQL:
+			case TSQLParser.FLOATING_LITERAL:
+			case TSQLParser.OCTAL_LITERAL:
+			case TSQLParser.DECIMAL_LITERAL:
+			case TSQLParser.HEXADECIMAL_LITERAL:
+			case TSQLParser.DASH:
+			case TSQLParser.DOT:
+			case TSQLParser.PLUS:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1274;
+				this.numberLiteral();
+				}
+				break;
+			case TSQLParser.STRING_LITERAL:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1275;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+				break;
+			case TSQLParser.NULL_SQL:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 1276;
+				this.match(TSQLParser.NULL_SQL);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public interval(): IntervalContext {
+		let _localctx: IntervalContext = new IntervalContext(this._ctx, this.state);
+		this.enterRule(_localctx, 156, TSQLParser.RULE_interval);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1279;
+			_la = this._input.LA(1);
+			if (!(_la === TSQLParser.DAY || _la === TSQLParser.HOUR || ((((_la - 58)) & ~0x1F) === 0 && ((1 << (_la - 58)) & ((1 << (TSQLParser.MINUTE - 58)) | (1 << (TSQLParser.MONTH - 58)) | (1 << (TSQLParser.QUARTER - 58)) | (1 << (TSQLParser.SECOND - 58)))) !== 0) || _la === TSQLParser.WEEK || _la === TSQLParser.YEAR)) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public keyword(): KeywordContext {
+		let _localctx: KeywordContext = new KeywordContext(this._ctx, this.state);
+		this.enterRule(_localctx, 158, TSQLParser.RULE_keyword);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1281;
+			_la = this._input.LA(1);
+			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << TSQLParser.ALL) | (1 << TSQLParser.AND) | (1 << TSQLParser.ANTI) | (1 << TSQLParser.ANY) | (1 << TSQLParser.ARRAY) | (1 << TSQLParser.AS) | (1 << TSQLParser.ASCENDING) | (1 << TSQLParser.ASOF) | (1 << TSQLParser.BETWEEN) | (1 << TSQLParser.BOTH) | (1 << TSQLParser.BY) | (1 << TSQLParser.CASE) | (1 << TSQLParser.CAST) | (1 << TSQLParser.COHORT) | (1 << TSQLParser.COLLATE) | (1 << TSQLParser.CROSS) | (1 << TSQLParser.CUBE) | (1 << TSQLParser.CURRENT) | (1 << TSQLParser.DATE) | (1 << TSQLParser.DESC) | (1 << TSQLParser.DESCENDING) | (1 << TSQLParser.DISTINCT) | (1 << TSQLParser.ELSE) | (1 << TSQLParser.END) | (1 << TSQLParser.EXTRACT) | (1 << TSQLParser.FINAL) | (1 << TSQLParser.FIRST))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (TSQLParser.FOLLOWING - 33)) | (1 << (TSQLParser.FOR - 33)) | (1 << (TSQLParser.FROM - 33)) | (1 << (TSQLParser.FULL - 33)) | (1 << (TSQLParser.GROUP - 33)) | (1 << (TSQLParser.HAVING - 33)) | (1 << (TSQLParser.ID - 33)) | (1 << (TSQLParser.IF - 33)) | (1 << (TSQLParser.ILIKE - 33)) | (1 << (TSQLParser.IN - 33)) | (1 << (TSQLParser.INNER - 33)) | (1 << (TSQLParser.INTERVAL - 33)) | (1 << (TSQLParser.IS - 33)) | (1 << (TSQLParser.JOIN - 33)) | (1 << (TSQLParser.KEY - 33)) | (1 << (TSQLParser.LAST - 33)) | (1 << (TSQLParser.LEADING - 33)) | (1 << (TSQLParser.LEFT - 33)) | (1 << (TSQLParser.LIKE - 33)) | (1 << (TSQLParser.LIMIT - 33)) | (1 << (TSQLParser.NOT - 33)) | (1 << (TSQLParser.NULLS - 33)) | (1 << (TSQLParser.OFFSET - 33)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (TSQLParser.ON - 65)) | (1 << (TSQLParser.OR - 65)) | (1 << (TSQLParser.ORDER - 65)) | (1 << (TSQLParser.OUTER - 65)) | (1 << (TSQLParser.OVER - 65)) | (1 << (TSQLParser.PARTITION - 65)) | (1 << (TSQLParser.PRECEDING - 65)) | (1 << (TSQLParser.PREWHERE - 65)) | (1 << (TSQLParser.RANGE - 65)) | (1 << (TSQLParser.RETURN - 65)) | (1 << (TSQLParser.RIGHT - 65)) | (1 << (TSQLParser.ROLLUP - 65)) | (1 << (TSQLParser.ROW - 65)) | (1 << (TSQLParser.ROWS - 65)) | (1 << (TSQLParser.SAMPLE - 65)) | (1 << (TSQLParser.SELECT - 65)) | (1 << (TSQLParser.SEMI - 65)) | (1 << (TSQLParser.SETTINGS - 65)) | (1 << (TSQLParser.SUBSTRING - 65)) | (1 << (TSQLParser.THEN - 65)) | (1 << (TSQLParser.TIES - 65)) | (1 << (TSQLParser.TIMESTAMP - 65)) | (1 << (TSQLParser.TO - 65)) | (1 << (TSQLParser.TOP - 65)) | (1 << (TSQLParser.TOTALS - 65)) | (1 << (TSQLParser.TRAILING - 65)) | (1 << (TSQLParser.TRIM - 65)) | (1 << (TSQLParser.TRUNCATE - 65)))) !== 0) || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & ((1 << (TSQLParser.UNBOUNDED - 97)) | (1 << (TSQLParser.UNION - 97)) | (1 << (TSQLParser.USING - 97)) | (1 << (TSQLParser.WHEN - 97)) | (1 << (TSQLParser.WHERE - 97)) | (1 << (TSQLParser.WINDOW - 97)) | (1 << (TSQLParser.WITH - 97)))) !== 0))) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public keywordForAlias(): KeywordForAliasContext {
+		let _localctx: KeywordForAliasContext = new KeywordForAliasContext(this._ctx, this.state);
+		this.enterRule(_localctx, 160, TSQLParser.RULE_keywordForAlias);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1283;
+			_la = this._input.LA(1);
+			if (!(((((_la - 20)) & ~0x1F) === 0 && ((1 << (_la - 20)) & ((1 << (TSQLParser.DATE - 20)) | (1 << (TSQLParser.FIRST - 20)) | (1 << (TSQLParser.ID - 20)) | (1 << (TSQLParser.KEY - 20)))) !== 0))) {
+			this._errHandler.recoverInline(this);
+			} else {
+				if (this._input.LA(1) === Token.EOF) {
+					this.matchedEOF = true;
+				}
+
+				this._errHandler.reportMatch(this);
+				this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public alias(): AliasContext {
+		let _localctx: AliasContext = new AliasContext(this._ctx, this.state);
+		this.enterRule(_localctx, 162, TSQLParser.RULE_alias);
+		try {
+			this.state = 1287;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.IDENTIFIER:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1285;
+				this.match(TSQLParser.IDENTIFIER);
+				}
+				break;
+			case TSQLParser.DATE:
+			case TSQLParser.FIRST:
+			case TSQLParser.ID:
+			case TSQLParser.KEY:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1286;
+				this.keywordForAlias();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public identifier(): IdentifierContext {
+		let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state);
+		this.enterRule(_localctx, 164, TSQLParser.RULE_identifier);
+		try {
+			this.state = 1292;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.IDENTIFIER:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1289;
+				this.match(TSQLParser.IDENTIFIER);
+				}
+				break;
+			case TSQLParser.DAY:
+			case TSQLParser.HOUR:
+			case TSQLParser.MINUTE:
+			case TSQLParser.MONTH:
+			case TSQLParser.QUARTER:
+			case TSQLParser.SECOND:
+			case TSQLParser.WEEK:
+			case TSQLParser.YEAR:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1290;
+				this.interval();
+				}
+				break;
+			case TSQLParser.ALL:
+			case TSQLParser.AND:
+			case TSQLParser.ANTI:
+			case TSQLParser.ANY:
+			case TSQLParser.ARRAY:
+			case TSQLParser.AS:
+			case TSQLParser.ASCENDING:
+			case TSQLParser.ASOF:
+			case TSQLParser.BETWEEN:
+			case TSQLParser.BOTH:
+			case TSQLParser.BY:
+			case TSQLParser.CASE:
+			case TSQLParser.CAST:
+			case TSQLParser.COHORT:
+			case TSQLParser.COLLATE:
+			case TSQLParser.CROSS:
+			case TSQLParser.CUBE:
+			case TSQLParser.CURRENT:
+			case TSQLParser.DATE:
+			case TSQLParser.DESC:
+			case TSQLParser.DESCENDING:
+			case TSQLParser.DISTINCT:
+			case TSQLParser.ELSE:
+			case TSQLParser.END:
+			case TSQLParser.EXTRACT:
+			case TSQLParser.FINAL:
+			case TSQLParser.FIRST:
+			case TSQLParser.FOLLOWING:
+			case TSQLParser.FOR:
+			case TSQLParser.FROM:
+			case TSQLParser.FULL:
+			case TSQLParser.GROUP:
+			case TSQLParser.HAVING:
+			case TSQLParser.ID:
+			case TSQLParser.IF:
+			case TSQLParser.ILIKE:
+			case TSQLParser.IN:
+			case TSQLParser.INNER:
+			case TSQLParser.INTERVAL:
+			case TSQLParser.IS:
+			case TSQLParser.JOIN:
+			case TSQLParser.KEY:
+			case TSQLParser.LAST:
+			case TSQLParser.LEADING:
+			case TSQLParser.LEFT:
+			case TSQLParser.LIKE:
+			case TSQLParser.LIMIT:
+			case TSQLParser.NOT:
+			case TSQLParser.NULLS:
+			case TSQLParser.OFFSET:
+			case TSQLParser.ON:
+			case TSQLParser.OR:
+			case TSQLParser.ORDER:
+			case TSQLParser.OUTER:
+			case TSQLParser.OVER:
+			case TSQLParser.PARTITION:
+			case TSQLParser.PRECEDING:
+			case TSQLParser.PREWHERE:
+			case TSQLParser.RANGE:
+			case TSQLParser.RETURN:
+			case TSQLParser.RIGHT:
+			case TSQLParser.ROLLUP:
+			case TSQLParser.ROW:
+			case TSQLParser.ROWS:
+			case TSQLParser.SAMPLE:
+			case TSQLParser.SELECT:
+			case TSQLParser.SEMI:
+			case TSQLParser.SETTINGS:
+			case TSQLParser.SUBSTRING:
+			case TSQLParser.THEN:
+			case TSQLParser.TIES:
+			case TSQLParser.TIMESTAMP:
+			case TSQLParser.TO:
+			case TSQLParser.TOP:
+			case TSQLParser.TOTALS:
+			case TSQLParser.TRAILING:
+			case TSQLParser.TRIM:
+			case TSQLParser.TRUNCATE:
+			case TSQLParser.UNBOUNDED:
+			case TSQLParser.UNION:
+			case TSQLParser.USING:
+			case TSQLParser.WHEN:
+			case TSQLParser.WHERE:
+			case TSQLParser.WINDOW:
+			case TSQLParser.WITH:
+				this.enterOuterAlt(_localctx, 3);
+				{
+				this.state = 1291;
+				this.keyword();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public enumValue(): EnumValueContext {
+		let _localctx: EnumValueContext = new EnumValueContext(this._ctx, this.state);
+		this.enterRule(_localctx, 166, TSQLParser.RULE_enumValue);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1294;
+			this.string();
+			this.state = 1295;
+			this.match(TSQLParser.EQ_SINGLE);
+			this.state = 1296;
+			this.numberLiteral();
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public placeholder(): PlaceholderContext {
+		let _localctx: PlaceholderContext = new PlaceholderContext(this._ctx, this.state);
+		this.enterRule(_localctx, 168, TSQLParser.RULE_placeholder);
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1298;
+			this.match(TSQLParser.LBRACE);
+			this.state = 1299;
+			this.columnExpr(0);
+			this.state = 1300;
+			this.match(TSQLParser.RBRACE);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public string(): StringContext {
+		let _localctx: StringContext = new StringContext(this._ctx, this.state);
+		this.enterRule(_localctx, 170, TSQLParser.RULE_string);
+		try {
+			this.state = 1304;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.STRING_LITERAL:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1302;
+				this.match(TSQLParser.STRING_LITERAL);
+				}
+				break;
+			case TSQLParser.QUOTE_SINGLE_TEMPLATE:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1303;
+				this.templateString();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public templateString(): TemplateStringContext {
+		let _localctx: TemplateStringContext = new TemplateStringContext(this._ctx, this.state);
+		this.enterRule(_localctx, 172, TSQLParser.RULE_templateString);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1306;
+			this.match(TSQLParser.QUOTE_SINGLE_TEMPLATE);
+			this.state = 1310;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.STRING_TEXT || _la === TSQLParser.STRING_ESCAPE_TRIGGER) {
+				{
+				{
+				this.state = 1307;
+				this.stringContents();
+				}
+				}
+				this.state = 1312;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 1313;
+			this.match(TSQLParser.QUOTE_SINGLE);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public stringContents(): StringContentsContext {
+		let _localctx: StringContentsContext = new StringContentsContext(this._ctx, this.state);
+		this.enterRule(_localctx, 174, TSQLParser.RULE_stringContents);
+		try {
+			this.state = 1320;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.STRING_ESCAPE_TRIGGER:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1315;
+				this.match(TSQLParser.STRING_ESCAPE_TRIGGER);
+				this.state = 1316;
+				this.columnExpr(0);
+				this.state = 1317;
+				this.match(TSQLParser.RBRACE);
+				}
+				break;
+			case TSQLParser.STRING_TEXT:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1319;
+				this.match(TSQLParser.STRING_TEXT);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public fullTemplateString(): FullTemplateStringContext {
+		let _localctx: FullTemplateStringContext = new FullTemplateStringContext(this._ctx, this.state);
+		this.enterRule(_localctx, 176, TSQLParser.RULE_fullTemplateString);
+		let _la: number;
+		try {
+			this.enterOuterAlt(_localctx, 1);
+			{
+			this.state = 1322;
+			this.match(TSQLParser.QUOTE_SINGLE_TEMPLATE_FULL);
+			this.state = 1326;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la === TSQLParser.FULL_STRING_TEXT || _la === TSQLParser.FULL_STRING_ESCAPE_TRIGGER) {
+				{
+				{
+				this.state = 1323;
+				this.stringContentsFull();
+				}
+				}
+				this.state = 1328;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			this.state = 1329;
+			this.match(TSQLParser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+	// @RuleVersion(0)
+	public stringContentsFull(): StringContentsFullContext {
+		let _localctx: StringContentsFullContext = new StringContentsFullContext(this._ctx, this.state);
+		this.enterRule(_localctx, 178, TSQLParser.RULE_stringContentsFull);
+		try {
+			this.state = 1336;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case TSQLParser.FULL_STRING_ESCAPE_TRIGGER:
+				this.enterOuterAlt(_localctx, 1);
+				{
+				this.state = 1331;
+				this.match(TSQLParser.FULL_STRING_ESCAPE_TRIGGER);
+				this.state = 1332;
+				this.columnExpr(0);
+				this.state = 1333;
+				this.match(TSQLParser.RBRACE);
+				}
+				break;
+			case TSQLParser.FULL_STRING_TEXT:
+				this.enterOuterAlt(_localctx, 2);
+				{
+				this.state = 1335;
+				this.match(TSQLParser.FULL_STRING_TEXT);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				_localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return _localctx;
+	}
+
+	public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
+		switch (ruleIndex) {
+		case 41:
+			return this.joinExpr_sempred(_localctx as JoinExprContext, predIndex);
+
+		case 61:
+			return this.columnExpr_sempred(_localctx as ColumnExprContext, predIndex);
+
+		case 70:
+			return this.tableExpr_sempred(_localctx as TableExprContext, predIndex);
+		}
+		return true;
+	}
+	private joinExpr_sempred(_localctx: JoinExprContext, predIndex: number): boolean {
+		switch (predIndex) {
+		case 0:
+			return this.precpred(this._ctx, 3);
+
+		case 1:
+			return this.precpred(this._ctx, 4);
+		}
+		return true;
+	}
+	private columnExpr_sempred(_localctx: ColumnExprContext, predIndex: number): boolean {
+		switch (predIndex) {
+		case 2:
+			return this.precpred(this._ctx, 19);
+
+		case 3:
+			return this.precpred(this._ctx, 18);
+
+		case 4:
+			return this.precpred(this._ctx, 17);
+
+		case 5:
+			return this.precpred(this._ctx, 15);
+
+		case 6:
+			return this.precpred(this._ctx, 13);
+
+		case 7:
+			return this.precpred(this._ctx, 12);
+
+		case 8:
+			return this.precpred(this._ctx, 11);
+
+		case 9:
+			return this.precpred(this._ctx, 10);
+
+		case 10:
+			return this.precpred(this._ctx, 31);
+
+		case 11:
+			return this.precpred(this._ctx, 30);
+
+		case 12:
+			return this.precpred(this._ctx, 26);
+
+		case 13:
+			return this.precpred(this._ctx, 25);
+
+		case 14:
+			return this.precpred(this._ctx, 24);
+
+		case 15:
+			return this.precpred(this._ctx, 23);
+
+		case 16:
+			return this.precpred(this._ctx, 22);
+
+		case 17:
+			return this.precpred(this._ctx, 21);
+
+		case 18:
+			return this.precpred(this._ctx, 16);
+
+		case 19:
+			return this.precpred(this._ctx, 9);
+		}
+		return true;
+	}
+	private tableExpr_sempred(_localctx: TableExprContext, predIndex: number): boolean {
+		switch (predIndex) {
+		case 20:
+			return this.precpred(this._ctx, 3);
+		}
+		return true;
+	}
+
+	private static readonly _serializedATNSegments: number = 3;
+	private static readonly _serializedATNSegment0: string =
+		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\xAA\u053D\x04" +
+		"\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
+		"\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" +
+		"\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
+		"\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
+		"\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C" +
+		"\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04" +
+		"#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t*\x04+\t" +
+		"+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x043\t3\x04" +
+		"4\t4\x045\t5\x046\t6\x047\t7\x048\t8\x049\t9\x04:\t:\x04;\t;\x04<\t<\x04" +
+		"=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04E\tE\x04" +
+		"F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04M\tM\x04N\tN\x04" +
+		"O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04T\tT\x04U\tU\x04V\tV\x04W\tW\x04" +
+		"X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x03\x02\x07\x02\xB8\n\x02\f\x02\x0E\x02\xBB" +
+		"\v\x02\x03\x02\x03\x02\x03\x03\x03\x03\x05\x03\xC1\n\x03\x03\x04\x03\x04" +
+		"\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x05\x05\xCA\n\x05\x03\x06\x03" +
+		"\x06\x03\x06\x07\x06\xCF\n\x06\f\x06\x0E\x06\xD2\v\x06\x03\x06\x05\x06" +
+		"\xD5\n\x06\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03" +
+		"\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05\x07\xE3\n\x07\x03\b\x03\b\x05" +
+		"\b\xE7\n\b\x03\b\x05\b\xEA\n\b\x03\t\x03\t\x05\t\xEE\n\t\x03\t\x05\t\xF1" +
+		"\n\t\x03\n\x03\n\x03\n\x03\n\x03\n\x05\n\xF8\n\n\x03\n\x03\n\x05\n\xFC" +
+		"\n\n\x03\n\x03\n\x03\v\x03\v\x03\v\x07\v\u0103\n\v\f\v\x0E\v\u0106\v\v" +
+		"\x03\v\x03\v\x05\v\u010A\n\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f" +
+		"\x05\f\u0113\n\f\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x05\r\u011B\n\r\x03" +
+		"\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\u0122\n\x0E\x03\x0E\x03\x0E" +
+		"\x05\x0E\u0126\n\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\u012C\n\x0E" +
+		"\x03\x0E\x03\x0E\x03\x0E\x05\x0E\u0131\n\x0E\x03\x0F\x03\x0F\x03\x0F\x03" +
+		"\x0F\x03\x0F\x03\x0F\x05\x0F\u0139\n\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F" +
+		"\x03\x0F\x05\x0F\u0140\n\x0F\x03\x10\x03\x10\x03\x10\x03\x10\x05\x10\u0146" +
+		"\n\x10\x03\x10\x03\x10\x03\x10\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11" +
+		"\x03\x12\x03\x12\x05\x12\u0152\n\x12\x03\x13\x03\x13\x03\x14\x03\x14\x07" +
+		"\x14\u0158\n\x14\f\x14\x0E\x14\u015B\v\x14\x03\x14\x03\x14\x03\x15\x03" +
+		"\x15\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x07\x16\u0166\n\x16\f\x16" +
+		"\x0E\x16\u0169\v\x16\x03\x16\x05\x16\u016C\n\x16\x03\x17\x03\x17\x03\x17" +
+		"\x05\x17\u0171\n\x17\x03\x17\x05\x17\u0174\n\x17\x03\x17\x03\x17\x03\x18" +
+		"\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18\x05\x18\u017E\n\x18\x03\x19\x03" +
+		"\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x05\x19\u0188\n\x19" +
+		"\x03\x19\x03\x19\x03\x1A\x03\x1A\x07\x1A\u018E\n\x1A\f\x1A\x0E\x1A\u0191" +
+		"\v\x1A\x03\x1B\x05\x1B\u0194\n\x1B\x03\x1B\x03\x1B\x05\x1B\u0198\n\x1B" +
+		"\x03\x1B\x05\x1B\u019B\n\x1B\x03\x1B\x03\x1B\x05\x1B\u019F\n\x1B\x03\x1B" +
+		"\x05\x1B\u01A2\n\x1B\x03\x1B\x05\x1B\u01A5\n\x1B\x03\x1B\x05\x1B\u01A8" +
+		"\n\x1B\x03\x1B\x05\x1B\u01AB\n\x1B\x03\x1B\x03\x1B\x05\x1B\u01AF\n\x1B" +
+		"\x03\x1B\x03\x1B\x05\x1B\u01B3\n\x1B\x03\x1B\x05\x1B\u01B6\n\x1B\x03\x1B" +
+		"\x05\x1B\u01B9\n\x1B\x03\x1B\x05\x1B\u01BC\n\x1B\x03\x1B\x05\x1B\u01BF" +
+		"\n\x1B\x03\x1B\x03\x1B\x05\x1B\u01C3\n\x1B\x03\x1B\x05\x1B\u01C6\n\x1B" +
+		"\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D\u01CF" +
+		"\n\x1D\x03\x1E\x03\x1E\x03\x1E\x03\x1F\x05\x1F\u01D5\n\x1F\x03\x1F\x03" +
+		"\x1F\x03\x1F\x03\x1F\x03 \x03 \x03 \x03 \x03 \x03 \x03 \x03 \x03 \x03" +
+		" \x03 \x03 \x03 \x07 \u01E8\n \f \x0E \u01EB\v \x03!\x03!\x03!\x03\"\x03" +
+		"\"\x03\"\x03#\x03#\x03#\x03#\x03#\x03#\x03#\x03#\x05#\u01FB\n#\x03$\x03" +
+		"$\x03$\x03%\x03%\x03%\x03%\x03&\x03&\x03&\x03&\x03\'\x03\'\x03\'\x03\'" +
+		"\x03\'\x03(\x03(\x03(\x03(\x05(\u0211\n(\x03(\x03(\x05(\u0215\n(\x03(" +
+		"\x03(\x03(\x03(\x05(\u021B\n(\x03(\x03(\x03(\x05(\u0220\n(\x03)\x03)\x03" +
+		")\x03*\x03*\x03*\x03+\x03+\x03+\x05+\u022B\n+\x03+\x05+\u022E\n+\x03+" +
+		"\x03+\x03+\x03+\x05+\u0234\n+\x03+\x03+\x03+\x03+\x03+\x03+\x05+\u023C" +
+		"\n+\x03+\x03+\x03+\x03+\x07+\u0242\n+\f+\x0E+\u0245\v+\x03,\x05,\u0248" +
+		"\n,\x03,\x03,\x03,\x05,\u024D\n,\x03,\x05,\u0250\n,\x03,\x05,\u0253\n" +
+		",\x03,\x03,\x05,\u0257\n,\x03,\x03,\x05,\u025B\n,\x03,\x05,\u025E\n,\x05" +
+		",\u0260\n,\x03,\x05,\u0263\n,\x03,\x03,\x05,\u0267\n,\x03,\x03,\x05,\u026B" +
+		"\n,\x03,\x05,\u026E\n,\x05,\u0270\n,\x05,\u0272\n,\x03-\x03-\x03-\x05" +
+		"-\u0277\n-\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x05.\u0282\n." +
+		"\x03/\x03/\x03/\x03/\x05/\u0288\n/\x030\x030\x030\x050\u028D\n0\x031\x03" +
+		"1\x031\x071\u0292\n1\f1\x0E1\u0295\v1\x032\x032\x052\u0299\n2\x032\x03" +
+		"2\x052\u029D\n2\x032\x032\x052\u02A1\n2\x033\x033\x033\x033\x053\u02A7" +
+		"\n3\x053\u02A9\n3\x034\x034\x034\x074\u02AE\n4\f4\x0E4\u02B1\v4\x035\x03" +
+		"5\x035\x035\x036\x056\u02B8\n6\x036\x056\u02BB\n6\x036\x056\u02BE\n6\x03" +
+		"7\x037\x037\x037\x038\x038\x038\x038\x039\x039\x039\x03:\x03:\x03:\x03" +
+		":\x03:\x03:\x05:\u02D1\n:\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03" +
+		";\x03;\x03;\x03;\x05;\u02DF\n;\x03<\x03<\x03<\x03=\x03=\x03=\x03=\x03" +
+		"=\x03=\x03=\x03=\x03=\x07=\u02ED\n=\f=\x0E=\u02F0\v=\x03=\x05=\u02F3\n" +
+		"=\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x07=\u02FC\n=\f=\x0E=\u02FF\v=\x03" +
+		"=\x05=\u0302\n=\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x07=\u030B\n=\f=\x0E" +
+		"=\u030E\v=\x03=\x05=\u0311\n=\x03=\x03=\x03=\x03=\x03=\x05=\u0318\n=\x03" +
+		"=\x03=\x05=\u031C\n=\x03>\x03>\x03>\x07>\u0321\n>\f>\x0E>\u0324\v>\x03" +
+		">\x05>\u0327\n>\x03?\x03?\x03?\x05?\u032C\n?\x03?\x03?\x03?\x03?\x03?" +
+		"\x06?\u0333\n?\r?\x0E?\u0334\x03?\x03?\x05?\u0339\n?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u0353\n?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u0364\n?\x03" +
+		"?\x03?\x03?\x03?\x05?\u036A\n?\x03?\x05?\u036D\n?\x03?\x05?\u0370\n?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u037A\n?\x03?\x03?\x03?\x03" +
+		"?\x05?\u0380\n?\x03?\x05?\u0383\n?\x03?\x05?\u0386\n?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x05?\u038E\n?\x03?\x05?\u0391\n?\x03?\x03?\x05?\u0395\n?\x03" +
+		"?\x05?\u0398\n?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x05?\u03A6\n?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x05?\u03B7\n?\x03?\x03?\x03?\x05?\u03BC\n?" +
+		"\x03?\x03?\x03?\x05?\u03C1\n?\x03?\x03?\x03?\x03?\x05?\u03C7\n?\x03?\x03" +
+		"?\x03?\x03?\x03?\x05?\u03CE\n?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x05?\u03DA\n?\x03?\x03?\x05?\u03DE\n?\x03?\x05?\u03E1\n?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u03EA\n?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u03F8\n?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x05?\u040D\n?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03" +
+		"?\x03?\x03?\x03?\x05?\u042A\n?\x03?\x03?\x03?\x03?\x03?\x03?\x05?\u0432" +
+		"\n?\x07?\u0434\n?\f?\x0E?\u0437\v?\x03@\x03@\x03@\x03@\x07@\u043D\n@\f" +
+		"@\x0E@\u0440\v@\x03@\x05@\u0443\n@\x03@\x03@\x03@\x03@\x03@\x07@\u044A" +
+		"\n@\f@\x0E@\u044D\v@\x03@\x05@\u0450\n@\x03@\x03@\x05@\u0454\n@\x03@\x03" +
+		"@\x03@\x05@\u0459\n@\x03A\x03A\x03A\x03A\x03A\x03A\x05A\u0461\nA\x03B" +
+		"\x03B\x03B\x07B\u0466\nB\fB\x0EB\u0469\vB\x03B\x03B\x03B\x03B\x03B\x07" +
+		"B\u0470\nB\fB\x0EB\u0473\vB\x03B\x03B\x07B\u0477\nB\fB\x0EB\u047A\vB\x03" +
+		"B\x03B\x03B\x03B\x05B\u0480\nB\x03C\x03C\x03C\x03C\x03C\x03C\x03C\x03" +
+		"C\x03C\x03C\x03C\x05C\u048D\nC\x03D\x03D\x03D\x07D\u0492\nD\fD\x0ED\u0495" +
+		"\vD\x03D\x05D\u0498\nD\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03" +
+		"E\x05E\u04A4\nE\x03F\x03F\x03F\x03F\x05F\u04AA\nF\x03F\x05F\u04AD\nF\x03" +
+		"G\x03G\x03G\x07G\u04B2\nG\fG\x0EG\u04B5\vG\x03H\x03H\x03H\x03H\x03H\x03" +
+		"H\x03H\x03H\x03H\x05H\u04C0\nH\x03H\x03H\x03H\x03H\x05H\u04C6\nH\x07H" +
+		"\u04C8\nH\fH\x0EH\u04CB\vH\x03I\x03I\x03I\x05I\u04D0\nI\x03I\x03I\x03" +
+		"J\x03J\x03J\x05J\u04D7\nJ\x03J\x03J\x03K\x03K\x03K\x07K\u04DE\nK\fK\x0E" +
+		"K\u04E1\vK\x03K\x05K\u04E4\nK\x03L\x03L\x03M\x03M\x03M\x03M\x03M\x03M" +
+		"\x05M\u04EE\nM\x05M\u04F0\nM\x03N\x05N\u04F3\nN\x03N\x03N\x03N\x03N\x03" +
+		"N\x03N\x05N\u04FB\nN\x03O\x03O\x03O\x05O\u0500\nO\x03P\x03P\x03Q\x03Q" +
+		"\x03R\x03R\x03S\x03S\x05S\u050A\nS\x03T\x03T\x03T\x05T\u050F\nT\x03U\x03" +
+		"U\x03U\x03U\x03V\x03V\x03V\x03V\x03W\x03W\x05W\u051B\nW\x03X\x03X\x07" +
+		"X\u051F\nX\fX\x0EX\u0522\vX\x03X\x03X\x03Y\x03Y\x03Y\x03Y\x03Y\x05Y\u052B" +
+		"\nY\x03Z\x03Z\x07Z\u052F\nZ\fZ\x0EZ\u0532\vZ\x03Z\x03Z\x03[\x03[\x03[" +
+		"\x03[\x03[\x05[\u053B\n[\x03[\x02\x02\x05T|\x8E\\\x02\x02\x04\x02\x06" +
+		"\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02" +
+		"\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x02" +
+		"2\x024\x026\x028\x02:\x02<\x02>\x02@\x02B\x02D\x02F\x02H\x02J\x02L\x02" +
+		"N\x02P\x02R\x02T\x02V\x02X\x02Z\x02\\\x02^\x02`\x02b\x02d\x02f\x02h\x02" +
+		"j\x02l\x02n\x02p\x02r\x02t\x02v\x02x\x02z\x02|\x02~\x02\x80\x02\x82\x02" +
+		"\x84\x02\x86\x02\x88\x02\x8A\x02\x8C\x02\x8E\x02\x90\x02\x92\x02\x94\x02" +
+		"\x96\x02\x98\x02\x9A\x02\x9C\x02\x9E\x02\xA0\x02\xA2\x02\xA4\x02\xA6\x02" +
+		"\xA8\x02\xAA\x02\xAC\x02\xAE\x02\xB0\x02\xB2\x02\xB4\x02\x02\x14\x04\x02" +
+		"\"\"\'\'\x04\x02\x14\x14OO\x04\x020088\x05\x02\x03\x03\x06\x06\n\n\x06" +
+		"\x02\x03\x03\x05\x06\n\nUU\x04\x0288NN\x04\x02\x03\x03\x06\x06\x04\x02" +
+		"BByy\x04\x02\t\t\x18\x19\x04\x02!!66\x04\x02LLQQ\x05\x02\f\f77__\x04\x02" +
+		"--::\x03\x02pq\x04\x02{{\x91\x91\t\x02\x17\x17**<=KKSSffll\x15\x02\x03" +
+		"\x0F\x11\x16\x18\x1C\x1E\x1F!!#&()+.0028:;??AJLRTXZaceghjk\x06\x02\x16" +
+		"\x16!!++55\x02\u05EC\x02\xB9\x03\x02\x02\x02\x04\xC0\x03\x02\x02\x02\x06" +
+		"\xC2\x03\x02\x02\x02\b\xC4\x03\x02\x02\x02\n\xCB\x03\x02\x02\x02\f\xE2" +
+		"\x03\x02\x02\x02\x0E\xE4\x03\x02\x02\x02\x10\xEB\x03\x02\x02\x02\x12\xF2" +
+		"\x03\x02\x02\x02\x14\xFF\x03\x02\x02\x02\x16\u010B\x03\x02\x02\x02\x18" +
+		"\u0114\x03\x02\x02\x02\x1A\u011C\x03\x02\x02\x02\x1C\u0132\x03\x02\x02" +
+		"\x02\x1E\u0141\x03\x02\x02\x02 \u014A\x03\x02\x02\x02\"\u014F\x03\x02" +
+		"\x02\x02$\u0153\x03\x02\x02\x02&\u0155\x03\x02\x02\x02(\u015E\x03\x02" +
+		"\x02\x02*\u0162\x03\x02\x02\x02,\u0170\x03\x02\x02\x02.\u017D\x03\x02" +
+		"\x02\x020\u0187\x03\x02\x02\x022\u018B\x03\x02\x02\x024\u0193\x03\x02" +
+		"\x02\x026\u01C7\x03\x02\x02\x028\u01CA\x03\x02\x02\x02:\u01D0\x03\x02" +
+		"\x02\x02<\u01D4\x03\x02\x02\x02>\u01DA\x03\x02\x02\x02@\u01EC\x03\x02" +
+		"\x02\x02B\u01EF\x03\x02\x02\x02D\u01F2\x03\x02\x02\x02F\u01FC\x03\x02" +
+		"\x02\x02H\u01FF\x03\x02\x02\x02J\u0203\x03\x02\x02\x02L\u0207\x03\x02" +
+		"\x02\x02N\u021F\x03\x02\x02\x02P\u0221\x03\x02\x02\x02R\u0224\x03\x02" +
+		"\x02\x02T\u0233\x03\x02\x02\x02V\u0271\x03\x02\x02\x02X\u0276\x03\x02" +
+		"\x02\x02Z\u0281\x03\x02\x02\x02\\\u0283\x03\x02\x02\x02^\u0289\x03\x02" +
+		"\x02\x02`\u028E\x03\x02\x02\x02b\u0296\x03\x02\x02\x02d\u02A8\x03\x02" +
+		"\x02\x02f\u02AA\x03\x02\x02\x02h\u02B2\x03\x02\x02\x02j\u02B7\x03\x02" +
+		"\x02\x02l\u02BF\x03\x02\x02\x02n\u02C3\x03\x02\x02\x02p\u02C7\x03\x02" +
+		"\x02\x02r\u02D0\x03\x02\x02\x02t\u02DE\x03\x02\x02\x02v\u02E0\x03\x02" +
+		"\x02\x02x\u031B\x03\x02\x02\x02z\u031D\x03\x02\x02\x02|\u03C0\x03\x02" +
+		"\x02\x02~\u0453\x03\x02\x02\x02\x80\u0460\x03\x02\x02\x02\x82\u047F\x03" +
+		"\x02\x02\x02\x84\u048C\x03\x02\x02\x02\x86\u048E\x03\x02\x02\x02\x88\u04A3" +
+		"\x03\x02\x02\x02\x8A\u04AC\x03\x02\x02\x02\x8C\u04AE\x03\x02\x02\x02\x8E" +
+		"\u04BF\x03\x02\x02\x02\x90\u04CC\x03\x02\x02\x02\x92\u04D6\x03\x02\x02" +
+		"\x02\x94\u04DA\x03\x02\x02\x02\x96\u04E5\x03\x02\x02\x02\x98\u04EF\x03" +
+		"\x02\x02\x02\x9A\u04F2\x03\x02\x02\x02\x9C\u04FF\x03\x02\x02\x02\x9E\u0501" +
+		"\x03\x02\x02\x02\xA0\u0503\x03\x02\x02\x02\xA2\u0505\x03\x02\x02\x02\xA4" +
+		"\u0509\x03\x02\x02\x02\xA6\u050E\x03\x02\x02\x02\xA8\u0510\x03\x02\x02" +
+		"\x02\xAA\u0514\x03\x02\x02\x02\xAC\u051A\x03\x02\x02\x02\xAE\u051C\x03" +
+		"\x02\x02\x02\xB0\u052A\x03\x02\x02\x02\xB2\u052C\x03\x02\x02\x02\xB4\u053A" +
+		"\x03\x02\x02\x02\xB6\xB8\x05\x04\x03\x02\xB7\xB6\x03\x02\x02\x02\xB8\xBB" +
+		"\x03\x02\x02\x02\xB9\xB7\x03\x02\x02\x02\xB9\xBA\x03\x02\x02\x02\xBA\xBC" +
+		"\x03\x02\x02\x02\xBB\xB9\x03\x02\x02\x02\xBC\xBD\x07\x02\x02\x03\xBD\x03" +
+		"\x03\x02\x02\x02\xBE\xC1\x05\b\x05\x02\xBF\xC1\x05\f\x07\x02\xC0\xBE\x03" +
+		"\x02\x02\x02\xC0\xBF\x03\x02\x02\x02\xC1\x05\x03\x02\x02\x02\xC2\xC3\x05" +
+		"|?\x02\xC3\x07\x03\x02\x02\x02\xC4\xC5\x079\x02\x02\xC5\xC9\x05\xA6T\x02" +
+		"\xC6\xC7\x07x\x02\x02\xC7\xC8\x07\x7F\x02\x02\xC8\xCA\x05\x06\x04\x02" +
+		"\xC9\xC6\x03\x02\x02\x02\xC9\xCA\x03\x02\x02\x02\xCA\t\x03\x02\x02\x02" +
+		"\xCB\xD0\x05\xA6T\x02\xCC\xCD\x07y\x02\x02\xCD\xCF\x05\xA6T\x02\xCE\xCC" +
+		"\x03\x02\x02\x02\xCF\xD2\x03\x02\x02\x02\xD0\xCE\x03\x02\x02\x02\xD0\xD1" +
+		"\x03\x02\x02\x02\xD1\xD4\x03\x02\x02\x02\xD2\xD0\x03\x02\x02\x02\xD3\xD5" +
+		"\x07y\x02\x02\xD4\xD3\x03\x02\x02\x02\xD4\xD5\x03\x02\x02\x02\xD5\v\x03" +
+		"\x02\x02\x02\xD6\xE3\x05\x0E\b\x02\xD7\xE3\x05\x10\t\x02\xD8\xE3\x05\x14" +
+		"\v\x02\xD9\xE3\x05\x16\f\x02\xDA\xE3\x05\x18\r\x02\xDB\xE3\x05\x1C\x0F" +
+		"\x02\xDC\xE3\x05\x1A\x0E\x02\xDD\xE3\x05\x1E\x10\x02\xDE\xE3\x05 \x11" +
+		"\x02\xDF\xE3\x05&\x14\x02\xE0\xE3\x05\"\x12\x02\xE1\xE3\x05$\x13\x02\xE2" +
+		"\xD6\x03\x02\x02\x02\xE2\xD7\x03\x02\x02\x02\xE2\xD8\x03\x02\x02\x02\xE2" +
+		"\xD9\x03\x02\x02\x02\xE2\xDA\x03\x02\x02\x02\xE2\xDB\x03\x02\x02\x02\xE2" +
+		"\xDC\x03\x02\x02\x02\xE2\xDD\x03\x02\x02\x02\xE2\xDE\x03\x02\x02\x02\xE2" +
+		"\xDF\x03\x02\x02\x02\xE2\xE0\x03\x02\x02\x02\xE2\xE1\x03\x02\x02\x02\xE3" +
+		"\r\x03\x02\x02\x02\xE4\xE6\x07M\x02\x02\xE5\xE7\x05\x06\x04\x02\xE6\xE5" +
+		"\x03\x02\x02\x02\xE6\xE7\x03\x02\x02\x02\xE7\xE9\x03\x02\x02\x02\xE8\xEA" +
+		"\x07\x9C\x02\x02\xE9\xE8\x03\x02\x02\x02\xE9\xEA\x03\x02\x02\x02\xEA\x0F" +
+		"\x03\x02\x02\x02\xEB\xED\x07Y\x02\x02\xEC\xEE\x05\x06\x04\x02\xED\xEC" +
+		"\x03\x02\x02\x02\xED\xEE\x03\x02\x02\x02\xEE\xF0\x03\x02\x02\x02\xEF\xF1" +
+		"\x07\x9C\x02\x02\xF0\xEF\x03\x02\x02\x02\xF0\xF1\x03\x02\x02\x02\xF1\x11" +
+		"\x03\x02\x02\x02\xF2\xFB\x07\x10\x02\x02\xF3\xF4\x07\x87\x02\x02\xF4\xF7" +
+		"\x05\xA6T\x02\xF5\xF6\x07x\x02\x02\xF6\xF8\x05\xA6T\x02\xF7\xF5\x03\x02" +
+		"\x02\x02\xF7\xF8\x03\x02\x02\x02\xF8\xF9\x03\x02\x02\x02\xF9\xFA\x07\x9B" +
+		"\x02\x02\xFA\xFC\x03\x02\x02\x02\xFB\xF3\x03\x02\x02\x02\xFB\xFC\x03\x02" +
+		"\x02\x02\xFC\xFD\x03\x02\x02\x02\xFD\xFE\x05&\x14\x02\xFE\x13\x03\x02" +
+		"\x02\x02\xFF\u0100\x07b\x02\x02\u0100\u0104\x05&\x14\x02\u0101\u0103\x05" +
+		"\x12\n\x02\u0102\u0101\x03\x02\x02\x02\u0103\u0106\x03\x02\x02\x02\u0104" +
+		"\u0102\x03\x02\x02\x02\u0104\u0105\x03\x02\x02\x02\u0105\u0109\x03\x02" +
+		"\x02\x02\u0106\u0104\x03\x02\x02\x02\u0107\u0108\x07 \x02\x02\u0108\u010A" +
+		"\x05&\x14\x02\u0109\u0107\x03\x02\x02\x02\u0109\u010A\x03\x02\x02\x02" +
+		"\u010A\x15\x03\x02\x02\x02\u010B\u010C\x07,\x02\x02\u010C\u010D\x07\x87" +
+		"\x02\x02\u010D\u010E\x05\x06\x04\x02\u010E\u010F\x07\x9B\x02\x02\u010F" +
+		"\u0112\x05\f\x07\x02\u0110\u0111\x07\x1B\x02\x02\u0111\u0113\x05\f\x07" +
+		"\x02\u0112\u0110\x03\x02\x02\x02\u0112\u0113\x03\x02\x02\x02\u0113\x17" +
+		"\x03\x02\x02\x02\u0114\u0115\x07i\x02\x02\u0115\u0116\x07\x87\x02\x02" +
+		"\u0116\u0117\x05\x06\x04\x02\u0117\u0118\x07\x9B\x02\x02\u0118\u011A\x05" +
+		"\f\x07\x02\u0119\u011B\x07\x9C\x02\x02\u011A\u0119\x03\x02\x02\x02\u011A" +
+		"\u011B\x03\x02\x02\x02\u011B\x19\x03\x02\x02\x02\u011C\u011D\x07$\x02" +
+		"\x02\u011D\u0121\x07\x87\x02\x02\u011E\u0122\x05\b\x05\x02\u011F\u0122" +
+		"\x05 \x11\x02\u0120\u0122\x05\x06\x04\x02\u0121\u011E\x03\x02\x02\x02" +
+		"\u0121\u011F\x03\x02\x02\x02\u0121\u0120\x03\x02\x02\x02\u0121\u0122\x03" +
+		"\x02\x02\x02\u0122\u0123\x03\x02\x02\x02\u0123\u0125\x07\x9C\x02\x02\u0124" +
+		"\u0126\x05\x06\x04\x02\u0125\u0124\x03\x02\x02\x02\u0125\u0126\x03\x02" +
+		"\x02\x02\u0126\u0127\x03\x02\x02\x02\u0127\u012B\x07\x9C\x02\x02\u0128" +
+		"\u012C\x05\b\x05\x02\u0129\u012C\x05 \x11\x02\u012A\u012C\x05\x06\x04" +
+		"\x02\u012B\u0128\x03\x02\x02\x02\u012B\u0129\x03\x02\x02\x02\u012B\u012A" +
+		"\x03\x02\x02\x02\u012B\u012C\x03\x02\x02\x02\u012C\u012D\x03\x02\x02\x02" +
+		"\u012D\u012E\x07\x9B\x02\x02\u012E\u0130\x05\f\x07\x02\u012F\u0131\x07" +
+		"\x9C\x02\x02\u0130\u012F\x03\x02\x02\x02\u0130\u0131\x03\x02\x02\x02\u0131" +
+		"\x1B\x03\x02\x02\x02\u0132\u0133\x07$\x02\x02\u0133\u0134\x07\x87\x02" +
+		"\x02\u0134\u0135\x079\x02\x02\u0135\u0138\x05\xA6T\x02\u0136\u0137\x07" +
+		"y\x02\x02\u0137\u0139\x05\xA6T\x02\u0138\u0136\x03\x02\x02\x02\u0138\u0139" +
+		"\x03\x02\x02\x02\u0139\u013A\x03\x02\x02\x02\u013A\u013B\x07.\x02\x02" +
+		"\u013B\u013C\x05\x06\x04\x02\u013C\u013D\x07\x9B\x02\x02\u013D\u013F\x05" +
+		"\f\x07\x02\u013E\u0140\x07\x9C\x02\x02\u013F\u013E\x03\x02\x02\x02\u013F" +
+		"\u0140\x03\x02\x02\x02\u0140\x1D\x03\x02\x02\x02\u0141\u0142\t\x02\x02" +
+		"\x02\u0142\u0143\x05\xA6T\x02\u0143\u0145\x07\x87\x02\x02\u0144\u0146" +
+		"\x05\n\x06\x02\u0145\u0144\x03\x02\x02\x02\u0145\u0146\x03\x02\x02\x02" +
+		"\u0146\u0147\x03\x02\x02\x02\u0147\u0148\x07\x9B\x02\x02\u0148\u0149\x05" +
+		"&\x14\x02\u0149\x1F\x03\x02\x02\x02\u014A\u014B\x05\x06\x04\x02\u014B" +
+		"\u014C\x07x\x02\x02\u014C\u014D\x07\x7F\x02\x02\u014D\u014E\x05\x06\x04" +
+		"\x02\u014E!\x03\x02\x02\x02\u014F\u0151\x05\x06\x04\x02\u0150\u0152\x07" +
+		"\x9C\x02\x02\u0151\u0150\x03\x02\x02\x02\u0151\u0152\x03\x02\x02\x02\u0152" +
+		"#\x03\x02\x02\x02\u0153\u0154\x07\x9C\x02\x02\u0154%\x03\x02\x02\x02\u0155" +
+		"\u0159\x07\x85\x02\x02\u0156\u0158\x05\x04\x03\x02\u0157\u0156\x03\x02" +
+		"\x02\x02\u0158\u015B\x03\x02\x02\x02\u0159\u0157\x03\x02\x02\x02\u0159" +
+		"\u015A\x03\x02\x02\x02\u015A\u015C\x03";
+	private static readonly _serializedATNSegment1: string =
+		"\x02\x02\x02\u015B\u0159\x03\x02\x02\x02\u015C\u015D\x07\x99\x02\x02\u015D" +
+		"\'\x03\x02\x02\x02\u015E\u015F\x05\x06\x04\x02\u015F\u0160\x07x\x02\x02" +
+		"\u0160\u0161\x05\x06\x04\x02\u0161)\x03\x02\x02\x02\u0162\u0167\x05(\x15" +
+		"\x02\u0163\u0164\x07y\x02\x02\u0164\u0166\x05(\x15\x02\u0165\u0163\x03" +
+		"\x02\x02\x02\u0166\u0169\x03\x02\x02\x02\u0167\u0165\x03\x02\x02\x02\u0167" +
+		"\u0168\x03\x02\x02\x02\u0168\u016B\x03\x02\x02\x02\u0169\u0167\x03\x02" +
+		"\x02\x02\u016A\u016C\x07y\x02\x02\u016B\u016A\x03\x02\x02\x02\u016B\u016C" +
+		"\x03\x02\x02\x02\u016C+\x03\x02\x02\x02\u016D\u0171\x052\x1A\x02\u016E" +
+		"\u0171\x054\x1B\x02\u016F\u0171\x05\x82B\x02\u0170\u016D\x03\x02\x02\x02" +
+		"\u0170\u016E\x03\x02\x02\x02\u0170\u016F\x03\x02\x02\x02\u0171\u0173\x03" +
+		"\x02\x02\x02\u0172\u0174\x07\x9C\x02\x02\u0173\u0172\x03\x02\x02\x02\u0173" +
+		"\u0174\x03\x02\x02\x02\u0174\u0175\x03\x02\x02\x02\u0175\u0176\x07\x02" +
+		"\x02\x03\u0176-\x03\x02\x02\x02\u0177\u017E\x054\x1B\x02\u0178\u0179\x07" +
+		"\x87\x02\x02\u0179\u017A\x052\x1A\x02\u017A\u017B\x07\x9B\x02\x02\u017B" +
+		"\u017E\x03\x02\x02\x02\u017C\u017E\x05\xAAV\x02\u017D\u0177\x03\x02\x02" +
+		"\x02\u017D\u0178\x03\x02\x02\x02\u017D\u017C\x03\x02\x02\x02\u017E/\x03" +
+		"\x02\x02\x02\u017F\u0188\x07\x1D\x02\x02\u0180\u0181\x07d\x02\x02\u0181" +
+		"\u0188\x07\x03\x02\x02\u0182\u0183\x07d\x02\x02\u0183\u0188\x07\x1A\x02" +
+		"\x02\u0184\u0188\x071\x02\x02\u0185\u0186\x071\x02\x02\u0186\u0188\x07" +
+		"\x1A\x02\x02\u0187\u017F\x03\x02\x02\x02\u0187\u0180\x03\x02\x02\x02\u0187" +
+		"\u0182\x03\x02\x02\x02\u0187\u0184\x03\x02\x02\x02\u0187\u0185\x03\x02" +
+		"\x02\x02\u0188\u0189\x03\x02\x02\x02\u0189\u018A\x05.\x18\x02\u018A1\x03" +
+		"\x02\x02\x02\u018B\u018F\x05.\x18\x02\u018C\u018E\x050\x19\x02\u018D\u018C" +
+		"\x03\x02\x02\x02\u018E\u0191\x03\x02\x02\x02\u018F\u018D\x03\x02\x02\x02" +
+		"\u018F\u0190\x03\x02\x02\x02\u01903\x03\x02\x02\x02\u0191\u018F\x03\x02" +
+		"\x02\x02\u0192\u0194\x056\x1C\x02\u0193\u0192\x03\x02\x02\x02\u0193\u0194" +
+		"\x03\x02\x02\x02\u0194\u0195\x03\x02\x02\x02\u0195\u0197\x07T\x02\x02" +
+		"\u0196\u0198\x07\x1A\x02\x02\u0197\u0196\x03\x02\x02\x02\u0197\u0198\x03" +
+		"\x02\x02\x02\u0198\u019A\x03\x02\x02\x02\u0199\u019B\x058\x1D\x02\u019A" +
+		"\u0199\x03\x02\x02\x02\u019A\u019B\x03\x02\x02\x02\u019B\u019C\x03\x02" +
+		"\x02\x02\u019C\u019E\x05z>\x02\u019D\u019F\x05:\x1E\x02\u019E\u019D\x03" +
+		"\x02\x02\x02\u019E\u019F\x03\x02\x02\x02\u019F\u01A1\x03\x02\x02\x02\u01A0" +
+		"\u01A2\x05<\x1F\x02\u01A1\u01A0\x03\x02\x02\x02\u01A1\u01A2\x03\x02\x02" +
+		"\x02\u01A2\u01A4\x03\x02\x02\x02\u01A3\u01A5\x05@!\x02\u01A4\u01A3\x03" +
+		"\x02\x02\x02\u01A4\u01A5\x03\x02\x02\x02\u01A5\u01A7\x03\x02\x02\x02\u01A6" +
+		"\u01A8\x05B\"\x02\u01A7\u01A6\x03\x02\x02\x02\u01A7\u01A8\x03\x02\x02" +
+		"\x02\u01A8\u01AA\x03\x02\x02\x02\u01A9\u01AB\x05D#\x02\u01AA\u01A9\x03" +
+		"\x02\x02\x02\u01AA\u01AB\x03\x02\x02\x02\u01AB\u01AE\x03\x02\x02\x02\u01AC" +
+		"\u01AD\x07k\x02\x02\u01AD\u01AF\t\x03\x02\x02\u01AE\u01AC\x03\x02\x02" +
+		"\x02\u01AE\u01AF\x03\x02\x02\x02\u01AF\u01B2\x03\x02\x02\x02\u01B0\u01B1" +
+		"\x07k\x02\x02\u01B1\u01B3\x07^\x02\x02\u01B2\u01B0\x03\x02\x02\x02\u01B2" +
+		"\u01B3\x03\x02\x02\x02\u01B3\u01B5\x03\x02\x02\x02\u01B4\u01B6\x05F$\x02" +
+		"\u01B5\u01B4\x03\x02\x02\x02\u01B5\u01B6\x03\x02\x02\x02\u01B6\u01B8\x03" +
+		"\x02\x02\x02\u01B7\u01B9\x05> \x02\u01B8\u01B7\x03\x02\x02\x02\u01B8\u01B9" +
+		"\x03\x02\x02\x02\u01B9\u01BB\x03\x02\x02\x02\u01BA\u01BC\x05H%\x02\u01BB" +
+		"\u01BA\x03\x02\x02\x02\u01BB\u01BC\x03\x02\x02\x02\u01BC\u01BE\x03\x02" +
+		"\x02\x02\u01BD\u01BF\x05L\'\x02\u01BE\u01BD\x03\x02\x02\x02\u01BE\u01BF" +
+		"\x03\x02\x02\x02\u01BF\u01C2\x03\x02\x02\x02\u01C0\u01C3\x05N(\x02\u01C1" +
+		"\u01C3\x05P)\x02\u01C2\u01C0\x03\x02\x02\x02\u01C2\u01C1\x03\x02\x02\x02" +
+		"\u01C2\u01C3\x03\x02\x02\x02\u01C3\u01C5\x03\x02\x02\x02\u01C4\u01C6\x05" +
+		"R*\x02\u01C5\u01C4\x03\x02\x02\x02\u01C5\u01C6\x03\x02\x02\x02\u01C65" +
+		"\x03\x02\x02\x02\u01C7\u01C8\x07k\x02\x02\u01C8\u01C9\x05\x86D\x02\u01C9" +
+		"7\x03\x02\x02\x02\u01CA\u01CB\x07]\x02\x02\u01CB\u01CE\x07q\x02\x02\u01CC" +
+		"\u01CD\x07k\x02\x02\u01CD\u01CF\x07Z\x02\x02\u01CE\u01CC\x03\x02\x02\x02" +
+		"\u01CE\u01CF\x03\x02\x02\x02\u01CF9\x03\x02\x02\x02\u01D0\u01D1\x07%\x02" +
+		"\x02\u01D1\u01D2\x05T+\x02\u01D2;\x03\x02\x02\x02\u01D3\u01D5\t\x04\x02" +
+		"\x02\u01D4\u01D3\x03\x02\x02\x02\u01D4\u01D5\x03\x02\x02\x02\u01D5\u01D6" +
+		"\x03\x02\x02\x02\u01D6\u01D7\x07\x07\x02\x02\u01D7\u01D8\x074\x02\x02" +
+		"\u01D8\u01D9\x05z>\x02\u01D9=\x03\x02\x02\x02\u01DA\u01DB\x07j\x02\x02" +
+		"\u01DB\u01DC\x05\xA6T\x02\u01DC\u01DD\x07\b\x02\x02\u01DD\u01DE\x07\x87" +
+		"\x02\x02\u01DE\u01DF\x05j6\x02\u01DF\u01E9\x07\x9B\x02\x02\u01E0\u01E1" +
+		"\x07y\x02\x02\u01E1\u01E2\x05\xA6T\x02\u01E2\u01E3\x07\b\x02\x02\u01E3" +
+		"\u01E4\x07\x87\x02\x02\u01E4\u01E5\x05j6\x02\u01E5\u01E6\x07\x9B\x02\x02" +
+		"\u01E6\u01E8\x03\x02\x02\x02\u01E7\u01E0\x03\x02\x02\x02\u01E8\u01EB\x03" +
+		"\x02\x02\x02\u01E9\u01E7\x03\x02\x02\x02\u01E9\u01EA\x03\x02\x02\x02\u01EA" +
+		"?\x03\x02\x02\x02\u01EB\u01E9\x03\x02\x02\x02\u01EC\u01ED\x07J\x02\x02" +
+		"\u01ED\u01EE\x05|?\x02\u01EEA\x03\x02\x02\x02\u01EF\u01F0\x07h\x02\x02" +
+		"\u01F0\u01F1\x05|?\x02\u01F1C\x03\x02\x02\x02\u01F2\u01F3\x07(\x02\x02" +
+		"\u01F3\u01FA\x07\r\x02\x02\u01F4\u01F5\t\x03\x02\x02\u01F5\u01F6\x07\x87" +
+		"\x02\x02\u01F6\u01F7\x05z>\x02\u01F7\u01F8\x07\x9B\x02\x02\u01F8\u01FB" +
+		"\x03\x02\x02\x02\u01F9\u01FB\x05z>\x02\u01FA\u01F4\x03\x02\x02\x02\u01FA" +
+		"\u01F9\x03\x02\x02\x02\u01FBE\x03\x02\x02\x02\u01FC\u01FD\x07)\x02\x02" +
+		"\u01FD\u01FE\x05|?\x02\u01FEG\x03\x02\x02\x02\u01FF\u0200\x07E\x02\x02" +
+		"\u0200\u0201\x07\r\x02\x02\u0201\u0202\x05`1\x02\u0202I\x03\x02\x02\x02" +
+		"\u0203\u0204\x07E\x02\x02\u0204\u0205\x07\r\x02\x02\u0205\u0206\x05z>" +
+		"\x02\u0206K\x03\x02\x02\x02\u0207\u0208\x07;\x02\x02\u0208\u0209\x05^" +
+		"0\x02\u0209\u020A\x07\r\x02\x02\u020A\u020B\x05z>\x02\u020BM\x03\x02\x02" +
+		"\x02\u020C\u020D\x07;\x02\x02\u020D\u0210\x05|?\x02\u020E\u020F\x07y\x02" +
+		"\x02\u020F\u0211\x05|?\x02\u0210\u020E\x03\x02\x02\x02\u0210\u0211\x03" +
+		"\x02\x02\x02\u0211\u0214\x03\x02\x02\x02\u0212\u0213\x07k\x02\x02\u0213" +
+		"\u0215\x07Z\x02\x02\u0214\u0212\x03\x02\x02\x02\u0214\u0215\x03\x02\x02" +
+		"\x02\u0215\u0220\x03\x02\x02\x02\u0216\u0217\x07;\x02\x02\u0217\u021A" +
+		"\x05|?\x02\u0218\u0219\x07k\x02\x02\u0219\u021B\x07Z\x02\x02\u021A\u0218" +
+		"\x03\x02\x02\x02\u021A\u021B\x03\x02\x02\x02\u021B\u021C\x03\x02\x02\x02" +
+		"\u021C\u021D\x07B\x02\x02\u021D\u021E\x05|?\x02\u021E\u0220\x03\x02\x02" +
+		"\x02\u021F\u020C\x03\x02\x02\x02\u021F\u0216\x03\x02\x02\x02\u0220O\x03" +
+		"\x02\x02\x02\u0221\u0222\x07B\x02\x02\u0222\u0223\x05|?\x02\u0223Q\x03" +
+		"\x02\x02\x02\u0224\u0225\x07V\x02\x02\u0225\u0226\x05f4\x02\u0226S\x03" +
+		"\x02\x02\x02\u0227\u0228\b+\x01\x02\u0228\u022A\x05\x8EH\x02\u0229\u022B" +
+		"\x07\x1F\x02\x02\u022A\u0229\x03\x02\x02\x02\u022A\u022B\x03\x02\x02\x02" +
+		"\u022B\u022D\x03\x02\x02\x02\u022C\u022E\x05\\/\x02\u022D\u022C\x03\x02" +
+		"\x02\x02\u022D\u022E\x03\x02\x02\x02\u022E\u0234\x03\x02\x02\x02\u022F" +
+		"\u0230\x07\x87\x02\x02\u0230\u0231\x05T+\x02\u0231\u0232\x07\x9B\x02\x02" +
+		"\u0232\u0234\x03\x02\x02\x02\u0233\u0227\x03\x02\x02\x02\u0233\u022F\x03" +
+		"\x02\x02\x02\u0234\u0243\x03\x02\x02\x02\u0235\u0236\f\x05\x02\x02\u0236" +
+		"\u0237\x05X-\x02\u0237\u0238\x05T+\x06\u0238\u0242\x03\x02\x02\x02\u0239" +
+		"\u023B\f\x06\x02\x02\u023A\u023C\x05V,\x02\u023B\u023A\x03\x02\x02\x02" +
+		"\u023B\u023C\x03\x02\x02\x02\u023C\u023D\x03\x02\x02\x02\u023D\u023E\x07" +
+		"4\x02\x02\u023E\u023F\x05T+\x02\u023F\u0240\x05Z.\x02\u0240\u0242\x03" +
+		"\x02\x02\x02\u0241\u0235\x03\x02\x02\x02\u0241\u0239\x03\x02\x02\x02\u0242" +
+		"\u0245\x03\x02\x02\x02\u0243\u0241\x03\x02\x02\x02\u0243\u0244\x03\x02" +
+		"\x02\x02\u0244U\x03\x02\x02\x02\u0245\u0243\x03\x02\x02\x02\u0246\u0248" +
+		"\t\x05\x02\x02\u0247\u0246\x03\x02\x02\x02\u0247\u0248\x03\x02\x02\x02" +
+		"\u0248\u0249\x03\x02\x02\x02\u0249\u0250\x070\x02\x02\u024A\u024C\x07" +
+		"0\x02\x02\u024B\u024D\t\x05\x02\x02\u024C\u024B\x03\x02\x02\x02\u024C" +
+		"\u024D\x03\x02\x02\x02\u024D\u0250\x03\x02\x02\x02\u024E\u0250\t\x05\x02" +
+		"\x02\u024F\u0247\x03\x02\x02\x02\u024F\u024A\x03\x02\x02\x02\u024F\u024E" +
+		"\x03\x02\x02\x02\u0250\u0272\x03\x02\x02\x02\u0251\u0253\t\x06\x02\x02" +
+		"\u0252\u0251\x03\x02\x02\x02\u0252\u0253\x03\x02\x02\x02\u0253\u0254\x03" +
+		"\x02\x02\x02\u0254\u0256\t\x07\x02\x02\u0255\u0257\x07F\x02\x02\u0256" +
+		"\u0255\x03\x02\x02\x02\u0256\u0257\x03\x02\x02\x02\u0257\u0260\x03\x02" +
+		"\x02\x02\u0258\u025A\t\x07\x02\x02\u0259\u025B\x07F\x02\x02\u025A\u0259" +
+		"\x03\x02\x02\x02\u025A\u025B\x03\x02\x02\x02\u025B\u025D\x03\x02\x02\x02" +
+		"\u025C\u025E\t\x06\x02\x02\u025D\u025C\x03\x02\x02\x02\u025D\u025E\x03" +
+		"\x02\x02\x02\u025E\u0260\x03\x02\x02\x02\u025F\u0252\x03\x02\x02\x02\u025F" +
+		"\u0258\x03\x02\x02\x02\u0260\u0272\x03\x02\x02\x02\u0261\u0263\t\b\x02" +
+		"\x02\u0262\u0261\x03\x02\x02\x02\u0262\u0263\x03\x02\x02\x02\u0263\u0264" +
+		"\x03\x02\x02\x02\u0264\u0266\x07&\x02\x02\u0265\u0267\x07F\x02\x02\u0266" +
+		"\u0265\x03\x02\x02\x02\u0266\u0267\x03\x02\x02\x02\u0267\u0270\x03\x02" +
+		"\x02\x02\u0268\u026A\x07&\x02\x02\u0269\u026B\x07F\x02\x02\u026A\u0269" +
+		"\x03\x02\x02\x02\u026A\u026B\x03\x02\x02\x02\u026B\u026D\x03\x02\x02\x02" +
+		"\u026C\u026E\t\b\x02\x02\u026D\u026C\x03\x02\x02\x02\u026D\u026E\x03\x02" +
+		"\x02\x02\u026E\u0270\x03\x02\x02\x02\u026F\u0262\x03\x02\x02\x02\u026F" +
+		"\u0268\x03\x02\x02\x02\u0270\u0272\x03\x02\x02\x02\u0271\u024F\x03\x02" +
+		"\x02\x02\u0271\u025F\x03\x02\x02\x02\u0271\u026F\x03\x02\x02\x02\u0272" +
+		"W\x03\x02\x02\x02\u0273\u0274\x07\x13\x02\x02\u0274\u0277\x074\x02\x02" +
+		"\u0275\u0277\x07y\x02\x02\u0276\u0273\x03\x02\x02\x02\u0276\u0275\x03" +
+		"\x02\x02\x02\u0277Y\x03\x02\x02\x02\u0278\u0279\x07C\x02\x02\u0279\u0282" +
+		"\x05z>\x02\u027A\u027B\x07e\x02\x02\u027B\u027C\x07\x87\x02\x02\u027C" +
+		"\u027D\x05z>\x02\u027D\u027E\x07\x9B\x02\x02\u027E\u0282\x03\x02\x02\x02" +
+		"\u027F\u0280\x07e\x02\x02\u0280\u0282\x05z>\x02\u0281\u0278\x03\x02\x02" +
+		"\x02\u0281\u027A\x03\x02\x02\x02\u0281\u027F\x03\x02\x02\x02\u0282[\x03" +
+		"\x02\x02\x02\u0283\u0284\x07R\x02\x02\u0284\u0287\x05d3\x02\u0285\u0286" +
+		"\x07B\x02\x02\u0286\u0288\x05d3\x02\u0287\u0285\x03\x02\x02\x02\u0287" +
+		"\u0288\x03\x02\x02\x02\u0288]\x03\x02\x02\x02\u0289\u028C\x05|?\x02\u028A" +
+		"\u028B\t\t\x02\x02\u028B\u028D\x05|?\x02\u028C\u028A\x03\x02\x02\x02\u028C" +
+		"\u028D\x03\x02\x02\x02\u028D_\x03\x02\x02\x02\u028E\u0293\x05b2\x02\u028F" +
+		"\u0290\x07y\x02\x02\u0290\u0292\x05b2\x02\u0291\u028F\x03\x02\x02\x02" +
+		"\u0292\u0295\x03\x02\x02\x02\u0293\u0291\x03\x02\x02\x02\u0293\u0294\x03" +
+		"\x02\x02\x02\u0294a\x03\x02\x02\x02\u0295\u0293\x03\x02\x02\x02\u0296" +
+		"\u0298\x05|?\x02\u0297\u0299\t\n\x02\x02\u0298\u0297\x03\x02\x02\x02\u0298" +
+		"\u0299\x03\x02\x02\x02\u0299\u029C\x03\x02\x02\x02\u029A\u029B\x07A\x02" +
+		"\x02\u029B\u029D\t\v\x02\x02\u029C\u029A\x03\x02\x02\x02\u029C\u029D\x03" +
+		"\x02\x02\x02\u029D\u02A0\x03\x02\x02\x02\u029E\u029F\x07\x12\x02\x02\u029F" +
+		"\u02A1\x07s\x02\x02\u02A0\u029E\x03\x02\x02\x02\u02A0\u02A1\x03\x02\x02" +
+		"\x02\u02A1c\x03\x02\x02\x02\u02A2\u02A9\x05\xAAV\x02\u02A3\u02A6\x05\x9A" +
+		"N\x02\u02A4\u02A5\x07\x9D\x02\x02\u02A5\u02A7\x05\x9AN\x02\u02A6\u02A4" +
+		"\x03\x02\x02\x02\u02A6\u02A7\x03\x02\x02\x02\u02A7\u02A9\x03\x02\x02\x02" +
+		"\u02A8\u02A2\x03\x02\x02\x02\u02A8\u02A3\x03\x02\x02\x02\u02A9e\x03\x02" +
+		"\x02\x02\u02AA\u02AF\x05h5\x02\u02AB\u02AC\x07y\x02\x02\u02AC\u02AE\x05" +
+		"h5\x02\u02AD\u02AB\x03\x02\x02\x02\u02AE\u02B1\x03\x02\x02\x02\u02AF\u02AD" +
+		"\x03\x02\x02\x02\u02AF\u02B0\x03\x02\x02\x02\u02B0g\x03\x02\x02\x02\u02B1" +
+		"\u02AF\x03\x02\x02\x02\u02B2\u02B3\x05\xA6T\x02\u02B3\u02B4\x07\x7F\x02" +
+		"\x02\u02B4\u02B5\x05\x9CO\x02\u02B5i\x03\x02\x02\x02\u02B6\u02B8\x05l" +
+		"7\x02\u02B7\u02B6\x03\x02\x02\x02\u02B7\u02B8\x03\x02\x02\x02\u02B8\u02BA" +
+		"\x03\x02\x02\x02\u02B9\u02BB\x05n8\x02\u02BA\u02B9\x03\x02\x02\x02\u02BA" +
+		"\u02BB\x03\x02\x02\x02\u02BB\u02BD\x03\x02\x02\x02\u02BC\u02BE\x05p9\x02" +
+		"\u02BD\u02BC\x03\x02\x02\x02\u02BD\u02BE\x03\x02\x02\x02\u02BEk\x03\x02" +
+		"\x02\x02\u02BF\u02C0\x07H\x02\x02\u02C0\u02C1\x07\r\x02\x02\u02C1\u02C2" +
+		"\x05z>\x02\u02C2m\x03\x02\x02\x02\u02C3\u02C4\x07E\x02\x02\u02C4\u02C5" +
+		"\x07\r\x02\x02\u02C5\u02C6\x05`1\x02\u02C6o\x03\x02\x02\x02\u02C7\u02C8" +
+		"\t\f\x02\x02\u02C8\u02C9\x05r:\x02\u02C9q\x03\x02\x02\x02\u02CA\u02D1" +
+		"\x05t;\x02\u02CB\u02CC\x07\v\x02\x02\u02CC\u02CD\x05t;\x02\u02CD\u02CE" +
+		"\x07\x04\x02\x02\u02CE\u02CF\x05t;\x02\u02CF\u02D1\x03\x02\x02\x02\u02D0" +
+		"\u02CA\x03\x02\x02\x02\u02D0\u02CB\x03\x02\x02\x02\u02D1s\x03\x02\x02" +
+		"\x02\u02D2\u02D3\x07\x15\x02\x02\u02D3\u02DF\x07P\x02\x02\u02D4\u02D5" +
+		"\x07c\x02\x02\u02D5\u02DF\x07I\x02\x02\u02D6\u02D7\x07c\x02\x02\u02D7" +
+		"\u02DF\x07#\x02\x02\u02D8\u02D9\x05\x9AN\x02\u02D9\u02DA\x07I\x02\x02" +
+		"\u02DA\u02DF\x03\x02\x02\x02\u02DB\u02DC\x05\x9AN\x02\u02DC\u02DD\x07" +
+		"#\x02\x02\u02DD\u02DF\x03\x02\x02\x02\u02DE\u02D2\x03\x02\x02\x02\u02DE" +
+		"\u02D4\x03\x02\x02\x02\u02DE\u02D6\x03\x02\x02\x02\u02DE\u02D8\x03\x02" +
+		"\x02\x02\u02DE\u02DB\x03\x02\x02\x02\u02DFu\x03\x02\x02\x02\u02E0\u02E1" +
+		"\x05|?\x02\u02E1\u02E2\x07\x02\x02\x03\u02E2w\x03\x02\x02\x02\u02E3\u031C" +
+		"\x05\xA6T\x02\u02E4\u02E5\x05\xA6T\x02\u02E5\u02E6\x07\x87\x02\x02\u02E6" +
+		"\u02E7\x05\xA6T\x02\u02E7\u02EE\x05x=\x02\u02E8\u02E9\x07y\x02\x02\u02E9" +
+		"\u02EA\x05\xA6T\x02\u02EA\u02EB\x05x=\x02\u02EB\u02ED\x03\x02\x02\x02" +
+		"\u02EC\u02E8\x03\x02\x02\x02\u02ED\u02F0\x03\x02\x02\x02\u02EE\u02EC\x03" +
+		"\x02\x02\x02\u02EE\u02EF\x03\x02\x02\x02\u02EF\u02F2\x03\x02\x02\x02\u02F0" +
+		"\u02EE\x03\x02\x02\x02\u02F1\u02F3\x07y\x02\x02\u02F2\u02F1\x03\x02\x02" +
+		"\x02\u02F2\u02F3\x03\x02\x02\x02\u02F3\u02F4\x03\x02\x02\x02\u02F4\u02F5" +
+		"\x07\x9B\x02\x02\u02F5\u031C\x03\x02\x02\x02\u02F6\u02F7\x05\xA6T\x02" +
+		"\u02F7\u02F8\x07\x87\x02\x02\u02F8\u02FD\x05\xA8U\x02\u02F9\u02FA\x07" +
+		"y\x02\x02\u02FA\u02FC\x05\xA8U\x02\u02FB\u02F9\x03\x02\x02\x02\u02FC\u02FF" +
+		"\x03\x02\x02\x02\u02FD\u02FB\x03\x02\x02\x02\u02FD\u02FE\x03\x02\x02\x02" +
+		"\u02FE\u0301\x03\x02\x02\x02\u02FF\u02FD\x03\x02\x02\x02\u0300\u0302\x07" +
+		"y\x02\x02\u0301\u0300\x03\x02\x02\x02\u0301\u0302\x03\x02\x02\x02\u0302" +
+		"\u0303\x03\x02\x02\x02\u0303\u0304\x07\x9B\x02\x02\u0304\u031C\x03\x02" +
+		"\x02\x02\u0305\u0306\x05\xA6T\x02\u0306\u0307\x07\x87\x02\x02\u0307\u030C" +
+		"\x05x=\x02\u0308\u0309\x07y\x02\x02\u0309\u030B\x05x=\x02\u030A\u0308" +
+		"\x03\x02\x02\x02\u030B\u030E\x03\x02\x02\x02\u030C\u030A\x03\x02\x02\x02" +
+		"\u030C\u030D\x03\x02\x02\x02\u030D\u0310\x03\x02\x02\x02\u030E\u030C\x03" +
+		"\x02\x02\x02\u030F\u0311\x07y\x02\x02\u0310\u030F\x03\x02\x02\x02\u0310" +
+		"\u0311\x03\x02\x02\x02\u0311\u0312\x03\x02\x02\x02\u0312\u0313\x07\x9B" +
+		"\x02\x02\u0313\u031C\x03\x02\x02\x02\u0314\u0315\x05\xA6T\x02\u0315\u0317" +
+		"\x07\x87\x02\x02\u0316\u0318\x05z>\x02\u0317\u0316\x03\x02\x02\x02\u0317" +
+		"\u0318\x03\x02\x02\x02\u0318\u0319\x03\x02\x02\x02\u0319\u031A\x07\x9B" +
+		"\x02\x02\u031A\u031C\x03\x02\x02\x02\u031B\u02E3\x03\x02\x02\x02\u031B" +
+		"\u02E4\x03\x02\x02\x02\u031B\u02F6\x03\x02\x02\x02\u031B\u0305\x03\x02" +
+		"\x02\x02\u031B\u0314\x03\x02\x02\x02\u031Cy\x03\x02\x02\x02\u031D\u0322" +
+		"\x05|?\x02\u031E\u031F\x07y\x02\x02\u031F\u0321\x05|?\x02\u0320\u031E" +
+		"\x03\x02\x02\x02\u0321\u0324\x03\x02\x02\x02\u0322\u0320\x03\x02\x02\x02" +
+		"\u0322\u0323\x03\x02\x02\x02\u0323\u0326\x03\x02\x02\x02\u0324\u0322\x03" +
+		"\x02\x02\x02\u0325\u0327\x07y\x02\x02\u0326\u0325\x03\x02\x02\x02\u0326" +
+		"\u0327\x03\x02\x02\x02\u0327{\x03\x02\x02\x02\u0328\u0329\b?\x01\x02\u0329" +
+		"\u032B\x07\x0E\x02\x02\u032A\u032C\x05|?\x02\u032B\u032A\x03\x02\x02\x02" +
+		"\u032B\u032C\x03\x02\x02\x02\u032C\u0332\x03\x02\x02\x02\u032D\u032E\x07" +
+		"g\x02\x02\u032E\u032F\x05|?\x02\u032F\u0330\x07X\x02\x02\u0330\u0331\x05" +
+		"|?\x02\u0331\u0333\x03\x02\x02\x02\u0332\u032D\x03\x02\x02\x02\u0333\u0334" +
+		"\x03\x02\x02\x02\u0334\u0332\x03\x02\x02\x02\u0334\u0335\x03\x02\x02\x02" +
+		"\u0335\u0338\x03\x02\x02\x02\u0336\u0337\x07\x1B\x02\x02\u0337\u0339\x05" +
+		"|?\x02\u0338\u0336\x03\x02\x02\x02\u0338\u0339\x03\x02\x02\x02\u0339\u033A" +
+		"\x03\x02\x02\x02\u033A\u033B\x07\x1C\x02\x02\u033B\u03C1\x03\x02\x02\x02" +
+		"\u033C\u033D\x07\x0F\x02\x02\u033D\u033E\x07\x87\x02\x02\u033E\u033F\x05" +
+		"|?\x02\u033F\u0340\x07\b\x02\x02\u0340\u0341\x05x=\x02\u0341\u0342\x07" +
+		"\x9B\x02\x02\u0342\u03C1\x03\x02\x02\x02\u0343\u0344\x07\x16\x02\x02\u0344" +
+		"\u03C1\x07s\x02\x02\u0345\u0346\x072\x02\x02\u0346\u03C1\x07s\x02\x02" +
+		"\u0347\u0348\x072\x02\x02\u0348\u0349\x05|?\x02\u0349\u034A\x05\x9EP\x02" +
+		"\u034A\u03C1\x03\x02\x02\x02\u034B\u034C\x07W\x02\x02\u034C\u034D\x07" +
+		"\x87\x02\x02\u034D\u034E\x05|?\x02\u034E\u034F\x07%\x02\x02\u034F\u0352" +
+		"\x05|?\x02\u0350\u0351\x07$\x02\x02\u0351\u0353\x05|?\x02\u0352\u0350" +
+		"\x03\x02\x02\x02\u0352\u0353\x03\x02\x02\x02\u0353\u0354\x03\x02\x02\x02" +
+		"\u0354\u0355\x07\x9B\x02\x02\u0355\u03C1\x03\x02\x02\x02\u0356\u0357\x07" +
+		"[\x02\x02\u0357\u03C1\x07s\x02\x02\u0358\u0359\x07`\x02\x02\u0359\u035A" +
+		"\x07\x87\x02\x02\u035A\u035B\t\r\x02\x02\u035B\u035C\x05\xACW\x02\u035C" +
+		"\u035D\x07%\x02\x02\u035D\u035E\x05|?\x02\u035E\u035F\x07\x9B\x02\x02" +
+		"\u035F\u03C1\x03\x02\x02\x02\u0360\u0361\x05\xA6T\x02\u0361\u0363\x07" +
+		"\x87\x02\x02\u0362\u0364\x05z>\x02\u0363\u0362\x03\x02\x02\x02\u0363\u0364" +
+		"\x03\x02\x02\x02\u0364\u0365\x03\x02\x02\x02\u0365\u0366\x07\x9B\x02\x02" +
+		"\u0366\u036F\x03\x02\x02\x02\u0367\u0369\x07\x87\x02\x02\u0368\u036A\x07" +
+		"\x1A\x02\x02\u0369\u0368\x03\x02\x02\x02\u0369\u036A\x03\x02\x02\x02\u036A" +
+		"\u036C\x03\x02\x02\x02\u036B\u036D\x05z>\x02\u036C\u036B\x03\x02\x02\x02" +
+		"\u036C\u036D\x03\x02\x02\x02\u036D\u036E\x03\x02\x02\x02\u036E\u0370\x07" +
+		"\x9B\x02\x02\u036F\u0367\x03\x02\x02\x02\u036F\u0370\x03\x02\x02\x02\u0370" +
+		"\u0371\x03\x02\x02\x02\u0371\u0372\x07G\x02\x02\u0372\u0373\x07\x87\x02" +
+		"\x02\u0373\u0374\x05j6\x02\u0374\u0375\x07\x9B\x02\x02\u0375\u03C1\x03" +
+		"\x02\x02\x02\u0376\u0377\x05\xA6T\x02\u0377\u0379\x07\x87\x02\x02\u0378" +
+		"\u037A\x05z>\x02\u0379\u0378\x03\x02\x02\x02\u0379\u037A\x03\x02\x02\x02" +
+		"\u037A\u037B\x03\x02\x02\x02\u037B\u037C\x07\x9B\x02\x02\u037C\u0385\x03" +
+		"\x02\x02\x02\u037D\u037F\x07\x87\x02\x02\u037E\u0380\x07\x1A\x02\x02\u037F" +
+		"\u037E\x03\x02\x02\x02\u037F\u0380\x03\x02\x02\x02\u0380\u0382\x03\x02" +
+		"\x02\x02\u0381\u0383\x05z>\x02\u0382\u0381\x03\x02\x02\x02\u0382\u0383" +
+		"\x03\x02\x02\x02\u0383\u0384\x03\x02\x02\x02\u0384\u0386\x07\x9B\x02\x02" +
+		"\u0385\u037D\x03\x02\x02\x02\u0385\u0386\x03\x02\x02\x02\u0386\u0387\x03" +
+		"\x02\x02\x02\u0387\u0388\x07G\x02\x02\u0388\u0389\x05\xA6T\x02\u0389\u03C1" +
+		"\x03\x02\x02\x02\u038A\u0390\x05\xA6T\x02\u038B\u038D\x07\x87\x02\x02" +
+		"\u038C\u038E\x05z>\x02\u038D\u038C\x03\x02\x02\x02\u038D\u038E\x03\x02" +
+		"\x02\x02\u038E\u038F\x03\x02\x02\x02\u038F\u0391\x07\x9B\x02\x02\u0390" +
+		"\u038B\x03\x02\x02\x02\u0390\u0391\x03\x02\x02\x02\u0391\u0392\x03\x02" +
+		"\x02\x02\u0392\u0394\x07\x87\x02\x02\u0393\u0395\x07\x1A\x02\x02\u0394" +
+		"\u0393\x03\x02\x02\x02\u0394\u0395\x03\x02\x02\x02\u0395\u0397\x03\x02" +
+		"\x02\x02\u0396\u0398\x05z>\x02\u0397\u0396\x03\x02\x02\x02\u0397\u0398" +
+		"\x03\x02\x02\x02\u0398\u0399\x03\x02\x02\x02\u0399\u039A\x07\x9B\x02\x02" +
+		"\u039A\u03C1\x03\x02\x02\x02\u039B\u03C1\x05\x82B\x02\u039C\u03C1\x05" +
+		"\xAEX\x02\u039D\u03C1\x05\x9CO\x02\u039E\u039F\x07{\x02\x02\u039F\u03C1" +
+		"\x05|?\x16\u03A0\u03A1\x07?\x02\x02\u03A1\u03C1\x05|?\x10\u03A2\u03A3" +
+		"\x05\x92J\x02\u03A3\u03A4\x07}\x02\x02\u03A4\u03A6\x03\x02\x02\x02\u03A5" +
+		"\u03A2\x03\x02\x02\x02\u03A5\u03A6\x03\x02\x02\x02\u03A6\u03A7\x03\x02" +
+		"\x02\x02\u03A7\u03C1\x07u\x02\x02\u03A8\u03A9\x07\x87\x02\x02\u03A9\u03AA" +
+		"\x052\x1A\x02\u03AA\u03AB\x07\x9B\x02\x02\u03AB\u03C1\x03\x02\x02\x02" +
+		"\u03AC\u03AD\x07\x87\x02\x02\u03AD\u03AE\x05|?\x02\u03AE\u03AF\x07\x9B" +
+		"\x02\x02\u03AF\u03C1\x03\x02\x02\x02\u03B0\u03B1\x07\x87\x02\x02\u03B1" +
+		"\u03B2\x05z>\x02\u03B2\u03B3\x07\x9B\x02\x02\u03B3\u03C1\x03\x02\x02\x02" +
+		"\u03B4\u03B6\x07\x86\x02\x02\u03B5\u03B7\x05z>\x02\u03B6\u03B5\x03\x02" +
+		"\x02\x02\u03B6\u03B7\x03\x02\x02\x02\u03B7\u03B8\x03\x02\x02\x02\u03B8" +
+		"\u03C1\x07\x9A\x02\x02\u03B9\u03BB\x07\x85\x02\x02\u03BA\u03BC\x05*\x16" +
+		"\x02\u03BB\u03BA\x03\x02\x02\x02\u03BB\u03BC\x03\x02\x02\x02\u03BC\u03BD" +
+		"\x03\x02\x02\x02\u03BD\u03C1\x07\x99\x02\x02\u03BE\u03C1\x05~@\x02\u03BF" +
+		"\u03C1\x05\x8AF\x02\u03C0\u0328\x03\x02\x02\x02\u03C0\u033C\x03\x02\x02" +
+		"\x02\u03C0\u0343\x03\x02\x02\x02\u03C0\u0345\x03\x02\x02\x02\u03C0\u0347" +
+		"\x03\x02\x02\x02\u03C0\u034B\x03\x02\x02\x02\u03C0\u0356\x03\x02\x02\x02" +
+		"\u03C0\u0358\x03\x02\x02\x02\u03C0\u0360\x03\x02\x02\x02\u03C0\u0376\x03" +
+		"\x02\x02\x02\u03C0\u038A\x03\x02\x02\x02\u03C0\u039B\x03\x02\x02\x02\u03C0" +
+		"\u039C\x03\x02\x02\x02\u03C0\u039D\x03\x02\x02\x02\u03C0\u039E\x03\x02" +
+		"\x02\x02\u03C0\u03A0\x03\x02\x02\x02\u03C0\u03A5\x03\x02\x02\x02\u03C0" +
+		"\u03A8\x03\x02\x02\x02\u03C0\u03AC\x03\x02\x02\x02\u03C0\u03B0\x03\x02" +
+		"\x02\x02\u03C0\u03B4\x03\x02\x02\x02\u03C0\u03B9\x03\x02\x02\x02\u03C0" +
+		"\u03BE\x03\x02\x02\x02\u03C0\u03BF\x03\x02\x02\x02\u03C1\u0435\x03\x02" +
+		"\x02\x02\u03C2\u03C6\f\x15\x02\x02\u03C3\u03C7\x07u\x02\x02\u03C4\u03C7" +
+		"\x07\x9D\x02\x02\u03C5\u03C7\x07\x90\x02\x02\u03C6\u03C3\x03\x02\x02\x02" +
+		"\u03C6\u03C4\x03\x02\x02\x02\u03C6\u03C5\x03\x02\x02\x02\u03C7\u03C8\x03" +
+		"\x02\x02\x02\u03C8\u0434\x05|?\x16\u03C9\u03CD\f\x14\x02\x02\u03CA\u03CE" +
+		"\x07\x91\x02\x02\u03CB\u03CE\x07{\x02\x02\u03CC\u03CE\x07z\x02\x02\u03CD" +
+		"\u03CA\x03\x02\x02\x02\u03CD\u03CB\x03\x02\x02\x02\u03CD\u03CC\x03\x02" +
+		"\x02\x02\u03CE\u03CF\x03\x02\x02\x02\u03CF\u0434\x05|?\x15\u03D0\u03E9" +
+		"\f\x13\x02\x02\u03D1\u03EA\x07~\x02\x02\u03D2\u03EA\x07\x7F\x02\x02\u03D3" +
+		"\u03EA\x07\x8B\x02\x02\u03D4\u03EA\x07\x88\x02\x02\u03D5\u03EA\x07\x89" +
+		"\x02\x02\u03D6\u03EA\x07\x80\x02\x02\u03D7\u03EA\x07\x81\x02\x02\u03D8" +
+		"\u03DA\x07?\x02\x02\u03D9\u03D8\x03\x02\x02\x02\u03D9\u03DA\x03\x02\x02" +
+		"\x02\u03DA\u03DB\x03\x02\x02\x02\u03DB\u03DD\x07.\x02\x02\u03DC\u03DE" +
+		"\x07\x11\x02\x02\u03DD\u03DC\x03\x02\x02\x02\u03DD\u03DE\x03\x02\x02\x02" +
+		"\u03DE\u03EA\x03\x02\x02\x02\u03DF\u03E1\x07?\x02\x02\u03E0\u03DF\x03" +
+		"\x02\x02\x02\u03E0\u03E1\x03\x02\x02\x02\u03E1\u03E2\x03\x02\x02\x02\u03E2" +
+		"\u03EA\t\x0E\x02\x02\u03E3\u03EA\x07\x97\x02\x02\u03E4\u03EA\x07\x98\x02" +
+		"\x02\u03E5\u03EA\x07\x8D\x02\x02\u03E6\u03EA\x07\x83\x02\x02\u03E7\u03EA" +
+		"\x07\x84\x02\x02\u03E8\u03EA\x07\x8C\x02\x02\u03E9\u03D1\x03\x02\x02\x02" +
+		"\u03E9\u03D2\x03\x02\x02\x02\u03E9\u03D3\x03\x02\x02\x02\u03E9\u03D4\x03" +
+		"\x02\x02\x02\u03E9\u03D5\x03\x02\x02\x02\u03E9\u03D6\x03\x02\x02\x02\u03E9" +
+		"\u03D7\x03\x02\x02\x02\u03E9\u03D9\x03\x02\x02\x02\u03E9\u03E0\x03\x02" +
+		"\x02\x02\u03E9\u03E3\x03\x02\x02\x02\u03E9\u03E4\x03\x02\x02\x02\u03E9" +
+		"\u03E5\x03\x02\x02\x02\u03E9\u03E6\x03\x02\x02\x02\u03E9\u03E7\x03\x02" +
+		"\x02\x02\u03E9\u03E8\x03\x02\x02\x02\u03EA\u03EB\x03\x02\x02\x02\u03EB" +
+		"\u0434\x05|?\x14\u03EC\u03ED\f\x11\x02\x02\u03ED\u03EE\x07\x8F\x02\x02" +
+		"\u03EE\u0434\x05|?\x12\u03EF\u03F0\f\x0F\x02\x02\u03F0\u03F1\x07\x04\x02" +
+		"\x02\u03F1\u0434\x05|?\x10\u03F2\u03F3\f\x0E\x02\x02\u03F3\u03F4\x07D" +
+		"\x02\x02\u03F4\u0434\x05|?\x0F\u03F5\u03F7\f\r\x02\x02\u03F6\u03F8\x07" +
+		"?\x02\x02\u03F7\u03F6\x03\x02\x02\x02\u03F7\u03F8\x03\x02\x02\x02\u03F8" +
+		"\u03F9\x03\x02\x02\x02\u03F9\u03FA\x07\v\x02\x02\u03FA\u03FB\x05|?\x02" +
+		"\u03FB\u03FC\x07\x04\x02\x02\u03FC\u03FD\x05|?\x0E\u03FD\u0434\x03\x02" +
+		"\x02\x02\u03FE\u03FF\f\f\x02\x02\u03FF\u0400\x07\x92\x02";
+	private static readonly _serializedATNSegment2: string =
+		"\x02\u0400\u0401\x05|?\x02\u0401\u0402\x07x\x02\x02\u0402\u0403\x05|?" +
+		"\f\u0403\u0434\x03\x02\x02\x02\u0404\u0405\f!\x02\x02\u0405\u0406\x07" +
+		"\x87\x02\x02\u0406\u0407\x052\x1A\x02\u0407\u0408\x07\x9B\x02\x02\u0408" +
+		"\u0434\x03\x02\x02\x02\u0409\u040A\f \x02\x02\u040A\u040C\x07\x87\x02" +
+		"\x02\u040B\u040D\x05z>\x02\u040C\u040B\x03\x02\x02\x02\u040C\u040D\x03" +
+		"\x02\x02\x02\u040D\u040E\x03\x02\x02\x02\u040E\u0434\x07\x9B\x02\x02\u040F" +
+		"\u0410\f\x1C\x02\x02\u0410\u0411\x07\x86\x02\x02\u0411\u0412\x05|?\x02" +
+		"\u0412\u0413\x07\x9A\x02\x02\u0413\u0434\x03\x02\x02\x02\u0414\u0415\f" +
+		"\x1B\x02\x02\u0415\u0416\x07}\x02\x02\u0416\u0434\x07q\x02\x02\u0417\u0418" +
+		"\f\x1A\x02\x02\u0418\u0419\x07}\x02\x02\u0419\u0434\x05\xA6T\x02\u041A" +
+		"\u041B\f\x19\x02\x02\u041B\u041C\x07\x8E\x02\x02\u041C\u041D\x07\x86\x02" +
+		"\x02\u041D\u041E\x05|?\x02\u041E\u041F\x07\x9A\x02\x02\u041F\u0434\x03" +
+		"\x02\x02\x02\u0420\u0421\f\x18\x02\x02\u0421\u0422\x07\x8E\x02\x02\u0422" +
+		"\u0434\x07q\x02\x02\u0423\u0424\f\x17\x02\x02\u0424\u0425\x07\x8E\x02" +
+		"\x02\u0425\u0434\x05\xA6T\x02\u0426\u0427\f\x12\x02\x02\u0427\u0429\x07" +
+		"3\x02\x02\u0428\u042A\x07?\x02\x02\u0429\u0428\x03\x02\x02\x02\u0429\u042A" +
+		"\x03\x02\x02\x02\u042A\u042B\x03\x02\x02\x02\u042B\u0434\x07@\x02\x02" +
+		"\u042C\u0431\f\v\x02\x02\u042D\u042E\x07\b\x02\x02\u042E\u0432\x05\xA6" +
+		"T\x02\u042F\u0430\x07\b\x02\x02\u0430\u0432\x07s\x02\x02\u0431\u042D\x03" +
+		"\x02\x02\x02\u0431\u042F\x03\x02\x02\x02\u0432\u0434\x03\x02\x02\x02\u0433" +
+		"\u03C2\x03\x02\x02\x02\u0433\u03C9\x03\x02\x02\x02\u0433\u03D0\x03\x02" +
+		"\x02\x02\u0433\u03EC\x03\x02\x02\x02\u0433\u03EF\x03\x02\x02\x02\u0433" +
+		"\u03F2\x03\x02\x02\x02\u0433\u03F5\x03\x02\x02\x02\u0433\u03FE\x03\x02" +
+		"\x02\x02\u0433\u0404\x03\x02\x02\x02\u0433\u0409\x03\x02\x02\x02\u0433" +
+		"\u040F\x03\x02\x02\x02\u0433\u0414\x03\x02\x02\x02\u0433\u0417\x03\x02" +
+		"\x02\x02\u0433\u041A\x03\x02\x02\x02\u0433\u0420\x03\x02\x02\x02\u0433" +
+		"\u0423\x03\x02\x02\x02\u0433\u0426\x03\x02\x02\x02\u0433\u042C\x03\x02" +
+		"\x02\x02\u0434\u0437\x03\x02\x02\x02\u0435\u0433\x03\x02\x02\x02\u0435" +
+		"\u0436\x03\x02\x02\x02\u0436}\x03\x02\x02\x02\u0437\u0435\x03\x02\x02" +
+		"\x02\u0438\u0439\x07\x87\x02\x02\u0439\u043E\x05\xA6T\x02\u043A\u043B" +
+		"\x07y\x02\x02\u043B\u043D\x05\xA6T\x02\u043C\u043A\x03\x02\x02\x02\u043D" +
+		"\u0440\x03\x02\x02\x02\u043E\u043C\x03\x02\x02\x02\u043E\u043F\x03\x02" +
+		"\x02\x02\u043F\u0442\x03\x02\x02\x02\u0440\u043E\x03\x02\x02\x02\u0441" +
+		"\u0443\x07y\x02\x02\u0442\u0441\x03\x02\x02\x02\u0442\u0443\x03\x02\x02" +
+		"\x02\u0443\u0444\x03\x02\x02\x02\u0444\u0445\x07\x9B\x02\x02\u0445\u0454" +
+		"\x03\x02\x02\x02\u0446\u044B\x05\xA6T\x02\u0447\u0448\x07y\x02\x02\u0448" +
+		"\u044A\x05\xA6T\x02\u0449\u0447\x03\x02\x02\x02\u044A\u044D\x03\x02\x02" +
+		"\x02\u044B\u0449\x03\x02\x02\x02\u044B\u044C\x03\x02\x02\x02\u044C\u044F" +
+		"\x03\x02\x02\x02\u044D\u044B\x03\x02\x02\x02\u044E\u0450\x07y\x02\x02" +
+		"\u044F\u044E\x03\x02\x02\x02\u044F\u0450\x03\x02\x02\x02\u0450\u0454\x03" +
+		"\x02\x02\x02\u0451\u0452\x07\x87\x02\x02\u0452\u0454\x07\x9B\x02\x02\u0453" +
+		"\u0438\x03\x02\x02\x02\u0453\u0446\x03\x02\x02\x02\u0453\u0451\x03\x02" +
+		"\x02\x02\u0454\u0455\x03\x02\x02\x02\u0455\u0458\x07t\x02\x02\u0456\u0459" +
+		"\x05|?\x02\u0457\u0459\x05&\x14\x02\u0458\u0456\x03\x02\x02\x02\u0458" +
+		"\u0457\x03\x02\x02\x02\u0459\x7F\x03\x02\x02\x02\u045A\u0461\x05\x82B" +
+		"\x02\u045B\u0461\x07\xA9\x02\x02\u045C\u045D\x07\x85\x02\x02\u045D\u045E" +
+		"\x05|?\x02\u045E\u045F\x07\x99\x02\x02\u045F\u0461\x03\x02\x02\x02\u0460" +
+		"\u045A\x03\x02\x02\x02\u0460\u045B\x03\x02\x02\x02\u0460\u045C\x03\x02" +
+		"\x02\x02\u0461\x81\x03\x02\x02\x02\u0462\u0463\x07\x89\x02\x02\u0463\u0467" +
+		"\x05\xA6T\x02\u0464\u0466\x05\x84C\x02\u0465\u0464\x03\x02\x02\x02\u0466" +
+		"\u0469\x03\x02\x02\x02\u0467\u0465\x03\x02\x02\x02\u0467\u0468\x03\x02" +
+		"\x02\x02\u0468\u046A\x03\x02\x02\x02\u0469\u0467\x03\x02\x02\x02\u046A" +
+		"\u046B\x07\x9E\x02\x02\u046B\u0480\x03\x02\x02\x02\u046C\u046D\x07\x89" +
+		"\x02\x02\u046D\u0471\x05\xA6T\x02\u046E\u0470\x05\x84C\x02\u046F\u046E" +
+		"\x03\x02\x02\x02\u0470\u0473\x03\x02\x02\x02\u0471\u046F\x03\x02\x02\x02" +
+		"\u0471\u0472\x03\x02\x02\x02\u0472\u0474\x03\x02\x02\x02\u0473\u0471\x03" +
+		"\x02\x02\x02\u0474\u0478\x07\x81\x02\x02\u0475\u0477\x05\x80A\x02\u0476" +
+		"\u0475\x03\x02\x02\x02\u0477\u047A\x03\x02\x02\x02\u0478\u0476\x03\x02" +
+		"\x02\x02\u0478\u0479\x03\x02\x02\x02\u0479\u047B\x03\x02\x02\x02\u047A" +
+		"\u0478\x03\x02\x02\x02\u047B\u047C\x07\x8A\x02\x02\u047C\u047D\x05\xA6" +
+		"T\x02\u047D\u047E\x07\x81\x02\x02\u047E\u0480\x03\x02\x02\x02\u047F\u0462" +
+		"\x03\x02\x02\x02\u047F\u046C\x03\x02\x02\x02\u0480\x83\x03\x02\x02\x02" +
+		"\u0481\u0482\x05\xA6T\x02\u0482\u0483\x07\x7F\x02\x02\u0483\u0484\x05" +
+		"\xACW\x02\u0484\u048D\x03\x02\x02\x02\u0485\u0486\x05\xA6T\x02\u0486\u0487" +
+		"\x07\x7F\x02\x02\u0487\u0488\x07\x85\x02\x02\u0488\u0489\x05|?\x02\u0489" +
+		"\u048A\x07\x99\x02\x02\u048A\u048D\x03\x02\x02\x02\u048B\u048D\x05\xA6" +
+		"T\x02\u048C\u0481\x03\x02\x02\x02\u048C\u0485\x03\x02\x02\x02\u048C\u048B" +
+		"\x03\x02\x02\x02\u048D\x85\x03\x02\x02\x02\u048E\u0493\x05\x88E\x02\u048F" +
+		"\u0490\x07y\x02\x02\u0490\u0492\x05\x88E\x02\u0491\u048F\x03\x02\x02\x02" +
+		"\u0492\u0495\x03\x02\x02\x02\u0493\u0491\x03\x02\x02\x02\u0493\u0494\x03" +
+		"\x02\x02\x02\u0494\u0497\x03\x02\x02\x02\u0495\u0493\x03\x02\x02\x02\u0496" +
+		"\u0498\x07y\x02\x02\u0497\u0496\x03\x02\x02\x02\u0497\u0498\x03\x02\x02" +
+		"\x02\u0498\x87\x03\x02\x02\x02\u0499\u049A\x05\xA6T\x02\u049A\u049B\x07" +
+		"\b\x02\x02\u049B\u049C\x07\x87\x02\x02\u049C\u049D\x052\x1A\x02\u049D" +
+		"\u049E\x07\x9B\x02\x02\u049E\u04A4\x03\x02\x02\x02\u049F\u04A0\x05|?\x02" +
+		"\u04A0\u04A1\x07\b\x02\x02\u04A1\u04A2\x05\xA6T\x02\u04A2\u04A4\x03\x02" +
+		"\x02\x02\u04A3\u0499\x03\x02\x02\x02\u04A3\u049F\x03\x02\x02\x02\u04A4" +
+		"\x89\x03\x02\x02\x02\u04A5\u04AD\x05\xAAV\x02\u04A6\u04A7\x05\x92J\x02" +
+		"\u04A7\u04A8\x07}\x02\x02\u04A8\u04AA\x03\x02\x02\x02\u04A9\u04A6\x03" +
+		"\x02\x02\x02\u04A9\u04AA\x03\x02\x02\x02\u04AA\u04AB\x03\x02\x02\x02\u04AB" +
+		"\u04AD\x05\x8CG\x02\u04AC\u04A5\x03\x02\x02\x02\u04AC\u04A9\x03\x02\x02" +
+		"\x02\u04AD\x8B\x03\x02\x02\x02\u04AE\u04B3\x05\xA6T\x02\u04AF\u04B0\x07" +
+		"}\x02\x02\u04B0\u04B2\x05\xA6T\x02\u04B1\u04AF\x03\x02\x02\x02\u04B2\u04B5" +
+		"\x03\x02\x02\x02\u04B3\u04B1\x03\x02\x02\x02\u04B3\u04B4\x03\x02\x02\x02" +
+		"\u04B4\x8D\x03\x02\x02\x02\u04B5\u04B3\x03\x02\x02\x02\u04B6\u04B7\bH" +
+		"\x01\x02\u04B7\u04C0\x05\x92J\x02\u04B8\u04C0\x05\x90I\x02\u04B9\u04BA" +
+		"\x07\x87\x02\x02\u04BA\u04BB\x052\x1A\x02\u04BB\u04BC\x07\x9B\x02\x02" +
+		"\u04BC\u04C0\x03\x02\x02\x02\u04BD\u04C0\x05\x82B\x02\u04BE\u04C0\x05" +
+		"\xAAV\x02\u04BF\u04B6\x03\x02\x02\x02\u04BF\u04B8\x03\x02\x02\x02\u04BF" +
+		"\u04B9\x03\x02\x02\x02\u04BF\u04BD\x03\x02\x02\x02\u04BF\u04BE\x03\x02" +
+		"\x02\x02\u04C0\u04C9\x03\x02\x02\x02\u04C1\u04C5\f\x05\x02\x02\u04C2\u04C6" +
+		"\x05\xA4S\x02\u04C3\u04C4\x07\b\x02\x02\u04C4\u04C6\x05\xA6T\x02\u04C5" +
+		"\u04C2\x03\x02\x02\x02\u04C5\u04C3\x03\x02\x02\x02\u04C6\u04C8\x03\x02" +
+		"\x02\x02\u04C7\u04C1\x03\x02\x02\x02\u04C8\u04CB\x03\x02\x02\x02\u04C9" +
+		"\u04C7\x03\x02\x02\x02\u04C9\u04CA\x03\x02\x02\x02\u04CA\x8F\x03\x02\x02" +
+		"\x02\u04CB\u04C9\x03\x02\x02\x02\u04CC\u04CD\x05\xA6T\x02\u04CD\u04CF" +
+		"\x07\x87\x02\x02\u04CE\u04D0\x05\x94K\x02\u04CF\u04CE\x03\x02\x02\x02" +
+		"\u04CF\u04D0\x03\x02\x02\x02\u04D0\u04D1\x03\x02\x02\x02\u04D1\u04D2\x07" +
+		"\x9B\x02\x02\u04D2\x91\x03\x02\x02\x02\u04D3\u04D4\x05\x96L\x02\u04D4" +
+		"\u04D5\x07}\x02\x02\u04D5\u04D7\x03\x02\x02\x02\u04D6\u04D3\x03\x02\x02" +
+		"\x02\u04D6\u04D7\x03\x02\x02\x02\u04D7\u04D8\x03\x02\x02\x02\u04D8\u04D9" +
+		"\x05\x8CG\x02\u04D9\x93\x03\x02\x02\x02\u04DA\u04DF\x05|?\x02\u04DB\u04DC" +
+		"\x07y\x02\x02\u04DC\u04DE\x05|?\x02\u04DD\u04DB\x03\x02\x02\x02\u04DE" +
+		"\u04E1\x03\x02\x02\x02\u04DF\u04DD\x03\x02\x02\x02\u04DF\u04E0\x03\x02" +
+		"\x02\x02\u04E0\u04E3\x03\x02\x02\x02\u04E1\u04DF\x03\x02\x02\x02\u04E2" +
+		"\u04E4\x07y\x02\x02\u04E3\u04E2\x03\x02\x02\x02\u04E3\u04E4\x03\x02\x02" +
+		"\x02\u04E4\x95\x03\x02\x02\x02\u04E5\u04E6\x05\xA6T\x02\u04E6\x97\x03" +
+		"\x02\x02\x02\u04E7\u04F0\x07o\x02\x02\u04E8\u04E9\x07}\x02\x02\u04E9\u04F0" +
+		"\t\x0F\x02\x02\u04EA\u04EB\x07q\x02\x02\u04EB\u04ED\x07}\x02\x02\u04EC" +
+		"\u04EE\t\x0F\x02\x02\u04ED\u04EC\x03\x02\x02\x02\u04ED\u04EE\x03\x02\x02" +
+		"\x02\u04EE\u04F0\x03\x02\x02\x02\u04EF\u04E7\x03\x02\x02\x02\u04EF\u04E8" +
+		"\x03\x02\x02\x02\u04EF\u04EA\x03\x02\x02\x02\u04F0\x99\x03\x02\x02\x02" +
+		"\u04F1\u04F3\t\x10\x02\x02\u04F2\u04F1\x03\x02\x02\x02\u04F2\u04F3\x03" +
+		"\x02\x02\x02\u04F3\u04FA\x03\x02\x02\x02\u04F4\u04FB\x05\x98M\x02\u04F5" +
+		"\u04FB\x07p\x02\x02\u04F6\u04FB\x07q\x02\x02\u04F7\u04FB\x07r\x02\x02" +
+		"\u04F8\u04FB\x07/\x02\x02\u04F9\u04FB\x07>\x02\x02\u04FA\u04F4\x03\x02" +
+		"\x02\x02\u04FA\u04F5\x03\x02\x02\x02\u04FA\u04F6\x03\x02\x02\x02\u04FA" +
+		"\u04F7\x03\x02\x02\x02\u04FA\u04F8\x03\x02\x02\x02\u04FA\u04F9\x03\x02" +
+		"\x02\x02\u04FB\x9B\x03\x02\x02\x02\u04FC\u0500\x05\x9AN\x02\u04FD\u0500" +
+		"\x07s\x02\x02\u04FE\u0500\x07@\x02\x02\u04FF\u04FC\x03\x02\x02\x02\u04FF" +
+		"\u04FD\x03\x02\x02\x02\u04FF\u04FE\x03\x02\x02\x02\u0500\x9D\x03\x02\x02" +
+		"\x02\u0501\u0502\t\x11\x02\x02\u0502\x9F\x03\x02\x02\x02\u0503\u0504\t" +
+		"\x12\x02\x02\u0504\xA1\x03\x02\x02\x02\u0505\u0506\t\x13\x02\x02\u0506" +
+		"\xA3\x03\x02\x02\x02\u0507\u050A\x07n\x02\x02\u0508\u050A\x05\xA2R\x02" +
+		"\u0509\u0507\x03\x02\x02\x02\u0509\u0508\x03\x02\x02\x02\u050A\xA5\x03" +
+		"\x02\x02\x02\u050B\u050F\x07n\x02\x02\u050C\u050F\x05\x9EP\x02\u050D\u050F" +
+		"\x05\xA0Q\x02\u050E\u050B\x03\x02\x02\x02\u050E\u050C\x03\x02\x02\x02" +
+		"\u050E\u050D\x03\x02\x02\x02\u050F\xA7\x03\x02\x02\x02\u0510\u0511\x05" +
+		"\xACW\x02\u0511\u0512\x07\x7F\x02\x02\u0512\u0513\x05\x9AN\x02\u0513\xA9" +
+		"\x03\x02\x02\x02\u0514\u0515\x07\x85\x02\x02\u0515\u0516\x05|?\x02\u0516" +
+		"\u0517\x07\x99\x02\x02\u0517\xAB\x03\x02\x02\x02\u0518\u051B\x07s\x02" +
+		"\x02\u0519\u051B\x05\xAEX\x02\u051A\u0518\x03\x02\x02\x02\u051A\u0519" +
+		"\x03\x02\x02\x02\u051B\xAD\x03\x02\x02\x02\u051C\u0520\x07\x94\x02\x02" +
+		"\u051D\u051F\x05\xB0Y\x02\u051E\u051D\x03\x02\x02\x02\u051F\u0522\x03" +
+		"\x02\x02\x02\u0520\u051E\x03\x02\x02\x02\u0520\u0521\x03\x02\x02\x02\u0521" +
+		"\u0523\x03\x02\x02\x02\u0522\u0520\x03\x02\x02\x02\u0523\u0524\x07\x96" +
+		"\x02\x02\u0524\xAF\x03\x02\x02\x02\u0525\u0526\x07\xA4\x02\x02\u0526\u0527" +
+		"\x05|?\x02\u0527\u0528\x07\x99\x02\x02\u0528\u052B\x03\x02\x02\x02\u0529" +
+		"\u052B\x07\xA3\x02\x02\u052A\u0525\x03\x02\x02\x02\u052A\u0529\x03\x02" +
+		"\x02\x02\u052B\xB1\x03\x02\x02\x02\u052C\u0530\x07\x95\x02\x02\u052D\u052F" +
+		"\x05\xB4[\x02\u052E\u052D\x03\x02\x02\x02\u052F\u0532\x03\x02\x02\x02" +
+		"\u0530\u052E\x03\x02\x02\x02\u0530\u0531\x03\x02\x02\x02\u0531\u0533\x03" +
+		"\x02\x02\x02\u0532\u0530\x03\x02\x02\x02\u0533\u0534\x07\x02\x02\x03\u0534" +
+		"\xB3\x03\x02\x02\x02\u0535\u0536\x07\xA6\x02\x02\u0536\u0537\x05|?\x02" +
+		"\u0537\u0538\x07\x99\x02\x02\u0538\u053B\x03\x02\x02\x02\u0539\u053B\x07" +
+		"\xA5\x02\x02\u053A\u0535\x03\x02\x02\x02\u053A\u0539\x03\x02\x02\x02\u053B" +
+		"\xB5\x03\x02\x02\x02\xAD\xB9\xC0\xC9\xD0\xD4\xE2\xE6\xE9\xED\xF0\xF7\xFB" +
+		"\u0104\u0109\u0112\u011A\u0121\u0125\u012B\u0130\u0138\u013F\u0145\u0151" +
+		"\u0159\u0167\u016B\u0170\u0173\u017D\u0187\u018F\u0193\u0197\u019A\u019E" +
+		"\u01A1\u01A4\u01A7\u01AA\u01AE\u01B2\u01B5\u01B8\u01BB\u01BE\u01C2\u01C5" +
+		"\u01CE\u01D4\u01E9\u01FA\u0210\u0214\u021A\u021F\u022A\u022D\u0233\u023B" +
+		"\u0241\u0243\u0247\u024C\u024F\u0252\u0256\u025A\u025D\u025F\u0262\u0266" +
+		"\u026A\u026D\u026F\u0271\u0276\u0281\u0287\u028C\u0293\u0298\u029C\u02A0" +
+		"\u02A6\u02A8\u02AF\u02B7\u02BA\u02BD\u02D0\u02DE\u02EE\u02F2\u02FD\u0301" +
+		"\u030C\u0310\u0317\u031B\u0322\u0326\u032B\u0334\u0338\u0352\u0363\u0369" +
+		"\u036C\u036F\u0379\u037F\u0382\u0385\u038D\u0390\u0394\u0397\u03A5\u03B6" +
+		"\u03BB\u03C0\u03C6\u03CD\u03D9\u03DD\u03E0\u03E9\u03F7\u040C\u0429\u0431" +
+		"\u0433\u0435\u043E\u0442\u044B\u044F\u0453\u0458\u0460\u0467\u0471\u0478" +
+		"\u047F\u048C\u0493\u0497\u04A3\u04A9\u04AC\u04B3\u04BF\u04C5\u04C9\u04CF" +
+		"\u04D6\u04DF\u04E3\u04ED\u04EF\u04F2\u04FA\u04FF\u0509\u050E\u051A\u0520" +
+		"\u052A\u0530\u053A";
+	public static readonly _serializedATN: string = Utils.join(
+		[
+			TSQLParser._serializedATNSegment0,
+			TSQLParser._serializedATNSegment1,
+			TSQLParser._serializedATNSegment2,
+		],
+		"",
+	);
+	public static __ATN: ATN;
+	public static get _ATN(): ATN {
+		if (!TSQLParser.__ATN) {
+			TSQLParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(TSQLParser._serializedATN));
+		}
+
+		return TSQLParser.__ATN;
+	}
+
+}
+
+export class ProgramContext extends ParserRuleContext {
+	public EOF(): TerminalNode { return this.getToken(TSQLParser.EOF, 0); }
+	public declaration(): DeclarationContext[];
+	public declaration(i: number): DeclarationContext;
+	public declaration(i?: number): DeclarationContext | DeclarationContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(DeclarationContext);
+		} else {
+			return this.getRuleContext(i, DeclarationContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_program; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitProgram) {
+			return visitor.visitProgram(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class DeclarationContext extends ParserRuleContext {
+	public varDecl(): VarDeclContext | undefined {
+		return this.tryGetRuleContext(0, VarDeclContext);
+	}
+	public statement(): StatementContext | undefined {
+		return this.tryGetRuleContext(0, StatementContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_declaration; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitDeclaration) {
+			return visitor.visitDeclaration(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ExpressionContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_expression; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitExpression) {
+			return visitor.visitExpression(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class VarDeclContext extends ParserRuleContext {
+	public LET(): TerminalNode { return this.getToken(TSQLParser.LET, 0); }
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public COLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COLON, 0); }
+	public EQ_SINGLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EQ_SINGLE, 0); }
+	public expression(): ExpressionContext | undefined {
+		return this.tryGetRuleContext(0, ExpressionContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_varDecl; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitVarDecl) {
+			return visitor.visitVarDecl(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class IdentifierListContext extends ParserRuleContext {
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_identifierList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitIdentifierList) {
+			return visitor.visitIdentifierList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class StatementContext extends ParserRuleContext {
+	public returnStmt(): ReturnStmtContext | undefined {
+		return this.tryGetRuleContext(0, ReturnStmtContext);
+	}
+	public throwStmt(): ThrowStmtContext | undefined {
+		return this.tryGetRuleContext(0, ThrowStmtContext);
+	}
+	public tryCatchStmt(): TryCatchStmtContext | undefined {
+		return this.tryGetRuleContext(0, TryCatchStmtContext);
+	}
+	public ifStmt(): IfStmtContext | undefined {
+		return this.tryGetRuleContext(0, IfStmtContext);
+	}
+	public whileStmt(): WhileStmtContext | undefined {
+		return this.tryGetRuleContext(0, WhileStmtContext);
+	}
+	public forInStmt(): ForInStmtContext | undefined {
+		return this.tryGetRuleContext(0, ForInStmtContext);
+	}
+	public forStmt(): ForStmtContext | undefined {
+		return this.tryGetRuleContext(0, ForStmtContext);
+	}
+	public funcStmt(): FuncStmtContext | undefined {
+		return this.tryGetRuleContext(0, FuncStmtContext);
+	}
+	public varAssignment(): VarAssignmentContext | undefined {
+		return this.tryGetRuleContext(0, VarAssignmentContext);
+	}
+	public block(): BlockContext | undefined {
+		return this.tryGetRuleContext(0, BlockContext);
+	}
+	public exprStmt(): ExprStmtContext | undefined {
+		return this.tryGetRuleContext(0, ExprStmtContext);
+	}
+	public emptyStmt(): EmptyStmtContext | undefined {
+		return this.tryGetRuleContext(0, EmptyStmtContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_statement; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitStatement) {
+			return visitor.visitStatement(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ReturnStmtContext extends ParserRuleContext {
+	public RETURN(): TerminalNode { return this.getToken(TSQLParser.RETURN, 0); }
+	public expression(): ExpressionContext | undefined {
+		return this.tryGetRuleContext(0, ExpressionContext);
+	}
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_returnStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitReturnStmt) {
+			return visitor.visitReturnStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ThrowStmtContext extends ParserRuleContext {
+	public THROW(): TerminalNode { return this.getToken(TSQLParser.THROW, 0); }
+	public expression(): ExpressionContext | undefined {
+		return this.tryGetRuleContext(0, ExpressionContext);
+	}
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_throwStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitThrowStmt) {
+			return visitor.visitThrowStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class CatchBlockContext extends ParserRuleContext {
+	public _catchVar!: IdentifierContext;
+	public _catchType!: IdentifierContext;
+	public _catchStmt!: BlockContext;
+	public CATCH(): TerminalNode { return this.getToken(TSQLParser.CATCH, 0); }
+	public block(): BlockContext {
+		return this.getRuleContext(0, BlockContext);
+	}
+	public LPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RPAREN, 0); }
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public COLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_catchBlock; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitCatchBlock) {
+			return visitor.visitCatchBlock(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TryCatchStmtContext extends ParserRuleContext {
+	public _tryStmt!: BlockContext;
+	public _finallyStmt!: BlockContext;
+	public TRY(): TerminalNode { return this.getToken(TSQLParser.TRY, 0); }
+	public block(): BlockContext[];
+	public block(i: number): BlockContext;
+	public block(i?: number): BlockContext | BlockContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(BlockContext);
+		} else {
+			return this.getRuleContext(i, BlockContext);
+		}
+	}
+	public catchBlock(): CatchBlockContext[];
+	public catchBlock(i: number): CatchBlockContext;
+	public catchBlock(i?: number): CatchBlockContext | CatchBlockContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(CatchBlockContext);
+		} else {
+			return this.getRuleContext(i, CatchBlockContext);
+		}
+	}
+	public FINALLY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FINALLY, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tryCatchStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTryCatchStmt) {
+			return visitor.visitTryCatchStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class IfStmtContext extends ParserRuleContext {
+	public IF(): TerminalNode { return this.getToken(TSQLParser.IF, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public expression(): ExpressionContext {
+		return this.getRuleContext(0, ExpressionContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public statement(): StatementContext[];
+	public statement(i: number): StatementContext;
+	public statement(i?: number): StatementContext | StatementContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(StatementContext);
+		} else {
+			return this.getRuleContext(i, StatementContext);
+		}
+	}
+	public ELSE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ELSE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_ifStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitIfStmt) {
+			return visitor.visitIfStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WhileStmtContext extends ParserRuleContext {
+	public WHILE(): TerminalNode { return this.getToken(TSQLParser.WHILE, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public expression(): ExpressionContext {
+		return this.getRuleContext(0, ExpressionContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public statement(): StatementContext {
+		return this.getRuleContext(0, StatementContext);
+	}
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_whileStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWhileStmt) {
+			return visitor.visitWhileStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ForStmtContext extends ParserRuleContext {
+	public _initializerVarDeclr!: VarDeclContext;
+	public _initializerVarAssignment!: VarAssignmentContext;
+	public _initializerExpression!: ExpressionContext;
+	public _condition!: ExpressionContext;
+	public _incrementVarDeclr!: VarDeclContext;
+	public _incrementVarAssignment!: VarAssignmentContext;
+	public _incrementExpression!: ExpressionContext;
+	public FOR(): TerminalNode { return this.getToken(TSQLParser.FOR, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public SEMICOLON(): TerminalNode[];
+	public SEMICOLON(i: number): TerminalNode;
+	public SEMICOLON(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.SEMICOLON);
+		} else {
+			return this.getToken(TSQLParser.SEMICOLON, i);
+		}
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public statement(): StatementContext {
+		return this.getRuleContext(0, StatementContext);
+	}
+	public varDecl(): VarDeclContext[];
+	public varDecl(i: number): VarDeclContext;
+	public varDecl(i?: number): VarDeclContext | VarDeclContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(VarDeclContext);
+		} else {
+			return this.getRuleContext(i, VarDeclContext);
+		}
+	}
+	public varAssignment(): VarAssignmentContext[];
+	public varAssignment(i: number): VarAssignmentContext;
+	public varAssignment(i?: number): VarAssignmentContext | VarAssignmentContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(VarAssignmentContext);
+		} else {
+			return this.getRuleContext(i, VarAssignmentContext);
+		}
+	}
+	public expression(): ExpressionContext[];
+	public expression(i: number): ExpressionContext;
+	public expression(i?: number): ExpressionContext | ExpressionContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ExpressionContext);
+		} else {
+			return this.getRuleContext(i, ExpressionContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_forStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitForStmt) {
+			return visitor.visitForStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ForInStmtContext extends ParserRuleContext {
+	public FOR(): TerminalNode { return this.getToken(TSQLParser.FOR, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public LET(): TerminalNode { return this.getToken(TSQLParser.LET, 0); }
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public IN(): TerminalNode { return this.getToken(TSQLParser.IN, 0); }
+	public expression(): ExpressionContext {
+		return this.getRuleContext(0, ExpressionContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public statement(): StatementContext {
+		return this.getRuleContext(0, StatementContext);
+	}
+	public COMMA(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COMMA, 0); }
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_forInStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitForInStmt) {
+			return visitor.visitForInStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class FuncStmtContext extends ParserRuleContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public block(): BlockContext {
+		return this.getRuleContext(0, BlockContext);
+	}
+	public FN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FN, 0); }
+	public FUN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FUN, 0); }
+	public identifierList(): IdentifierListContext | undefined {
+		return this.tryGetRuleContext(0, IdentifierListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_funcStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFuncStmt) {
+			return visitor.visitFuncStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class VarAssignmentContext extends ParserRuleContext {
+	public expression(): ExpressionContext[];
+	public expression(i: number): ExpressionContext;
+	public expression(i?: number): ExpressionContext | ExpressionContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ExpressionContext);
+		} else {
+			return this.getRuleContext(i, ExpressionContext);
+		}
+	}
+	public COLON(): TerminalNode { return this.getToken(TSQLParser.COLON, 0); }
+	public EQ_SINGLE(): TerminalNode { return this.getToken(TSQLParser.EQ_SINGLE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_varAssignment; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitVarAssignment) {
+			return visitor.visitVarAssignment(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ExprStmtContext extends ParserRuleContext {
+	public expression(): ExpressionContext {
+		return this.getRuleContext(0, ExpressionContext);
+	}
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_exprStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitExprStmt) {
+			return visitor.visitExprStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class EmptyStmtContext extends ParserRuleContext {
+	public SEMICOLON(): TerminalNode { return this.getToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_emptyStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitEmptyStmt) {
+			return visitor.visitEmptyStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class BlockContext extends ParserRuleContext {
+	public LBRACE(): TerminalNode { return this.getToken(TSQLParser.LBRACE, 0); }
+	public RBRACE(): TerminalNode { return this.getToken(TSQLParser.RBRACE, 0); }
+	public declaration(): DeclarationContext[];
+	public declaration(i: number): DeclarationContext;
+	public declaration(i?: number): DeclarationContext | DeclarationContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(DeclarationContext);
+		} else {
+			return this.getRuleContext(i, DeclarationContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_block; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitBlock) {
+			return visitor.visitBlock(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class KvPairContext extends ParserRuleContext {
+	public expression(): ExpressionContext[];
+	public expression(i: number): ExpressionContext;
+	public expression(i?: number): ExpressionContext | ExpressionContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ExpressionContext);
+		} else {
+			return this.getRuleContext(i, ExpressionContext);
+		}
+	}
+	public COLON(): TerminalNode { return this.getToken(TSQLParser.COLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_kvPair; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitKvPair) {
+			return visitor.visitKvPair(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class KvPairListContext extends ParserRuleContext {
+	public kvPair(): KvPairContext[];
+	public kvPair(i: number): KvPairContext;
+	public kvPair(i?: number): KvPairContext | KvPairContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(KvPairContext);
+		} else {
+			return this.getRuleContext(i, KvPairContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_kvPairList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitKvPairList) {
+			return visitor.visitKvPairList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SelectContext extends ParserRuleContext {
+	public EOF(): TerminalNode { return this.getToken(TSQLParser.EOF, 0); }
+	public selectSetStmt(): SelectSetStmtContext | undefined {
+		return this.tryGetRuleContext(0, SelectSetStmtContext);
+	}
+	public selectStmt(): SelectStmtContext | undefined {
+		return this.tryGetRuleContext(0, SelectStmtContext);
+	}
+	public tSQLxTagElement(): TSQLxTagElementContext | undefined {
+		return this.tryGetRuleContext(0, TSQLxTagElementContext);
+	}
+	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMICOLON, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_select; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSelect) {
+			return visitor.visitSelect(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SelectStmtWithParensContext extends ParserRuleContext {
+	public selectStmt(): SelectStmtContext | undefined {
+		return this.tryGetRuleContext(0, SelectStmtContext);
+	}
+	public LPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LPAREN, 0); }
+	public selectSetStmt(): SelectSetStmtContext | undefined {
+		return this.tryGetRuleContext(0, SelectSetStmtContext);
+	}
+	public RPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RPAREN, 0); }
+	public placeholder(): PlaceholderContext | undefined {
+		return this.tryGetRuleContext(0, PlaceholderContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_selectStmtWithParens; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSelectStmtWithParens) {
+			return visitor.visitSelectStmtWithParens(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SubsequentSelectSetClauseContext extends ParserRuleContext {
+	public selectStmtWithParens(): SelectStmtWithParensContext {
+		return this.getRuleContext(0, SelectStmtWithParensContext);
+	}
+	public EXCEPT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EXCEPT, 0); }
+	public UNION(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.UNION, 0); }
+	public ALL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ALL, 0); }
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	public INTERSECT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INTERSECT, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_subsequentSelectSetClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSubsequentSelectSetClause) {
+			return visitor.visitSubsequentSelectSetClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SelectSetStmtContext extends ParserRuleContext {
+	public selectStmtWithParens(): SelectStmtWithParensContext {
+		return this.getRuleContext(0, SelectStmtWithParensContext);
+	}
+	public subsequentSelectSetClause(): SubsequentSelectSetClauseContext[];
+	public subsequentSelectSetClause(i: number): SubsequentSelectSetClauseContext;
+	public subsequentSelectSetClause(i?: number): SubsequentSelectSetClauseContext | SubsequentSelectSetClauseContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(SubsequentSelectSetClauseContext);
+		} else {
+			return this.getRuleContext(i, SubsequentSelectSetClauseContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_selectSetStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSelectSetStmt) {
+			return visitor.visitSelectSetStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SelectStmtContext extends ParserRuleContext {
+	public _with!: WithClauseContext;
+	public _columns!: ColumnExprListContext;
+	public _from!: FromClauseContext;
+	public _where!: WhereClauseContext;
+	public SELECT(): TerminalNode { return this.getToken(TSQLParser.SELECT, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	public topClause(): TopClauseContext | undefined {
+		return this.tryGetRuleContext(0, TopClauseContext);
+	}
+	public arrayJoinClause(): ArrayJoinClauseContext | undefined {
+		return this.tryGetRuleContext(0, ArrayJoinClauseContext);
+	}
+	public prewhereClause(): PrewhereClauseContext | undefined {
+		return this.tryGetRuleContext(0, PrewhereClauseContext);
+	}
+	public groupByClause(): GroupByClauseContext | undefined {
+		return this.tryGetRuleContext(0, GroupByClauseContext);
+	}
+	public WITH(): TerminalNode[];
+	public WITH(i: number): TerminalNode;
+	public WITH(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.WITH);
+		} else {
+			return this.getToken(TSQLParser.WITH, i);
+		}
+	}
+	public TOTALS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TOTALS, 0); }
+	public havingClause(): HavingClauseContext | undefined {
+		return this.tryGetRuleContext(0, HavingClauseContext);
+	}
+	public windowClause(): WindowClauseContext | undefined {
+		return this.tryGetRuleContext(0, WindowClauseContext);
+	}
+	public orderByClause(): OrderByClauseContext | undefined {
+		return this.tryGetRuleContext(0, OrderByClauseContext);
+	}
+	public limitByClause(): LimitByClauseContext | undefined {
+		return this.tryGetRuleContext(0, LimitByClauseContext);
+	}
+	public limitAndOffsetClause(): LimitAndOffsetClauseContext | undefined {
+		return this.tryGetRuleContext(0, LimitAndOffsetClauseContext);
+	}
+	public offsetOnlyClause(): OffsetOnlyClauseContext | undefined {
+		return this.tryGetRuleContext(0, OffsetOnlyClauseContext);
+	}
+	public settingsClause(): SettingsClauseContext | undefined {
+		return this.tryGetRuleContext(0, SettingsClauseContext);
+	}
+	public withClause(): WithClauseContext | undefined {
+		return this.tryGetRuleContext(0, WithClauseContext);
+	}
+	public fromClause(): FromClauseContext | undefined {
+		return this.tryGetRuleContext(0, FromClauseContext);
+	}
+	public whereClause(): WhereClauseContext | undefined {
+		return this.tryGetRuleContext(0, WhereClauseContext);
+	}
+	public CUBE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CUBE, 0); }
+	public ROLLUP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROLLUP, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_selectStmt; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSelectStmt) {
+			return visitor.visitSelectStmt(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WithClauseContext extends ParserRuleContext {
+	public WITH(): TerminalNode { return this.getToken(TSQLParser.WITH, 0); }
+	public withExprList(): WithExprListContext {
+		return this.getRuleContext(0, WithExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_withClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWithClause) {
+			return visitor.visitWithClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TopClauseContext extends ParserRuleContext {
+	public TOP(): TerminalNode { return this.getToken(TSQLParser.TOP, 0); }
+	public DECIMAL_LITERAL(): TerminalNode { return this.getToken(TSQLParser.DECIMAL_LITERAL, 0); }
+	public WITH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WITH, 0); }
+	public TIES(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TIES, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_topClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTopClause) {
+			return visitor.visitTopClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class FromClauseContext extends ParserRuleContext {
+	public FROM(): TerminalNode { return this.getToken(TSQLParser.FROM, 0); }
+	public joinExpr(): JoinExprContext {
+		return this.getRuleContext(0, JoinExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_fromClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFromClause) {
+			return visitor.visitFromClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ArrayJoinClauseContext extends ParserRuleContext {
+	public ARRAY(): TerminalNode { return this.getToken(TSQLParser.ARRAY, 0); }
+	public JOIN(): TerminalNode { return this.getToken(TSQLParser.JOIN, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	public LEFT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LEFT, 0); }
+	public INNER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INNER, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_arrayJoinClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitArrayJoinClause) {
+			return visitor.visitArrayJoinClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WindowClauseContext extends ParserRuleContext {
+	public WINDOW(): TerminalNode { return this.getToken(TSQLParser.WINDOW, 0); }
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public AS(): TerminalNode[];
+	public AS(i: number): TerminalNode;
+	public AS(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.AS);
+		} else {
+			return this.getToken(TSQLParser.AS, i);
+		}
+	}
+	public LPAREN(): TerminalNode[];
+	public LPAREN(i: number): TerminalNode;
+	public LPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.LPAREN);
+		} else {
+			return this.getToken(TSQLParser.LPAREN, i);
+		}
+	}
+	public windowExpr(): WindowExprContext[];
+	public windowExpr(i: number): WindowExprContext;
+	public windowExpr(i?: number): WindowExprContext | WindowExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(WindowExprContext);
+		} else {
+			return this.getRuleContext(i, WindowExprContext);
+		}
+	}
+	public RPAREN(): TerminalNode[];
+	public RPAREN(i: number): TerminalNode;
+	public RPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.RPAREN);
+		} else {
+			return this.getToken(TSQLParser.RPAREN, i);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_windowClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWindowClause) {
+			return visitor.visitWindowClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class PrewhereClauseContext extends ParserRuleContext {
+	public PREWHERE(): TerminalNode { return this.getToken(TSQLParser.PREWHERE, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_prewhereClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitPrewhereClause) {
+			return visitor.visitPrewhereClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WhereClauseContext extends ParserRuleContext {
+	public WHERE(): TerminalNode { return this.getToken(TSQLParser.WHERE, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_whereClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWhereClause) {
+			return visitor.visitWhereClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class GroupByClauseContext extends ParserRuleContext {
+	public GROUP(): TerminalNode { return this.getToken(TSQLParser.GROUP, 0); }
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public LPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LPAREN, 0); }
+	public columnExprList(): ColumnExprListContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprListContext);
+	}
+	public RPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RPAREN, 0); }
+	public CUBE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CUBE, 0); }
+	public ROLLUP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROLLUP, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_groupByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitGroupByClause) {
+			return visitor.visitGroupByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class HavingClauseContext extends ParserRuleContext {
+	public HAVING(): TerminalNode { return this.getToken(TSQLParser.HAVING, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_havingClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitHavingClause) {
+			return visitor.visitHavingClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class OrderByClauseContext extends ParserRuleContext {
+	public ORDER(): TerminalNode { return this.getToken(TSQLParser.ORDER, 0); }
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public orderExprList(): OrderExprListContext {
+		return this.getRuleContext(0, OrderExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_orderByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitOrderByClause) {
+			return visitor.visitOrderByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ProjectionOrderByClauseContext extends ParserRuleContext {
+	public ORDER(): TerminalNode { return this.getToken(TSQLParser.ORDER, 0); }
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_projectionOrderByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitProjectionOrderByClause) {
+			return visitor.visitProjectionOrderByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class LimitByClauseContext extends ParserRuleContext {
+	public LIMIT(): TerminalNode { return this.getToken(TSQLParser.LIMIT, 0); }
+	public limitExpr(): LimitExprContext {
+		return this.getRuleContext(0, LimitExprContext);
+	}
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_limitByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitLimitByClause) {
+			return visitor.visitLimitByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class LimitAndOffsetClauseContext extends ParserRuleContext {
+	public LIMIT(): TerminalNode { return this.getToken(TSQLParser.LIMIT, 0); }
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public COMMA(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COMMA, 0); }
+	public WITH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WITH, 0); }
+	public TIES(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TIES, 0); }
+	public OFFSET(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OFFSET, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_limitAndOffsetClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitLimitAndOffsetClause) {
+			return visitor.visitLimitAndOffsetClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class OffsetOnlyClauseContext extends ParserRuleContext {
+	public OFFSET(): TerminalNode { return this.getToken(TSQLParser.OFFSET, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_offsetOnlyClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitOffsetOnlyClause) {
+			return visitor.visitOffsetOnlyClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SettingsClauseContext extends ParserRuleContext {
+	public SETTINGS(): TerminalNode { return this.getToken(TSQLParser.SETTINGS, 0); }
+	public settingExprList(): SettingExprListContext {
+		return this.getRuleContext(0, SettingExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_settingsClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSettingsClause) {
+			return visitor.visitSettingsClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class JoinExprContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_joinExpr; }
+	public copyFrom(ctx: JoinExprContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class JoinExprOpContext extends JoinExprContext {
+	public joinExpr(): JoinExprContext[];
+	public joinExpr(i: number): JoinExprContext;
+	public joinExpr(i?: number): JoinExprContext | JoinExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(JoinExprContext);
+		} else {
+			return this.getRuleContext(i, JoinExprContext);
+		}
+	}
+	public JOIN(): TerminalNode { return this.getToken(TSQLParser.JOIN, 0); }
+	public joinConstraintClause(): JoinConstraintClauseContext {
+		return this.getRuleContext(0, JoinConstraintClauseContext);
+	}
+	public joinOp(): JoinOpContext | undefined {
+		return this.tryGetRuleContext(0, JoinOpContext);
+	}
+	constructor(ctx: JoinExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinExprOp) {
+			return visitor.visitJoinExprOp(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class JoinExprCrossOpContext extends JoinExprContext {
+	public joinExpr(): JoinExprContext[];
+	public joinExpr(i: number): JoinExprContext;
+	public joinExpr(i?: number): JoinExprContext | JoinExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(JoinExprContext);
+		} else {
+			return this.getRuleContext(i, JoinExprContext);
+		}
+	}
+	public joinOpCross(): JoinOpCrossContext {
+		return this.getRuleContext(0, JoinOpCrossContext);
+	}
+	constructor(ctx: JoinExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinExprCrossOp) {
+			return visitor.visitJoinExprCrossOp(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class JoinExprTableContext extends JoinExprContext {
+	public tableExpr(): TableExprContext {
+		return this.getRuleContext(0, TableExprContext);
+	}
+	public FINAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FINAL, 0); }
+	public sampleClause(): SampleClauseContext | undefined {
+		return this.tryGetRuleContext(0, SampleClauseContext);
+	}
+	constructor(ctx: JoinExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinExprTable) {
+			return visitor.visitJoinExprTable(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class JoinExprParensContext extends JoinExprContext {
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public joinExpr(): JoinExprContext {
+		return this.getRuleContext(0, JoinExprContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: JoinExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinExprParens) {
+			return visitor.visitJoinExprParens(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class JoinOpContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_joinOp; }
+	public copyFrom(ctx: JoinOpContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class JoinOpInnerContext extends JoinOpContext {
+	public INNER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INNER, 0); }
+	public ALL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ALL, 0); }
+	public ANY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANY, 0); }
+	public ASOF(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASOF, 0); }
+	constructor(ctx: JoinOpContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinOpInner) {
+			return visitor.visitJoinOpInner(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class JoinOpLeftRightContext extends JoinOpContext {
+	public LEFT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LEFT, 0); }
+	public RIGHT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RIGHT, 0); }
+	public OUTER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OUTER, 0); }
+	public SEMI(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMI, 0); }
+	public ALL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ALL, 0); }
+	public ANTI(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANTI, 0); }
+	public ANY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANY, 0); }
+	public ASOF(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASOF, 0); }
+	constructor(ctx: JoinOpContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinOpLeftRight) {
+			return visitor.visitJoinOpLeftRight(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class JoinOpFullContext extends JoinOpContext {
+	public FULL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FULL, 0); }
+	public OUTER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OUTER, 0); }
+	public ALL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ALL, 0); }
+	public ANY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANY, 0); }
+	constructor(ctx: JoinOpContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinOpFull) {
+			return visitor.visitJoinOpFull(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class JoinOpCrossContext extends ParserRuleContext {
+	public CROSS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CROSS, 0); }
+	public JOIN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.JOIN, 0); }
+	public COMMA(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COMMA, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_joinOpCross; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinOpCross) {
+			return visitor.visitJoinOpCross(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class JoinConstraintClauseContext extends ParserRuleContext {
+	public ON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ON, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	public USING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.USING, 0); }
+	public LPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RPAREN, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_joinConstraintClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitJoinConstraintClause) {
+			return visitor.visitJoinConstraintClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SampleClauseContext extends ParserRuleContext {
+	public SAMPLE(): TerminalNode { return this.getToken(TSQLParser.SAMPLE, 0); }
+	public ratioExpr(): RatioExprContext[];
+	public ratioExpr(i: number): RatioExprContext;
+	public ratioExpr(i?: number): RatioExprContext | RatioExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(RatioExprContext);
+		} else {
+			return this.getRuleContext(i, RatioExprContext);
+		}
+	}
+	public OFFSET(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OFFSET, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_sampleClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSampleClause) {
+			return visitor.visitSampleClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class LimitExprContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public COMMA(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COMMA, 0); }
+	public OFFSET(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OFFSET, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_limitExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitLimitExpr) {
+			return visitor.visitLimitExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class OrderExprListContext extends ParserRuleContext {
+	public orderExpr(): OrderExprContext[];
+	public orderExpr(i: number): OrderExprContext;
+	public orderExpr(i?: number): OrderExprContext | OrderExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(OrderExprContext);
+		} else {
+			return this.getRuleContext(i, OrderExprContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_orderExprList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitOrderExprList) {
+			return visitor.visitOrderExprList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class OrderExprContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public NULLS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NULLS, 0); }
+	public COLLATE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COLLATE, 0); }
+	public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_LITERAL, 0); }
+	public ASCENDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASCENDING, 0); }
+	public DESCENDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DESCENDING, 0); }
+	public DESC(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DESC, 0); }
+	public FIRST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FIRST, 0); }
+	public LAST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LAST, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_orderExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitOrderExpr) {
+			return visitor.visitOrderExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class RatioExprContext extends ParserRuleContext {
+	public placeholder(): PlaceholderContext | undefined {
+		return this.tryGetRuleContext(0, PlaceholderContext);
+	}
+	public numberLiteral(): NumberLiteralContext[];
+	public numberLiteral(i: number): NumberLiteralContext;
+	public numberLiteral(i?: number): NumberLiteralContext | NumberLiteralContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(NumberLiteralContext);
+		} else {
+			return this.getRuleContext(i, NumberLiteralContext);
+		}
+	}
+	public SLASH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SLASH, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_ratioExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitRatioExpr) {
+			return visitor.visitRatioExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SettingExprListContext extends ParserRuleContext {
+	public settingExpr(): SettingExprContext[];
+	public settingExpr(i: number): SettingExprContext;
+	public settingExpr(i?: number): SettingExprContext | SettingExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(SettingExprContext);
+		} else {
+			return this.getRuleContext(i, SettingExprContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_settingExprList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSettingExprList) {
+			return visitor.visitSettingExprList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class SettingExprContext extends ParserRuleContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public EQ_SINGLE(): TerminalNode { return this.getToken(TSQLParser.EQ_SINGLE, 0); }
+	public literal(): LiteralContext {
+		return this.getRuleContext(0, LiteralContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_settingExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitSettingExpr) {
+			return visitor.visitSettingExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WindowExprContext extends ParserRuleContext {
+	public winPartitionByClause(): WinPartitionByClauseContext | undefined {
+		return this.tryGetRuleContext(0, WinPartitionByClauseContext);
+	}
+	public winOrderByClause(): WinOrderByClauseContext | undefined {
+		return this.tryGetRuleContext(0, WinOrderByClauseContext);
+	}
+	public winFrameClause(): WinFrameClauseContext | undefined {
+		return this.tryGetRuleContext(0, WinFrameClauseContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_windowExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWindowExpr) {
+			return visitor.visitWindowExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WinPartitionByClauseContext extends ParserRuleContext {
+	public PARTITION(): TerminalNode { return this.getToken(TSQLParser.PARTITION, 0); }
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_winPartitionByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWinPartitionByClause) {
+			return visitor.visitWinPartitionByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WinOrderByClauseContext extends ParserRuleContext {
+	public ORDER(): TerminalNode { return this.getToken(TSQLParser.ORDER, 0); }
+	public BY(): TerminalNode { return this.getToken(TSQLParser.BY, 0); }
+	public orderExprList(): OrderExprListContext {
+		return this.getRuleContext(0, OrderExprListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_winOrderByClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWinOrderByClause) {
+			return visitor.visitWinOrderByClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WinFrameClauseContext extends ParserRuleContext {
+	public winFrameExtend(): WinFrameExtendContext {
+		return this.getRuleContext(0, WinFrameExtendContext);
+	}
+	public ROWS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROWS, 0); }
+	public RANGE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RANGE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_winFrameClause; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWinFrameClause) {
+			return visitor.visitWinFrameClause(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WinFrameExtendContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_winFrameExtend; }
+	public copyFrom(ctx: WinFrameExtendContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class FrameStartContext extends WinFrameExtendContext {
+	public winFrameBound(): WinFrameBoundContext {
+		return this.getRuleContext(0, WinFrameBoundContext);
+	}
+	constructor(ctx: WinFrameExtendContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFrameStart) {
+			return visitor.visitFrameStart(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class FrameBetweenContext extends WinFrameExtendContext {
+	public BETWEEN(): TerminalNode { return this.getToken(TSQLParser.BETWEEN, 0); }
+	public winFrameBound(): WinFrameBoundContext[];
+	public winFrameBound(i: number): WinFrameBoundContext;
+	public winFrameBound(i?: number): WinFrameBoundContext | WinFrameBoundContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(WinFrameBoundContext);
+		} else {
+			return this.getRuleContext(i, WinFrameBoundContext);
+		}
+	}
+	public AND(): TerminalNode { return this.getToken(TSQLParser.AND, 0); }
+	constructor(ctx: WinFrameExtendContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFrameBetween) {
+			return visitor.visitFrameBetween(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WinFrameBoundContext extends ParserRuleContext {
+	public CURRENT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CURRENT, 0); }
+	public ROW(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROW, 0); }
+	public UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.UNBOUNDED, 0); }
+	public PRECEDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PRECEDING, 0); }
+	public FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FOLLOWING, 0); }
+	public numberLiteral(): NumberLiteralContext | undefined {
+		return this.tryGetRuleContext(0, NumberLiteralContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_winFrameBound; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWinFrameBound) {
+			return visitor.visitWinFrameBound(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ExprContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public EOF(): TerminalNode { return this.getToken(TSQLParser.EOF, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_expr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitExpr) {
+			return visitor.visitExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ColumnTypeExprContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_columnTypeExpr; }
+	public copyFrom(ctx: ColumnTypeExprContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class ColumnTypeExprSimpleContext extends ColumnTypeExprContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	constructor(ctx: ColumnTypeExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnTypeExprSimple) {
+			return visitor.visitColumnTypeExprSimple(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnTypeExprNestedContext extends ColumnTypeExprContext {
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnTypeExpr(): ColumnTypeExprContext[];
+	public columnTypeExpr(i: number): ColumnTypeExprContext;
+	public columnTypeExpr(i?: number): ColumnTypeExprContext | ColumnTypeExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnTypeExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnTypeExprContext);
+		}
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(ctx: ColumnTypeExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnTypeExprNested) {
+			return visitor.visitColumnTypeExprNested(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnTypeExprEnumContext extends ColumnTypeExprContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public enumValue(): EnumValueContext[];
+	public enumValue(i: number): EnumValueContext;
+	public enumValue(i?: number): EnumValueContext | EnumValueContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(EnumValueContext);
+		} else {
+			return this.getRuleContext(i, EnumValueContext);
+		}
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(ctx: ColumnTypeExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnTypeExprEnum) {
+			return visitor.visitColumnTypeExprEnum(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnTypeExprComplexContext extends ColumnTypeExprContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnTypeExpr(): ColumnTypeExprContext[];
+	public columnTypeExpr(i: number): ColumnTypeExprContext;
+	public columnTypeExpr(i?: number): ColumnTypeExprContext | ColumnTypeExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnTypeExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnTypeExprContext);
+		}
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(ctx: ColumnTypeExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnTypeExprComplex) {
+			return visitor.visitColumnTypeExprComplex(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnTypeExprParamContext extends ColumnTypeExprContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public columnExprList(): ColumnExprListContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprListContext);
+	}
+	constructor(ctx: ColumnTypeExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnTypeExprParam) {
+			return visitor.visitColumnTypeExprParam(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ColumnExprListContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_columnExprList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprList) {
+			return visitor.visitColumnExprList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ColumnExprContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_columnExpr; }
+	public copyFrom(ctx: ColumnExprContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class ColumnExprCaseContext extends ColumnExprContext {
+	public _caseExpr!: ColumnExprContext;
+	public _whenExpr!: ColumnExprContext;
+	public _thenExpr!: ColumnExprContext;
+	public _elseExpr!: ColumnExprContext;
+	public CASE(): TerminalNode { return this.getToken(TSQLParser.CASE, 0); }
+	public END(): TerminalNode { return this.getToken(TSQLParser.END, 0); }
+	public WHEN(): TerminalNode[];
+	public WHEN(i: number): TerminalNode;
+	public WHEN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.WHEN);
+		} else {
+			return this.getToken(TSQLParser.WHEN, i);
+		}
+	}
+	public THEN(): TerminalNode[];
+	public THEN(i: number): TerminalNode;
+	public THEN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.THEN);
+		} else {
+			return this.getToken(TSQLParser.THEN, i);
+		}
+	}
+	public ELSE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ELSE, 0); }
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprCase) {
+			return visitor.visitColumnExprCase(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprCastContext extends ColumnExprContext {
+	public CAST(): TerminalNode { return this.getToken(TSQLParser.CAST, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public AS(): TerminalNode { return this.getToken(TSQLParser.AS, 0); }
+	public columnTypeExpr(): ColumnTypeExprContext {
+		return this.getRuleContext(0, ColumnTypeExprContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprCast) {
+			return visitor.visitColumnExprCast(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprDateContext extends ColumnExprContext {
+	public DATE(): TerminalNode { return this.getToken(TSQLParser.DATE, 0); }
+	public STRING_LITERAL(): TerminalNode { return this.getToken(TSQLParser.STRING_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprDate) {
+			return visitor.visitColumnExprDate(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprIntervalStringContext extends ColumnExprContext {
+	public INTERVAL(): TerminalNode { return this.getToken(TSQLParser.INTERVAL, 0); }
+	public STRING_LITERAL(): TerminalNode { return this.getToken(TSQLParser.STRING_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprIntervalString) {
+			return visitor.visitColumnExprIntervalString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprIntervalContext extends ColumnExprContext {
+	public INTERVAL(): TerminalNode { return this.getToken(TSQLParser.INTERVAL, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public interval(): IntervalContext {
+		return this.getRuleContext(0, IntervalContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprInterval) {
+			return visitor.visitColumnExprInterval(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprSubstringContext extends ColumnExprContext {
+	public SUBSTRING(): TerminalNode { return this.getToken(TSQLParser.SUBSTRING, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public FROM(): TerminalNode { return this.getToken(TSQLParser.FROM, 0); }
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public FOR(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FOR, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprSubstring) {
+			return visitor.visitColumnExprSubstring(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTimestampContext extends ColumnExprContext {
+	public TIMESTAMP(): TerminalNode { return this.getToken(TSQLParser.TIMESTAMP, 0); }
+	public STRING_LITERAL(): TerminalNode { return this.getToken(TSQLParser.STRING_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTimestamp) {
+			return visitor.visitColumnExprTimestamp(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTrimContext extends ColumnExprContext {
+	public TRIM(): TerminalNode { return this.getToken(TSQLParser.TRIM, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public string(): StringContext {
+		return this.getRuleContext(0, StringContext);
+	}
+	public FROM(): TerminalNode { return this.getToken(TSQLParser.FROM, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public BOTH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.BOTH, 0); }
+	public LEADING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LEADING, 0); }
+	public TRAILING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TRAILING, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTrim) {
+			return visitor.visitColumnExprTrim(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprWinFunctionContext extends ColumnExprContext {
+	public _columnExprs!: ColumnExprListContext;
+	public _columnArgList!: ColumnExprListContext;
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public OVER(): TerminalNode { return this.getToken(TSQLParser.OVER, 0); }
+	public LPAREN(): TerminalNode[];
+	public LPAREN(i: number): TerminalNode;
+	public LPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.LPAREN);
+		} else {
+			return this.getToken(TSQLParser.LPAREN, i);
+		}
+	}
+	public windowExpr(): WindowExprContext {
+		return this.getRuleContext(0, WindowExprContext);
+	}
+	public RPAREN(): TerminalNode[];
+	public RPAREN(i: number): TerminalNode;
+	public RPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.RPAREN);
+		} else {
+			return this.getToken(TSQLParser.RPAREN, i);
+		}
+	}
+	public columnExprList(): ColumnExprListContext[];
+	public columnExprList(i: number): ColumnExprListContext;
+	public columnExprList(i?: number): ColumnExprListContext | ColumnExprListContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprListContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprListContext);
+		}
+	}
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprWinFunction) {
+			return visitor.visitColumnExprWinFunction(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprWinFunctionTargetContext extends ColumnExprContext {
+	public _columnExprs!: ColumnExprListContext;
+	public _columnArgList!: ColumnExprListContext;
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public OVER(): TerminalNode { return this.getToken(TSQLParser.OVER, 0); }
+	public LPAREN(): TerminalNode[];
+	public LPAREN(i: number): TerminalNode;
+	public LPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.LPAREN);
+		} else {
+			return this.getToken(TSQLParser.LPAREN, i);
+		}
+	}
+	public RPAREN(): TerminalNode[];
+	public RPAREN(i: number): TerminalNode;
+	public RPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.RPAREN);
+		} else {
+			return this.getToken(TSQLParser.RPAREN, i);
+		}
+	}
+	public columnExprList(): ColumnExprListContext[];
+	public columnExprList(i: number): ColumnExprListContext;
+	public columnExprList(i?: number): ColumnExprListContext | ColumnExprListContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprListContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprListContext);
+		}
+	}
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprWinFunctionTarget) {
+			return visitor.visitColumnExprWinFunctionTarget(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprFunctionContext extends ColumnExprContext {
+	public _columnExprs!: ColumnExprListContext;
+	public _columnArgList!: ColumnExprListContext;
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode[];
+	public LPAREN(i: number): TerminalNode;
+	public LPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.LPAREN);
+		} else {
+			return this.getToken(TSQLParser.LPAREN, i);
+		}
+	}
+	public RPAREN(): TerminalNode[];
+	public RPAREN(i: number): TerminalNode;
+	public RPAREN(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.RPAREN);
+		} else {
+			return this.getToken(TSQLParser.RPAREN, i);
+		}
+	}
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	public columnExprList(): ColumnExprListContext[];
+	public columnExprList(i: number): ColumnExprListContext;
+	public columnExprList(i?: number): ColumnExprListContext | ColumnExprListContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprListContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprListContext);
+		}
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprFunction) {
+			return visitor.visitColumnExprFunction(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprCallSelectContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public selectSetStmt(): SelectSetStmtContext {
+		return this.getRuleContext(0, SelectSetStmtContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprCallSelect) {
+			return visitor.visitColumnExprCallSelect(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprCallContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public columnExprList(): ColumnExprListContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprListContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprCall) {
+			return visitor.visitColumnExprCall(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTagElementContext extends ColumnExprContext {
+	public tSQLxTagElement(): TSQLxTagElementContext {
+		return this.getRuleContext(0, TSQLxTagElementContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTagElement) {
+			return visitor.visitColumnExprTagElement(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTemplateStringContext extends ColumnExprContext {
+	public templateString(): TemplateStringContext {
+		return this.getRuleContext(0, TemplateStringContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTemplateString) {
+			return visitor.visitColumnExprTemplateString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprLiteralContext extends ColumnExprContext {
+	public literal(): LiteralContext {
+		return this.getRuleContext(0, LiteralContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprLiteral) {
+			return visitor.visitColumnExprLiteral(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprArrayAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public LBRACKET(): TerminalNode { return this.getToken(TSQLParser.LBRACKET, 0); }
+	public RBRACKET(): TerminalNode { return this.getToken(TSQLParser.RBRACKET, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprArrayAccess) {
+			return visitor.visitColumnExprArrayAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTupleAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public DOT(): TerminalNode { return this.getToken(TSQLParser.DOT, 0); }
+	public DECIMAL_LITERAL(): TerminalNode { return this.getToken(TSQLParser.DECIMAL_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTupleAccess) {
+			return visitor.visitColumnExprTupleAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprPropertyAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public DOT(): TerminalNode { return this.getToken(TSQLParser.DOT, 0); }
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprPropertyAccess) {
+			return visitor.visitColumnExprPropertyAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNullArrayAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public NULL_PROPERTY(): TerminalNode { return this.getToken(TSQLParser.NULL_PROPERTY, 0); }
+	public LBRACKET(): TerminalNode { return this.getToken(TSQLParser.LBRACKET, 0); }
+	public RBRACKET(): TerminalNode { return this.getToken(TSQLParser.RBRACKET, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNullArrayAccess) {
+			return visitor.visitColumnExprNullArrayAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNullTupleAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public NULL_PROPERTY(): TerminalNode { return this.getToken(TSQLParser.NULL_PROPERTY, 0); }
+	public DECIMAL_LITERAL(): TerminalNode { return this.getToken(TSQLParser.DECIMAL_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNullTupleAccess) {
+			return visitor.visitColumnExprNullTupleAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNullPropertyAccessContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public NULL_PROPERTY(): TerminalNode { return this.getToken(TSQLParser.NULL_PROPERTY, 0); }
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNullPropertyAccess) {
+			return visitor.visitColumnExprNullPropertyAccess(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNegateContext extends ColumnExprContext {
+	public DASH(): TerminalNode { return this.getToken(TSQLParser.DASH, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNegate) {
+			return visitor.visitColumnExprNegate(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprPrecedence1Context extends ColumnExprContext {
+	public _left!: ColumnExprContext;
+	public _operator!: Token;
+	public _right!: ColumnExprContext;
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASTERISK, 0); }
+	public SLASH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SLASH, 0); }
+	public PERCENT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PERCENT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprPrecedence1) {
+			return visitor.visitColumnExprPrecedence1(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprPrecedence2Context extends ColumnExprContext {
+	public _left!: ColumnExprContext;
+	public _operator!: Token;
+	public _right!: ColumnExprContext;
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public PLUS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PLUS, 0); }
+	public DASH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DASH, 0); }
+	public CONCAT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CONCAT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprPrecedence2) {
+			return visitor.visitColumnExprPrecedence2(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprPrecedence3Context extends ColumnExprContext {
+	public _left!: ColumnExprContext;
+	public _operator!: Token;
+	public _right!: ColumnExprContext;
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public IN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IN, 0); }
+	public EQ_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EQ_DOUBLE, 0); }
+	public EQ_SINGLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EQ_SINGLE, 0); }
+	public NOT_EQ(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT_EQ, 0); }
+	public LT_EQ(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LT_EQ, 0); }
+	public LT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LT, 0); }
+	public GT_EQ(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.GT_EQ, 0); }
+	public GT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.GT, 0); }
+	public LIKE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LIKE, 0); }
+	public ILIKE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ILIKE, 0); }
+	public REGEX_SINGLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.REGEX_SINGLE, 0); }
+	public REGEX_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.REGEX_DOUBLE, 0); }
+	public NOT_REGEX(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT_REGEX, 0); }
+	public IREGEX_SINGLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IREGEX_SINGLE, 0); }
+	public IREGEX_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IREGEX_DOUBLE, 0); }
+	public NOT_IREGEX(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT_IREGEX, 0); }
+	public COHORT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COHORT, 0); }
+	public NOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprPrecedence3) {
+			return visitor.visitColumnExprPrecedence3(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprIsNullContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public IS(): TerminalNode { return this.getToken(TSQLParser.IS, 0); }
+	public NULL_SQL(): TerminalNode { return this.getToken(TSQLParser.NULL_SQL, 0); }
+	public NOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprIsNull) {
+			return visitor.visitColumnExprIsNull(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNullishContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public NULLISH(): TerminalNode { return this.getToken(TSQLParser.NULLISH, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNullish) {
+			return visitor.visitColumnExprNullish(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprNotContext extends ColumnExprContext {
+	public NOT(): TerminalNode { return this.getToken(TSQLParser.NOT, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprNot) {
+			return visitor.visitColumnExprNot(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprAndContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public AND(): TerminalNode { return this.getToken(TSQLParser.AND, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprAnd) {
+			return visitor.visitColumnExprAnd(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprOrContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public OR(): TerminalNode { return this.getToken(TSQLParser.OR, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprOr) {
+			return visitor.visitColumnExprOr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprBetweenContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public BETWEEN(): TerminalNode { return this.getToken(TSQLParser.BETWEEN, 0); }
+	public AND(): TerminalNode { return this.getToken(TSQLParser.AND, 0); }
+	public NOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprBetween) {
+			return visitor.visitColumnExprBetween(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTernaryOpContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public QUERY(): TerminalNode { return this.getToken(TSQLParser.QUERY, 0); }
+	public COLON(): TerminalNode { return this.getToken(TSQLParser.COLON, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTernaryOp) {
+			return visitor.visitColumnExprTernaryOp(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprAliasContext extends ColumnExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public AS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.AS, 0); }
+	public identifier(): IdentifierContext | undefined {
+		return this.tryGetRuleContext(0, IdentifierContext);
+	}
+	public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_LITERAL, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprAlias) {
+			return visitor.visitColumnExprAlias(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprAsteriskContext extends ColumnExprContext {
+	public ASTERISK(): TerminalNode { return this.getToken(TSQLParser.ASTERISK, 0); }
+	public tableIdentifier(): TableIdentifierContext | undefined {
+		return this.tryGetRuleContext(0, TableIdentifierContext);
+	}
+	public DOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DOT, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprAsterisk) {
+			return visitor.visitColumnExprAsterisk(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprSubqueryContext extends ColumnExprContext {
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public selectSetStmt(): SelectSetStmtContext {
+		return this.getRuleContext(0, SelectSetStmtContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprSubquery) {
+			return visitor.visitColumnExprSubquery(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprParensContext extends ColumnExprContext {
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprParens) {
+			return visitor.visitColumnExprParens(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprTupleContext extends ColumnExprContext {
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public columnExprList(): ColumnExprListContext {
+		return this.getRuleContext(0, ColumnExprListContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprTuple) {
+			return visitor.visitColumnExprTuple(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprArrayContext extends ColumnExprContext {
+	public LBRACKET(): TerminalNode { return this.getToken(TSQLParser.LBRACKET, 0); }
+	public RBRACKET(): TerminalNode { return this.getToken(TSQLParser.RBRACKET, 0); }
+	public columnExprList(): ColumnExprListContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprListContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprArray) {
+			return visitor.visitColumnExprArray(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprDictContext extends ColumnExprContext {
+	public LBRACE(): TerminalNode { return this.getToken(TSQLParser.LBRACE, 0); }
+	public RBRACE(): TerminalNode { return this.getToken(TSQLParser.RBRACE, 0); }
+	public kvPairList(): KvPairListContext | undefined {
+		return this.tryGetRuleContext(0, KvPairListContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprDict) {
+			return visitor.visitColumnExprDict(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprLambdaContext extends ColumnExprContext {
+	public columnLambdaExpr(): ColumnLambdaExprContext {
+		return this.getRuleContext(0, ColumnLambdaExprContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprLambda) {
+			return visitor.visitColumnExprLambda(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class ColumnExprIdentifierContext extends ColumnExprContext {
+	public columnIdentifier(): ColumnIdentifierContext {
+		return this.getRuleContext(0, ColumnIdentifierContext);
+	}
+	constructor(ctx: ColumnExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnExprIdentifier) {
+			return visitor.visitColumnExprIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ColumnLambdaExprContext extends ParserRuleContext {
+	public ARROW(): TerminalNode { return this.getToken(TSQLParser.ARROW, 0); }
+	public LPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LPAREN, 0); }
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public RPAREN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RPAREN, 0); }
+	public columnExpr(): ColumnExprContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprContext);
+	}
+	public block(): BlockContext | undefined {
+		return this.tryGetRuleContext(0, BlockContext);
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_columnLambdaExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnLambdaExpr) {
+			return visitor.visitColumnLambdaExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TSQLxChildElementContext extends ParserRuleContext {
+	public tSQLxTagElement(): TSQLxTagElementContext | undefined {
+		return this.tryGetRuleContext(0, TSQLxTagElementContext);
+	}
+	public TSQLX_TEXT_TEXT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TSQLX_TEXT_TEXT, 0); }
+	public LBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LBRACE, 0); }
+	public columnExpr(): ColumnExprContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprContext);
+	}
+	public RBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RBRACE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tSQLxChildElement; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTSQLxChildElement) {
+			return visitor.visitTSQLxChildElement(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TSQLxTagElementContext extends ParserRuleContext {
+	public LT(): TerminalNode { return this.getToken(TSQLParser.LT, 0); }
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public SLASH_GT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SLASH_GT, 0); }
+	public tSQLxTagAttribute(): TSQLxTagAttributeContext[];
+	public tSQLxTagAttribute(i: number): TSQLxTagAttributeContext;
+	public tSQLxTagAttribute(i?: number): TSQLxTagAttributeContext | TSQLxTagAttributeContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(TSQLxTagAttributeContext);
+		} else {
+			return this.getRuleContext(i, TSQLxTagAttributeContext);
+		}
+	}
+	public GT(): TerminalNode[];
+	public GT(i: number): TerminalNode;
+	public GT(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.GT);
+		} else {
+			return this.getToken(TSQLParser.GT, i);
+		}
+	}
+	public LT_SLASH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LT_SLASH, 0); }
+	public tSQLxChildElement(): TSQLxChildElementContext[];
+	public tSQLxChildElement(i: number): TSQLxChildElementContext;
+	public tSQLxChildElement(i?: number): TSQLxChildElementContext | TSQLxChildElementContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(TSQLxChildElementContext);
+		} else {
+			return this.getRuleContext(i, TSQLxChildElementContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tSQLxTagElement; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTSQLxTagElement) {
+			return visitor.visitTSQLxTagElement(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TSQLxTagAttributeContext extends ParserRuleContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public EQ_SINGLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EQ_SINGLE, 0); }
+	public string(): StringContext | undefined {
+		return this.tryGetRuleContext(0, StringContext);
+	}
+	public LBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LBRACE, 0); }
+	public columnExpr(): ColumnExprContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprContext);
+	}
+	public RBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RBRACE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tSQLxTagAttribute; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTSQLxTagAttribute) {
+			return visitor.visitTSQLxTagAttribute(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WithExprListContext extends ParserRuleContext {
+	public withExpr(): WithExprContext[];
+	public withExpr(i: number): WithExprContext;
+	public withExpr(i?: number): WithExprContext | WithExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(WithExprContext);
+		} else {
+			return this.getRuleContext(i, WithExprContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_withExprList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWithExprList) {
+			return visitor.visitWithExprList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class WithExprContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_withExpr; }
+	public copyFrom(ctx: WithExprContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class WithExprSubqueryContext extends WithExprContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public AS(): TerminalNode { return this.getToken(TSQLParser.AS, 0); }
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public selectSetStmt(): SelectSetStmtContext {
+		return this.getRuleContext(0, SelectSetStmtContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: WithExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWithExprSubquery) {
+			return visitor.visitWithExprSubquery(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class WithExprColumnContext extends WithExprContext {
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public AS(): TerminalNode { return this.getToken(TSQLParser.AS, 0); }
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	constructor(ctx: WithExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitWithExprColumn) {
+			return visitor.visitWithExprColumn(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class ColumnIdentifierContext extends ParserRuleContext {
+	public placeholder(): PlaceholderContext | undefined {
+		return this.tryGetRuleContext(0, PlaceholderContext);
+	}
+	public nestedIdentifier(): NestedIdentifierContext | undefined {
+		return this.tryGetRuleContext(0, NestedIdentifierContext);
+	}
+	public tableIdentifier(): TableIdentifierContext | undefined {
+		return this.tryGetRuleContext(0, TableIdentifierContext);
+	}
+	public DOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DOT, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_columnIdentifier; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitColumnIdentifier) {
+			return visitor.visitColumnIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class NestedIdentifierContext extends ParserRuleContext {
+	public identifier(): IdentifierContext[];
+	public identifier(i: number): IdentifierContext;
+	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(IdentifierContext);
+		} else {
+			return this.getRuleContext(i, IdentifierContext);
+		}
+	}
+	public DOT(): TerminalNode[];
+	public DOT(i: number): TerminalNode;
+	public DOT(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.DOT);
+		} else {
+			return this.getToken(TSQLParser.DOT, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_nestedIdentifier; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitNestedIdentifier) {
+			return visitor.visitNestedIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TableExprContext extends ParserRuleContext {
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tableExpr; }
+	public copyFrom(ctx: TableExprContext): void {
+		super.copyFrom(ctx);
+	}
+}
+export class TableExprIdentifierContext extends TableExprContext {
+	public tableIdentifier(): TableIdentifierContext {
+		return this.getRuleContext(0, TableIdentifierContext);
+	}
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprIdentifier) {
+			return visitor.visitTableExprIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TableExprFunctionContext extends TableExprContext {
+	public tableFunctionExpr(): TableFunctionExprContext {
+		return this.getRuleContext(0, TableFunctionExprContext);
+	}
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprFunction) {
+			return visitor.visitTableExprFunction(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TableExprSubqueryContext extends TableExprContext {
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public selectSetStmt(): SelectSetStmtContext {
+		return this.getRuleContext(0, SelectSetStmtContext);
+	}
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprSubquery) {
+			return visitor.visitTableExprSubquery(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TableExprAliasContext extends TableExprContext {
+	public tableExpr(): TableExprContext {
+		return this.getRuleContext(0, TableExprContext);
+	}
+	public alias(): AliasContext | undefined {
+		return this.tryGetRuleContext(0, AliasContext);
+	}
+	public AS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.AS, 0); }
+	public identifier(): IdentifierContext | undefined {
+		return this.tryGetRuleContext(0, IdentifierContext);
+	}
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprAlias) {
+			return visitor.visitTableExprAlias(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TableExprTagContext extends TableExprContext {
+	public tSQLxTagElement(): TSQLxTagElementContext {
+		return this.getRuleContext(0, TSQLxTagElementContext);
+	}
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprTag) {
+			return visitor.visitTableExprTag(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+export class TableExprPlaceholderContext extends TableExprContext {
+	public placeholder(): PlaceholderContext {
+		return this.getRuleContext(0, PlaceholderContext);
+	}
+	constructor(ctx: TableExprContext) {
+		super(ctx.parent, ctx.invokingState);
+		this.copyFrom(ctx);
+	}
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableExprPlaceholder) {
+			return visitor.visitTableExprPlaceholder(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TableFunctionExprContext extends ParserRuleContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	public LPAREN(): TerminalNode { return this.getToken(TSQLParser.LPAREN, 0); }
+	public RPAREN(): TerminalNode { return this.getToken(TSQLParser.RPAREN, 0); }
+	public tableArgList(): TableArgListContext | undefined {
+		return this.tryGetRuleContext(0, TableArgListContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tableFunctionExpr; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableFunctionExpr) {
+			return visitor.visitTableFunctionExpr(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TableIdentifierContext extends ParserRuleContext {
+	public nestedIdentifier(): NestedIdentifierContext {
+		return this.getRuleContext(0, NestedIdentifierContext);
+	}
+	public databaseIdentifier(): DatabaseIdentifierContext | undefined {
+		return this.tryGetRuleContext(0, DatabaseIdentifierContext);
+	}
+	public DOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DOT, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tableIdentifier; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableIdentifier) {
+			return visitor.visitTableIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TableArgListContext extends ParserRuleContext {
+	public columnExpr(): ColumnExprContext[];
+	public columnExpr(i: number): ColumnExprContext;
+	public columnExpr(i?: number): ColumnExprContext | ColumnExprContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(ColumnExprContext);
+		} else {
+			return this.getRuleContext(i, ColumnExprContext);
+		}
+	}
+	public COMMA(): TerminalNode[];
+	public COMMA(i: number): TerminalNode;
+	public COMMA(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.COMMA);
+		} else {
+			return this.getToken(TSQLParser.COMMA, i);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_tableArgList; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTableArgList) {
+			return visitor.visitTableArgList(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class DatabaseIdentifierContext extends ParserRuleContext {
+	public identifier(): IdentifierContext {
+		return this.getRuleContext(0, IdentifierContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_databaseIdentifier; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitDatabaseIdentifier) {
+			return visitor.visitDatabaseIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class FloatingLiteralContext extends ParserRuleContext {
+	public FLOATING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FLOATING_LITERAL, 0); }
+	public DOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DOT, 0); }
+	public DECIMAL_LITERAL(): TerminalNode[];
+	public DECIMAL_LITERAL(i: number): TerminalNode;
+	public DECIMAL_LITERAL(i?: number): TerminalNode | TerminalNode[] {
+		if (i === undefined) {
+			return this.getTokens(TSQLParser.DECIMAL_LITERAL);
+		} else {
+			return this.getToken(TSQLParser.DECIMAL_LITERAL, i);
+		}
+	}
+	public OCTAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OCTAL_LITERAL, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_floatingLiteral; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFloatingLiteral) {
+			return visitor.visitFloatingLiteral(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class NumberLiteralContext extends ParserRuleContext {
+	public floatingLiteral(): FloatingLiteralContext | undefined {
+		return this.tryGetRuleContext(0, FloatingLiteralContext);
+	}
+	public OCTAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OCTAL_LITERAL, 0); }
+	public DECIMAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DECIMAL_LITERAL, 0); }
+	public HEXADECIMAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.HEXADECIMAL_LITERAL, 0); }
+	public INF(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INF, 0); }
+	public NAN_SQL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NAN_SQL, 0); }
+	public PLUS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PLUS, 0); }
+	public DASH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DASH, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_numberLiteral; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitNumberLiteral) {
+			return visitor.visitNumberLiteral(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class LiteralContext extends ParserRuleContext {
+	public numberLiteral(): NumberLiteralContext | undefined {
+		return this.tryGetRuleContext(0, NumberLiteralContext);
+	}
+	public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_LITERAL, 0); }
+	public NULL_SQL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NULL_SQL, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_literal; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitLiteral) {
+			return visitor.visitLiteral(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class IntervalContext extends ParserRuleContext {
+	public SECOND(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SECOND, 0); }
+	public MINUTE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.MINUTE, 0); }
+	public HOUR(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.HOUR, 0); }
+	public DAY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DAY, 0); }
+	public WEEK(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WEEK, 0); }
+	public MONTH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.MONTH, 0); }
+	public QUARTER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.QUARTER, 0); }
+	public YEAR(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.YEAR, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_interval; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitInterval) {
+			return visitor.visitInterval(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class KeywordContext extends ParserRuleContext {
+	public ALL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ALL, 0); }
+	public AND(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.AND, 0); }
+	public ANTI(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANTI, 0); }
+	public ANY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ANY, 0); }
+	public ARRAY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ARRAY, 0); }
+	public AS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.AS, 0); }
+	public ASCENDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASCENDING, 0); }
+	public ASOF(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ASOF, 0); }
+	public BETWEEN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.BETWEEN, 0); }
+	public BOTH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.BOTH, 0); }
+	public BY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.BY, 0); }
+	public CASE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CASE, 0); }
+	public CAST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CAST, 0); }
+	public COHORT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COHORT, 0); }
+	public COLLATE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.COLLATE, 0); }
+	public CROSS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CROSS, 0); }
+	public CUBE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CUBE, 0); }
+	public CURRENT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.CURRENT, 0); }
+	public DATE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DATE, 0); }
+	public DESC(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DESC, 0); }
+	public DESCENDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DESCENDING, 0); }
+	public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DISTINCT, 0); }
+	public ELSE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ELSE, 0); }
+	public END(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.END, 0); }
+	public EXTRACT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.EXTRACT, 0); }
+	public FINAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FINAL, 0); }
+	public FIRST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FIRST, 0); }
+	public FOR(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FOR, 0); }
+	public FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FOLLOWING, 0); }
+	public FROM(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FROM, 0); }
+	public FULL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FULL, 0); }
+	public GROUP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.GROUP, 0); }
+	public HAVING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.HAVING, 0); }
+	public ID(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ID, 0); }
+	public IS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IS, 0); }
+	public IF(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IF, 0); }
+	public ILIKE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ILIKE, 0); }
+	public IN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IN, 0); }
+	public INNER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INNER, 0); }
+	public INTERVAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.INTERVAL, 0); }
+	public JOIN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.JOIN, 0); }
+	public KEY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.KEY, 0); }
+	public LAST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LAST, 0); }
+	public LEADING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LEADING, 0); }
+	public LEFT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LEFT, 0); }
+	public LIKE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LIKE, 0); }
+	public LIMIT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.LIMIT, 0); }
+	public NOT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NOT, 0); }
+	public NULLS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.NULLS, 0); }
+	public OFFSET(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OFFSET, 0); }
+	public ON(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ON, 0); }
+	public OR(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OR, 0); }
+	public ORDER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ORDER, 0); }
+	public OUTER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OUTER, 0); }
+	public OVER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.OVER, 0); }
+	public PARTITION(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PARTITION, 0); }
+	public PRECEDING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PRECEDING, 0); }
+	public PREWHERE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.PREWHERE, 0); }
+	public RANGE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RANGE, 0); }
+	public RETURN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RETURN, 0); }
+	public RIGHT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RIGHT, 0); }
+	public ROLLUP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROLLUP, 0); }
+	public ROW(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROW, 0); }
+	public ROWS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ROWS, 0); }
+	public SAMPLE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SAMPLE, 0); }
+	public SELECT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SELECT, 0); }
+	public SEMI(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SEMI, 0); }
+	public SETTINGS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SETTINGS, 0); }
+	public SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.SUBSTRING, 0); }
+	public THEN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.THEN, 0); }
+	public TIES(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TIES, 0); }
+	public TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TIMESTAMP, 0); }
+	public TOTALS(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TOTALS, 0); }
+	public TRAILING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TRAILING, 0); }
+	public TRIM(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TRIM, 0); }
+	public TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TRUNCATE, 0); }
+	public TO(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TO, 0); }
+	public TOP(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.TOP, 0); }
+	public UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.UNBOUNDED, 0); }
+	public UNION(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.UNION, 0); }
+	public USING(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.USING, 0); }
+	public WHEN(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WHEN, 0); }
+	public WHERE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WHERE, 0); }
+	public WINDOW(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WINDOW, 0); }
+	public WITH(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.WITH, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_keyword; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitKeyword) {
+			return visitor.visitKeyword(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class KeywordForAliasContext extends ParserRuleContext {
+	public DATE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.DATE, 0); }
+	public FIRST(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FIRST, 0); }
+	public ID(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.ID, 0); }
+	public KEY(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.KEY, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_keywordForAlias; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitKeywordForAlias) {
+			return visitor.visitKeywordForAlias(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class AliasContext extends ParserRuleContext {
+	public IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IDENTIFIER, 0); }
+	public keywordForAlias(): KeywordForAliasContext | undefined {
+		return this.tryGetRuleContext(0, KeywordForAliasContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_alias; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitAlias) {
+			return visitor.visitAlias(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class IdentifierContext extends ParserRuleContext {
+	public IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.IDENTIFIER, 0); }
+	public interval(): IntervalContext | undefined {
+		return this.tryGetRuleContext(0, IntervalContext);
+	}
+	public keyword(): KeywordContext | undefined {
+		return this.tryGetRuleContext(0, KeywordContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_identifier; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitIdentifier) {
+			return visitor.visitIdentifier(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class EnumValueContext extends ParserRuleContext {
+	public string(): StringContext {
+		return this.getRuleContext(0, StringContext);
+	}
+	public EQ_SINGLE(): TerminalNode { return this.getToken(TSQLParser.EQ_SINGLE, 0); }
+	public numberLiteral(): NumberLiteralContext {
+		return this.getRuleContext(0, NumberLiteralContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_enumValue; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitEnumValue) {
+			return visitor.visitEnumValue(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class PlaceholderContext extends ParserRuleContext {
+	public LBRACE(): TerminalNode { return this.getToken(TSQLParser.LBRACE, 0); }
+	public columnExpr(): ColumnExprContext {
+		return this.getRuleContext(0, ColumnExprContext);
+	}
+	public RBRACE(): TerminalNode { return this.getToken(TSQLParser.RBRACE, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_placeholder; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitPlaceholder) {
+			return visitor.visitPlaceholder(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class StringContext extends ParserRuleContext {
+	public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_LITERAL, 0); }
+	public templateString(): TemplateStringContext | undefined {
+		return this.tryGetRuleContext(0, TemplateStringContext);
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_string; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitString) {
+			return visitor.visitString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class TemplateStringContext extends ParserRuleContext {
+	public QUOTE_SINGLE_TEMPLATE(): TerminalNode { return this.getToken(TSQLParser.QUOTE_SINGLE_TEMPLATE, 0); }
+	public QUOTE_SINGLE(): TerminalNode { return this.getToken(TSQLParser.QUOTE_SINGLE, 0); }
+	public stringContents(): StringContentsContext[];
+	public stringContents(i: number): StringContentsContext;
+	public stringContents(i?: number): StringContentsContext | StringContentsContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(StringContentsContext);
+		} else {
+			return this.getRuleContext(i, StringContentsContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_templateString; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitTemplateString) {
+			return visitor.visitTemplateString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class StringContentsContext extends ParserRuleContext {
+	public STRING_ESCAPE_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_ESCAPE_TRIGGER, 0); }
+	public columnExpr(): ColumnExprContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprContext);
+	}
+	public RBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RBRACE, 0); }
+	public STRING_TEXT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.STRING_TEXT, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_stringContents; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitStringContents) {
+			return visitor.visitStringContents(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class FullTemplateStringContext extends ParserRuleContext {
+	public QUOTE_SINGLE_TEMPLATE_FULL(): TerminalNode { return this.getToken(TSQLParser.QUOTE_SINGLE_TEMPLATE_FULL, 0); }
+	public EOF(): TerminalNode { return this.getToken(TSQLParser.EOF, 0); }
+	public stringContentsFull(): StringContentsFullContext[];
+	public stringContentsFull(i: number): StringContentsFullContext;
+	public stringContentsFull(i?: number): StringContentsFullContext | StringContentsFullContext[] {
+		if (i === undefined) {
+			return this.getRuleContexts(StringContentsFullContext);
+		} else {
+			return this.getRuleContext(i, StringContentsFullContext);
+		}
+	}
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_fullTemplateString; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitFullTemplateString) {
+			return visitor.visitFullTemplateString(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
+export class StringContentsFullContext extends ParserRuleContext {
+	public FULL_STRING_ESCAPE_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FULL_STRING_ESCAPE_TRIGGER, 0); }
+	public columnExpr(): ColumnExprContext | undefined {
+		return this.tryGetRuleContext(0, ColumnExprContext);
+	}
+	public RBRACE(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.RBRACE, 0); }
+	public FULL_STRING_TEXT(): TerminalNode | undefined { return this.tryGetToken(TSQLParser.FULL_STRING_TEXT, 0); }
+	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
+		super(parent, invokingState);
+	}
+	// @Override
+	public get ruleIndex(): number { return TSQLParser.RULE_stringContentsFull; }
+	// @Override
+	public accept<Result>(visitor: TSQLParserVisitor<Result>): Result {
+		if (visitor.visitStringContentsFull) {
+			return visitor.visitStringContentsFull(this);
+		} else {
+			return visitor.visitChildren(this);
+		}
+	}
+}
+
+
diff --git a/internal-packages/tsql/src/grammar/TSQLParserVisitor.ts b/internal-packages/tsql/src/grammar/TSQLParserVisitor.ts
new file mode 100644
index 00000000000..a562330bc58
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/TSQLParserVisitor.ts
@@ -0,0 +1,1312 @@
+// Generated from src/grammar/TSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT
+
+
+import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
+
+import { JoinOpInnerContext } from "./TSQLParser";
+import { JoinOpLeftRightContext } from "./TSQLParser";
+import { JoinOpFullContext } from "./TSQLParser";
+import { ColumnExprCaseContext } from "./TSQLParser";
+import { ColumnExprCastContext } from "./TSQLParser";
+import { ColumnExprDateContext } from "./TSQLParser";
+import { ColumnExprIntervalStringContext } from "./TSQLParser";
+import { ColumnExprIntervalContext } from "./TSQLParser";
+import { ColumnExprSubstringContext } from "./TSQLParser";
+import { ColumnExprTimestampContext } from "./TSQLParser";
+import { ColumnExprTrimContext } from "./TSQLParser";
+import { ColumnExprWinFunctionContext } from "./TSQLParser";
+import { ColumnExprWinFunctionTargetContext } from "./TSQLParser";
+import { ColumnExprFunctionContext } from "./TSQLParser";
+import { ColumnExprCallSelectContext } from "./TSQLParser";
+import { ColumnExprCallContext } from "./TSQLParser";
+import { ColumnExprTagElementContext } from "./TSQLParser";
+import { ColumnExprTemplateStringContext } from "./TSQLParser";
+import { ColumnExprLiteralContext } from "./TSQLParser";
+import { ColumnExprArrayAccessContext } from "./TSQLParser";
+import { ColumnExprTupleAccessContext } from "./TSQLParser";
+import { ColumnExprPropertyAccessContext } from "./TSQLParser";
+import { ColumnExprNullArrayAccessContext } from "./TSQLParser";
+import { ColumnExprNullTupleAccessContext } from "./TSQLParser";
+import { ColumnExprNullPropertyAccessContext } from "./TSQLParser";
+import { ColumnExprNegateContext } from "./TSQLParser";
+import { ColumnExprPrecedence1Context } from "./TSQLParser";
+import { ColumnExprPrecedence2Context } from "./TSQLParser";
+import { ColumnExprPrecedence3Context } from "./TSQLParser";
+import { ColumnExprIsNullContext } from "./TSQLParser";
+import { ColumnExprNullishContext } from "./TSQLParser";
+import { ColumnExprNotContext } from "./TSQLParser";
+import { ColumnExprAndContext } from "./TSQLParser";
+import { ColumnExprOrContext } from "./TSQLParser";
+import { ColumnExprBetweenContext } from "./TSQLParser";
+import { ColumnExprTernaryOpContext } from "./TSQLParser";
+import { ColumnExprAliasContext } from "./TSQLParser";
+import { ColumnExprAsteriskContext } from "./TSQLParser";
+import { ColumnExprSubqueryContext } from "./TSQLParser";
+import { ColumnExprParensContext } from "./TSQLParser";
+import { ColumnExprTupleContext } from "./TSQLParser";
+import { ColumnExprArrayContext } from "./TSQLParser";
+import { ColumnExprDictContext } from "./TSQLParser";
+import { ColumnExprLambdaContext } from "./TSQLParser";
+import { ColumnExprIdentifierContext } from "./TSQLParser";
+import { TableExprIdentifierContext } from "./TSQLParser";
+import { TableExprFunctionContext } from "./TSQLParser";
+import { TableExprSubqueryContext } from "./TSQLParser";
+import { TableExprAliasContext } from "./TSQLParser";
+import { TableExprTagContext } from "./TSQLParser";
+import { TableExprPlaceholderContext } from "./TSQLParser";
+import { WithExprSubqueryContext } from "./TSQLParser";
+import { WithExprColumnContext } from "./TSQLParser";
+import { JoinExprOpContext } from "./TSQLParser";
+import { JoinExprCrossOpContext } from "./TSQLParser";
+import { JoinExprTableContext } from "./TSQLParser";
+import { JoinExprParensContext } from "./TSQLParser";
+import { FrameStartContext } from "./TSQLParser";
+import { FrameBetweenContext } from "./TSQLParser";
+import { ColumnTypeExprSimpleContext } from "./TSQLParser";
+import { ColumnTypeExprNestedContext } from "./TSQLParser";
+import { ColumnTypeExprEnumContext } from "./TSQLParser";
+import { ColumnTypeExprComplexContext } from "./TSQLParser";
+import { ColumnTypeExprParamContext } from "./TSQLParser";
+import { ProgramContext } from "./TSQLParser";
+import { DeclarationContext } from "./TSQLParser";
+import { ExpressionContext } from "./TSQLParser";
+import { VarDeclContext } from "./TSQLParser";
+import { IdentifierListContext } from "./TSQLParser";
+import { StatementContext } from "./TSQLParser";
+import { ReturnStmtContext } from "./TSQLParser";
+import { ThrowStmtContext } from "./TSQLParser";
+import { CatchBlockContext } from "./TSQLParser";
+import { TryCatchStmtContext } from "./TSQLParser";
+import { IfStmtContext } from "./TSQLParser";
+import { WhileStmtContext } from "./TSQLParser";
+import { ForStmtContext } from "./TSQLParser";
+import { ForInStmtContext } from "./TSQLParser";
+import { FuncStmtContext } from "./TSQLParser";
+import { VarAssignmentContext } from "./TSQLParser";
+import { ExprStmtContext } from "./TSQLParser";
+import { EmptyStmtContext } from "./TSQLParser";
+import { BlockContext } from "./TSQLParser";
+import { KvPairContext } from "./TSQLParser";
+import { KvPairListContext } from "./TSQLParser";
+import { SelectContext } from "./TSQLParser";
+import { SelectStmtWithParensContext } from "./TSQLParser";
+import { SubsequentSelectSetClauseContext } from "./TSQLParser";
+import { SelectSetStmtContext } from "./TSQLParser";
+import { SelectStmtContext } from "./TSQLParser";
+import { WithClauseContext } from "./TSQLParser";
+import { TopClauseContext } from "./TSQLParser";
+import { FromClauseContext } from "./TSQLParser";
+import { ArrayJoinClauseContext } from "./TSQLParser";
+import { WindowClauseContext } from "./TSQLParser";
+import { PrewhereClauseContext } from "./TSQLParser";
+import { WhereClauseContext } from "./TSQLParser";
+import { GroupByClauseContext } from "./TSQLParser";
+import { HavingClauseContext } from "./TSQLParser";
+import { OrderByClauseContext } from "./TSQLParser";
+import { ProjectionOrderByClauseContext } from "./TSQLParser";
+import { LimitByClauseContext } from "./TSQLParser";
+import { LimitAndOffsetClauseContext } from "./TSQLParser";
+import { OffsetOnlyClauseContext } from "./TSQLParser";
+import { SettingsClauseContext } from "./TSQLParser";
+import { JoinExprContext } from "./TSQLParser";
+import { JoinOpContext } from "./TSQLParser";
+import { JoinOpCrossContext } from "./TSQLParser";
+import { JoinConstraintClauseContext } from "./TSQLParser";
+import { SampleClauseContext } from "./TSQLParser";
+import { LimitExprContext } from "./TSQLParser";
+import { OrderExprListContext } from "./TSQLParser";
+import { OrderExprContext } from "./TSQLParser";
+import { RatioExprContext } from "./TSQLParser";
+import { SettingExprListContext } from "./TSQLParser";
+import { SettingExprContext } from "./TSQLParser";
+import { WindowExprContext } from "./TSQLParser";
+import { WinPartitionByClauseContext } from "./TSQLParser";
+import { WinOrderByClauseContext } from "./TSQLParser";
+import { WinFrameClauseContext } from "./TSQLParser";
+import { WinFrameExtendContext } from "./TSQLParser";
+import { WinFrameBoundContext } from "./TSQLParser";
+import { ExprContext } from "./TSQLParser";
+import { ColumnTypeExprContext } from "./TSQLParser";
+import { ColumnExprListContext } from "./TSQLParser";
+import { ColumnExprContext } from "./TSQLParser";
+import { ColumnLambdaExprContext } from "./TSQLParser";
+import { TSQLxChildElementContext } from "./TSQLParser";
+import { TSQLxTagElementContext } from "./TSQLParser";
+import { TSQLxTagAttributeContext } from "./TSQLParser";
+import { WithExprListContext } from "./TSQLParser";
+import { WithExprContext } from "./TSQLParser";
+import { ColumnIdentifierContext } from "./TSQLParser";
+import { NestedIdentifierContext } from "./TSQLParser";
+import { TableExprContext } from "./TSQLParser";
+import { TableFunctionExprContext } from "./TSQLParser";
+import { TableIdentifierContext } from "./TSQLParser";
+import { TableArgListContext } from "./TSQLParser";
+import { DatabaseIdentifierContext } from "./TSQLParser";
+import { FloatingLiteralContext } from "./TSQLParser";
+import { NumberLiteralContext } from "./TSQLParser";
+import { LiteralContext } from "./TSQLParser";
+import { IntervalContext } from "./TSQLParser";
+import { KeywordContext } from "./TSQLParser";
+import { KeywordForAliasContext } from "./TSQLParser";
+import { AliasContext } from "./TSQLParser";
+import { IdentifierContext } from "./TSQLParser";
+import { EnumValueContext } from "./TSQLParser";
+import { PlaceholderContext } from "./TSQLParser";
+import { StringContext } from "./TSQLParser";
+import { TemplateStringContext } from "./TSQLParser";
+import { StringContentsContext } from "./TSQLParser";
+import { FullTemplateStringContext } from "./TSQLParser";
+import { StringContentsFullContext } from "./TSQLParser";
+
+
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `TSQLParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export interface TSQLParserVisitor<Result> extends ParseTreeVisitor<Result> {
+	/**
+	 * Visit a parse tree produced by the `JoinOpInner`
+	 * labeled alternative in `TSQLParser.joinOp`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinOpInner?: (ctx: JoinOpInnerContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinOpLeftRight`
+	 * labeled alternative in `TSQLParser.joinOp`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinOpLeftRight?: (ctx: JoinOpLeftRightContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinOpFull`
+	 * labeled alternative in `TSQLParser.joinOp`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinOpFull?: (ctx: JoinOpFullContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprCase`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprCase?: (ctx: ColumnExprCaseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprCast`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprCast?: (ctx: ColumnExprCastContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprDate`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprDate?: (ctx: ColumnExprDateContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprIntervalString`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprIntervalString?: (ctx: ColumnExprIntervalStringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprInterval`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprInterval?: (ctx: ColumnExprIntervalContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprSubstring`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprSubstring?: (ctx: ColumnExprSubstringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTimestamp`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTimestamp?: (ctx: ColumnExprTimestampContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTrim`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTrim?: (ctx: ColumnExprTrimContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprWinFunction`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprWinFunction?: (ctx: ColumnExprWinFunctionContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprWinFunctionTarget`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprWinFunctionTarget?: (ctx: ColumnExprWinFunctionTargetContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprFunction`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprFunction?: (ctx: ColumnExprFunctionContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprCallSelect`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprCallSelect?: (ctx: ColumnExprCallSelectContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprCall`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprCall?: (ctx: ColumnExprCallContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTagElement`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTagElement?: (ctx: ColumnExprTagElementContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTemplateString`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTemplateString?: (ctx: ColumnExprTemplateStringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprLiteral`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprLiteral?: (ctx: ColumnExprLiteralContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprArrayAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprArrayAccess?: (ctx: ColumnExprArrayAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTupleAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTupleAccess?: (ctx: ColumnExprTupleAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprPropertyAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprPropertyAccess?: (ctx: ColumnExprPropertyAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNullArrayAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNullArrayAccess?: (ctx: ColumnExprNullArrayAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNullTupleAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNullTupleAccess?: (ctx: ColumnExprNullTupleAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNullPropertyAccess`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNullPropertyAccess?: (ctx: ColumnExprNullPropertyAccessContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNegate`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNegate?: (ctx: ColumnExprNegateContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprPrecedence1`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprPrecedence1?: (ctx: ColumnExprPrecedence1Context) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprPrecedence2`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprPrecedence2?: (ctx: ColumnExprPrecedence2Context) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprPrecedence3`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprPrecedence3?: (ctx: ColumnExprPrecedence3Context) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprIsNull`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprIsNull?: (ctx: ColumnExprIsNullContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNullish`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNullish?: (ctx: ColumnExprNullishContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprNot`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprNot?: (ctx: ColumnExprNotContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprAnd`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprAnd?: (ctx: ColumnExprAndContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprOr`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprOr?: (ctx: ColumnExprOrContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprBetween`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprBetween?: (ctx: ColumnExprBetweenContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTernaryOp`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTernaryOp?: (ctx: ColumnExprTernaryOpContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprAlias`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprAlias?: (ctx: ColumnExprAliasContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprAsterisk`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprAsterisk?: (ctx: ColumnExprAsteriskContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprSubquery`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprSubquery?: (ctx: ColumnExprSubqueryContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprParens`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprParens?: (ctx: ColumnExprParensContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprTuple`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprTuple?: (ctx: ColumnExprTupleContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprArray`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprArray?: (ctx: ColumnExprArrayContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprDict`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprDict?: (ctx: ColumnExprDictContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprLambda`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprLambda?: (ctx: ColumnExprLambdaContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnExprIdentifier`
+	 * labeled alternative in `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprIdentifier?: (ctx: ColumnExprIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprIdentifier`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprIdentifier?: (ctx: TableExprIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprFunction`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprFunction?: (ctx: TableExprFunctionContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprSubquery`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprSubquery?: (ctx: TableExprSubqueryContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprAlias`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprAlias?: (ctx: TableExprAliasContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprTag`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprTag?: (ctx: TableExprTagContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `TableExprPlaceholder`
+	 * labeled alternative in `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExprPlaceholder?: (ctx: TableExprPlaceholderContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `WithExprSubquery`
+	 * labeled alternative in `TSQLParser.withExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWithExprSubquery?: (ctx: WithExprSubqueryContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `WithExprColumn`
+	 * labeled alternative in `TSQLParser.withExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWithExprColumn?: (ctx: WithExprColumnContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinExprOp`
+	 * labeled alternative in `TSQLParser.joinExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinExprOp?: (ctx: JoinExprOpContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinExprCrossOp`
+	 * labeled alternative in `TSQLParser.joinExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinExprCrossOp?: (ctx: JoinExprCrossOpContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinExprTable`
+	 * labeled alternative in `TSQLParser.joinExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinExprTable?: (ctx: JoinExprTableContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `JoinExprParens`
+	 * labeled alternative in `TSQLParser.joinExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinExprParens?: (ctx: JoinExprParensContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `frameStart`
+	 * labeled alternative in `TSQLParser.winFrameExtend`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFrameStart?: (ctx: FrameStartContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `frameBetween`
+	 * labeled alternative in `TSQLParser.winFrameExtend`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFrameBetween?: (ctx: FrameBetweenContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnTypeExprSimple`
+	 * labeled alternative in `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExprSimple?: (ctx: ColumnTypeExprSimpleContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnTypeExprNested`
+	 * labeled alternative in `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExprNested?: (ctx: ColumnTypeExprNestedContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnTypeExprEnum`
+	 * labeled alternative in `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExprEnum?: (ctx: ColumnTypeExprEnumContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnTypeExprComplex`
+	 * labeled alternative in `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExprComplex?: (ctx: ColumnTypeExprComplexContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `ColumnTypeExprParam`
+	 * labeled alternative in `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExprParam?: (ctx: ColumnTypeExprParamContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.program`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitProgram?: (ctx: ProgramContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.declaration`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitDeclaration?: (ctx: DeclarationContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.expression`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitExpression?: (ctx: ExpressionContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.varDecl`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitVarDecl?: (ctx: VarDeclContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.identifierList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitIdentifierList?: (ctx: IdentifierListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.statement`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitStatement?: (ctx: StatementContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.returnStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitReturnStmt?: (ctx: ReturnStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.throwStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitThrowStmt?: (ctx: ThrowStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.catchBlock`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitCatchBlock?: (ctx: CatchBlockContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tryCatchStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTryCatchStmt?: (ctx: TryCatchStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.ifStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitIfStmt?: (ctx: IfStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.whileStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWhileStmt?: (ctx: WhileStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.forStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitForStmt?: (ctx: ForStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.forInStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitForInStmt?: (ctx: ForInStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.funcStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFuncStmt?: (ctx: FuncStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.varAssignment`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitVarAssignment?: (ctx: VarAssignmentContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.exprStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitExprStmt?: (ctx: ExprStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.emptyStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitEmptyStmt?: (ctx: EmptyStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.block`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitBlock?: (ctx: BlockContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.kvPair`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitKvPair?: (ctx: KvPairContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.kvPairList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitKvPairList?: (ctx: KvPairListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.select`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSelect?: (ctx: SelectContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.selectStmtWithParens`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSelectStmtWithParens?: (ctx: SelectStmtWithParensContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.subsequentSelectSetClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSubsequentSelectSetClause?: (ctx: SubsequentSelectSetClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.selectSetStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSelectSetStmt?: (ctx: SelectSetStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.selectStmt`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSelectStmt?: (ctx: SelectStmtContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.withClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWithClause?: (ctx: WithClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.topClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTopClause?: (ctx: TopClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.fromClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFromClause?: (ctx: FromClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.arrayJoinClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitArrayJoinClause?: (ctx: ArrayJoinClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.windowClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWindowClause?: (ctx: WindowClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.prewhereClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitPrewhereClause?: (ctx: PrewhereClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.whereClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWhereClause?: (ctx: WhereClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.groupByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitGroupByClause?: (ctx: GroupByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.havingClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitHavingClause?: (ctx: HavingClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.orderByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitOrderByClause?: (ctx: OrderByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.projectionOrderByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitProjectionOrderByClause?: (ctx: ProjectionOrderByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.limitByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitLimitByClause?: (ctx: LimitByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.limitAndOffsetClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitLimitAndOffsetClause?: (ctx: LimitAndOffsetClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.offsetOnlyClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitOffsetOnlyClause?: (ctx: OffsetOnlyClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.settingsClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSettingsClause?: (ctx: SettingsClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.joinExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinExpr?: (ctx: JoinExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.joinOp`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinOp?: (ctx: JoinOpContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.joinOpCross`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinOpCross?: (ctx: JoinOpCrossContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.joinConstraintClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitJoinConstraintClause?: (ctx: JoinConstraintClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.sampleClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSampleClause?: (ctx: SampleClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.limitExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitLimitExpr?: (ctx: LimitExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.orderExprList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitOrderExprList?: (ctx: OrderExprListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.orderExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitOrderExpr?: (ctx: OrderExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.ratioExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitRatioExpr?: (ctx: RatioExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.settingExprList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSettingExprList?: (ctx: SettingExprListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.settingExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitSettingExpr?: (ctx: SettingExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.windowExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWindowExpr?: (ctx: WindowExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.winPartitionByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWinPartitionByClause?: (ctx: WinPartitionByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.winOrderByClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWinOrderByClause?: (ctx: WinOrderByClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.winFrameClause`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWinFrameClause?: (ctx: WinFrameClauseContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.winFrameExtend`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWinFrameExtend?: (ctx: WinFrameExtendContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.winFrameBound`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWinFrameBound?: (ctx: WinFrameBoundContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.expr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitExpr?: (ctx: ExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.columnTypeExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnTypeExpr?: (ctx: ColumnTypeExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.columnExprList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExprList?: (ctx: ColumnExprListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.columnExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnExpr?: (ctx: ColumnExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.columnLambdaExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnLambdaExpr?: (ctx: ColumnLambdaExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tSQLxChildElement`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTSQLxChildElement?: (ctx: TSQLxChildElementContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tSQLxTagElement`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTSQLxTagElement?: (ctx: TSQLxTagElementContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tSQLxTagAttribute`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTSQLxTagAttribute?: (ctx: TSQLxTagAttributeContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.withExprList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWithExprList?: (ctx: WithExprListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.withExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitWithExpr?: (ctx: WithExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.columnIdentifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitColumnIdentifier?: (ctx: ColumnIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.nestedIdentifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitNestedIdentifier?: (ctx: NestedIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tableExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableExpr?: (ctx: TableExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tableFunctionExpr`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableFunctionExpr?: (ctx: TableFunctionExprContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tableIdentifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableIdentifier?: (ctx: TableIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.tableArgList`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTableArgList?: (ctx: TableArgListContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.databaseIdentifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitDatabaseIdentifier?: (ctx: DatabaseIdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.floatingLiteral`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFloatingLiteral?: (ctx: FloatingLiteralContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.numberLiteral`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitNumberLiteral?: (ctx: NumberLiteralContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.literal`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitLiteral?: (ctx: LiteralContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.interval`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitInterval?: (ctx: IntervalContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.keyword`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitKeyword?: (ctx: KeywordContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.keywordForAlias`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitKeywordForAlias?: (ctx: KeywordForAliasContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.alias`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitAlias?: (ctx: AliasContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.identifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitIdentifier?: (ctx: IdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.enumValue`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitEnumValue?: (ctx: EnumValueContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.placeholder`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitPlaceholder?: (ctx: PlaceholderContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.string`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitString?: (ctx: StringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.templateString`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTemplateString?: (ctx: TemplateStringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.stringContents`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitStringContents?: (ctx: StringContentsContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.fullTemplateString`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitFullTemplateString?: (ctx: FullTemplateStringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `TSQLParser.stringContentsFull`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitStringContentsFull?: (ctx: StringContentsFullContext) => Result;
+}
+
diff --git a/internal-packages/tsql/src/grammar/parser.test.ts b/internal-packages/tsql/src/grammar/parser.test.ts
new file mode 100644
index 00000000000..fed698130f0
--- /dev/null
+++ b/internal-packages/tsql/src/grammar/parser.test.ts
@@ -0,0 +1,166 @@
+import { describe, it, expect } from "vitest";
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { TSQLLexer } from "./TSQLLexer.js";
+import { TSQLParser } from "./TSQLParser.js";
+
+describe("TSQLParser", () => {
+  function parse(input: string) {
+    const inputStream = CharStreams.fromString(input);
+    const lexer = new TSQLLexer(inputStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new TSQLParser(tokenStream);
+    return parser;
+  }
+
+  describe("select statements", () => {
+    it("should parse a simple SELECT statement", () => {
+      const parser = parse("SELECT * FROM users;");
+      const tree = parser.select();
+
+      expect(tree).toBeDefined();
+      // The select rule can return selectStmt, selectSetStmt, or tSQLxTagElement
+      // Most SELECT statements are wrapped in selectSetStmt
+      const selectSetStmt = tree.selectSetStmt();
+      expect(selectSetStmt).toBeDefined();
+
+      // Get the underlying selectStmt from selectSetStmt -> selectStmtWithParens
+      const selectStmtWithParens = selectSetStmt!.selectStmtWithParens();
+      const selectStmt = selectStmtWithParens.selectStmt();
+
+      expect(selectStmt).toBeDefined();
+      expect(selectStmt!.SELECT()).toBeDefined();
+      expect(selectStmt!.columnExprList()).toBeDefined();
+      expect(selectStmt!.fromClause()).toBeDefined();
+    });
+
+    it("should parse SELECT with WHERE clause", () => {
+      const parser = parse("SELECT id, name FROM users WHERE id = 1;");
+      const tree = parser.select();
+
+      expect(tree).toBeDefined();
+      const selectSetStmt = tree.selectSetStmt();
+      const selectStmt = selectSetStmt!.selectStmtWithParens().selectStmt()!;
+
+      expect(selectStmt.whereClause()).toBeDefined();
+      expect(selectStmt.whereClause()!.WHERE()).toBeDefined();
+      expect(selectStmt.whereClause()!.columnExpr()).toBeDefined();
+    });
+
+    it("should parse SELECT with multiple columns", () => {
+      const parser = parse("SELECT id, name, email FROM users;");
+      const tree = parser.select();
+
+      expect(tree).toBeDefined();
+      const selectSetStmt = tree.selectSetStmt();
+      const selectStmt = selectSetStmt!.selectStmtWithParens().selectStmt()!;
+
+      const columnList = selectStmt.columnExprList();
+      expect(columnList).toBeDefined();
+      // columnExprList contains comma-separated expressions
+      expect(columnList.columnExpr().length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("should parse SELECT with DISTINCT", () => {
+      const parser = parse("SELECT DISTINCT id FROM users;");
+      const tree = parser.select();
+
+      expect(tree).toBeDefined();
+      const selectSetStmt = tree.selectSetStmt();
+      const selectStmt = selectSetStmt!.selectStmtWithParens().selectStmt()!;
+
+      expect(selectStmt.DISTINCT()).toBeDefined();
+    });
+  });
+
+  describe("expressions", () => {
+    it("should parse a simple addition expression", () => {
+      const parser = parse("1 + 2");
+      const tree = parser.expr();
+
+      expect(tree).toBeDefined();
+      const columnExpr = tree.columnExpr();
+      expect(columnExpr).toBeDefined();
+      // Check that the expression has children (the operands and operator)
+      expect(columnExpr.text).toBeDefined();
+      const text = columnExpr.text;
+      expect(text).toContain("1");
+      expect(text).toContain("2");
+      expect(text).toContain("+");
+    });
+
+    it("should parse arithmetic expressions with parentheses", () => {
+      const parser = parse("(1 + 2) * 3");
+      const tree = parser.expr();
+
+      expect(tree).toBeDefined();
+      const columnExpr = tree.columnExpr();
+      expect(columnExpr).toBeDefined();
+      // The expression should contain the operators
+      const text = columnExpr.text;
+      expect(text).toContain("+");
+      expect(text).toContain("*");
+      expect(text).toContain("1");
+      expect(text).toContain("2");
+      expect(text).toContain("3");
+    });
+
+    it("should parse string literals", () => {
+      const parser = parse("'hello world'");
+      const tree = parser.expr();
+
+      expect(tree).toBeDefined();
+      const columnExpr = tree.columnExpr();
+      expect(columnExpr).toBeDefined();
+      const text = columnExpr.text;
+      expect(text).toContain("hello");
+      expect(text).toContain("world");
+    });
+
+    it("should parse numeric literals", () => {
+      const parser = parse("42");
+      const tree = parser.expr();
+
+      expect(tree).toBeDefined();
+      const columnExpr = tree.columnExpr();
+      expect(columnExpr).toBeDefined();
+      expect(columnExpr.text).toContain("42");
+    });
+  });
+
+  describe("program", () => {
+    it("should parse an empty program", () => {
+      const parser = parse("");
+      const tree = parser.program();
+
+      expect(tree).toBeDefined();
+      expect(tree.EOF()).toBeDefined();
+      expect(tree.declaration().length).toBe(0);
+    });
+
+    it("should parse variable declarations", () => {
+      const parser = parse("let x := 1");
+      const tree = parser.program();
+
+      expect(tree).toBeDefined();
+      expect(tree.declaration().length).toBe(1);
+      const declaration = tree.declaration(0);
+
+      // Check if it's a varDecl
+      const varDecl = declaration.varDecl();
+      expect(varDecl).toBeDefined();
+      expect(varDecl!.LET()).toBeDefined();
+      expect(varDecl!.identifier()).toBeDefined();
+      expect(varDecl!.expression()).toBeDefined();
+    });
+
+    it("should parse multiple declarations", () => {
+      const parser = parse("let x := 1; let y := 2");
+      const tree = parser.program();
+
+      expect(tree).toBeDefined();
+      // Count only non-empty declarations (varDecl or non-empty statements)
+      const varDecls = tree.declaration().filter((d) => d.varDecl() !== undefined);
+      expect(varDecls.length).toBe(2);
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/index.test.ts b/internal-packages/tsql/src/index.test.ts
new file mode 100644
index 00000000000..a93fb0fd4b0
--- /dev/null
+++ b/internal-packages/tsql/src/index.test.ts
@@ -0,0 +1,828 @@
+import { describe, it, expect } from "vitest";
+import {
+  compileTSQL,
+  parseTSQLSelect,
+  isColumnReferencedInExpression,
+  createFallbackExpression,
+  injectFallbackConditions,
+  type WhereClauseCondition,
+} from "./index.js";
+import { column, type TableSchema } from "./query/schema.js";
+
+/**
+ * Test table schema for enforcedWhereClause tests
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    status: { name: "status", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime64") },
+    updated_at: { name: "updated_at", ...column("DateTime64") },
+    time: { name: "time", ...column("DateTime64") },
+    triggered_at: { name: "triggered_at", ...column("DateTime64") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+/**
+ * Test table schema with tenant columns (lookup table with tenant isolation)
+ */
+const lookupTableSchema: TableSchema = {
+  name: "lookup_table",
+  clickhouseName: "trigger_dev.lookup_table",
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+  columns: {
+    id: { name: "id", ...column("String") },
+    name: { name: "name", ...column("String") },
+  },
+};
+
+/**
+ * Test table schema WITHOUT tenant columns (e.g., global reference data)
+ */
+const nonTenantTableSchema: TableSchema = {
+  name: "reference_data",
+  clickhouseName: "trigger_dev.reference_data",
+  // No tenantColumns - this is a global table
+  columns: {
+    id: { name: "id", ...column("String") },
+    value: { name: "value", ...column("String") },
+  },
+};
+
+/**
+ * Base options with tenant isolation for tests
+ */
+const baseEnforcedWhereClause: Record<string, WhereClauseCondition> = {
+  organization_id: { op: "eq", value: "org_test123" },
+  project_id: { op: "eq", value: "proj_test456" },
+  environment_id: { op: "eq", value: "env_test789" },
+};
+
+describe("isColumnReferencedInExpression", () => {
+  it("should detect column in simple WHERE clause", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs WHERE time > '2024-01-01'");
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(ast.where, "status")).toBe(false);
+    }
+  });
+
+  it("should detect column in AND expression", () => {
+    const ast = parseTSQLSelect(
+      "SELECT * FROM task_runs WHERE time > '2024-01-01' AND status = 'completed'"
+    );
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(ast.where, "status")).toBe(true);
+      expect(isColumnReferencedInExpression(ast.where, "id")).toBe(false);
+    }
+  });
+
+  it("should detect column in OR expression", () => {
+    const ast = parseTSQLSelect(
+      "SELECT * FROM task_runs WHERE time > '2024-01-01' OR status = 'completed'"
+    );
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(ast.where, "status")).toBe(true);
+    }
+  });
+
+  it("should detect column in BETWEEN expression", () => {
+    const ast = parseTSQLSelect(
+      "SELECT * FROM task_runs WHERE time BETWEEN '2024-01-01' AND '2024-12-31'"
+    );
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(ast.where, "status")).toBe(false);
+    }
+  });
+
+  it("should detect column in qualified reference (table.column)", () => {
+    const ast = parseTSQLSelect(
+      "SELECT * FROM task_runs WHERE task_runs.time > '2024-01-01'"
+    );
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+    }
+  });
+
+  it("should return false for empty WHERE clause", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs");
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(false);
+    }
+  });
+
+  it("should detect column in nested NOT expression", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs WHERE NOT time > '2024-01-01'");
+    if (ast.expression_type === "select_query") {
+      expect(isColumnReferencedInExpression(ast.where, "time")).toBe(true);
+    }
+  });
+});
+
+describe("createFallbackExpression", () => {
+  it("should create a simple comparison expression (gt)", () => {
+    const expr = createFallbackExpression("time", { op: "gt", value: "2024-01-01" });
+    expect(expr.expression_type).toBe("compare_operation");
+  });
+
+  it("should create a simple comparison expression (eq)", () => {
+    const expr = createFallbackExpression("status", { op: "eq", value: "completed" });
+    expect(expr.expression_type).toBe("compare_operation");
+  });
+
+  it("should create a between expression", () => {
+    const expr = createFallbackExpression("time", {
+      op: "between",
+      low: "2024-01-01",
+      high: "2024-12-31",
+    });
+    expect(expr.expression_type).toBe("between_expr");
+  });
+
+  it("should convert Date values to ISO strings", () => {
+    const date = new Date("2024-06-15T12:00:00Z");
+    const expr = createFallbackExpression("time", { op: "gte", value: date });
+    expect(expr.expression_type).toBe("compare_operation");
+  });
+});
+
+describe("injectFallbackConditions", () => {
+  it("should inject fallback when column is not in WHERE", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs WHERE status = 'completed'");
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" },
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    if (modified.expression_type === "select_query") {
+      expect(modified.where).toBeDefined();
+      expect(isColumnReferencedInExpression(modified.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(modified.where, "status")).toBe(true);
+    }
+  });
+
+  it("should NOT inject fallback when column is already in WHERE", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs WHERE time > '2024-06-01'");
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" },
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    // The WHERE clause should remain as is (no additional time condition)
+    if (modified.expression_type === "select_query" && modified.where) {
+      // It should not be an AND expression - it should be the original compare_operation
+      expect(modified.where.expression_type).toBe("compare_operation");
+    }
+  });
+
+  it("should inject fallback when query has no WHERE clause", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs LIMIT 10");
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" },
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    if (modified.expression_type === "select_query") {
+      expect(modified.where).toBeDefined();
+      expect(isColumnReferencedInExpression(modified.where, "time")).toBe(true);
+    }
+  });
+
+  it("should inject multiple fallbacks", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs LIMIT 10");
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" },
+      status: { op: "eq", value: "completed" },
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    if (modified.expression_type === "select_query") {
+      expect(modified.where).toBeDefined();
+      expect(isColumnReferencedInExpression(modified.where, "time")).toBe(true);
+      expect(isColumnReferencedInExpression(modified.where, "status")).toBe(true);
+    }
+  });
+
+  it("should only inject fallbacks for unreferenced columns", () => {
+    const ast = parseTSQLSelect("SELECT * FROM task_runs WHERE time > '2024-06-01'");
+    const fallbacks: Record<string, WhereClauseCondition> = {
+      time: { op: "gte", value: "2024-01-01" }, // Should NOT be injected
+      status: { op: "eq", value: "completed" }, // Should be injected
+    };
+
+    const modified = injectFallbackConditions(ast, fallbacks);
+    if (modified.expression_type === "select_query" && modified.where) {
+      // Should be an AND expression combining fallback status with original time
+      expect(modified.where.expression_type).toBe("and");
+    }
+  });
+});
+
+describe("compileTSQL with whereClauseFallback", () => {
+  const baseOptions = {
+    tableSchema: [taskRunsSchema],
+    enforcedWhereClause: baseEnforcedWhereClause,
+  };
+
+  describe("simple comparison fallbacks", () => {
+    it("should apply gt fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT * FROM task_runs WHERE status = 'completed'", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "gt", value: "2024-01-01" },
+        },
+      });
+
+      // Should contain a time comparison
+      expect(sql).toContain("time");
+      expect(sql).toContain("greater(");
+    });
+
+    it("should apply gte fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "gte", value: "2024-01-01" },
+        },
+      });
+
+      expect(sql).toContain("greaterOrEquals(");
+    });
+
+    it("should apply lt fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "lt", value: "2024-12-31" },
+        },
+      });
+
+      expect(sql).toContain("less(");
+    });
+
+    it("should apply lte fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "lte", value: "2024-12-31" },
+        },
+      });
+
+      expect(sql).toContain("lessOrEquals(");
+    });
+
+    it("should apply eq fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          status: { op: "eq", value: "completed" },
+        },
+      });
+
+      expect(sql).toContain("equals(");
+      expect(sql).toContain("status");
+    });
+
+    it("should apply neq fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          status: { op: "neq", value: "failed" },
+        },
+      });
+
+      expect(sql).toContain("notEquals(");
+      expect(sql).toContain("status");
+    });
+  });
+
+  describe("between fallback", () => {
+    it("should apply BETWEEN fallback when column not in WHERE", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs WHERE status = 'completed'", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "between", low: "2024-01-01", high: "2024-12-31" },
+        },
+      });
+
+      expect(sql).toContain("time BETWEEN");
+    });
+
+    it("should apply BETWEEN fallback with Date values", () => {
+      const startDate = new Date("2024-01-01T00:00:00Z");
+      const endDate = new Date("2024-12-31T23:59:59Z");
+
+      const { sql, params } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "between", low: startDate, high: endDate },
+        },
+      });
+
+      expect(sql).toContain("time BETWEEN");
+      // The dates should be converted to ISO strings and parameterized
+      expect(Object.values(params).some((v) => typeof v === "string" && v.includes("2024"))).toBe(
+        true
+      );
+    });
+  });
+
+  describe("fallback NOT applied when column already filtered", () => {
+    it("should NOT apply fallback when column is in simple WHERE", () => {
+      const { sql } = compileTSQL("SELECT * FROM task_runs WHERE time > '2024-06-01'", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "gte", value: "2024-01-01" },
+        },
+      });
+
+      // Should only have the user's time condition, not the fallback
+      // Count occurrences of time comparison - should be 1 (just the user's)
+      const timeMatches = sql.match(/greater\(.*?time/g) || [];
+      expect(timeMatches.length).toBe(1);
+    });
+
+    it("should NOT apply fallback when column is in BETWEEN expression", () => {
+      const { sql } = compileTSQL(
+        "SELECT * FROM task_runs WHERE time BETWEEN '2024-06-01' AND '2024-06-30'",
+        {
+          ...baseOptions,
+          whereClauseFallback: {
+            time: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Should have the user's BETWEEN, not the fallback gte
+      expect(sql).toContain("time BETWEEN");
+      expect(sql).not.toContain("greaterOrEquals(");
+    });
+
+    it("should NOT apply fallback when column is in AND expression", () => {
+      const { sql } = compileTSQL(
+        "SELECT * FROM task_runs WHERE status = 'completed' AND time > '2024-06-01'",
+        {
+          ...baseOptions,
+          whereClauseFallback: {
+            time: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Should only have one time comparison
+      const timeMatches = sql.match(/greater\(.*?time/g) || [];
+      expect(timeMatches.length).toBe(1);
+    });
+
+    it("should NOT apply fallback when column is in OR expression", () => {
+      const { sql } = compileTSQL(
+        "SELECT * FROM task_runs WHERE status = 'completed' OR time > '2024-06-01'",
+        {
+          ...baseOptions,
+          whereClauseFallback: {
+            time: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Fallback should not be applied since time is mentioned in OR
+      const timeGreaterMatches = sql.match(/greater\(.*?time/g) || [];
+      expect(timeGreaterMatches.length).toBe(1);
+    });
+
+    it("should NOT apply fallback when column is in qualified reference", () => {
+      const { sql } = compileTSQL(
+        "SELECT * FROM task_runs WHERE task_runs.time > '2024-06-01'",
+        {
+          ...baseOptions,
+          whereClauseFallback: {
+            time: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Fallback should not be applied
+      const timeGreaterMatches = sql.match(/greater.*time/g) || [];
+      expect(timeGreaterMatches.length).toBe(1);
+    });
+  });
+
+  describe("multiple fallbacks", () => {
+    it("should apply multiple fallbacks for different unreferenced columns", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "gte", value: "2024-01-01" },
+          status: { op: "eq", value: "completed" },
+        },
+      });
+
+      expect(sql).toContain("greaterOrEquals(");
+      expect(sql).toContain("time");
+      expect(sql).toContain("equals(");
+      expect(sql).toContain("status");
+    });
+
+    it("should only apply fallbacks for unreferenced columns when some are filtered", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs WHERE time > '2024-06-01'", {
+        ...baseOptions,
+        whereClauseFallback: {
+          time: { op: "gte", value: "2024-01-01" }, // Should NOT be applied
+          status: { op: "eq", value: "completed" }, // Should be applied
+        },
+      });
+
+      // Status fallback should be applied
+      expect(sql).toContain("equals(");
+      expect(sql).toContain("status");
+
+      // Time should only have user's condition
+      const timeGreaterMatches = sql.match(/greater\(.*?time/g) || [];
+      expect(timeGreaterMatches.length).toBe(1);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty whereClauseFallback", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {},
+      });
+
+      // Should just compile normally without errors
+      expect(sql).toContain("SELECT");
+      expect(sql).toContain("FROM");
+    });
+
+    it("should handle undefined whereClauseFallback", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        // whereClauseFallback is undefined
+      });
+
+      // Should just compile normally without errors
+      expect(sql).toContain("SELECT");
+      expect(sql).toContain("FROM");
+    });
+
+    it("should work with UNION queries", () => {
+      const { sql } = compileTSQL(
+        "SELECT id FROM task_runs WHERE status = 'completed' UNION ALL SELECT id FROM task_runs WHERE status = 'failed'",
+        {
+          ...baseOptions,
+          whereClauseFallback: {
+            time: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Both queries in the UNION should have the time fallback
+      const timeMatches = sql.match(/greaterOrEquals\(.*?time/g) || [];
+      expect(timeMatches.length).toBe(2);
+    });
+
+    it("should handle numeric values in fallback", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        ...baseOptions,
+        whereClauseFallback: {
+          id: { op: "gt", value: 100 },
+        },
+      });
+
+      expect(sql).toContain("greater(");
+      expect(sql).toContain("100");
+    });
+  });
+});
+
+describe("compileTSQL with enforcedWhereClause", () => {
+  describe("validation tests", () => {
+    it("should throw error when required tenant column is missing", () => {
+      expect(() =>
+        compileTSQL("SELECT id FROM task_runs", {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {}, // Missing organization_id
+        })
+      ).toThrow("Table 'task_runs' requires 'organization_id' in enforcedWhereClause");
+    });
+
+    it("should throw error when organization_id is missing but other tenant columns are present", () => {
+      expect(() =>
+        compileTSQL("SELECT id FROM task_runs", {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            project_id: { op: "eq", value: "proj_123" },
+            environment_id: { op: "eq", value: "env_456" },
+          },
+        })
+      ).toThrow("Table 'task_runs' requires 'organization_id' in enforcedWhereClause");
+    });
+
+    it("should work with non-tenant table and empty enforcedWhereClause", () => {
+      const { sql } = compileTSQL("SELECT id FROM reference_data", {
+        tableSchema: [nonTenantTableSchema],
+        enforcedWhereClause: {},
+      });
+
+      expect(sql).toContain("SELECT");
+      expect(sql).toContain("FROM");
+    });
+
+    it("should work with only organization_id (project and env are optional)", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+        },
+      });
+
+      expect(sql).toContain("organization_id");
+      expect(sql).not.toContain("project_id");
+      expect(sql).not.toContain("environment_id");
+    });
+  });
+
+  describe("basic functionality", () => {
+    it("should apply single enforced condition", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+        },
+      });
+
+      expect(sql).toContain("equals(");
+      expect(sql).toContain("organization_id");
+    });
+
+    it("should apply multiple enforced conditions", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          project_id: { op: "eq", value: "proj_456" },
+          environment_id: { op: "eq", value: "env_789" },
+        },
+      });
+
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+    });
+
+    it("should apply enforced condition even when user filters on same field", () => {
+      const { sql } = compileTSQL(
+        "SELECT id FROM task_runs WHERE triggered_at > '2025-01-01'",
+        {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_123" },
+            triggered_at: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Should have BOTH the user's condition AND the enforced condition
+      // User's condition: greater(triggered_at, '2025-01-01')
+      // Enforced condition: greaterOrEquals(triggered_at, '2024-01-01')
+      const triggeredAtMatches = sql.match(/triggered_at/g) || [];
+      expect(triggeredAtMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should apply different comparison operators", () => {
+      const { sql: sqlGt } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          time: { op: "gt", value: "2024-01-01" },
+        },
+      });
+      expect(sqlGt).toContain("greater(");
+
+      const { sql: sqlLt } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          time: { op: "lt", value: "2024-12-31" },
+        },
+      });
+      expect(sqlLt).toContain("less(");
+
+      const { sql: sqlNeq } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          status: { op: "neq", value: "deleted" },
+        },
+      });
+      expect(sqlNeq).toContain("notEquals(");
+    });
+
+    it("should apply BETWEEN condition", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          time: { op: "between", low: "2024-01-01", high: "2024-12-31" },
+        },
+      });
+
+      expect(sql).toContain("time BETWEEN");
+    });
+
+    it("should handle Date values in enforced conditions", () => {
+      const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+      const { sql, params } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          triggered_at: { op: "gte", value: sevenDaysAgo },
+        },
+      });
+
+      expect(sql).toContain("triggered_at");
+      expect(sql).toContain("toDateTime64");
+    });
+  });
+
+  describe("enforcedWhereClause + whereClauseFallback interaction", () => {
+    it("should apply both enforced and fallback conditions when user doesn't filter", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          triggered_at: { op: "gte", value: "2024-01-01" },
+        },
+        whereClauseFallback: {
+          status: { op: "eq", value: "completed" },
+        },
+      });
+
+      // Should have both enforced (triggered_at) and fallback (status)
+      expect(sql).toContain("triggered_at");
+      expect(sql).toContain("status");
+    });
+
+    it("should apply enforced but not fallback when user filters on fallback column", () => {
+      const { sql, params } = compileTSQL(
+        "SELECT id FROM task_runs WHERE status = 'failed'",
+        {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_123" },
+            triggered_at: { op: "gte", value: "2024-01-01" },
+          },
+          whereClauseFallback: {
+            status: { op: "eq", value: "completed" },
+          },
+        }
+      );
+
+      // Enforced triggered_at should be applied
+      expect(sql).toContain("triggered_at");
+      // User's status = 'failed' should be there (as a parameter)
+      expect(Object.values(params)).toContain("failed");
+      // The fallback 'completed' should NOT be applied since user filtered on status
+      expect(Object.values(params)).not.toContain("completed");
+    });
+
+    it("should apply both enforced and fallback on same field (enforced always, fallback only if not filtered)", () => {
+      // User doesn't filter on triggered_at, so BOTH enforced AND fallback apply
+      const { sql } = compileTSQL("SELECT id FROM task_runs WHERE status = 'completed'", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          triggered_at: { op: "gte", value: "2024-06-01" }, // Enforced: last 6 months
+        },
+        whereClauseFallback: {
+          triggered_at: { op: "gte", value: "2024-01-01" }, // Fallback: last year
+        },
+      });
+
+      // Both should be applied (enforced at printer level, fallback at AST level)
+      const triggeredAtMatches = sql.match(/triggered_at/g) || [];
+      expect(triggeredAtMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should skip fallback but keep enforced when user filters on same field", () => {
+      const { sql } = compileTSQL(
+        "SELECT id FROM task_runs WHERE triggered_at > '2025-01-01'",
+        {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_123" },
+            triggered_at: { op: "gte", value: "2024-06-01" }, // Enforced: always applied
+          },
+          whereClauseFallback: {
+            triggered_at: { op: "gte", value: "2024-01-01" }, // Fallback: skipped since user filtered
+          },
+        }
+      );
+
+      // User's condition + enforced should be present
+      // Fallback should NOT be applied since user filtered on triggered_at
+      // Count distinct triggered_at conditions
+      const triggeredAtMatches = sql.match(/triggered_at/g) || [];
+      // Should be 2: user's condition + enforced condition (NOT 3, no fallback)
+      expect(triggeredAtMatches.length).toBe(2);
+    });
+  });
+
+  describe("security tests", () => {
+    it("should apply enforced conditions to UNION queries", () => {
+      const { sql } = compileTSQL(
+        "SELECT id FROM task_runs WHERE status = 'completed' UNION ALL SELECT id FROM task_runs WHERE status = 'failed'",
+        {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_123" },
+            triggered_at: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // Both parts of the UNION should have the enforced conditions
+      const orgMatches = sql.match(/organization_id/g) || [];
+      expect(orgMatches.length).toBe(2);
+
+      const triggeredAtMatches = sql.match(/triggered_at/g) || [];
+      expect(triggeredAtMatches.length).toBe(2);
+    });
+
+    it("should NOT be bypassable via OR clause", () => {
+      const { sql } = compileTSQL(
+        "SELECT id FROM task_runs WHERE status = 'completed' OR 1=1",
+        {
+          tableSchema: [taskRunsSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_123" },
+            triggered_at: { op: "gte", value: "2024-01-01" },
+          },
+        }
+      );
+
+      // The enforced conditions should be ANDed with the entire user WHERE clause
+      // So the structure should be: (enforced AND enforced AND ...) AND (user_where)
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("triggered_at");
+      // The 1=1 should be within the user's OR clause, not affecting enforced conditions
+    });
+
+    it("should skip enforced conditions for columns that don't exist in table", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+          nonexistent_column: { op: "eq", value: "test" },
+        },
+      });
+
+      // Should not contain nonexistent_column
+      expect(sql).not.toContain("nonexistent_column");
+      // Should still have organization_id
+      expect(sql).toContain("organization_id");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty enforced conditions for non-tenant table", () => {
+      const { sql } = compileTSQL("SELECT id FROM reference_data", {
+        tableSchema: [nonTenantTableSchema],
+        enforcedWhereClause: {},
+      });
+
+      expect(sql).toContain("SELECT");
+      expect(sql).not.toContain("WHERE"); // No WHERE clause needed
+    });
+
+    it("should properly format numeric values", () => {
+      const { sql } = compileTSQL("SELECT id FROM task_runs", {
+        tableSchema: [taskRunsSchema],
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_123" },
+        },
+      });
+
+      // org_123 should be parameterized, not inlined
+      expect(sql).toContain("tsql_val_");
+    });
+  });
+});
+
diff --git a/internal-packages/tsql/src/index.ts b/internal-packages/tsql/src/index.ts
new file mode 100644
index 00000000000..923d8b8829f
--- /dev/null
+++ b/internal-packages/tsql/src/index.ts
@@ -0,0 +1,607 @@
+// TSQL - Type-Safe SQL Query Language for ClickHouse
+// Originally derived from PostHog's HogQL (see NOTICE.md for attribution)
+
+import type { ANTLRErrorListener, RecognitionException, Recognizer } from "antlr4ts";
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import type { Token } from "antlr4ts/Token";
+import { TSQLLexer } from "./grammar/TSQLLexer.js";
+import { TSQLParser } from "./grammar/TSQLParser.js";
+import type {
+  And,
+  BetweenExpr,
+  Call,
+  CompareOperation,
+  Constant,
+  Expression,
+  Field,
+  Not,
+  Or,
+  SelectQuery,
+  SelectSetQuery,
+  Tuple,
+} from "./query/ast.js";
+import { CompareOperationOp } from "./query/ast.js";
+import { SyntaxError as TSQLSyntaxError } from "./query/errors.js";
+import { TSQLParseTreeConverter } from "./query/parser.js";
+import { printToClickHouse, type PrintResult } from "./query/printer.js";
+import {
+  createPrinterContext,
+  type BetweenCondition,
+  type QuerySettings,
+  type SimpleComparisonCondition,
+  type TimeRange,
+  type WhereClauseCondition,
+} from "./query/printer_context.js";
+import { createSchemaRegistry, type FieldMappings, type TableSchema } from "./query/schema.js";
+
+/**
+ * Simple error listener that captures syntax errors
+ */
+class TSQLErrorListener implements ANTLRErrorListener<Token> {
+  public error: string | null = null;
+
+  syntaxError(
+    _recognizer: Recognizer<Token, any>,
+    _offendingSymbol: Token | undefined,
+    line: number,
+    charPositionInLine: number,
+    msg: string,
+    _e: RecognitionException | undefined
+  ): void {
+    this.error = `Syntax error at line ${line}:${charPositionInLine}: ${msg}`;
+  }
+}
+
+// Re-export AST types
+export * from "./query/ast.js";
+
+// Re-export errors
+export * from "./query/errors.js";
+
+// Re-export escape utilities
+export {
+  escapeClickHouseIdentifier,
+  escapeClickHouseString,
+  escapeTSQLIdentifier,
+  escapeTSQLString,
+  getClickHouseType,
+} from "./query/escape.js";
+
+// Re-export function definitions
+export {
+  findTSQLAggregation,
+  findTSQLFunction,
+  getAllExposedFunctionNames,
+  TSQL_AGGREGATIONS,
+  TSQL_CLICKHOUSE_FUNCTIONS,
+  TSQL_COMPARISON_MAPPING,
+  type TSQLFunctionMeta,
+} from "./query/functions.js";
+
+// Re-export schema types and functions
+export {
+  column,
+  createSchemaRegistry,
+  findColumn,
+  findTable,
+  getAllowedUserValues,
+  // Core column utilities
+  getCoreColumns,
+  getExternalValue,
+  getInternalValue,
+  getInternalValueFromMapping,
+  getInternalValueFromMappingCaseInsensitive,
+  // Value mapping utilities
+  getUserFriendlyValue,
+  getVirtualColumnExpression,
+  // Field mapping utilities (runtime dynamic mappings)
+  hasFieldMapping,
+  isValidUserValue,
+  // Virtual column utilities
+  isVirtualColumn,
+  // Error message sanitization
+  sanitizeErrorMessage,
+  validateFilterColumn,
+  validateGroupColumn,
+  validateSelectColumn,
+  validateSortColumn,
+  validateTable,
+  type ClickHouseType,
+  type ColumnSchema,
+  type FieldMappings,
+  type ColumnFormatType,
+  type OutputColumnMetadata,
+  type RequiredFilter,
+  type SchemaRegistry,
+  type TableSchema,
+  type TenantColumnConfig,
+} from "./query/schema.js";
+
+// Re-export printer context
+export {
+  createPrinterContext,
+  DEFAULT_QUERY_SETTINGS,
+  PrinterContext,
+  type BetweenCondition,
+  type InCondition,
+  type PrinterContextOptions,
+  type QueryNotice,
+  type QuerySettings,
+  type SimpleComparisonCondition,
+  type TimeRange,
+  type WhereClauseCondition,
+} from "./query/printer_context.js";
+
+// Re-export time bucket utilities
+export {
+  BUCKET_THRESHOLDS,
+  calculateTimeBucketInterval,
+  type BucketThreshold,
+  type TimeBucketInterval,
+} from "./query/time_buckets.js";
+
+// Re-export printer
+export { ClickHousePrinter, printToClickHouse, type PrintResult } from "./query/printer.js";
+
+// Re-export parser converter for advanced usage
+export { TSQLParseTreeConverter } from "./query/parser.js";
+
+// Re-export validator
+export {
+  validateQuery,
+  type ValidationIssue,
+  type ValidationResult,
+  type ValidationSeverity,
+} from "./query/validator.js";
+
+// Re-export result transformation utilities
+export {
+  createResultTransformer,
+  transformResults,
+  type TransformResultsOptions,
+} from "./query/results.js";
+
+/**
+ * Parse a TSQL SELECT query string into an AST
+ *
+ * @param query - The TSQL query string to parse
+ * @returns The parsed AST (SelectQuery or SelectSetQuery)
+ * @throws TSQLSyntaxError if the query is invalid
+ *
+ * @example
+ * ```typescript
+ * const ast = parseTSQLSelect("SELECT * FROM users WHERE id = 1");
+ * ```
+ */
+export function parseTSQLSelect(query: string): SelectQuery | SelectSetQuery {
+  const inputStream = CharStreams.fromString(query);
+  const lexer = new TSQLLexer(inputStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new TSQLParser(tokenStream);
+
+  // Remove default error listeners and add custom one
+  parser.removeErrorListeners();
+  const errorListener = new TSQLErrorListener();
+  parser.addErrorListener(errorListener);
+
+  const parseTree = parser.select();
+
+  if (errorListener.error) {
+    throw new TSQLSyntaxError(errorListener.error);
+  }
+
+  const converter = new TSQLParseTreeConverter();
+  const ast = converter.visit(parseTree);
+
+  // Validate the result is a select query
+  if (typeof ast === "string" || !("expression_type" in ast)) {
+    throw new TSQLSyntaxError("Failed to parse SELECT query");
+  }
+
+  if (ast.expression_type !== "select_query" && ast.expression_type !== "select_set_query") {
+    throw new TSQLSyntaxError(`Expected SELECT query, got ${ast.expression_type}`);
+  }
+
+  return ast as SelectQuery | SelectSetQuery;
+}
+
+/**
+ * Parse a TSQL expression string into an AST
+ *
+ * @param expr - The TSQL expression string to parse
+ * @returns The parsed expression AST
+ * @throws TSQLSyntaxError if the expression is invalid
+ *
+ * @example
+ * ```typescript
+ * const ast = parseTSQLExpr("id = 1 AND name = 'test'");
+ * ```
+ */
+export function parseTSQLExpr(expr: string): Expression {
+  const inputStream = CharStreams.fromString(expr);
+  const lexer = new TSQLLexer(inputStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new TSQLParser(tokenStream);
+
+  // Remove default error listeners and add custom one
+  parser.removeErrorListeners();
+  const errorListener = new TSQLErrorListener();
+  parser.addErrorListener(errorListener);
+
+  const parseTree = parser.columnExpr(0);
+
+  if (errorListener.error) {
+    throw new TSQLSyntaxError(errorListener.error);
+  }
+
+  const converter = new TSQLParseTreeConverter();
+  return converter.visit(parseTree) as Expression;
+}
+
+/**
+ * Check if a column is referenced in an expression (for WHERE clause detection).
+ * Recursively traverses And, Or, CompareOperation, BetweenExpr, and Field nodes.
+ *
+ * @param expr - The expression to search
+ * @param column - The column name to look for
+ * @returns true if the column is referenced in the expression
+ */
+export function isColumnReferencedInExpression(
+  expr: Expression | undefined,
+  column: string
+): boolean {
+  if (!expr) return false;
+
+  const exprType = (expr as Expression).expression_type;
+
+  switch (exprType) {
+    case "and": {
+      const andExpr = expr as And;
+      return andExpr.exprs.some((e) => isColumnReferencedInExpression(e, column));
+    }
+    case "or": {
+      const orExpr = expr as Or;
+      return orExpr.exprs.some((e) => isColumnReferencedInExpression(e, column));
+    }
+    case "compare_operation": {
+      const compareExpr = expr as CompareOperation;
+      return (
+        isColumnReferencedInExpression(compareExpr.left, column) ||
+        isColumnReferencedInExpression(compareExpr.right, column)
+      );
+    }
+    case "between_expr": {
+      const betweenExpr = expr as BetweenExpr;
+      return isColumnReferencedInExpression(betweenExpr.expr, column);
+    }
+    case "field": {
+      const fieldExpr = expr as Field;
+      // Check if any part of the chain matches the column name
+      // Handles both unqualified (column) and qualified (table.column) references
+      return fieldExpr.chain.some((part) => part === column);
+    }
+    case "not": {
+      const notExpr = expr as Not;
+      return isColumnReferencedInExpression(notExpr.expr, column);
+    }
+    default:
+      return false;
+  }
+}
+
+/**
+ * Format a Date as a ClickHouse-compatible DateTime64 string.
+ * ClickHouse expects format: 'YYYY-MM-DD HH:MM:SS.mmm' (in UTC)
+ */
+function formatDateForClickHouse(date: Date): string {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  const ms = String(date.getUTCMilliseconds()).padStart(3, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+}
+
+/**
+ * Create an AST expression for a fallback value.
+ * Date values are wrapped in toDateTime64() for ClickHouse compatibility.
+ */
+function createValueExpression(value: Date | string | number): Expression {
+  if (value instanceof Date) {
+    // Wrap Date in toDateTime64(formatted_string, 3) for ClickHouse DateTime64(3) columns
+    return {
+      expression_type: "call",
+      name: "toDateTime64",
+      args: [
+        { expression_type: "constant", value: formatDateForClickHouse(value) } as Constant,
+        { expression_type: "constant", value: 3 } as Constant,
+      ],
+    } as Call;
+  }
+  return { expression_type: "constant", value } as Constant;
+}
+
+/**
+ * Map fallback operator to CompareOperationOp
+ */
+function mapFallbackOpToCompareOp(op: SimpleComparisonCondition["op"]): CompareOperationOp {
+  switch (op) {
+    case "eq":
+      return CompareOperationOp.Eq;
+    case "neq":
+      return CompareOperationOp.NotEq;
+    case "gt":
+      return CompareOperationOp.Gt;
+    case "gte":
+      return CompareOperationOp.GtEq;
+    case "lt":
+      return CompareOperationOp.Lt;
+    case "lte":
+      return CompareOperationOp.LtEq;
+  }
+}
+
+/**
+ * Create an AST expression from a fallback condition
+ *
+ * @param column - The column name
+ * @param fallback - The fallback condition
+ * @returns The AST expression for the fallback condition
+ */
+export function createFallbackExpression(
+  column: string,
+  fallback: WhereClauseCondition
+): Expression {
+  const fieldExpr: Field = {
+    expression_type: "field",
+    chain: [column],
+  };
+
+  if (fallback.op === "between") {
+    const betweenExpr: BetweenExpr = {
+      expression_type: "between_expr",
+      expr: fieldExpr,
+      low: createValueExpression(fallback.low),
+      high: createValueExpression(fallback.high),
+    };
+    return betweenExpr;
+  }
+
+  if (fallback.op === "in") {
+    // Create a tuple of values for the IN clause
+    const tupleExpr: Tuple = {
+      expression_type: "tuple",
+      exprs: fallback.values.map((value) => createValueExpression(value)),
+    };
+    const inExpr: CompareOperation = {
+      expression_type: "compare_operation",
+      left: fieldExpr,
+      right: tupleExpr,
+      op: CompareOperationOp.In,
+    };
+    return inExpr;
+  }
+
+  // Simple comparison
+  const compareExpr: CompareOperation = {
+    expression_type: "compare_operation",
+    left: fieldExpr,
+    right: createValueExpression(fallback.value),
+    op: mapFallbackOpToCompareOp(fallback.op),
+  };
+  return compareExpr;
+}
+
+/**
+ * Inject fallback WHERE conditions into a parsed AST.
+ * Only adds fallback conditions for columns not already referenced in the WHERE clause.
+ *
+ * @param ast - The parsed SELECT query AST
+ * @param fallbacks - The fallback conditions to potentially inject
+ * @returns The modified AST with fallback conditions injected
+ */
+export function injectFallbackConditions(
+  ast: SelectQuery | SelectSetQuery,
+  fallbacks: Record<string, WhereClauseCondition>
+): SelectQuery | SelectSetQuery {
+  // Handle SelectSetQuery (UNION, etc.) - apply to each query in the set
+  if (ast.expression_type === "select_set_query") {
+    const setQuery = ast as SelectSetQuery;
+    // Process the initial select query
+    const modifiedInitial = injectFallbackConditions(
+      setQuery.initial_select_query,
+      fallbacks
+    ) as SelectQuery;
+
+    // Process subsequent queries
+    const modifiedSubsequent = setQuery.subsequent_select_queries.map((sq) => ({
+      ...sq,
+      select_query: injectFallbackConditions(sq.select_query, fallbacks) as SelectQuery,
+    }));
+
+    return {
+      ...setQuery,
+      initial_select_query: modifiedInitial,
+      subsequent_select_queries: modifiedSubsequent,
+    };
+  }
+
+  // Handle SelectQuery
+  const selectQuery = ast as SelectQuery;
+  const existingWhere = selectQuery.where;
+
+  // Collect fallback expressions for columns not already in WHERE
+  const fallbackExprs: Expression[] = [];
+  for (const [column, fallback] of Object.entries(fallbacks)) {
+    if (!isColumnReferencedInExpression(existingWhere, column)) {
+      fallbackExprs.push(createFallbackExpression(column, fallback));
+    }
+  }
+
+  // If no fallbacks to add, return original AST
+  if (fallbackExprs.length === 0) {
+    return ast;
+  }
+
+  // Combine fallbacks with existing WHERE using AND
+  let newWhere: Expression;
+  if (!existingWhere) {
+    // No existing WHERE - just use fallbacks
+    if (fallbackExprs.length === 1) {
+      newWhere = fallbackExprs[0];
+    } else {
+      newWhere = {
+        expression_type: "and",
+        exprs: fallbackExprs,
+      } as And;
+    }
+  } else {
+    // Combine existing WHERE with fallbacks
+    newWhere = {
+      expression_type: "and",
+      exprs: [...fallbackExprs, existingWhere],
+    } as And;
+  }
+
+  return {
+    ...selectQuery,
+    where: newWhere,
+  };
+}
+
+/**
+ * Options for compiling a TSQL query to ClickHouse SQL
+ */
+export interface CompileTSQLOptions {
+  /** Schema definitions for allowed tables and columns */
+  tableSchema: TableSchema[];
+  /**
+   * REQUIRED: Conditions always applied at the table level.
+   * Must include tenant columns (e.g., organization_id) for multi-tenant tables.
+   * Applied to every table reference including subqueries, CTEs, and JOINs.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   // Tenant isolation
+   *   organization_id: { op: "eq", value: "org_123" },
+   *   project_id: { op: "eq", value: "proj_456" },
+   *   environment_id: { op: "eq", value: "env_789" },
+   *   // Plan-based time limit
+   *   triggered_at: { op: "gte", value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
+   * }
+   * ```
+   */
+  enforcedWhereClause: Record<string, WhereClauseCondition | undefined>;
+  /** Optional query settings */
+  settings?: Partial<QuerySettings>;
+  /**
+   * Runtime field mappings for dynamic value translation.
+   * Maps internal ClickHouse values to external user-facing values.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   project: { "cm12345": "my-project-ref" },
+   * }
+   * ```
+   */
+  fieldMappings?: FieldMappings;
+  /**
+   * Fallback WHERE conditions to apply when the user hasn't filtered on a column.
+   * Key is the column name, value is the fallback condition.
+   * These are applied at the AST level (top-level query only).
+   *
+   * @example
+   * ```typescript
+   * // Apply time > 7 days ago if user doesn't filter on time
+   * whereClauseFallback: {
+   *   time: { op: 'gte', value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
+   * }
+   *
+   * // Apply time BETWEEN two dates if user doesn't filter on time
+   * whereClauseFallback: {
+   *   time: { op: 'between', low: startDate, high: endDate }
+   * }
+   * ```
+   */
+  whereClauseFallback?: Record<string, WhereClauseCondition>;
+  /**
+   * Time range for `timeBucket()` interval calculation.
+   * When provided, `timeBucket()` uses this to determine the appropriate bucket size
+   * based on the span of the time range.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   from: new Date('2024-01-01'),
+   *   to: new Date('2024-01-08'),
+   * }
+   * ```
+   */
+  timeRange?: TimeRange;
+}
+
+/**
+ * Compile a TSQL query string to ClickHouse SQL with parameters
+ *
+ * This function:
+ * 1. Parses the TSQL query into an AST
+ * 2. Validates tables and columns against the schema
+ * 3. Injects enforced WHERE clauses (tenant isolation + plan limits) at printer level
+ * 4. Optionally injects fallback WHERE conditions at AST level
+ * 5. Generates parameterized ClickHouse SQL
+ *
+ * @param query - The TSQL query string to compile
+ * @param options - Compilation options including enforcedWhereClause and schema
+ * @returns The compiled SQL and parameters
+ * @throws TSQLSyntaxError if the query is invalid
+ * @throws QueryError if tables/columns are not allowed or required tenant columns are missing
+ *
+ * @example
+ * ```typescript
+ * const { sql, params } = compileTSQL(
+ *   "SELECT * FROM task_runs WHERE status = 'completed' LIMIT 100",
+ *   {
+ *     tableSchema: [taskRunsSchema],
+ *     enforcedWhereClause: {
+ *       organization_id: { op: "eq", value: "org_123" },
+ *       project_id: { op: "eq", value: "proj_456" },
+ *       environment_id: { op: "eq", value: "env_789" },
+ *       triggered_at: { op: "gte", value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) },
+ *     },
+ *   }
+ * );
+ * ```
+ */
+export function compileTSQL(query: string, options: CompileTSQLOptions): PrintResult {
+  // 1. Parse the TSQL query
+  let ast = parseTSQLSelect(query);
+
+  // 2. Inject fallback WHERE conditions if provided (applied at AST level - top-level query only)
+  if (options.whereClauseFallback && Object.keys(options.whereClauseFallback).length > 0) {
+    ast = injectFallbackConditions(ast, options.whereClauseFallback);
+  }
+
+  // 3. Create schema registry from table schemas
+  const schemaRegistry = createSchemaRegistry(options.tableSchema);
+
+  // 4. Strip undefined values from enforcedWhereClause
+  const enforcedWhereClause = Object.fromEntries(
+    Object.entries(options.enforcedWhereClause).filter(([_, value]) => value !== undefined)
+  ) as Record<string, WhereClauseCondition>;
+
+  // 5. Create printer context with enforced WHERE clause and field mappings
+  const context = createPrinterContext({
+    schema: schemaRegistry,
+    settings: options.settings,
+    fieldMappings: options.fieldMappings,
+    enforcedWhereClause,
+    timeRange: options.timeRange,
+  });
+
+  // 6. Print the AST to ClickHouse SQL (enforced conditions applied at printer level)
+  return printToClickHouse(ast, context);
+}
diff --git a/internal-packages/tsql/src/query/ast.ts b/internal-packages/tsql/src/query/ast.ts
new file mode 100644
index 00000000000..4ef1e7e2d8c
--- /dev/null
+++ b/internal-packages/tsql/src/query/ast.ts
@@ -0,0 +1,672 @@
+// TypeScript translation of posthog/hogql/ast.py
+
+import type { TSQLContext } from "./context";
+import type {
+  DatabaseField,
+  ExpressionField,
+  FieldOrTable,
+  FieldTraverser,
+  LazyJoin,
+  LazyTable,
+  StringArrayDatabaseField,
+  StringJSONDatabaseField,
+  Table,
+  UnknownDatabaseField,
+  VirtualTable,
+} from "./models";
+import type { ConstantDataType, TSQLQuerySettings } from "./constants";
+
+// Base types
+export interface AST {
+  start?: number;
+  end?: number;
+  accept?(visitor: any): any;
+}
+
+export interface Type extends AST {
+  get_child?(name: string, context: TSQLContext): Type;
+  has_child?(name: string, context: TSQLContext): boolean;
+  resolve_constant_type?(context: TSQLContext): ConstantType;
+  resolve_column_constant_type?(name: string, context: TSQLContext): ConstantType;
+}
+
+export interface Expr extends AST {
+  type?: Type;
+}
+
+export interface ConstantType extends Type {
+  data_type: ConstantDataType;
+  nullable?: boolean;
+  print_type?(): string;
+}
+
+export interface UnknownType extends ConstantType {
+  data_type: "unknown";
+}
+
+export type Expression =
+  | CTE
+  | Alias
+  | ArithmeticOperation
+  | And
+  | Or
+  | CompareOperation
+  | Not
+  | BetweenExpr
+  | OrderExpr
+  | ArrayAccess
+  | Array
+  | Dict
+  | TupleAccess
+  | Tuple
+  | Lambda
+  | Constant
+  | Field
+  | Placeholder
+  | Call
+  | ExprCall
+  | JoinConstraint
+  | JoinExpr
+  | WindowFrameExpr
+  | WindowExpr
+  | WindowFunction
+  | LimitByExpr
+  | SelectQuery
+  | SelectSetQuery
+  | RatioExpr
+  | SampleExpr
+  | TSQLXTag;
+
+export interface CTE extends Expr {
+  expression_type: "cte";
+  name: string;
+  expr: Expression;
+  cte_type: "column" | "subquery";
+}
+
+// Type system
+export type TableOrSelectType =
+  | BaseTableType
+  | SelectSetQueryType
+  | SelectQueryType
+  | SelectQueryAliasType;
+
+export interface FieldAliasType extends Type {
+  alias: string;
+  type: Type;
+}
+
+export interface BaseTableType extends Type {
+  resolve_database_table?(context: TSQLContext): Table;
+}
+
+export interface TableType extends BaseTableType {
+  table: Table;
+}
+
+export interface LazyJoinType extends BaseTableType {
+  table_type: TableOrSelectType;
+  field: string;
+  lazy_join: LazyJoin;
+}
+
+export interface LazyTableType extends BaseTableType {
+  table: LazyTable;
+}
+
+export interface TableAliasType extends BaseTableType {
+  alias: string;
+  table_type: TableType | LazyTableType;
+}
+
+export interface VirtualTableType extends BaseTableType {
+  table_type: TableOrSelectType;
+  field: string;
+  virtual_table: VirtualTable;
+}
+
+export interface SelectQueryType extends Type {
+  aliases: Record<string, FieldAliasType>;
+  columns: Record<string, Type>;
+  tables: Record<string, TableOrSelectType>;
+  ctes: Record<string, CTE>;
+  anonymous_tables: (SelectQueryType | SelectSetQueryType)[];
+  parent?: SelectQueryType | SelectSetQueryType;
+  is_lambda_type?: boolean;
+}
+
+export interface SelectSetQueryType extends Type {
+  types: (SelectQueryType | SelectSetQueryType)[];
+}
+
+export interface SelectViewType extends BaseTableType {
+  view_name: string;
+  alias: string;
+  select_query_type: SelectQueryType | SelectSetQueryType;
+}
+
+export interface SelectQueryAliasType extends Type {
+  alias: string;
+  select_query_type: SelectQueryType | SelectSetQueryType;
+}
+
+export interface IntegerType extends ConstantType {
+  data_type: "int";
+}
+
+export interface DecimalType extends ConstantType {
+  data_type: "unknown";
+}
+
+export interface FloatType extends ConstantType {
+  data_type: "float";
+}
+
+export interface StringType extends ConstantType {
+  data_type: "str";
+}
+
+export interface StringJSONType extends StringType {}
+
+export interface StringArrayType extends StringType {}
+
+export interface BooleanType extends ConstantType {
+  data_type: "bool";
+}
+
+export interface DateType extends ConstantType {
+  data_type: "date";
+}
+
+export interface DateTimeType extends ConstantType {
+  data_type: "datetime";
+}
+
+export interface IntervalType extends ConstantType {
+  data_type: "unknown";
+}
+
+export interface UUIDType extends ConstantType {
+  data_type: "uuid";
+}
+
+export interface ArrayType extends ConstantType {
+  data_type: "array";
+  item_type: ConstantType;
+}
+
+export interface TupleType extends ConstantType {
+  data_type: "tuple";
+  item_types: ConstantType[];
+  repeat?: boolean;
+}
+
+export interface CallType extends Type {
+  name: string;
+  arg_types: ConstantType[];
+  param_types?: ConstantType[];
+  return_type: ConstantType;
+}
+
+export interface AsteriskType extends Type {
+  table_type: TableOrSelectType;
+}
+
+export interface FieldTraverserType extends Type {
+  chain: (string | number)[];
+  table_type: TableOrSelectType;
+}
+
+export interface ExpressionFieldType extends Type {
+  name: string;
+  expr: Expression;
+  table_type: TableOrSelectType;
+  isolate_scope?: boolean;
+}
+
+export interface FieldType extends Type {
+  name: string;
+  table_type: TableOrSelectType;
+}
+
+export interface UnresolvedFieldType extends Type {
+  name: string;
+}
+
+export interface PropertyType extends Type {
+  chain: (string | number)[];
+  field_type: FieldType;
+  joined_subquery?: SelectQueryAliasType;
+  joined_subquery_field_name?: string;
+}
+
+export interface LambdaArgumentType extends Type {
+  name: string;
+}
+
+// Enums
+export enum ArithmeticOperationOp {
+  Add = "+",
+  Sub = "-",
+  Mult = "*",
+  Div = "/",
+  Mod = "%",
+}
+
+export enum CompareOperationOp {
+  Eq = "==",
+  NotEq = "!=",
+  Gt = ">",
+  GtEq = ">=",
+  Lt = "<",
+  LtEq = "<=",
+  Like = "like",
+  ILike = "ilike",
+  NotLike = "not like",
+  NotILike = "not ilike",
+  In = "in",
+  GlobalIn = "global in",
+  NotIn = "not in",
+  GlobalNotIn = "global not in",
+  InCohort = "in cohort",
+  NotInCohort = "not in cohort",
+  Regex = "=~",
+  IRegex = "=~*",
+  NotRegex = "!~",
+  NotIRegex = "!~*",
+}
+
+export const NEGATED_COMPARE_OPS: CompareOperationOp[] = [
+  CompareOperationOp.NotEq,
+  CompareOperationOp.NotLike,
+  CompareOperationOp.NotILike,
+  CompareOperationOp.NotIn,
+  CompareOperationOp.GlobalNotIn,
+  CompareOperationOp.NotInCohort,
+  CompareOperationOp.NotRegex,
+  CompareOperationOp.NotIRegex,
+];
+
+export type SetOperator =
+  | "UNION ALL"
+  | "UNION DISTINCT"
+  | "INTERSECT"
+  | "INTERSECT DISTINCT"
+  | "EXCEPT";
+
+export type ParseResult = Expression | Declaration | string;
+
+// Declaration and Statement types
+export interface Declaration extends AST {}
+
+export interface VariableAssignment extends Declaration {
+  left: Expression;
+  right: Expression;
+}
+
+export interface VariableDeclaration extends Declaration {
+  name: string;
+  expr?: Expression;
+}
+
+export interface Statement extends Declaration {}
+
+export interface ExprStatement extends Statement {
+  expr?: Expression;
+}
+
+export interface ReturnStatement extends Statement {
+  expr?: Expression;
+}
+
+export interface ThrowStatement extends Statement {
+  expr?: Expression;
+}
+
+export interface TryCatchStatement extends Statement {
+  try_stmt: Statement;
+  catches: [string | null, string | null, Statement][];
+  finally_stmt?: Statement;
+}
+
+export interface IfStatement extends Statement {
+  expr: Expression;
+  then: Statement;
+  else_?: Statement;
+}
+
+export interface WhileStatement extends Statement {
+  expr: Expression;
+  body: Statement;
+}
+
+export interface ForStatement extends Statement {
+  initializer?: VariableDeclaration | VariableAssignment | Expression;
+  condition?: Expression;
+  increment?: VariableDeclaration;
+  body: Statement;
+}
+
+export interface ForInStatement extends Statement {
+  keyVar?: string;
+  valueVar: string;
+  expr: Expression;
+  body: Statement;
+}
+
+export interface Function extends Statement {
+  name: string;
+  params: string[];
+  body: Statement;
+}
+
+export interface Block extends Statement {
+  declarations: Declaration[];
+}
+
+export interface Program extends AST {
+  declarations: Declaration[];
+}
+
+// Expression types
+export interface Alias extends Expr {
+  expression_type: "alias";
+  alias: string;
+  expr: Expression;
+  hidden?: boolean;
+  from_asterisk?: boolean;
+}
+
+export interface ArithmeticOperation extends Expr {
+  expression_type: "arithmetic_operation";
+  left: Expression;
+  right: Expression;
+  op: ArithmeticOperationOp;
+}
+
+export interface And extends Expr {
+  expression_type: "and";
+  type?: ConstantType;
+  exprs: Expression[];
+}
+
+export interface Or extends Expr {
+  expression_type: "or";
+  exprs: Expression[];
+  type?: ConstantType;
+}
+
+export interface CompareOperation extends Expr {
+  expression_type: "compare_operation";
+  left: Expression;
+  right: Expression;
+  op: CompareOperationOp;
+  type?: ConstantType;
+}
+
+export interface Not extends Expr {
+  expression_type: "not";
+  expr: Expression;
+  type?: ConstantType;
+}
+
+export interface BetweenExpr extends Expr {
+  expression_type: "between_expr";
+  expr: Expression;
+  low: Expression;
+  high: Expression;
+  negated?: boolean;
+  type?: ConstantType;
+}
+
+export interface OrderExpr extends Expr {
+  expression_type: "order_expr";
+  expr: Expression;
+  order?: "ASC" | "DESC";
+}
+
+export interface ArrayAccess extends Expr {
+  expression_type: "array_access";
+  array: Expression;
+  property: Expression;
+  nullish?: boolean;
+}
+
+export interface Array extends Expr {
+  expression_type: "array";
+  exprs: Expression[];
+}
+
+export interface Dict extends Expr {
+  expression_type: "dict";
+  items: [Expression, Expression][];
+}
+
+export interface TupleAccess extends Expr {
+  expression_type: "tuple_access";
+  tuple: Expression;
+  index: number;
+  nullish?: boolean;
+}
+
+export interface Tuple extends Expr {
+  expression_type: "tuple";
+  exprs: Expression[];
+}
+
+export interface Lambda extends Expr {
+  expression_type: "lambda";
+  args: string[];
+  expr: Expression | Block;
+}
+
+export interface Constant extends Expr {
+  expression_type: "constant";
+  value: any;
+}
+
+export interface Field extends Expr {
+  expression_type: "field";
+  chain: (string | number)[];
+  from_asterisk?: boolean;
+}
+
+export interface Placeholder extends Expr {
+  expression_type: "placeholder";
+  expr: Expression;
+  // Computed properties
+  chain?: (string | number)[] | null;
+  field?: string | null;
+}
+
+export interface Call extends Expr {
+  expression_type: "call";
+  name: string;
+  args: Expression[];
+  params?: Expression[];
+  distinct?: boolean;
+}
+
+export interface ExprCall extends Expr {
+  expression_type: "expr_call";
+  expr: Expression;
+  args: Expression[];
+}
+
+export interface JoinConstraint extends Expr {
+  expression_type: "join_constraint";
+  expr: Expression;
+  constraint_type: "ON" | "USING";
+}
+
+export interface JoinExpr extends Expr {
+  expression_type: "join_expr";
+  type?: TableOrSelectType;
+  join_type?: string;
+  table?: SelectQuery | SelectSetQuery | Placeholder | TSQLXTag | Field;
+  table_args?: Expression[];
+  alias?: string;
+  table_final?: boolean;
+  constraint?: JoinConstraint;
+  next_join?: JoinExpr;
+  sample?: SampleExpr;
+}
+
+export interface WindowFrameExpr extends Expr {
+  expression_type: "window_frame_expr";
+  frame_type?: "CURRENT ROW" | "PRECEDING" | "FOLLOWING";
+  frame_value?: number;
+}
+
+export interface WindowExpr extends Expr {
+  expression_type: "window_expr";
+  partition_by?: Expression[];
+  order_by?: OrderExpr[];
+  frame_method?: "ROWS" | "RANGE";
+  frame_start?: WindowFrameExpr;
+  frame_end?: WindowFrameExpr;
+}
+
+export interface WindowFunction extends Expr {
+  expression_type: "window_function";
+  name: string;
+  args?: Expression[];
+  exprs?: Expression[];
+  over_expr?: WindowExpr;
+  over_identifier?: string;
+}
+
+export interface LimitByExpr extends Expr {
+  expression_type: "limit_by_expr";
+  n: Expression;
+  exprs: Expression[];
+  offset_value?: Expression;
+}
+
+export interface SelectQuery extends Expr {
+  expression_type: "select_query";
+  type?: SelectQueryType;
+  ctes?: Record<string, CTE>;
+  select: Expression[];
+  distinct?: boolean;
+  select_from?: JoinExpr;
+  array_join_op?: string;
+  array_join_list?: Expression[];
+  window_exprs?: Record<string, WindowExpr>;
+  where?: Expression;
+  prewhere?: Expression;
+  having?: Expression;
+  group_by?: Expression[];
+  order_by?: OrderExpr[];
+  limit?: Expression;
+  limit_by?: LimitByExpr;
+  limit_with_ties?: boolean;
+  offset?: Expression;
+  settings?: TSQLQuerySettings;
+  view_name?: string;
+}
+
+export interface SelectSetNode extends AST {
+  select_query: SelectQuery | SelectSetQuery;
+  set_operator: SetOperator;
+}
+
+export interface SelectSetQuery extends Expr {
+  expression_type: "select_set_query";
+  type?: SelectSetQueryType;
+  initial_select_query: SelectQuery | SelectSetQuery;
+  subsequent_select_queries: SelectSetNode[];
+  // Equivalent to select_queries() method
+  select_queries?(): (SelectQuery | SelectSetQuery)[];
+}
+
+// Add static method equivalent for SelectSetQuery.create_from_queries()
+export namespace SelectSetQuery {
+  export function createFromQueries(
+    queries: (SelectQuery | SelectSetQuery)[],
+    set_operator: SetOperator
+  ): SelectQuery | SelectSetQuery {
+    return createSelectSetQueryFromQueries(queries, set_operator);
+  }
+}
+
+export interface RatioExpr extends Expr {
+  expression_type: "ratio_expr";
+  left: Constant;
+  right?: Constant;
+}
+
+export interface SampleExpr extends Expr {
+  expression_type: "sample_expr";
+  sample_value: RatioExpr;
+  offset_value?: RatioExpr;
+}
+
+export interface TSQLXAttribute extends AST {
+  name: string;
+  value: any;
+}
+
+export interface TSQLXTag extends Expr {
+  expression_type: "tsqlx_tag";
+  kind: string;
+  attributes: TSQLXAttribute[];
+  // Equivalent to to_dict() method
+  to_dict?(): Record<string, any>;
+}
+
+// Helper function to create empty SelectQuery (equivalent to SelectQuery.empty())
+export function createEmptySelectQuery(columns?: Record<string, FieldOrTable>): SelectQuery {
+  if (!columns) {
+    columns = { _: { name: "_" } as UnknownDatabaseField };
+  }
+
+  return {
+    expression_type: "select_query",
+    select: Object.entries(columns).map(([column, field]) => ({
+      expression_type: "alias" as const,
+      alias: column,
+      expr: {
+        expression_type: "constant",
+        value: (field as DatabaseField).default_value?.() ?? null,
+      } as Constant,
+    })),
+    where: { expression_type: "constant", value: false } as Constant,
+  };
+}
+
+// Add static method equivalent for SelectQuery.empty()
+export namespace SelectQuery {
+  export function empty(columns?: Record<string, FieldOrTable>): SelectQuery {
+    return createEmptySelectQuery(columns);
+  }
+}
+
+// Helper function for SelectSetQuery.select_queries()
+export function selectQueries(query: SelectSetQuery): (SelectQuery | SelectSetQuery)[] {
+  return [
+    query.initial_select_query,
+    ...query.subsequent_select_queries.map((node) => node.select_query),
+  ];
+}
+
+// Helper function to create SelectSetQuery from multiple queries
+export function createSelectSetQueryFromQueries(
+  queries: (SelectQuery | SelectSetQuery)[],
+  set_operator: SetOperator
+): SelectQuery | SelectSetQuery {
+  if (queries.length === 0) {
+    throw new Error("Cannot create a SelectSetQuery from an empty list of queries");
+  } else if (queries.length === 1) {
+    return queries[0];
+  }
+
+  return {
+    expression_type: "select_set_query",
+    initial_select_query: queries[0],
+    subsequent_select_queries: queries.slice(1).map((query) => ({
+      select_query: query,
+      set_operator,
+    })) as SelectSetNode[],
+  } as SelectSetQuery;
+}
diff --git a/internal-packages/tsql/src/query/constants.ts b/internal-packages/tsql/src/query/constants.ts
new file mode 100644
index 00000000000..f698d3cc7aa
--- /dev/null
+++ b/internal-packages/tsql/src/query/constants.ts
@@ -0,0 +1,71 @@
+// TypeScript translation of posthog/hogql/constants.py
+
+export type ConstantDataType =
+  | "int"
+  | "float"
+  | "str"
+  | "bool"
+  | "array"
+  | "tuple"
+  | "date"
+  | "datetime"
+  | "uuid"
+  | "unknown";
+
+export type ConstantSupportedPrimitive = number | string | boolean | Date | null;
+export type ConstantSupportedData =
+  | ConstantSupportedPrimitive
+  | ConstantSupportedPrimitive[]
+  | [ConstantSupportedPrimitive, ...ConstantSupportedPrimitive[]];
+
+export const KEYWORDS = ["true", "false", "null"] as const;
+export const RESERVED_KEYWORDS = [...KEYWORDS, "team_id"] as const;
+
+export const DEFAULT_RETURNED_ROWS = 100;
+export const MAX_SELECT_RETURNED_ROWS = 50000;
+export const MAX_SELECT_RETENTION_LIMIT = 100000;
+export const MAX_SELECT_HEATMAPS_LIMIT = 1000000;
+export const MAX_SELECT_COHORT_CALCULATION_LIMIT = 1000000000;
+export const MAX_BYTES_BEFORE_EXTERNAL_GROUP_BY = 22 * 1024 * 1024 * 1024;
+export const CSV_EXPORT_LIMIT = 300000;
+export const CSV_EXPORT_BREAKDOWN_LIMIT_INITIAL = 512;
+export const CSV_EXPORT_BREAKDOWN_LIMIT_LOW = 64;
+export const BREAKDOWN_VALUES_LIMIT = 25;
+export const BREAKDOWN_VALUES_LIMIT_FOR_COUNTRIES = 300;
+
+export enum LimitContext {
+  QUERY = "query",
+  QUERY_ASYNC = "query_async",
+  EXPORT = "export",
+  COHORT_CALCULATION = "cohort_calculation",
+  HEATMAPS = "heatmaps",
+  SAVED_QUERY = "saved_query",
+  RETENTION = "retention",
+}
+
+// Settings applied at the SELECT level
+export interface TSQLQuerySettings {
+  optimize_aggregation_in_order?: boolean;
+  date_time_output_format?: string;
+  date_time_input_format?: string;
+  join_algorithm?: string;
+}
+
+// Settings applied on top of all TSQL queries
+export interface TSQLGlobalSettings extends TSQLQuerySettings {
+  readonly?: number;
+  max_execution_time?: number;
+  max_memory_usage?: number;
+  max_threads?: number;
+  allow_experimental_object_type?: boolean;
+  format_csv_allow_double_quotes?: boolean;
+  max_ast_elements?: number;
+  max_expanded_ast_elements?: number;
+  max_bytes_before_external_group_by?: number;
+  allow_experimental_analyzer?: boolean;
+  transform_null_in?: boolean;
+  optimize_min_equality_disjunction_chain_length?: number;
+  allow_experimental_join_condition?: boolean;
+  preferred_block_size_bytes?: number;
+  use_hive_partitioning?: number;
+}
diff --git a/internal-packages/tsql/src/query/context.ts b/internal-packages/tsql/src/query/context.ts
new file mode 100644
index 00000000000..249d3faa282
--- /dev/null
+++ b/internal-packages/tsql/src/query/context.ts
@@ -0,0 +1,56 @@
+// TypeScript translation of posthog/hogql/context.py
+
+import type { LimitContext } from "./constants";
+import type { Database } from "./database";
+import type { PropertySwapper } from "./property_types";
+import type { TSQLTimings } from "./timings";
+
+export interface TSQLNotice {
+  start?: number;
+  end?: number;
+  message: string;
+  fix?: string;
+}
+
+export interface TSQLQueryModifiers {
+  optimizeJoinedFilters?: boolean;
+  debug?: boolean;
+  timings?: boolean;
+  useMaterializedViews?: boolean;
+  formatCsvAllowDoubleQuotes?: boolean;
+  convertToProjectTimezone?: boolean;
+  usePreaggregatedTableTransforms?: boolean;
+  optimizeProjections?: boolean;
+}
+
+export interface TSQLFieldAccess {
+  input: string[];
+  type?: "run";
+  field?: string;
+  sql: string;
+}
+
+export interface Team {
+  id: number;
+  project_id: number;
+}
+
+export interface TSQLContext {
+  team_id?: number;
+  team?: Team;
+  database?: Database;
+  values: Record<string, any>;
+  within_non_tsql_query?: boolean;
+  enable_select_queries?: boolean;
+  limit_top_select?: boolean;
+  limit_context?: LimitContext;
+  output_format?: string | null;
+  globals?: Record<string, any>;
+  warnings: TSQLNotice[];
+  notices: TSQLNotice[];
+  errors: TSQLNotice[];
+  timings: TSQLTimings;
+  modifiers: TSQLQueryModifiers;
+  debug?: boolean;
+  property_swapper?: PropertySwapper;
+}
diff --git a/internal-packages/tsql/src/query/database.ts b/internal-packages/tsql/src/query/database.ts
new file mode 100644
index 00000000000..e91e0132c53
--- /dev/null
+++ b/internal-packages/tsql/src/query/database.ts
@@ -0,0 +1,585 @@
+// TypeScript translation of posthog/hogql/database/database.py
+//
+// NOTE: This implementation requires database/ORM access for:
+// - serialize() method (needs DataWarehouseTable, DataWarehouseSavedQuery queries)
+// - create_for() method (needs Team, DataWarehouseJoin, DataWarehouseSavedQuery queries)
+// Adapt these methods to your database/ORM setup
+
+import type { ConstantType } from "./ast";
+import type { TSQLContext, TSQLQueryModifiers, Team } from "./context";
+import type {
+  DatabaseField,
+  ExpressionField,
+  FieldOrTable,
+  FieldTraverser,
+  LazyJoin,
+  Table,
+  TableNode,
+  VirtualTable,
+} from "./models";
+import type { TSQLTimings } from "./timings";
+import { QueryError, ResolutionError } from "./errors";
+import { TSQLTimings as TSQLTimingsClass } from "./timings";
+
+// Type definitions for schema serialization (adapt to your schema types)
+export interface DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+}
+
+export interface DatabaseSchemaSystemTable extends DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+}
+
+export interface DatabaseSchemaDataWarehouseTable extends DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+  format?: string;
+  url_pattern?: string;
+  schema?: DatabaseSchemaSchema;
+  source?: DatabaseSchemaSource;
+  row_count?: number;
+}
+
+export interface DatabaseSchemaViewTable extends DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+  query: { query: string };
+  row_count?: number;
+}
+
+export interface DatabaseSchemaManagedViewTable extends DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+  kind: string;
+  source_id?: string;
+  query: { query: string };
+}
+
+export interface DatabaseSchemaEndpointTable extends DatabaseSchemaTable {
+  fields: Record<string, DatabaseSchemaField>;
+  id: string;
+  name: string;
+  query: { query: string };
+  row_count?: number;
+  status?: string;
+}
+
+export interface DatabaseSchemaField {
+  name: string;
+  tsql_value: string;
+  type: DatabaseSerializedFieldType;
+  schema_valid: boolean;
+  fields?: string[];
+  table?: string;
+  chain?: Array<string | number>;
+  id?: string;
+}
+
+export interface DatabaseSchemaSchema {
+  id: string;
+  name: string;
+  should_sync: boolean;
+  incremental: boolean;
+  status: string;
+  last_synced_at: string;
+}
+
+export interface DatabaseSchemaSource {
+  id: string;
+  status: string;
+  source_type: string;
+  prefix: string;
+  last_synced_at?: string | null;
+}
+
+export enum DatabaseSerializedFieldType {
+  STRING = "string",
+  INTEGER = "integer",
+  FLOAT = "float",
+  DECIMAL = "decimal",
+  BOOLEAN = "boolean",
+  DATE = "date",
+  DATETIME = "datetime",
+  UUID = "uuid",
+  ARRAY = "array",
+  JSON = "json",
+  TUPLE = "tuple",
+  UNKNOWN = "unknown",
+  EXPRESSION = "expression",
+  VIEW = "view",
+  LAZY_TABLE = "lazy_table",
+  VIRTUAL_TABLE = "virtual_table",
+  FIELD_TRAVERSER = "field_traverser",
+}
+
+export interface SerializedField {
+  key: string;
+  name: string;
+  type: DatabaseSerializedFieldType;
+  schema_valid: boolean;
+  fields?: string[];
+  table?: string;
+  chain?: Array<string | number>;
+}
+
+import { TableNodeImpl } from "./models";
+
+export class Database {
+  // Users can query from the tables below
+  tables: TableNode;
+
+  private _warehouseTableNames: string[] = [];
+  private _warehouseSelfManagedTableNames: string[] = [];
+  private _viewTableNames: string[] = [];
+  private _coreTableNames: string[] = [];
+
+  private _timezone?: string | null;
+  private _weekStartDay?: string | null; // WeekStartDay enum
+
+  private _serializationErrors: Record<string, string> = {};
+
+  constructor(timezone?: string | null, weekStartDay?: string | null) {
+    // Initialize with root TableNode
+    this.tables = new TableNodeImpl("root");
+    this._timezone = timezone || null;
+    this._weekStartDay = weekStartDay || null;
+  }
+
+  getTimezone(): string {
+    return this._timezone || "UTC";
+  }
+
+  getWeekStartDay(): string {
+    return this._weekStartDay || "sunday"; // Adapt to your WeekStartDay enum
+  }
+
+  getSerializationErrors(): Record<string, string> {
+    /** Return any errors encountered during serialization. */
+    return { ...this._serializationErrors };
+  }
+
+  hasTable(tableName: string | string[]): boolean {
+    const path = typeof tableName === "string" ? tableName.split(".") : tableName;
+    return this.tables.has_child ? this.tables.has_child(path) : false;
+  }
+
+  getTableNode(tableName: string | string[]): TableNode {
+    let path: string[];
+    if (typeof tableName === "string") {
+      path = tableName.split(".");
+    } else {
+      path = tableName;
+    }
+
+    // Handle edge case where tableName is a list with a single string containing dots
+    if (path.length === 1 && path[0].includes(".")) {
+      path = path[0].split(".");
+    }
+
+    if (!this.tables.get_child) {
+      throw new ResolutionError(`TableNode.get_child not implemented`);
+    }
+    return this.tables.get_child(path);
+  }
+
+  getTable(tableName: string | string[]): Table {
+    try {
+      const node = this.getTableNode(tableName);
+      if (!node.get) {
+        throw new ResolutionError("TableNode.get not implemented");
+      }
+      const table = node.get();
+      if (!table || typeof table !== "object" || !("fields" in table)) {
+        throw new ResolutionError("Table is not set");
+      }
+      return table as Table;
+    } catch (e) {
+      const name = Array.isArray(tableName) ? tableName.join(".") : tableName;
+      if (e instanceof ResolutionError) {
+        throw new QueryError(`Unknown table \`${name}\`.`);
+      }
+      throw e;
+    }
+  }
+
+  getAllTableNames(): string[] {
+    const warehouseTableNames = this._warehouseTableNames.filter((x) => x.includes("."));
+
+    return [
+      ...this._coreTableNames,
+      ...warehouseTableNames,
+      ...this._warehouseSelfManagedTableNames,
+      ...this._viewTableNames,
+    ];
+  }
+
+  // Core tables exposed via SQL editor autocomplete and data management
+  getCoreTableNames(): string[] {
+    return [...this._coreTableNames, ...this.getSystemTableNames()];
+  }
+
+  getSystemTableNames(): string[] {
+    const systemNode = this.tables.children["system"];
+    if (systemNode && systemNode.resolve_all_table_names) {
+      return ["query_log", ...systemNode.resolve_all_table_names()];
+    }
+    return ["query_log"];
+  }
+
+  getWarehouseTableNames(): string[] {
+    return [...this._warehouseTableNames, ...this._warehouseSelfManagedTableNames];
+  }
+
+  getViewNames(): string[] {
+    return this._viewTableNames;
+  }
+
+  addCoreTable(tableName: string, node: TableNode): void {
+    if (this.tables.add_child) {
+      this.tables.add_child(node);
+    }
+    this._coreTableNames.push(tableName);
+  }
+
+  private _addWarehouseTables(node: TableNode): void {
+    if (this.tables.merge_with) {
+      this.tables.merge_with(node);
+    }
+    if (node.resolve_all_table_names) {
+      const names = node.resolve_all_table_names();
+      this._warehouseTableNames.push(...names.sort());
+    }
+  }
+
+  private _addWarehouseSelfManagedTables(node: TableNode): void {
+    if (this.tables.merge_with) {
+      this.tables.merge_with(node);
+    }
+    if (node.resolve_all_table_names) {
+      const names = node.resolve_all_table_names();
+      this._warehouseSelfManagedTableNames.push(...names.sort());
+    }
+  }
+
+  private _addViews(node: TableNode): void {
+    if (this.tables.merge_with) {
+      this.tables.merge_with(node);
+    }
+    if (node.resolve_all_table_names) {
+      const names = node.resolve_all_table_names();
+      this._viewTableNames.push(...names.sort());
+    }
+  }
+
+  serialize(context: TSQLContext, includeOnly?: Set<string>): Record<string, DatabaseSchemaTable> {
+    // NOTE: This method requires database queries to fetch:
+    // - DataWarehouseTable objects
+    // - DataWarehouseSavedQuery objects
+    // - External data sources and schemas
+    //
+    // Adapt this to your database/ORM setup
+
+    const tables: Record<string, DatabaseSchemaTable> = {};
+
+    if (!context.team_id) {
+      throw new ResolutionError("Must provide team_id to serialize database");
+    }
+
+    // Core tables
+    const coreTableNames = this.getCoreTableNames();
+    for (const tableName of coreTableNames) {
+      if (includeOnly && !includeOnly.has(tableName)) {
+        continue;
+      }
+
+      let fieldInput: Record<string, FieldOrTable> = {};
+      const table = this.getTable(tableName);
+      if ("get_asterisk" in table && typeof table.get_asterisk === "function") {
+        fieldInput = table.get_asterisk() || {};
+      } else if ("fields" in table) {
+        fieldInput = table.fields;
+      }
+
+      const fields = serializeFields(fieldInput, context, tableName.split("."), undefined);
+      const fieldsDict: Record<string, DatabaseSchemaField> = {};
+      for (const field of fields) {
+        fieldsDict[field.name] = field;
+      }
+      tables[tableName] = {
+        fields: fieldsDict,
+        id: tableName,
+        name: tableName,
+      } as DatabaseSchemaTable;
+    }
+
+    // System tables
+    const systemTables = this.getSystemTableNames();
+    for (const tableKey of systemTables) {
+      if (includeOnly && !includeOnly.has(tableKey)) {
+        continue;
+      }
+
+      let systemFieldInput: Record<string, FieldOrTable> = {};
+      const table = this.getTable(tableKey);
+      if ("get_asterisk" in table && typeof table.get_asterisk === "function") {
+        systemFieldInput = table.get_asterisk() || {};
+      } else if ("fields" in table) {
+        systemFieldInput = table.fields;
+      }
+
+      const fields = serializeFields(systemFieldInput, context, tableKey.split("."), undefined);
+      const fieldsDict: Record<string, DatabaseSchemaField> = {};
+      for (const field of fields) {
+        fieldsDict[field.name] = field;
+      }
+      tables[tableKey] = {
+        fields: fieldsDict,
+        id: tableKey,
+        name: tableKey,
+      } as DatabaseSchemaSystemTable;
+    }
+
+    // NOTE: Data Warehouse Tables and Views processing requires database queries
+    // Implement based on your database/ORM setup:
+    // - Fetch DataWarehouseTable objects
+    // - Fetch DataWarehouseSavedQuery objects
+    // - Process and serialize them
+
+    return tables;
+  }
+
+  static createFor(
+    teamId?: number,
+    options?: {
+      team?: Team;
+      modifiers?: TSQLQueryModifiers;
+      timings?: TSQLTimings;
+    }
+  ): Database {
+    // NOTE: This method requires extensive database/ORM access:
+    // - Team model queries
+    // - DataWarehouseTable queries
+    // - DataWarehouseSavedQuery queries
+    // - DataWarehouseJoin queries
+    // - GroupTypeMapping queries
+    // - Feature flag checks
+    //
+    // This is a skeleton structure - adapt to your setup
+
+    const timings = options?.timings || new TSQLTimingsClass();
+    const { team, modifiers } = options || {};
+
+    // Validate team/teamId
+    if (!teamId && !team) {
+      throw new Error("Either team_id or team must be provided");
+    }
+
+    if (team && teamId && team.id !== teamId) {
+      throw new Error("team_id and team must be the same");
+    }
+
+    // NOTE: Fetch team from database if not provided
+    // const fetchedTeam = team || await Team.findById(teamId);
+
+    // Create database instance
+    const database = timings.measure("database", () => {
+      // NOTE: Get timezone and week_start_day from team
+      // const timezone = fetchedTeam.timezone;
+      // const weekStartDay = fetchedTeam.week_start_day;
+      return new Database(undefined, undefined);
+    });
+
+    // NOTE: Apply modifiers, setup tables, etc.
+    // This requires extensive database access and table setup logic
+
+    return database;
+  }
+}
+
+// Helper functions
+
+const TSQL_CHARACTERS_TO_BE_WRAPPED = ["@", "-", "!", "$", "+"];
+
+function constantTypeToSerializedFieldType(
+  constantType: ConstantType
+): DatabaseSerializedFieldType | null {
+  // Type checking for ConstantType subtypes
+  // NOTE: In TypeScript, we need to check properties rather than instanceof
+  // since these are interfaces, not classes
+
+  if ("data_type" in constantType) {
+    const dataType = constantType.data_type;
+    if (dataType === "str") {
+      return DatabaseSerializedFieldType.STRING;
+    }
+    if (dataType === "bool") {
+      return DatabaseSerializedFieldType.BOOLEAN;
+    }
+    if (dataType === "date") {
+      return DatabaseSerializedFieldType.DATE;
+    }
+    if (dataType === "datetime") {
+      return DatabaseSerializedFieldType.DATETIME;
+    }
+    if (dataType === "uuid") {
+      return DatabaseSerializedFieldType.STRING;
+    }
+    if (dataType === "array") {
+      return DatabaseSerializedFieldType.ARRAY;
+    }
+    if (dataType === "tuple") {
+      return DatabaseSerializedFieldType.JSON;
+    }
+    if (dataType === "int") {
+      return DatabaseSerializedFieldType.INTEGER;
+    }
+    if (dataType === "float") {
+      return DatabaseSerializedFieldType.FLOAT;
+    }
+  }
+
+  // Fallback: check print_type if available
+  if ("print_type" in constantType && typeof constantType.print_type === "function") {
+    const printed = constantType.print_type();
+    if (printed === "String" || printed === "JSON" || printed === "Array") {
+      return printed === "String"
+        ? DatabaseSerializedFieldType.STRING
+        : printed === "JSON"
+        ? DatabaseSerializedFieldType.JSON
+        : DatabaseSerializedFieldType.ARRAY;
+    }
+    if (printed === "Boolean") return DatabaseSerializedFieldType.BOOLEAN;
+    if (printed === "Date") return DatabaseSerializedFieldType.DATE;
+    if (printed === "DateTime") return DatabaseSerializedFieldType.DATETIME;
+    if (printed === "UUID") return DatabaseSerializedFieldType.STRING;
+    if (printed === "Integer") return DatabaseSerializedFieldType.INTEGER;
+    if (printed === "Float") return DatabaseSerializedFieldType.FLOAT;
+    if (printed === "Decimal") return DatabaseSerializedFieldType.DECIMAL;
+  }
+
+  return null;
+}
+
+export function serializeFields(
+  fieldInput: Record<string, FieldOrTable>,
+  context: TSQLContext,
+  tableChain: string[],
+  dbColumns?: Record<string, any> // DataWarehouseTableColumns
+): DatabaseSchemaField[] {
+  // NOTE: This requires resolve_types_from_table from resolver
+  // Import as needed: import { resolveTypesFromTable } from '../resolver';
+
+  const fieldOutput: DatabaseSchemaField[] = [];
+
+  for (const [fieldKey, field] of Object.entries(fieldInput)) {
+    let schemaValid = true;
+
+    if (dbColumns) {
+      const column = dbColumns[fieldKey];
+      if (typeof column === "string") {
+        schemaValid = true;
+      } else if (column && typeof column === "object") {
+        schemaValid = column.valid !== false;
+      }
+    }
+
+    let tsqlValue: string;
+    if (TSQL_CHARACTERS_TO_BE_WRAPPED.some((char) => fieldKey.includes(char))) {
+      tsqlValue = `\`${fieldKey}\``;
+    } else {
+      tsqlValue = fieldKey;
+    }
+
+    if ("hidden" in field && field.hidden) {
+      continue;
+    }
+
+    if ("name" in field && "get_constant_type" in field) {
+      // DatabaseField
+      const dbField = field as DatabaseField;
+      let fieldType: DatabaseSerializedFieldType;
+
+      // Determine field type based on DatabaseField subclass
+      // NOTE: You'll need to check instanceof or use type guards
+      // For now, using a simplified approach
+      if (dbField.get_constant_type) {
+        const constantType = dbField.get_constant_type();
+        fieldType =
+          constantTypeToSerializedFieldType(constantType) || DatabaseSerializedFieldType.UNKNOWN;
+      } else {
+        fieldType = DatabaseSerializedFieldType.UNKNOWN;
+      }
+
+      fieldOutput.push({
+        name: fieldKey,
+        tsql_value: tsqlValue,
+        type: fieldType,
+        schema_valid: schemaValid,
+      });
+    } else if ("expr" in field) {
+      // ExpressionField
+      const exprField = field as ExpressionField;
+      // NOTE: Requires resolve_types_from_table
+      // const resolvedExpr = resolveTypesFromTable(exprField.expr, tableChain, context, 'tsql');
+      // const constantType = resolvedExpr.type?.resolve_constant_type(context);
+      // const fieldType = constantTypeToSerializedFieldType(constantType) || DatabaseSerializedFieldType.EXPRESSION;
+
+      fieldOutput.push({
+        name: fieldKey,
+        tsql_value: tsqlValue,
+        type: DatabaseSerializedFieldType.EXPRESSION,
+        schema_valid: schemaValid,
+      });
+    } else if ("resolve_table" in field) {
+      // LazyJoin
+      const lazyJoin = field as LazyJoin;
+      if (lazyJoin.resolve_table) {
+        const resolvedTable = lazyJoin.resolve_table(context);
+        const type =
+          "id" in resolvedTable && resolvedTable.id
+            ? DatabaseSerializedFieldType.VIEW
+            : DatabaseSerializedFieldType.LAZY_TABLE;
+
+        fieldOutput.push({
+          name: fieldKey,
+          tsql_value: tsqlValue,
+          type,
+          schema_valid: schemaValid,
+          table: resolvedTable.to_printed_tsql ? resolvedTable.to_printed_tsql() : fieldKey,
+          fields: "fields" in resolvedTable ? Object.keys(resolvedTable.fields) : [],
+          id: "id" in resolvedTable && resolvedTable.id ? String(resolvedTable.id) : fieldKey,
+        });
+      }
+    } else if ("fields" in field && !("resolve_table" in field)) {
+      // VirtualTable
+      const virtualTable = field as VirtualTable;
+      fieldOutput.push({
+        name: fieldKey,
+        tsql_value: tsqlValue,
+        type: DatabaseSerializedFieldType.VIRTUAL_TABLE,
+        schema_valid: schemaValid,
+        table: virtualTable.to_printed_tsql ? virtualTable.to_printed_tsql() : fieldKey,
+        fields: Object.keys(virtualTable.fields),
+      });
+    } else if ("chain" in field) {
+      // FieldTraverser
+      const traverser = field as FieldTraverser;
+      fieldOutput.push({
+        name: fieldKey,
+        tsql_value: tsqlValue,
+        type: DatabaseSerializedFieldType.FIELD_TRAVERSER,
+        schema_valid: schemaValid,
+        chain: traverser.chain,
+      });
+    }
+  }
+
+  return fieldOutput;
+}
diff --git a/internal-packages/tsql/src/query/errors.ts b/internal-packages/tsql/src/query/errors.ts
new file mode 100644
index 00000000000..c0da0d3cefb
--- /dev/null
+++ b/internal-packages/tsql/src/query/errors.ts
@@ -0,0 +1,61 @@
+// TypeScript translation of posthog/hogql/errors.py
+
+import type { Expr } from "./ast";
+
+export class BaseTSQLError extends Error {
+  message: string;
+  start?: number;
+  end?: number;
+
+  constructor(
+    message: string,
+    options?: {
+      start?: number;
+      end?: number;
+      node?: Expr;
+    }
+  ) {
+    super(message);
+    this.message = message;
+
+    if (options?.node && options.node.start !== undefined && options.node.end !== undefined) {
+      this.start = options.node.start;
+      this.end = options.node.end;
+    } else {
+      this.start = options?.start;
+      this.end = options?.end;
+    }
+  }
+}
+
+export class ExposedTSQLError extends BaseTSQLError {
+  /** An exception that can be exposed to the user. */
+}
+
+export class InternalTSQLError extends BaseTSQLError {
+  /** An internal exception in the TSQL engine. */
+}
+
+export class SyntaxError extends ExposedTSQLError {
+  /** The input does not conform to TSQL syntax. */
+}
+
+export class QueryError extends ExposedTSQLError {
+  /** The query is invalid, though correct syntactically. */
+}
+
+export class NotImplementedError extends InternalTSQLError {
+  /** This feature isn't implemented in TSQL (yet). */
+}
+
+export class ParsingError extends InternalTSQLError {
+  /** Parsing failed. */
+}
+
+export class ImpossibleASTError extends InternalTSQLError {
+  /** Parsing or resolution resulted in an impossible AST. */
+}
+
+export class ResolutionError extends InternalTSQLError {
+  /** Resolution of a table/field/expression failed. */
+}
diff --git a/internal-packages/tsql/src/query/escape.test.ts b/internal-packages/tsql/src/query/escape.test.ts
new file mode 100644
index 00000000000..5a74926dbb4
--- /dev/null
+++ b/internal-packages/tsql/src/query/escape.test.ts
@@ -0,0 +1,241 @@
+import { describe, it, expect } from "vitest";
+import {
+  escapeClickHouseIdentifier,
+  escapeTSQLIdentifier,
+  escapeClickHouseString,
+  escapeTSQLString,
+  getClickHouseType,
+  SQLValueEscaper,
+  safeIdentifier,
+} from "./escape.js";
+import { QueryError } from "./errors.js";
+
+describe("escapeClickHouseIdentifier", () => {
+  it("should pass through simple identifiers", () => {
+    expect(escapeClickHouseIdentifier("id")).toBe("id");
+    expect(escapeClickHouseIdentifier("user_name")).toBe("user_name");
+    expect(escapeClickHouseIdentifier("Column1")).toBe("Column1");
+    expect(escapeClickHouseIdentifier("_private")).toBe("_private");
+  });
+
+  it("should escape identifiers with special characters", () => {
+    expect(escapeClickHouseIdentifier("my column")).toBe("`my column`");
+    expect(escapeClickHouseIdentifier("table-name")).toBe("`table-name`");
+    expect(escapeClickHouseIdentifier("column.with.dots")).toBe("`column.with.dots`");
+  });
+
+  it("should escape identifiers starting with numbers", () => {
+    expect(escapeClickHouseIdentifier("1column")).toBe("`1column`");
+    expect(escapeClickHouseIdentifier("123")).toBe("`123`");
+  });
+
+  it("should escape backticks in identifiers", () => {
+    expect(escapeClickHouseIdentifier("column`name")).toBe("`column\\`name`");
+  });
+
+  it("should escape control characters", () => {
+    expect(escapeClickHouseIdentifier("col\nname")).toBe("`col\\nname`");
+    expect(escapeClickHouseIdentifier("col\tname")).toBe("`col\\tname`");
+  });
+
+  it("should throw for identifiers containing %", () => {
+    expect(() => escapeClickHouseIdentifier("column%name")).toThrow(QueryError);
+  });
+});
+
+describe("escapeTSQLIdentifier", () => {
+  it("should pass through simple identifiers", () => {
+    expect(escapeTSQLIdentifier("id")).toBe("id");
+    expect(escapeTSQLIdentifier("user_name")).toBe("user_name");
+  });
+
+  it("should allow dollar signs in identifiers", () => {
+    expect(escapeTSQLIdentifier("$property")).toBe("$property");
+    expect(escapeTSQLIdentifier("property$value")).toBe("property$value");
+  });
+
+  it("should handle numeric identifiers", () => {
+    expect(escapeTSQLIdentifier(0)).toBe("0");
+    expect(escapeTSQLIdentifier(123)).toBe("123");
+  });
+
+  it("should throw for identifiers containing %", () => {
+    expect(() => escapeTSQLIdentifier("column%name")).toThrow(QueryError);
+  });
+});
+
+describe("SQLValueEscaper", () => {
+  describe("ClickHouse dialect", () => {
+    const escaper = new SQLValueEscaper({ dialect: "clickhouse" });
+
+    it("should escape null", () => {
+      expect(escaper.visit(null)).toBe("NULL");
+      expect(escaper.visit(undefined)).toBe("NULL");
+    });
+
+    it("should escape booleans as numbers", () => {
+      expect(escaper.visit(true)).toBe("1");
+      expect(escaper.visit(false)).toBe("0");
+    });
+
+    it("should escape integers", () => {
+      expect(escaper.visit(0)).toBe("0");
+      expect(escaper.visit(42)).toBe("42");
+      expect(escaper.visit(-100)).toBe("-100");
+    });
+
+    it("should escape floats", () => {
+      expect(escaper.visit(3.14)).toBe("3.14");
+      expect(escaper.visit(-0.5)).toBe("-0.5");
+    });
+
+    it("should escape special floats", () => {
+      expect(escaper.visit(NaN)).toBe("NaN");
+      expect(escaper.visit(Infinity)).toBe("Inf");
+      expect(escaper.visit(-Infinity)).toBe("-Inf");
+    });
+
+    it("should escape strings with quotes", () => {
+      expect(escaper.visit("hello")).toBe("'hello'");
+      expect(escaper.visit("hello'world")).toBe("'hello\\'world'");
+    });
+
+    it("should escape strings with control characters", () => {
+      expect(escaper.visit("line1\nline2")).toBe("'line1\\nline2'");
+      expect(escaper.visit("col1\tcol2")).toBe("'col1\\tcol2'");
+    });
+
+    it("should escape arrays", () => {
+      expect(escaper.visit([1, 2, 3])).toBe("[1, 2, 3]");
+      expect(escaper.visit(["a", "b"])).toBe("['a', 'b']");
+      expect(escaper.visit(["hello", "world"])).toBe("['hello', 'world']");
+    });
+
+    it("should escape nested arrays", () => {
+      expect(
+        escaper.visit([
+          [1, 2],
+          [3, 4],
+        ])
+      ).toBe("[[1, 2], [3, 4]]");
+    });
+
+    it("should escape dates with toDateTime64 and default UTC timezone", () => {
+      const date = new Date("2024-01-15T10:30:00.500Z");
+      const result = escaper.visit(date);
+      expect(result).toBe("toDateTime64('2024-01-15 10:30:00.500000', 6, 'UTC')");
+    });
+
+    it("should escape dates with custom timezone", () => {
+      const escaperWithTz = new SQLValueEscaper({
+        dialect: "clickhouse",
+        timezone: "America/New_York",
+      });
+      const date = new Date("2024-01-15T10:30:00.500Z");
+      const result = escaperWithTz.visit(date);
+      expect(result).toBe("toDateTime64('2024-01-15 10:30:00.500000', 6, 'America/New_York')");
+    });
+  });
+
+  describe("TSQL dialect", () => {
+    const escaper = new SQLValueEscaper({ dialect: "tsql" });
+
+    it("should escape booleans as keywords", () => {
+      expect(escaper.visit(true)).toBe("true");
+      expect(escaper.visit(false)).toBe("false");
+    });
+
+    it("should escape dates with toDateTime and default UTC timezone", () => {
+      const date = new Date("2024-01-15T10:30:00.500Z");
+      const result = escaper.visit(date);
+      expect(result).toBe("toDateTime('2024-01-15 10:30:00.500000', 'UTC')");
+    });
+
+    it("should escape dates with custom timezone", () => {
+      const escaperWithTz = new SQLValueEscaper({
+        dialect: "tsql",
+        timezone: "Europe/London",
+      });
+      const date = new Date("2024-01-15T10:30:00.500Z");
+      const result = escaperWithTz.visit(date);
+      expect(result).toBe("toDateTime('2024-01-15 10:30:00.500000', 'Europe/London')");
+    });
+  });
+});
+
+describe("escapeClickHouseString", () => {
+  it("should escape string values", () => {
+    expect(escapeClickHouseString("test")).toBe("'test'");
+  });
+
+  it("should handle null", () => {
+    expect(escapeClickHouseString(null)).toBe("NULL");
+  });
+
+  it("should handle numbers", () => {
+    expect(escapeClickHouseString(42)).toBe("42");
+  });
+});
+
+describe("escapeTSQLString", () => {
+  it("should escape string values", () => {
+    expect(escapeTSQLString("test")).toBe("'test'");
+  });
+
+  it("should handle booleans differently from ClickHouse", () => {
+    expect(escapeTSQLString(true)).toBe("true");
+    expect(escapeTSQLString(false)).toBe("false");
+  });
+});
+
+describe("getClickHouseType", () => {
+  it("should return String for strings", () => {
+    expect(getClickHouseType("hello")).toBe("String");
+  });
+
+  it("should return UInt8 for booleans", () => {
+    expect(getClickHouseType(true)).toBe("UInt8");
+    expect(getClickHouseType(false)).toBe("UInt8");
+  });
+
+  it("should return Int32 for small integers", () => {
+    expect(getClickHouseType(42)).toBe("Int32");
+    expect(getClickHouseType(-100)).toBe("Int32");
+  });
+
+  it("should return Int64 for large integers", () => {
+    expect(getClickHouseType(3000000000)).toBe("Int64");
+    expect(getClickHouseType(-3000000000)).toBe("Int64");
+  });
+
+  it("should return Float64 for floats", () => {
+    expect(getClickHouseType(3.14)).toBe("Float64");
+  });
+
+  it("should return DateTime64(6) for dates", () => {
+    expect(getClickHouseType(new Date())).toBe("DateTime64(6)");
+  });
+
+  it("should return Array type for arrays", () => {
+    expect(getClickHouseType(["a", "b"])).toBe("Array(String)");
+    expect(getClickHouseType([1, 2])).toBe("Array(Int32)");
+    expect(getClickHouseType([])).toBe("Array(String)");
+  });
+
+  it("should return Nullable(String) for null", () => {
+    expect(getClickHouseType(null)).toBe("Nullable(String)");
+    expect(getClickHouseType(undefined)).toBe("Nullable(String)");
+  });
+});
+
+describe("safeIdentifier", () => {
+  it("should return identifier unchanged if no %", () => {
+    expect(safeIdentifier("column")).toBe("column");
+    expect(safeIdentifier("table_name")).toBe("table_name");
+  });
+
+  it("should remove % characters", () => {
+    expect(safeIdentifier("column%name")).toBe("columnname");
+    expect(safeIdentifier("%%test%%")).toBe("test");
+  });
+});
diff --git a/internal-packages/tsql/src/query/escape.ts b/internal-packages/tsql/src/query/escape.ts
new file mode 100644
index 00000000000..c0762d365bf
--- /dev/null
+++ b/internal-packages/tsql/src/query/escape.ts
@@ -0,0 +1,265 @@
+// TypeScript port of posthog/hogql/escape_sql.py
+// Keep this file in sync with the Python version
+
+import { QueryError } from "./errors";
+
+/**
+ * Character escape maps for ClickHouse string escaping
+ * Copied from clickhouse_driver.util.escape
+ *
+ * Note: In JavaScript, \a and \v are not recognized escape sequences like in Python.
+ * We use the actual ASCII codes: \x07 for bell (Python's \a) and \x0B for vertical tab.
+ */
+const escapeCharsMap: Record<string, string> = {
+  "\b": "\\b",
+  "\f": "\\f",
+  "\r": "\\r",
+  "\n": "\\n",
+  "\t": "\\t",
+  "\0": "\\0",
+  "\x07": "\\a", // Bell character (ASCII 7) - Python's \a
+  "\x0B": "\\v", // Vertical tab (ASCII 11) - use explicit code since JS \v may not work in all contexts
+  "\\": "\\\\",
+};
+
+const singlequoteEscapeCharsMap: Record<string, string> = {
+  ...escapeCharsMap,
+  "'": "\\'",
+};
+
+const backquoteEscapeCharsMap: Record<string, string> = {
+  ...escapeCharsMap,
+  "`": "\\`",
+};
+
+/**
+ * Sanitize an identifier by removing % characters
+ */
+export function safeIdentifier(identifier: string): string {
+  if (identifier.includes("%")) {
+    return identifier.replace(/%/g, "");
+  }
+  return identifier;
+}
+
+/**
+ * Escape a string value for use as a parameter in ClickHouse
+ * Copied from clickhouse_driver.util.escape_param
+ */
+export function escapeParamClickhouse(value: string): string {
+  const escaped = value
+    .split("")
+    .map((c) => singlequoteEscapeCharsMap[c] || c)
+    .join("");
+  return `'${escaped}'`;
+}
+
+/**
+ * Escape an identifier for use in TSQL/HogQL queries
+ * Adapted from clickhouse_driver.util.escape with support for $ in identifiers
+ */
+export function escapeTSQLIdentifier(identifier: string | number): string {
+  if (typeof identifier === "number") {
+    // In TSQL we allow integers as identifiers to access array elements
+    return String(identifier);
+  }
+
+  if (identifier.includes("%")) {
+    throw new QueryError(
+      `The TSQL identifier "${identifier}" is not permitted as it contains the "%" character`
+    );
+  }
+
+  // TSQL allows dollars in the identifier (same regex as frontend escapePropertyAsTSQLIdentifier)
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) {
+    return identifier;
+  }
+
+  const escaped = identifier
+    .split("")
+    .map((c) => backquoteEscapeCharsMap[c] || c)
+    .join("");
+  return `\`${escaped}\``;
+}
+
+/**
+ * Escape an identifier for use in ClickHouse queries
+ * Copied from clickhouse_driver.util.escape, adapted from single quotes to backquotes
+ */
+export function escapeClickHouseIdentifier(identifier: string): string {
+  if (identifier.includes("%")) {
+    throw new QueryError(
+      `The identifier "${identifier}" is not permitted as it contains the "%" character`
+    );
+  }
+
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    return identifier;
+  }
+
+  const escaped = identifier
+    .split("")
+    .map((c) => backquoteEscapeCharsMap[c] || c)
+    .join("");
+  return `\`${escaped}\``;
+}
+
+/**
+ * Type for values that can be escaped as SQL strings
+ */
+export type EscapableValue =
+  | null
+  | undefined
+  | string
+  | number
+  | boolean
+  | Date
+  | EscapableValue[]
+  | [EscapableValue, ...EscapableValue[]];
+
+/**
+ * SQL Value Escaper class that handles different types of values
+ * Port of SQLValueEscaper from escape_sql.py
+ */
+export class SQLValueEscaper {
+  private timezone: string;
+  private dialect: "tsql" | "clickhouse";
+
+  constructor(options: { timezone?: string; dialect?: "tsql" | "clickhouse" } = {}) {
+    this.timezone = options.timezone || "UTC";
+    this.dialect = options.dialect || "clickhouse";
+  }
+
+  visit(value: EscapableValue): string {
+    if (value === null || value === undefined) {
+      return this.visitNull();
+    }
+    if (typeof value === "string") {
+      return this.visitString(value);
+    }
+    if (typeof value === "boolean") {
+      return this.visitBoolean(value);
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return this.visitInt(value);
+      }
+      return this.visitFloat(value);
+    }
+    if (value instanceof Date) {
+      return this.visitDateTime(value);
+    }
+    if (Array.isArray(value)) {
+      return this.visitArray(value);
+    }
+
+    throw new QueryError(`SQLValueEscaper cannot handle value of type ${typeof value}`);
+  }
+
+  private visitNull(): string {
+    return "NULL";
+  }
+
+  private visitString(value: string): string {
+    return escapeParamClickhouse(value);
+  }
+
+  private visitBoolean(value: boolean): string {
+    if (this.dialect === "clickhouse") {
+      return value ? "1" : "0";
+    }
+    return value ? "true" : "false";
+  }
+
+  private visitInt(value: number): string {
+    return String(value);
+  }
+
+  private visitFloat(value: number): string {
+    if (Number.isNaN(value)) {
+      return "NaN";
+    }
+    if (!Number.isFinite(value)) {
+      return value < 0 ? "-Inf" : "Inf";
+    }
+    return String(value);
+  }
+
+  private visitDateTime(value: Date): string {
+    // Format: YYYY-MM-DD HH:MM:SS.ffffff
+    const pad = (n: number, len: number = 2) => String(n).padStart(len, "0");
+
+    const year = value.getUTCFullYear();
+    const month = pad(value.getUTCMonth() + 1);
+    const day = pad(value.getUTCDate());
+    const hours = pad(value.getUTCHours());
+    const minutes = pad(value.getUTCMinutes());
+    const seconds = pad(value.getUTCSeconds());
+    const ms = pad(value.getUTCMilliseconds(), 3);
+
+    const datetimeString = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}000`;
+
+    if (this.dialect === "tsql") {
+      return `toDateTime(${this.visitString(datetimeString)}, ${this.visitString(this.timezone)})`;
+    }
+    return `toDateTime64(${this.visitString(datetimeString)}, 6, ${this.visitString(
+      this.timezone
+    )})`;
+  }
+
+  private visitArray(value: EscapableValue[]): string {
+    return `[${value.map((x) => this.visit(x)).join(", ")}]`;
+  }
+}
+
+/**
+ * Escape a value for use in a TSQL/HogQL query string
+ */
+export function escapeTSQLString(value: EscapableValue, timezone?: string): string {
+  return new SQLValueEscaper({ timezone, dialect: "tsql" }).visit(value);
+}
+
+/**
+ * Escape a value for use in a ClickHouse query string
+ */
+export function escapeClickHouseString(value: EscapableValue, timezone?: string): string {
+  return new SQLValueEscaper({ timezone, dialect: "clickhouse" }).visit(value);
+}
+
+/**
+ * Get the ClickHouse type string for a value
+ * Used when creating parameterized query placeholders like {param: Type}
+ */
+export function getClickHouseType(value: unknown): string {
+  if (value === null || value === undefined) {
+    return "Nullable(String)";
+  }
+  if (typeof value === "string") {
+    return "String";
+  }
+  if (typeof value === "boolean") {
+    return "UInt8";
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      // Use Int64 for large integers, Int32 for smaller ones
+      if (value > 2147483647 || value < -2147483648) {
+        return "Int64";
+      }
+      return "Int32";
+    }
+    return "Float64";
+  }
+  if (value instanceof Date) {
+    return "DateTime64(6)";
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "Array(String)";
+    }
+    const itemType = getClickHouseType(value[0]);
+    return `Array(${itemType})`;
+  }
+  // Default to String for unknown types
+  return "String";
+}
diff --git a/internal-packages/tsql/src/query/functions.ts b/internal-packages/tsql/src/query/functions.ts
new file mode 100644
index 00000000000..f184ed8f382
--- /dev/null
+++ b/internal-packages/tsql/src/query/functions.ts
@@ -0,0 +1,665 @@
+// TypeScript port of posthog/hogql/functions/mapping.py and aggregations.py
+// Keep this file in sync with the Python version
+
+import { CompareOperationOp } from "./ast";
+
+/**
+ * Metadata for a TSQL function
+ */
+export interface TSQLFunctionMeta {
+  /** The ClickHouse function name to use */
+  clickhouseName: string;
+  /** Minimum number of arguments */
+  minArgs: number;
+  /** Maximum number of arguments (undefined means unlimited) */
+  maxArgs?: number;
+  /** Minimum number of parameters (for parametric functions) */
+  minParams?: number;
+  /** Maximum number of parameters */
+  maxParams?: number;
+  /** Whether this is an aggregate function */
+  aggregate?: boolean;
+  /** Whether function is case-sensitive */
+  caseSensitive?: boolean;
+  /** Whether function is timezone-aware (will append timezone as last arg) */
+  tzAware?: boolean;
+  /** Whether the function uses placeholder arguments like {} */
+  usingPlaceholderArguments?: boolean;
+}
+
+/**
+ * Comparison function mappings from function names to CompareOperationOp
+ */
+export const TSQL_COMPARISON_MAPPING: Record<string, CompareOperationOp> = {
+  equals: CompareOperationOp.Eq,
+  notEquals: CompareOperationOp.NotEq,
+  less: CompareOperationOp.Lt,
+  greater: CompareOperationOp.Gt,
+  lessOrEquals: CompareOperationOp.LtEq,
+  greaterOrEquals: CompareOperationOp.GtEq,
+  like: CompareOperationOp.Like,
+  ilike: CompareOperationOp.ILike,
+  notLike: CompareOperationOp.NotLike,
+  notILike: CompareOperationOp.NotILike,
+  in: CompareOperationOp.In,
+  notIn: CompareOperationOp.NotIn,
+};
+
+/**
+ * ClickHouse functions available in TSQL
+ * Port of HOGQL_CLICKHOUSE_FUNCTIONS from mapping.py
+ */
+export const TSQL_CLICKHOUSE_FUNCTIONS: Record<string, TSQLFunctionMeta> = {
+  // Comparison
+  equals: { clickhouseName: "equals", minArgs: 2, maxArgs: 2 },
+  notEquals: { clickhouseName: "notEquals", minArgs: 2, maxArgs: 2 },
+  less: { clickhouseName: "less", minArgs: 2, maxArgs: 2 },
+  greater: { clickhouseName: "greater", minArgs: 2, maxArgs: 2 },
+  lessOrEquals: { clickhouseName: "lessOrEquals", minArgs: 2, maxArgs: 2 },
+  greaterOrEquals: { clickhouseName: "greaterOrEquals", minArgs: 2, maxArgs: 2 },
+
+  // Logical
+  and: { clickhouseName: "and", minArgs: 2 },
+  or: { clickhouseName: "or", minArgs: 2 },
+  xor: { clickhouseName: "xor", minArgs: 2 },
+  not: { clickhouseName: "not", minArgs: 1, maxArgs: 1, caseSensitive: false },
+
+  // Conditional
+  if: { clickhouseName: "if", minArgs: 3, maxArgs: 3, caseSensitive: false },
+  multiIf: { clickhouseName: "multiIf", minArgs: 3 },
+
+  // In
+  in: { clickhouseName: "in", minArgs: 2, maxArgs: 2 },
+  notIn: { clickhouseName: "notIn", minArgs: 2, maxArgs: 2 },
+
+  // Arithmetic
+  plus: { clickhouseName: "plus", minArgs: 2, maxArgs: 2 },
+  minus: { clickhouseName: "minus", minArgs: 2, maxArgs: 2 },
+  multiply: { clickhouseName: "multiply", minArgs: 2, maxArgs: 2 },
+  divide: { clickhouseName: "divide", minArgs: 2, maxArgs: 2 },
+  intDiv: { clickhouseName: "intDiv", minArgs: 2, maxArgs: 2 },
+  intDivOrZero: { clickhouseName: "intDivOrZero", minArgs: 2, maxArgs: 2 },
+  modulo: { clickhouseName: "modulo", minArgs: 2, maxArgs: 2 },
+  moduloOrZero: { clickhouseName: "moduloOrZero", minArgs: 2, maxArgs: 2 },
+  positiveModulo: { clickhouseName: "positiveModulo", minArgs: 2, maxArgs: 2 },
+  negate: { clickhouseName: "negate", minArgs: 1, maxArgs: 1 },
+  abs: { clickhouseName: "abs", minArgs: 1, maxArgs: 1 },
+  gcd: { clickhouseName: "gcd", minArgs: 2, maxArgs: 2 },
+  lcm: { clickhouseName: "lcm", minArgs: 2, maxArgs: 2 },
+
+  // Mathematical
+  exp: { clickhouseName: "exp", minArgs: 1, maxArgs: 1 },
+  log: { clickhouseName: "log", minArgs: 1, maxArgs: 1 },
+  ln: { clickhouseName: "log", minArgs: 1, maxArgs: 1 },
+  exp2: { clickhouseName: "exp2", minArgs: 1, maxArgs: 1 },
+  log2: { clickhouseName: "log2", minArgs: 1, maxArgs: 1 },
+  exp10: { clickhouseName: "exp10", minArgs: 1, maxArgs: 1 },
+  log10: { clickhouseName: "log10", minArgs: 1, maxArgs: 1 },
+  sqrt: { clickhouseName: "sqrt", minArgs: 1, maxArgs: 1 },
+  cbrt: { clickhouseName: "cbrt", minArgs: 1, maxArgs: 1 },
+  erf: { clickhouseName: "erf", minArgs: 1, maxArgs: 1 },
+  erfc: { clickhouseName: "erfc", minArgs: 1, maxArgs: 1 },
+  lgamma: { clickhouseName: "lgamma", minArgs: 1, maxArgs: 1 },
+  tgamma: { clickhouseName: "tgamma", minArgs: 1, maxArgs: 1 },
+  sin: { clickhouseName: "sin", minArgs: 1, maxArgs: 1 },
+  cos: { clickhouseName: "cos", minArgs: 1, maxArgs: 1 },
+  tan: { clickhouseName: "tan", minArgs: 1, maxArgs: 1 },
+  asin: { clickhouseName: "asin", minArgs: 1, maxArgs: 1 },
+  acos: { clickhouseName: "acos", minArgs: 1, maxArgs: 1 },
+  atan: { clickhouseName: "atan", minArgs: 1, maxArgs: 1 },
+  pow: { clickhouseName: "pow", minArgs: 2, maxArgs: 2 },
+  power: { clickhouseName: "power", minArgs: 2, maxArgs: 2 },
+  round: { clickhouseName: "round", minArgs: 1, maxArgs: 2 },
+  floor: { clickhouseName: "floor", minArgs: 1, maxArgs: 2 },
+  ceil: { clickhouseName: "ceil", minArgs: 1, maxArgs: 2 },
+  ceiling: { clickhouseName: "ceiling", minArgs: 1, maxArgs: 2 },
+  trunc: { clickhouseName: "trunc", minArgs: 1, maxArgs: 2 },
+  truncate: { clickhouseName: "truncate", minArgs: 1, maxArgs: 2 },
+  sign: { clickhouseName: "sign", minArgs: 1, maxArgs: 1 },
+
+  // String functions
+  empty: { clickhouseName: "empty", minArgs: 1, maxArgs: 1 },
+  notEmpty: { clickhouseName: "notEmpty", minArgs: 1, maxArgs: 1 },
+  length: { clickhouseName: "length", minArgs: 1, maxArgs: 1 },
+  lengthUTF8: { clickhouseName: "lengthUTF8", minArgs: 1, maxArgs: 1 },
+  char_length: { clickhouseName: "char_length", minArgs: 1, maxArgs: 1 },
+  character_length: { clickhouseName: "character_length", minArgs: 1, maxArgs: 1 },
+  lower: { clickhouseName: "lower", minArgs: 1, maxArgs: 1 },
+  upper: { clickhouseName: "upper", minArgs: 1, maxArgs: 1 },
+  lowerUTF8: { clickhouseName: "lowerUTF8", minArgs: 1, maxArgs: 1 },
+  upperUTF8: { clickhouseName: "upperUTF8", minArgs: 1, maxArgs: 1 },
+  reverse: { clickhouseName: "reverse", minArgs: 1, maxArgs: 1 },
+  reverseUTF8: { clickhouseName: "reverseUTF8", minArgs: 1, maxArgs: 1 },
+  concat: { clickhouseName: "concat", minArgs: 1 },
+  concatAssumeInjective: { clickhouseName: "concatAssumeInjective", minArgs: 1 },
+  substring: { clickhouseName: "substring", minArgs: 2, maxArgs: 3 },
+  substr: { clickhouseName: "substring", minArgs: 2, maxArgs: 3 },
+  mid: { clickhouseName: "substring", minArgs: 2, maxArgs: 3 },
+  substringUTF8: { clickhouseName: "substringUTF8", minArgs: 2, maxArgs: 3 },
+  appendTrailingCharIfAbsent: { clickhouseName: "appendTrailingCharIfAbsent", minArgs: 2, maxArgs: 2 },
+  convertCharset: { clickhouseName: "convertCharset", minArgs: 3, maxArgs: 3 },
+  base58Encode: { clickhouseName: "base58Encode", minArgs: 1, maxArgs: 1 },
+  base58Decode: { clickhouseName: "base58Decode", minArgs: 1, maxArgs: 1 },
+  base64Encode: { clickhouseName: "base64Encode", minArgs: 1, maxArgs: 1 },
+  base64Decode: { clickhouseName: "base64Decode", minArgs: 1, maxArgs: 1 },
+  tryBase64Decode: { clickhouseName: "tryBase64Decode", minArgs: 1, maxArgs: 1 },
+  endsWith: { clickhouseName: "endsWith", minArgs: 2, maxArgs: 2 },
+  startsWith: { clickhouseName: "startsWith", minArgs: 2, maxArgs: 2 },
+  trim: { clickhouseName: "trim", minArgs: 1, maxArgs: 2 },
+  trimLeft: { clickhouseName: "trimLeft", minArgs: 1, maxArgs: 2 },
+  trimRight: { clickhouseName: "trimRight", minArgs: 1, maxArgs: 2 },
+  ltrim: { clickhouseName: "trimLeft", minArgs: 1, maxArgs: 1 },
+  rtrim: { clickhouseName: "trimRight", minArgs: 1, maxArgs: 1 },
+  leftPad: { clickhouseName: "leftPad", minArgs: 2, maxArgs: 3 },
+  rightPad: { clickhouseName: "rightPad", minArgs: 2, maxArgs: 3 },
+  leftPadUTF8: { clickhouseName: "leftPadUTF8", minArgs: 2, maxArgs: 3 },
+  rightPadUTF8: { clickhouseName: "rightPadUTF8", minArgs: 2, maxArgs: 3 },
+  left: { clickhouseName: "left", minArgs: 2, maxArgs: 2 },
+  right: { clickhouseName: "right", minArgs: 2, maxArgs: 2 },
+  repeat: { clickhouseName: "repeat", minArgs: 2, maxArgs: 2 },
+  space: { clickhouseName: "space", minArgs: 1, maxArgs: 1 },
+  replace: { clickhouseName: "replace", minArgs: 3, maxArgs: 3 },
+  replaceOne: { clickhouseName: "replaceOne", minArgs: 3, maxArgs: 3 },
+  replaceAll: { clickhouseName: "replaceAll", minArgs: 3, maxArgs: 3 },
+  replaceRegexpOne: { clickhouseName: "replaceRegexpOne", minArgs: 3, maxArgs: 3 },
+  replaceRegexpAll: { clickhouseName: "replaceRegexpAll", minArgs: 3, maxArgs: 3 },
+  position: { clickhouseName: "position", minArgs: 2, maxArgs: 2 },
+  positionCaseInsensitive: { clickhouseName: "positionCaseInsensitive", minArgs: 2, maxArgs: 2 },
+  positionUTF8: { clickhouseName: "positionUTF8", minArgs: 2, maxArgs: 2 },
+  positionCaseInsensitiveUTF8: { clickhouseName: "positionCaseInsensitiveUTF8", minArgs: 2, maxArgs: 2 },
+  locate: { clickhouseName: "locate", minArgs: 2, maxArgs: 2 },
+  match: { clickhouseName: "match", minArgs: 2, maxArgs: 2 },
+  multiMatchAny: { clickhouseName: "multiMatchAny", minArgs: 2, maxArgs: 2 },
+  multiMatchAnyIndex: { clickhouseName: "multiMatchAnyIndex", minArgs: 2, maxArgs: 2 },
+  multiMatchAllIndices: { clickhouseName: "multiMatchAllIndices", minArgs: 2, maxArgs: 2 },
+  multiSearchFirstPosition: { clickhouseName: "multiSearchFirstPosition", minArgs: 2, maxArgs: 2 },
+  multiSearchFirstIndex: { clickhouseName: "multiSearchFirstIndex", minArgs: 2, maxArgs: 2 },
+  multiSearchAny: { clickhouseName: "multiSearchAny", minArgs: 2, maxArgs: 2 },
+  extract: { clickhouseName: "extract", minArgs: 2, maxArgs: 2 },
+  extractAll: { clickhouseName: "extractAll", minArgs: 2, maxArgs: 2 },
+  extractAllGroupsHorizontal: { clickhouseName: "extractAllGroupsHorizontal", minArgs: 2, maxArgs: 2 },
+  extractAllGroupsVertical: { clickhouseName: "extractAllGroupsVertical", minArgs: 2, maxArgs: 2 },
+  like: { clickhouseName: "like", minArgs: 2, maxArgs: 2 },
+  ilike: { clickhouseName: "ilike", minArgs: 2, maxArgs: 2 },
+  notLike: { clickhouseName: "notLike", minArgs: 2, maxArgs: 2 },
+  notILike: { clickhouseName: "notILike", minArgs: 2, maxArgs: 2 },
+  splitByChar: { clickhouseName: "splitByChar", minArgs: 2, maxArgs: 3 },
+  splitByString: { clickhouseName: "splitByString", minArgs: 2, maxArgs: 3 },
+  splitByRegexp: { clickhouseName: "splitByRegexp", minArgs: 2, maxArgs: 3 },
+  arrayStringConcat: { clickhouseName: "arrayStringConcat", minArgs: 1, maxArgs: 2 },
+  format: { clickhouseName: "format", minArgs: 1 },
+  coalesce: { clickhouseName: "coalesce", minArgs: 1 },
+  ifNull: { clickhouseName: "ifNull", minArgs: 2, maxArgs: 2 },
+  nullIf: { clickhouseName: "nullIf", minArgs: 2, maxArgs: 2 },
+  assumeNotNull: { clickhouseName: "assumeNotNull", minArgs: 1, maxArgs: 1 },
+  toNullable: { clickhouseName: "toNullable", minArgs: 1, maxArgs: 1 },
+  isNull: { clickhouseName: "isNull", minArgs: 1, maxArgs: 1 },
+  isNotNull: { clickhouseName: "isNotNull", minArgs: 1, maxArgs: 1 },
+
+  // Type conversions
+  toString: { clickhouseName: "toString", minArgs: 1, maxArgs: 1 },
+  toFixedString: { clickhouseName: "toFixedString", minArgs: 2, maxArgs: 2 },
+  toUInt8: { clickhouseName: "toUInt8", minArgs: 1, maxArgs: 1 },
+  toUInt16: { clickhouseName: "toUInt16", minArgs: 1, maxArgs: 1 },
+  toUInt32: { clickhouseName: "toUInt32", minArgs: 1, maxArgs: 1 },
+  toUInt64: { clickhouseName: "toUInt64", minArgs: 1, maxArgs: 1 },
+  toInt8: { clickhouseName: "toInt8", minArgs: 1, maxArgs: 1 },
+  toInt16: { clickhouseName: "toInt16", minArgs: 1, maxArgs: 1 },
+  toInt32: { clickhouseName: "toInt32", minArgs: 1, maxArgs: 1 },
+  toInt64: { clickhouseName: "toInt64", minArgs: 1, maxArgs: 1 },
+  toInt128: { clickhouseName: "toInt128", minArgs: 1, maxArgs: 1 },
+  toInt256: { clickhouseName: "toInt256", minArgs: 1, maxArgs: 1 },
+  toUInt128: { clickhouseName: "toUInt128", minArgs: 1, maxArgs: 1 },
+  toUInt256: { clickhouseName: "toUInt256", minArgs: 1, maxArgs: 1 },
+  toFloat32: { clickhouseName: "toFloat32", minArgs: 1, maxArgs: 1 },
+  toFloat64: { clickhouseName: "toFloat64", minArgs: 1, maxArgs: 1 },
+  toDecimal32: { clickhouseName: "toDecimal32", minArgs: 2, maxArgs: 2 },
+  toDecimal64: { clickhouseName: "toDecimal64", minArgs: 2, maxArgs: 2 },
+  toDecimal128: { clickhouseName: "toDecimal128", minArgs: 2, maxArgs: 2 },
+  toDecimal256: { clickhouseName: "toDecimal256", minArgs: 2, maxArgs: 2 },
+  toDate: { clickhouseName: "toDate", minArgs: 1, maxArgs: 2 },
+  toDateOrNull: { clickhouseName: "toDateOrNull", minArgs: 1, maxArgs: 2 },
+  toDateOrZero: { clickhouseName: "toDateOrZero", minArgs: 1, maxArgs: 2 },
+  toDate32: { clickhouseName: "toDate32", minArgs: 1, maxArgs: 2 },
+  toDate32OrNull: { clickhouseName: "toDate32OrNull", minArgs: 1, maxArgs: 2 },
+  toDate32OrZero: { clickhouseName: "toDate32OrZero", minArgs: 1, maxArgs: 2 },
+  toDateTime: { clickhouseName: "toDateTime", minArgs: 1, maxArgs: 2 },
+  toDateTimeOrNull: { clickhouseName: "toDateTimeOrNull", minArgs: 1, maxArgs: 2 },
+  toDateTimeOrZero: { clickhouseName: "toDateTimeOrZero", minArgs: 1, maxArgs: 2 },
+  toDateTime64: { clickhouseName: "toDateTime64", minArgs: 1, maxArgs: 3 },
+  toDateTime64OrNull: { clickhouseName: "toDateTime64OrNull", minArgs: 1, maxArgs: 3 },
+  toDateTime64OrZero: { clickhouseName: "toDateTime64OrZero", minArgs: 1, maxArgs: 3 },
+  toUUID: { clickhouseName: "toUUID", minArgs: 1, maxArgs: 1 },
+  toUUIDOrNull: { clickhouseName: "toUUIDOrNull", minArgs: 1, maxArgs: 1 },
+  toUUIDOrZero: { clickhouseName: "toUUIDOrZero", minArgs: 1, maxArgs: 1 },
+  toTypeName: { clickhouseName: "toTypeName", minArgs: 1, maxArgs: 1 },
+
+  // Date/time functions
+  now: { clickhouseName: "now", minArgs: 0, maxArgs: 1, tzAware: true },
+  now64: { clickhouseName: "now64", minArgs: 0, maxArgs: 2, tzAware: true },
+  today: { clickhouseName: "today", minArgs: 0, maxArgs: 0 },
+  yesterday: { clickhouseName: "yesterday", minArgs: 0, maxArgs: 0 },
+  toYear: { clickhouseName: "toYear", minArgs: 1, maxArgs: 1 },
+  toQuarter: { clickhouseName: "toQuarter", minArgs: 1, maxArgs: 1 },
+  toMonth: { clickhouseName: "toMonth", minArgs: 1, maxArgs: 1 },
+  toDayOfYear: { clickhouseName: "toDayOfYear", minArgs: 1, maxArgs: 1 },
+  toDayOfMonth: { clickhouseName: "toDayOfMonth", minArgs: 1, maxArgs: 1 },
+  toDayOfWeek: { clickhouseName: "toDayOfWeek", minArgs: 1, maxArgs: 3 },
+  toHour: { clickhouseName: "toHour", minArgs: 1, maxArgs: 1 },
+  toMinute: { clickhouseName: "toMinute", minArgs: 1, maxArgs: 1 },
+  toSecond: { clickhouseName: "toSecond", minArgs: 1, maxArgs: 1 },
+  toUnixTimestamp: { clickhouseName: "toUnixTimestamp", minArgs: 1, maxArgs: 2 },
+  toStartOfYear: { clickhouseName: "toStartOfYear", minArgs: 1, maxArgs: 1 },
+  toStartOfQuarter: { clickhouseName: "toStartOfQuarter", minArgs: 1, maxArgs: 1 },
+  toStartOfMonth: { clickhouseName: "toStartOfMonth", minArgs: 1, maxArgs: 1 },
+  toMonday: { clickhouseName: "toMonday", minArgs: 1, maxArgs: 1 },
+  toStartOfWeek: { clickhouseName: "toStartOfWeek", minArgs: 1, maxArgs: 2 },
+  toStartOfDay: { clickhouseName: "toStartOfDay", minArgs: 1, maxArgs: 1 },
+  toStartOfHour: { clickhouseName: "toStartOfHour", minArgs: 1, maxArgs: 1 },
+  toStartOfMinute: { clickhouseName: "toStartOfMinute", minArgs: 1, maxArgs: 1 },
+  toStartOfSecond: { clickhouseName: "toStartOfSecond", minArgs: 1, maxArgs: 1 },
+  toStartOfFiveMinutes: { clickhouseName: "toStartOfFiveMinutes", minArgs: 1, maxArgs: 1 },
+  toStartOfTenMinutes: { clickhouseName: "toStartOfTenMinutes", minArgs: 1, maxArgs: 1 },
+  toStartOfFifteenMinutes: { clickhouseName: "toStartOfFifteenMinutes", minArgs: 1, maxArgs: 1 },
+  toStartOfInterval: { clickhouseName: "toStartOfInterval", minArgs: 2, maxArgs: 4 },
+  toTime: { clickhouseName: "toTime", minArgs: 1, maxArgs: 2 },
+  toISOYear: { clickhouseName: "toISOYear", minArgs: 1, maxArgs: 1 },
+  toISOWeek: { clickhouseName: "toISOWeek", minArgs: 1, maxArgs: 1 },
+  toWeek: { clickhouseName: "toWeek", minArgs: 1, maxArgs: 3 },
+  toYearWeek: { clickhouseName: "toYearWeek", minArgs: 1, maxArgs: 3 },
+  date_add: { clickhouseName: "date_add", minArgs: 3, maxArgs: 3 },
+  date_diff: { clickhouseName: "date_diff", minArgs: 3, maxArgs: 4 },
+  date_sub: { clickhouseName: "date_sub", minArgs: 3, maxArgs: 3 },
+  date_trunc: { clickhouseName: "date_trunc", minArgs: 2, maxArgs: 3 },
+  dateDiff: { clickhouseName: "dateDiff", minArgs: 3, maxArgs: 4 },
+  dateAdd: { clickhouseName: "dateAdd", minArgs: 3, maxArgs: 3 },
+  dateSub: { clickhouseName: "dateSub", minArgs: 3, maxArgs: 3 },
+  dateTrunc: { clickhouseName: "dateTrunc", minArgs: 2, maxArgs: 3 },
+  addSeconds: { clickhouseName: "addSeconds", minArgs: 2, maxArgs: 2 },
+  addMinutes: { clickhouseName: "addMinutes", minArgs: 2, maxArgs: 2 },
+  addHours: { clickhouseName: "addHours", minArgs: 2, maxArgs: 2 },
+  addDays: { clickhouseName: "addDays", minArgs: 2, maxArgs: 2 },
+  addWeeks: { clickhouseName: "addWeeks", minArgs: 2, maxArgs: 2 },
+  addMonths: { clickhouseName: "addMonths", minArgs: 2, maxArgs: 2 },
+  addQuarters: { clickhouseName: "addQuarters", minArgs: 2, maxArgs: 2 },
+  addYears: { clickhouseName: "addYears", minArgs: 2, maxArgs: 2 },
+  subtractSeconds: { clickhouseName: "subtractSeconds", minArgs: 2, maxArgs: 2 },
+  subtractMinutes: { clickhouseName: "subtractMinutes", minArgs: 2, maxArgs: 2 },
+  subtractHours: { clickhouseName: "subtractHours", minArgs: 2, maxArgs: 2 },
+  subtractDays: { clickhouseName: "subtractDays", minArgs: 2, maxArgs: 2 },
+  subtractWeeks: { clickhouseName: "subtractWeeks", minArgs: 2, maxArgs: 2 },
+  subtractMonths: { clickhouseName: "subtractMonths", minArgs: 2, maxArgs: 2 },
+  subtractQuarters: { clickhouseName: "subtractQuarters", minArgs: 2, maxArgs: 2 },
+  subtractYears: { clickhouseName: "subtractYears", minArgs: 2, maxArgs: 2 },
+  toTimeZone: { clickhouseName: "toTimeZone", minArgs: 2, maxArgs: 2 },
+  formatDateTime: { clickhouseName: "formatDateTime", minArgs: 2, maxArgs: 3 },
+  parseDateTime: { clickhouseName: "parseDateTime", minArgs: 2, maxArgs: 3 },
+  parseDateTimeBestEffort: { clickhouseName: "parseDateTimeBestEffort", minArgs: 1, maxArgs: 2, tzAware: true },
+  parseDateTimeBestEffortOrNull: { clickhouseName: "parseDateTimeBestEffortOrNull", minArgs: 1, maxArgs: 2, tzAware: true },
+  parseDateTimeBestEffortOrZero: { clickhouseName: "parseDateTimeBestEffortOrZero", minArgs: 1, maxArgs: 2, tzAware: true },
+  parseDateTime64BestEffort: { clickhouseName: "parseDateTime64BestEffort", minArgs: 1, maxArgs: 3, tzAware: true },
+  parseDateTime64BestEffortOrNull: { clickhouseName: "parseDateTime64BestEffortOrNull", minArgs: 1, maxArgs: 3, tzAware: true },
+  parseDateTime64BestEffortOrZero: { clickhouseName: "parseDateTime64BestEffortOrZero", minArgs: 1, maxArgs: 3, tzAware: true },
+
+  // Interval functions
+  toIntervalSecond: { clickhouseName: "toIntervalSecond", minArgs: 1, maxArgs: 1 },
+  toIntervalMinute: { clickhouseName: "toIntervalMinute", minArgs: 1, maxArgs: 1 },
+  toIntervalHour: { clickhouseName: "toIntervalHour", minArgs: 1, maxArgs: 1 },
+  toIntervalDay: { clickhouseName: "toIntervalDay", minArgs: 1, maxArgs: 1 },
+  toIntervalWeek: { clickhouseName: "toIntervalWeek", minArgs: 1, maxArgs: 1 },
+  toIntervalMonth: { clickhouseName: "toIntervalMonth", minArgs: 1, maxArgs: 1 },
+  toIntervalQuarter: { clickhouseName: "toIntervalQuarter", minArgs: 1, maxArgs: 1 },
+  toIntervalYear: { clickhouseName: "toIntervalYear", minArgs: 1, maxArgs: 1 },
+
+  // Array functions
+  array: { clickhouseName: "array", minArgs: 0 },
+  range: { clickhouseName: "range", minArgs: 1, maxArgs: 3 },
+  arrayElement: { clickhouseName: "arrayElement", minArgs: 2, maxArgs: 2 },
+  has: { clickhouseName: "has", minArgs: 2, maxArgs: 2 },
+  hasAll: { clickhouseName: "hasAll", minArgs: 2, maxArgs: 2 },
+  hasAny: { clickhouseName: "hasAny", minArgs: 2, maxArgs: 2 },
+  hasSubstr: { clickhouseName: "hasSubstr", minArgs: 2, maxArgs: 2 },
+  indexOf: { clickhouseName: "indexOf", minArgs: 2, maxArgs: 2 },
+  arrayCount: { clickhouseName: "arrayCount", minArgs: 1, maxArgs: 2 },
+  countEqual: { clickhouseName: "countEqual", minArgs: 2, maxArgs: 2 },
+  arrayEnumerate: { clickhouseName: "arrayEnumerate", minArgs: 1, maxArgs: 1 },
+  arrayEnumerateDense: { clickhouseName: "arrayEnumerateDense", minArgs: 1 },
+  arrayEnumerateUniq: { clickhouseName: "arrayEnumerateUniq", minArgs: 1 },
+  arrayEnumerateUniqRanked: { clickhouseName: "arrayEnumerateUniqRanked", minArgs: 1 },
+  arrayPopBack: { clickhouseName: "arrayPopBack", minArgs: 1, maxArgs: 1 },
+  arrayPopFront: { clickhouseName: "arrayPopFront", minArgs: 1, maxArgs: 1 },
+  arrayPushBack: { clickhouseName: "arrayPushBack", minArgs: 2, maxArgs: 2 },
+  arrayPushFront: { clickhouseName: "arrayPushFront", minArgs: 2, maxArgs: 2 },
+  arrayResize: { clickhouseName: "arrayResize", minArgs: 2, maxArgs: 3 },
+  arraySlice: { clickhouseName: "arraySlice", minArgs: 2, maxArgs: 3 },
+  arraySort: { clickhouseName: "arraySort", minArgs: 1, maxArgs: 2 },
+  arrayPartialSort: { clickhouseName: "arrayPartialSort", minArgs: 2, maxArgs: 3 },
+  arrayReverseSort: { clickhouseName: "arrayReverseSort", minArgs: 1, maxArgs: 2 },
+  arrayPartialReverseSort: { clickhouseName: "arrayPartialReverseSort", minArgs: 2, maxArgs: 3 },
+  arrayShuffle: { clickhouseName: "arrayShuffle", minArgs: 1, maxArgs: 2 },
+  arrayUniq: { clickhouseName: "arrayUniq", minArgs: 1 },
+  arrayJoin: { clickhouseName: "arrayJoin", minArgs: 1, maxArgs: 1 },
+  arrayDifference: { clickhouseName: "arrayDifference", minArgs: 1, maxArgs: 1 },
+  arrayDistinct: { clickhouseName: "arrayDistinct", minArgs: 1, maxArgs: 1 },
+  arrayIntersect: { clickhouseName: "arrayIntersect", minArgs: 1 },
+  arrayReduce: { clickhouseName: "arrayReduce", minArgs: 2 },
+  arrayReverse: { clickhouseName: "arrayReverse", minArgs: 1, maxArgs: 1 },
+  arrayFlatten: { clickhouseName: "arrayFlatten", minArgs: 1, maxArgs: 1 },
+  arrayCompact: { clickhouseName: "arrayCompact", minArgs: 1, maxArgs: 1 },
+  arrayZip: { clickhouseName: "arrayZip", minArgs: 1 },
+
+  arrayMin: { clickhouseName: "arrayMin", minArgs: 1, maxArgs: 2 },
+  arrayMax: { clickhouseName: "arrayMax", minArgs: 1, maxArgs: 2 },
+  arraySum: { clickhouseName: "arraySum", minArgs: 1, maxArgs: 2 },
+  arrayAvg: { clickhouseName: "arrayAvg", minArgs: 1, maxArgs: 2 },
+  arrayCumSum: { clickhouseName: "arrayCumSum", minArgs: 1, maxArgs: 2 },
+  arrayCumSumNonNegative: { clickhouseName: "arrayCumSumNonNegative", minArgs: 1, maxArgs: 2 },
+  arrayProduct: { clickhouseName: "arrayProduct", minArgs: 1, maxArgs: 1 },
+
+  // JSON functions
+  JSONHas: { clickhouseName: "JSONHas", minArgs: 1 },
+  JSONLength: { clickhouseName: "JSONLength", minArgs: 1 },
+  JSONType: { clickhouseName: "JSONType", minArgs: 1 },
+  JSONExtractUInt: { clickhouseName: "JSONExtractUInt", minArgs: 1 },
+  JSONExtractInt: { clickhouseName: "JSONExtractInt", minArgs: 1 },
+  JSONExtractFloat: { clickhouseName: "JSONExtractFloat", minArgs: 1 },
+  JSONExtractBool: { clickhouseName: "JSONExtractBool", minArgs: 1 },
+  JSONExtractString: { clickhouseName: "JSONExtractString", minArgs: 1 },
+  JSONExtract: { clickhouseName: "JSONExtract", minArgs: 2 },
+  JSONExtractRaw: { clickhouseName: "JSONExtractRaw", minArgs: 1 },
+  JSONExtractArrayRaw: { clickhouseName: "JSONExtractArrayRaw", minArgs: 1 },
+  JSONExtractKeysAndValues: { clickhouseName: "JSONExtractKeysAndValues", minArgs: 2, maxArgs: 2 },
+  JSONExtractKeys: { clickhouseName: "JSONExtractKeys", minArgs: 1 },
+  toJSONString: { clickhouseName: "toJSONString", minArgs: 1, maxArgs: 1 },
+
+  // Tuple functions
+  tuple: { clickhouseName: "tuple", minArgs: 0 },
+  tupleElement: { clickhouseName: "tupleElement", minArgs: 2, maxArgs: 3 },
+  untuple: { clickhouseName: "untuple", minArgs: 1, maxArgs: 1 },
+
+  // Map functions
+  map: { clickhouseName: "map", minArgs: 0 },
+  mapFromArrays: { clickhouseName: "mapFromArrays", minArgs: 2, maxArgs: 2 },
+  mapContains: { clickhouseName: "mapContains", minArgs: 2, maxArgs: 2 },
+  mapKeys: { clickhouseName: "mapKeys", minArgs: 1, maxArgs: 1 },
+  mapValues: { clickhouseName: "mapValues", minArgs: 1, maxArgs: 1 },
+
+  // Hash functions
+  MD5: { clickhouseName: "MD5", minArgs: 1, maxArgs: 1 },
+  SHA1: { clickhouseName: "SHA1", minArgs: 1, maxArgs: 1 },
+  SHA224: { clickhouseName: "SHA224", minArgs: 1, maxArgs: 1 },
+  SHA256: { clickhouseName: "SHA256", minArgs: 1, maxArgs: 1 },
+  SHA384: { clickhouseName: "SHA384", minArgs: 1, maxArgs: 1 },
+  SHA512: { clickhouseName: "SHA512", minArgs: 1, maxArgs: 1 },
+  sipHash64: { clickhouseName: "sipHash64", minArgs: 1 },
+  sipHash128: { clickhouseName: "sipHash128", minArgs: 1 },
+  cityHash64: { clickhouseName: "cityHash64", minArgs: 1 },
+  intHash32: { clickhouseName: "intHash32", minArgs: 1, maxArgs: 1 },
+  intHash64: { clickhouseName: "intHash64", minArgs: 1, maxArgs: 1 },
+  farmHash64: { clickhouseName: "farmHash64", minArgs: 1 },
+  farmFingerprint64: { clickhouseName: "farmFingerprint64", minArgs: 1 },
+  xxHash32: { clickhouseName: "xxHash32", minArgs: 1 },
+  xxHash64: { clickhouseName: "xxHash64", minArgs: 1 },
+  murmurHash2_32: { clickhouseName: "murmurHash2_32", minArgs: 1 },
+  murmurHash2_64: { clickhouseName: "murmurHash2_64", minArgs: 1 },
+  murmurHash3_32: { clickhouseName: "murmurHash3_32", minArgs: 1 },
+  murmurHash3_64: { clickhouseName: "murmurHash3_64", minArgs: 1 },
+  murmurHash3_128: { clickhouseName: "murmurHash3_128", minArgs: 1 },
+  hex: { clickhouseName: "hex", minArgs: 1, maxArgs: 1 },
+  unhex: { clickhouseName: "unhex", minArgs: 1, maxArgs: 1 },
+
+  // URL functions
+  protocol: { clickhouseName: "protocol", minArgs: 1, maxArgs: 1 },
+  domain: { clickhouseName: "domain", minArgs: 1, maxArgs: 1 },
+  domainWithoutWWW: { clickhouseName: "domainWithoutWWW", minArgs: 1, maxArgs: 1 },
+  topLevelDomain: { clickhouseName: "topLevelDomain", minArgs: 1, maxArgs: 1 },
+  firstSignificantSubdomain: { clickhouseName: "firstSignificantSubdomain", minArgs: 1, maxArgs: 1 },
+  cutToFirstSignificantSubdomain: { clickhouseName: "cutToFirstSignificantSubdomain", minArgs: 1, maxArgs: 1 },
+  cutToFirstSignificantSubdomainWithWWW: { clickhouseName: "cutToFirstSignificantSubdomainWithWWW", minArgs: 1, maxArgs: 1 },
+  port: { clickhouseName: "port", minArgs: 1, maxArgs: 2 },
+  path: { clickhouseName: "path", minArgs: 1, maxArgs: 1 },
+  pathFull: { clickhouseName: "pathFull", minArgs: 1, maxArgs: 1 },
+  queryString: { clickhouseName: "queryString", minArgs: 1, maxArgs: 1 },
+  fragment: { clickhouseName: "fragment", minArgs: 1, maxArgs: 1 },
+  extractURLParameter: { clickhouseName: "extractURLParameter", minArgs: 2, maxArgs: 2 },
+  extractURLParameters: { clickhouseName: "extractURLParameters", minArgs: 1, maxArgs: 1 },
+  encodeURLComponent: { clickhouseName: "encodeURLComponent", minArgs: 1, maxArgs: 1 },
+  decodeURLComponent: { clickhouseName: "decodeURLComponent", minArgs: 1, maxArgs: 1 },
+
+  // UUID functions
+  generateUUIDv4: { clickhouseName: "generateUUIDv4", minArgs: 0, maxArgs: 0 },
+  UUIDStringToNum: { clickhouseName: "UUIDStringToNum", minArgs: 1, maxArgs: 1 },
+  UUIDNumToString: { clickhouseName: "UUIDNumToString", minArgs: 1, maxArgs: 1 },
+
+  // Other functions
+  isFinite: { clickhouseName: "isFinite", minArgs: 1, maxArgs: 1 },
+  isInfinite: { clickhouseName: "isInfinite", minArgs: 1, maxArgs: 1 },
+  ifNotFinite: { clickhouseName: "ifNotFinite", minArgs: 2, maxArgs: 2 },
+  isNaN: { clickhouseName: "isNaN", minArgs: 1, maxArgs: 1 },
+  bar: { clickhouseName: "bar", minArgs: 4, maxArgs: 4 },
+  transform: { clickhouseName: "transform", minArgs: 3, maxArgs: 4 },
+  formatReadableDecimalSize: { clickhouseName: "formatReadableDecimalSize", minArgs: 1, maxArgs: 1 },
+  formatReadableSize: { clickhouseName: "formatReadableSize", minArgs: 1, maxArgs: 1 },
+  formatReadableQuantity: { clickhouseName: "formatReadableQuantity", minArgs: 1, maxArgs: 1 },
+  formatReadableTimeDelta: { clickhouseName: "formatReadableTimeDelta", minArgs: 1, maxArgs: 2 },
+  least: { clickhouseName: "least", minArgs: 2, maxArgs: 2, caseSensitive: false },
+  greatest: { clickhouseName: "greatest", minArgs: 2, maxArgs: 2, caseSensitive: false },
+  min2: { clickhouseName: "min2", minArgs: 2, maxArgs: 2 },
+  max2: { clickhouseName: "max2", minArgs: 2, maxArgs: 2 },
+  runningDifference: { clickhouseName: "runningDifference", minArgs: 1, maxArgs: 1 },
+  runningDifferenceStartingWithFirstValue: { clickhouseName: "runningDifferenceStartingWithFirstValue", minArgs: 1, maxArgs: 1 },
+  neighbor: { clickhouseName: "neighbor", minArgs: 2, maxArgs: 3 },
+
+  // Window functions
+  rank: { clickhouseName: "rank", minArgs: 0, maxArgs: 0 },
+  dense_rank: { clickhouseName: "dense_rank", minArgs: 0, maxArgs: 0 },
+  row_number: { clickhouseName: "row_number", minArgs: 0, maxArgs: 0 },
+  first_value: { clickhouseName: "first_value", minArgs: 1, maxArgs: 1 },
+  last_value: { clickhouseName: "last_value", minArgs: 1, maxArgs: 1 },
+  nth_value: { clickhouseName: "nth_value", minArgs: 2, maxArgs: 2 },
+  lagInFrame: { clickhouseName: "lagInFrame", minArgs: 1, maxArgs: 3 },
+  leadInFrame: { clickhouseName: "leadInFrame", minArgs: 1, maxArgs: 3 },
+  lag: { clickhouseName: "lagInFrame", minArgs: 1, maxArgs: 3 },
+  lead: { clickhouseName: "leadInFrame", minArgs: 1, maxArgs: 3 },
+};
+
+/**
+ * Aggregate functions available in TSQL
+ * Port of HOGQL_AGGREGATIONS from aggregations.py
+ */
+export const TSQL_AGGREGATIONS: Record<string, TSQLFunctionMeta> = {
+  // Standard aggregate functions
+  count: { clickhouseName: "count", minArgs: 0, maxArgs: 1, aggregate: true, caseSensitive: false },
+  countIf: { clickhouseName: "countIf", minArgs: 1, maxArgs: 2, aggregate: true },
+  countDistinct: { clickhouseName: "countDistinct", minArgs: 1, maxArgs: 1, aggregate: true },
+  countDistinctIf: { clickhouseName: "countDistinctIf", minArgs: 1, maxArgs: 2, aggregate: true },
+  min: { clickhouseName: "min", minArgs: 1, maxArgs: 1, aggregate: true, caseSensitive: false },
+  minIf: { clickhouseName: "minIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  max: { clickhouseName: "max", minArgs: 1, maxArgs: 1, aggregate: true, caseSensitive: false },
+  maxIf: { clickhouseName: "maxIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  sum: { clickhouseName: "sum", minArgs: 1, maxArgs: 1, aggregate: true, caseSensitive: false },
+  sumIf: { clickhouseName: "sumIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  avg: { clickhouseName: "avg", minArgs: 1, maxArgs: 1, aggregate: true, caseSensitive: false },
+  avgIf: { clickhouseName: "avgIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  any: { clickhouseName: "any", minArgs: 1, maxArgs: 1, aggregate: true },
+  anyIf: { clickhouseName: "anyIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  anyLast: { clickhouseName: "anyLast", minArgs: 1, maxArgs: 1, aggregate: true },
+  anyLastIf: { clickhouseName: "anyLastIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  anyHeavy: { clickhouseName: "anyHeavy", minArgs: 1, maxArgs: 1, aggregate: true },
+  anyHeavyIf: { clickhouseName: "anyHeavyIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  argMin: { clickhouseName: "argMin", minArgs: 2, maxArgs: 2, aggregate: true },
+  argMinIf: { clickhouseName: "argMinIf", minArgs: 3, maxArgs: 3, aggregate: true },
+  argMax: { clickhouseName: "argMax", minArgs: 2, maxArgs: 2, aggregate: true },
+  argMaxIf: { clickhouseName: "argMaxIf", minArgs: 3, maxArgs: 3, aggregate: true },
+  stddevPop: { clickhouseName: "stddevPop", minArgs: 1, maxArgs: 1, aggregate: true },
+  stddevSamp: { clickhouseName: "stddevSamp", minArgs: 1, maxArgs: 1, aggregate: true },
+  varPop: { clickhouseName: "varPop", minArgs: 1, maxArgs: 1, aggregate: true },
+  varSamp: { clickhouseName: "varSamp", minArgs: 1, maxArgs: 1, aggregate: true },
+  covarPop: { clickhouseName: "covarPop", minArgs: 2, maxArgs: 2, aggregate: true },
+  covarSamp: { clickhouseName: "covarSamp", minArgs: 2, maxArgs: 2, aggregate: true },
+  corr: { clickhouseName: "corr", minArgs: 2, maxArgs: 2, aggregate: true },
+
+  // Array aggregations
+  groupArray: { clickhouseName: "groupArray", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupArrayIf: { clickhouseName: "groupArrayIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  groupUniqArray: { clickhouseName: "groupUniqArray", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupUniqArrayIf: { clickhouseName: "groupUniqArrayIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  groupArrayInsertAt: { clickhouseName: "groupArrayInsertAt", minArgs: 2, maxArgs: 2, aggregate: true },
+  groupArrayMovingAvg: { clickhouseName: "groupArrayMovingAvg", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupArrayMovingSum: { clickhouseName: "groupArrayMovingSum", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupArraySample: { clickhouseName: "groupArraySample", minArgs: 1, maxArgs: 1, minParams: 1, maxParams: 2, aggregate: true },
+  array_agg: { clickhouseName: "groupArray", minArgs: 1, maxArgs: 1, aggregate: true },
+
+  // Bitmap aggregations
+  groupBitmap: { clickhouseName: "groupBitmap", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupBitmapAnd: { clickhouseName: "groupBitmapAnd", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupBitmapOr: { clickhouseName: "groupBitmapOr", minArgs: 1, maxArgs: 1, aggregate: true },
+  groupBitmapXor: { clickhouseName: "groupBitmapXor", minArgs: 1, maxArgs: 1, aggregate: true },
+
+  // Uniq functions
+  uniq: { clickhouseName: "uniq", minArgs: 1, aggregate: true },
+  uniqIf: { clickhouseName: "uniqIf", minArgs: 2, aggregate: true },
+  uniqExact: { clickhouseName: "uniqExact", minArgs: 1, aggregate: true },
+  uniqExactIf: { clickhouseName: "uniqExactIf", minArgs: 2, aggregate: true },
+  uniqHLL12: { clickhouseName: "uniqHLL12", minArgs: 1, aggregate: true },
+  uniqTheta: { clickhouseName: "uniqTheta", minArgs: 1, aggregate: true },
+
+  // Quantile functions
+  median: { clickhouseName: "median", minArgs: 1, maxArgs: 1, aggregate: true },
+  medianIf: { clickhouseName: "medianIf", minArgs: 2, maxArgs: 2, aggregate: true },
+  medianExact: { clickhouseName: "medianExact", minArgs: 1, maxArgs: 1, aggregate: true },
+  quantile: { clickhouseName: "quantile", minArgs: 1, maxArgs: 1, minParams: 1, maxParams: 1, aggregate: true },
+  quantileIf: { clickhouseName: "quantileIf", minArgs: 2, maxArgs: 2, minParams: 1, maxParams: 1, aggregate: true },
+  quantiles: { clickhouseName: "quantiles", minArgs: 1, aggregate: true },
+  // -Merge combinators for AggregatingMergeTree tables
+  quantilesMerge: { clickhouseName: "quantilesMerge", minArgs: 1, maxArgs: 1, minParams: 1, aggregate: true },
+  quantileMerge: { clickhouseName: "quantileMerge", minArgs: 1, maxArgs: 1, minParams: 1, maxParams: 1, aggregate: true },
+  sumMerge: { clickhouseName: "sumMerge", minArgs: 1, maxArgs: 1, aggregate: true },
+  avgMerge: { clickhouseName: "avgMerge", minArgs: 1, maxArgs: 1, aggregate: true },
+  countMerge: { clickhouseName: "countMerge", minArgs: 1, maxArgs: 1, aggregate: true },
+  minMerge: { clickhouseName: "minMerge", minArgs: 1, maxArgs: 1, aggregate: true },
+  maxMerge: { clickhouseName: "maxMerge", minArgs: 1, maxArgs: 1, aggregate: true },
+
+  // Statistical functions
+  simpleLinearRegression: { clickhouseName: "simpleLinearRegression", minArgs: 2, maxArgs: 2, aggregate: true },
+  contingency: { clickhouseName: "contingency", minArgs: 2, maxArgs: 2, aggregate: true },
+  cramersV: { clickhouseName: "cramersV", minArgs: 2, maxArgs: 2, aggregate: true },
+  theilsU: { clickhouseName: "theilsU", minArgs: 2, maxArgs: 2, aggregate: true },
+
+  // Sum/Map variants
+  sumMap: { clickhouseName: "sumMap", minArgs: 1, maxArgs: 2, aggregate: true },
+  minMap: { clickhouseName: "minMap", minArgs: 1, maxArgs: 2, aggregate: true },
+  maxMap: { clickhouseName: "maxMap", minArgs: 1, maxArgs: 2, aggregate: true },
+
+  // TopK
+  topK: { clickhouseName: "topK", minArgs: 1, maxArgs: 1, minParams: 1, maxParams: 1, aggregate: true },
+
+  // Funnel
+  windowFunnel: { clickhouseName: "windowFunnel", minArgs: 1, maxArgs: 99, aggregate: true },
+};
+
+/**
+ * Build a lowercase lookup map from a functions record.
+ * Uses a null-prototype object to avoid Object.prototype pollution (e.g. "toString").
+ */
+function buildLowercaseMap(
+  functions: Record<string, TSQLFunctionMeta>
+): Record<string, TSQLFunctionMeta> {
+  const map: Record<string, TSQLFunctionMeta> = Object.create(null);
+  for (const [key, value] of Object.entries(functions)) {
+    map[key.toLowerCase()] = value;
+  }
+  return map;
+}
+
+const FUNCTIONS_LOWERCASE = buildLowercaseMap(TSQL_CLICKHOUSE_FUNCTIONS);
+const AGGREGATIONS_LOWERCASE = buildLowercaseMap(TSQL_AGGREGATIONS);
+
+/**
+ * Find a function in the TSQL functions map.
+ * Supports case-insensitive lookup for non-case-sensitive functions.
+ *
+ * @param functions - The canonical functions record (exact-match lookup)
+ * @param lowercaseMap - Pre-computed lowercase lookup (null-prototype, safe from prototype pollution)
+ */
+function findFunction(
+  name: string,
+  functions: Record<string, TSQLFunctionMeta>,
+  lowercaseMap: Record<string, TSQLFunctionMeta>
+): TSQLFunctionMeta | undefined {
+  if (Object.prototype.hasOwnProperty.call(functions, name)) {
+    return functions[name];
+  }
+
+  // Case-insensitive fallback using the pre-computed lowercase map
+  const lowerFunc = lowercaseMap[name.toLowerCase()];
+  if (lowerFunc === undefined) {
+    return undefined;
+  }
+
+  // If the function is case-sensitive, only the exact-match above should find it
+  if (lowerFunc.caseSensitive) {
+    return undefined;
+  }
+
+  return lowerFunc;
+}
+
+/**
+ * Find a TSQL aggregation function by name
+ */
+export function findTSQLAggregation(name: string): TSQLFunctionMeta | undefined {
+  return findFunction(name, TSQL_AGGREGATIONS, AGGREGATIONS_LOWERCASE);
+}
+
+/**
+ * Find a TSQL function by name
+ */
+export function findTSQLFunction(name: string): TSQLFunctionMeta | undefined {
+  return findFunction(name, TSQL_CLICKHOUSE_FUNCTIONS, FUNCTIONS_LOWERCASE);
+}
+
+/**
+ * Get all exposed function names (for autocomplete, suggestions, etc.)
+ */
+export function getAllExposedFunctionNames(): string[] {
+  const functionNames = Object.keys(TSQL_CLICKHOUSE_FUNCTIONS).filter((name) => !name.startsWith("_"));
+  const aggregationNames = Object.keys(TSQL_AGGREGATIONS).filter((name) => !name.startsWith("_"));
+  return [...functionNames, ...aggregationNames];
+}
+
+/**
+ * Validate function arguments
+ */
+export function validateFunctionArgs(
+  args: unknown[],
+  minArgs: number,
+  maxArgs: number | undefined,
+  functionName: string,
+  options: {
+    functionTerm?: string;
+    argumentTerm?: string;
+  } = {}
+): void {
+  const { functionTerm = "function", argumentTerm = "argument" } = options;
+
+  const tooFew = args.length < minArgs;
+  const tooMany = maxArgs !== undefined && args.length > maxArgs;
+
+  if (minArgs === maxArgs && (tooFew || tooMany)) {
+    throw new Error(
+      `${functionTerm.charAt(0).toUpperCase() + functionTerm.slice(1)} '${functionName}' expects ${minArgs} ${argumentTerm}${minArgs !== 1 ? "s" : ""}, found ${args.length}`
+    );
+  }
+  if (tooFew) {
+    throw new Error(
+      `${functionTerm.charAt(0).toUpperCase() + functionTerm.slice(1)} '${functionName}' expects at least ${minArgs} ${argumentTerm}${minArgs !== 1 ? "s" : ""}, found ${args.length}`
+    );
+  }
+  if (tooMany) {
+    throw new Error(
+      `${functionTerm.charAt(0).toUpperCase() + functionTerm.slice(1)} '${functionName}' expects at most ${maxArgs} ${argumentTerm}${maxArgs !== 1 ? "s" : ""}, found ${args.length}`
+    );
+  }
+}
+
diff --git a/internal-packages/tsql/src/query/models.ts b/internal-packages/tsql/src/query/models.ts
new file mode 100644
index 00000000000..49c8bd4f3c5
--- /dev/null
+++ b/internal-packages/tsql/src/query/models.ts
@@ -0,0 +1,253 @@
+// TypeScript translation of posthog/hogql/database/models.py
+
+import type { Expr, ConstantType } from "./ast";
+import type { TSQLContext } from "./context";
+
+export interface FieldOrTable {
+  hidden?: boolean;
+}
+
+export interface DatabaseField extends FieldOrTable {
+  name: string;
+  array?: boolean;
+  nullable?: boolean;
+  is_nullable?(): boolean;
+  get_constant_type?(): ConstantType;
+  default_value?(): any;
+}
+
+export interface IntegerDatabaseField extends DatabaseField {}
+export interface FloatDatabaseField extends DatabaseField {}
+export interface DecimalDatabaseField extends DatabaseField {}
+export interface StringDatabaseField extends DatabaseField {}
+export interface UnknownDatabaseField extends DatabaseField {}
+export interface StringJSONDatabaseField extends DatabaseField {}
+export interface StringArrayDatabaseField extends DatabaseField {}
+export interface FloatArrayDatabaseField extends DatabaseField {}
+export interface DateDatabaseField extends DatabaseField {}
+export interface DateTimeDatabaseField extends DatabaseField {}
+export interface BooleanDatabaseField extends DatabaseField {}
+export interface UUIDDatabaseField extends DatabaseField {}
+
+export interface ExpressionField extends DatabaseField {
+  expr: Expr;
+  isolate_scope?: boolean;
+}
+
+export interface FieldTraverser extends FieldOrTable {
+  chain: Array<string | number>;
+}
+
+export interface Table extends FieldOrTable {
+  fields: Record<string, FieldOrTable>;
+  has_field?(name: string | number): boolean;
+  get_field?(name: string | number): FieldOrTable;
+  to_printed_clickhouse?(context: TSQLContext): string;
+  to_printed_tsql?(): string;
+  avoid_asterisk_fields?(): string[];
+  get_asterisk?(): Record<string, FieldOrTable>;
+}
+
+export interface LazyJoin extends FieldOrTable {
+  join_function?(from_table: Table, to_table: Table, requesting_table: Table): Expr;
+  resolve_table?(context: TSQLContext): Table;
+}
+
+export interface LazyTable extends Table {}
+
+export interface VirtualTable extends Table {}
+
+export interface SavedQuery extends Table {
+  query: Expr;
+}
+
+export interface FunctionCallTable extends Table {
+  call_function?(context: TSQLContext): Expr;
+}
+
+export interface TableNode {
+  name: "root" | string;
+  table?: FieldOrTable | null;
+  children: Record<string, TableNode>;
+  get?(): FieldOrTable;
+  has_child?(path: string[]): boolean;
+  get_child?(path: string[]): TableNode;
+  add_child?(
+    child: TableNode,
+    options?: {
+      table_conflict_mode?: "override" | "ignore";
+      children_conflict_mode?: "override" | "merge" | "ignore";
+    }
+  ): void;
+  merge_with?(
+    other: TableNode,
+    options?: {
+      table_conflict_mode?: "override" | "ignore";
+      children_conflict_mode?: "override" | "merge" | "ignore";
+    }
+  ): void;
+  resolve_all_table_names?(): string[];
+}
+
+// Basic TableNode implementation class
+export class TableNodeImpl implements TableNode {
+  name: "root" | string;
+  table?: FieldOrTable | null;
+  children: Record<string, TableNode>;
+
+  constructor(name: "root" | string = "root", table?: FieldOrTable | null) {
+    this.name = name;
+    this.table = table || null;
+    this.children = {};
+  }
+
+  get(): FieldOrTable {
+    if (this.table === null || this.table === undefined) {
+      throw new Error(`Table is not set at \`${this.name}\``);
+    }
+    return this.table;
+  }
+
+  has_child(path: string[]): boolean {
+    if (path.length === 0) {
+      return this.table !== null && this.table !== undefined;
+    }
+
+    const [first, ...restOfPath] = path;
+    if (!(first in this.children)) {
+      return false;
+    }
+
+    return this.children[first].has_child ? this.children[first].has_child!(restOfPath) : false;
+  }
+
+  get_child(path: string[]): TableNode {
+    if (path.length === 0) {
+      return this;
+    }
+
+    const [first, ...restOfPath] = path;
+    if (!(first in this.children)) {
+      throw new Error(`Unknown child \`${first}\` at \`${this.name}\`.`);
+    }
+
+    return this.children[first].get_child
+      ? this.children[first].get_child!(restOfPath)
+      : this.children[first];
+  }
+
+  add_child(
+    child: TableNode,
+    options?: {
+      table_conflict_mode?: "override" | "ignore";
+      children_conflict_mode?: "override" | "merge" | "ignore";
+    }
+  ): void {
+    const tableConflictMode = options?.table_conflict_mode || "ignore";
+    const childrenConflictMode = options?.children_conflict_mode || "merge";
+
+    if (child.name in this.children) {
+      if (childrenConflictMode === "override") {
+        this.children[child.name] = child;
+      } else if (childrenConflictMode === "merge") {
+        const existing = this.children[child.name];
+        if (existing.merge_with) {
+          existing.merge_with(child, {
+            table_conflict_mode: tableConflictMode,
+            children_conflict_mode: childrenConflictMode,
+          });
+        }
+      }
+      // ignore mode: do nothing
+      return;
+    }
+
+    this.children[child.name] = child;
+  }
+
+  merge_with(
+    other: TableNode,
+    options?: {
+      table_conflict_mode?: "override" | "ignore";
+      children_conflict_mode?: "override" | "merge" | "ignore";
+    }
+  ): void {
+    const tableConflictMode = options?.table_conflict_mode || "ignore";
+    const childrenConflictMode = options?.children_conflict_mode || "merge";
+
+    if (other.table !== null && other.table !== undefined) {
+      if (this.table === null || this.table === undefined) {
+        this.table = other.table;
+      } else {
+        // Conflict - check conflict mode
+        if (tableConflictMode === "override") {
+          this.table = other.table;
+        }
+        // ignore mode: do nothing
+      }
+    }
+
+    for (const child of Object.values(other.children)) {
+      this.add_child(child, {
+        table_conflict_mode: tableConflictMode,
+        children_conflict_mode: childrenConflictMode,
+      });
+    }
+  }
+
+  resolve_all_table_names(): string[] {
+    const names: string[] = [];
+
+    if (this.table !== null && this.table !== undefined) {
+      names.push(this.name);
+    }
+
+    for (const child of Object.values(this.children)) {
+      const childNames = child.resolve_all_table_names ? child.resolve_all_table_names() : [];
+
+      // The root node should NOT include itself in the names
+      if (this.name === "root") {
+        names.push(...childNames);
+      } else {
+        names.push(...childNames.map((x) => `${this.name}.${x}`));
+      }
+    }
+
+    return names;
+  }
+
+  static createNestedForChain(chain: string[], table: Table): TableNode {
+    if (chain.length === 0) {
+      throw new Error("Chain must have at least one element");
+    }
+
+    const start = new TableNodeImpl(chain[0]);
+    let current: TableNode = start;
+
+    for (let i = 1; i < chain.length; i++) {
+      const child = new TableNodeImpl(chain[i]);
+      if (current.add_child) {
+        current.add_child(child);
+      } else {
+        current.children[child.name] = child;
+      }
+      current = child;
+    }
+
+    current.table = table;
+    return start;
+  }
+}
+
+export interface LazyTableToAdd {
+  lazy_table: LazyTable;
+  fields_accessed: Record<string, Array<string | number>>;
+}
+
+export interface LazyJoinToAdd {
+  from_table: string;
+  to_table: string;
+  lazy_join: LazyJoin;
+  lazy_join_type: any; // LazyJoinType from ast.ts
+  fields_accessed: Record<string, Array<string | number>>;
+}
diff --git a/internal-packages/tsql/src/query/parse_string.ts b/internal-packages/tsql/src/query/parse_string.ts
new file mode 100644
index 00000000000..be38f752dd2
--- /dev/null
+++ b/internal-packages/tsql/src/query/parse_string.ts
@@ -0,0 +1,65 @@
+// TypeScript translation of posthog/hogql/parse_string.py
+// Keep this file in sync with the Python version
+
+import { SyntaxError } from './errors';
+
+function replaceCommonEscapeCharacters(text: string): string {
+    // copied from clickhouse_driver/util/escape.py
+    // Note: \a (bell) and \v (vertical tab) are not directly supported in JavaScript strings
+    // but we handle them as escape sequences that get replaced
+    text = text.replace(/\\b/g, '\b');
+    text = text.replace(/\\f/g, '\f');
+    text = text.replace(/\\r/g, '\r');
+    text = text.replace(/\\n/g, '\n');
+    text = text.replace(/\\t/g, '\t');
+    text = text.replace(/\\0/g, ''); // NUL characters are ignored
+    text = text.replace(/\\a/g, '\x07'); // Bell character (ASCII 7)
+    text = text.replace(/\\v/g, '\x0B'); // Vertical tab (ASCII 11)
+    text = text.replace(/\\\\/g, '\\');
+    return text;
+}
+
+export function parseStringLiteralText(text: string): string {
+    /** Converts a string received from antlr via ctx.getText() into a JavaScript string */
+    let result: string;
+    
+    if (text.startsWith("'") && text.endsWith("'")) {
+        result = text.slice(1, -1);
+        result = result.replace(/''/g, "'");
+        result = result.replace(/\\'/g, "'");
+    } else if (text.startsWith('"') && text.endsWith('"')) {
+        result = text.slice(1, -1);
+        result = result.replace(/""/g, '"');
+        result = result.replace(/\\"/g, '"');
+    } else if (text.startsWith('`') && text.endsWith('`')) {
+        result = text.slice(1, -1);
+        result = result.replace(/``/g, '`');
+        result = result.replace(/\\`/g, '`');
+    } else if (text.startsWith('{') && text.endsWith('}')) {
+        result = text.slice(1, -1);
+        result = result.replace(/{{/g, '{');
+        result = result.replace(/\\{/g, '{');
+    } else {
+        throw new SyntaxError(`Invalid string literal, must start and end with the same quote type: ${text}`);
+    }
+
+    return replaceCommonEscapeCharacters(result);
+}
+
+export function parseStringLiteralCtx(ctx: { getText(): string }): string {
+    /** Converts a STRING_LITERAL received from antlr via ctx.getText() into a JavaScript string */
+    const text = ctx.getText();
+    return parseStringLiteralText(text);
+}
+
+export function parseStringTextCtx(ctx: { getText(): string }, escapeQuotes: boolean = true): string {
+    /** Converts a STRING_TEXT received from antlr via ctx.getText() into a JavaScript string */
+    let text = ctx.getText();
+    if (escapeQuotes) {
+        text = text.replace(/''/g, "'");
+        text = text.replace(/\\'/g, "'");
+    }
+    text = text.replace(/\\{/g, '{');
+    return replaceCommonEscapeCharacters(text);
+}
+
diff --git a/internal-packages/tsql/src/query/parser.test.ts b/internal-packages/tsql/src/query/parser.test.ts
new file mode 100644
index 00000000000..a3ba292a6f3
--- /dev/null
+++ b/internal-packages/tsql/src/query/parser.test.ts
@@ -0,0 +1,629 @@
+import { describe, it, expect } from "vitest";
+import { CharStreams, CommonTokenStream } from "antlr4ts";
+import { TSQLLexer } from "../grammar/TSQLLexer.js";
+import { TSQLParser } from "../grammar/TSQLParser.js";
+import { TSQLParseTreeConverter } from "./parser.js";
+import { ArithmeticOperationOp, CompareOperationOp } from "./ast.js";
+import { SyntaxError } from "./errors.js";
+
+/**
+ * Helper function to parse TSQL input and convert to AST
+ */
+function parseAndConvert(input: string) {
+  const inputStream = CharStreams.fromString(input);
+  const lexer = new TSQLLexer(inputStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new TSQLParser(tokenStream);
+  const parseTree = parser.select();
+  const converter = new TSQLParseTreeConverter();
+  return converter.visit(parseTree);
+}
+
+describe("TSQLParseTreeConverter", () => {
+  describe("SELECT statements", () => {
+    it("should convert a simple SELECT statement", () => {
+      const ast = parseAndConvert("SELECT * FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+        },
+      });
+    });
+
+    it("should convert SELECT with multiple columns", () => {
+      const ast = parseAndConvert("SELECT id, name, email FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          { expression_type: "field", chain: ["id"] },
+          { expression_type: "field", chain: ["name"] },
+          { expression_type: "field", chain: ["email"] },
+        ],
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+        },
+      });
+    });
+
+    it("should convert SELECT with DISTINCT", () => {
+      const ast = parseAndConvert("SELECT DISTINCT id FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        distinct: true,
+        select: [{ expression_type: "field", chain: ["id"] }],
+      });
+    });
+
+    it("should convert SELECT with WHERE clause", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id = 1");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+        },
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Eq,
+          left: { expression_type: "field", chain: ["id"] },
+          right: { expression_type: "constant", value: 1 },
+        },
+      });
+    });
+
+    it("should convert SELECT with ORDER BY", () => {
+      const ast = parseAndConvert("SELECT * FROM users ORDER BY id DESC");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        order_by: [
+          {
+            expression_type: "order_expr",
+            order: "DESC",
+            expr: { expression_type: "field", chain: ["id"] },
+          },
+        ],
+      });
+    });
+
+    it("should convert SELECT with LIMIT", () => {
+      const ast = parseAndConvert("SELECT * FROM users LIMIT 10");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        limit: { expression_type: "constant", value: 10 },
+      });
+    });
+
+    it("should convert SELECT with LIMIT and OFFSET", () => {
+      const ast = parseAndConvert("SELECT * FROM users LIMIT 10 OFFSET 5");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        limit: { expression_type: "constant", value: 10 },
+        offset: { expression_type: "constant", value: 5 },
+      });
+    });
+
+    it("should convert SELECT with GROUP BY", () => {
+      const ast = parseAndConvert("SELECT category, COUNT(*) FROM products GROUP BY category");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          { expression_type: "field", chain: ["category"] },
+          { expression_type: "call", name: "COUNT" },
+        ],
+        group_by: [{ expression_type: "field", chain: ["category"] }],
+      });
+    });
+
+    it("should convert SELECT with HAVING", () => {
+      const ast = parseAndConvert(
+        "SELECT category FROM products GROUP BY category HAVING COUNT(*) > 10"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["category"] }],
+        group_by: [{ expression_type: "field", chain: ["category"] }],
+        having: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Gt,
+          left: { expression_type: "call", name: "COUNT" },
+          right: { expression_type: "constant", value: 10 },
+        },
+      });
+    });
+  });
+
+  describe("expressions", () => {
+    it("should convert numeric constants", () => {
+      const ast = parseAndConvert("SELECT 42 FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "constant", value: 42 }],
+      });
+    });
+
+    it("should convert string constants", () => {
+      const ast = parseAndConvert("SELECT 'hello' FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "constant", value: "hello" }],
+      });
+    });
+
+    it("should convert boolean constants", () => {
+      const ast = parseAndConvert("SELECT true FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "constant", value: true }],
+      });
+    });
+
+    it("should convert arithmetic addition", () => {
+      const ast = parseAndConvert("SELECT 1 + 2 FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "arithmetic_operation",
+            op: ArithmeticOperationOp.Add,
+            left: { expression_type: "constant", value: 1 },
+            right: { expression_type: "constant", value: 2 },
+          },
+        ],
+      });
+    });
+
+    it("should convert arithmetic subtraction", () => {
+      const ast = parseAndConvert("SELECT 5 - 3 FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "arithmetic_operation",
+            op: ArithmeticOperationOp.Sub,
+            left: { expression_type: "constant", value: 5 },
+            right: { expression_type: "constant", value: 3 },
+          },
+        ],
+      });
+    });
+
+    it("should convert arithmetic multiplication", () => {
+      const ast = parseAndConvert("SELECT 2 * 3 FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "arithmetic_operation",
+            op: ArithmeticOperationOp.Mult,
+            left: { expression_type: "constant", value: 2 },
+            right: { expression_type: "constant", value: 3 },
+          },
+        ],
+      });
+    });
+
+    it("should convert arithmetic division", () => {
+      const ast = parseAndConvert("SELECT 10 / 2 FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "arithmetic_operation",
+            op: ArithmeticOperationOp.Div,
+            left: { expression_type: "constant", value: 10 },
+            right: { expression_type: "constant", value: 2 },
+          },
+        ],
+      });
+    });
+
+    it("should convert comparison equals", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id = 1");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Eq,
+          left: { expression_type: "field", chain: ["id"] },
+          right: { expression_type: "constant", value: 1 },
+        },
+      });
+    });
+
+    it("should convert comparison not equals", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id != 1");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.NotEq,
+          left: { expression_type: "field", chain: ["id"] },
+          right: { expression_type: "constant", value: 1 },
+        },
+      });
+    });
+
+    it("should convert comparison less than", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id < 10");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Lt,
+          left: { expression_type: "field", chain: ["id"] },
+          right: { expression_type: "constant", value: 10 },
+        },
+      });
+    });
+
+    it("should convert comparison greater than", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id > 5");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Gt,
+          left: { expression_type: "field", chain: ["id"] },
+          right: { expression_type: "constant", value: 5 },
+        },
+      });
+    });
+
+    it("should convert LIKE comparison", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE name LIKE '%john%'");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Like,
+          left: { expression_type: "field", chain: ["name"] },
+          right: { expression_type: "constant", value: "%john%" },
+        },
+      });
+    });
+
+    it("should convert IN comparison", () => {
+      const ast = parseAndConvert("SELECT * FROM users WHERE id IN (1, 2, 3)");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.In,
+          left: { expression_type: "field", chain: ["id"] },
+          right: {
+            expression_type: "tuple",
+            exprs: [
+              { expression_type: "constant", value: 1 },
+              { expression_type: "constant", value: 2 },
+              { expression_type: "constant", value: 3 },
+            ],
+          },
+        },
+      });
+    });
+
+    it("should convert function calls", () => {
+      const ast = parseAndConvert("SELECT COUNT(*) FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "call",
+            name: "COUNT",
+            args: [{ expression_type: "field", chain: ["*"] }],
+          },
+        ],
+      });
+    });
+
+    it("should convert nested field access", () => {
+      const ast = parseAndConvert("SELECT user.profile.name FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["user", "profile", "name"] }],
+      });
+    });
+
+    it("should convert aliased expressions", () => {
+      const ast = parseAndConvert("SELECT id AS user_id FROM users");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          {
+            expression_type: "alias",
+            alias: "user_id",
+            expr: { expression_type: "field", chain: ["id"] },
+          },
+        ],
+      });
+    });
+  });
+
+  describe("JOINs", () => {
+    it("should convert INNER JOIN", () => {
+      const ast = parseAndConvert(
+        "SELECT * FROM users INNER JOIN orders ON users.id = orders.user_id"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+          next_join: {
+            expression_type: "join_expr",
+            join_type: "INNER JOIN",
+            table: { expression_type: "field", chain: ["orders"] },
+            constraint: {
+              expression_type: "join_constraint",
+              constraint_type: "ON",
+              expr: {
+                expression_type: "compare_operation",
+                op: CompareOperationOp.Eq,
+              },
+            },
+          },
+        },
+      });
+    });
+
+    it("should convert LEFT JOIN", () => {
+      const ast = parseAndConvert(
+        "SELECT * FROM users LEFT JOIN orders ON users.id = orders.user_id"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+          next_join: {
+            expression_type: "join_expr",
+            join_type: "LEFT JOIN",
+            table: { expression_type: "field", chain: ["orders"] },
+            constraint: { constraint_type: "ON" },
+          },
+        },
+      });
+    });
+
+    it("should convert CROSS JOIN", () => {
+      const ast = parseAndConvert("SELECT * FROM users CROSS JOIN orders");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+          next_join: {
+            expression_type: "join_expr",
+            join_type: "CROSS JOIN",
+            table: { expression_type: "field", chain: ["orders"] },
+          },
+        },
+      });
+    });
+  });
+
+  describe("UNION queries", () => {
+    it("should convert UNION DISTINCT query", () => {
+      // Grammar supports UNION ALL, UNION DISTINCT, INTERSECT, INTERSECT DISTINCT, EXCEPT
+      // Bare UNION (without ALL/DISTINCT) is not supported
+      const ast = parseAndConvert("SELECT id FROM users UNION DISTINCT SELECT id FROM customers");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_set_query",
+        initial_select_query: {
+          expression_type: "select_query",
+          select: [{ expression_type: "field", chain: ["id"] }],
+          select_from: {
+            table: { expression_type: "field", chain: ["users"] },
+          },
+        },
+        subsequent_select_queries: [
+          {
+            set_operator: "UNION DISTINCT",
+            select_query: {
+              expression_type: "select_query",
+              select: [{ expression_type: "field", chain: ["id"] }],
+              select_from: {
+                table: { expression_type: "field", chain: ["customers"] },
+              },
+            },
+          },
+        ],
+      });
+    });
+
+    it("should convert UNION ALL query", () => {
+      const ast = parseAndConvert("SELECT id FROM users UNION ALL SELECT id FROM customers");
+
+      expect(ast).toMatchObject({
+        expression_type: "select_set_query",
+        initial_select_query: {
+          expression_type: "select_query",
+          select: [{ expression_type: "field", chain: ["id"] }],
+        },
+        subsequent_select_queries: [
+          {
+            set_operator: "UNION ALL",
+            select_query: {
+              expression_type: "select_query",
+              select: [{ expression_type: "field", chain: ["id"] }],
+            },
+          },
+        ],
+      });
+    });
+  });
+
+  describe("WITH clauses (CTEs)", () => {
+    it("should convert SELECT with WITH clause", () => {
+      const ast = parseAndConvert(
+        "WITH recent_users AS (SELECT * FROM users WHERE created_at > '2024-01-01') SELECT * FROM recent_users"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        ctes: {
+          recent_users: {
+            expression_type: "cte",
+            name: "recent_users",
+            cte_type: "subquery",
+            expr: {
+              expression_type: "select_query",
+              select: [{ expression_type: "field", chain: ["*"] }],
+              select_from: {
+                table: { expression_type: "field", chain: ["users"] },
+              },
+              where: {
+                expression_type: "compare_operation",
+                op: CompareOperationOp.Gt,
+              },
+            },
+          },
+        },
+        select: [{ expression_type: "field", chain: ["*"] }],
+        select_from: {
+          table: { expression_type: "field", chain: ["recent_users"] },
+        },
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("should preserve position information in errors", () => {
+      const input = "SELECT * FROM users WHERE invalid syntax";
+      const inputStream = CharStreams.fromString(input);
+      const lexer = new TSQLLexer(inputStream);
+      const tokenStream = new CommonTokenStream(lexer);
+      const parser = new TSQLParser(tokenStream);
+
+      // This might not parse correctly, but if it does and we visit an error node,
+      // it should throw with position info
+      try {
+        const parseTree = parser.select();
+        const converter = new TSQLParseTreeConverter();
+        converter.visit(parseTree);
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          // Error should have position information if available
+          expect(error).toBeInstanceOf(SyntaxError);
+        }
+      }
+    });
+  });
+
+  describe("complex queries", () => {
+    it("should convert a complex query with multiple clauses", () => {
+      const ast = parseAndConvert(
+        "SELECT category, COUNT(*) as count " +
+          "FROM products " +
+          "WHERE price > 100 " +
+          "GROUP BY category " +
+          "HAVING COUNT(*) > 5 " +
+          "ORDER BY count DESC " +
+          "LIMIT 10"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [
+          { expression_type: "field", chain: ["category"] },
+          {
+            expression_type: "alias",
+            alias: "count",
+            expr: { expression_type: "call", name: "COUNT" },
+          },
+        ],
+        select_from: {
+          table: { expression_type: "field", chain: ["products"] },
+        },
+        where: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Gt,
+          left: { expression_type: "field", chain: ["price"] },
+          right: { expression_type: "constant", value: 100 },
+        },
+        group_by: [{ expression_type: "field", chain: ["category"] }],
+        having: {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Gt,
+          left: { expression_type: "call", name: "COUNT" },
+          right: { expression_type: "constant", value: 5 },
+        },
+        order_by: [
+          {
+            expression_type: "order_expr",
+            order: "DESC",
+            expr: { expression_type: "field", chain: ["count"] },
+          },
+        ],
+        limit: { expression_type: "constant", value: 10 },
+      });
+    });
+
+    it("should convert query with multiple JOINs", () => {
+      const ast = parseAndConvert(
+        "SELECT * FROM users " +
+          "INNER JOIN orders ON users.id = orders.user_id " +
+          "LEFT JOIN products ON orders.product_id = products.id"
+      );
+
+      expect(ast).toMatchObject({
+        expression_type: "select_query",
+        select: [{ expression_type: "field", chain: ["*"] }],
+        select_from: {
+          expression_type: "join_expr",
+          table: { expression_type: "field", chain: ["users"] },
+          next_join: {
+            expression_type: "join_expr",
+            join_type: "INNER JOIN",
+            table: { expression_type: "field", chain: ["orders"] },
+            constraint: { constraint_type: "ON" },
+            next_join: {
+              expression_type: "join_expr",
+              join_type: "LEFT JOIN",
+              table: { expression_type: "field", chain: ["products"] },
+              constraint: { constraint_type: "ON" },
+            },
+          },
+        },
+      });
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/query/parser.ts b/internal-packages/tsql/src/query/parser.ts
new file mode 100644
index 00000000000..05b1df052ba
--- /dev/null
+++ b/internal-packages/tsql/src/query/parser.ts
@@ -0,0 +1,1845 @@
+import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
+import { Token } from "antlr4ts/Token";
+import { ErrorNode } from "antlr4ts/tree/ErrorNode";
+import { ParseTree } from "antlr4ts/tree/ParseTree";
+import { TerminalNode } from "antlr4ts/tree/TerminalNode";
+import {
+  AliasContext,
+  BlockContext,
+  CatchBlockContext,
+  ColumnExprAliasContext,
+  ColumnExprAndContext,
+  ColumnExprArrayAccessContext,
+  ColumnExprArrayContext,
+  ColumnExprAsteriskContext,
+  ColumnExprBetweenContext,
+  ColumnExprCallContext,
+  ColumnExprCallSelectContext,
+  ColumnExprCaseContext,
+  ColumnExprDictContext,
+  ColumnExprFunctionContext,
+  ColumnExprIdentifierContext,
+  ColumnExprIntervalContext,
+  ColumnExprIsNullContext,
+  ColumnExprListContext,
+  ColumnExprLiteralContext,
+  ColumnExprNegateContext,
+  ColumnExprNotContext,
+  ColumnExprNullArrayAccessContext,
+  ColumnExprNullishContext,
+  ColumnExprNullPropertyAccessContext,
+  ColumnExprNullTupleAccessContext,
+  ColumnExprOrContext,
+  ColumnExprParensContext,
+  ColumnExprPrecedence1Context,
+  ColumnExprPrecedence2Context,
+  ColumnExprPrecedence3Context,
+  ColumnExprPropertyAccessContext,
+  ColumnExprSubqueryContext,
+  ColumnExprTemplateStringContext,
+  ColumnExprTernaryOpContext,
+  ColumnExprTupleAccessContext,
+  ColumnExprTupleContext,
+  ColumnExprWinFunctionContext,
+  ColumnExprWinFunctionTargetContext,
+  ColumnIdentifierContext,
+  ColumnLambdaExprContext,
+  DatabaseIdentifierContext,
+  DeclarationContext,
+  EmptyStmtContext,
+  ExpressionContext,
+  ExprStmtContext,
+  ForInStmtContext,
+  ForStmtContext,
+  FrameBetweenContext,
+  FrameStartContext,
+  FromClauseContext,
+  FullTemplateStringContext,
+  FuncStmtContext,
+  GroupByClauseContext,
+  HavingClauseContext,
+  IdentifierContext,
+  IdentifierListContext,
+  IfStmtContext,
+  JoinConstraintClauseContext,
+  JoinExprCrossOpContext,
+  JoinExprOpContext,
+  JoinExprParensContext,
+  JoinExprTableContext,
+  JoinOpFullContext,
+  JoinOpInnerContext,
+  JoinOpLeftRightContext,
+  KvPairContext,
+  KvPairListContext,
+  LimitByClauseContext,
+  LimitExprContext,
+  LiteralContext,
+  NestedIdentifierContext,
+  NumberLiteralContext,
+  OrderByClauseContext,
+  OrderExprContext,
+  OrderExprListContext,
+  PlaceholderContext,
+  PrewhereClauseContext,
+  ProgramContext,
+  RatioExprContext,
+  ReturnStmtContext,
+  SampleClauseContext,
+  SelectContext,
+  SelectSetStmtContext,
+  SelectStmtContext,
+  SelectStmtWithParensContext,
+  StatementContext,
+  StringContentsContext,
+  StringContentsFullContext,
+  StringContext,
+  TableArgListContext,
+  TableExprAliasContext,
+  TableExprFunctionContext,
+  TableExprIdentifierContext,
+  TableExprPlaceholderContext,
+  TableExprSubqueryContext,
+  TableExprTagContext,
+  TableFunctionExprContext,
+  TableIdentifierContext,
+  TemplateStringContext,
+  ThrowStmtContext,
+  TryCatchStmtContext,
+  TSQLxChildElementContext,
+  TSQLxTagAttributeContext,
+  TSQLxTagElementContext,
+  VarAssignmentContext,
+  VarDeclContext,
+  WhereClauseContext,
+  WhileStmtContext,
+  WindowExprContext,
+  WinFrameBoundContext,
+  WinFrameClauseContext,
+  WinOrderByClauseContext,
+  WinPartitionByClauseContext,
+  WithClauseContext,
+  WithExprColumnContext,
+  WithExprListContext,
+  WithExprSubqueryContext,
+} from "../grammar/TSQLParser.js";
+import { TSQLParserVisitor } from "../grammar/TSQLParserVisitor.js";
+import {
+  Alias,
+  And,
+  ArithmeticOperation,
+  ArithmeticOperationOp,
+  ArrayAccess,
+  Array as ArrayExpression,
+  AST,
+  BetweenExpr,
+  Block,
+  Call,
+  CompareOperation,
+  CompareOperationOp,
+  Constant,
+  CTE,
+  Declaration,
+  Dict,
+  Expr,
+  ExprCall,
+  Expression,
+  ExprStatement,
+  Field,
+  ForInStatement,
+  ForStatement,
+  Function,
+  TSQLXAttribute,
+  TSQLXTag,
+  IfStatement,
+  JoinConstraint,
+  JoinExpr,
+  Lambda,
+  LimitByExpr,
+  Not,
+  Or,
+  OrderExpr,
+  ParseResult,
+  Placeholder,
+  Program,
+  RatioExpr,
+  ReturnStatement,
+  SampleExpr,
+  SelectQuery,
+  SelectSetNode,
+  SelectSetQuery,
+  SetOperator,
+  Statement,
+  ThrowStatement,
+  TryCatchStatement,
+  Tuple,
+  TupleAccess,
+  VariableAssignment,
+  VariableDeclaration,
+  WhileStatement,
+  WindowExpr,
+  WindowFrameExpr,
+  WindowFunction,
+} from "./ast";
+import { RESERVED_KEYWORDS } from "./constants";
+import { BaseTSQLError, NotImplementedError, SyntaxError } from "./errors";
+import { parseStringLiteralText } from "./parse_string";
+
+/**
+ * Token with position information.
+ * antlr4ts Token interface has startIndex/stopIndex, but runtime may also expose start/stop.
+ * This type represents the union of both possibilities.
+ */
+type TokenWithPosition = Token & {
+  start?: number;
+  stop?: number;
+};
+
+/**
+ * Extract start position from a token, handling both start and startIndex properties.
+ */
+function getTokenStart(token: Token | undefined): number | undefined {
+  if (!token) return undefined;
+  const tokenWithPos = token as TokenWithPosition;
+  // Try start first (runtime property), then fall back to startIndex (type-safe property)
+  return tokenWithPos.start ?? tokenWithPos.startIndex;
+}
+
+/**
+ * Extract stop position from a token, handling both stop and stopIndex properties.
+ */
+function getTokenStop(token: Token | undefined): number | undefined {
+  if (!token) return undefined;
+  const tokenWithPos = token as TokenWithPosition;
+  // Try stop first (runtime property), then fall back to stopIndex (type-safe property)
+  return tokenWithPos.stop ?? tokenWithPos.stopIndex;
+}
+
+/**
+ * Visitor that converts TSQL AST to a QueryConfig
+ * The QueryConfig can then be used to build a ClickhouseQueryBuilder
+ */
+export class TSQLParseTreeConverter implements TSQLParserVisitor<any> {
+  start?: number;
+
+  constructor(start?: number) {
+    this.start = start;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Typed visit helpers - these provide type-safe wrappers around the generic visit()
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  /** Visit a column expression and return an Expression */
+  private visitAsExpr(ctx: ParserRuleContext): Expression {
+    return this.visit(ctx) as Expression;
+  }
+
+  /** Visit a join expression context */
+  private visitJoin(ctx: ParserRuleContext): JoinExpr {
+    return this.visit(ctx) as JoinExpr;
+  }
+
+  /** Visit an order expression list */
+  private visitOrderList(ctx: ParserRuleContext): OrderExpr[] {
+    return this.visit(ctx) as OrderExpr[];
+  }
+
+  /** Visit a window expression */
+  private visitWindow(ctx: ParserRuleContext): WindowExpr {
+    return this.visit(ctx) as WindowExpr;
+  }
+
+  /** Visit a ratio expression */
+  private visitRatio(ctx: ParserRuleContext): RatioExpr {
+    return this.visit(ctx) as RatioExpr;
+  }
+
+  /** Visit a CTE list */
+  private visitCTEs(ctx: ParserRuleContext): Record<string, CTE> {
+    return this.visit(ctx) as Record<string, CTE>;
+  }
+
+  /** Visit an expression list */
+  private visitExprList(ctx: ParserRuleContext): Expression[] {
+    return this.visit(ctx) as Expression[];
+  }
+
+  /** Visit a select statement */
+  private visitSelectQuery(ctx: ParserRuleContext): SelectQuery | SelectSetQuery {
+    return this.visit(ctx) as SelectQuery | SelectSetQuery;
+  }
+
+  /** Visit a placeholder */
+  private visitPlaceholderExpr(ctx: ParserRuleContext): Placeholder {
+    return this.visit(ctx) as Placeholder;
+  }
+
+  /** Visit and return a string (for identifiers, aliases) */
+  private visitAsString(ctx: ParserRuleContext): string {
+    return this.visit(ctx) as string;
+  }
+
+  /** Visit and return string array (for table identifiers, nested identifiers) */
+  private visitStringArray(ctx: ParserRuleContext): string[] {
+    return this.visit(ctx) as string[];
+  }
+
+  /** Visit a limit by expression */
+  private visitLimitBy(ctx: ParserRuleContext): LimitByExpr {
+    return this.visit(ctx) as LimitByExpr;
+  }
+
+  /** Visit a join operator and return the type string */
+  private visitJoinOpString(ctx: ParserRuleContext): string {
+    return this.visit(ctx) as string;
+  }
+
+  /** Visit a join constraint */
+  private visitConstraint(ctx: ParserRuleContext): JoinConstraint {
+    return this.visit(ctx) as JoinConstraint;
+  }
+
+  /** Visit a sample expression */
+  private visitSample(ctx: ParserRuleContext): SampleExpr {
+    return this.visit(ctx) as SampleExpr;
+  }
+
+  /** Visit a window frame expression */
+  private visitFrame(ctx: ParserRuleContext): WindowFrameExpr | [WindowFrameExpr, WindowFrameExpr] {
+    return this.visit(ctx) as WindowFrameExpr | [WindowFrameExpr, WindowFrameExpr];
+  }
+
+  /** Visit and return a Constant */
+  private visitConst(ctx: ParserRuleContext): Constant {
+    return this.visit(ctx) as Constant;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Core visitor methods
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  visit(ctx: ParserRuleContext): ParseResult {
+    const start = getTokenStart(ctx.start);
+    const stop = getTokenStop(ctx.stop);
+    const end = stop !== undefined ? stop + 1 : undefined;
+    try {
+      // Use accept() for proper visitor dispatch - this calls the correct visitXxx method
+      // based on the runtime type of the context
+      const node = ctx.accept(this);
+      // Only set position if node is a valid object and we have position info
+      if (
+        node &&
+        typeof node === "object" &&
+        node !== null &&
+        "start" in node &&
+        this.start !== undefined
+      ) {
+        node.start = start;
+        node.end = end;
+      }
+      return node;
+    } catch (e: any) {
+      if (e instanceof BaseTSQLError) {
+        if (
+          start !== undefined &&
+          end !== undefined &&
+          (e.start === undefined || e.end === undefined)
+        ) {
+          e.start = start;
+          e.end = end;
+        }
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Visit a parse tree node, dispatching to the appropriate visitor method.
+   * Uses the accept method for proper double dispatch, which handles ErrorNode vs TerminalNode correctly.
+   */
+  private visitParseTree(node: ParseTree): any {
+    // Use accept method for double dispatch - this will call the correct visit method
+    // based on the actual runtime type of the node
+    return node.accept(this);
+  }
+
+  visitChildren(ctx: ParserRuleContext): any {
+    if (!ctx.children || ctx.children.length === 0) {
+      return null;
+    }
+
+    const results: any[] = [];
+    for (const child of ctx.children) {
+      results.push(this.visitParseTree(child));
+    }
+
+    // Return single result if only one child, otherwise return array
+    return results.length === 1 ? results[0] : results;
+  }
+
+  visitTerminal(node: TerminalNode): any {
+    // Terminal nodes are leaf nodes (tokens) in the parse tree
+    // Typically not needed for AST conversion, but required by interface
+    return null;
+  }
+
+  visitErrorNode(node: ErrorNode): any {
+    // Error nodes represent syntax errors in the parse tree
+    // Throw a syntax error with position information
+    const symbol = node.symbol;
+    // ErrorNode has a symbol property with text
+    const text = symbol?.text || "";
+    const start = getTokenStart(symbol);
+    const end = symbol ? (getTokenStop(symbol) ?? -1) + 1 : undefined;
+    throw new SyntaxError(`Syntax error: ${text}`, {
+      start,
+      end,
+    });
+  }
+
+  // Program and declarations
+  visitProgram(ctx: ProgramContext): Program {
+    const declarations: Declaration[] = [];
+    // Implement based on your parser context structure
+    throw new NotImplementedError("visitProgram not implemented");
+  }
+
+  visitDeclaration(ctx: DeclarationContext): Declaration {
+    return this.visitChildren(ctx);
+  }
+
+  visitExpression(ctx: ExpressionContext): Expression {
+    return this.visitChildren(ctx);
+  }
+
+  visitVarDecl(ctx: VarDeclContext): VariableDeclaration {
+    const expr = ctx.expression();
+    return {
+      name: this.visitIdentifier(ctx.identifier()),
+      expr: expr ? this.visitExpression(expr) : undefined,
+    };
+  }
+
+  visitVarAssignment(ctx: VarAssignmentContext): VariableAssignment {
+    return {
+      left: this.visitExpression(ctx.expression(0)),
+      right: this.visitExpression(ctx.expression(1)),
+    };
+  }
+
+  visitStatement(ctx: StatementContext): Statement {
+    return this.visitChildren(ctx);
+  }
+
+  visitExprStmt(ctx: ExprStmtContext): ExprStatement {
+    return {
+      expr: this.visitExpression(ctx.expression()),
+    };
+  }
+
+  visitReturnStmt(ctx: ReturnStmtContext): ReturnStatement {
+    const expr = ctx.expression();
+    return {
+      expr: expr ? this.visitExpression(expr) : undefined,
+    };
+  }
+
+  visitThrowStmt(ctx: ThrowStmtContext): ThrowStatement {
+    const expr = ctx.expression();
+    return {
+      expr: expr ? this.visitExpression(expr) : undefined,
+    };
+  }
+
+  visitCatchBlock(ctx: CatchBlockContext): [string | null, string | null, Statement] {
+    const catchVar = ctx._catchVar;
+    const catchType = ctx._catchType;
+    const catchStmt = ctx._catchStmt;
+    if (!catchStmt) {
+      throw new SyntaxError("Catch statement is required");
+    }
+    return [
+      catchVar ? this.visitIdentifier(catchVar) : null,
+      catchType ? this.visitIdentifier(catchType) : null,
+      this.visitBlock(catchStmt),
+    ];
+  }
+
+  visitTryCatchStmt(ctx: TryCatchStmtContext): TryCatchStatement {
+    const tryStmt = ctx._tryStmt;
+    const catchBlocks = ctx.catchBlock();
+    const finallyStmt = ctx._finallyStmt;
+    if (!tryStmt) {
+      throw new SyntaxError("Try statement is required");
+    }
+    return {
+      try_stmt: this.visitBlock(tryStmt),
+      catches: catchBlocks.map((c: CatchBlockContext) => this.visitCatchBlock(c)),
+      finally_stmt: finallyStmt ? this.visitBlock(finallyStmt) : undefined,
+    };
+  }
+
+  visitIfStmt(ctx: IfStmtContext): IfStatement {
+    return {
+      expr: this.visitExpression(ctx.expression()),
+      then: this.visitStatement(ctx.statement(0)),
+      else_: ctx.statement(1) ? this.visitStatement(ctx.statement(1)) : undefined,
+    };
+  }
+
+  visitWhileStmt(ctx: WhileStmtContext): WhileStatement {
+    const statement = ctx.statement();
+    if (!statement) {
+      throw new SyntaxError("While statement body is required");
+    }
+    return {
+      expr: this.visitExpression(ctx.expression()),
+      body: this.visitStatement(statement),
+    };
+  }
+
+  visitForInStmt(ctx: ForInStmtContext): ForInStatement {
+    const firstIdentifier = this.visitIdentifier(ctx.identifier(0));
+    const secondIdentifier = ctx.identifier(1) ? this.visitIdentifier(ctx.identifier(1)) : null;
+    const statement = ctx.statement();
+    if (!statement) {
+      throw new SyntaxError("For in statement body is required");
+    }
+    return {
+      valueVar: secondIdentifier ?? firstIdentifier,
+      keyVar: secondIdentifier ? firstIdentifier : undefined,
+      expr: this.visitExpression(ctx.expression()),
+      body: this.visitStatement(statement),
+    };
+  }
+
+  visitForStmt(ctx: ForStmtContext): ForStatement {
+    const initializer =
+      ctx._initializerVarDeclr || ctx._initializerVarAssignment || ctx._initializerExpression;
+    const increment =
+      ctx._incrementVarDeclr || ctx._incrementVarAssignment || ctx._incrementExpression;
+
+    const statement = ctx.statement();
+    if (!statement) {
+      throw new SyntaxError("For statement body is required");
+    }
+    return {
+      initializer: initializer ? this.visitVarDecl(initializer as any) : undefined,
+      condition: this.visitExpression(ctx._condition),
+      increment: this.visitVarDecl(increment as any),
+      body: this.visitStatement(statement),
+    };
+  }
+
+  visitFuncStmt(ctx: FuncStmtContext): Function {
+    const params = ctx.identifierList();
+
+    return {
+      name: this.visitIdentifier(ctx.identifier()),
+      params: params ? this.visitIdentifierList(params) : [],
+      body: this.visitBlock(ctx.block()),
+    };
+  }
+
+  visitKvPairList(ctx: KvPairListContext): [Expression, Expression][] {
+    return ctx
+      .kvPair()
+      .map((kv: any) => [
+        this.visitExpression(kv.expression(0)),
+        this.visitExpression(kv.expression(1)),
+      ]);
+  }
+
+  visitKvPair(ctx: KvPairContext): [Expression, Expression] {
+    const exprs = ctx.expression();
+    return [this.visitExpression(exprs[0]), this.visitExpression(exprs[1])];
+  }
+
+  visitIdentifierList(ctx: IdentifierListContext): string[] {
+    return ctx.identifier().map((ident: any) => this.visitIdentifier(ident));
+  }
+
+  visitEmptyStmt(ctx: EmptyStmtContext): ExprStatement {
+    return { expr: undefined };
+  }
+
+  visitBlock(ctx: BlockContext): Block {
+    const declarations: Declaration[] = [];
+    // Implement based on your parser structure
+    throw new NotImplementedError("visitBlock not implemented");
+  }
+
+  // SELECT statements
+  visitSelect(ctx: SelectContext): SelectQuery | SelectSetQuery | TSQLXTag {
+    const selectSetStmt = ctx.selectSetStmt();
+    const selectStmt = ctx.selectStmt();
+    const tSQLxTagElement = ctx.tSQLxTagElement();
+    if (selectSetStmt) {
+      return this.visitSelectSetStmt(selectSetStmt);
+    } else if (selectStmt) {
+      return this.visitSelectStmt(selectStmt);
+    } else if (tSQLxTagElement) {
+      return this.visitTsqlxTagElementNested(tSQLxTagElement);
+    }
+    throw new SyntaxError(
+      "Select statement must be either a select set statement, a select statement, or a tSQLx tag element"
+    );
+  }
+
+  visitSelectSetStmt(ctx: SelectSetStmtContext): SelectQuery | SelectSetQuery {
+    const selectQueries: SelectSetNode[] = [];
+    const initialQuery = this.visitSelectStmtWithParens(ctx.selectStmtWithParens());
+
+    for (const subsequent of ctx.subsequentSelectSetClause()) {
+      let unionType: SetOperator;
+      if (subsequent.UNION() && subsequent.ALL()) {
+        unionType = "UNION ALL";
+      } else if (subsequent.UNION() && subsequent.DISTINCT()) {
+        unionType = "UNION DISTINCT";
+      } else if (subsequent.INTERSECT() && subsequent.DISTINCT()) {
+        unionType = "INTERSECT DISTINCT";
+      } else if (subsequent.INTERSECT()) {
+        unionType = "INTERSECT";
+      } else if (subsequent.EXCEPT()) {
+        unionType = "EXCEPT";
+      } else {
+        throw new SyntaxError(
+          "Set operator must be one of UNION ALL, UNION DISTINCT, INTERSECT, INTERSECT DISTINCT, and EXCEPT"
+        );
+      }
+      const selectQuery = this.visitSelectStmtWithParens(subsequent.selectStmtWithParens());
+      // SelectSetNode expects SelectQuery | SelectSetQuery, but visitSelectStmtWithParens may return Placeholder
+      // In practice, a Placeholder in this position would be substituted at runtime
+      selectQueries.push({
+        select_query: selectQuery as SelectQuery | SelectSetQuery,
+        set_operator: unionType,
+      });
+    }
+
+    if (selectQueries.length === 0) {
+      // initialQuery may be Placeholder but we cast since SelectSetQuery expects SelectQuery | SelectSetQuery
+      return initialQuery as SelectQuery | SelectSetQuery;
+    }
+    return {
+      expression_type: "select_set_query",
+      initial_select_query: initialQuery as SelectQuery | SelectSetQuery,
+      subsequent_select_queries: selectQueries,
+    };
+  }
+
+  visitSelectStmtWithParens(
+    ctx: SelectStmtWithParensContext
+  ): SelectQuery | SelectSetQuery | Placeholder {
+    const selectStmt = ctx.selectStmt();
+    const selectSetStmt = ctx.selectSetStmt();
+    const placeholder = ctx.placeholder();
+    if (selectStmt) {
+      return this.visitSelectStmt(selectStmt);
+    } else if (selectSetStmt) {
+      return this.visitSelectSetStmt(selectSetStmt);
+    } else if (placeholder) {
+      return this.visitPlaceholder(placeholder);
+    }
+    throw new SyntaxError(
+      "Select statement must be either a select statement, a select set statement, or a placeholder"
+    );
+  }
+
+  visitSelectStmt(ctx: SelectStmtContext): SelectQuery {
+    const withClause = ctx.withClause();
+    const columnExprList = ctx.columnExprList();
+    const fromClause = ctx.fromClause();
+    const whereClause = ctx.whereClause();
+    const prewhereClause = ctx.prewhereClause();
+    const havingClause = ctx.havingClause();
+    const groupByClause = ctx.groupByClause();
+    const orderByClause = ctx.orderByClause();
+    const limitByClause = ctx.limitByClause();
+    const selectQuery: SelectQuery = {
+      expression_type: "select_query",
+      ctes: withClause ? this.visitWithClause(withClause) : undefined,
+      select: columnExprList ? this.visitColumnExprList(columnExprList) : [],
+      distinct: ctx.DISTINCT() ? true : undefined,
+      select_from: fromClause ? this.visitJoin(fromClause) : undefined,
+      where: whereClause ? this.visitAsExpr(whereClause) : undefined,
+      prewhere: prewhereClause ? this.visitAsExpr(prewhereClause) : undefined,
+      having: havingClause ? this.visitAsExpr(havingClause) : undefined,
+      group_by: groupByClause ? this.visitExprList(groupByClause) : undefined,
+      order_by: orderByClause ? this.visitOrderList(orderByClause) : undefined,
+      limit_by: limitByClause ? this.visitLimitBy(limitByClause) : undefined,
+    };
+
+    const windowClause = ctx.windowClause();
+    if (windowClause) {
+      selectQuery.window_exprs = {};
+      for (let index = 0; index < windowClause.windowExpr().length; index++) {
+        const name = this.visitAsString(windowClause.identifier()[index]);
+        selectQuery.window_exprs![name] = this.visitWindow(windowClause.windowExpr()[index]);
+      }
+    }
+
+    const limitAndOffsetClause = ctx.limitAndOffsetClause();
+    const offsetOnlyClause = ctx.offsetOnlyClause();
+    if (limitAndOffsetClause) {
+      // Use array access to avoid getRuleContext throwing when index is out of bounds
+      const columnExprs = limitAndOffsetClause.columnExpr();
+      if (columnExprs.length > 0) {
+        selectQuery.limit = this.visitAsExpr(columnExprs[0]);
+      }
+      if (columnExprs.length > 1) {
+        selectQuery.offset = this.visitAsExpr(columnExprs[1]);
+      }
+      if (limitAndOffsetClause.WITH() && limitAndOffsetClause.TIES()) {
+        selectQuery.limit_with_ties = true;
+      }
+    } else if (offsetOnlyClause) {
+      selectQuery.offset = this.visitAsExpr(offsetOnlyClause.columnExpr());
+    }
+
+    const arrayJoinClause = ctx.arrayJoinClause();
+    if (arrayJoinClause) {
+      if (!selectQuery.select_from) {
+        throw new SyntaxError("Using ARRAY JOIN without a FROM clause is not permitted");
+      }
+      if (arrayJoinClause.LEFT()) {
+        selectQuery.array_join_op = "LEFT ARRAY JOIN";
+      } else if (arrayJoinClause.INNER()) {
+        selectQuery.array_join_op = "INNER ARRAY JOIN";
+      } else {
+        selectQuery.array_join_op = "ARRAY JOIN";
+      }
+      selectQuery.array_join_list = this.visitExprList(arrayJoinClause.columnExprList());
+      if (selectQuery.array_join_list) {
+        for (const expr of selectQuery.array_join_list) {
+          if (!("alias" in expr)) {
+            throw new SyntaxError("ARRAY JOIN arrays must have an alias", {
+              start: expr.start,
+              end: expr.end,
+            });
+          }
+        }
+      }
+    }
+
+    if (ctx.topClause()) {
+      throw new NotImplementedError("Unsupported: SelectStmt.topClause()");
+    }
+    if (ctx.settingsClause()) {
+      throw new NotImplementedError("Unsupported: SelectStmt.settingsClause()");
+    }
+
+    return selectQuery;
+  }
+
+  visitWithClause(ctx: WithClauseContext): Record<string, CTE> {
+    return this.visitCTEs(ctx.withExprList());
+  }
+
+  visitFromClause(ctx: FromClauseContext): JoinExpr {
+    return this.visitJoin(ctx.joinExpr());
+  }
+
+  visitPrewhereClause(ctx: PrewhereClauseContext): Expr {
+    return this.visitAsExpr(ctx.columnExpr());
+  }
+
+  visitWhereClause(ctx: WhereClauseContext): Expr {
+    return this.visitAsExpr(ctx.columnExpr());
+  }
+
+  visitGroupByClause(ctx: GroupByClauseContext): Expr[] {
+    const columnExprList = ctx.columnExprList();
+    if (!columnExprList) {
+      throw new SyntaxError("GROUP BY clause must have a column expression list");
+    }
+    return this.visitExprList(columnExprList);
+  }
+
+  visitHavingClause(ctx: HavingClauseContext): Expr {
+    return this.visitAsExpr(ctx.columnExpr());
+  }
+
+  visitOrderByClause(ctx: OrderByClauseContext): OrderExpr[] {
+    return this.visitOrderList(ctx.orderExprList());
+  }
+
+  visitLimitByClause(ctx: LimitByClauseContext): LimitByExpr {
+    const limitExpr = this.visitLimitExprResult(ctx.limitExpr());
+
+    // If limitExpr is a tuple (n, offset), split it
+    if (Array.isArray(limitExpr)) {
+      const [n, offsetValue] = limitExpr;
+      return {
+        expression_type: "limit_by_expr",
+        n,
+        offset_value: offsetValue,
+        exprs: this.visitExprList(ctx.columnExprList()),
+      };
+    }
+
+    // If no offset, just use limitExpr as n (TypeScript now knows it's Expression)
+    return {
+      expression_type: "limit_by_expr",
+      n: limitExpr,
+      offset_value: undefined,
+      exprs: this.visitExprList(ctx.columnExprList()),
+    };
+  }
+
+  /** Helper for visitLimitExpr which returns Expression | [Expression, Expression] */
+  private visitLimitExprResult(ctx: LimitExprContext): Expression | [Expression, Expression] {
+    return this.visitLimitExpr(ctx);
+  }
+
+  visitLimitExpr(ctx: LimitExprContext): Expression | [Expression, Expression] {
+    const n = this.visitAsExpr(ctx.columnExpr(0));
+
+    // Check if we have an offset (second expression)
+    if (ctx.columnExpr(1)) {
+      const offsetValue = this.visitAsExpr(ctx.columnExpr(1));
+      // For "LIMIT a, b" syntax: a is offset, b is limit
+      if (ctx.COMMA()) {
+        return [offsetValue, n]; // Return tuple as (offset, limit)
+      }
+      // For "LIMIT a OFFSET b" syntax: a is limit, b is offset
+      return [n, offsetValue];
+    }
+
+    return n;
+  }
+
+  // JOIN expressions
+  visitJoinExprOp(ctx: JoinExprOpContext): JoinExpr {
+    const join1: JoinExpr = this.visitJoin(ctx.joinExpr(0));
+    const join2: JoinExpr = this.visitJoin(ctx.joinExpr(1));
+
+    const joinOp = ctx.joinOp();
+    if (joinOp) {
+      join2.join_type = `${this.visitJoinOpString(joinOp)} JOIN`;
+    } else {
+      join2.join_type = "JOIN";
+    }
+    join2.constraint = this.visitConstraint(ctx.joinConstraintClause());
+
+    let lastJoin = join1;
+    while (lastJoin.next_join) {
+      lastJoin = lastJoin.next_join;
+    }
+    lastJoin.next_join = join2;
+
+    return join1;
+  }
+
+  visitJoinExprTable(ctx: JoinExprTableContext): JoinExpr {
+    const sampleClause = ctx.sampleClause();
+    const sample = sampleClause ? this.visitSample(sampleClause) : undefined;
+    const tableResult = this.visitTableExprResult(ctx.tableExpr());
+    const tableFinal = ctx.FINAL() ? true : undefined;
+    // Check if result is already a JoinExpr (from visitTableExprAlias or visitTableExprFunction)
+    if ("expression_type" in tableResult && tableResult.expression_type === "join_expr") {
+      // visitTableExprAlias returns a JoinExpr to pass the alias
+      // visitTableExprFunction returns a JoinExpr to pass the args
+      tableResult.table_final = tableFinal;
+      tableResult.sample = sample;
+      return tableResult;
+    }
+    // Otherwise, wrap the table expression in a JoinExpr
+    const table = tableResult as SelectQuery | SelectSetQuery | Placeholder | TSQLXTag | Field;
+    return {
+      expression_type: "join_expr",
+      table,
+      table_final: tableFinal,
+      sample,
+    };
+  }
+
+  /** Helper for visiting table expressions that may return JoinExpr or table types */
+  private visitTableExprResult(
+    ctx: ParserRuleContext
+  ): JoinExpr | SelectQuery | SelectSetQuery | Placeholder | TSQLXTag | Field {
+    return this.visit(ctx) as
+      | JoinExpr
+      | SelectQuery
+      | SelectSetQuery
+      | Placeholder
+      | TSQLXTag
+      | Field;
+  }
+
+  visitJoinExprParens(ctx: JoinExprParensContext): JoinExpr {
+    return this.visitJoin(ctx.joinExpr());
+  }
+
+  visitJoinExprCrossOp(ctx: JoinExprCrossOpContext): JoinExpr {
+    const join1: JoinExpr = this.visitJoin(ctx.joinExpr(0));
+    const join2: JoinExpr = this.visitJoin(ctx.joinExpr(1));
+    join2.join_type = "CROSS JOIN";
+    let lastJoin = join1;
+    while (lastJoin.next_join) {
+      lastJoin = lastJoin.next_join;
+    }
+    lastJoin.next_join = join2;
+    return join1;
+  }
+
+  visitJoinOpInner(ctx: JoinOpInnerContext): string {
+    const tokens: string[] = [];
+    if (ctx.ALL()) tokens.push("ALL");
+    if (ctx.ANY()) tokens.push("ANY");
+    if (ctx.ASOF()) tokens.push("ASOF");
+    tokens.push("INNER");
+    return tokens.join(" ");
+  }
+
+  visitJoinOpLeftRight(ctx: JoinOpLeftRightContext): string {
+    const tokens: string[] = [];
+    if (ctx.LEFT()) tokens.push("LEFT");
+    if (ctx.RIGHT()) tokens.push("RIGHT");
+    if (ctx.OUTER()) tokens.push("OUTER");
+    if (ctx.SEMI()) tokens.push("SEMI");
+    if (ctx.ALL()) tokens.push("ALL");
+    if (ctx.ANTI()) tokens.push("ANTI");
+    if (ctx.ANY()) tokens.push("ANY");
+    if (ctx.ASOF()) tokens.push("ASOF");
+    return tokens.join(" ");
+  }
+
+  visitJoinOpFull(ctx: JoinOpFullContext): string {
+    const tokens: string[] = [];
+    if (ctx.FULL()) tokens.push("FULL");
+    if (ctx.OUTER()) tokens.push("OUTER");
+    if (ctx.ALL()) tokens.push("ALL");
+    if (ctx.ANY()) tokens.push("ANY");
+    return tokens.join(" ");
+  }
+
+  visitJoinConstraintClause(ctx: JoinConstraintClauseContext): JoinConstraint {
+    const columnExprList = this.visitExprList(ctx.columnExprList());
+    if (columnExprList.length !== 1) {
+      throw new NotImplementedError("Unsupported: JOIN ... ON with multiple expressions");
+    }
+    return {
+      expression_type: "join_constraint",
+      expr: columnExprList[0],
+      constraint_type: ctx.USING() ? "USING" : "ON",
+    };
+  }
+
+  visitSampleClause(ctx: SampleClauseContext): SampleExpr {
+    const ratioExpressions = ctx.ratioExpr();
+    const sampleRatioExpr = this.visitRatio(ratioExpressions[0]);
+    const offsetRatioExpr =
+      ratioExpressions.length > 1 && ctx.OFFSET()
+        ? this.visitRatio(ratioExpressions[1])
+        : undefined;
+
+    return {
+      expression_type: "sample_expr",
+      sample_value: sampleRatioExpr,
+      offset_value: offsetRatioExpr,
+    };
+  }
+
+  visitOrderExprList(ctx: OrderExprListContext): OrderExpr[] {
+    return ctx.orderExpr().map((expr: OrderExprContext) => this.visitOrderExpr(expr));
+  }
+
+  visitOrderExpr(ctx: OrderExprContext): OrderExpr {
+    const order = ctx.DESC() || ctx.DESCENDING() ? "DESC" : "ASC";
+    return {
+      expression_type: "order_expr",
+      expr: this.visitAsExpr(ctx.columnExpr()),
+      order: order as "ASC" | "DESC",
+    };
+  }
+
+  visitRatioExpr(ctx: RatioExprContext): RatioExpr {
+    const placeholder = ctx.placeholder();
+    if (placeholder) {
+      return this.visitPlaceholderExpr(placeholder) as unknown as RatioExpr;
+    }
+
+    const numberLiterals = ctx.numberLiteral();
+    const left = numberLiterals[0];
+    const right = ctx.SLASH() && numberLiterals.length > 1 ? numberLiterals[1] : null;
+
+    return {
+      expression_type: "ratio_expr",
+      left: this.visitNumberLiteral(left),
+      right: right ? this.visitNumberLiteral(right) : undefined,
+    };
+  }
+
+  visitWindowExpr(ctx: WindowExprContext): WindowExpr {
+    const frame = ctx.winFrameClause();
+    const visitedFrame = frame ? this.visitFrame(frame) : undefined;
+    const partitionByClause = ctx.winPartitionByClause();
+    const orderByClause = ctx.winOrderByClause();
+    return {
+      expression_type: "window_expr",
+      partition_by: partitionByClause ? this.visitExprList(partitionByClause) : undefined,
+      order_by: orderByClause ? this.visitOrderList(orderByClause) : undefined,
+      frame_method: frame && frame.RANGE() ? "RANGE" : frame && frame.ROWS() ? "ROWS" : undefined,
+      frame_start: Array.isArray(visitedFrame) ? visitedFrame[0] : visitedFrame,
+      frame_end: Array.isArray(visitedFrame) ? visitedFrame[1] : undefined,
+    };
+  }
+
+  visitWinPartitionByClause(ctx: WinPartitionByClauseContext): Expr[] {
+    return this.visitExprList(ctx.columnExprList());
+  }
+
+  visitWinOrderByClause(ctx: WinOrderByClauseContext): OrderExpr[] {
+    return this.visitOrderList(ctx.orderExprList());
+  }
+
+  visitWinFrameClause(
+    ctx: WinFrameClauseContext
+  ): WindowFrameExpr | [WindowFrameExpr, WindowFrameExpr] {
+    return this.visitFrame(ctx.winFrameExtend());
+  }
+
+  visitFrameStart(ctx: FrameStartContext): WindowFrameExpr {
+    return this.visitFrameBound(ctx.winFrameBound());
+  }
+
+  visitFrameBetween(ctx: FrameBetweenContext): [WindowFrameExpr, WindowFrameExpr] {
+    return [this.visitFrameBound(ctx.winFrameBound(0)), this.visitFrameBound(ctx.winFrameBound(1))];
+  }
+
+  /** Helper for visiting a single frame bound */
+  private visitFrameBound(ctx: WinFrameBoundContext): WindowFrameExpr {
+    return this.visitWinFrameBound(ctx);
+  }
+
+  visitWinFrameBound(ctx: WinFrameBoundContext): WindowFrameExpr {
+    if (ctx.PRECEDING()) {
+      const numberLiteral = ctx.numberLiteral();
+      return {
+        expression_type: "window_frame_expr",
+        frame_type: "PRECEDING",
+        frame_value: numberLiteral ? this.visitNumberLiteral(numberLiteral).value : undefined,
+      };
+    }
+    if (ctx.FOLLOWING()) {
+      const numberLiteral = ctx.numberLiteral();
+      return {
+        expression_type: "window_frame_expr",
+        frame_type: "FOLLOWING",
+        frame_value: numberLiteral ? this.visitNumberLiteral(numberLiteral).value : undefined,
+      };
+    }
+    return { expression_type: "window_frame_expr", frame_type: "CURRENT ROW" };
+  }
+
+  // Column expressions
+  visitColumnExprList(ctx: ColumnExprListContext): Expression[] {
+    return ctx.columnExpr().map((c: ParserRuleContext) => this.visitAsExpr(c));
+  }
+
+  visitColumnExprTernaryOp(ctx: ColumnExprTernaryOpContext): Call {
+    return {
+      expression_type: "call",
+      name: "if",
+      args: [
+        this.visitAsExpr(ctx.columnExpr(0)),
+        this.visitAsExpr(ctx.columnExpr(1)),
+        this.visitAsExpr(ctx.columnExpr(2)),
+      ],
+    };
+  }
+
+  visitColumnExprAlias(ctx: ColumnExprAliasContext): Alias {
+    let alias: string;
+    const identifier = ctx.identifier();
+    const stringLiteral = ctx.STRING_LITERAL();
+    if (identifier) {
+      alias = this.visitIdentifier(identifier);
+    } else if (stringLiteral) {
+      alias = parseStringLiteralText(stringLiteral.text);
+    } else {
+      throw new SyntaxError("Must specify an alias");
+    }
+    const expr = this.visitAsExpr(ctx.columnExpr());
+
+    if (RESERVED_KEYWORDS.includes(alias.toLowerCase() as any)) {
+      throw new SyntaxError(
+        `"${alias}" cannot be an alias or identifier, as it's a reserved keyword`
+      );
+    }
+
+    return { expression_type: "alias", expr, alias };
+  }
+
+  visitColumnExprNegate(ctx: ColumnExprNegateContext): ArithmeticOperation {
+    return {
+      expression_type: "arithmetic_operation",
+      op: ArithmeticOperationOp.Sub,
+      left: { value: 0 } as Constant,
+      right: this.visitAsExpr(ctx.columnExpr()),
+    };
+  }
+
+  visitColumnExprDict(ctx: ColumnExprDictContext): Dict {
+    const kvPairList = ctx.kvPairList();
+    return {
+      expression_type: "dict",
+      items: kvPairList ? this.visitKvPairList(kvPairList) : [],
+    };
+  }
+
+  visitColumnExprSubquery(ctx: ColumnExprSubqueryContext): SelectQuery | SelectSetQuery {
+    return this.visitSelectQuery(ctx.selectSetStmt());
+  }
+
+  visitColumnExprLiteral(ctx: ColumnExprLiteralContext): Expr {
+    return this.visitChildren(ctx);
+  }
+
+  visitColumnExprArray(ctx: ColumnExprArrayContext): ArrayExpression {
+    const columnExprList = ctx.columnExprList();
+    return {
+      expression_type: "array",
+      exprs: columnExprList ? this.visitExprList(columnExprList) : [],
+    };
+  }
+
+  visitColumnExprPrecedence1(ctx: ColumnExprPrecedence1Context): ArithmeticOperation {
+    let op: ArithmeticOperationOp;
+    if (ctx.SLASH()) {
+      op = ArithmeticOperationOp.Div;
+    } else if (ctx.ASTERISK()) {
+      op = ArithmeticOperationOp.Mult;
+    } else if (ctx.PERCENT()) {
+      op = ArithmeticOperationOp.Mod;
+    } else {
+      throw new NotImplementedError(`Unsupported ColumnExprPrecedence1: ${ctx.text}`);
+    }
+    // Use columnExpr() method to get left and right operands
+    const left = this.visitAsExpr(ctx.columnExpr(0));
+    const right = this.visitAsExpr(ctx.columnExpr(1));
+    return { expression_type: "arithmetic_operation", left, right, op };
+  }
+
+  visitColumnExprPrecedence2(ctx: ColumnExprPrecedence2Context): ArithmeticOperation | Call {
+    // Use columnExpr() method to get left and right operands
+    const left = this.visitAsExpr(ctx.columnExpr(0));
+    const right = this.visitAsExpr(ctx.columnExpr(1));
+
+    if (ctx.PLUS()) {
+      return {
+        expression_type: "arithmetic_operation",
+        left,
+        right,
+        op: ArithmeticOperationOp.Add,
+      };
+    } else if (ctx.DASH()) {
+      return {
+        expression_type: "arithmetic_operation",
+        left,
+        right,
+        op: ArithmeticOperationOp.Sub,
+      };
+    } else if (ctx.CONCAT()) {
+      const args: Expression[] = [];
+      if ("name" in left && left.name === "concat" && "args" in left && left.args) {
+        args.push(...left.args);
+      } else {
+        args.push(left);
+      }
+
+      if ("name" in right && right.name === "concat" && "args" in right && right.args) {
+        args.push(...right.args);
+      } else {
+        args.push(right);
+      }
+
+      return { expression_type: "call", name: "concat", args };
+    } else {
+      throw new NotImplementedError(`Unsupported ColumnExprPrecedence2: ${ctx.text}`);
+    }
+  }
+
+  visitColumnExprPrecedence3(ctx: ColumnExprPrecedence3Context): CompareOperation {
+    // Use columnExpr() method to get left and right operands
+    const left = this.visitAsExpr(ctx.columnExpr(0));
+    const right = this.visitAsExpr(ctx.columnExpr(1));
+
+    let op: CompareOperationOp;
+    if (ctx.EQ_SINGLE() || ctx.EQ_DOUBLE()) {
+      op = CompareOperationOp.Eq;
+    } else if (ctx.NOT_EQ()) {
+      op = CompareOperationOp.NotEq;
+    } else if (ctx.LT()) {
+      op = CompareOperationOp.Lt;
+    } else if (ctx.LT_EQ()) {
+      op = CompareOperationOp.LtEq;
+    } else if (ctx.GT()) {
+      op = CompareOperationOp.Gt;
+    } else if (ctx.GT_EQ()) {
+      op = CompareOperationOp.GtEq;
+    } else if (ctx.LIKE()) {
+      op = ctx.NOT() ? CompareOperationOp.NotLike : CompareOperationOp.Like;
+    } else if (ctx.ILIKE()) {
+      op = ctx.NOT() ? CompareOperationOp.NotILike : CompareOperationOp.ILike;
+    } else if (ctx.REGEX_SINGLE() || ctx.REGEX_DOUBLE()) {
+      op = CompareOperationOp.Regex;
+    } else if (ctx.NOT_REGEX()) {
+      op = CompareOperationOp.NotRegex;
+    } else if (ctx.IREGEX_SINGLE() || ctx.IREGEX_DOUBLE()) {
+      op = CompareOperationOp.IRegex;
+    } else if (ctx.NOT_IREGEX()) {
+      op = CompareOperationOp.NotIRegex;
+    } else if (ctx.IN()) {
+      if (ctx.COHORT()) {
+        op = ctx.NOT() ? CompareOperationOp.NotInCohort : CompareOperationOp.InCohort;
+      } else {
+        op = ctx.NOT() ? CompareOperationOp.NotIn : CompareOperationOp.In;
+      }
+    } else {
+      throw new NotImplementedError(`Unsupported ColumnExprPrecedence3: ${ctx.text}`);
+    }
+
+    return { expression_type: "compare_operation", left, right, op };
+  }
+
+  visitColumnExprInterval(ctx: ColumnExprIntervalContext): Call {
+    let name: string;
+    const interval = ctx.interval();
+    if (interval.SECOND()) {
+      name = "toIntervalSecond";
+    } else if (interval.MINUTE()) {
+      name = "toIntervalMinute";
+    } else if (interval.HOUR()) {
+      name = "toIntervalHour";
+    } else if (interval.DAY()) {
+      name = "toIntervalDay";
+    } else if (interval.WEEK()) {
+      name = "toIntervalWeek";
+    } else if (interval.MONTH()) {
+      name = "toIntervalMonth";
+    } else if (interval.QUARTER()) {
+      name = "toIntervalQuarter";
+    } else if (interval.YEAR()) {
+      name = "toIntervalYear";
+    } else {
+      throw new NotImplementedError(`Unsupported interval type: ${interval.text}`);
+    }
+
+    return { expression_type: "call", name, args: [this.visitAsExpr(ctx.columnExpr())] };
+  }
+
+  visitColumnExprIsNull(ctx: ColumnExprIsNullContext): CompareOperation {
+    return {
+      expression_type: "compare_operation",
+      left: this.visitAsExpr(ctx.columnExpr()),
+      right: { expression_type: "constant", value: null } as Constant,
+      op: ctx.NOT() ? CompareOperationOp.NotEq : CompareOperationOp.Eq,
+    };
+  }
+
+  visitColumnExprTuple(ctx: ColumnExprTupleContext): Tuple {
+    const columnExprList = ctx.columnExprList();
+    return {
+      expression_type: "tuple",
+      exprs: columnExprList ? this.visitExprList(columnExprList) : [],
+    };
+  }
+
+  visitColumnExprArrayAccess(ctx: ColumnExprArrayAccessContext): ArrayAccess {
+    const object: Expression = this.visitAsExpr(ctx.columnExpr(0));
+    const property: Expression = this.visitAsExpr(ctx.columnExpr(1));
+    return { expression_type: "array_access", array: object, property };
+  }
+
+  visitColumnExprNullArrayAccess(ctx: ColumnExprNullArrayAccessContext): ArrayAccess {
+    const object: Expression = this.visitAsExpr(ctx.columnExpr(0));
+    const property: Expression = this.visitAsExpr(ctx.columnExpr(1));
+    return { expression_type: "array_access", array: object, property, nullish: true };
+  }
+
+  visitColumnExprPropertyAccess(ctx: ColumnExprPropertyAccessContext): ArrayAccess {
+    const object = this.visitAsExpr(ctx.columnExpr());
+    const property: Constant = {
+      expression_type: "constant",
+      value: this.visitIdentifier(ctx.identifier()),
+    };
+    return { expression_type: "array_access", array: object, property };
+  }
+
+  visitColumnExprNullPropertyAccess(ctx: ColumnExprNullPropertyAccessContext): ArrayAccess {
+    const object = this.visitAsExpr(ctx.columnExpr());
+    const property: Constant = {
+      expression_type: "constant",
+      value: this.visitIdentifier(ctx.identifier()),
+    };
+    return { expression_type: "array_access", array: object, property, nullish: true };
+  }
+
+  visitColumnExprBetween(ctx: ColumnExprBetweenContext): BetweenExpr {
+    return {
+      expression_type: "between_expr",
+      expr: this.visitAsExpr(ctx.columnExpr(0)),
+      low: this.visitAsExpr(ctx.columnExpr(1)),
+      high: this.visitAsExpr(ctx.columnExpr(2)),
+      negated: !!ctx.NOT(),
+    };
+  }
+
+  visitColumnExprParens(ctx: ColumnExprParensContext): Expr {
+    return this.visitAsExpr(ctx.columnExpr());
+  }
+
+  visitColumnExprAnd(ctx: ColumnExprAndContext): And {
+    const left = this.visitAsExpr(ctx.columnExpr(0));
+    const leftArray = "exprs" in left && left.exprs ? left.exprs : [left];
+
+    const right = this.visitAsExpr(ctx.columnExpr(1));
+    const rightArray = "exprs" in right && right.exprs ? right.exprs : [right];
+
+    return { expression_type: "and", exprs: [...leftArray, ...rightArray] };
+  }
+
+  visitColumnExprOr(ctx: ColumnExprOrContext): Or {
+    const left = this.visitAsExpr(ctx.columnExpr(0));
+    const leftArray = "exprs" in left && left.exprs ? left.exprs : [left];
+
+    const right = this.visitAsExpr(ctx.columnExpr(1));
+    const rightArray = "exprs" in right && right.exprs ? right.exprs : [right];
+
+    return { expression_type: "or", exprs: [...leftArray, ...rightArray] };
+  }
+
+  visitColumnExprTupleAccess(ctx: ColumnExprTupleAccessContext): TupleAccess {
+    const tuple = this.visitAsExpr(ctx.columnExpr());
+    const index = parseInt(ctx.DECIMAL_LITERAL().text);
+    return { expression_type: "tuple_access", tuple, index };
+  }
+
+  visitColumnExprNullTupleAccess(ctx: ColumnExprNullTupleAccessContext): TupleAccess {
+    const tuple = this.visitAsExpr(ctx.columnExpr());
+    const index = parseInt(ctx.DECIMAL_LITERAL().text);
+    return { expression_type: "tuple_access", tuple, index, nullish: true };
+  }
+
+  visitColumnExprCase(ctx: ColumnExprCaseContext): Call {
+    const columns = ctx
+      .columnExpr()
+      .map((column: ParserRuleContext) => this.visitAsExpr(column) as Expression);
+    if (ctx._caseExpr) {
+      const args: (Expression | undefined)[] = [
+        columns[0],
+        { expression_type: "array", exprs: [] },
+        { expression_type: "array", exprs: [] },
+        undefined,
+        columns[columns.length - 1],
+      ];
+      for (let index = 1; index < columns.length - 1; index++) {
+        const arrayIndex = ((index - 1) % 2) + 1;
+        (args[arrayIndex] as ArrayExpression).exprs.push(columns[index]);
+      }
+      return { expression_type: "call", name: "transform", args: args as Expression[] };
+    } else if (columns.length === 3) {
+      return { expression_type: "call", name: "if", args: columns };
+    } else {
+      return { expression_type: "call", name: "multiIf", args: columns };
+    }
+  }
+
+  visitColumnExprNot(ctx: ColumnExprNotContext): Not {
+    return { expression_type: "not", expr: this.visitAsExpr(ctx.columnExpr()) };
+  }
+
+  visitColumnExprWinFunctionTarget(ctx: ColumnExprWinFunctionTargetContext): WindowFunction {
+    return {
+      expression_type: "window_function",
+      name: this.visitIdentifier(ctx.identifier(0)),
+      exprs: ctx._columnExprs ? this.visitExprList(ctx._columnExprs) : [],
+      args: ctx._columnArgList ? this.visitExprList(ctx._columnArgList) : [],
+      over_identifier: this.visitIdentifier(ctx.identifier(1)),
+    };
+  }
+
+  visitColumnExprWinFunction(ctx: ColumnExprWinFunctionContext): WindowFunction {
+    const windowExpr = ctx.windowExpr();
+    return {
+      expression_type: "window_function",
+      name: this.visitIdentifier(ctx.identifier()),
+      exprs: ctx._columnExprs ? this.visitExprList(ctx._columnExprs) : [],
+      args: ctx._columnArgList ? this.visitExprList(ctx._columnArgList) : [],
+      over_expr: windowExpr ? this.visitWindowExpr(windowExpr) : undefined,
+    };
+  }
+
+  visitColumnExprIdentifier(ctx: ColumnExprIdentifierContext): Expr {
+    return this.visitColumnIdentifier(ctx.columnIdentifier());
+  }
+
+  visitColumnExprFunction(ctx: ColumnExprFunctionContext): Call {
+    const name = this.visitIdentifier(ctx.identifier());
+
+    let parameters: Expression[] | undefined = ctx._columnExprs
+      ? this.visitExprList(ctx._columnExprs)
+      : undefined;
+    // two sets of parameters fn()(), return an empty list for the first even if no parameters
+    if (ctx.LPAREN && ctx.LPAREN().length > 1 && parameters === undefined) {
+      parameters = [];
+    }
+
+    const args: Expression[] = ctx._columnArgList ? this.visitExprList(ctx._columnArgList) : [];
+    const distinct = ctx.DISTINCT() ? true : false;
+    return { expression_type: "call", name, params: parameters, args, distinct };
+  }
+
+  visitColumnExprAsterisk(ctx: ColumnExprAsteriskContext): Field {
+    const tableIdentifier = ctx.tableIdentifier();
+    if (tableIdentifier) {
+      const table = this.visitStringArray(tableIdentifier);
+      return { expression_type: "field", chain: [...table, "*"] };
+    }
+    return { expression_type: "field", chain: ["*"] };
+  }
+
+  visitColumnLambdaExpr(ctx: ColumnLambdaExprContext): Lambda {
+    const columnExpr = ctx.columnExpr();
+    const block = ctx.block();
+    let expr: Expression | Block;
+    if (columnExpr) {
+      expr = this.visitAsExpr(columnExpr);
+    } else if (block) {
+      expr = this.visitBlock(block) as Block;
+    } else {
+      throw new SyntaxError("Lambda expression must have either an expression or a block");
+    }
+    return {
+      expression_type: "lambda",
+      args: ctx
+        .identifier()
+        .map((identifier: IdentifierContext) => this.visitIdentifier(identifier)),
+      expr,
+    };
+  }
+
+  visitWithExprList(ctx: WithExprListContext): Record<string, CTE> {
+    const ctes: Record<string, CTE> = {};
+    for (const expr of ctx.withExpr()) {
+      const cte = this.visitCTE(expr);
+      ctes[cte.name] = cte;
+    }
+    return ctes;
+  }
+
+  /** Helper to visit a CTE expression */
+  private visitCTE(ctx: ParserRuleContext): CTE {
+    return this.visit(ctx) as CTE;
+  }
+
+  visitWithExprSubquery(ctx: WithExprSubqueryContext): CTE {
+    const subquery = this.visitSelectQuery(ctx.selectSetStmt());
+    const name = this.visitIdentifier(ctx.identifier());
+    return { expression_type: "cte", name, expr: subquery, cte_type: "subquery" };
+  }
+
+  visitWithExprColumn(ctx: WithExprColumnContext): CTE {
+    const expr = this.visitAsExpr(ctx.columnExpr());
+    const name = this.visitIdentifier(ctx.identifier());
+    return { expression_type: "cte", name, expr, cte_type: "column" };
+  }
+
+  visitColumnIdentifier(ctx: ColumnIdentifierContext): Expression {
+    const placeholder = ctx.placeholder();
+    if (placeholder) {
+      return this.visitPlaceholder(placeholder);
+    }
+
+    const tableIdentifier = ctx.tableIdentifier();
+    const table = tableIdentifier ? this.visitTableIdentifier(tableIdentifier) : [];
+
+    const nestedIdentifier = ctx.nestedIdentifier();
+    const nested = nestedIdentifier ? this.visitNestedIdentifier(nestedIdentifier) : [];
+
+    if (table.length === 0 && nested.length > 0) {
+      const text = ctx.text.toLowerCase();
+      if (text === "true") {
+        return { expression_type: "constant", value: true };
+      }
+      if (text === "false") {
+        return { expression_type: "constant", value: false };
+      }
+      return { expression_type: "field", chain: nested };
+    }
+
+    return { expression_type: "field", chain: [...table, ...nested] };
+  }
+
+  visitNestedIdentifier(ctx: NestedIdentifierContext): string[] {
+    return ctx
+      .identifier()
+      .map((identifier: IdentifierContext) => this.visitIdentifier(identifier));
+  }
+
+  visitTableExprIdentifier(ctx: TableExprIdentifierContext): Field {
+    const chain = this.visitTableIdentifier(ctx.tableIdentifier());
+    return { expression_type: "field", chain };
+  }
+
+  visitTableExprSubquery(ctx: TableExprSubqueryContext): SelectQuery | SelectSetQuery {
+    return this.visitSelectQuery(ctx.selectSetStmt());
+  }
+
+  visitTableExprPlaceholder(ctx: TableExprPlaceholderContext): Placeholder {
+    return this.visitPlaceholder(ctx.placeholder());
+  }
+
+  visitTableExprAlias(ctx: TableExprAliasContext): JoinExpr {
+    const exp = ctx.alias() || ctx.identifier();
+    if (!exp) {
+      throw new SyntaxError("Must specify an alias");
+    }
+    const alias: string =
+      exp instanceof AliasContext
+        ? this.visitAlias(exp)
+        : this.visitIdentifier(exp as IdentifierContext);
+    if (RESERVED_KEYWORDS.includes(alias.toLowerCase() as any)) {
+      throw new SyntaxError(
+        `"${alias}" cannot be an alias or identifier, as it's a reserved keyword`
+      );
+    }
+    const tableResult = this.visitTableExprResult(ctx.tableExpr());
+    // Check if result is already a JoinExpr
+    if ("expression_type" in tableResult && tableResult.expression_type === "join_expr") {
+      tableResult.alias = alias;
+      return tableResult;
+    }
+    // Otherwise, wrap in a JoinExpr
+    const table = tableResult as SelectQuery | SelectSetQuery | Placeholder | TSQLXTag | Field;
+    return { expression_type: "join_expr", table, alias };
+  }
+
+  visitTableExprFunction(ctx: TableExprFunctionContext): JoinExpr {
+    return this.visitTableFunctionExpr(ctx.tableFunctionExpr());
+  }
+
+  visitTableExprTag(ctx: TableExprTagContext): TSQLXTag {
+    return this.visitTsqlxTagElementNested(ctx.tSQLxTagElement());
+  }
+
+  visitTableFunctionExpr(ctx: TableFunctionExprContext): JoinExpr {
+    const name = this.visitIdentifier(ctx.identifier());
+    const tableArgList = ctx.tableArgList();
+    const args = tableArgList ? this.visitTableArgList(tableArgList) : [];
+    return {
+      expression_type: "join_expr",
+      table: { expression_type: "field", chain: [name] },
+      table_args: args,
+    };
+  }
+
+  visitTableIdentifier(ctx: TableIdentifierContext): string[] {
+    const nestedIdentifier = ctx.nestedIdentifier();
+    const nested = nestedIdentifier ? this.visitNestedIdentifier(nestedIdentifier) : [];
+    // Ensure nested is always an array
+    const nestedArray = Array.isArray(nested) ? nested : nested ? [nested] : [];
+
+    const databaseIdentifier = ctx.databaseIdentifier();
+    if (databaseIdentifier) {
+      const dbId = this.visitDatabaseIdentifier(databaseIdentifier);
+      return [dbId, ...nestedArray];
+    }
+
+    return nestedArray;
+  }
+
+  visitTableArgList(ctx: TableArgListContext): Expression[] {
+    return ctx.columnExpr().map((arg: ParserRuleContext) => this.visitAsExpr(arg));
+  }
+
+  visitDatabaseIdentifier(ctx: DatabaseIdentifierContext): string {
+    return this.visitIdentifier(ctx.identifier());
+  }
+
+  visitNumberLiteral(ctx: NumberLiteralContext): Constant {
+    const text = ctx.text.toLowerCase();
+    if (
+      text.includes(".") ||
+      text.includes("e") ||
+      text === "-inf" ||
+      text === "inf" ||
+      text === "nan"
+    ) {
+      return { expression_type: "constant", value: parseFloat(text) };
+    }
+    return { expression_type: "constant", value: parseInt(text) };
+  }
+
+  visitLiteral(ctx: LiteralContext): Constant {
+    if (ctx.NULL_SQL()) {
+      return { expression_type: "constant", value: null };
+    }
+
+    const stringLiteral = ctx.STRING_LITERAL();
+    if (stringLiteral) {
+      // STRING_LITERAL() returns a TerminalNode, which has getText()
+      const text = parseStringLiteralText(stringLiteral.text);
+      return { expression_type: "constant", value: text };
+    }
+
+    const numberLiteral = ctx.numberLiteral();
+    if (numberLiteral) {
+      return this.visitNumberLiteral(numberLiteral);
+    }
+    return this.visitChildren(ctx);
+  }
+
+  visitAlias(ctx: AliasContext): string {
+    let text = ctx.text;
+    if (
+      text.length >= 2 &&
+      ((text.startsWith("`") && text.endsWith("`")) || (text.startsWith('"') && text.endsWith('"')))
+    ) {
+      text = parseStringLiteralText(text);
+    }
+    return text;
+  }
+
+  visitIdentifier(ctx: IdentifierContext): string {
+    // IdentifierContext is a ParserRuleContext that has IDENTIFIER() method returning TerminalNode
+    // If ctx has IDENTIFIER() method, extract the terminal node
+    if (ctx.IDENTIFIER && typeof ctx.IDENTIFIER === "function") {
+      const terminalNode = ctx.IDENTIFIER();
+      if (terminalNode) {
+        // TerminalNode has getText() at runtime but types don't expose it
+        // Use symbol.text as fallback
+        let text = (terminalNode as any).getText?.() || terminalNode.symbol?.text || "";
+        if (
+          text.length >= 2 &&
+          ((text.startsWith("`") && text.endsWith("`")) ||
+            (text.startsWith('"') && text.endsWith('"')))
+        ) {
+          text = parseStringLiteralText(text);
+        }
+        return text;
+      }
+    }
+
+    // If it's already a string
+    if (typeof ctx === "string") {
+      return ctx;
+    }
+    // Fallback: if it's a ParserRuleContext, use getText()
+    let text = ctx.text;
+    if (
+      text.length >= 2 &&
+      ((text.startsWith("`") && text.endsWith("`")) || (text.startsWith('"') && text.endsWith('"')))
+    ) {
+      text = parseStringLiteralText(text);
+    }
+    return text;
+  }
+
+  visitColumnExprNullish(ctx: ColumnExprNullishContext): Call {
+    return {
+      expression_type: "call",
+      name: "ifNull",
+      args: [this.visitAsExpr(ctx.columnExpr(0)), this.visitAsExpr(ctx.columnExpr(1))],
+    };
+  }
+
+  visitColumnExprCall(ctx: ColumnExprCallContext): ExprCall {
+    const columnExprList = ctx.columnExprList();
+    return {
+      expression_type: "expr_call",
+      expr: this.visitAsExpr(ctx.columnExpr()),
+      args: columnExprList ? this.visitExprList(columnExprList) : [],
+    };
+  }
+
+  visitColumnExprCallSelect(ctx: ColumnExprCallSelectContext): Call | ExprCall {
+    const expr = this.visitAsExpr(ctx.columnExpr());
+    if ("chain" in expr && expr.chain && expr.chain.length === 1) {
+      return {
+        expression_type: "call",
+        name: String(expr.chain[0]),
+        args: [this.visitSelectQuery(ctx.selectSetStmt())],
+      };
+    }
+    return {
+      expression_type: "expr_call",
+      expr,
+      args: [this.visitSelectQuery(ctx.selectSetStmt())],
+    };
+  }
+
+  visitTsqlxChildElement(ctx: TSQLxChildElementContext): Expression {
+    const tSQLxTagElement = ctx.tSQLxTagElement();
+    if (tSQLxTagElement) {
+      return this.visitTsqlxTagElementNested(tSQLxTagElement);
+    }
+    if (ctx.TSQLX_TEXT_TEXT()) {
+      return this.visitTsqlxText(ctx);
+    }
+    return this.visitAsExpr(ctx.columnExpr()!);
+  }
+
+  visitTsqlxText(ctx: TSQLxChildElementContext): Constant {
+    const text = ctx.TSQLX_TEXT_TEXT();
+    return { expression_type: "constant", value: text ? text.text : "" };
+  }
+
+  visitTsqlxTagElementClosed(ctx: TSQLxTagElementContext): TSQLXTag {
+    const kind = this.visitIdentifier(ctx.identifier()[0]);
+    const attributes = ctx.tSQLxTagAttribute()
+      ? ctx
+          .tSQLxTagAttribute()
+          .map((a: TSQLxTagAttributeContext) => this.visitTsqlxTagAttribute(a))
+      : [];
+    return { expression_type: "tsqlx_tag", kind, attributes };
+  }
+
+  visitTsqlxTagElementNested(ctx: TSQLxTagElementContext): TSQLXTag {
+    const opening = this.visitIdentifier(ctx.identifier(0));
+    const closing = this.visitIdentifier(ctx.identifier(1));
+    if (opening !== closing) {
+      throw new SyntaxError(
+        `Opening and closing TSQLX tags must match. Got ${opening} and ${closing}`
+      );
+    }
+
+    const attributes = ctx.tSQLxTagAttribute()
+      ? ctx
+          .tSQLxTagAttribute()
+          .map((a: TSQLxTagAttributeContext) => this.visitTsqlxTagAttribute(a))
+      : [];
+
+    // ── collect child nodes, discarding pure-indentation whitespace ──
+    const keptChildren: Expression[] = [];
+    for (const element of ctx.tSQLxChildElement()) {
+      const child = this.visitTsqlxChildElement(element);
+
+      if ("value" in child && typeof child.value === "string") {
+        const v = child.value;
+        const onlyWs = /^\s*$/.test(v);
+        const hasNl = v.includes("\n") || v.includes("\r");
+        if (onlyWs && hasNl) {
+          continue; // drop indentation text node
+        }
+      }
+
+      keptChildren.push(child);
+    }
+
+    if (keptChildren.length > 0) {
+      if (attributes.some((a: TSQLXAttribute) => a.name === "children")) {
+        throw new SyntaxError(
+          "Can't have a TSQLX tag with both children and a 'children' attribute"
+        );
+      }
+      attributes.push({ name: "children", value: keptChildren });
+    }
+
+    return { expression_type: "tsqlx_tag", kind: opening, attributes };
+  }
+
+  visitTsqlxTagAttribute(ctx: TSQLxTagAttributeContext): TSQLXAttribute {
+    const name = this.visitIdentifier(ctx.identifier());
+    const columnExpr = ctx.columnExpr();
+    const string = ctx.string();
+    if (columnExpr) {
+      return { name, value: this.visitAsExpr(columnExpr) };
+    } else if (string) {
+      return { name, value: this.visitStringExpr(string) };
+    } else {
+      return { name, value: { expression_type: "constant", value: true } as Constant };
+    }
+  }
+
+  visitPlaceholder(ctx: PlaceholderContext): Placeholder {
+    return { expression_type: "placeholder", expr: this.visitAsExpr(ctx.columnExpr()) };
+  }
+
+  visitColumnExprTemplateString(ctx: ColumnExprTemplateStringContext): Expr {
+    return this.visitTemplateString(ctx.templateString());
+  }
+
+  /** Helper to visit a string context that returns Constant | Expr */
+  private visitStringExpr(ctx: StringContext): Constant | Expr {
+    return this.visitStringLiteral(ctx);
+  }
+
+  visitStringLiteral(ctx: StringContext): Constant | Expr {
+    const stringLiteral = ctx.STRING_LITERAL();
+    if (stringLiteral) {
+      return { expression_type: "constant", value: parseStringLiteralText(stringLiteral.text) };
+    }
+    const templateString = ctx.templateString();
+    if (templateString) {
+      return this.visitTemplateString(templateString);
+    }
+    return { expression_type: "constant", value: "" };
+  }
+
+  visitTemplateString(ctx: TemplateStringContext): Constant | Call {
+    const pieces: Expression[] = [];
+    for (const chunk of ctx.stringContents()) {
+      pieces.push(this.visitStringContents(chunk));
+    }
+
+    if (pieces.length === 0) {
+      return { expression_type: "constant", value: "" };
+    } else if (pieces.length === 1) {
+      const first = pieces[0];
+      // If it's already a Constant or Call, return as-is, otherwise wrap in Call
+      if ("value" in first || "name" in first) {
+        return first as Constant | Call;
+      }
+      return { expression_type: "call", name: "concat", args: [first] };
+    }
+
+    return { expression_type: "call", name: "concat", args: pieces };
+  }
+
+  visitFullTemplateString(ctx: FullTemplateStringContext): Constant | Call {
+    const pieces: Expression[] = [];
+    for (const chunk of ctx.stringContentsFull()) {
+      pieces.push(this.visitStringContentsFull(chunk));
+    }
+
+    if (pieces.length === 0) {
+      return { expression_type: "constant", value: "" };
+    } else if (pieces.length === 1) {
+      const first = pieces[0];
+      // If it's already a Constant or Call, return as-is, otherwise wrap in Call
+      if ("value" in first || "name" in first) {
+        return first as Constant | Call;
+      }
+      return { expression_type: "call", name: "concat", args: [first] };
+    }
+
+    return { expression_type: "call", name: "concat", args: pieces };
+  }
+
+  visitStringContents(ctx: StringContentsContext): Constant | Expression {
+    const stringText = ctx.STRING_TEXT();
+    const columnExpr = ctx.columnExpr();
+    if (stringText) {
+      return { expression_type: "constant", value: parseStringLiteralText(stringText.text) };
+    } else if (columnExpr) {
+      return this.visitAsExpr(columnExpr);
+    }
+    return { expression_type: "constant", value: "" };
+  }
+
+  visitStringContentsFull(ctx: StringContentsFullContext): Constant | Expression {
+    const fullStringText = ctx.FULL_STRING_TEXT();
+    const columnExpr = ctx.columnExpr();
+    if (fullStringText) {
+      return {
+        expression_type: "constant",
+        value: parseStringLiteralText(fullStringText.text),
+      };
+    } else if (columnExpr) {
+      return this.visitAsExpr(columnExpr);
+    }
+    return { expression_type: "constant", value: "" };
+  }
+}
diff --git a/internal-packages/tsql/src/query/printer.test.ts b/internal-packages/tsql/src/query/printer.test.ts
new file mode 100644
index 00000000000..88ce7330354
--- /dev/null
+++ b/internal-packages/tsql/src/query/printer.test.ts
@@ -0,0 +1,3867 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { parseTSQLSelect, parseTSQLExpr, compileTSQL } from "../index.js";
+import { ClickHousePrinter, printToClickHouse, type PrintResult } from "./printer.js";
+import { createPrinterContext, PrinterContext } from "./printer_context.js";
+import {
+  createSchemaRegistry,
+  column,
+  type TableSchema,
+  type SchemaRegistry,
+} from "./schema.js";
+import type { BucketThreshold } from "./time_buckets.js";
+import { QueryError, SyntaxError } from "./errors.js";
+
+/**
+ * Test table schemas
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    status: { name: "status", ...column("String") },
+    task_identifier: { name: "task_identifier", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime64") },
+    updated_at: { name: "updated_at", ...column("DateTime64") },
+    started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+    completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+    duration_ms: { name: "duration_ms", ...column("Nullable(UInt64)") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+    queue_name: { name: "queue_name", ...column("String") },
+    is_test: { name: "is_test", ...column("UInt8") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+const taskEventsSchema: TableSchema = {
+  name: "task_events",
+  clickhouseName: "trigger_dev.task_events_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    run_id: { name: "run_id", ...column("String") },
+    event_type: { name: "event_type", ...column("String") },
+    timestamp: { name: "timestamp", ...column("DateTime64") },
+    payload: { name: "payload", ...column("String") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+/**
+ * Schema with user-friendly names that map to internal ClickHouse names
+ */
+const runsSchema: TableSchema = {
+  name: "runs", // User writes: FROM runs
+  clickhouseName: "trigger_dev.task_runs_v2", // ClickHouse sees this
+  columns: {
+    id: { name: "id", clickhouseName: "run_id", ...column("String") },
+    friendly_id: { name: "friendly_id", ...column("String") }, // No mapping
+    created: { name: "created", clickhouseName: "created_at", ...column("DateTime64") },
+    updated: { name: "updated", clickhouseName: "updated_at", ...column("DateTime64") },
+    status: { name: "status", ...column("String") },
+    task: { name: "task", clickhouseName: "task_identifier", ...column("String") },
+    org_id: { name: "org_id", clickhouseName: "organization_id", ...column("String") },
+    proj_id: { name: "proj_id", clickhouseName: "project_id", ...column("String") },
+    env_id: { name: "env_id", clickhouseName: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+/**
+ * Helper to create a test context
+ */
+function createTestContext(
+  overrides: Partial<Parameters<typeof createPrinterContext>[0]> = {}
+): PrinterContext {
+  const schema = createSchemaRegistry([taskRunsSchema, taskEventsSchema]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test123" },
+      project_id: { op: "eq", value: "proj_test456" },
+      environment_id: { op: "eq", value: "env_test789" },
+    },
+    ...overrides,
+  });
+}
+
+/**
+ * Helper to print a query and get SQL + params
+ */
+function printQuery(query: string, context?: PrinterContext) {
+  const ast = parseTSQLSelect(query);
+  const ctx = context ?? createTestContext();
+  return printToClickHouse(ast, ctx);
+}
+
+describe("ClickHousePrinter", () => {
+  describe("Basic SELECT statements", () => {
+    it("should expand SELECT * to individual columns", () => {
+      const { sql, params, columns } = printQuery("SELECT * FROM task_runs");
+
+      // SELECT * should be expanded to individual columns
+      expect(sql).toContain("SELECT ");
+      expect(sql).not.toContain("SELECT *"); // Should NOT contain literal *
+      expect(sql).toContain("FROM trigger_dev.task_runs_v2");
+
+      // Should include all columns from the schema
+      expect(sql).toContain("id");
+      expect(sql).toContain("status");
+      expect(sql).toContain("task_identifier");
+      expect(sql).toContain("created_at");
+      expect(sql).toContain("is_test");
+
+      // Should include tenant guards in WHERE
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+
+      // Should return column metadata for all expanded columns
+      expect(columns.length).toBeGreaterThan(0);
+      expect(columns.some((c) => c.name === "id")).toBe(true);
+      expect(columns.some((c) => c.name === "status")).toBe(true);
+    });
+
+    it("should print SELECT with specific columns", () => {
+      const { sql, params } = printQuery("SELECT id, status, created_at FROM task_runs");
+
+      expect(sql).toContain("SELECT id, status, created_at");
+      expect(sql).toContain("FROM trigger_dev.task_runs_v2");
+    });
+
+    it("should print SELECT DISTINCT", () => {
+      const { sql } = printQuery("SELECT DISTINCT status FROM task_runs");
+
+      expect(sql).toContain("SELECT DISTINCT status");
+    });
+
+    it("should print SELECT with aliases", () => {
+      const { sql } = printQuery("SELECT id AS run_id, status AS run_status FROM task_runs");
+
+      expect(sql).toContain("id AS run_id");
+      expect(sql).toContain("status AS run_status");
+    });
+
+    it("should expand SELECT * with column name mapping", () => {
+      const schema = createSchemaRegistry([runsSchema]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test" },
+          project_id: { op: "eq", value: "proj_test" },
+          environment_id: { op: "eq", value: "env_test" },
+        },
+      });
+
+      const { sql, columns } = printQuery("SELECT * FROM runs", ctx);
+
+      // Should expand to all columns from runsSchema with proper aliases
+      expect(sql).not.toContain("SELECT *");
+      // Should have AS clauses for columns with different clickhouseName
+      expect(sql).toContain("run_id AS id"); // id -> run_id with alias back to id
+      expect(sql).toContain("created_at AS created"); // created -> created_at with alias back
+      expect(sql).toContain("status"); // status stays as-is
+
+      // Should return column metadata with user-facing names
+      expect(columns.length).toBeGreaterThan(0);
+      expect(columns.some((c) => c.name === "id")).toBe(true);
+      expect(columns.some((c) => c.name === "created")).toBe(true);
+      expect(columns.some((c) => c.name === "status")).toBe(true);
+    });
+
+    it("should expand table.* for specific table", () => {
+      const { sql, columns } = printQuery("SELECT task_runs.* FROM task_runs");
+
+      // Should expand to all columns from task_runs
+      expect(sql).not.toContain("task_runs.*");
+      expect(sql).toContain("id");
+      expect(sql).toContain("status");
+
+      // Should return column metadata
+      expect(columns.length).toBeGreaterThan(0);
+    });
+
+    it("should include virtual columns in SELECT * expansion", () => {
+      // Schema with virtual columns
+      const schemaWithVirtual: TableSchema = {
+        name: "runs",
+        clickhouseName: "trigger_dev.task_runs_v2",
+        columns: {
+          id: { name: "id", ...column("String") },
+          started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+          completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+          // Virtual column with expression
+          duration: {
+            name: "duration",
+            ...column("Nullable(Int64)"),
+            expression: "dateDiff('millisecond', started_at, completed_at)",
+            description: "Execution duration in ms",
+          },
+          org_id: { name: "org_id", clickhouseName: "organization_id", ...column("String") },
+          proj_id: { name: "proj_id", clickhouseName: "project_id", ...column("String") },
+          env_id: { name: "env_id", clickhouseName: "environment_id", ...column("String") },
+        },
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+      };
+
+      const schema = createSchemaRegistry([schemaWithVirtual]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test" },
+          project_id: { op: "eq", value: "proj_test" },
+          environment_id: { op: "eq", value: "env_test" },
+        },
+      });
+
+      const { sql, columns } = printQuery("SELECT * FROM runs", ctx);
+
+      // Should include virtual column with its expression
+      expect(sql).toContain("dateDiff('millisecond', started_at, completed_at)");
+      expect(sql).toContain("AS duration");
+
+      // Should include regular columns
+      expect(sql).toContain("id");
+
+      // Metadata should include the virtual column
+      expect(columns.some((c) => c.name === "duration")).toBe(true);
+      const durationCol = columns.find((c) => c.name === "duration");
+      expect(durationCol?.description).toBe("Execution duration in ms");
+    });
+  });
+
+  describe("Table and column name mapping", () => {
+    function createMappedContext() {
+      const schema = createSchemaRegistry([runsSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  it("should map user-friendly table name to ClickHouse name", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT * FROM runs", ctx);
+
+      // Table name should be mapped
+      expect(sql).toContain("FROM trigger_dev.task_runs_v2");
+      expect(sql).not.toContain("FROM runs");
+    });
+
+    it("should map user-friendly column names to ClickHouse names", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT id, created, status FROM runs", ctx);
+
+      // id -> run_id, created -> created_at, status stays as status
+      expect(sql).toContain("run_id");
+      expect(sql).toContain("created_at");
+      expect(sql).toContain("status");
+    });
+
+    it("should map column names in WHERE clause", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE task = 'my-task'", ctx);
+
+      // task -> task_identifier
+      expect(sql).toContain("task_identifier");
+      expect(sql).not.toMatch(/\btask\b.*=/); // task should not appear as column
+    });
+
+    it("should map column names in ORDER BY", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT * FROM runs ORDER BY created DESC", ctx);
+
+      // created -> created_at
+      expect(sql).toContain("ORDER BY created_at DESC");
+    });
+
+    it("should map column names in GROUP BY", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT task, count(*) FROM runs GROUP BY task", ctx);
+
+      // task -> task_identifier in both SELECT and GROUP BY
+      expect(sql).toContain("task_identifier");
+      expect(sql).toContain("GROUP BY task_identifier");
+    });
+
+    it("should preserve unmapped column names", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT friendly_id, status FROM runs", ctx);
+
+      // friendly_id has no clickhouseName, should stay as-is
+      expect(sql).toContain("friendly_id");
+      expect(sql).toContain("status");
+    });
+
+    it("should handle qualified column references (table.column)", () => {
+      const ctx = createMappedContext();
+      const { sql } = printQuery("SELECT runs.id, runs.created FROM runs", ctx);
+
+      // Should still map the column names
+      expect(sql).toContain("run_id");
+      expect(sql).toContain("created_at");
+    });
+
+    it("should add AS alias for columns with different clickhouseName to preserve user-facing name in results", () => {
+      const ctx = createMappedContext();
+      const { sql, columns } = printQuery("SELECT id, created, status FROM runs", ctx);
+
+      // Columns with clickhouseName should be aliased back to user-facing name
+      // id -> run_id AS id, created -> created_at AS created
+      expect(sql).toContain("run_id AS id");
+      expect(sql).toContain("created_at AS created");
+      // status has no clickhouseName mapping, should not have alias
+      expect(sql).not.toContain("status AS");
+
+      // Column metadata should use user-facing names
+      expect(columns.map((c) => c.name)).toEqual(["id", "created", "status"]);
+    });
+
+    it("should add AS alias for qualified column references with different clickhouseName", () => {
+      const ctx = createMappedContext();
+      const { sql, columns } = printQuery("SELECT runs.id, runs.task FROM runs", ctx);
+
+      // Should add aliases to preserve user-facing names
+      expect(sql).toContain("run_id AS id");
+      expect(sql).toContain("task_identifier AS task");
+
+      // Column metadata should use user-facing names
+      expect(columns.map((c) => c.name)).toEqual(["id", "task"]);
+    });
+
+    it("should not add redundant alias when user provides explicit AS", () => {
+      const ctx = createMappedContext();
+      const { sql, columns } = printQuery("SELECT id AS my_id FROM runs", ctx);
+
+      // Should use the clickhouse name with user's explicit alias
+      expect(sql).toContain("run_id AS my_id");
+      // Should NOT have double aliasing
+      expect(sql).not.toContain("run_id AS id AS my_id");
+
+      // Column metadata should use the explicit alias
+      expect(columns.map((c) => c.name)).toEqual(["my_id"]);
+    });
+  });
+
+  describe("WHERE clauses", () => {
+    it("should print WHERE with equality comparison", () => {
+      const { sql, params } = printQuery("SELECT * FROM task_runs WHERE status = 'completed'");
+
+      expect(sql).toContain("WHERE");
+      expect(sql).toContain("equals(");
+      // Value should be parameterized
+      expect(Object.values(params)).toContain("completed");
+    });
+
+    it("should print WHERE with multiple conditions", () => {
+      const { sql } = printQuery(
+        "SELECT * FROM task_runs WHERE status = 'completed' AND is_test = 0"
+      );
+
+      expect(sql).toContain("and(");
+      expect(sql).toContain("equals(");
+    });
+
+    it("should print WHERE with OR conditions", () => {
+      const { sql } = printQuery(
+        "SELECT * FROM task_runs WHERE status = 'completed' OR status = 'failed'"
+      );
+
+      expect(sql).toContain("or(");
+    });
+
+    it("should print WHERE with NOT", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE NOT status = 'pending'");
+
+      expect(sql).toContain("not(");
+    });
+
+    it("should print WHERE with BETWEEN", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE duration_ms BETWEEN 100 AND 1000");
+
+      expect(sql).toContain("BETWEEN");
+    });
+
+    it("should print WHERE with IN", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE status IN ('completed', 'failed')");
+
+      expect(sql).toContain("in(");
+    });
+
+    it("should print WHERE with NOT IN", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE status NOT IN ('pending')");
+
+      expect(sql).toContain("notIn(");
+    });
+
+    it("should print WHERE with LIKE", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE task_identifier LIKE 'email%'");
+
+      expect(sql).toContain("like(");
+    });
+
+    it("should print WHERE with ILIKE", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE task_identifier ILIKE '%Email%'");
+
+      expect(sql).toContain("ilike(");
+    });
+
+    it("should handle NULL comparisons", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE started_at = NULL");
+
+      expect(sql).toContain("isNull(");
+    });
+
+    it("should handle != NULL comparisons", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE started_at != NULL");
+
+      expect(sql).toContain("isNotNull(");
+    });
+
+    it("should handle IS NULL syntax", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE started_at IS NULL");
+
+      expect(sql).toContain("isNull(started_at)");
+    });
+
+    it("should handle IS NOT NULL syntax", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE started_at IS NOT NULL");
+
+      expect(sql).toContain("isNotNull(started_at)");
+    });
+  });
+
+  describe("nullValue transformation for JSON columns", () => {
+    // Create a schema with JSON columns that have nullValue set
+    const jsonSchema: TableSchema = {
+      name: "runs",
+      clickhouseName: "trigger_dev.task_runs_v2",
+      columns: {
+        id: { name: "id", ...column("String") },
+        error: {
+          name: "error",
+          ...column("JSON"),
+          nullValue: "'{}'", // Empty object represents NULL
+        },
+        output: {
+          name: "output",
+          ...column("JSON"),
+          nullValue: "'{}'", // Empty object represents NULL
+        },
+        status: { name: "status", ...column("String") },
+        organization_id: { name: "organization_id", ...column("String") },
+        project_id: { name: "project_id", ...column("String") },
+        environment_id: { name: "environment_id", ...column("String") },
+      },
+      tenantColumns: {
+        organizationId: "organization_id",
+        projectId: "project_id",
+        environmentId: "environment_id",
+      },
+    };
+
+    function createJsonContext() {
+      const schema = createSchemaRegistry([jsonSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  it("should transform IS NULL to equals empty object for JSON columns with nullValue", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE error IS NULL", ctx);
+
+      // Should use equals with '{}' instead of isNull
+      expect(sql).toContain("equals(error, '{}')");
+      expect(sql).not.toContain("isNull(error)");
+    });
+
+    it("should transform IS NOT NULL to notEquals empty object for JSON columns with nullValue", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE error IS NOT NULL", ctx);
+
+      // Should use notEquals with '{}' instead of isNotNull
+      expect(sql).toContain("notEquals(error, '{}')");
+      expect(sql).not.toContain("isNotNull(error)");
+    });
+
+    it("should transform = NULL to equals empty object for JSON columns with nullValue", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE error = NULL", ctx);
+
+      expect(sql).toContain("equals(error, '{}')");
+      expect(sql).not.toContain("isNull(error)");
+    });
+
+    it("should transform != NULL to notEquals empty object for JSON columns with nullValue", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE error != NULL", ctx);
+
+      expect(sql).toContain("notEquals(error, '{}')");
+      expect(sql).not.toContain("isNotNull(error)");
+    });
+
+    it("should not affect regular columns without nullValue", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE status IS NULL", ctx);
+
+      // Regular column should still use isNull
+      expect(sql).toContain("isNull(status)");
+    });
+
+    it("should work with multiple JSON column NULL checks", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT * FROM runs WHERE error IS NOT NULL AND output IS NULL",
+        ctx
+      );
+
+      expect(sql).toContain("notEquals(error, '{}')");
+      expect(sql).toContain("equals(output, '{}')");
+    });
+
+    it("should allow GROUP BY on JSON columns without error", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT error, count() AS error_count FROM runs WHERE error IS NOT NULL GROUP BY error",
+        ctx
+      );
+
+      // Should filter with notEquals
+      expect(sql).toContain("notEquals(error, '{}')");
+      // Should group by the raw column
+      expect(sql).toContain("GROUP BY error");
+    });
+
+    it("should cast JSON subfield to String with underscore alias in SELECT and GROUP BY", () => {
+      const ctx = createJsonContext();
+      const { sql, columns } = printQuery(
+        "SELECT error.data.name, count() AS error_count FROM runs GROUP BY error.data.name",
+        ctx
+      );
+
+      // SELECT should use .:String type hint with underscore alias
+      expect(sql).toContain("error.data.name.:String AS error_data_name");
+      // GROUP BY should use .:String type hint (no alias needed)
+      expect(sql).toContain("GROUP BY error.data.name.:String");
+
+      // Column metadata should have the underscore alias name
+      expect(columns).toContainEqual(
+        expect.objectContaining({ name: "error_data_name", type: "String" })
+      );
+      expect(columns).toContainEqual(
+        expect.objectContaining({ name: "error_count", type: "UInt64" })
+      );
+    });
+
+    it("should cast JSON subfield to String with multiple fields and underscore aliases", () => {
+      const ctx = createJsonContext();
+      const { sql, columns } = printQuery(
+        "SELECT error.name, error.message, count() AS cnt FROM runs GROUP BY error.name, error.message",
+        ctx
+      );
+
+      // SELECT should have type hints with underscore aliases
+      expect(sql).toContain("error.name.:String AS error_name");
+      expect(sql).toContain("error.message.:String AS error_message");
+      // GROUP BY should have type hints
+      expect(sql).toContain("GROUP BY error.name.:String, error.message.:String");
+
+      // Column metadata should have correct names
+      expect(columns).toContainEqual(
+        expect.objectContaining({ name: "error_name", type: "String" })
+      );
+      expect(columns).toContainEqual(
+        expect.objectContaining({ name: "error_message", type: "String" })
+      );
+    });
+
+    it("should not cast non-JSON columns in GROUP BY", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery("SELECT status, count() AS cnt FROM runs GROUP BY status", ctx);
+
+      // Regular columns should not have type hints
+      expect(sql).toContain("GROUP BY status");
+      expect(sql).not.toContain(".:String");
+    });
+
+    it("should NOT add .:String type hint for JSON subfield in WHERE comparison", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT id FROM runs WHERE error.data.name = 'test'",
+        ctx
+      );
+
+      // WHERE clause should NOT have .:String type hint (it breaks the query)
+      expect(sql).toContain("equals(error.data.name,");
+      expect(sql).not.toContain("error.data.name.:String");
+    });
+
+    it("should NOT add .:String for JSON subfield in WHERE with LIKE", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT id FROM runs WHERE error.message LIKE '%error%'",
+        ctx
+      );
+
+      // WHERE clause should NOT have .:String type hint
+      expect(sql).toContain("like(error.message,");
+      expect(sql).not.toContain("error.message.:String");
+    });
+
+    it("should NOT add .:String in SELECT or WHERE when no GROUP BY", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT error.data.name FROM runs WHERE error.data.name = 'test'",
+        ctx
+      );
+
+      // SELECT should NOT have .:String (no GROUP BY, so no need for type hint)
+      expect(sql).toContain("error.data.name AS error_data_name");
+      expect(sql).not.toContain(".:String");
+      // WHERE should NOT have .:String
+      expect(sql).toContain("equals(error.data.name,");
+    });
+
+    it("should add .:String in GROUP BY but not in WHERE for same query", () => {
+      const ctx = createJsonContext();
+      const { sql } = printQuery(
+        "SELECT error.data.name, count() AS cnt FROM runs WHERE error.data.name = 'test' GROUP BY error.data.name",
+        ctx
+      );
+
+      // SELECT should have .:String
+      expect(sql).toContain("error.data.name.:String AS error_data_name");
+      // GROUP BY should have .:String
+      expect(sql).toContain("GROUP BY error.data.name.:String");
+      // WHERE should NOT have .:String
+      expect(sql).toContain("equals(error.data.name,");
+      expect(sql).not.toMatch(/equals\(error\.data\.name\.:String/);
+    });
+  });
+
+  describe("textColumn optimization for JSON columns", () => {
+    // Create a schema with JSON columns that have textColumn set
+    const textColumnSchema: TableSchema = {
+      name: "runs",
+      clickhouseName: "trigger_dev.task_runs_v2",
+      columns: {
+        id: { name: "id", ...column("String") },
+        output: {
+          name: "output",
+          ...column("JSON"),
+          nullValue: "'{}'",
+          textColumn: "output_text",
+        },
+        error: {
+          name: "error",
+          ...column("JSON"),
+          nullValue: "'{}'",
+          textColumn: "error_text",
+        },
+        status: { name: "status", ...column("String") },
+        organization_id: { name: "organization_id", ...column("String") },
+        project_id: { name: "project_id", ...column("String") },
+        environment_id: { name: "environment_id", ...column("String") },
+      },
+      tenantColumns: {
+        organizationId: "organization_id",
+        projectId: "project_id",
+        environmentId: "environment_id",
+      },
+    };
+
+    function createTextColumnContext() {
+      const schema = createSchemaRegistry([textColumnSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  describe("SELECT clause", () => {
+    it("should use text column when selecting bare JSON column", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT output FROM runs", ctx);
+
+        // Should use the text column with an alias to preserve the column name
+        expect(sql).toContain("output_text AS output");
+      });
+
+      it("should use text column for multiple JSON columns", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT output, error FROM runs", ctx);
+
+        expect(sql).toContain("output_text AS output");
+        expect(sql).toContain("error_text AS error");
+      });
+
+      it("should use JSON column for subfield access without .:String when no GROUP BY", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT output.data.name FROM runs", ctx);
+
+        // Should use the original JSON column without .:String (no GROUP BY)
+        expect(sql).toContain("output.data.name AS output_data_name");
+        expect(sql).not.toContain("output_text");
+        expect(sql).not.toContain(".:String");
+      });
+    });
+
+    describe("SELECT * expansion", () => {
+      it("should use text columns when expanding SELECT *", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT * FROM runs", ctx);
+
+        // Should use text columns for JSON columns
+        expect(sql).toContain("output_text AS output");
+        expect(sql).toContain("error_text AS error");
+      });
+    });
+
+    describe("WHERE clause", () => {
+      it("should use text column for exact equality comparison", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE output = '{}'", ctx);
+
+        expect(sql).toContain("equals(output_text,");
+        expect(sql).not.toMatch(/equals\(output,/);
+      });
+
+      it("should use text column for inequality comparison", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE output != '{}'", ctx);
+
+        expect(sql).toContain("notEquals(output_text,");
+      });
+
+      it("should use text column for LIKE comparison", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE output LIKE '%error%'", ctx);
+
+        expect(sql).toContain("like(output_text,");
+        expect(sql).not.toMatch(/like\(output,/);
+      });
+
+      it("should use text column for ILIKE comparison", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE error ILIKE '%failed%'", ctx);
+
+        expect(sql).toContain("ilike(error_text,");
+      });
+
+      it("should use text column for NOT LIKE comparison", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE output NOT LIKE '%test%'", ctx);
+
+        expect(sql).toContain("notLike(output_text,");
+      });
+
+      it("should use JSON column for subfield comparison without .:String", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery(
+          "SELECT id FROM runs WHERE output.data.name = 'test'",
+          ctx
+        );
+
+        // Should use the original JSON column, not the text column
+        // And should NOT have .:String in WHERE (breaks the query)
+        expect(sql).toContain("equals(output.data.name,");
+        expect(sql).not.toContain("output_text");
+        expect(sql).not.toContain("output.data.name.:String");
+      });
+
+      it("should still use nullValue transformation for IS NULL", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE output IS NULL", ctx);
+
+        // NULL check should use the text column with nullValue
+        expect(sql).toContain("equals(output_text, '{}')");
+      });
+
+      it("should still use nullValue transformation for IS NOT NULL", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT id FROM runs WHERE error IS NOT NULL", ctx);
+
+        expect(sql).toContain("notEquals(error_text, '{}')");
+      });
+    });
+
+    describe("edge cases", () => {
+      it("should work with columns without textColumn defined", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT status FROM runs WHERE status = 'completed'", ctx);
+
+        // Regular column should work as before
+        expect(sql).toContain("status");
+        expect(sql).not.toContain("status_text");
+      });
+
+      it("should use text column for aliased JSON columns in SELECT", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT output AS result FROM runs", ctx);
+
+        // Should use text column with user's alias
+        expect(sql).toContain("output_text AS result");
+      });
+
+      it("should use text column for table-qualified JSON columns in SELECT", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery("SELECT runs.output FROM runs", ctx);
+
+        // Should use text column
+        expect(sql).toContain("output_text AS output");
+      });
+
+      it("should use text column in both SELECT and WHERE for same query", () => {
+        const ctx = createTextColumnContext();
+        const { sql } = printQuery(
+          "SELECT output FROM runs WHERE output LIKE '%test%'",
+          ctx
+        );
+
+        // SELECT should use text column
+        expect(sql).toContain("output_text AS output");
+        // WHERE should use text column
+        expect(sql).toContain("like(output_text,");
+      });
+    });
+
+    describe("JOINs with textColumn", () => {
+      // Create a second schema with the same JSON column names to test JOIN ambiguity
+      const runsSchemaWithTextColumn: TableSchema = {
+        name: "runs",
+        clickhouseName: "trigger_dev.task_runs_v2",
+        columns: {
+          id: { name: "id", ...column("String") },
+          output: {
+            name: "output",
+            ...column("JSON"),
+            nullValue: "'{}'",
+            textColumn: "output_text",
+          },
+          organization_id: { name: "organization_id", ...column("String") },
+          project_id: { name: "project_id", ...column("String") },
+          environment_id: { name: "environment_id", ...column("String") },
+        },
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+      };
+
+      const eventsSchemaWithTextColumn: TableSchema = {
+        name: "events",
+        clickhouseName: "trigger_dev.task_events_v2",
+        columns: {
+          id: { name: "id", ...column("String") },
+          run_id: { name: "run_id", ...column("String") },
+          output: {
+            name: "output",
+            ...column("JSON"),
+            nullValue: "'{}'",
+            textColumn: "output_text",
+          },
+          organization_id: { name: "organization_id", ...column("String") },
+          project_id: { name: "project_id", ...column("String") },
+          environment_id: { name: "environment_id", ...column("String") },
+        },
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+      };
+
+      function createJoinTextColumnContext() {
+        const schema = createSchemaRegistry([runsSchemaWithTextColumn, eventsSchemaWithTextColumn]);
+        return createPrinterContext({
+          schema,
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_test" },
+            project_id: { op: "eq", value: "proj_test" },
+            environment_id: { op: "eq", value: "env_test" },
+          },
+        });
+      }
+
+      it("should qualify text column with table alias in JOIN WHERE clause to avoid ambiguity", () => {
+        const ctx = createJoinTextColumnContext();
+        const { sql } = printQuery(
+          `SELECT r.id FROM runs r JOIN events e ON r.id = e.run_id WHERE r.output = '{}'`,
+          ctx
+        );
+
+        // The text column should be table-qualified to avoid ambiguity
+        // since both tables have an output_text column
+        expect(sql).toContain("equals(r.output_text,");
+        // Should NOT have unqualified output_text in the comparison
+        expect(sql).not.toMatch(/equals\(output_text,/);
+      });
+
+      it("should qualify text column with table alias for LIKE in JOIN", () => {
+        const ctx = createJoinTextColumnContext();
+        const { sql } = printQuery(
+          `SELECT r.id FROM runs r JOIN events e ON r.id = e.run_id WHERE e.output LIKE '%error%'`,
+          ctx
+        );
+
+        // Should use table-qualified text column
+        expect(sql).toContain("like(e.output_text,");
+        expect(sql).not.toMatch(/like\(output_text,/);
+      });
+
+      it("should handle multiple qualified text column comparisons in JOIN", () => {
+        const ctx = createJoinTextColumnContext();
+        const { sql } = printQuery(
+          `SELECT r.id FROM runs r JOIN events e ON r.id = e.run_id WHERE r.output = '{}' AND e.output != '{}'`,
+          ctx
+        );
+
+        // Both comparisons should be table-qualified
+        expect(sql).toContain("equals(r.output_text,");
+        expect(sql).toContain("notEquals(e.output_text,");
+      });
+    });
+  });
+
+  describe("dataPrefix for JSON columns", () => {
+    // Create a schema with JSON columns that have dataPrefix set
+    const dataPrefixSchema: TableSchema = {
+      name: "runs",
+      clickhouseName: "trigger_dev.task_runs_v2",
+      columns: {
+        id: { name: "id", ...column("String") },
+        output: {
+          name: "output",
+          ...column("JSON"),
+          nullValue: "'{}'",
+          dataPrefix: "data",
+        },
+        error: {
+          name: "error",
+          ...column("JSON"),
+          nullValue: "'{}'",
+          dataPrefix: "data",
+        },
+        status: { name: "status", ...column("String") },
+        organization_id: { name: "organization_id", ...column("String") },
+        project_id: { name: "project_id", ...column("String") },
+        environment_id: { name: "environment_id", ...column("String") },
+      },
+      tenantColumns: {
+        organizationId: "organization_id",
+        projectId: "project_id",
+        environmentId: "environment_id",
+      },
+    };
+
+    function createDataPrefixContext() {
+      const schema = createSchemaRegistry([dataPrefixSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  describe("SELECT clause", () => {
+    it("should inject dataPrefix into JSON subfield path", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT output.message FROM runs", ctx);
+
+        // Should transform output.message to output.data.message
+        expect(sql).toContain("output.data.message");
+      });
+
+      it("should generate clean alias without dataPrefix", () => {
+        const ctx = createDataPrefixContext();
+        const { sql, columns } = printQuery("SELECT output.message FROM runs", ctx);
+
+        // Alias should be output_message, not output_data_message
+        expect(sql).toContain("AS output_message");
+        expect(sql).not.toContain("AS output_data_message");
+        expect(columns).toContainEqual(
+          expect.objectContaining({ name: "output_message" })
+        );
+      });
+
+      it("should handle nested paths with dataPrefix", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT output.user.name FROM runs", ctx);
+
+        // Should transform output.user.name to output.data.user.name
+        expect(sql).toContain("output.data.user.name");
+        // Alias should be output_user_name
+        expect(sql).toContain("AS output_user_name");
+      });
+
+      it("should work with multiple JSON columns with dataPrefix", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT output.msg, error.code FROM runs", ctx);
+
+        expect(sql).toContain("output.data.msg");
+        expect(sql).toContain("error.data.code");
+        expect(sql).toContain("AS output_msg");
+        expect(sql).toContain("AS error_code");
+      });
+
+      it("should not affect bare JSON column selection", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT output FROM runs", ctx);
+
+        // Bare column should not have dataPrefix injected
+        expect(sql).not.toContain("output.data");
+        expect(sql).toMatch(/SELECT\s+output[\s,]/);
+      });
+    });
+
+    describe("WHERE clause", () => {
+      it("should inject dataPrefix into WHERE comparison", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery(
+          "SELECT id FROM runs WHERE output.status = 'success'",
+          ctx
+        );
+
+        // Should transform output.status to output.data.status
+        expect(sql).toContain("output.data.status");
+      });
+
+      it("should inject dataPrefix into LIKE comparison", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery(
+          "SELECT id FROM runs WHERE error.message LIKE '%failed%'",
+          ctx
+        );
+
+        expect(sql).toContain("error.data.message");
+      });
+    });
+
+    describe("GROUP BY clause", () => {
+      it("should inject dataPrefix into GROUP BY", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery(
+          "SELECT output.type, count() AS cnt FROM runs GROUP BY output.type",
+          ctx
+        );
+
+        // Should inject dataPrefix in both SELECT and GROUP BY
+        expect(sql).toContain("output.data.type");
+        expect(sql).toContain("GROUP BY output.data.type");
+      });
+    });
+
+    describe("edge cases", () => {
+      it("should not affect columns without dataPrefix", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT status FROM runs", ctx);
+
+        // Regular column should not be affected
+        expect(sql).toContain("status");
+        expect(sql).not.toContain("status.data");
+      });
+
+      it("should work with explicit alias on JSON subfield", () => {
+        const ctx = createDataPrefixContext();
+        const { sql } = printQuery("SELECT output.message AS msg FROM runs", ctx);
+
+        // Should inject dataPrefix but use user's alias
+        expect(sql).toContain("output.data.message");
+        expect(sql).toContain("AS msg");
+      });
+    });
+  });
+
+  describe("ORDER BY clauses", () => {
+    it("should print ORDER BY ASC", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs ORDER BY created_at ASC");
+
+      expect(sql).toContain("ORDER BY created_at ASC");
+    });
+
+    it("should print ORDER BY DESC", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs ORDER BY created_at DESC");
+
+      expect(sql).toContain("ORDER BY created_at DESC");
+    });
+
+    it("should print ORDER BY with multiple columns", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs ORDER BY status ASC, created_at DESC");
+
+      expect(sql).toContain("ORDER BY status ASC, created_at DESC");
+    });
+  });
+
+  describe("LIMIT and OFFSET", () => {
+    it("should print LIMIT", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs LIMIT 10");
+
+      expect(sql).toContain("LIMIT 10");
+    });
+
+    it("should print LIMIT with OFFSET", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs LIMIT 10 OFFSET 20");
+
+      expect(sql).toContain("LIMIT 10");
+      expect(sql).toContain("OFFSET 20");
+    });
+
+    it("should cap LIMIT to maxRows setting", () => {
+      const context = createTestContext({ settings: { maxRows: 100 } });
+      const { sql } = printQuery("SELECT * FROM task_runs LIMIT 1000", context);
+
+      expect(sql).toContain("LIMIT 100");
+    });
+
+    it("should add default LIMIT when none specified", () => {
+      const context = createTestContext({ settings: { maxRows: 10000 } });
+      const { sql } = printQuery("SELECT * FROM task_runs", context);
+
+      expect(sql).toContain("LIMIT 10000");
+    });
+  });
+
+  describe("GROUP BY clauses", () => {
+    it("should print GROUP BY", () => {
+      const { sql } = printQuery("SELECT status, count(*) FROM task_runs GROUP BY status");
+
+      expect(sql).toContain("GROUP BY status");
+    });
+
+    it("should print GROUP BY with multiple columns", () => {
+      const { sql } = printQuery(
+        "SELECT status, queue_name, count(*) FROM task_runs GROUP BY status, queue_name"
+      );
+
+      expect(sql).toContain("GROUP BY status, queue_name");
+    });
+
+    it("should print GROUP BY with HAVING", () => {
+      const { sql } = printQuery(
+        "SELECT status, count(*) as cnt FROM task_runs GROUP BY status HAVING cnt > 10"
+      );
+
+      expect(sql).toContain("GROUP BY status");
+      expect(sql).toContain("HAVING");
+      expect(sql).toContain("greater(");
+    });
+  });
+
+  describe("Aggregate functions", () => {
+    it("should print COUNT", () => {
+      const { sql } = printQuery("SELECT count(*) FROM task_runs");
+
+      expect(sql).toContain("count(*)");
+    });
+
+    it("should print COUNT DISTINCT", () => {
+      const { sql } = printQuery("SELECT count(DISTINCT status) FROM task_runs");
+
+      expect(sql).toContain("count(DISTINCT status)");
+    });
+
+    it("should print SUM", () => {
+      const { sql } = printQuery("SELECT sum(duration_ms) FROM task_runs");
+
+      expect(sql).toContain("sum(duration_ms)");
+    });
+
+    it("should print AVG", () => {
+      const { sql } = printQuery("SELECT avg(duration_ms) FROM task_runs");
+
+      expect(sql).toContain("avg(duration_ms)");
+    });
+
+    it("should print MIN and MAX", () => {
+      const { sql } = printQuery("SELECT min(created_at), max(created_at) FROM task_runs");
+
+      expect(sql).toContain("min(created_at)");
+      expect(sql).toContain("max(created_at)");
+    });
+  });
+
+  describe("Arithmetic operations", () => {
+    it("should print addition", () => {
+      const { sql } = printQuery("SELECT duration_ms + 100 FROM task_runs");
+
+      expect(sql).toContain("plus(duration_ms, 100)");
+    });
+
+    it("should print subtraction", () => {
+      const { sql } = printQuery("SELECT duration_ms - 100 FROM task_runs");
+
+      expect(sql).toContain("minus(duration_ms, 100)");
+    });
+
+    it("should print multiplication", () => {
+      const { sql } = printQuery("SELECT duration_ms * 2 FROM task_runs");
+
+      expect(sql).toContain("multiply(duration_ms, 2)");
+    });
+
+    it("should print division", () => {
+      const { sql } = printQuery("SELECT duration_ms / 1000 FROM task_runs");
+
+      expect(sql).toContain("divide(duration_ms, 1000)");
+    });
+
+    it("should print modulo", () => {
+      const { sql } = printQuery("SELECT duration_ms % 60 FROM task_runs");
+
+      expect(sql).toContain("modulo(duration_ms, 60)");
+    });
+  });
+
+  describe("Date functions with interval units", () => {
+    it("should output dateAdd with string interval as bare keyword", () => {
+      const { sql } = printQuery("SELECT dateAdd('day', 7, created_at) AS week_later FROM task_runs");
+
+      expect(sql).toContain("dateAdd(day, 7, created_at)");
+      expect(sql).not.toContain("'day'");
+    });
+
+    it("should output dateAdd with bare identifier interval as keyword", () => {
+      const { sql } = printQuery("SELECT dateAdd(day, 7, created_at) AS week_later FROM task_runs");
+
+      expect(sql).toContain("dateAdd(day, 7, created_at)");
+    });
+
+    it("should output dateDiff with string interval as bare keyword", () => {
+      const { sql } = printQuery(
+        "SELECT dateDiff('minute', started_at, completed_at) AS duration_minutes FROM task_runs"
+      );
+
+      expect(sql).toContain("dateDiff(minute,");
+      expect(sql).not.toContain("'minute'");
+    });
+
+    it("should output dateSub with string interval as bare keyword", () => {
+      const { sql } = printQuery("SELECT dateSub('hour', 1, created_at) AS earlier FROM task_runs");
+
+      expect(sql).toContain("dateSub(hour, 1, created_at)");
+      expect(sql).not.toContain("'hour'");
+    });
+
+    it("should keep dateTrunc interval as parameterized string (ClickHouse expects string)", () => {
+      const { sql } = printQuery(
+        "SELECT dateTrunc('month', created_at) AS month_start FROM task_runs"
+      );
+
+      expect(sql).toContain("dateTrunc(");
+      expect(sql).not.toContain("dateTrunc(month,");
+    });
+
+    it("should output date_add (underscore variant) with bare keyword", () => {
+      const { sql } = printQuery(
+        "SELECT date_add('week', 2, created_at) AS two_weeks FROM task_runs"
+      );
+
+      expect(sql).toContain("date_add(week, 2, created_at)");
+      expect(sql).not.toContain("'week'");
+    });
+
+    it("should output date_diff (underscore variant) with bare keyword", () => {
+      const { sql } = printQuery(
+        "SELECT date_diff('second', started_at, completed_at) AS dur FROM task_runs"
+      );
+
+      expect(sql).toContain("date_diff(second,");
+      expect(sql).not.toContain("'second'");
+    });
+
+    it("should handle case-insensitive interval units", () => {
+      const { sql } = printQuery("SELECT dateAdd('DAY', 7, created_at) AS week_later FROM task_runs");
+
+      expect(sql).toContain("dateAdd(day, 7, created_at)");
+    });
+
+    it("should output dateDiff with sub-second units as bare keywords", () => {
+      const { sql } = printQuery(
+        "SELECT dateDiff('millisecond', started_at, completed_at) AS dur FROM task_runs"
+      );
+
+      expect(sql).toContain("dateDiff(millisecond,");
+      expect(sql).not.toContain("'millisecond'");
+    });
+
+    it("should output dateDiff with microsecond as bare keyword", () => {
+      const { sql } = printQuery(
+        "SELECT dateDiff('microsecond', started_at, completed_at) AS dur FROM task_runs"
+      );
+
+      expect(sql).toContain("dateDiff(microsecond,");
+    });
+
+    it("should output dateDiff with nanosecond as bare keyword", () => {
+      const { sql } = printQuery(
+        "SELECT dateDiff('nanosecond', started_at, completed_at) AS dur FROM task_runs"
+      );
+
+      expect(sql).toContain("dateDiff(nanosecond,");
+    });
+  });
+
+  describe("Tenant isolation", () => {
+    it("should inject tenant guards for single table", () => {
+      const context = createTestContext({
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_abc" },
+          project_id: { op: "eq", value: "proj_def" },
+          environment_id: { op: "eq", value: "env_ghi" },
+        },
+      });
+      const { sql, params } = printQuery("SELECT * FROM task_runs", context);
+
+      // Should have WHERE clause with tenant columns
+      expect(sql).toContain("WHERE");
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+
+      // Values should be parameterized
+      expect(Object.values(params)).toContain("org_abc");
+      expect(Object.values(params)).toContain("proj_def");
+      expect(Object.values(params)).toContain("env_ghi");
+    });
+
+    it("should combine tenant guards with user WHERE clause", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE status = 'completed'");
+
+      // Should have both tenant guard AND user condition
+      expect(sql).toContain("and(");
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("equals(");
+    });
+  });
+
+  describe("SQL injection prevention", () => {
+    it("should parameterize string values", () => {
+      const { sql, params } = printQuery(
+        "SELECT * FROM task_runs WHERE status = 'DROP TABLE users'"
+      );
+
+      // The malicious string should be in params, not in SQL
+      expect(sql).not.toContain("DROP TABLE");
+      expect(Object.values(params)).toContain("DROP TABLE users");
+    });
+
+    it("should safely handle identifiers with special characters", () => {
+      // This should either escape or reject
+      expect(() => {
+        printQuery("SELECT * FROM task_runs WHERE `weird`column` = 'test'");
+      }).toThrow();
+    });
+
+    it("should only allow tables defined in schema", () => {
+      // Users cannot query arbitrary tables - only those in the schema
+      expect(() => {
+        printQuery("SELECT * FROM system_tables");
+      }).toThrow();
+
+      expect(() => {
+        printQuery("SELECT * FROM unknown_table");
+      }).toThrow();
+    });
+
+    it("should parameterize numeric values inline", () => {
+      const { sql, params } = printQuery("SELECT * FROM task_runs WHERE duration_ms > 1000");
+
+      // Numbers can be inlined safely
+      expect(sql).toContain("1000");
+    });
+
+    it("should handle boolean values safely", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE is_test = 1");
+
+      expect(sql).toContain("equals(is_test, 1)");
+    });
+  });
+
+  describe("Subqueries", () => {
+    it("should print subquery in FROM clause", () => {
+      const { sql } = printQuery(`
+        SELECT status, cnt
+        FROM (
+          SELECT status, count(*) as cnt
+          FROM task_runs
+          GROUP BY status
+        )
+      `);
+
+      expect(sql).toContain("SELECT status, cnt");
+      expect(sql).toContain("FROM (");
+      expect(sql).toContain("count(*)");
+    });
+
+    it("should print subquery in WHERE clause", () => {
+      const { sql } = printQuery(`
+        SELECT * FROM task_runs
+        WHERE id IN (SELECT run_id FROM task_events WHERE event_type = 'completed')
+      `);
+
+      expect(sql).toContain("in(id,");
+      expect(sql).toContain("SELECT run_id FROM");
+    });
+  });
+
+  describe("UNION queries", () => {
+    it("should print UNION ALL", () => {
+      const { sql } = printQuery(`
+        SELECT id, status FROM task_runs WHERE status = 'completed'
+        UNION ALL
+        SELECT id, status FROM task_runs WHERE status = 'failed'
+      `);
+
+      expect(sql).toContain("UNION ALL");
+    });
+  });
+
+  describe("Window functions", () => {
+    it("should print ROW_NUMBER", () => {
+      const { sql } = printQuery(`
+        SELECT id, status, row_number() OVER (PARTITION BY status ORDER BY created_at DESC) as rn
+        FROM task_runs
+      `);
+
+      expect(sql).toContain("row_number()");
+      expect(sql).toContain("OVER (");
+      expect(sql).toContain("PARTITION BY status");
+      expect(sql).toContain("ORDER BY created_at DESC");
+    });
+  });
+
+  describe("Functions", () => {
+    it("should print toDateTime with column argument", () => {
+      const { sql } = printQuery("SELECT toDateTime(created_at) FROM task_runs");
+
+      expect(sql).toContain("toDateTime(created_at)");
+    });
+
+    it("should print toDateTime with string and timezone arguments", () => {
+      const { sql, params } = printQuery(
+        "SELECT toDateTime('2024-01-15 10:30:00', 'UTC') FROM task_runs"
+      );
+
+      // String values are parameterized for security
+      expect(sql).toContain("toDateTime(");
+      expect(sql).toMatch(/toDateTime\(\{tsql_val_\d+: String\}, \{tsql_val_\d+: String\}\)/);
+      expect(Object.values(params)).toContain("2024-01-15 10:30:00");
+      expect(Object.values(params)).toContain("UTC");
+    });
+
+    it("should print toDateTime with timezone containing special characters", () => {
+      const { sql, params } = printQuery(
+        "SELECT toDateTime('2024-01-15 10:30:00', 'America/New_York') FROM task_runs"
+      );
+
+      // String values are parameterized for security
+      expect(sql).toContain("toDateTime(");
+      expect(sql).toMatch(/toDateTime\(\{tsql_val_\d+: String\}, \{tsql_val_\d+: String\}\)/);
+      expect(Object.values(params)).toContain("2024-01-15 10:30:00");
+      expect(Object.values(params)).toContain("America/New_York");
+    });
+
+    it("should print toDateTime64 with precision and timezone", () => {
+      const { sql, params } = printQuery(
+        "SELECT toDateTime64('2024-01-15 10:30:00.500000', 6, 'Europe/London') FROM task_runs"
+      );
+
+      // String values are parameterized, but numeric precision is inline
+      expect(sql).toContain("toDateTime64(");
+      expect(sql).toMatch(/toDateTime64\(\{tsql_val_\d+: String\}, 6, \{tsql_val_\d+: String\}\)/);
+      expect(Object.values(params)).toContain("2024-01-15 10:30:00.500000");
+      expect(Object.values(params)).toContain("Europe/London");
+    });
+
+    it("should print now()", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE created_at > now()");
+
+      expect(sql).toContain("now()");
+    });
+
+    it("should print string functions", () => {
+      const { sql } = printQuery("SELECT lower(status), upper(queue_name) FROM task_runs");
+
+      expect(sql).toContain("lower(status)");
+      expect(sql).toContain("upper(queue_name)");
+    });
+
+    it("should print conditional functions", () => {
+      const { sql } = printQuery("SELECT if(is_test = 1, 'test', 'prod') FROM task_runs");
+
+      expect(sql).toContain("if(");
+    });
+
+    it("should print coalesce", () => {
+      const { sql } = printQuery("SELECT coalesce(started_at, created_at) FROM task_runs");
+
+      expect(sql).toContain("coalesce(started_at, created_at)");
+    });
+  });
+
+  describe("Arrays and tuples", () => {
+    it("should print array literals", () => {
+      const { sql } = printQuery("SELECT * FROM task_runs WHERE status IN ['completed', 'failed']");
+
+      expect(sql).toContain("[");
+      expect(sql).toContain("]");
+    });
+
+    it("should print tuple", () => {
+      const { sql } = printQuery("SELECT tuple(id, status) FROM task_runs");
+
+      expect(sql).toContain("tuple(id, status)");
+    });
+  });
+
+  describe("Error handling", () => {
+    it("should throw QueryError for unknown tables", () => {
+      expect(() => {
+        printQuery("SELECT * FROM unknown_table");
+      }).toThrow(QueryError);
+    });
+
+    it("should throw QueryError for unknown functions", () => {
+      expect(() => {
+        printQuery("SELECT unknown_function(id) FROM task_runs");
+      }).toThrow(QueryError);
+    });
+
+    it("should throw QueryError for nested aggregations", () => {
+      expect(() => {
+        printQuery("SELECT sum(count(*)) FROM task_runs");
+      }).toThrow(QueryError);
+    });
+
+    it("should throw SyntaxError for malformed queries", () => {
+      expect(() => {
+        parseTSQLSelect("SELECT * FORM task_runs"); // typo: FORM instead of FROM
+      }).toThrow();
+    });
+  });
+
+  describe("Pretty printing", () => {
+    it("should format SQL with newlines when pretty=true", () => {
+      const ast = parseTSQLSelect(
+        "SELECT id, status FROM task_runs WHERE status = 'completed' ORDER BY created_at"
+      );
+      const context = createTestContext();
+      const printer = new ClickHousePrinter(context, { pretty: true });
+      const { sql } = printer.print(ast);
+
+      expect(sql).toContain("\n");
+    });
+
+    it("should produce single-line SQL when pretty=false", () => {
+      const ast = parseTSQLSelect(
+        "SELECT id, status FROM task_runs WHERE status = 'completed' ORDER BY created_at"
+      );
+      const context = createTestContext();
+      const printer = new ClickHousePrinter(context, { pretty: false });
+      const { sql } = printer.print(ast);
+
+      // Count newlines - there should be very few or none in the main query structure
+      const newlineCount = (sql.match(/\n/g) || []).length;
+      expect(newlineCount).toBeLessThan(3);
+    });
+  });
+
+  describe("Parameter generation", () => {
+    it("should generate unique parameter names", () => {
+      const { params } = printQuery(`
+        SELECT * FROM task_runs
+        WHERE status = 'completed' AND queue_name = 'email' AND task_identifier = 'send'
+      `);
+
+      // Should have multiple unique parameter keys
+      const keys = Object.keys(params);
+      expect(new Set(keys).size).toBe(keys.length);
+    });
+
+    it("should include correct types in placeholders", () => {
+      const { sql, params } = printQuery("SELECT * FROM task_runs WHERE status = 'test'");
+
+      // Should have String type in placeholder
+      expect(sql).toMatch(/\{tsql_val_\d+: String\}/);
+    });
+  });
+});
+
+describe("Value mapping (valueMap)", () => {
+  /**
+   * Schema with valueMap for status column
+   */
+  const statusMappedSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      id: { name: "id", ...column("String") },
+      status: {
+        name: "status",
+        ...column("String"),
+        valueMap: {
+          COMPLETED_SUCCESSFULLY: "Completed",
+          COMPLETED_WITH_ERRORS: "Completed with errors",
+          SYSTEM_FAILURE: "System failure",
+          PENDING: "Pending",
+          EXECUTING: "Running",
+          FAILED: "Failed",
+        },
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createValueMapContext() {
+    const schema = createSchemaRegistry([statusMappedSchema]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test" },
+      project_id: { op: "eq", value: "proj_test" },
+      environment_id: { op: "eq", value: "env_test" },
+    },
+  });
+}
+
+it("should transform user-friendly value to internal value in equality comparison", () => {
+    const ctx = createValueMapContext();
+    const { sql, params } = printQuery("SELECT * FROM runs WHERE status = 'Completed'", ctx);
+
+    // The user-friendly value "Completed" should be transformed to "COMPLETED_SUCCESSFULLY"
+    expect(Object.values(params)).toContain("COMPLETED_SUCCESSFULLY");
+    expect(Object.values(params)).not.toContain("Completed");
+  });
+
+  it("should transform user-friendly values in IN clause", () => {
+    const ctx = createValueMapContext();
+    const { sql, params } = printQuery(
+      "SELECT * FROM runs WHERE status IN ('Completed', 'Failed', 'Running')",
+      ctx
+    );
+
+    // All user-friendly values should be transformed
+    expect(Object.values(params)).toContain("COMPLETED_SUCCESSFULLY");
+    expect(Object.values(params)).toContain("FAILED");
+    expect(Object.values(params)).toContain("EXECUTING");
+    expect(Object.values(params)).not.toContain("Completed");
+    expect(Object.values(params)).not.toContain("Failed");
+    expect(Object.values(params)).not.toContain("Running");
+  });
+
+  it("should handle case-insensitive value matching", () => {
+    const ctx = createValueMapContext();
+    const { params: params1 } = printQuery("SELECT * FROM runs WHERE status = 'completed'", ctx);
+    const { params: params2 } = printQuery("SELECT * FROM runs WHERE status = 'COMPLETED'", ctx);
+    const { params: params3 } = printQuery("SELECT * FROM runs WHERE status = 'Completed'", ctx);
+
+    // All variations should map to the same internal value
+    expect(Object.values(params1)).toContain("COMPLETED_SUCCESSFULLY");
+    expect(Object.values(params2)).toContain("COMPLETED_SUCCESSFULLY");
+    expect(Object.values(params3)).toContain("COMPLETED_SUCCESSFULLY");
+  });
+
+  it("should pass through values without mapping if not in valueMap", () => {
+    const ctx = createValueMapContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE status = 'UNKNOWN_STATUS'", ctx);
+
+    // Value not in valueMap should pass through unchanged
+    expect(Object.values(params)).toContain("UNKNOWN_STATUS");
+  });
+
+  it("should transform values in NOT IN clause", () => {
+    const ctx = createValueMapContext();
+    const { sql, params } = printQuery(
+      "SELECT * FROM runs WHERE status NOT IN ('Pending', 'System failure')",
+      ctx
+    );
+
+    expect(Object.values(params)).toContain("PENDING");
+    expect(Object.values(params)).toContain("SYSTEM_FAILURE");
+  });
+
+  it("should transform values in != comparison", () => {
+    const ctx = createValueMapContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE status != 'Failed'", ctx);
+
+    expect(Object.values(params)).toContain("FAILED");
+  });
+
+  it("should not transform values for columns without valueMap", () => {
+    const ctx = createValueMapContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE id = 'Completed'", ctx);
+
+    // 'id' column has no valueMap, so "Completed" should pass through unchanged
+    expect(Object.values(params)).toContain("Completed");
+  });
+});
+
+describe("WHERE transform (whereTransform)", () => {
+  /**
+   * Schema with whereTransform for batch_id column (strips prefix)
+   */
+  const prefixedIdSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      id: { name: "id", ...column("String") },
+      batch_id: {
+        name: "batch_id",
+        ...column("String"),
+        // Transform strips the "batch_" prefix from user input
+        whereTransform: (value: string) => value.replace(/^batch_/, ""),
+        // Expression adds the prefix back in SELECT
+        expression: "if(batch_id = '', NULL, concat('batch_', batch_id))",
+      },
+      schedule_id: {
+        name: "schedule_id",
+        ...column("String"),
+        // Transform strips the "sched_" prefix
+        whereTransform: (value: string) => value.replace(/^sched_/, ""),
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createPrefixedContext() {
+    const schema = createSchemaRegistry([prefixedIdSchema]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test123" },
+      project_id: { op: "eq", value: "proj_test456" },
+      environment_id: { op: "eq", value: "env_test789" },
+    },
+  });
+}
+
+it("should strip prefix from value in equality comparison", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE batch_id = 'batch_abc123'", ctx);
+
+    // The "batch_" prefix should be stripped, leaving just "abc123"
+    expect(Object.values(params)).toContain("abc123");
+    expect(Object.values(params)).not.toContain("batch_abc123");
+  });
+
+  it("should strip prefix from values in IN clause", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery(
+      "SELECT * FROM runs WHERE batch_id IN ('batch_abc', 'batch_def', 'batch_ghi')",
+      ctx
+    );
+
+    // All prefixes should be stripped
+    expect(Object.values(params)).toContain("abc");
+    expect(Object.values(params)).toContain("def");
+    expect(Object.values(params)).toContain("ghi");
+    expect(Object.values(params)).not.toContain("batch_abc");
+  });
+
+  it("should strip prefix from value in NOT IN clause", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE batch_id NOT IN ('batch_xyz')", ctx);
+
+    expect(Object.values(params)).toContain("xyz");
+    expect(Object.values(params)).not.toContain("batch_xyz");
+  });
+
+  it("should strip prefix from value in != comparison", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE batch_id != 'batch_test'", ctx);
+
+    expect(Object.values(params)).toContain("test");
+    expect(Object.values(params)).not.toContain("batch_test");
+  });
+
+  it("should handle values without the prefix (pass through unchanged)", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE batch_id = 'raw_value'", ctx);
+
+    // If no prefix to strip, the value passes through unchanged
+    expect(Object.values(params)).toContain("raw_value");
+  });
+
+  it("should not transform values for columns without whereTransform", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE id = 'batch_abc123'", ctx);
+
+    // 'id' column has no whereTransform, so value passes through unchanged
+    expect(Object.values(params)).toContain("batch_abc123");
+  });
+
+  it("should use expression for SELECT output (virtual column)", () => {
+    const ctx = createPrefixedContext();
+    const { sql } = printQuery("SELECT batch_id FROM runs", ctx);
+
+    // The expression should be used in SELECT
+    expect(sql).toContain("if(batch_id = '', NULL, concat('batch_', batch_id))");
+  });
+
+  it("should use raw column in WHERE but expression in SELECT", () => {
+    const ctx = createPrefixedContext();
+    const { sql, params } = printQuery(
+      "SELECT batch_id FROM runs WHERE batch_id = 'batch_abc123'",
+      ctx
+    );
+
+    // SELECT should use the expression (adds prefix)
+    expect(sql).toContain("if(batch_id = '', NULL, concat('batch_', batch_id))");
+
+    // WHERE should use table-qualified raw column (not the expression), and value should be stripped
+    // The WHERE clause should compare `runs.batch_id` directly (table-qualified to avoid alias conflict)
+    expect(sql).toMatch(/WHERE.*equals\(`?runs`?\.`?batch_id`?,/);
+    expect(sql).not.toMatch(/WHERE.*concat\('batch_'/);
+
+    // The value should have prefix stripped
+    expect(Object.values(params)).toContain("abc123");
+  });
+
+  it("should work with different prefix patterns", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery("SELECT * FROM runs WHERE schedule_id = 'sched_xyz789'", ctx);
+
+    // The "sched_" prefix should be stripped
+    expect(Object.values(params)).toContain("xyz789");
+    expect(Object.values(params)).not.toContain("sched_xyz789");
+  });
+
+  it("should transform values in tuple/array for IN expressions", () => {
+    const ctx = createPrefixedContext();
+    const { params } = printQuery(
+      "SELECT * FROM runs WHERE batch_id IN ['batch_a', 'batch_b']",
+      ctx
+    );
+
+    // Both prefixes should be stripped
+    expect(Object.values(params)).toContain("a");
+    expect(Object.values(params)).toContain("b");
+  });
+
+  it("should use raw column in GROUP BY for columns with whereTransform", () => {
+    const ctx = createPrefixedContext();
+    const { sql } = printQuery(
+      "SELECT batch_id, COUNT() as count FROM runs GROUP BY batch_id",
+      ctx
+    );
+
+    // SELECT should use the expression (adds prefix)
+    expect(sql).toContain("if(batch_id = '', NULL, concat('batch_', batch_id))");
+
+    // GROUP BY should use table-qualified raw column (not the expression)
+    // This avoids the "not in GROUP BY keys" error from ClickHouse
+    expect(sql).toMatch(/GROUP BY.*`?runs`?\.`?batch_id`?/);
+    expect(sql).not.toMatch(/GROUP BY.*concat\('batch_'/);
+  });
+
+  it("should work with GROUP BY and WHERE together", () => {
+    const ctx = createPrefixedContext();
+    const { sql, params } = printQuery(
+      "SELECT batch_id, COUNT() as count FROM runs WHERE batch_id != NULL GROUP BY batch_id",
+      ctx
+    );
+
+    // SELECT should use expression
+    expect(sql).toContain("if(batch_id = '', NULL, concat('batch_', batch_id))");
+
+    // Both WHERE and GROUP BY should use raw column
+    expect(sql).toMatch(/WHERE.*`?runs`?\.`?batch_id`?/);
+    expect(sql).toMatch(/GROUP BY.*`?runs`?\.`?batch_id`?/);
+  });
+});
+
+describe("Edge cases", () => {
+  it("should handle empty string values", () => {
+    const { sql, params } = printQuery("SELECT * FROM task_runs WHERE status = ''");
+
+    expect(Object.values(params)).toContain("");
+  });
+
+  it("should handle special characters in strings", () => {
+    const { sql, params } = printQuery("SELECT * FROM task_runs WHERE status = 'test\nvalue'");
+
+    // The string value should be parameterized
+    expect(Object.keys(params).length).toBeGreaterThan(0);
+  });
+
+  it("should handle large numbers", () => {
+    // Use a number that JavaScript can safely represent
+    const { sql } = printQuery("SELECT * FROM task_runs WHERE duration_ms > 1000000000000");
+
+    expect(sql).toContain("1000000000000");
+  });
+
+  it("should handle negative numbers", () => {
+    const { sql } = printQuery("SELECT * FROM task_runs WHERE duration_ms > -1000");
+
+    // Negative numbers might be expressed as subtraction or negate
+    expect(sql).toMatch(/-1000|minus|negate/);
+  });
+
+  it("should handle floating point numbers", () => {
+    const { sql } = printQuery("SELECT * FROM task_runs WHERE duration_ms > 1.5");
+
+    expect(sql).toContain("1.5");
+  });
+});
+
+describe("Virtual columns", () => {
+  /**
+   * Schema with virtual (computed) columns
+   */
+  const virtualColumnSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+      completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+      usage_duration_ms: { name: "usage_duration_ms", ...column("UInt32") },
+      // Virtual column: execution_duration computes the time between started_at and completed_at
+      execution_duration: {
+        name: "execution_duration",
+        ...column("Nullable(Int64)"),
+        expression: "dateDiff('millisecond', started_at, completed_at)",
+        description: "Time between started_at and completed_at in milliseconds",
+      },
+      // Virtual column: is_long_running checks if execution took more than 60 seconds
+      is_long_running: {
+        name: "is_long_running",
+        ...column("UInt8"),
+        expression:
+          "if(completed_at IS NOT NULL AND started_at IS NOT NULL, dateDiff('second', started_at, completed_at) > 60, 0)",
+      },
+      // Virtual column with simple arithmetic
+      usage_duration_seconds: {
+        name: "usage_duration_seconds",
+        ...column("Float64"),
+        expression: "usage_duration_ms / 1000.0",
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createVirtualColumnContext() {
+    const schema = createSchemaRegistry([virtualColumnSchema]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test" },
+      project_id: { op: "eq", value: "proj_test" },
+      environment_id: { op: "eq", value: "env_test" },
+    },
+  });
+}
+
+describe("SELECT clause", () => {
+  it("should expand bare virtual column to expression with alias", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT execution_duration FROM runs", ctx);
+
+      // Virtual column should be expanded to its expression with AS alias
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at))");
+      expect(sql).toContain("AS execution_duration");
+    });
+
+    it("should expand virtual column with explicit alias", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT execution_duration AS dur FROM runs", ctx);
+
+      // Virtual column should use the user-provided alias
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at))");
+      expect(sql).toContain("AS dur");
+      expect(sql).not.toContain("AS execution_duration");
+    });
+
+    it("should expand qualified virtual column reference", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT runs.execution_duration FROM runs", ctx);
+
+      // Qualified reference should also expand
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at))");
+      expect(sql).toContain("AS execution_duration");
+    });
+
+    it("should handle multiple virtual columns in SELECT", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT run_id, execution_duration, is_long_running FROM runs",
+        ctx
+      );
+
+      expect(sql).toContain("run_id");
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at))");
+      expect(sql).toContain("AS execution_duration");
+      expect(sql).toContain(
+        "(if(completed_at IS NOT NULL AND started_at IS NOT NULL, dateDiff('second', started_at, completed_at) > 60, 0))"
+      );
+      expect(sql).toContain("AS is_long_running");
+    });
+
+    it("should mix regular and virtual columns correctly", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT run_id, status, execution_duration, started_at FROM runs",
+        ctx
+      );
+
+      // Regular columns should be normal
+      expect(sql).toMatch(/\brun_id\b/);
+      expect(sql).toMatch(/\bstatus\b/);
+      expect(sql).toMatch(/\bstarted_at\b/);
+      // Virtual column should be expanded
+      expect(sql).toContain(
+        "(dateDiff('millisecond', started_at, completed_at)) AS execution_duration"
+      );
+    });
+  });
+
+  describe("WHERE clause", () => {
+    it("should expand virtual column in WHERE equality", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE execution_duration > 1000", ctx);
+
+      // Virtual column in WHERE should expand without AS
+      expect(sql).toContain("greater((dateDiff('millisecond', started_at, completed_at)), 1000)");
+    });
+
+    it("should expand virtual column in WHERE with comparison operators", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE execution_duration >= 5000", ctx);
+
+      expect(sql).toContain(
+        "greaterOrEquals((dateDiff('millisecond', started_at, completed_at)), 5000)"
+      );
+    });
+
+    it("should expand virtual column in WHERE with multiple conditions", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT * FROM runs WHERE execution_duration > 1000 AND is_long_running = 1",
+        ctx
+      );
+
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at))");
+      expect(sql).toContain(
+        "(if(completed_at IS NOT NULL AND started_at IS NOT NULL, dateDiff('second', started_at, completed_at) > 60, 0))"
+      );
+    });
+
+    it("should expand qualified virtual column in WHERE", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE runs.execution_duration > 1000", ctx);
+
+      expect(sql).toContain("greater((dateDiff('millisecond', started_at, completed_at)), 1000)");
+    });
+  });
+
+  describe("ORDER BY clause", () => {
+    it("should expand virtual column in ORDER BY", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT * FROM runs ORDER BY execution_duration DESC", ctx);
+
+      expect(sql).toContain("ORDER BY (dateDiff('millisecond', started_at, completed_at)) DESC");
+    });
+
+    it("should expand virtual column in ORDER BY with multiple columns", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT * FROM runs ORDER BY status ASC, execution_duration DESC",
+        ctx
+      );
+
+      expect(sql).toContain("status ASC");
+      expect(sql).toContain("(dateDiff('millisecond', started_at, completed_at)) DESC");
+    });
+  });
+
+  describe("GROUP BY clause", () => {
+    it("should use alias for virtual column in GROUP BY", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT is_long_running, count(*) FROM runs GROUP BY is_long_running",
+        ctx
+      );
+
+      // SELECT should have the expression with alias
+      expect(sql).toContain(
+        "(if(completed_at IS NOT NULL AND started_at IS NOT NULL, dateDiff('second', started_at, completed_at) > 60, 0)) AS is_long_running"
+      );
+      // GROUP BY should use the alias, not the expression (ClickHouse allows this)
+      expect(sql).toContain("GROUP BY is_long_running");
+      // Should NOT have the expression in GROUP BY
+      expect(sql).not.toContain("GROUP BY (if(completed_at IS NOT NULL AND started_at IS NOT NULL");
+    });
+
+    it("should use alias for virtual column in GROUP BY with WHERE and aggregation", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery(
+        "SELECT execution_duration, count() AS duration_count FROM runs WHERE execution_duration IS NOT NULL GROUP BY execution_duration ORDER BY duration_count DESC LIMIT 100",
+        ctx
+      );
+
+      // SELECT should have the expression with alias
+      expect(sql).toContain(
+        "(dateDiff('millisecond', started_at, completed_at)) AS execution_duration"
+      );
+      // GROUP BY should use the alias, not the expression
+      expect(sql).toContain("GROUP BY execution_duration");
+      // Should NOT have the expression in GROUP BY
+      expect(sql).not.toContain("GROUP BY (dateDiff('millisecond'");
+      // WHERE should still use the expression
+      expect(sql).toContain("isNotNull((dateDiff('millisecond', started_at, completed_at)))");
+    });
+  });
+
+  describe("Complex expressions", () => {
+    it("should handle arithmetic virtual columns", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT usage_duration_seconds FROM runs", ctx);
+
+      expect(sql).toContain("(usage_duration_ms / 1000.0)");
+      expect(sql).toContain("AS usage_duration_seconds");
+    });
+
+    it("should handle virtual column in arithmetic expression", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT execution_duration / 1000 AS dur_seconds FROM runs", ctx);
+
+      // The virtual column expression should be wrapped in the arithmetic
+      expect(sql).toContain("divide((dateDiff('millisecond', started_at, completed_at)), 1000)");
+      expect(sql).toContain("AS dur_seconds");
+    });
+  });
+
+  describe("Regular columns unchanged", () => {
+    it("should not affect regular columns without expression", () => {
+      const ctx = createVirtualColumnContext();
+      const { sql } = printQuery("SELECT run_id, status, started_at FROM runs", ctx);
+
+      // Regular columns should appear as-is
+      expect(sql).toContain("run_id, status, started_at");
+      // No extra parentheses or AS for regular columns in basic SELECT
+      expect(sql).not.toMatch(/\(run_id\)/);
+      expect(sql).not.toMatch(/\(status\)/);
+    });
+  });
+});
+
+describe("Expression columns with division (cost/invocation_cost pattern)", () => {
+  /**
+   * Schema mimicking the real runsSchema with cost-based expression columns
+   * These use division expressions like base_cost_in_cents / 100.0
+   */
+  const costExpressionSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      cost_in_cents: { name: "cost_in_cents", ...column("Float64") },
+      base_cost_in_cents: { name: "base_cost_in_cents", ...column("Float64") },
+      // Virtual column: compute_cost = cost_in_cents / 100.0
+      compute_cost: {
+        name: "compute_cost",
+        ...column("Float64"),
+        expression: "cost_in_cents / 100.0",
+        description: "Compute cost in dollars",
+      },
+      // Virtual column: invocation_cost = base_cost_in_cents / 100.0
+      invocation_cost: {
+        name: "invocation_cost",
+        ...column("Float64"),
+        expression: "base_cost_in_cents / 100.0",
+        description: "Invocation cost in dollars",
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createCostExpressionContext() {
+    const schema = createSchemaRegistry([costExpressionSchema]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test" },
+      project_id: { op: "eq", value: "proj_test" },
+      environment_id: { op: "eq", value: "env_test" },
+    },
+  });
+}
+
+describe("WHERE clause with division expression columns", () => {
+  it("should expand invocation_cost > 100 to (base_cost_in_cents / 100.0) > 100", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE invocation_cost > 100", ctx);
+
+      // Virtual column should be expanded to its expression in the comparison
+      expect(sql).toContain("greater((base_cost_in_cents / 100.0), 100)");
+    });
+
+    it("should expand invocation_cost >= 0.01 correctly", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE invocation_cost >= 0.01", ctx);
+
+      expect(sql).toContain("greaterOrEquals((base_cost_in_cents / 100.0), 0.01)");
+    });
+
+    it("should expand invocation_cost < 1.5 correctly", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE invocation_cost < 1.5", ctx);
+
+      expect(sql).toContain("less((base_cost_in_cents / 100.0), 1.5)");
+    });
+
+    it("should expand invocation_cost = 0 correctly", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE invocation_cost = 0", ctx);
+
+      expect(sql).toContain("equals((base_cost_in_cents / 100.0), 0)");
+    });
+
+    it("should expand compute_cost in BETWEEN correctly", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs WHERE compute_cost BETWEEN 1.0 AND 10.0", ctx);
+
+      expect(sql).toContain("(cost_in_cents / 100.0) BETWEEN 1 AND 10");
+    });
+
+    it("should handle multiple expression columns in WHERE with AND", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery(
+        "SELECT * FROM runs WHERE invocation_cost > 0.5 AND compute_cost < 5.0",
+        ctx
+      );
+
+      expect(sql).toContain("greater((base_cost_in_cents / 100.0), 0.5)");
+      expect(sql).toContain("less((cost_in_cents / 100.0), 5)");
+    });
+
+    it("should handle expression column with OR condition", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery(
+        "SELECT * FROM runs WHERE invocation_cost > 10 OR status = 'COMPLETED'",
+        ctx
+      );
+
+      expect(sql).toContain("or(");
+      expect(sql).toContain("greater((base_cost_in_cents / 100.0), 10)");
+    });
+  });
+
+  describe("SELECT clause with division expression columns", () => {
+    it("should expand invocation_cost in SELECT with alias", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT run_id, invocation_cost FROM runs", ctx);
+
+      expect(sql).toContain("(base_cost_in_cents / 100.0) AS invocation_cost");
+    });
+
+    it("should expand both cost columns correctly", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT compute_cost, invocation_cost FROM runs", ctx);
+
+      expect(sql).toContain("(cost_in_cents / 100.0) AS compute_cost");
+      expect(sql).toContain("(base_cost_in_cents / 100.0) AS invocation_cost");
+    });
+  });
+
+  describe("ORDER BY clause with division expression columns", () => {
+    it("should expand invocation_cost in ORDER BY DESC", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs ORDER BY invocation_cost DESC", ctx);
+
+      expect(sql).toContain("ORDER BY (base_cost_in_cents / 100.0) DESC");
+    });
+
+    it("should expand compute_cost in ORDER BY ASC", () => {
+      const ctx = createCostExpressionContext();
+      const { sql } = printQuery("SELECT * FROM runs ORDER BY compute_cost ASC", ctx);
+
+      expect(sql).toContain("ORDER BY (cost_in_cents / 100.0) ASC");
+    });
+  });
+});
+
+describe("Column metadata", () => {
+  /**
+   * Schema with customRenderType for testing
+   */
+  const schemaWithRenderTypes: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      friendly_id: { name: "friendly_id", ...column("String") },
+      status: {
+        name: "status",
+        ...column("LowCardinality(String)"),
+        customRenderType: "runStatus",
+      },
+      created_at: { name: "created_at", ...column("DateTime64") },
+      started_at: { name: "started_at", ...column("Nullable(DateTime64)") },
+      completed_at: { name: "completed_at", ...column("Nullable(DateTime64)") },
+      usage_duration_ms: {
+        name: "usage_duration_ms",
+        ...column("UInt32"),
+        customRenderType: "duration",
+      },
+      cost_in_cents: {
+        name: "cost_in_cents",
+        ...column("Float64"),
+        customRenderType: "cost",
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+      is_test: { name: "is_test", ...column("UInt8") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createMetadataTestContext() {
+    const schema = createSchemaRegistry([schemaWithRenderTypes]);
+  return createPrinterContext({
+    schema,
+    enforcedWhereClause: {
+      organization_id: { op: "eq", value: "org_test" },
+      project_id: { op: "eq", value: "proj_test" },
+      environment_id: { op: "eq", value: "env_test" },
+    },
+  });
+}
+
+describe("Basic column metadata", () => {
+  it("should return column metadata for simple field references", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT run_id, created_at FROM runs", ctx);
+
+      expect(columns).toHaveLength(2);
+      expect(columns[0]).toEqual({
+        name: "run_id",
+        type: "String",
+      });
+      expect(columns[1]).toEqual({
+        name: "created_at",
+        type: "DateTime64",
+      });
+    });
+
+    it("should include customRenderType when defined in schema", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT status, usage_duration_ms, cost_in_cents FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(3);
+      expect(columns[0]).toEqual({
+        name: "status",
+        type: "LowCardinality(String)",
+        customRenderType: "runStatus",
+        format: "runStatus",
+      });
+      expect(columns[1]).toEqual({
+        name: "usage_duration_ms",
+        type: "UInt32",
+        customRenderType: "duration",
+        format: "duration",
+      });
+      expect(columns[2]).toEqual({
+        name: "cost_in_cents",
+        type: "Float64",
+        customRenderType: "cost",
+        format: "cost",
+      });
+    });
+
+    it("should use alias as output name when AS is used", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT run_id AS id, status AS run_status FROM runs", ctx);
+
+      expect(columns).toHaveLength(2);
+      expect(columns[0].name).toBe("id");
+      expect(columns[0].type).toBe("String");
+      expect(columns[1].name).toBe("run_status");
+      expect(columns[1].type).toBe("LowCardinality(String)");
+      expect(columns[1].customRenderType).toBe("runStatus");
+    });
+  });
+
+  describe("Type inference for aggregations", () => {
+    it("should infer UInt64 for COUNT", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT(*) AS total FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("total");
+      expect(columns[0].type).toBe("UInt64");
+    });
+
+    it("should infer UInt64 for COUNT with column", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT(run_id) AS run_count FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("run_count");
+      expect(columns[0].type).toBe("UInt64");
+    });
+
+    it("should infer Float64 for AVG", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT AVG(usage_duration_ms) AS avg_duration FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("avg_duration");
+      expect(columns[0].type).toBe("Float64");
+    });
+
+    it("should infer Int64 for SUM", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT SUM(usage_duration_ms) AS total_duration FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("total_duration");
+      expect(columns[0].type).toBe("Int64");
+    });
+
+    it("should preserve column type for MIN/MAX", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT MIN(created_at) AS first_run, MAX(created_at) AS last_run FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(2);
+      expect(columns[0].name).toBe("first_run");
+      expect(columns[0].type).toBe("DateTime64");
+      expect(columns[1].name).toBe("last_run");
+      expect(columns[1].type).toBe("DateTime64");
+    });
+  });
+
+  describe("Type inference for computed expressions", () => {
+    it("should infer Int64 for dateDiff", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT dateDiff('millisecond', started_at, completed_at) AS duration FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("duration");
+      expect(columns[0].type).toBe("Int64");
+    });
+
+    it("should infer Float64 for division", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT usage_duration_ms / 1000 AS duration_seconds FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("duration_seconds");
+      expect(columns[0].type).toBe("Float64");
+    });
+
+    it("should infer Int64 for integer arithmetic", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT usage_duration_ms + 100 AS adjusted_duration FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("adjusted_duration");
+      // UInt32 + Int64 constant = Int64
+      expect(columns[0].type).toBe("Int64");
+    });
+
+    it("should infer String for string functions", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT concat(run_id, '-', status) AS combined FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("combined");
+      expect(columns[0].type).toBe("String");
+    });
+  });
+
+  describe("Mixed columns with and without customRenderType", () => {
+    it("should handle a mix of regular and custom-rendered columns", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT run_id, status, created_at, usage_duration_ms, cost_in_cents FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(5);
+
+      // run_id - no customRenderType
+      expect(columns[0].name).toBe("run_id");
+      expect(columns[0].type).toBe("String");
+      expect(columns[0].customRenderType).toBeUndefined();
+
+      // status - has customRenderType
+      expect(columns[1].name).toBe("status");
+      expect(columns[1].customRenderType).toBe("runStatus");
+
+      // created_at - no customRenderType
+      expect(columns[2].name).toBe("created_at");
+      expect(columns[2].type).toBe("DateTime64");
+      expect(columns[2].customRenderType).toBeUndefined();
+
+      // usage_duration_ms - has customRenderType
+      expect(columns[3].name).toBe("usage_duration_ms");
+      expect(columns[3].customRenderType).toBe("duration");
+
+      // cost_in_cents - has customRenderType
+      expect(columns[4].name).toBe("cost_in_cents");
+      expect(columns[4].customRenderType).toBe("cost");
+    });
+
+    it("should handle aggregations mixed with regular columns", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT status, COUNT(*) AS count, AVG(usage_duration_ms) AS avg_duration FROM runs GROUP BY status",
+        ctx
+      );
+
+      expect(columns).toHaveLength(3);
+
+      // status - from schema with customRenderType
+      expect(columns[0].name).toBe("status");
+      expect(columns[0].customRenderType).toBe("runStatus");
+
+      // count - aggregation inferred type, COUNT doesn't preserve customRenderType
+      expect(columns[1].name).toBe("count");
+      expect(columns[1].type).toBe("UInt64");
+      expect(columns[1].customRenderType).toBeUndefined();
+
+      // avg_duration - aggregation inferred type, AVG preserves customRenderType from source column
+      // (average duration is still a duration)
+      expect(columns[2].name).toBe("avg_duration");
+      expect(columns[2].type).toBe("Float64");
+      expect(columns[2].customRenderType).toBe("duration");
+    });
+
+    it("should propagate customRenderType for value-preserving aggregates (SUM, AVG, MIN, MAX)", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT SUM(usage_duration_ms) AS total_duration, AVG(cost_in_cents) AS avg_cost, MIN(usage_duration_ms) AS min_duration, MAX(cost_in_cents) AS max_cost FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(4);
+
+      // SUM preserves customRenderType
+      expect(columns[0].name).toBe("total_duration");
+      expect(columns[0].customRenderType).toBe("duration");
+
+      // AVG preserves customRenderType
+      expect(columns[1].name).toBe("avg_cost");
+      expect(columns[1].customRenderType).toBe("cost");
+
+      // MIN preserves customRenderType
+      expect(columns[2].name).toBe("min_duration");
+      expect(columns[2].customRenderType).toBe("duration");
+
+      // MAX preserves customRenderType
+      expect(columns[3].name).toBe("max_cost");
+      expect(columns[3].customRenderType).toBe("cost");
+    });
+
+    it("should NOT propagate customRenderType for COUNT aggregates", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT COUNT(*), COUNT(usage_duration_ms), COUNT(DISTINCT status) FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(3);
+
+      // COUNT(*) - no customRenderType
+      expect(columns[0].customRenderType).toBeUndefined();
+
+      // COUNT(duration_column) - still no customRenderType (it's a count, not a duration)
+      expect(columns[1].customRenderType).toBeUndefined();
+
+      // COUNT(DISTINCT ...) - no customRenderType
+      expect(columns[2].customRenderType).toBeUndefined();
+    });
+  });
+
+  describe("Implicit column names for expressions without aliases", () => {
+    it("should generate implicit name for COUNT()", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT() FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("count");
+      expect(columns[0].type).toBe("UInt64");
+    });
+
+    it("should generate implicit name for COUNT(*)", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT(*) FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("count");
+      expect(columns[0].type).toBe("UInt64");
+    });
+
+    it("should generate implicit name for COUNT with column argument", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT(run_id) FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("count");
+      expect(columns[0].type).toBe("UInt64");
+    });
+
+    it("should generate implicit name for SUM", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT SUM(usage_duration_ms) FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("sum");
+      expect(columns[0].type).toBe("Int64");
+    });
+
+    it("should generate implicit name for AVG", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT AVG(usage_duration_ms) FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("avg");
+      expect(columns[0].type).toBe("Float64");
+    });
+
+    it("should generate implicit names for multiple aggregations without aliases", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT COUNT(), status FROM runs GROUP BY status", ctx);
+
+      expect(columns).toHaveLength(2);
+      expect(columns[0].name).toBe("count");
+      expect(columns[0].type).toBe("UInt64");
+      expect(columns[1].name).toBe("status");
+      expect(columns[1].type).toBe("LowCardinality(String)");
+    });
+
+    it("should generate implicit name for arithmetic expressions", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT usage_duration_ms + 100 FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("plus");
+    });
+
+    it("should generate implicit name for constant values", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT 42, 'hello' FROM runs", ctx);
+
+      expect(columns).toHaveLength(2);
+      expect(columns[0].name).toBe("42");
+      expect(columns[1].name).toBe("'hello'");
+    });
+
+    it("should mix explicit aliases with implicit names", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT COUNT() AS total, AVG(usage_duration_ms), status AS run_status FROM runs GROUP BY status",
+        ctx
+      );
+
+      expect(columns).toHaveLength(3);
+      expect(columns[0].name).toBe("total");
+      expect(columns[1].name).toBe("avg");
+      expect(columns[2].name).toBe("run_status");
+    });
+
+    it("should add AS clause to generated SQL for implicit names", () => {
+      const ctx = createMetadataTestContext();
+      const { sql, columns } = printQuery("SELECT COUNT(), status FROM runs GROUP BY status", ctx);
+
+      // The SQL should include an explicit AS clause for the COUNT()
+      expect(sql).toContain("count() AS count");
+      expect(columns[0].name).toBe("count");
+    });
+
+    it("should add AS clause for multiple aggregations", () => {
+      const ctx = createMetadataTestContext();
+      const { sql, columns } = printQuery(
+        "SELECT COUNT(), SUM(usage_duration_ms), AVG(usage_duration_ms) FROM runs",
+        ctx
+      );
+
+      // All aggregations should have AS clauses
+      expect(sql).toContain("count() AS count");
+      expect(sql).toContain("sum(usage_duration_ms) AS sum");
+      expect(sql).toContain("avg(usage_duration_ms) AS avg");
+      expect(columns).toHaveLength(3);
+      expect(columns[0].name).toBe("count");
+      expect(columns[1].name).toBe("sum");
+      expect(columns[2].name).toBe("avg");
+    });
+  });
+
+  describe("prettyFormat()", () => {
+    it("should strip prettyFormat from SQL and attach format to column metadata", () => {
+      const ctx = createMetadataTestContext();
+      const { sql, columns } = printQuery(
+        "SELECT prettyFormat(usage_duration_ms, 'bytes') AS memory FROM runs",
+        ctx
+      );
+
+      // SQL should not contain prettyFormat
+      expect(sql).not.toContain("prettyFormat");
+      expect(sql).toContain("usage_duration_ms");
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("memory");
+      expect(columns[0].format).toBe("bytes");
+    });
+
+    it("should work with aggregation wrapping", () => {
+      const ctx = createMetadataTestContext();
+      const { sql, columns } = printQuery(
+        "SELECT prettyFormat(avg(usage_duration_ms), 'bytes') AS avg_memory FROM runs",
+        ctx
+      );
+
+      expect(sql).not.toContain("prettyFormat");
+      expect(sql).toContain("avg(usage_duration_ms)");
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("avg_memory");
+      expect(columns[0].format).toBe("bytes");
+      expect(columns[0].type).toBe("Float64");
+    });
+
+    it("should work without explicit alias", () => {
+      const ctx = createMetadataTestContext();
+      const { sql, columns } = printQuery(
+        "SELECT prettyFormat(usage_duration_ms, 'percent') FROM runs",
+        ctx
+      );
+
+      expect(sql).not.toContain("prettyFormat");
+      expect(columns).toHaveLength(1);
+      expect(columns[0].name).toBe("usage_duration_ms");
+      expect(columns[0].format).toBe("percent");
+    });
+
+    it("should throw for invalid format type", () => {
+      const ctx = createMetadataTestContext();
+      expect(() => {
+        printQuery(
+          "SELECT prettyFormat(usage_duration_ms, 'invalid') FROM runs",
+          ctx
+        );
+      }).toThrow(QueryError);
+      expect(() => {
+        printQuery(
+          "SELECT prettyFormat(usage_duration_ms, 'invalid') FROM runs",
+          ctx
+        );
+      }).toThrow(/Unknown format type/);
+    });
+
+    it("should throw for wrong argument count", () => {
+      const ctx = createMetadataTestContext();
+      expect(() => {
+        printQuery("SELECT prettyFormat(usage_duration_ms) FROM runs", ctx);
+      }).toThrow(QueryError);
+      expect(() => {
+        printQuery("SELECT prettyFormat(usage_duration_ms) FROM runs", ctx);
+      }).toThrow(/requires exactly 2 arguments/);
+    });
+
+    it("should throw when second argument is not a string literal", () => {
+      const ctx = createMetadataTestContext();
+      expect(() => {
+        printQuery(
+          "SELECT prettyFormat(usage_duration_ms, 123) FROM runs",
+          ctx
+        );
+      }).toThrow(QueryError);
+      expect(() => {
+        printQuery(
+          "SELECT prettyFormat(usage_duration_ms, 123) FROM runs",
+          ctx
+        );
+      }).toThrow(/must be a string literal/);
+    });
+
+    it("should override schema-level customRenderType", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT prettyFormat(usage_duration_ms, 'bytes') AS mem FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(1);
+      // prettyFormat's format should take precedence
+      expect(columns[0].format).toBe("bytes");
+      // customRenderType from schema should NOT be set since prettyFormat overrides
+      // The source column had customRenderType: "duration" but prettyFormat replaces it
+    });
+
+    it("should auto-populate format from customRenderType when not explicitly set", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery(
+        "SELECT usage_duration_ms, cost_in_cents FROM runs",
+        ctx
+      );
+
+      expect(columns).toHaveLength(2);
+      // customRenderType should auto-populate format
+      expect(columns[0].customRenderType).toBe("duration");
+      expect(columns[0].format).toBe("duration");
+      expect(columns[1].customRenderType).toBe("cost");
+      expect(columns[1].format).toBe("cost");
+    });
+
+    it("should not set format when column has no customRenderType", () => {
+      const ctx = createMetadataTestContext();
+      const { columns } = printQuery("SELECT run_id FROM runs", ctx);
+
+      expect(columns).toHaveLength(1);
+      expect(columns[0].format).toBeUndefined();
+      expect(columns[0].customRenderType).toBeUndefined();
+    });
+  });
+});
+
+describe("Unknown column blocking", () => {
+  /**
+   * These tests verify that unknown columns are blocked at compile time,
+   * preventing access to internal ClickHouse columns that aren't exposed in the schema.
+   */
+
+  describe("should block unknown columns in SELECT", () => {
+    it("should throw error for unknown column in SELECT list", () => {
+      expect(() => {
+        printQuery("SELECT id, unknown_column FROM task_runs");
+      }).toThrow(QueryError);
+      expect(() => {
+        printQuery("SELECT id, unknown_column FROM task_runs");
+      }).toThrow(/unknown.*column.*unknown_column/i);
+    });
+
+    it("should throw error for internal ClickHouse column name not in schema", () => {
+      // The schema exposes 'created' but the internal ClickHouse column is 'created_at'
+      // Using the internal name directly should be blocked
+      const schema = createSchemaRegistry([runsSchema]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test" },
+          project_id: { op: "eq", value: "proj_test" },
+          environment_id: { op: "eq", value: "env_test" },
+        },
+      });
+
+      // 'created_at' is not in runsSchema - only 'created' which maps to 'created_at'
+      expect(() => {
+        printQuery("SELECT id, created_at FROM runs", ctx);
+      }).toThrow(QueryError);
+    });
+
+    it("should suggest TSQL column name when user types ClickHouse column name", () => {
+      // The schema exposes 'created' but the internal ClickHouse column is 'created_at'
+      // When user types 'created_at', we should suggest 'created'
+      const schema = createSchemaRegistry([runsSchema]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test" },
+          project_id: { op: "eq", value: "proj_test" },
+          environment_id: { op: "eq", value: "env_test" },
+        },
+      });
+
+      expect(() => {
+        printQuery("SELECT id, created_at FROM runs", ctx);
+      }).toThrow(/Did you mean "created"/);
+    });
+
+    it("should throw error for unknown qualified column (table.column)", () => {
+      expect(() => {
+        printQuery("SELECT task_runs.unknown_column FROM task_runs");
+      }).toThrow(QueryError);
+    });
+  });
+
+  describe("should block unknown columns in WHERE", () => {
+    it("should throw error for unknown column in WHERE clause", () => {
+      expect(() => {
+        printQuery("SELECT id FROM task_runs WHERE unknown_column = 'test'");
+      }).toThrow(QueryError);
+    });
+
+    it("should throw error for unknown column in complex WHERE", () => {
+      expect(() => {
+        printQuery("SELECT id FROM task_runs WHERE status = 'completed' AND unknown_column > 10");
+      }).toThrow(QueryError);
+    });
+  });
+
+  describe("should block unknown columns in ORDER BY", () => {
+    it("should throw error for unknown column in ORDER BY", () => {
+      expect(() => {
+        printQuery("SELECT id, status FROM task_runs ORDER BY unknown_column DESC");
+      }).toThrow(QueryError);
+    });
+  });
+
+  describe("should block unknown columns in GROUP BY", () => {
+    it("should throw error for unknown column in GROUP BY", () => {
+      expect(() => {
+        printQuery("SELECT count(*) FROM task_runs GROUP BY unknown_column");
+      }).toThrow(QueryError);
+    });
+  });
+
+  describe("should allow SELECT aliases", () => {
+    it("should allow ORDER BY to reference aliased columns", () => {
+      // This should NOT throw - 'cnt' is a valid alias from SELECT
+      const { sql } = printQuery(
+        "SELECT status, count(*) AS cnt FROM task_runs GROUP BY status ORDER BY cnt DESC"
+      );
+      expect(sql).toContain("ORDER BY cnt DESC");
+    });
+
+    it("should allow HAVING to reference aliased columns", () => {
+      const { sql } = printQuery(
+        "SELECT status, count(*) AS cnt FROM task_runs GROUP BY status HAVING cnt > 10"
+      );
+      expect(sql).toContain("HAVING");
+    });
+
+    it("should allow ORDER BY to reference implicit aggregation names", () => {
+      // COUNT() without alias gets implicit name 'count'
+      const { sql } = printQuery(
+        "SELECT status, count() FROM task_runs GROUP BY status ORDER BY count DESC"
+      );
+      expect(sql).toContain("ORDER BY count DESC");
+    });
+  });
+
+  // Note: CTE support is limited - CTEs are not added to the table context,
+  // so CTE column references are treated as unknown. This is a pre-existing limitation.
+  // The tests below verify that unknown column blocking doesn't break existing behavior.
+
+  describe("should allow subquery alias references", () => {
+    it("should allow referencing columns from subquery in FROM clause", () => {
+      const { sql } = printQuery(`
+        SELECT sub.status_name, sub.total
+        FROM (
+          SELECT status AS status_name, count(*) AS total
+          FROM task_runs
+          GROUP BY status
+        ) AS sub
+        ORDER BY sub.total DESC
+      `);
+      expect(sql).toContain("status_name");
+      expect(sql).toContain("total");
+    });
+
+    it("should allow unqualified references to subquery columns", () => {
+      const { sql } = printQuery(`
+        SELECT status_name, total
+        FROM (
+          SELECT status AS status_name, count(*) AS total
+          FROM task_runs
+          GROUP BY status
+        )
+        WHERE total > 10
+      `);
+      expect(sql).toContain("status_name");
+      expect(sql).toContain("total");
+    });
+  });
+});
+
+describe("Field Mapping Value Transformation", () => {
+  // Test schema with a field mapping column
+  const fieldMappingSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      run_id: { name: "run_id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      project_ref: {
+        name: "project_ref",
+        clickhouseName: "project_id",
+        ...column("String"),
+        fieldMapping: "project",
+      },
+      environment_id: { name: "environment_id", ...column("String") },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  function createFieldMappingContext(): PrinterContext {
+    const schemaRegistry = createSchemaRegistry([fieldMappingSchema]);
+    return new PrinterContext(
+      schemaRegistry,
+      {},
+      {
+        project: {
+          proj_tenant1: "my-project-ref",
+          proj_other: "other-project",
+        },
+      },
+      {
+        organization_id: { op: "eq", value: "org_123" },
+        project_id: { op: "eq", value: "proj_456" },
+        environment_id: { op: "eq", value: "env_789" },
+      }
+    );
+  }
+
+  function printQuery(query: string, ctx: PrinterContext): PrintResult {
+    const ast = parseTSQLSelect(query);
+    const printer = new ClickHousePrinter(ctx);
+    return printer.print(ast);
+  }
+
+  it("should transform field mapping values in WHERE clause with equals", () => {
+    const ctx = createFieldMappingContext();
+    const { sql, params } = printQuery(
+      "SELECT run_id FROM runs WHERE project_ref = 'my-project-ref'",
+      ctx
+    );
+
+    // The value should be transformed to the internal value
+    expect(sql).toContain("project_id");
+    expect(Object.values(params)).toContain("proj_tenant1");
+    expect(Object.values(params)).not.toContain("my-project-ref");
+  });
+
+  it("should transform field mapping values in WHERE clause with IN list", () => {
+    const ctx = createFieldMappingContext();
+    const { sql, params } = printQuery(
+      "SELECT run_id FROM runs WHERE project_ref IN ('my-project-ref', 'other-project')",
+      ctx
+    );
+
+    expect(sql).toContain("project_id");
+    const paramValues = Object.values(params);
+    expect(paramValues).toContain("proj_tenant1");
+    expect(paramValues).toContain("proj_other");
+    expect(paramValues).not.toContain("my-project-ref");
+    expect(paramValues).not.toContain("other-project");
+  });
+
+  it("should be case-insensitive when transforming field mapping values", () => {
+    const ctx = createFieldMappingContext();
+    // Using uppercase version of the external value
+    const { params } = printQuery(
+      "SELECT run_id FROM runs WHERE project_ref = 'MY-PROJECT-REF'",
+      ctx
+    );
+
+    // Should still transform to the internal value
+    expect(Object.values(params)).toContain("proj_tenant1");
+  });
+
+  it("should pass through unmapped values unchanged", () => {
+    const ctx = createFieldMappingContext();
+    // Using a value that's not in the mapping
+    const { params } = printQuery("SELECT run_id FROM runs WHERE project_ref = 'unknown-ref'", ctx);
+
+    // Value should remain unchanged since it's not in the mapping
+    expect(Object.values(params)).toContain("unknown-ref");
+  });
+
+  it("should use clickhouseName when selecting field mapping column", () => {
+    const ctx = createFieldMappingContext();
+    const { sql } = printQuery("SELECT project_ref FROM runs", ctx);
+
+    // Should use the actual ClickHouse column name (project_id) in the SQL
+    expect(sql).toContain("project_id");
+    // But the column metadata should use the exposed name
+  });
+});
+
+describe("Internal-only column blocking", () => {
+  /**
+   * These tests verify that internal columns (tenant columns, required filter columns)
+   * that are NOT exposed in tableSchema.columns are blocked from user queries in
+   * SELECT, ORDER BY, GROUP BY, and HAVING clauses, but allowed in system-generated
+   * tenant isolation guards.
+   */
+
+  // Schema with hidden tenant columns (not exposed in public columns)
+  const hiddenTenantSchema: TableSchema = {
+    name: "hidden_tenant_runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      // Public columns - these are exposed to users
+      id: { name: "id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      task_identifier: { name: "task_identifier", ...column("String") },
+      created_at: { name: "created_at", ...column("DateTime64") },
+    },
+    // Tenant columns are NOT in the public columns above
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  // Schema with hidden required filter column
+  const hiddenFilterSchema: TableSchema = {
+    name: "hidden_filter_runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    columns: {
+      id: { name: "id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      created_at: { name: "created_at", ...column("DateTime64") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+    requiredFilters: [
+      { column: "engine", value: "V2" }, // 'engine' is not in public columns
+    ],
+  };
+
+  function createHiddenTenantContext(): PrinterContext {
+    const schema = createSchemaRegistry([hiddenTenantSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  function createHiddenFilterContext(): PrinterContext {
+    const schema = createSchemaRegistry([hiddenFilterSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test" },
+        project_id: { op: "eq", value: "proj_test" },
+        environment_id: { op: "eq", value: "env_test" },
+      },
+    });
+  }
+
+  describe("should block internal-only columns in SELECT", () => {
+    it("should throw error when selecting hidden tenant column (organization_id)", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery("SELECT id, organization_id FROM hidden_tenant_runs", ctx);
+      }).toThrow(QueryError);
+      expect(() => {
+        printQuery("SELECT id, organization_id FROM hidden_tenant_runs", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+
+    it("should throw error when selecting hidden tenant column (project_id)", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery("SELECT project_id FROM hidden_tenant_runs", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+
+    it("should throw error when selecting hidden tenant column (environment_id)", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery("SELECT environment_id FROM hidden_tenant_runs", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+
+    it("should throw error when selecting hidden required filter column", () => {
+      const ctx = createHiddenFilterContext();
+      expect(() => {
+        printQuery("SELECT id, engine FROM hidden_filter_runs", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+  });
+
+  describe("should block internal-only columns in ORDER BY", () => {
+    it("should throw error when ordering by hidden tenant column", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery("SELECT id, status FROM hidden_tenant_runs ORDER BY organization_id", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+
+    it("should throw error when ordering by hidden required filter column", () => {
+      const ctx = createHiddenFilterContext();
+      expect(() => {
+        printQuery("SELECT id, status FROM hidden_filter_runs ORDER BY engine", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+  });
+
+  describe("should block internal-only columns in GROUP BY", () => {
+    it("should throw error when grouping by hidden tenant column", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery("SELECT count(*) FROM hidden_tenant_runs GROUP BY organization_id", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+
+    it("should throw error when grouping by hidden required filter column", () => {
+      const ctx = createHiddenFilterContext();
+      expect(() => {
+        printQuery("SELECT count(*) FROM hidden_filter_runs GROUP BY engine", ctx);
+      }).toThrow(/not available for querying/i);
+    });
+  });
+
+  describe("should block internal-only columns in HAVING", () => {
+    it("should throw error when using hidden column in HAVING", () => {
+      const ctx = createHiddenTenantContext();
+      expect(() => {
+        printQuery(
+          "SELECT status, count(*) as cnt FROM hidden_tenant_runs GROUP BY status HAVING organization_id = 'x'",
+          ctx
+        );
+      }).toThrow(/not available for querying/i);
+    });
+  });
+
+  describe("should allow tenant guard in WHERE clause", () => {
+    it("should successfully execute query with tenant isolation (hidden tenant columns work internally)", () => {
+      const ctx = createHiddenTenantContext();
+      // This should succeed - the tenant guard is injected internally and should work
+      const { sql } = printQuery("SELECT id, status FROM hidden_tenant_runs", ctx);
+
+      // Verify tenant guards are present in WHERE clause
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+      // But NOT in SELECT
+      expect(sql).toMatch(/SELECT\s+id,\s*status\s+FROM/i);
+    });
+
+    it("should successfully execute query with required filter (hidden filter columns work internally)", () => {
+      const ctx = createHiddenFilterContext();
+      const { sql, params } = printQuery("SELECT id, status FROM hidden_filter_runs", ctx);
+
+      // Verify required filter is present in WHERE clause
+      expect(sql).toContain("engine");
+      // The value V2 is parameterized, check that it's in the params
+      expect(Object.values(params)).toContain("V2");
+    });
+  });
+
+  describe("should allow exposed tenant columns", () => {
+    // In task_runs schema, tenant columns ARE exposed in the public columns
+    it("should allow selecting exposed tenant column", () => {
+      // task_runs schema exposes organization_id in its columns
+      const { sql } = printQuery("SELECT id, organization_id FROM task_runs");
+      expect(sql).toContain("SELECT id, organization_id");
+    });
+
+    it("should allow ordering by exposed tenant column", () => {
+      const { sql } = printQuery("SELECT id, status FROM task_runs ORDER BY organization_id");
+      expect(sql).toContain("ORDER BY organization_id");
+    });
+
+    it("should allow grouping by exposed tenant column", () => {
+      const { sql } = printQuery("SELECT organization_id, count(*) FROM task_runs GROUP BY organization_id");
+      expect(sql).toContain("GROUP BY organization_id");
+    });
+  });
+});
+
+describe("Required Filters", () => {
+  /**
+   * Tests for tables with requiredFilters, which inject internal ClickHouse
+   * column conditions (like engine = 'V2') that aren't exposed in the schema.
+   */
+
+  const schemaWithRequiredFilters: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    description: "Task runs table with required filters",
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+    requiredFilters: [{ column: "engine", value: "V2" }],
+    columns: {
+      run_id: {
+        name: "run_id",
+        clickhouseName: "friendly_id",
+        ...column("String", { description: "Run ID", coreColumn: true }),
+      },
+      status: {
+        name: "status",
+        ...column("String", { description: "Status" }),
+      },
+      triggered_at: {
+        name: "triggered_at",
+        clickhouseName: "created_at",
+        ...column("DateTime64", { description: "When the run was triggered", coreColumn: true }),
+      },
+      total_cost: {
+        name: "total_cost",
+        ...column("Float64", { description: "Total cost" }),
+        expression: "(cost_in_cents + base_cost_in_cents) / 100.0",
+      },
+    },
+  };
+
+  function createRequiredFiltersContext(): PrinterContext {
+    const schemaRegistry = createSchemaRegistry([schemaWithRequiredFilters]);
+    return createPrinterContext({
+      schema: schemaRegistry,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test123" },
+        project_id: { op: "eq", value: "proj_test456" },
+        environment_id: { op: "eq", value: "env_test789" },
+      },
+    });
+  }
+
+  function printQueryWithFilters(query: string): PrintResult {
+    const ctx = createRequiredFiltersContext();
+    const ast = parseTSQLSelect(query);
+    const printer = new ClickHousePrinter(ctx);
+    return printer.print(ast);
+  }
+
+  it("should NOT throw for internal engine column from requiredFilters", () => {
+    // This query should work even though 'engine' is not in the schema
+    // because it's automatically injected by requiredFilters
+    const { sql, params } = printQueryWithFilters("SELECT run_id, status FROM runs LIMIT 10");
+
+    // The engine filter should be in the WHERE clause
+    expect(sql).toContain("engine");
+    // The V2 value is parameterized, so check the params
+    expect(Object.values(params)).toContain("V2");
+  });
+
+  it("should allow TSQL column names that map to different ClickHouse names", () => {
+    // User writes 'triggered_at' but it maps to 'created_at' in ClickHouse
+    const { sql } = printQueryWithFilters(`
+      SELECT run_id, status, triggered_at
+      FROM runs
+      WHERE triggered_at > now() - INTERVAL 14 DAY
+      ORDER BY triggered_at DESC
+      LIMIT 100
+    `);
+
+    // The ClickHouse SQL should use 'created_at' instead of 'triggered_at'
+    expect(sql).toContain("created_at");
+    // The result should still have the alias for the user-friendly name
+    expect(sql).toContain("AS triggered_at");
+  });
+
+  it("should allow filtering by mapped column name", () => {
+    const { sql } = printQueryWithFilters(`
+      SELECT run_id FROM runs WHERE triggered_at > '2024-01-01' LIMIT 10
+    `);
+
+    // Should use the ClickHouse column name in the WHERE clause
+    expect(sql).toContain("created_at");
+  });
+
+  it("should allow ORDER BY on mapped column name", () => {
+    const { sql } = printQueryWithFilters(`
+      SELECT run_id FROM runs ORDER BY triggered_at DESC LIMIT 10
+    `);
+
+    // ORDER BY should use the ClickHouse column name
+    expect(sql).toContain("ORDER BY");
+    expect(sql).toContain("created_at");
+  });
+
+  it("should handle virtual columns with expressions", () => {
+    const { sql } = printQueryWithFilters(`
+      SELECT run_id, total_cost FROM runs ORDER BY total_cost DESC LIMIT 10
+    `);
+
+    // Virtual column should be expanded to its expression with an alias
+    expect(sql).toContain("cost_in_cents");
+    expect(sql).toContain("base_cost_in_cents");
+    expect(sql).toContain("AS total_cost");
+  });
+
+  it("should combine tenant guards with required filters", () => {
+    const { sql, params } = printQueryWithFilters("SELECT run_id FROM runs LIMIT 10");
+
+    // Should have all tenant columns AND the engine filter
+    expect(sql).toContain("organization_id");
+    expect(sql).toContain("project_id");
+    expect(sql).toContain("environment_id");
+    expect(sql).toContain("engine");
+    // The V2 value is parameterized, so check the params
+    expect(Object.values(params)).toContain("V2");
+  });
+
+  it("should allow complex queries with mapped columns", () => {
+    // This query is similar to what a user might write
+    const { sql } = printQueryWithFilters(`
+      SELECT
+        run_id,
+        status,
+        total_cost,
+        triggered_at
+      FROM runs
+      WHERE triggered_at > now() - INTERVAL 14 DAY
+      ORDER BY total_cost DESC
+      LIMIT 100
+    `);
+
+    // All should work without errors
+    expect(sql).toContain("friendly_id");  // run_id maps to friendly_id
+    expect(sql).toContain("status");
+    expect(sql).toContain("created_at");   // triggered_at maps to created_at
+    expect(sql).toContain("cost_in_cents"); // total_cost is a virtual column
+  });
+});
+
+// ============================================================
+// timeBucket() Tests
+// ============================================================
+
+describe("timeBucket()", () => {
+  /**
+   * Schema with timeConstraint for timeBucket() tests.
+   * Uses column mapping: TSQL "triggered_at" → ClickHouse "created_at"
+   */
+  const timeBucketSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    timeConstraint: "triggered_at",
+    columns: {
+      id: { name: "id", ...column("String") },
+      status: { name: "status", ...column("String") },
+      triggered_at: {
+        name: "triggered_at",
+        clickhouseName: "created_at",
+        ...column("DateTime64"),
+      },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  /**
+   * Schema without timeConstraint (for error tests)
+   */
+  const noTimeConstraintSchema: TableSchema = {
+    name: "events",
+    clickhouseName: "trigger_dev.events_v1",
+    columns: {
+      id: { name: "id", ...column("String") },
+      event_type: { name: "event_type", ...column("String") },
+      organization_id: { name: "organization_id", ...column("String") },
+      project_id: { name: "project_id", ...column("String") },
+      environment_id: { name: "environment_id", ...column("String") },
+    },
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+
+  /** 7-day time range: should produce 6 HOUR buckets */
+  const sevenDayRange = {
+    from: new Date("2024-01-01T00:00:00Z"),
+    to: new Date("2024-01-08T00:00:00Z"),
+  };
+
+  /** 1-hour time range: should produce 1 MINUTE buckets */
+  const oneHourRange = {
+    from: new Date("2024-01-01T00:00:00Z"),
+    to: new Date("2024-01-01T01:00:00Z"),
+  };
+
+  function createTimeBucketContext(
+    overrides: Partial<Parameters<typeof createPrinterContext>[0]> = {}
+  ): PrinterContext {
+    const schema = createSchemaRegistry([timeBucketSchema]);
+    return createPrinterContext({
+      schema,
+      enforcedWhereClause: {
+        organization_id: { op: "eq", value: "org_test123" },
+        project_id: { op: "eq", value: "proj_test456" },
+        environment_id: { op: "eq", value: "env_test789" },
+      },
+      timeRange: sevenDayRange,
+      ...overrides,
+    });
+  }
+
+  function printTimeBucketQuery(query: string, context?: PrinterContext) {
+    const ast = parseTSQLSelect(query);
+    const ctx = context ?? createTimeBucketContext();
+    return printToClickHouse(ast, ctx);
+  }
+
+  describe("SELECT with timeBucket()", () => {
+    it("should compile timeBucket() to toStartOfInterval with correct column and interval", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket"
+      );
+
+      // Should use ClickHouse column name (created_at), not TSQL name (triggered_at)
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+      expect(sql).toContain("count()");
+    });
+
+    it("should use 1 MINUTE interval for 1-hour time range", () => {
+      const ctx = createTimeBucketContext({ timeRange: oneHourRange });
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket",
+        ctx
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 1 MINUTE)");
+    });
+
+    it("should work with other selected columns", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), status, count() FROM runs GROUP BY timeBucket, status"
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+      expect(sql).toContain("status");
+      expect(sql).toContain("count()");
+    });
+  });
+
+  describe("GROUP BY with timeBucket alias", () => {
+    it("should allow GROUP BY timeBucket (bare identifier, matching implicit alias)", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket"
+      );
+
+      // The GROUP BY should reference the alias, not re-expand
+      expect(sql).toContain("GROUP BY");
+      // The SELECT should have the toStartOfInterval call
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+    });
+
+    it("should allow GROUP BY timebucket (all lowercase)", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timebucket"
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+    });
+
+    it("should allow GROUP BY TIMEBUCKET (all uppercase)", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY TIMEBUCKET"
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+    });
+  });
+
+  describe("ORDER BY with timeBucket alias", () => {
+    it("should allow ORDER BY timeBucket", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket ORDER BY timeBucket"
+      );
+
+      expect(sql).toContain("ORDER BY timebucket");
+    });
+
+    it("should allow ORDER BY timeBucket DESC", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket ORDER BY timeBucket DESC"
+      );
+
+      expect(sql).toContain("ORDER BY timebucket DESC");
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw when timeBucket() is called with arguments", () => {
+      expect(() =>
+        printTimeBucketQuery("SELECT timeBucket(triggered_at) FROM runs")
+      ).toThrow("timeBucket() does not accept arguments");
+    });
+
+    it("should throw when table has no timeConstraint", () => {
+      const schema = createSchemaRegistry([noTimeConstraintSchema]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test123" },
+          project_id: { op: "eq", value: "proj_test456" },
+          environment_id: { op: "eq", value: "env_test789" },
+        },
+        timeRange: sevenDayRange,
+      });
+
+      expect(() =>
+        printTimeBucketQuery("SELECT timeBucket(), count() FROM events GROUP BY timeBucket", ctx)
+      ).toThrow("timeConstraint");
+    });
+
+    it("should throw when no timeRange is provided", () => {
+      const ctx = createTimeBucketContext({ timeRange: undefined });
+
+      expect(() =>
+        printTimeBucketQuery("SELECT timeBucket(), count() FROM runs GROUP BY timeBucket", ctx)
+      ).toThrow("time range");
+    });
+  });
+
+  describe("column name mapping", () => {
+    it("should resolve timeConstraint through column mapping (TSQL → ClickHouse)", () => {
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket"
+      );
+
+      // timeConstraint is "triggered_at" which maps to CH "created_at"
+      expect(sql).toContain("created_at");
+      expect(sql).not.toContain("triggered_at");
+    });
+
+    it("should work with timeConstraint column that has no clickhouseName mapping", () => {
+      const schemaNoMapping: TableSchema = {
+        name: "logs",
+        clickhouseName: "trigger_dev.logs_v1",
+        timeConstraint: "timestamp",
+        columns: {
+          id: { name: "id", ...column("String") },
+          timestamp: { name: "timestamp", ...column("DateTime64") },
+          organization_id: { name: "organization_id", ...column("String") },
+          project_id: { name: "project_id", ...column("String") },
+          environment_id: { name: "environment_id", ...column("String") },
+        },
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+      };
+
+      const schema = createSchemaRegistry([schemaNoMapping]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test123" },
+          project_id: { op: "eq", value: "proj_test456" },
+          environment_id: { op: "eq", value: "env_test789" },
+        },
+        timeRange: sevenDayRange,
+      });
+
+      const { sql } = printTimeBucketQuery(
+        "SELECT timeBucket(), count() FROM logs GROUP BY timeBucket",
+        ctx
+      );
+
+      // No clickhouseName, so uses the TSQL name "timestamp" directly
+      expect(sql).toContain("toStartOfInterval(timestamp, INTERVAL 6 HOUR)");
+    });
+  });
+
+  describe("case insensitivity", () => {
+    it("should handle timeBucket() case-insensitively in SELECT", () => {
+      // The parser preserves case, but visitCall checks case-insensitively
+      const { sql } = printTimeBucketQuery(
+        "SELECT TIMEBUCKET(), count() FROM runs GROUP BY timeBucket"
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+    });
+  });
+
+  describe("integration with compileTSQL", () => {
+    it("should work through the full compileTSQL pipeline", () => {
+      const { sql, params } = compileTSQL(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket",
+        {
+          tableSchema: [timeBucketSchema],
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_test123" },
+            project_id: { op: "eq", value: "proj_test456" },
+            environment_id: { op: "eq", value: "env_test789" },
+          },
+          timeRange: sevenDayRange,
+        }
+      );
+
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 6 HOUR)");
+      expect(sql).toContain("count()");
+      // Tenant isolation should still be applied
+      expect(Object.values(params)).toContain("org_test123");
+    });
+  });
+
+  describe("per-table timeBucketThresholds", () => {
+    const customThresholds: BucketThreshold[] = [
+      // 10-second minimum granularity (e.g., for pre-aggregated metrics)
+      { maxRangeSeconds: 10 * 60, interval: { value: 10, unit: "SECOND" } },
+      { maxRangeSeconds: 30 * 60, interval: { value: 30, unit: "SECOND" } },
+      { maxRangeSeconds: 2 * 60 * 60, interval: { value: 1, unit: "MINUTE" } },
+    ];
+
+    const schemaWithCustomThresholds: TableSchema = {
+      ...timeBucketSchema,
+      name: "metrics",
+      timeBucketThresholds: customThresholds,
+    };
+
+    it("should use custom thresholds when defined on the table schema", () => {
+      // 3-minute range: global default would give 5 SECOND, custom gives 10 SECOND
+      const threeMinuteRange = {
+        from: new Date("2024-01-01T00:00:00Z"),
+        to: new Date("2024-01-01T00:03:00Z"),
+      };
+
+      const schema = createSchemaRegistry([schemaWithCustomThresholds]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test123" },
+          project_id: { op: "eq", value: "proj_test456" },
+          environment_id: { op: "eq", value: "env_test789" },
+        },
+        timeRange: threeMinuteRange,
+      });
+
+      const ast = parseTSQLSelect(
+        "SELECT timeBucket(), count() FROM metrics GROUP BY timeBucket"
+      );
+      const { sql } = printToClickHouse(ast, ctx);
+
+      // Custom thresholds: under 10 min → 10 SECOND (not the global 5 SECOND)
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 10 SECOND)");
+    });
+
+    it("should fall back to global defaults when no custom thresholds are defined", () => {
+      // 3-minute range with standard schema (no custom thresholds)
+      const threeMinuteRange = {
+        from: new Date("2024-01-01T00:00:00Z"),
+        to: new Date("2024-01-01T00:03:00Z"),
+      };
+
+      const schema = createSchemaRegistry([timeBucketSchema]);
+      const ctx = createPrinterContext({
+        schema,
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_test123" },
+          project_id: { op: "eq", value: "proj_test456" },
+          environment_id: { op: "eq", value: "env_test789" },
+        },
+        timeRange: threeMinuteRange,
+      });
+
+      const ast = parseTSQLSelect(
+        "SELECT timeBucket(), count() FROM runs GROUP BY timeBucket"
+      );
+      const { sql } = printToClickHouse(ast, ctx);
+
+      // Global default: under 5 min → 5 SECOND
+      expect(sql).toContain("toStartOfInterval(created_at, INTERVAL 5 SECOND)");
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/query/printer.ts b/internal-packages/tsql/src/query/printer.ts
new file mode 100644
index 00000000000..d45002f6715
--- /dev/null
+++ b/internal-packages/tsql/src/query/printer.ts
@@ -0,0 +1,3228 @@
+// TypeScript port of posthog/hogql/printer.py
+// ClickHouse SQL printer with tenant isolation and schema validation
+
+import {
+  And,
+  Alias,
+  ArithmeticOperation,
+  ArithmeticOperationOp,
+  Array as ASTArray,
+  ArrayAccess,
+  AST,
+  BetweenExpr,
+  Call,
+  CompareOperation,
+  CompareOperationOp,
+  Constant,
+  CTE,
+  Dict,
+  Expression,
+  Field,
+  JoinConstraint,
+  JoinExpr,
+  Lambda,
+  LimitByExpr,
+  Not,
+  Or,
+  OrderExpr,
+  Placeholder,
+  RatioExpr,
+  SampleExpr,
+  SelectQuery,
+  SelectSetQuery,
+  Tuple,
+  TupleAccess,
+  WindowExpr,
+  WindowFrameExpr,
+  WindowFunction,
+} from "./ast";
+import { escapeClickHouseIdentifier, escapeTSQLIdentifier, escapeClickHouseString } from "./escape";
+import { ImpossibleASTError, NotImplementedError, QueryError } from "./errors";
+import {
+  TSQL_CLICKHOUSE_FUNCTIONS,
+  TSQL_AGGREGATIONS,
+  TSQL_COMPARISON_MAPPING,
+  findTSQLAggregation,
+  findTSQLFunction,
+  validateFunctionArgs,
+} from "./functions";
+import { PrinterContext, WhereClauseCondition } from "./printer_context";
+import { calculateTimeBucketInterval } from "./time_buckets";
+import {
+  findTable,
+  validateTable,
+  TableSchema,
+  ColumnSchema,
+  getInternalValue,
+  isVirtualColumn,
+  OutputColumnMetadata,
+  ClickHouseType,
+  hasFieldMapping,
+  getInternalValueFromMappingCaseInsensitive,
+  type ColumnFormatType,
+} from "./schema";
+
+/**
+ * Result of printing an AST to ClickHouse SQL
+ */
+export interface PrintResult {
+  /** The generated ClickHouse SQL query */
+  sql: string;
+  /** Parameter values for parameterized query execution */
+  params: Record<string, unknown>;
+  /** Metadata for each column in the SELECT clause, in order */
+  columns: OutputColumnMetadata[];
+  /**
+   * Columns that were hidden when SELECT * was used.
+   * Only populated when SELECT * is transformed to core columns only.
+   */
+  hiddenColumns?: string[];
+}
+
+/**
+ * Response from visiting a JoinExpr node
+ */
+interface JoinExprResponse {
+  /** The printed SQL for the JOIN */
+  printedSql: string;
+  /** Additional WHERE clause to add (e.g., tenant isolation guards) */
+  where: Expression | null;
+}
+
+/**
+ * ClickHouse SQL Printer
+ *
+ * Converts a TSQL AST to a parameterized ClickHouse SQL query with:
+ * - Automatic tenant isolation (organization_id, project_id, environment_id)
+ * - Schema-based table/column validation
+ * - SQL injection protection via parameterized queries
+ * - Table and column name mapping (user-friendly → internal ClickHouse names)
+ */
+export class ClickHousePrinter {
+  /** Stack of AST nodes being visited (for context) */
+  private stack: AST[] = [];
+  /** Indent level for pretty printing */
+  private indentLevel = -1;
+  /** Tab size for pretty printing */
+  private tabSize = 4;
+  /** Whether to pretty print output */
+  private pretty: boolean;
+  /**
+   * Map of table aliases to their schemas (for column name resolution)
+   * Key is the alias/name used in the query, value is the TableSchema
+   */
+  private tableContexts: Map<string, TableSchema> = new Map();
+  /** Column metadata collected during SELECT processing */
+  private outputColumns: OutputColumnMetadata[] = [];
+  /** Whether we're currently processing GROUP BY expressions */
+  private inGroupByContext = false;
+  /** Whether the current query has a GROUP BY clause (used for JSON subfield type hints) */
+  private queryHasGroupBy = false;
+  /** Columns hidden when SELECT * is expanded to core columns only */
+  private hiddenColumns: string[] = [];
+  /**
+   * Map of column aliases defined in the current SELECT clause.
+   * Key is the lowercase alias (for case-insensitive lookup),
+   * value is the canonical form (as it appears in the generated SQL).
+   * Used to allow ORDER BY/HAVING to reference aliased columns.
+   */
+  private selectAliases: Map<string, string> = new Map();
+  /**
+   * Set of internal ClickHouse column names that are allowed (e.g., tenant columns).
+   * These are populated from tableSchema.tenantColumns when processing joins.
+   */
+  private allowedInternalColumns: Set<string> = new Set();
+  /**
+   * Set of internal-only column names that are NOT user-queryable.
+   * These are tenant columns and required filter columns that are not exposed in tableSchema.columns.
+   * Used to block user queries from accessing internal columns in SELECT, ORDER BY, GROUP BY, HAVING.
+   */
+  private internalOnlyColumns: Set<string> = new Set();
+  /**
+   * Whether we're currently processing user projection clauses (SELECT, ORDER BY, GROUP BY, HAVING).
+   * When true, internal-only columns will be rejected.
+   */
+  private inProjectionContext = false;
+
+  constructor(
+    private context: PrinterContext,
+    options: { pretty?: boolean } = {}
+  ) {
+    this.pretty = options.pretty ?? false;
+  }
+
+  /**
+   * Print an AST node to ClickHouse SQL
+   */
+  print(node: SelectQuery | SelectSetQuery): PrintResult {
+    this.outputColumns = [];
+    this.hiddenColumns = [];
+    const sql = this.visit(node);
+    const result: PrintResult = {
+      sql,
+      params: this.context.getParams(),
+      columns: this.outputColumns,
+    };
+    if (this.hiddenColumns.length > 0) {
+      result.hiddenColumns = this.hiddenColumns;
+    }
+    return result;
+  }
+
+  /**
+   * Get current indentation string
+   */
+  private indent(extra = 0): string {
+    return " ".repeat(this.tabSize * (this.indentLevel + extra));
+  }
+
+  /**
+   * Visit an AST node and return its SQL representation
+   */
+  private visit(node: AST | null | undefined): string {
+    if (node === null || node === undefined) {
+      return "";
+    }
+
+    this.stack.push(node);
+    this.indentLevel++;
+
+    let response: string;
+
+    // Type-based dispatch
+    const nodeType = (node as Expression).expression_type;
+
+    switch (nodeType) {
+      case "select_set_query":
+        response = this.visitSelectSetQuery(node as SelectSetQuery);
+        break;
+      case "select_query":
+        response = this.visitSelectQuery(node as SelectQuery);
+        break;
+      case "cte":
+        response = this.visitCTE(node as CTE);
+        break;
+      case "alias":
+        response = this.visitAlias(node as Alias);
+        break;
+      case "arithmetic_operation":
+        response = this.visitArithmeticOperation(node as ArithmeticOperation);
+        break;
+      case "and":
+        response = this.visitAnd(node as And);
+        break;
+      case "or":
+        response = this.visitOr(node as Or);
+        break;
+      case "compare_operation":
+        response = this.visitCompareOperation(node as CompareOperation);
+        break;
+      case "not":
+        response = this.visitNot(node as Not);
+        break;
+      case "between_expr":
+        response = this.visitBetweenExpr(node as BetweenExpr);
+        break;
+      case "order_expr":
+        response = this.visitOrderExpr(node as OrderExpr);
+        break;
+      case "array_access":
+        response = this.visitArrayAccess(node as ArrayAccess);
+        break;
+      case "array":
+        response = this.visitArray(node as ASTArray);
+        break;
+      case "dict":
+        response = this.visitDict(node as Dict);
+        break;
+      case "tuple_access":
+        response = this.visitTupleAccess(node as TupleAccess);
+        break;
+      case "tuple":
+        response = this.visitTuple(node as Tuple);
+        break;
+      case "lambda":
+        response = this.visitLambda(node as Lambda);
+        break;
+      case "constant":
+        response = this.visitConstant(node as Constant);
+        break;
+      case "field":
+        response = this.visitField(node as Field);
+        break;
+      case "placeholder":
+        response = this.visitPlaceholder(node as Placeholder);
+        break;
+      case "call":
+        response = this.visitCall(node as Call);
+        break;
+      case "join_expr":
+        // JoinExpr is handled specially since it returns more than just SQL
+        throw new ImpossibleASTError("JoinExpr should be handled via visitJoinExpr");
+      case "join_constraint":
+        response = this.visitJoinConstraint(node as JoinConstraint);
+        break;
+      case "window_frame_expr":
+        response = this.visitWindowFrameExpr(node as WindowFrameExpr);
+        break;
+      case "window_expr":
+        response = this.visitWindowExpr(node as WindowExpr);
+        break;
+      case "window_function":
+        response = this.visitWindowFunction(node as WindowFunction);
+        break;
+      case "limit_by_expr":
+        response = this.visitLimitByExpr(node as LimitByExpr);
+        break;
+      case "ratio_expr":
+        response = this.visitRatioExpr(node as RatioExpr);
+        break;
+      case "sample_expr":
+        response = this.visitSampleExpr(node as SampleExpr);
+        break;
+      default:
+        throw new NotImplementedError(
+          `Unknown expression type: ${nodeType}. Node: ${JSON.stringify(node, null, 2).slice(
+            0,
+            200
+          )}`
+        );
+    }
+
+    this.indentLevel--;
+    this.stack.pop();
+
+    return response;
+  }
+
+  // ============================================================
+  // SELECT Query Visitors
+  // ============================================================
+
+  private visitSelectSetQuery(node: SelectSetQuery): string {
+    this.indentLevel--;
+    let ret = this.visit(node.initial_select_query);
+    if (this.pretty) {
+      ret = ret.trim();
+    }
+
+    for (const expr of node.subsequent_select_queries) {
+      let query = this.visit(expr.select_query);
+      if (this.pretty) {
+        query = query.trim();
+      }
+      if (expr.set_operator !== undefined) {
+        if (this.pretty) {
+          ret += `\n${this.indent(1)}${expr.set_operator}\n${this.indent(1)}`;
+        } else {
+          ret += ` ${expr.set_operator} `;
+        }
+      }
+      ret += query;
+    }
+
+    this.indentLevel++;
+
+    // Wrap in parentheses if not top level
+    if (this.stack.length > 1) {
+      return `(${ret.trim()})`;
+    }
+    return ret;
+  }
+
+  private visitSelectQuery(node: SelectQuery): string {
+    // Determine if this is a top-level query
+    const partOfSelectUnion =
+      this.stack.length >= 2 && this.isSelectSetQuery(this.stack[this.stack.length - 2]);
+    const isTopLevelQuery =
+      this.stack.length <= 1 || (this.stack.length === 2 && partOfSelectUnion);
+
+    // Save and clear table contexts
+    // Top-level queries clear contexts; subqueries save parent context and create fresh context
+    const savedTableContexts = new Map(this.tableContexts);
+    const savedInternalColumns = new Set(this.allowedInternalColumns);
+    const savedInternalOnlyColumns = new Set(this.internalOnlyColumns);
+    if (isTopLevelQuery) {
+      this.tableContexts.clear();
+      this.allowedInternalColumns.clear();
+      this.internalOnlyColumns.clear();
+    } else {
+      // Subqueries get fresh contexts - they don't inherit parent tables
+      // (the parent will restore its context after the subquery is processed)
+      this.tableContexts = new Map();
+      this.allowedInternalColumns = new Set();
+      this.internalOnlyColumns = new Set();
+    }
+
+    // Build WHERE clause starting with any existing where
+    let where: Expression | undefined = node.where;
+
+    // Process CTEs
+    const cteStrings: string[] = [];
+    if (node.ctes) {
+      for (const [name, cte] of Object.entries(node.ctes)) {
+        cteStrings.push(`${this.printIdentifier(name)} AS (${this.visit(cte.expr)})`);
+      }
+    }
+
+    // Process joins and collect tenant guards
+    const joinedTables: string[] = [];
+    let nextJoin: JoinExpr | undefined = node.select_from;
+
+    while (nextJoin) {
+      const visitedJoin = this.visitJoinExpr(nextJoin);
+      joinedTables.push(visitedJoin.printedSql);
+
+      // Add tenant guard to WHERE clause
+      const extraWhere = visitedJoin.where;
+      if (extraWhere !== null) {
+        if (where === undefined) {
+          where = extraWhere;
+        } else if ((where as And).expression_type === "and") {
+          where = { expression_type: "and", exprs: [extraWhere, ...(where as And).exprs] } as And;
+        } else {
+          where = { expression_type: "and", exprs: [extraWhere, where] } as And;
+        }
+      }
+
+      nextJoin = nextJoin.next_join;
+    }
+
+    // Extract SELECT column aliases BEFORE visiting columns
+    // This allows ORDER BY/HAVING to reference aliased columns
+    const savedAliases = this.selectAliases;
+    this.selectAliases = new Map();
+    if (node.select) {
+      for (const col of node.select) {
+        this.extractSelectAlias(col);
+      }
+    }
+
+    // Track if query has GROUP BY for JSON subfield type hint decisions
+    // (ClickHouse requires .:String for Dynamic types in GROUP BY, and SELECT must match)
+    const savedQueryHasGroupBy = this.queryHasGroupBy;
+    this.queryHasGroupBy = !!node.group_by;
+
+    // Process SELECT columns and collect metadata
+    // Using flatMap because asterisk expansion can return multiple columns
+    // Set inProjectionContext to block internal-only columns in user projections
+    let columns: string[];
+    if (node.select && node.select.length > 0) {
+      // Only collect metadata for top-level queries (not subqueries)
+      if (isTopLevelQuery) {
+        this.outputColumns = [];
+      }
+      this.inProjectionContext = true;
+      columns = node.select.flatMap((col) =>
+        this.visitSelectColumnWithMetadata(col, isTopLevelQuery)
+      );
+      this.inProjectionContext = false;
+    } else {
+      columns = ["1"];
+    }
+
+    // Process WINDOW definitions
+    let windowClause: string | null = null;
+    if (node.window_exprs && Object.keys(node.window_exprs).length > 0) {
+      const windowDefs = Object.entries(node.window_exprs).map(
+        ([name, expr]) => `${this.printIdentifier(name)} AS (${this.visit(expr)})`
+      );
+      windowClause = windowDefs.join(", ");
+    }
+
+    // Process other clauses
+    const prewhere = node.prewhere ? this.visit(node.prewhere) : null;
+    const whereStr = where ? this.visit(where) : null;
+
+    // Process GROUP BY with context flags:
+    // - inGroupByContext: use raw columns for whereTransform columns
+    // - inProjectionContext: block internal-only columns
+    let groupBy: string[] | null = null;
+    if (node.group_by) {
+      this.inGroupByContext = true;
+      this.inProjectionContext = true;
+      groupBy = node.group_by.map((col) => this.visit(col));
+      this.inProjectionContext = false;
+      this.inGroupByContext = false;
+    }
+
+    // Process HAVING with inProjectionContext to block internal-only columns
+    let having: string | null = null;
+    if (node.having) {
+      this.inProjectionContext = true;
+      having = this.visit(node.having);
+      this.inProjectionContext = false;
+    }
+
+    // Process ORDER BY with inProjectionContext to block internal-only columns
+    let orderBy: string[] | null = null;
+    if (node.order_by) {
+      this.inProjectionContext = true;
+      orderBy = node.order_by.map((col) => this.visit(col));
+      this.inProjectionContext = false;
+    }
+
+    // Process ARRAY JOIN
+    let arrayJoin = "";
+    if (node.array_join_op) {
+      if (!["ARRAY JOIN", "LEFT ARRAY JOIN", "INNER ARRAY JOIN"].includes(node.array_join_op)) {
+        throw new ImpossibleASTError(`Invalid ARRAY JOIN operation: ${node.array_join_op}`);
+      }
+      arrayJoin = node.array_join_op;
+      if (!node.array_join_list || node.array_join_list.length === 0) {
+        throw new ImpossibleASTError("Invalid ARRAY JOIN without an array");
+      }
+      arrayJoin += ` ${node.array_join_list.map((expr) => this.visit(expr)).join(", ")}`;
+    }
+
+    // Format spacing
+    const space = this.pretty ? `\n${this.indent(1)}` : " ";
+    const comma = this.pretty ? `,\n${this.indent(1)}` : ", ";
+
+    // Build SQL clauses
+    const clauses: (string | null)[] = [
+      `SELECT${space}${node.distinct ? "DISTINCT " : ""}${columns.join(comma)}`,
+      joinedTables.length > 0 ? `FROM${space}${joinedTables.join(space)}` : null,
+      arrayJoin || null,
+      prewhere ? `PREWHERE${space}${prewhere}` : null,
+      whereStr ? `WHERE${space}${whereStr}` : null,
+      groupBy && groupBy.length > 0 ? `GROUP BY${space}${groupBy.join(comma)}` : null,
+      having ? `HAVING${space}${having}` : null,
+      windowClause ? `WINDOW${space}${windowClause}` : null,
+      orderBy && orderBy.length > 0 ? `ORDER BY${space}${orderBy.join(comma)}` : null,
+    ];
+
+    // Process LIMIT
+    let limit = node.limit;
+    if (isTopLevelQuery && this.context.maxRows) {
+      const maxLimit = this.context.maxRows;
+      if (limit !== undefined) {
+        // Cap the limit to maxRows
+        if ((limit as Constant).expression_type === "constant") {
+          const constLimit = limit as Constant;
+          if (typeof constLimit.value === "number") {
+            constLimit.value = Math.min(constLimit.value, maxLimit);
+          }
+        }
+      } else {
+        // Add default limit
+        limit = { expression_type: "constant", value: maxLimit } as Constant;
+      }
+    }
+
+    // Add LIMIT BY
+    if (node.limit_by) {
+      const limitByExprs = node.limit_by.exprs.map((e) => this.visit(e)).join(", ");
+      const offsetPart = node.limit_by.offset_value
+        ? ` OFFSET ${this.visit(node.limit_by.offset_value)}`
+        : "";
+      clauses.push(`LIMIT ${this.visit(node.limit_by.n)}${offsetPart} BY ${limitByExprs}`);
+    }
+
+    // Add LIMIT/OFFSET
+    if (limit !== undefined) {
+      clauses.push(`LIMIT ${this.visit(limit)}`);
+      if (node.limit_with_ties) {
+        clauses.push("WITH TIES");
+      }
+      if (node.offset !== undefined) {
+        clauses.push(`OFFSET ${this.visit(node.offset)}`);
+      }
+    }
+
+    // Add CTEs
+    let response: string;
+    if (this.pretty) {
+      response = clauses
+        .filter((c) => c !== null)
+        .map((c) => `${this.indent()}${c}`)
+        .join("\n");
+    } else {
+      response = clauses.filter((c) => c !== null).join(" ");
+    }
+
+    // Add WITH clause for CTEs
+    if (cteStrings.length > 0) {
+      const ctePrefix = `WITH ${cteStrings.join(", ")}`;
+      response = `${ctePrefix} ${response}`;
+    }
+
+    // Wrap subqueries in parentheses
+    if (!partOfSelectUnion && !isTopLevelQuery) {
+      response = this.pretty ? `(${response.trim()})` : `(${response})`;
+    }
+
+    // Restore saved contexts (for nested queries)
+    this.selectAliases = savedAliases;
+    this.queryHasGroupBy = savedQueryHasGroupBy;
+    this.tableContexts = savedTableContexts;
+    this.allowedInternalColumns = savedInternalColumns;
+    this.internalOnlyColumns = savedInternalOnlyColumns;
+
+    return response;
+  }
+
+  /**
+   * Extract column aliases from a SELECT expression.
+   * Handles explicit aliases (AS name) and implicit names from aggregations/functions.
+   *
+   * NOTE: We intentionally do NOT add field names as aliases here.
+   * Field names (e.g., SELECT status) are columns from the table, not aliases.
+   * Only explicit aliases (SELECT x AS name) and implicit function names
+   * (SELECT COUNT() → 'count') should be added.
+   */
+  private extractSelectAlias(expr: Expression): void {
+    // Handle explicit Alias: SELECT ... AS name
+    // Key is lowercase for case-insensitive lookup, value is the original casing
+    // so that ORDER BY/GROUP BY output matches the alias in the generated SQL.
+    if ((expr as Alias).expression_type === "alias") {
+      const alias = (expr as Alias).alias;
+      this.selectAliases.set(alias.toLowerCase(), alias);
+      return;
+    }
+
+    // Handle implicit names from function calls (e.g., COUNT() → 'count')
+    // ClickHouse generates implicit aliases as lowercase
+    if ((expr as Call).expression_type === "call") {
+      const call = expr as Call;
+      const canonicalName = call.name.toLowerCase();
+      this.selectAliases.set(canonicalName, canonicalName);
+      return;
+    }
+
+    // Handle implicit names from arithmetic operations (e.g., a + b → 'plus')
+    // ClickHouse generates these as lowercase
+    if ((expr as ArithmeticOperation).expression_type === "arithmetic_operation") {
+      const op = expr as ArithmeticOperation;
+      const opNames: Record<ArithmeticOperationOp, string> = {
+        [ArithmeticOperationOp.Add]: "plus",
+        [ArithmeticOperationOp.Sub]: "minus",
+        [ArithmeticOperationOp.Mult]: "multiply",
+        [ArithmeticOperationOp.Div]: "divide",
+        [ArithmeticOperationOp.Mod]: "modulo",
+      };
+      const canonicalName = opNames[op.op];
+      this.selectAliases.set(canonicalName, canonicalName);
+      return;
+    }
+
+    // Field references (e.g., SELECT status) are NOT aliases - they're columns
+    // that will be validated against the table schema. Don't add them here.
+  }
+
+  /**
+   * Visit a SELECT column expression with metadata collection
+   *
+   * For bare Field expressions that reference virtual columns, we need to add
+   * an AS alias to preserve the column name in the result set.
+   *
+   * Examples:
+   * - `SELECT execution_duration` → `SELECT (expr) AS execution_duration`
+   * - `SELECT execution_duration AS dur` → `SELECT (expr) AS dur` (Alias handles it)
+   * - `SELECT run_id` → `SELECT run_id` (not a virtual column)
+   * - `SELECT *` → Expands to all selectable columns from the table(s)
+   *
+   * @param col - The column expression
+   * @param collectMetadata - Whether to collect column metadata (only for top-level queries)
+   * @returns Array of SQL column strings (usually one, but multiple for asterisk expansion)
+   */
+  private visitSelectColumnWithMetadata(col: Expression, collectMetadata: boolean): string[] {
+    // Check for asterisk expansion first
+    if ((col as Field).expression_type === "field") {
+      const field = col as Field;
+      const asteriskExpansion = this.expandAsterisk(field.chain, collectMetadata);
+      if (asteriskExpansion !== null) {
+        return asteriskExpansion;
+      }
+    }
+
+    // Extract output name and source column before visiting
+    const { outputName, sourceColumn, inferredType } = this.analyzeSelectColumn(col);
+    // effectiveOutputName may be overridden for JSON subfields
+    let effectiveOutputName = outputName;
+
+    // Check if this is a bare Field (not wrapped in Alias)
+    let sqlResult: string;
+    if ((col as Field).expression_type === "field") {
+      const field = col as Field;
+
+      // Check if this is a bare JSON field that should use a text column
+      const textColumn = this.getTextColumnForField(field.chain);
+      if (textColumn !== null && outputName) {
+        // Use the text column instead of the JSON column, with alias to preserve name
+        sqlResult = `${this.printIdentifier(textColumn)} AS ${this.printIdentifier(outputName)}`;
+      } else {
+        const virtualColumnName = this.getVirtualColumnNameForField(field.chain);
+
+        if (virtualColumnName !== null) {
+          // Visit the field (which will return the expression)
+          const visited = this.visit(col);
+          // Add the alias to preserve the column name
+          sqlResult = `${visited} AS ${this.printIdentifier(virtualColumnName)}`;
+        } else {
+          // Visit the field to get the ClickHouse SQL
+          const visited = this.visit(col);
+
+          // Check if this is a JSON subfield access (will have .:String type hint)
+          // If so, add an alias to preserve the nice column name (dots → underscores)
+          const isJsonSubfield = this.isJsonSubfieldAccess(field.chain);
+          if (isJsonSubfield) {
+            // Build the alias using underscores, excluding any dataPrefix
+            // e.g., output.message -> "output_message" (not "output_data_message")
+            const dataPrefix = this.getDataPrefixForField(field.chain);
+            const aliasName = this.buildAliasWithoutDataPrefix(field.chain, dataPrefix);
+            sqlResult = `${visited} AS ${this.printIdentifier(aliasName)}`;
+            // Override output name for metadata
+            effectiveOutputName = aliasName;
+          }
+          // Check if the column has a different clickhouseName - if so, add an alias
+          // to ensure results come back with the user-facing name
+          else if (
+            outputName &&
+            sourceColumn?.clickhouseName &&
+            sourceColumn.clickhouseName !== outputName
+          ) {
+            sqlResult = `${visited} AS ${this.printIdentifier(outputName)}`;
+          } else {
+            sqlResult = visited;
+          }
+        }
+      }
+    } else if (
+      // Handle expressions that need implicit aliases (Call, ArithmeticOperation, Constant)
+      // These expressions get implicit names and need AS clauses so results match metadata
+      (col as Alias).expression_type !== "alias" &&
+      ((col as Call).expression_type === "call" ||
+        (col as ArithmeticOperation).expression_type === "arithmetic_operation" ||
+        (col as Constant).expression_type === "constant")
+    ) {
+      const visited = this.visit(col);
+      // Add explicit AS clause with the implicit name so ClickHouse results match our metadata
+      if (outputName) {
+        sqlResult = `${visited} AS ${this.printIdentifier(outputName)}`;
+      } else {
+        sqlResult = visited;
+      }
+    } else if ((col as Alias).expression_type === "alias") {
+      // Handle Alias expressions - check if inner expression is a bare JSON field with textColumn
+      const alias = col as Alias;
+      if ((alias.expr as Field).expression_type === "field") {
+        const innerField = alias.expr as Field;
+        const textColumn = this.getTextColumnForField(innerField.chain);
+        if (textColumn !== null) {
+          // Use the text column with the user's explicit alias
+          sqlResult = `${this.printIdentifier(textColumn)} AS ${this.printIdentifier(alias.alias)}`;
+        } else {
+          sqlResult = this.visit(col);
+        }
+      } else {
+        sqlResult = this.visit(col);
+      }
+    } else {
+      // For other types, visit normally
+      sqlResult = this.visit(col);
+    }
+
+    // Collect metadata for top-level queries
+    if (collectMetadata && effectiveOutputName) {
+      const metadata: OutputColumnMetadata = {
+        name: effectiveOutputName,
+        type: sourceColumn?.type ?? inferredType ?? "String",
+      };
+
+      // Only add customRenderType if specified in schema
+      if (sourceColumn?.customRenderType) {
+        metadata.customRenderType = sourceColumn.customRenderType;
+      }
+
+      // Only add description if specified in schema (columns and virtual columns)
+      if (sourceColumn?.description) {
+        metadata.description = sourceColumn.description;
+      }
+
+      // Set format hint from prettyFormat() or auto-populate from customRenderType
+      const sourceWithFormat = sourceColumn as (Partial<ColumnSchema> & { format?: ColumnFormatType }) | null;
+      if (sourceWithFormat?.format) {
+        metadata.format = sourceWithFormat.format;
+      } else if (sourceColumn?.customRenderType) {
+        metadata.format = sourceColumn.customRenderType as ColumnFormatType;
+      }
+
+      this.outputColumns.push(metadata);
+    }
+
+    return [sqlResult];
+  }
+
+  /**
+   * Expand an asterisk field to all selectable columns from the table(s)
+   *
+   * @param chain - The field chain (["*"] for SELECT *, [tableName, "*"] for table.*)
+   * @param collectMetadata - Whether to collect column metadata
+   * @returns Array of SQL column strings, or null if not an asterisk
+   */
+  private expandAsterisk(chain: Array<string | number>, collectMetadata: boolean): string[] | null {
+    // Check for SELECT * (chain: ["*"])
+    if (chain.length === 1 && chain[0] === "*") {
+      return this.expandAllTableColumns(collectMetadata);
+    }
+
+    // Check for table.* (chain: [tableName, "*"])
+    if (chain.length === 2 && chain[1] === "*") {
+      const tableAlias = chain[0];
+      if (typeof tableAlias === "string") {
+        return this.expandTableColumns(tableAlias, collectMetadata);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Expand SELECT * to core columns only from all tables in context.
+   * Non-core columns are tracked in hiddenColumns for user notification.
+   */
+  private expandAllTableColumns(collectMetadata: boolean): string[] {
+    const results: string[] = [];
+
+    // Iterate through all tables in the context
+    for (const [tableAlias, tableSchema] of this.tableContexts.entries()) {
+      const tableColumns = this.getSelectableColumnsFromSchema(
+        tableSchema,
+        tableAlias,
+        collectMetadata,
+        true // onlyCoreColumns - SELECT * only returns core columns
+      );
+      results.push(...tableColumns);
+    }
+
+    // If no tables in context, fall back to literal *
+    if (results.length === 0) {
+      return ["*"];
+    }
+
+    return results;
+  }
+
+  /**
+   * Expand table.* to core columns only from a specific table.
+   * Non-core columns are tracked in hiddenColumns for user notification.
+   */
+  private expandTableColumns(tableAlias: string, collectMetadata: boolean): string[] {
+    const tableSchema = this.tableContexts.get(tableAlias);
+
+    if (!tableSchema) {
+      // Table not found in context, fall back to literal table.*
+      return [`${this.printIdentifier(tableAlias)}.*`];
+    }
+
+    return this.getSelectableColumnsFromSchema(
+      tableSchema,
+      tableAlias,
+      collectMetadata,
+      true // onlyCoreColumns - table.* only returns core columns
+    );
+  }
+
+  /**
+   * Get selectable columns from a table schema as SQL strings
+   *
+   * @param tableSchema - The table schema
+   * @param tableAlias - The alias used for the table in the query (for table-qualified columns)
+   * @param collectMetadata - Whether to collect column metadata
+   * @param onlyCoreColumns - If true, only return core columns and track hidden columns (but falls back to all columns if no core columns are defined)
+   * @returns Array of SQL column strings
+   */
+  private getSelectableColumnsFromSchema(
+    tableSchema: TableSchema,
+    tableAlias: string,
+    collectMetadata: boolean,
+    onlyCoreColumns = false
+  ): string[] {
+    const results: string[] = [];
+
+    // Check if any core columns exist - if not, we'll return all columns as a fallback
+    const hasCoreColumns = Object.values(tableSchema.columns).some(
+      (col) => col.coreColumn === true && col.selectable !== false
+    );
+
+    // Only filter to core columns if the schema defines some core columns
+    const shouldFilterToCoreOnly = onlyCoreColumns && hasCoreColumns;
+
+    for (const [columnName, columnSchema] of Object.entries(tableSchema.columns)) {
+      // Skip non-selectable columns
+      if (columnSchema.selectable === false) {
+        continue;
+      }
+
+      // If filtering to core columns only, skip non-core and track them
+      if (shouldFilterToCoreOnly && !columnSchema.coreColumn) {
+        this.hiddenColumns.push(columnName);
+        continue;
+      }
+
+      // Build the SQL for this column
+      let sqlResult: string;
+
+      // Check if this is a virtual column (has expression)
+      if (isVirtualColumn(columnSchema)) {
+        // Virtual column: use the expression with an alias
+        sqlResult = `(${columnSchema.expression}) AS ${this.printIdentifier(columnName)}`;
+      } else if (columnSchema.textColumn) {
+        // JSON column with text column optimization: use the text column with alias
+        sqlResult = `${this.printIdentifier(columnSchema.textColumn)} AS ${this.printIdentifier(
+          columnName
+        )}`;
+      } else {
+        // Regular column: use the actual ClickHouse column name
+        const clickhouseName = columnSchema.clickhouseName ?? columnName;
+
+        // If the column has a different internal name, add an alias
+        if (clickhouseName !== columnName) {
+          sqlResult = `${this.printIdentifier(clickhouseName)} AS ${this.printIdentifier(
+            columnName
+          )}`;
+        } else {
+          sqlResult = this.printIdentifier(columnName);
+        }
+      }
+
+      results.push(sqlResult);
+
+      // Collect metadata if requested
+      if (collectMetadata) {
+        const metadata: OutputColumnMetadata = {
+          name: columnName,
+          type: columnSchema.type,
+        };
+
+        if (columnSchema.customRenderType) {
+          metadata.customRenderType = columnSchema.customRenderType;
+        }
+
+        if (columnSchema.description) {
+          metadata.description = columnSchema.description;
+        }
+
+        this.outputColumns.push(metadata);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Analyze a SELECT column expression to extract output name, source column, and type
+   */
+  private analyzeSelectColumn(col: Expression): {
+    outputName: string | null;
+    sourceColumn: Partial<ColumnSchema> | null;
+    inferredType: ClickHouseType | null;
+  } {
+    // Handle Alias - the output name is the alias
+    if ((col as Alias).expression_type === "alias") {
+      const alias = col as Alias;
+      const innerAnalysis = this.analyzeSelectColumn(alias.expr);
+      return {
+        outputName: alias.alias,
+        sourceColumn: innerAnalysis.sourceColumn,
+        inferredType: innerAnalysis.inferredType,
+      };
+    }
+
+    // Handle Field - the output name is the column name
+    if ((col as Field).expression_type === "field") {
+      const field = col as Field;
+      const columnInfo = this.resolveFieldToColumn(field.chain);
+      return {
+        outputName: columnInfo.outputName,
+        sourceColumn: columnInfo.column,
+        inferredType: columnInfo.column?.type ?? null,
+      };
+    }
+
+    // Handle prettyFormat(expr, 'formatType') — metadata-only wrapper
+    if ((col as Call).expression_type === "call") {
+      const call = col as Call;
+      if (call.name.toLowerCase() === "prettyformat") {
+        if (call.args.length !== 2) {
+          throw new QueryError(
+            "prettyFormat() requires exactly 2 arguments: prettyFormat(expression, 'formatType')"
+          );
+        }
+        const formatArg = call.args[1];
+        if (
+          (formatArg as Constant).expression_type !== "constant" ||
+          typeof (formatArg as Constant).value !== "string"
+        ) {
+          throw new QueryError(
+            "prettyFormat() second argument must be a string literal format type"
+          );
+        }
+        const formatType = (formatArg as Constant).value as string;
+        const validFormats = [
+          "bytes",
+          "decimalBytes",
+          "quantity",
+          "percent",
+          "duration",
+          "durationSeconds",
+          "costInDollars",
+          "cost",
+        ];
+        if (!validFormats.includes(formatType)) {
+          throw new QueryError(
+            `Unknown format type '${formatType}'. Valid types: ${validFormats.join(", ")}`
+          );
+        }
+        const innerAnalysis = this.analyzeSelectColumn(call.args[0]);
+        return {
+          outputName: innerAnalysis.outputName,
+          sourceColumn: {
+            ...(innerAnalysis.sourceColumn ?? {}),
+            type: innerAnalysis.sourceColumn?.type ?? innerAnalysis.inferredType ?? undefined,
+            format: formatType as ColumnFormatType,
+          } as Partial<ColumnSchema> & { format?: ColumnFormatType },
+          inferredType: innerAnalysis.inferredType,
+        };
+      }
+    }
+
+    // Handle Call (function/aggregation) - infer type from function
+    if ((col as Call).expression_type === "call") {
+      const call = col as Call;
+      const inferredType = this.inferCallType(call);
+
+      // For value-preserving aggregates (SUM, AVG, MIN, MAX), propagate customRenderType
+      // from the source column. COUNT and other aggregates return counts, not values,
+      // so they shouldn't inherit the source column's render type.
+      const valuePreservingAggregates = [
+        "sum",
+        "sumif",
+        "avg",
+        "avgif",
+        "min",
+        "minif",
+        "max",
+        "maxif",
+        "quantile",
+      ];
+      const funcName = call.name.toLowerCase();
+      let sourceColumn: Partial<ColumnSchema> | null = null;
+
+      if (valuePreservingAggregates.includes(funcName) && call.args.length > 0) {
+        const firstArg = call.args[0];
+        if ((firstArg as Field).expression_type === "field") {
+          const field = firstArg as Field;
+          const columnInfo = this.resolveFieldToColumn(field.chain);
+          // Only propagate customRenderType, not the full column schema
+          if (columnInfo.column?.customRenderType) {
+            sourceColumn = {
+              type: inferredType,
+              customRenderType: columnInfo.column.customRenderType,
+            };
+          }
+        }
+      }
+
+      return {
+        outputName: this.generateImplicitName(call),
+        sourceColumn,
+        inferredType,
+      };
+    }
+
+    // Handle ArithmeticOperation - infer type
+    if ((col as ArithmeticOperation).expression_type === "arithmetic_operation") {
+      const arith = col as ArithmeticOperation;
+      const inferredType = this.inferArithmeticType(arith);
+      return {
+        outputName: this.generateImplicitName(arith),
+        sourceColumn: null,
+        inferredType,
+      };
+    }
+
+    // Handle Constant
+    if ((col as Constant).expression_type === "constant") {
+      const constant = col as Constant;
+      const inferredType = this.inferConstantType(constant);
+      return {
+        outputName: this.generateImplicitName(constant),
+        sourceColumn: null,
+        inferredType,
+      };
+    }
+
+    // Default for other expression types
+    return {
+      outputName: null,
+      sourceColumn: null,
+      inferredType: null,
+    };
+  }
+
+  /**
+   * Generate an implicit column name for an expression without an explicit alias.
+   * This matches how Postgres auto-names result columns (just the function name).
+   *
+   * Examples:
+   * - COUNT() -> "count"
+   * - COUNT(id) -> "count"
+   * - SUM(duration_ms) -> "sum"
+   * - 1 + 2 -> "plus"
+   */
+  private generateImplicitName(expr: Expression): string {
+    // Handle Call (function/aggregation)
+    if ((expr as Call).expression_type === "call") {
+      const call = expr as Call;
+      // Use lowercase function name without parentheses, like Postgres does
+      // This allows users to reference the column in WHERE/HAVING without issues
+      return call.name.toLowerCase();
+    }
+
+    // Handle Field
+    if ((expr as Field).expression_type === "field") {
+      const field = expr as Field;
+      // Return the last part of the chain (column name)
+      const parts = field.chain.filter((p): p is string => typeof p === "string");
+      return parts.length > 0 ? parts[parts.length - 1] : "*";
+    }
+
+    // Handle ArithmeticOperation - use operator function name without args
+    if ((expr as ArithmeticOperation).expression_type === "arithmetic_operation") {
+      const arith = expr as ArithmeticOperation;
+
+      switch (arith.op) {
+        case ArithmeticOperationOp.Add:
+          return "plus";
+        case ArithmeticOperationOp.Sub:
+          return "minus";
+        case ArithmeticOperationOp.Mult:
+          return "multiply";
+        case ArithmeticOperationOp.Div:
+          return "divide";
+        case ArithmeticOperationOp.Mod:
+          return "modulo";
+        default:
+          return "expression";
+      }
+    }
+
+    // Handle Constant
+    if ((expr as Constant).expression_type === "constant") {
+      const constant = expr as Constant;
+      if (constant.value === null) {
+        return "NULL";
+      }
+      if (typeof constant.value === "string") {
+        return `'${constant.value}'`;
+      }
+      return String(constant.value);
+    }
+
+    // Handle Alias (shouldn't normally reach here since aliases have explicit names)
+    if ((expr as Alias).expression_type === "alias") {
+      const alias = expr as Alias;
+      return alias.alias;
+    }
+
+    // Default fallback
+    return "expression";
+  }
+
+  /**
+   * Resolve a field chain to its column schema and output name
+   */
+  private resolveFieldToColumn(chain: Array<string | number>): {
+    outputName: string | null;
+    column: ColumnSchema | null;
+  } {
+    if (chain.length === 0) {
+      return { outputName: null, column: null };
+    }
+
+    // Handle asterisk
+    if (chain[0] === "*" || (chain.length === 2 && chain[1] === "*")) {
+      return { outputName: null, column: null };
+    }
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") {
+      return { outputName: null, column: null };
+    }
+
+    // Case 1: Qualified reference like table.column
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+      if (!tableSchema) {
+        return { outputName: firstPart, column: null };
+      }
+
+      const columnName = chain[1];
+      if (typeof columnName !== "string") {
+        return { outputName: null, column: null };
+      }
+
+      const columnSchema = tableSchema.columns[columnName];
+      return {
+        outputName: columnName,
+        column: columnSchema || null,
+      };
+    }
+
+    // Case 2: Unqualified reference like just "column"
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema) {
+        return {
+          outputName: columnName,
+          column: columnSchema,
+        };
+      }
+    }
+
+    // Column not found in any table context
+    return {
+      outputName: columnName,
+      column: null,
+    };
+  }
+
+  // ============================================================
+  // Type Inference for Computed Expressions
+  // ============================================================
+
+  /**
+   * Infer the ClickHouse type for a function call expression
+   */
+  private inferCallType(call: Call): ClickHouseType {
+    const name = call.name.toLowerCase();
+
+    // Count functions always return UInt64
+    if (
+      name === "count" ||
+      name === "countif" ||
+      name === "countdistinct" ||
+      name === "countdistinctif"
+    ) {
+      return "UInt64";
+    }
+
+    // Uniq functions return UInt64
+    if (name.startsWith("uniq")) {
+      return "UInt64";
+    }
+
+    // Sum returns Int64 by default (could be more specific based on input)
+    if (name === "sum" || name === "sumif") {
+      return "Int64";
+    }
+
+    // Avg returns Float64
+    if (name === "avg" || name === "avgif") {
+      return "Float64";
+    }
+
+    // Quantile functions return Float64
+    if (name === "quantile" || name === "quantileif" || name.startsWith("quantile")) {
+      return "Float64";
+    }
+
+    // Min/Max preserve the input type - try to infer from first arg
+    if (name === "min" || name === "max" || name === "minif" || name === "maxif") {
+      if (call.args.length > 0) {
+        const argType = this.inferExpressionType(call.args[0]);
+        if (argType) return argType;
+      }
+      return "Float64"; // Default
+    }
+
+    // dateDiff returns Int64 (signed difference)
+    if (name === "datediff" || name === "date_diff") {
+      return "Int64";
+    }
+
+    // String functions
+    if (
+      name === "concat" ||
+      name === "substring" ||
+      name === "substr" ||
+      name === "lower" ||
+      name === "upper" ||
+      name === "trim" ||
+      name === "replace" ||
+      name === "tostring"
+    ) {
+      return "String";
+    }
+
+    // Date/DateTime conversion functions
+    if (name === "todate" || name === "todate32") {
+      return "Date";
+    }
+    if (name === "todatetime") {
+      return "DateTime";
+    }
+    if (name === "todatetime64") {
+      return "DateTime64";
+    }
+
+    // Date extraction functions return UInt8/UInt16
+    if (
+      name === "toyear" ||
+      name === "tomonth" ||
+      name === "todayofmonth" ||
+      name === "todayofweek" ||
+      name === "todayofyear" ||
+      name === "tohour" ||
+      name === "tominute" ||
+      name === "tosecond"
+    ) {
+      return "UInt16";
+    }
+
+    // toUnixTimestamp returns UInt32
+    if (name === "tounixtimestamp") {
+      return "UInt32";
+    }
+
+    // Numeric conversion functions
+    if (name === "toint8") return "Int8";
+    if (name === "toint16") return "Int16";
+    if (name === "toint32") return "Int32";
+    if (name === "toint64") return "Int64";
+    if (name === "touint8") return "UInt8";
+    if (name === "touint16") return "UInt16";
+    if (name === "touint32") return "UInt32";
+    if (name === "touint64") return "UInt64";
+    if (name === "tofloat32") return "Float32";
+    if (name === "tofloat64") return "Float64";
+
+    // Boolean functions
+    if (
+      name === "empty" ||
+      name === "notempty" ||
+      name === "isnull" ||
+      name === "isnotnull" ||
+      name === "in" ||
+      name === "notin"
+    ) {
+      return "UInt8"; // ClickHouse uses UInt8 for booleans
+    }
+
+    // If/multiIf - try to infer from result expressions
+    if (name === "if" && call.args.length >= 2) {
+      const thenType = this.inferExpressionType(call.args[1]);
+      if (thenType) return thenType;
+    }
+
+    // Array functions that return arrays
+    if (name === "grouparray" || name === "groupuniqarray" || name === "array") {
+      return "Array(String)"; // Simplified - could be more specific
+    }
+
+    // Length functions return UInt64
+    if (name === "length" || name === "lengthutf8" || name === "char_length") {
+      return "UInt64";
+    }
+
+    // Default to String for unknown functions
+    return "String";
+  }
+
+  /**
+   * Infer the ClickHouse type for an arithmetic operation
+   */
+  private inferArithmeticType(arith: ArithmeticOperation): ClickHouseType {
+    const leftType = this.inferExpressionType(arith.left);
+    const rightType = this.inferExpressionType(arith.right);
+
+    // DateTime minus DateTime could produce an interval/Int64
+    if (this.isDateTimeType(leftType) && this.isDateTimeType(rightType)) {
+      return "Int64"; // Seconds difference
+    }
+
+    // If either is Float, result is Float
+    if (this.isFloatType(leftType) || this.isFloatType(rightType)) {
+      return "Float64";
+    }
+
+    // Division always produces Float64
+    if (arith.op === ArithmeticOperationOp.Div) {
+      return "Float64";
+    }
+
+    // Integer arithmetic stays integer
+    if (this.isIntType(leftType) && this.isIntType(rightType)) {
+      // Return the wider type
+      return this.widerIntType(leftType, rightType);
+    }
+
+    // Default to Float64 for mixed or unknown types
+    return "Float64";
+  }
+
+  /**
+   * Infer the ClickHouse type for a constant value
+   */
+  private inferConstantType(constant: Constant): ClickHouseType {
+    const value = constant.value;
+
+    if (value === null) {
+      return "Nullable(String)";
+    }
+    if (typeof value === "boolean") {
+      return "UInt8";
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return "Int64";
+      }
+      return "Float64";
+    }
+    if (typeof value === "string") {
+      // Check if it looks like a date/datetime
+      if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+        return "DateTime64";
+      }
+      if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        return "Date";
+      }
+      return "String";
+    }
+
+    return "String";
+  }
+
+  /**
+   * Infer the ClickHouse type for any expression
+   */
+  private inferExpressionType(expr: Expression): ClickHouseType | null {
+    if ((expr as Field).expression_type === "field") {
+      const field = expr as Field;
+      const { column } = this.resolveFieldToColumn(field.chain);
+      return column?.type ?? null;
+    }
+
+    if ((expr as Call).expression_type === "call") {
+      return this.inferCallType(expr as Call);
+    }
+
+    if ((expr as ArithmeticOperation).expression_type === "arithmetic_operation") {
+      return this.inferArithmeticType(expr as ArithmeticOperation);
+    }
+
+    if ((expr as Constant).expression_type === "constant") {
+      return this.inferConstantType(expr as Constant);
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a type is a DateTime type
+   */
+  private isDateTimeType(type: ClickHouseType | null): boolean {
+    if (!type) return false;
+    return (
+      type === "DateTime" ||
+      type === "DateTime64" ||
+      type === "Date" ||
+      type === "Date32" ||
+      type.startsWith("Nullable(DateTime") ||
+      type.startsWith("Nullable(Date")
+    );
+  }
+
+  /**
+   * Check if a type is a Float type
+   */
+  private isFloatType(type: ClickHouseType | null): boolean {
+    if (!type) return false;
+    return (
+      type === "Float32" ||
+      type === "Float64" ||
+      type === "Nullable(Float32)" ||
+      type === "Nullable(Float64)"
+    );
+  }
+
+  /**
+   * Check if a type is an integer type
+   */
+  private isIntType(type: ClickHouseType | null): boolean {
+    if (!type) return false;
+    return (
+      type.startsWith("Int") ||
+      type.startsWith("UInt") ||
+      type.startsWith("Nullable(Int") ||
+      type.startsWith("Nullable(UInt")
+    );
+  }
+
+  /**
+   * Return the wider of two integer types
+   */
+  private widerIntType(left: ClickHouseType | null, right: ClickHouseType | null): ClickHouseType {
+    // Simple heuristic: prefer Int64 for safety
+    if (left === "Int64" || right === "Int64") return "Int64";
+    if (left === "UInt64" || right === "UInt64") return "UInt64";
+    if (left === "Int32" || right === "Int32") return "Int32";
+    if (left === "UInt32" || right === "UInt32") return "UInt32";
+    return "Int64";
+  }
+
+  /**
+   * Get the virtual column name if a field chain references a virtual column
+   * @returns The column name (as exposed in TSQL), or null if not a virtual column
+   */
+  private getVirtualColumnNameForField(chain: Array<string | number>): string | null {
+    if (chain.length === 0) return null;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    // Case 1: Qualified reference like table.column
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+      if (!tableSchema) return null;
+
+      const columnName = chain[1];
+      if (typeof columnName !== "string") return null;
+
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema && isVirtualColumn(columnSchema)) {
+        return columnName;
+      }
+      return null;
+    }
+
+    // Case 2: Unqualified reference like just "column"
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema && isVirtualColumn(columnSchema)) {
+        return columnName;
+      }
+    }
+
+    return null;
+  }
+
+  // ============================================================
+  // JOIN Expression Visitor
+  // ============================================================
+
+  private visitJoinExpr(node: JoinExpr): JoinExprResponse {
+    let extraWhere: Expression | null = null;
+    const joinStrings: string[] = [];
+
+    // Add join type
+    if (node.join_type) {
+      joinStrings.push(node.join_type);
+    }
+
+    // Handle table reference
+    if (node.table) {
+      const tableExpr = node.table;
+
+      if ((tableExpr as Field).expression_type === "field") {
+        // Direct table reference
+        const field = tableExpr as Field;
+        const tableName = field.chain[0];
+        if (typeof tableName !== "string") {
+          throw new QueryError("Table name must be a string");
+        }
+
+        // Look up table schema and get ClickHouse table name
+        const tableSchema = this.lookupTable(tableName);
+
+        // Validate that required tenant columns are present in enforcedWhereClause
+        this.validateRequiredTenantColumns(tableSchema);
+
+        // Always add the TSQL table name as an alias if no explicit alias is provided
+        // This ensures table-qualified column references work in WHERE clauses
+        // (needed to avoid alias conflicts when columns have expressions)
+        const effectiveAlias = node.alias || tableName;
+        joinStrings.push(
+          `${tableSchema.clickhouseName} AS ${this.printIdentifier(effectiveAlias)}`
+        );
+
+        // Register this table context for column name resolution
+        this.tableContexts.set(effectiveAlias, tableSchema);
+
+        // Register tenant columns as allowed internal columns
+        // These are ClickHouse column names used for tenant isolation
+        // Also mark them as internal-only if they're not exposed in tableSchema.columns
+        if (tableSchema.tenantColumns) {
+          const { organizationId, projectId, environmentId } = tableSchema.tenantColumns;
+          if (organizationId) {
+            this.allowedInternalColumns.add(organizationId);
+            if (!this.isColumnExposedInSchema(tableSchema, organizationId)) {
+              this.internalOnlyColumns.add(organizationId);
+            }
+          }
+          if (projectId) {
+            this.allowedInternalColumns.add(projectId);
+            if (!this.isColumnExposedInSchema(tableSchema, projectId)) {
+              this.internalOnlyColumns.add(projectId);
+            }
+          }
+          if (environmentId) {
+            this.allowedInternalColumns.add(environmentId);
+            if (!this.isColumnExposedInSchema(tableSchema, environmentId)) {
+              this.internalOnlyColumns.add(environmentId);
+            }
+          }
+        }
+
+        // Register required filter columns as allowed internal columns
+        // These are ClickHouse columns used for internal filtering (e.g., engine = 'V2')
+        // Also mark them as internal-only if they're not exposed in tableSchema.columns
+        if (tableSchema.requiredFilters) {
+          for (const filter of tableSchema.requiredFilters) {
+            this.allowedInternalColumns.add(filter.column);
+            if (!this.isColumnExposedInSchema(tableSchema, filter.column)) {
+              this.internalOnlyColumns.add(filter.column);
+            }
+          }
+        }
+
+        // Add enforced WHERE clause guard (tenant isolation + plan limits)
+        extraWhere = this.createEnforcedGuard(tableSchema, effectiveAlias);
+      } else if (
+        (tableExpr as SelectQuery).expression_type === "select_query" ||
+        (tableExpr as SelectSetQuery).expression_type === "select_set_query"
+      ) {
+        // Subquery
+        joinStrings.push(this.visit(tableExpr));
+      } else if ((tableExpr as Placeholder).expression_type === "placeholder") {
+        // Placeholder - visit inner expression
+        joinStrings.push(this.visit(tableExpr));
+      } else {
+        throw new QueryError(
+          `Unsupported table expression type: ${(tableExpr as Expression).expression_type}`
+        );
+      }
+    }
+
+    // Add alias
+    if (node.alias) {
+      joinStrings.push(`AS ${this.printIdentifier(node.alias)}`);
+    }
+
+    // Add FINAL for direct table references to ReplacingMergeTree tables
+    // to ensure deduplicated results. Only applied when the table schema
+    // opts in via `useFinal: true` (not needed for plain MergeTree tables).
+    if (node.table) {
+      const tableExpr = node.table;
+      if ((tableExpr as Field).expression_type === "field") {
+        const field = tableExpr as Field;
+        const tableName = field.chain[0];
+        if (typeof tableName === "string") {
+          const tableSchema = this.lookupTable(tableName);
+          if (tableSchema.useFinal) {
+            joinStrings.push("FINAL");
+          }
+        }
+      }
+    }
+
+    // Add SAMPLE
+    if (node.sample) {
+      const sampleClause = this.visitSampleExpr(node.sample);
+      if (sampleClause) {
+        joinStrings.push(sampleClause);
+      }
+    }
+
+    // Add constraint
+    if (node.constraint) {
+      joinStrings.push(`${node.constraint.constraint_type} ${this.visit(node.constraint)}`);
+    }
+
+    return {
+      printedSql: joinStrings.join(" "),
+      where: extraWhere,
+    };
+  }
+
+  // ============================================================
+  // Enforced WHERE Clause
+  // ============================================================
+
+  /**
+   * Validate that required tenant columns are present in enforcedWhereClause.
+   *
+   * If a table defines `tenantColumns.organizationId`, the `enforcedWhereClause`
+   * MUST include that column to ensure tenant isolation. This prevents accidental
+   * data leaks when the caller forgets to include tenant isolation conditions.
+   *
+   * @throws QueryError if a required tenant column is missing
+   */
+  private validateRequiredTenantColumns(tableSchema: TableSchema): void {
+    const { tenantColumns } = tableSchema;
+    if (!tenantColumns) return;
+
+    // Organization ID is always required if the table defines it
+    if (tenantColumns.organizationId) {
+      const orgColumn = tenantColumns.organizationId;
+      if (!this.context.enforcedWhereClause[orgColumn]) {
+        throw new QueryError(
+          `Table '${tableSchema.name}' requires '${orgColumn}' in enforcedWhereClause for tenant isolation`
+        );
+      }
+    }
+    // Note: projectId and environmentId are optional - no validation needed
+  }
+
+  /**
+   * Format a Date as a ClickHouse-compatible DateTime64 string.
+   * ClickHouse expects format: 'YYYY-MM-DD HH:MM:SS.mmm' (in UTC)
+   */
+  private formatDateForClickHouse(date: Date): string {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+    const ms = String(date.getUTCMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+  }
+
+  /**
+   * Create an AST expression for a value.
+   * Date values are wrapped in toDateTime64() for ClickHouse compatibility.
+   */
+  private createValueExpression(value: Date | string | number): Expression {
+    if (value instanceof Date) {
+      // Wrap Date in toDateTime64(formatted_string, 3) for ClickHouse DateTime64(3) columns
+      return {
+        expression_type: "call",
+        name: "toDateTime64",
+        args: [
+          { expression_type: "constant", value: this.formatDateForClickHouse(value) } as Constant,
+          { expression_type: "constant", value: 3 } as Constant,
+        ],
+      } as Call;
+    }
+    return { expression_type: "constant", value } as Constant;
+  }
+
+  /**
+   * Map condition operator to CompareOperationOp
+   */
+  private mapConditionOpToCompareOp(
+    op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte"
+  ): CompareOperationOp {
+    switch (op) {
+      case "eq":
+        return CompareOperationOp.Eq;
+      case "neq":
+        return CompareOperationOp.NotEq;
+      case "gt":
+        return CompareOperationOp.Gt;
+      case "gte":
+        return CompareOperationOp.GtEq;
+      case "lt":
+        return CompareOperationOp.Lt;
+      case "lte":
+        return CompareOperationOp.LtEq;
+    }
+  }
+
+  /**
+   * Create an AST expression from a WhereClauseCondition
+   *
+   * @param column - The column name
+   * @param condition - The condition to apply
+   * @param tableAlias - Optional table alias to qualify the column reference.
+   *                     When provided, constructs the field chain as [tableAlias, column]
+   *                     so resolveFieldChain will resolve to the correct table in multi-join queries.
+   * @returns The AST expression for the condition
+   */
+  private createConditionExpression(
+    column: string,
+    condition: WhereClauseCondition,
+    tableAlias?: string
+  ): Expression {
+    // When tableAlias is provided, qualify the field chain to ensure it binds
+    // to the correct table in multi-join queries
+    const fieldExpr: Field = {
+      expression_type: "field",
+      chain: tableAlias ? [tableAlias, column] : [column],
+    };
+
+    if (condition.op === "between") {
+      const betweenExpr: BetweenExpr = {
+        expression_type: "between_expr",
+        expr: fieldExpr,
+        low: this.createValueExpression(condition.low),
+        high: this.createValueExpression(condition.high),
+      };
+      return betweenExpr;
+    }
+
+    if (condition.op === "in") {
+      // Create a tuple of values for the IN clause
+      const tupleExpr: Tuple = {
+        expression_type: "tuple",
+        exprs: condition.values.map((value) => this.createValueExpression(value)),
+      };
+      const inExpr: CompareOperation = {
+        expression_type: "compare_operation",
+        left: fieldExpr,
+        right: tupleExpr,
+        op: CompareOperationOp.In,
+      };
+      return inExpr;
+    }
+
+    // Simple comparison
+    const compareExpr: CompareOperation = {
+      expression_type: "compare_operation",
+      left: fieldExpr,
+      right: this.createValueExpression(condition.value),
+      op: this.mapConditionOpToCompareOp(condition.op),
+    };
+    return compareExpr;
+  }
+
+  /**
+   * Create a WHERE clause expression for enforced conditions and required filters.
+   *
+   * This method applies:
+   * 1. All conditions from enforcedWhereClause (tenant isolation + plan limits)
+   * 2. Required filters from the table schema (e.g., engine = 'V2')
+   *
+   * Conditions are applied if the column exists in either:
+   * - The exposed columns (tableSchema.columns)
+   * - The tenant columns (tableSchema.tenantColumns)
+   *
+   * This ensures the same enforcedWhereClause can be used across different tables.
+   *
+   * All guard expressions are qualified with the table alias to ensure they bind
+   * to the correct table in multi-join queries, preventing potential security
+   * issues where an unqualified column reference could bind to the wrong table.
+   */
+  private createEnforcedGuard(tableSchema: TableSchema, tableAlias: string): Expression | null {
+    const { requiredFilters, tenantColumns } = tableSchema;
+    const guards: Expression[] = [];
+
+    // Build a set of valid columns for this table (exposed + tenant columns)
+    const validColumns = new Set<string>(Object.keys(tableSchema.columns));
+    if (tenantColumns) {
+      if (tenantColumns.organizationId) validColumns.add(tenantColumns.organizationId);
+      if (tenantColumns.projectId) validColumns.add(tenantColumns.projectId);
+      if (tenantColumns.environmentId) validColumns.add(tenantColumns.environmentId);
+    }
+
+    // Apply all enforced conditions for columns that exist in this table
+    // Pass tableAlias to ensure guards are qualified and bind to the correct table
+    for (const [column, condition] of Object.entries(this.context.enforcedWhereClause)) {
+      // Skip undefined/null conditions (allows conditional inclusion like project_id?: condition)
+      if (condition === undefined || condition === null) {
+        continue;
+      }
+      // Only apply if column exists in this table's schema or is a tenant column
+      if (validColumns.has(column)) {
+        guards.push(this.createConditionExpression(column, condition, tableAlias));
+      }
+    }
+
+    // Add required filters from the table schema (e.g., engine = 'V2')
+    // Also qualified with table alias to ensure correct binding in multi-join queries
+    if (requiredFilters && requiredFilters.length > 0) {
+      for (const filter of requiredFilters) {
+        const filterGuard: CompareOperation = {
+          expression_type: "compare_operation",
+          op: CompareOperationOp.Eq,
+          left: { expression_type: "field", chain: [tableAlias, filter.column] } as Field,
+          right: { expression_type: "constant", value: filter.value } as Constant,
+        };
+        guards.push(filterGuard);
+      }
+    }
+
+    // Return null if no guards (empty enforcedWhereClause and no requiredFilters)
+    if (guards.length === 0) {
+      return null;
+    }
+
+    // If only one guard, return it directly (no need for AND wrapper)
+    if (guards.length === 1) {
+      return guards[0];
+    }
+
+    return {
+      expression_type: "and",
+      exprs: guards,
+    } as And;
+  }
+
+  // ============================================================
+  // Expression Visitors
+  // ============================================================
+
+  private visitCTE(node: CTE): string {
+    return this.visit(node.expr);
+  }
+
+  private visitAlias(node: Alias): string {
+    const expr = this.visit(node.expr);
+    if (node.hidden) {
+      return expr;
+    }
+    return `${expr} AS ${this.printIdentifier(node.alias)}`;
+  }
+
+  private visitArithmeticOperation(node: ArithmeticOperation): string {
+    const left = this.visit(node.left);
+    const right = this.visit(node.right);
+
+    switch (node.op) {
+      case ArithmeticOperationOp.Add:
+        return `plus(${left}, ${right})`;
+      case ArithmeticOperationOp.Sub:
+        return `minus(${left}, ${right})`;
+      case ArithmeticOperationOp.Mult:
+        return `multiply(${left}, ${right})`;
+      case ArithmeticOperationOp.Div:
+        return `divide(${left}, ${right})`;
+      case ArithmeticOperationOp.Mod:
+        return `modulo(${left}, ${right})`;
+      default:
+        throw new ImpossibleASTError(`Unknown ArithmeticOperationOp: ${node.op}`);
+    }
+  }
+
+  private visitAnd(node: And): string {
+    if (node.exprs.length === 1) {
+      return this.visit(node.exprs[0]);
+    }
+
+    // Optimization: filter out constant true values, short-circuit on false
+    const exprs: string[] = [];
+    for (const expr of node.exprs) {
+      const printed = this.visit(expr);
+      if (printed === "0") {
+        // Short-circuit: and(..., 0, ...) => 0
+        return "0";
+      }
+      if (printed !== "1") {
+        // Skip constant true values
+        exprs.push(printed);
+      }
+    }
+
+    if (exprs.length === 0) {
+      return "1";
+    }
+    if (exprs.length === 1) {
+      return exprs[0];
+    }
+    return `and(${exprs.join(", ")})`;
+  }
+
+  private visitOr(node: Or): string {
+    if (node.exprs.length === 1) {
+      return this.visit(node.exprs[0]);
+    }
+
+    // Optimization: filter out constant false values, short-circuit on true
+    const exprs: string[] = [];
+    for (const expr of node.exprs) {
+      const printed = this.visit(expr);
+      if (printed === "1") {
+        // Short-circuit: or(..., 1, ...) => 1
+        return "1";
+      }
+      if (printed !== "0") {
+        // Skip constant false values
+        exprs.push(printed);
+      }
+    }
+
+    if (exprs.length === 0) {
+      return "0";
+    }
+    if (exprs.length === 1) {
+      return exprs[0];
+    }
+    return `or(${exprs.join(", ")})`;
+  }
+
+  private visitNot(node: Not): string {
+    return `not(${this.visit(node.expr)})`;
+  }
+
+  private visitCompareOperation(node: CompareOperation): string {
+    // Check if we need to transform values using valueMap
+    const columnSchema = this.extractColumnSchemaFromExpression(node.left);
+    const rightColumnSchema = this.extractColumnSchemaFromExpression(node.right);
+
+    // Transform the right side if it contains user-friendly values
+    const transformedRight = this.transformValueMapExpression(node.right, columnSchema);
+
+    // Check if we should use a text column for bare JSON field comparisons
+    // This applies to: Eq, NotEq, Like, ILike, NotLike, NotILike
+    const textColumnOps = [
+      CompareOperationOp.Eq,
+      CompareOperationOp.NotEq,
+      CompareOperationOp.Like,
+      CompareOperationOp.ILike,
+      CompareOperationOp.NotLike,
+      CompareOperationOp.NotILike,
+    ];
+    const useTextColumn = textColumnOps.includes(node.op);
+    const leftTextColumn = useTextColumn ? this.getTextColumnForExpression(node.left) : null;
+
+    // Build the left side, qualifying the text column with table alias if present
+    let left: string;
+    if (leftTextColumn) {
+      // Check if the field is qualified with a table alias (e.g., r.output)
+      // and prepend that alias to the text column to avoid ambiguity in JOINs
+      const fieldNode = node.left as Field;
+      if (fieldNode.expression_type === "field" && fieldNode.chain.length >= 2) {
+        const firstPart = fieldNode.chain[0];
+        if (typeof firstPart === "string" && this.tableContexts.has(firstPart)) {
+          // The field is qualified with a table alias, prepend it to the text column
+          left = this.printIdentifier(firstPart) + "." + this.printIdentifier(leftTextColumn);
+        } else {
+          left = this.printIdentifier(leftTextColumn);
+        }
+      } else {
+        left = this.printIdentifier(leftTextColumn);
+      }
+    } else {
+      left = this.visit(node.left);
+    }
+    const right = this.visit(transformedRight);
+
+    switch (node.op) {
+      case CompareOperationOp.Eq:
+        // Handle NULL comparison
+        if (
+          (transformedRight as Constant).expression_type === "constant" &&
+          (transformedRight as Constant).value === null
+        ) {
+          // Check if the column has a custom nullValue (e.g., '{}' for JSON columns)
+          if (columnSchema?.nullValue) {
+            return `equals(${left}, ${columnSchema.nullValue})`;
+          }
+          return `isNull(${left})`;
+        }
+        if (
+          (node.left as Constant).expression_type === "constant" &&
+          (node.left as Constant).value === null
+        ) {
+          // Check if the column has a custom nullValue (e.g., '{}' for JSON columns)
+          if (rightColumnSchema?.nullValue) {
+            return `equals(${right}, ${rightColumnSchema.nullValue})`;
+          }
+          return `isNull(${right})`;
+        }
+        return `equals(${left}, ${right})`;
+
+      case CompareOperationOp.NotEq:
+        // Handle NULL comparison
+        if (
+          (transformedRight as Constant).expression_type === "constant" &&
+          (transformedRight as Constant).value === null
+        ) {
+          // Check if the column has a custom nullValue (e.g., '{}' for JSON columns)
+          if (columnSchema?.nullValue) {
+            return `notEquals(${left}, ${columnSchema.nullValue})`;
+          }
+          return `isNotNull(${left})`;
+        }
+        if (
+          (node.left as Constant).expression_type === "constant" &&
+          (node.left as Constant).value === null
+        ) {
+          // Check if the column has a custom nullValue (e.g., '{}' for JSON columns)
+          if (rightColumnSchema?.nullValue) {
+            return `notEquals(${right}, ${rightColumnSchema.nullValue})`;
+          }
+          return `isNotNull(${right})`;
+        }
+        return `notEquals(${left}, ${right})`;
+
+      case CompareOperationOp.Lt:
+        return `less(${left}, ${right})`;
+      case CompareOperationOp.LtEq:
+        return `lessOrEquals(${left}, ${right})`;
+      case CompareOperationOp.Gt:
+        return `greater(${left}, ${right})`;
+      case CompareOperationOp.GtEq:
+        return `greaterOrEquals(${left}, ${right})`;
+      case CompareOperationOp.Like:
+        return `like(${left}, ${right})`;
+      case CompareOperationOp.ILike:
+        return `ilike(${left}, ${right})`;
+      case CompareOperationOp.NotLike:
+        return `notLike(${left}, ${right})`;
+      case CompareOperationOp.NotILike:
+        return `notILike(${left}, ${right})`;
+      case CompareOperationOp.In:
+        return `in(${left}, ${right})`;
+      case CompareOperationOp.NotIn:
+        return `notIn(${left}, ${right})`;
+      case CompareOperationOp.GlobalIn:
+        return `globalIn(${left}, ${right})`;
+      case CompareOperationOp.GlobalNotIn:
+        return `globalNotIn(${left}, ${right})`;
+      case CompareOperationOp.Regex:
+        return `match(${left}, ${right})`;
+      case CompareOperationOp.NotRegex:
+        return `not(match(${left}, ${right}))`;
+      case CompareOperationOp.IRegex:
+        return `match(${left}, concat('(?i)', ${right}))`;
+      case CompareOperationOp.NotIRegex:
+        return `not(match(${left}, concat('(?i)', ${right})))`;
+      default:
+        throw new ImpossibleASTError(`Unknown CompareOperationOp: ${node.op}`);
+    }
+  }
+
+  /**
+   * Extract column schema from a field expression if it references a known column
+   */
+  private extractColumnSchemaFromExpression(expr: Expression): ColumnSchema | null {
+    if ((expr as Field).expression_type !== "field") return null;
+
+    const field = expr as Field;
+    const chain = field.chain;
+
+    if (chain.length === 0) return null;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    // Qualified reference: table.column
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+      if (!tableSchema) return null;
+
+      const columnName = chain[1];
+      if (typeof columnName !== "string") return null;
+
+      return tableSchema.columns[columnName] || null;
+    }
+
+    // Unqualified reference
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema) {
+        return columnSchema;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Transform a single string value using whereTransform, valueMap, or fieldMapping
+   * Returns the transformed value, or the original value if no transformation applies
+   */
+  private transformSingleValue(columnSchema: ColumnSchema, value: string): string {
+    // First try whereTransform function (highest priority)
+    if (columnSchema.whereTransform) {
+      return columnSchema.whereTransform(value);
+    }
+
+    // Then try static valueMap
+    if (columnSchema.valueMap) {
+      const internalValue = getInternalValue(columnSchema, value);
+      if (internalValue !== value) {
+        return internalValue;
+      }
+    }
+
+    // Then try runtime fieldMapping
+    if (hasFieldMapping(columnSchema) && columnSchema.fieldMapping) {
+      const internalValue = getInternalValueFromMappingCaseInsensitive(
+        this.context.fieldMappings,
+        columnSchema.fieldMapping,
+        value
+      );
+      if (internalValue !== null) {
+        return internalValue;
+      }
+    }
+
+    return value;
+  }
+
+  /**
+   * Transform an expression's values using the column's whereTransform, valueMap, or fieldMapping if applicable
+   * Returns the original expression if no transformation is needed
+   */
+  private transformValueMapExpression(
+    expr: Expression,
+    columnSchema: ColumnSchema | null
+  ): Expression {
+    // No column schema, return as-is
+    if (!columnSchema) {
+      return expr;
+    }
+
+    // Check if column has any transformation mechanism
+    const hasWhereTransform = columnSchema.whereTransform !== undefined;
+    const hasValueMap = columnSchema.valueMap && Object.keys(columnSchema.valueMap).length > 0;
+    const hasFieldMap = hasFieldMapping(columnSchema);
+    if (!hasWhereTransform && !hasValueMap && !hasFieldMap) {
+      return expr;
+    }
+
+    // Handle constant string values
+    if ((expr as Constant).expression_type === "constant") {
+      const constant = expr as Constant;
+      if (typeof constant.value === "string") {
+        const internalValue = this.transformSingleValue(columnSchema, constant.value);
+        if (internalValue !== constant.value) {
+          // Return a new constant with the transformed value
+          return {
+            expression_type: "constant",
+            value: internalValue,
+          } as Constant;
+        }
+      }
+      return expr;
+    }
+
+    // Handle arrays (for IN expressions with [...])
+    if ((expr as ASTArray).expression_type === "array") {
+      const array = expr as ASTArray;
+      const transformedExprs = array.exprs.map((e) =>
+        this.transformValueMapExpression(e, columnSchema)
+      );
+
+      // Check if any expressions were actually transformed
+      const hasChanges = transformedExprs.some((e, i) => e !== array.exprs[i]);
+      if (hasChanges) {
+        return {
+          expression_type: "array",
+          exprs: transformedExprs,
+        } as ASTArray;
+      }
+      return expr;
+    }
+
+    // Handle tuples (for IN expressions with (...))
+    if ((expr as Tuple).expression_type === "tuple") {
+      const tuple = expr as Tuple;
+      const transformedExprs = tuple.exprs.map((e) =>
+        this.transformValueMapExpression(e, columnSchema)
+      );
+
+      // Check if any expressions were actually transformed
+      const hasChanges = transformedExprs.some((e, i) => e !== tuple.exprs[i]);
+      if (hasChanges) {
+        return {
+          expression_type: "tuple",
+          exprs: transformedExprs,
+        } as Tuple;
+      }
+      return expr;
+    }
+
+    // Other expression types, return as-is
+    return expr;
+  }
+
+  private visitBetweenExpr(node: BetweenExpr): string {
+    const expr = this.visit(node.expr);
+    const low = this.visit(node.low);
+    const high = this.visit(node.high);
+    const notKw = node.negated ? " NOT" : "";
+    return `${expr}${notKw} BETWEEN ${low} AND ${high}`;
+  }
+
+  private visitOrderExpr(node: OrderExpr): string {
+    const expr = this.visit(node.expr);
+    return `${expr} ${node.order || "ASC"}`;
+  }
+
+  private visitArrayAccess(node: ArrayAccess): string {
+    const array = this.visit(node.array);
+    const property = this.visit(node.property);
+    return `${array}[${property}]`;
+  }
+
+  private visitArray(node: ASTArray): string {
+    const elements = node.exprs.map((e) => this.visit(e));
+    return `[${elements.join(", ")}]`;
+  }
+
+  private visitDict(node: Dict): string {
+    // Convert dict to tuple format for ClickHouse
+    let str = "tuple('__hx_tag', '__hx_obj'";
+    for (const [key, value] of node.items) {
+      str += `, ${this.visit(key)}, ${this.visit(value)}`;
+    }
+    return str + ")";
+  }
+
+  private visitTupleAccess(node: TupleAccess): string {
+    const tuple = this.visit(node.tuple);
+    const index = node.index;
+    const isSimple =
+      (node.tuple as Field).expression_type === "field" ||
+      (node.tuple as Tuple).expression_type === "tuple" ||
+      (node.tuple as Call).expression_type === "call";
+    return isSimple ? `${tuple}.${index}` : `(${tuple}).${index}`;
+  }
+
+  private visitTuple(node: Tuple): string {
+    const elements = node.exprs.map((e) => this.visit(e));
+    return `tuple(${elements.join(", ")})`;
+  }
+
+  private visitLambda(node: Lambda): string {
+    const identifiers = node.args.map((arg) => this.printIdentifier(arg));
+    if (identifiers.length === 0) {
+      throw new QueryError("Lambdas require at least one argument");
+    }
+    const args = identifiers.length === 1 ? identifiers[0] : `(${identifiers.join(", ")})`;
+    return `${args} -> ${this.visit(node.expr as Expression)}`;
+  }
+
+  private visitConstant(node: Constant): string {
+    const value = node.value;
+
+    // Inline simple constants
+    if (value === null) {
+      return "NULL";
+    }
+    if (typeof value === "boolean") {
+      return value ? "1" : "0";
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        if (Number.isNaN(value)) return "nan";
+        return value > 0 ? "inf" : "-inf";
+      }
+      return String(value);
+    }
+
+    // Use parameterized query for strings and other types
+    return this.context.addValue(value);
+  }
+
+  private visitField(node: Field): string {
+    if (node.chain.length === 0) {
+      throw new ImpossibleASTError("Field chain is empty");
+    }
+
+    // Handle asterisk
+    if (node.chain.length === 1 && node.chain[0] === "*") {
+      return "*";
+    }
+
+    // Handle table.* asterisk
+    if (node.chain.length === 2 && node.chain[1] === "*") {
+      const tableAlias = node.chain[0];
+      if (typeof tableAlias === "string") {
+        return `${this.printIdentifier(tableAlias)}.*`;
+      }
+    }
+
+    // Check if this field is a virtual column
+    // BUT: if the column has whereTransform and we're in a comparison context,
+    // use the raw column instead of the expression (for efficient index usage)
+    const columnSchema = this.resolveFieldToColumnSchema(node.chain);
+    const inComparisonContext = this.isInComparisonContext();
+
+    if (columnSchema?.whereTransform && inComparisonContext) {
+      // Use raw column for WHERE comparisons when whereTransform is defined
+      // Must table-qualify to avoid alias conflicts with SELECT expressions
+      const tableQualifiedChain = this.resolveFieldChainWithTableAlias(node.chain);
+      return tableQualifiedChain.map((part) => this.printIdentifierOrIndex(part)).join(".");
+    }
+
+    // In GROUP BY context, for virtual columns (columns with expressions),
+    // use the alias name instead of the expression. ClickHouse allows
+    // referencing SELECT aliases in GROUP BY.
+    if (this.inGroupByContext) {
+      const virtualColumnName = this.getVirtualColumnNameForField(node.chain);
+      if (virtualColumnName !== null) {
+        return this.printIdentifier(virtualColumnName);
+      }
+    }
+
+    const virtualExpression = this.getVirtualColumnExpressionForField(node.chain);
+    if (virtualExpression !== null) {
+      // Return the expression wrapped in parentheses
+      return `(${virtualExpression})`;
+    }
+
+    // Inject dataPrefix for JSON columns if needed (e.g., output.message -> output.data.message)
+    const chainWithPrefix = this.injectDataPrefix(node.chain);
+
+    // Try to resolve column names through table context
+    const resolvedChain = this.resolveFieldChain(chainWithPrefix);
+
+    // For Map columns, convert dot-notation to bracket syntax:
+    // metadata.user -> metadata['user']
+    if (resolvedChain.length > 1) {
+      const rootColumnSchema = this.resolveFieldToColumnSchema([node.chain[0]]);
+      if (rootColumnSchema?.type.startsWith("Map(")) {
+        const rootCol = this.printIdentifierOrIndex(resolvedChain[0]);
+        const mapKeys = resolvedChain.slice(1);
+        let result = rootCol;
+        for (const key of mapKeys) {
+          result = `${result}[${this.context.addValue(String(key))}]`;
+        }
+        return result;
+      }
+    }
+
+    // Print each chain element
+    let result = resolvedChain.map((part) => this.printIdentifierOrIndex(part)).join(".");
+
+    // For JSON column subfield access (e.g., error.data.name), add .:String type hint
+    // This is ONLY required when the query has GROUP BY, because:
+    // 1. ClickHouse's Dynamic/Variant types are not allowed in GROUP BY without type casting
+    // 2. SELECT/GROUP BY expressions must match
+    // For queries without GROUP BY, the .:String type hint actually breaks the query
+    // (returns NULL instead of the actual value)
+    // We also skip this in WHERE comparisons where it breaks the query
+    if (resolvedChain.length > 1) {
+      // Check if the root column (first part) is a JSON column
+      const rootColumnSchema = this.resolveFieldToColumnSchema([node.chain[0]]);
+      // Add .:String ONLY for GROUP BY queries, and NOT in WHERE comparisons
+      if (
+        rootColumnSchema?.type === "JSON" &&
+        this.queryHasGroupBy &&
+        !this.isInWhereComparisonContext()
+      ) {
+        // Add .:String type hint for JSON subfield access
+        result = `${result}.:String`;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if we're in a context where we should use raw column names
+   * instead of virtual column expressions (WHERE comparisons or GROUP BY)
+   */
+  private isInComparisonContext(): boolean {
+    // Check if we're in GROUP BY context
+    if (this.inGroupByContext) {
+      return true;
+    }
+
+    // Check if we're inside a comparison operation (WHERE/HAVING context)
+    for (const node of this.stack) {
+      if ((node as CompareOperation).expression_type === "compare_operation") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check if we're inside a WHERE/HAVING comparison operation.
+   * Unlike isInComparisonContext(), this does NOT include GROUP BY context.
+   * Used to skip .:String type hints in WHERE clauses where they break queries.
+   */
+  private isInWhereComparisonContext(): boolean {
+    for (const node of this.stack) {
+      if ((node as CompareOperation).expression_type === "compare_operation") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Resolve field chain with table alias prefix to avoid alias conflicts.
+   * This is used in WHERE clauses when a column has whereTransform to ensure
+   * we reference the raw column, not a SELECT alias with the same name.
+   */
+  private resolveFieldChainWithTableAlias(chain: Array<string | number>): Array<string | number> {
+    if (chain.length === 0) return chain;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return chain;
+
+    // If already qualified (table.column), use normal resolution
+    if (chain.length >= 2) {
+      return this.resolveFieldChain(chain);
+    }
+
+    // Unqualified reference - need to find the table and add its alias
+    const columnName = firstPart;
+    for (const [tableAlias, tableSchema] of this.tableContexts.entries()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema) {
+        const resolvedColumnName = columnSchema.clickhouseName || columnSchema.name;
+        return [tableAlias, resolvedColumnName, ...chain.slice(1)];
+      }
+    }
+
+    // Not found in any table - return as-is
+    return chain;
+  }
+
+  /**
+   * Check if a field chain represents JSON subfield access (e.g., error.data.name)
+   * Returns true if the root column is JSON type and there are additional path parts
+   */
+  private isJsonSubfieldAccess(chain: Array<string | number>): boolean {
+    if (chain.length <= 1) return false;
+
+    const rootColumnSchema = this.resolveFieldToColumnSchema([chain[0]]);
+    return rootColumnSchema?.type === "JSON";
+  }
+
+  /**
+   * Check if a field should use a text column instead of the JSON column.
+   * Returns the text column name if the field is a bare JSON field with textColumn defined,
+   * or null if the original column should be used.
+   *
+   * A "bare" JSON field means selecting the entire column (e.g., SELECT output)
+   * rather than accessing a subfield (e.g., SELECT output.data.name).
+   */
+  private getTextColumnForField(chain: Array<string | number>): string | null {
+    if (chain.length === 0) return null;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    let columnSchema: ColumnSchema | null = null;
+
+    if (chain.length === 1) {
+      // Unqualified: just column name
+      columnSchema = this.resolveFieldToColumnSchema(chain);
+    } else if (chain.length === 2) {
+      // Could be table.column (qualified) - check if first part is a table alias
+      const tableSchema = this.tableContexts.get(firstPart);
+      if (tableSchema) {
+        const columnName = chain[1];
+        if (typeof columnName === "string") {
+          columnSchema = tableSchema.columns[columnName] || null;
+        }
+      }
+      // If not a table alias, it's JSON path access (e.g., output.data) - return null
+    }
+    // chain.length > 2 means JSON path access - return null
+
+    return columnSchema?.textColumn ?? null;
+  }
+
+  /**
+   * Get the text column for an expression if it's a bare JSON field.
+   * Returns null if the expression is not a field or doesn't have a textColumn.
+   */
+  private getTextColumnForExpression(expr: Expression): string | null {
+    if ((expr as Field).expression_type !== "field") return null;
+    return this.getTextColumnForField((expr as Field).chain);
+  }
+
+  /**
+   * Get the dataPrefix for a field chain if the root column has one defined.
+   * Returns null if the column doesn't have a dataPrefix or if this isn't a subfield access.
+   */
+  private getDataPrefixForField(chain: Array<string | number>): string | null {
+    if (chain.length < 2) return null; // Need at least column.subfield
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    // Check if first part is a table alias (table.column.subfield)
+    const tableSchema = this.tableContexts.get(firstPart);
+    if (tableSchema) {
+      // Qualified: table.column.subfield - need at least 3 parts
+      if (chain.length < 3) return null;
+      const columnName = chain[1];
+      if (typeof columnName !== "string") return null;
+      const columnSchema = tableSchema.columns[columnName];
+      return columnSchema?.dataPrefix ?? null;
+    }
+
+    // Unqualified: column.subfield
+    const columnSchema = this.resolveFieldToColumnSchema([firstPart]);
+    return columnSchema?.dataPrefix ?? null;
+  }
+
+  /**
+   * Inject dataPrefix into a field chain if the root column has one defined.
+   * e.g., [output, message] -> [output, data, message] when dataPrefix is "data"
+   * Returns the original chain if no dataPrefix applies.
+   */
+  private injectDataPrefix(chain: Array<string | number>): Array<string | number> {
+    const dataPrefix = this.getDataPrefixForField(chain);
+    if (!dataPrefix) return chain;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return chain;
+
+    // Check if first part is a table alias
+    const tableSchema = this.tableContexts.get(firstPart);
+    if (tableSchema) {
+      // Qualified: table.column.subfield -> table.column.dataPrefix.subfield
+      // [table, column, subfield] -> [table, column, dataPrefix, subfield]
+      return [chain[0], chain[1], dataPrefix, ...chain.slice(2)];
+    }
+
+    // Unqualified: column.subfield -> column.dataPrefix.subfield
+    // [column, subfield] -> [column, dataPrefix, subfield]
+    return [chain[0], dataPrefix, ...chain.slice(1)];
+  }
+
+  /**
+   * Build an alias name for a field chain, excluding the dataPrefix if present.
+   * e.g., [output, message] with dataPrefix "data" -> "output_message"
+   * This gives users clean column names without the internal data wrapper.
+   */
+  private buildAliasWithoutDataPrefix(
+    chain: Array<string | number>,
+    dataPrefix: string | null
+  ): string {
+    // Filter to just string parts and join with underscores
+    const parts = chain.filter((p): p is string => typeof p === "string");
+
+    if (dataPrefix) {
+      // Remove the dataPrefix from the parts (it's an implementation detail)
+      const prefixIndex = parts.indexOf(dataPrefix);
+      if (prefixIndex > 0) {
+        // Only remove if it's not the first element (column name)
+        parts.splice(prefixIndex, 1);
+      }
+    }
+
+    return parts.join("_");
+  }
+
+  /**
+   * Resolve a field chain to its column schema (if it references a known column)
+   */
+  private resolveFieldToColumnSchema(chain: Array<string | number>): ColumnSchema | null {
+    if (chain.length === 0) return null;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    // Qualified reference: table.column
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+      if (!tableSchema) return null;
+
+      const columnName = chain[1];
+      if (typeof columnName !== "string") return null;
+
+      return tableSchema.columns[columnName] || null;
+    }
+
+    // Unqualified reference
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema) {
+        return columnSchema;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a field chain references a virtual column and return its expression
+   * @returns The virtual column expression, or null if not a virtual column
+   */
+  private getVirtualColumnExpressionForField(chain: Array<string | number>): string | null {
+    if (chain.length === 0) return null;
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") return null;
+
+    // Case 1: Qualified reference like table.column
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+      if (!tableSchema) return null;
+
+      const columnName = chain[1];
+      if (typeof columnName !== "string") return null;
+
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema && isVirtualColumn(columnSchema)) {
+        return columnSchema.expression!;
+      }
+      return null;
+    }
+
+    // Case 2: Unqualified reference like just "column"
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema && isVirtualColumn(columnSchema)) {
+        return columnSchema.expression!;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve field chain to use ClickHouse column names where applicable
+   * Handles both qualified (table.column) and unqualified (column) references
+   *
+   * @throws QueryError if the column is not found in any table schema and is not a SELECT alias
+   */
+  private resolveFieldChain(chain: Array<string | number>): Array<string | number> {
+    if (chain.length === 0) {
+      return chain;
+    }
+
+    const firstPart = chain[0];
+    if (typeof firstPart !== "string") {
+      return chain; // Index access, return as-is
+    }
+
+    // Case 1: Qualified reference like table.column or table.column.nested
+    if (chain.length >= 2) {
+      const tableAlias = firstPart;
+      const tableSchema = this.tableContexts.get(tableAlias);
+
+      if (tableSchema) {
+        // This is a table.column reference
+        const columnName = chain[1];
+        if (typeof columnName === "string") {
+          const resolvedColumn = this.resolveColumnName(tableSchema, columnName, tableAlias);
+          return [tableAlias, resolvedColumn, ...chain.slice(2)];
+        }
+      }
+      // Not a known table alias, might be a nested field or JSON path - return as-is
+      return chain;
+    }
+
+    // Case 2: Unqualified reference like just "column"
+    // Try to find the column in any table context
+    const columnName = firstPart;
+    for (const tableSchema of this.tableContexts.values()) {
+      const columnSchema = tableSchema.columns[columnName];
+      if (columnSchema) {
+        return [columnSchema.clickhouseName || columnSchema.name, ...chain.slice(1)];
+      }
+    }
+
+    // Check if it's a SELECT alias (e.g., from COUNT() or explicit AS)
+    // Case-insensitive lookup: map key is lowercase, value is the canonical form
+    // that matches the alias as it appears in the generated SQL
+    const canonicalAlias = this.selectAliases.get(columnName.toLowerCase());
+    if (canonicalAlias !== undefined) {
+      return [canonicalAlias, ...chain.slice(1)];
+    }
+
+    // Check if this is an internal-only column being accessed in a user projection context
+    // (SELECT, ORDER BY, GROUP BY, HAVING). These columns are used internally for
+    // tenant isolation but should not be user-queryable unless explicitly exposed.
+    if (this.inProjectionContext && this.internalOnlyColumns.has(columnName)) {
+      const availableColumns = this.getAvailableColumnNames();
+      throw new QueryError(
+        `Column "${columnName}" is not available for querying. Available columns: ${availableColumns.join(
+          ", "
+        )}`
+      );
+    }
+
+    // Check if this is an allowed internal column (e.g., tenant columns)
+    // These are ClickHouse column names that are allowed for internal use only
+    // (e.g., in WHERE clauses for tenant isolation)
+    if (this.allowedInternalColumns.has(columnName)) {
+      return chain;
+    }
+
+    // Column not found in any table context and not a SELECT alias
+    // This is a security issue - block access to unknown columns
+    if (this.tableContexts.size > 0) {
+      // Only throw if we have tables in context (otherwise might be subquery)
+      // Check if the user typed a ClickHouse column name instead of the TSQL name
+      const suggestion = this.findTSQLNameForClickHouseName(columnName);
+      if (suggestion) {
+        throw new QueryError(`Unknown column "${columnName}". Did you mean "${suggestion}"?`);
+      }
+
+      const availableColumns = this.getAvailableColumnNames();
+      throw new QueryError(
+        `Unknown column "${columnName}". Available columns: ${availableColumns.join(", ")}`
+      );
+    }
+
+    // No tables in context (might be FROM subquery without alias) - return as-is
+    return chain;
+  }
+
+  /**
+   * Get list of available column names from all tables in context
+   */
+  private getAvailableColumnNames(): string[] {
+    const columns: string[] = [];
+    for (const tableSchema of this.tableContexts.values()) {
+      columns.push(...Object.keys(tableSchema.columns));
+    }
+    return [...new Set(columns)].sort();
+  }
+
+  /**
+   * Check if a ClickHouse column name is exposed in the table schema's public columns.
+   * A column is considered exposed if:
+   * - It exists as a column name in tableSchema.columns, OR
+   * - It is the clickhouseName of a column in tableSchema.columns
+   *
+   * @param tableSchema The table schema to check
+   * @param clickhouseColumnName The ClickHouse column name to check
+   * @returns true if the column is exposed to users, false if it's internal-only
+   */
+  private isColumnExposedInSchema(tableSchema: TableSchema, clickhouseColumnName: string): boolean {
+    for (const [tsqlName, columnSchema] of Object.entries(tableSchema.columns)) {
+      // Check if the ClickHouse column name matches either:
+      // 1. The TSQL name (if no clickhouseName mapping exists)
+      // 2. The explicit clickhouseName mapping
+      const actualClickhouseName = columnSchema.clickhouseName || tsqlName;
+      if (actualClickhouseName === clickhouseColumnName) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Find the TSQL column name for a given ClickHouse column name.
+   * This is used to provide helpful suggestions when users accidentally
+   * use internal ClickHouse column names instead of TSQL names.
+   *
+   * @returns The TSQL column name if found, null otherwise
+   */
+  private findTSQLNameForClickHouseName(clickhouseName: string): string | null {
+    for (const tableSchema of this.tableContexts.values()) {
+      for (const [tsqlName, columnSchema] of Object.entries(tableSchema.columns)) {
+        if (columnSchema.clickhouseName === clickhouseName) {
+          return tsqlName;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Resolve a column name to its ClickHouse name using the table schema
+   *
+   * @throws QueryError if the column is not found in the table schema
+   */
+  private resolveColumnName(
+    tableSchema: TableSchema,
+    columnName: string,
+    tableAlias?: string
+  ): string {
+    const columnSchema = tableSchema.columns[columnName];
+    if (columnSchema) {
+      return columnSchema.clickhouseName || columnSchema.name;
+    }
+
+    // Check if this is a tenant column that's not exposed in the schema's columns
+    // These are internal columns used for tenant isolation guards
+    const { tenantColumns, requiredFilters } = tableSchema;
+    if (tenantColumns) {
+      if (
+        columnName === tenantColumns.organizationId ||
+        columnName === tenantColumns.projectId ||
+        columnName === tenantColumns.environmentId
+      ) {
+        // Tenant columns are already ClickHouse column names, return as-is
+        return columnName;
+      }
+    }
+
+    // Check if this is a required filter column (e.g., engine = 'V2')
+    // These are internal columns used for enforced filters
+    if (requiredFilters) {
+      for (const filter of requiredFilters) {
+        if (columnName === filter.column) {
+          // Required filter columns are already ClickHouse column names, return as-is
+          return columnName;
+        }
+      }
+    }
+
+    // Column not in schema - this is a security issue, block access
+    // Check if the user typed a ClickHouse column name instead of the TSQL name
+    for (const [tsqlName, colSchema] of Object.entries(tableSchema.columns)) {
+      if (colSchema.clickhouseName === columnName) {
+        throw new QueryError(`Unknown column "${columnName}". Did you mean "${tsqlName}"?`);
+      }
+    }
+
+    const availableColumns = Object.keys(tableSchema.columns).sort().join(", ");
+    const tableName = tableAlias || tableSchema.name;
+    throw new QueryError(
+      `Unknown column "${columnName}" on table "${tableName}". Available columns: ${availableColumns}`
+    );
+  }
+
+  private visitPlaceholder(node: Placeholder): string {
+    return this.visit(node.expr);
+  }
+
+  private visitCall(node: Call): string {
+    const name = node.name;
+
+    // Handle prettyFormat() — strip wrapper, only emit the inner expression
+    if (name.toLowerCase() === "prettyformat") {
+      if (node.args.length !== 2) {
+        throw new QueryError("prettyFormat() requires exactly 2 arguments");
+      }
+      return this.visit(node.args[0]);
+    }
+
+    // Handle timeBucket() - special TSQL function for automatic time bucketing
+    if (name.toLowerCase() === "timebucket") {
+      return this.visitTimeBucket(node);
+    }
+
+    // Check if this is a comparison function
+    if (Object.prototype.hasOwnProperty.call(TSQL_COMPARISON_MAPPING, name)) {
+      const op = TSQL_COMPARISON_MAPPING[name];
+      if (node.args.length !== 2) {
+        throw new QueryError(`Comparison '${name}' requires exactly two arguments`);
+      }
+      return this.visitCompareOperation({
+        expression_type: "compare_operation",
+        left: node.args[0],
+        right: node.args[1],
+        op,
+      });
+    }
+
+    // Check for aggregation function
+    const aggMeta = findTSQLAggregation(name);
+    if (aggMeta) {
+      validateFunctionArgs(node.args, aggMeta.minArgs, aggMeta.maxArgs, name, {
+        functionTerm: "aggregation",
+      });
+
+      // Check for nested aggregations
+      for (const stackNode of this.stack.slice().reverse()) {
+        if ((stackNode as SelectQuery).expression_type === "select_query") {
+          break;
+        }
+        if ((stackNode as Call).expression_type === "call" && stackNode !== node) {
+          const stackCall = stackNode as Call;
+          if (findTSQLAggregation(stackCall.name)) {
+            throw new QueryError(
+              `Aggregation '${name}' cannot be nested inside another aggregation '${stackCall.name}'`
+            );
+          }
+        }
+      }
+
+      const args = node.args.map((arg) => this.visit(arg));
+      const params = node.params ? node.params.map((p) => this.visit(p)) : null;
+      const paramsPart = params ? `(${params.join(", ")})` : "";
+      const distinctPart = node.distinct ? "DISTINCT " : "";
+      return `${aggMeta.clickhouseName}${paramsPart}(${distinctPart}${args.join(", ")})`;
+    }
+
+    // Check for regular function
+    const funcMeta = findTSQLFunction(name);
+    if (funcMeta) {
+      validateFunctionArgs(node.args, funcMeta.minArgs, funcMeta.maxArgs, name);
+
+      const args = this.visitCallArgs(name, node.args);
+      const params = node.params ? node.params.map((p) => this.visit(p)) : null;
+      const paramsPart = params ? `(${params.join(", ")})` : "";
+      return `${funcMeta.clickhouseName}${paramsPart}(${args.join(", ")})`;
+    }
+
+    // Unknown function - throw error
+    throw new QueryError(`Unknown function: ${name}`);
+  }
+
+  /**
+   * Valid ClickHouse interval unit keywords used by date functions like dateAdd, dateDiff, etc.
+   */
+  private static readonly INTERVAL_UNITS = new Set([
+    "nanosecond",
+    "microsecond",
+    "millisecond",
+    "second",
+    "minute",
+    "hour",
+    "day",
+    "week",
+    "month",
+    "quarter",
+    "year",
+  ]);
+
+  /**
+   * Date functions whose first argument is an interval unit keyword.
+   * ClickHouse requires the unit as a bare keyword (e.g., `dateAdd(day, 7, col)`),
+   * not a string literal (e.g., `dateAdd('day', 7, col)` fails).
+   */
+  private static readonly DATE_FUNCTIONS_WITH_INTERVAL_UNIT = new Set([
+    "dateadd",
+    "datesub",
+    "datediff",
+    "date_add",
+    "date_sub",
+    "date_diff",
+  ]);
+
+  /**
+   * Visit function call arguments, handling date functions that require an interval unit
+   * keyword as their first argument. For these functions, the first arg is output as a
+   * bare keyword instead of being parameterized or resolved as a column reference.
+   */
+  private visitCallArgs(functionName: string, args: Expression[]): string[] {
+    const lowerName = functionName.toLowerCase();
+
+    if (
+      ClickHousePrinter.DATE_FUNCTIONS_WITH_INTERVAL_UNIT.has(lowerName) &&
+      args.length > 0
+    ) {
+      const firstArg = args[0];
+      const intervalUnit = this.extractIntervalUnit(firstArg);
+
+      if (intervalUnit) {
+        return [intervalUnit, ...args.slice(1).map((arg) => this.visit(arg))];
+      }
+    }
+
+    return args.map((arg) => this.visit(arg));
+  }
+
+  /**
+   * Try to extract a valid interval unit keyword from an expression.
+   * Handles both string constants ('day') and bare identifiers (day).
+   * Returns the bare keyword string if valid, or null if not an interval unit.
+   */
+  private extractIntervalUnit(expr: Expression): string | null {
+    if (expr.expression_type === "constant") {
+      const value = (expr as Constant).value;
+      if (typeof value === "string" && ClickHousePrinter.INTERVAL_UNITS.has(value.toLowerCase())) {
+        return value.toLowerCase();
+      }
+    }
+
+    if (expr.expression_type === "field") {
+      const chain = (expr as Field).chain;
+      if (chain.length === 1 && typeof chain[0] === "string") {
+        const name = chain[0].toLowerCase();
+        if (ClickHousePrinter.INTERVAL_UNITS.has(name)) {
+          return name;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  private visitJoinConstraint(node: JoinConstraint): string {
+    return this.visit(node.expr);
+  }
+
+  private visitWindowFrameExpr(node: WindowFrameExpr): string {
+    if (node.frame_type === "CURRENT ROW") {
+      return "CURRENT ROW";
+    }
+    if (node.frame_value !== undefined) {
+      return `${node.frame_value} ${node.frame_type}`;
+    }
+    return `UNBOUNDED ${node.frame_type}`;
+  }
+
+  private visitWindowExpr(node: WindowExpr): string {
+    const parts: string[] = [];
+
+    if (node.partition_by && node.partition_by.length > 0) {
+      parts.push(`PARTITION BY ${node.partition_by.map((e) => this.visit(e)).join(", ")}`);
+    }
+
+    if (node.order_by && node.order_by.length > 0) {
+      parts.push(`ORDER BY ${node.order_by.map((e) => this.visit(e)).join(", ")}`);
+    }
+
+    if (node.frame_method && node.frame_start) {
+      let frameStr = `${node.frame_method} `;
+      if (node.frame_end) {
+        frameStr += `BETWEEN ${this.visit(node.frame_start)} AND ${this.visit(node.frame_end)}`;
+      } else {
+        frameStr += this.visit(node.frame_start);
+      }
+      parts.push(frameStr);
+    }
+
+    return parts.join(" ");
+  }
+
+  private visitWindowFunction(node: WindowFunction): string {
+    const args = node.args ? node.args.map((a) => this.visit(a)) : [];
+    const funcCall = `${node.name}(${args.join(", ")})`;
+
+    if (node.over_identifier) {
+      return `${funcCall} OVER ${this.printIdentifier(node.over_identifier)}`;
+    }
+    if (node.over_expr) {
+      return `${funcCall} OVER (${this.visit(node.over_expr)})`;
+    }
+    return funcCall;
+  }
+
+  private visitLimitByExpr(node: LimitByExpr): string {
+    const exprs = node.exprs.map((e) => this.visit(e)).join(", ");
+    const offsetPart = node.offset_value ? ` OFFSET ${this.visit(node.offset_value)}` : "";
+    return `LIMIT ${this.visit(node.n)}${offsetPart} BY ${exprs}`;
+  }
+
+  private visitRatioExpr(node: RatioExpr): string {
+    const left = this.visit(node.left);
+    if (node.right) {
+      return `${left}/${this.visit(node.right)}`;
+    }
+    return left;
+  }
+
+  private visitSampleExpr(node: SampleExpr): string {
+    const sample = this.visitRatioExpr(node.sample_value);
+    if (node.offset_value) {
+      return `SAMPLE ${sample} OFFSET ${this.visitRatioExpr(node.offset_value)}`;
+    }
+    return `SAMPLE ${sample}`;
+  }
+
+  // ============================================================
+  // timeBucket() Support
+  // ============================================================
+
+  /**
+   * Handle the `timeBucket()` TSQL function.
+   *
+   * Resolves the table's timeConstraint column to its ClickHouse name,
+   * calculates an appropriate interval from the query's time range,
+   * and emits `toStartOfInterval(column, INTERVAL N UNIT)`.
+   *
+   * @throws QueryError if timeBucket() is called with arguments, or if the table
+   *   has no timeConstraint, or if no timeRange is provided in the context.
+   */
+  private visitTimeBucket(node: Call): string {
+    // Validate: timeBucket() takes no arguments
+    if (node.args.length > 0) {
+      throw new QueryError(
+        "timeBucket() does not accept arguments. It automatically uses the table's time constraint column."
+      );
+    }
+
+    // Find the table with a timeConstraint
+    const tableWithConstraint = this.findTimeConstraintTable();
+    if (!tableWithConstraint) {
+      throw new QueryError(
+        "timeBucket() requires a table with a timeConstraint defined in its schema."
+      );
+    }
+
+    const { tableSchema, clickhouseColumnName } = tableWithConstraint;
+
+    // Get the time range from context
+    const timeRange = this.context.timeRange;
+    if (!timeRange) {
+      throw new QueryError(
+        "timeBucket() requires a time range to be provided. Pass a timeRange option when compiling the query."
+      );
+    }
+
+    // Calculate the appropriate interval (use table-specific thresholds if defined)
+    const interval = calculateTimeBucketInterval(
+      timeRange.from,
+      timeRange.to,
+      tableSchema.timeBucketThresholds
+    );
+
+    // Emit toStartOfInterval(column, INTERVAL N UNIT)
+    return `toStartOfInterval(${escapeClickHouseIdentifier(clickhouseColumnName)}, INTERVAL ${interval.value} ${interval.unit})`;
+  }
+
+  /**
+   * Find a table in the current query context that has a timeConstraint defined.
+   * Returns the table schema and the resolved ClickHouse column name for the constraint.
+   */
+  private findTimeConstraintTable(): {
+    tableSchema: TableSchema;
+    clickhouseColumnName: string;
+  } | null {
+    for (const tableSchema of this.tableContexts.values()) {
+      if (tableSchema.timeConstraint) {
+        const columnSchema = tableSchema.columns[tableSchema.timeConstraint];
+        if (columnSchema) {
+          const clickhouseColumnName = columnSchema.clickhouseName || columnSchema.name;
+          return { tableSchema, clickhouseColumnName };
+        }
+      }
+    }
+    return null;
+  }
+
+  // ============================================================
+  // Helper Methods
+  // ============================================================
+
+  /**
+   * Print an identifier safely escaped for ClickHouse
+   */
+  private printIdentifier(name: string): string {
+    return escapeClickHouseIdentifier(name);
+  }
+
+  /**
+   * Print an identifier or array index
+   */
+  private printIdentifierOrIndex(part: string | number): string {
+    if (typeof part === "number") {
+      return String(part);
+    }
+    return escapeClickHouseIdentifier(part);
+  }
+
+  /**
+   * Check if a node is a SelectSetQuery
+   */
+  private isSelectSetQuery(node: AST): boolean {
+    return (node as SelectSetQuery).expression_type === "select_set_query";
+  }
+
+  /**
+   * Look up a table in the schema registry
+   */
+  private lookupTable(tableName: string): TableSchema {
+    return validateTable(this.context.schema, tableName);
+  }
+}
+
+// ============================================================
+// Public API
+// ============================================================
+
+/**
+ * Print a TSQL AST to ClickHouse SQL
+ */
+export function printToClickHouse(
+  node: SelectQuery | SelectSetQuery,
+  context: PrinterContext,
+  options: { pretty?: boolean } = {}
+): PrintResult {
+  const printer = new ClickHousePrinter(context, options);
+  return printer.print(node);
+}
diff --git a/internal-packages/tsql/src/query/printer_context.ts b/internal-packages/tsql/src/query/printer_context.ts
new file mode 100644
index 00000000000..54203cfa292
--- /dev/null
+++ b/internal-packages/tsql/src/query/printer_context.ts
@@ -0,0 +1,292 @@
+// TypeScript port of posthog/hogql/context.py
+// Adapted for ClickHouse client's {param: Type} syntax
+
+import { getClickHouseType } from "./escape";
+import { SchemaRegistry, FieldMappings } from "./schema";
+
+/**
+ * Settings that control query execution behavior
+ */
+export interface QuerySettings {
+  /** Maximum number of rows to return */
+  maxRows?: number;
+  /** Timezone for date/time operations */
+  timezone?: string;
+  /** Whether to allow full table scans */
+  allowFullTableScans?: boolean;
+  /** Query timeout in seconds */
+  timeoutSeconds?: number;
+}
+
+/**
+ * A simple comparison condition (e.g., column > value)
+ */
+export interface SimpleComparisonCondition {
+  /** The comparison operator */
+  op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte";
+  /** The value to compare against */
+  value: Date | string | number;
+}
+
+/**
+ * A between condition (e.g., column BETWEEN low AND high)
+ */
+export interface BetweenCondition {
+  /** The between operator */
+  op: "between";
+  /** The low bound of the range */
+  low: Date | string | number;
+  /** The high bound of the range */
+  high: Date | string | number;
+}
+
+/**
+ * An IN condition (e.g., column IN ('a', 'b', 'c'))
+ */
+export interface InCondition {
+  /** The in operator */
+  op: "in";
+  /** The values to check against */
+  values: (string | number)[];
+}
+
+/**
+ * A WHERE clause condition that can be either a simple comparison, a BETWEEN, or an IN.
+ * Used for both enforcedWhereClause (always applied) and whereClauseFallback (default when user doesn't filter).
+ */
+export type WhereClauseCondition = SimpleComparisonCondition | BetweenCondition | InCondition;
+
+/**
+ * A time range used by `timeBucket()` to determine the appropriate bucket interval.
+ */
+export interface TimeRange {
+  /** Start of the time range (inclusive) */
+  from: Date;
+  /** End of the time range (inclusive) */
+  to: Date;
+}
+
+/**
+ * Default query settings
+ */
+export const DEFAULT_QUERY_SETTINGS: Required<QuerySettings> = {
+  maxRows: 10000,
+  timezone: "UTC",
+  allowFullTableScans: false,
+  timeoutSeconds: 60,
+};
+
+/**
+ * A warning or notice collected during query printing
+ */
+export interface QueryNotice {
+  code: string;
+  message: string;
+  start?: number;
+  end?: number;
+}
+
+/**
+ * Context for the TSQL to ClickHouse printer
+ *
+ * Holds:
+ * - Enforced WHERE conditions for tenant isolation and plan limits
+ * - Schema registry for table/column validation
+ * - Parameter accumulator for SQL injection safety
+ * - Query settings and execution options
+ * - Field mappings for runtime value translation
+ */
+export class PrinterContext {
+  /** Accumulated parameter values for parameterized query */
+  private values: Record<string, unknown> = {};
+
+  /** Counter for generating unique parameter names */
+  private paramCounter = 0;
+
+  /** Warnings collected during printing */
+  readonly warnings: QueryNotice[] = [];
+
+  /** Errors collected during printing */
+  readonly errors: QueryNotice[] = [];
+
+  /** Runtime field mappings for dynamic value translation */
+  readonly fieldMappings: FieldMappings;
+
+  /**
+   * Enforced WHERE conditions that are ALWAYS applied at the table level.
+   * Used for tenant isolation (org_id, project_id, env_id) and plan-based limits.
+   * Applied to every table reference including subqueries, CTEs, and JOINs.
+   */
+  readonly enforcedWhereClause: Record<string, WhereClauseCondition>;
+
+  /**
+   * Time range for `timeBucket()` interval calculation.
+   * When provided, `timeBucket()` uses this to determine the appropriate bucket size.
+   */
+  readonly timeRange?: TimeRange;
+
+  constructor(
+    /** Schema registry containing allowed tables and columns */
+    public readonly schema: SchemaRegistry,
+    /** Query execution settings */
+    public readonly settings: QuerySettings = {},
+    /** Runtime field mappings for dynamic value translation */
+    fieldMappings: FieldMappings = {},
+    /**
+     * Enforced WHERE conditions that are ALWAYS applied at the table level.
+     * Must include tenant columns (e.g., organization_id) for multi-tenant tables.
+     */
+    enforcedWhereClause: Record<string, WhereClauseCondition> = {},
+    /** Time range for timeBucket() interval calculation */
+    timeRange?: TimeRange
+  ) {
+    // Initialize with default settings
+    this.settings = { ...DEFAULT_QUERY_SETTINGS, ...settings };
+    this.fieldMappings = fieldMappings;
+    this.enforcedWhereClause = enforcedWhereClause;
+    this.timeRange = timeRange;
+  }
+
+  /**
+   * Get the timezone setting
+   */
+  get timezone(): string {
+    return this.settings.timezone ?? DEFAULT_QUERY_SETTINGS.timezone;
+  }
+
+  /**
+   * Get the max rows setting
+   */
+  get maxRows(): number {
+    return this.settings.maxRows ?? DEFAULT_QUERY_SETTINGS.maxRows;
+  }
+
+  /**
+   * Add a value to the parameter map and return a ClickHouse placeholder
+   *
+   * @param value The value to parameterize
+   * @returns A placeholder string like "{tsql_val_0: String}"
+   */
+  addValue(value: unknown): string {
+    const key = `tsql_val_${this.paramCounter++}`;
+    this.values[key] = value;
+    const chType = getClickHouseType(value);
+    return `{${key}: ${chType}}`;
+  }
+
+  /**
+   * Add a value with a specific key (for named parameters)
+   *
+   * @param key The parameter name
+   * @param value The value
+   * @returns A placeholder string like "{key: Type}"
+   */
+  addNamedValue(key: string, value: unknown): string {
+    this.values[key] = value;
+    const chType = getClickHouseType(value);
+    return `{${key}: ${chType}}`;
+  }
+
+  /**
+   * Get all accumulated parameter values
+   */
+  getParams(): Record<string, unknown> {
+    return { ...this.values };
+  }
+
+  /**
+   * Add a warning notice
+   */
+  addWarning(code: string, message: string, start?: number, end?: number): void {
+    this.warnings.push({ code, message, start, end });
+  }
+
+  /**
+   * Add an error notice
+   */
+  addError(code: string, message: string, start?: number, end?: number): void {
+    this.errors.push({ code, message, start, end });
+  }
+
+  /**
+   * Check if any errors were collected
+   */
+  hasErrors(): boolean {
+    return this.errors.length > 0;
+  }
+
+  /**
+   * Create a child context that shares the same parameter accumulator
+   * Useful for handling subqueries while keeping parameters unified
+   */
+  createChildContext(): PrinterContext {
+    const child = new PrinterContext(
+      this.schema,
+      this.settings,
+      this.fieldMappings,
+      this.enforcedWhereClause,
+      this.timeRange
+    );
+    // Share the same values map so parameters are unified
+    child.values = this.values;
+    // Share the same counter reference via closure
+    const parentThis = this;
+    Object.defineProperty(child, "paramCounter", {
+      get() {
+        return parentThis.paramCounter;
+      },
+      set(v: number) {
+        parentThis.paramCounter = v;
+      },
+    });
+    return child;
+  }
+}
+
+/**
+ * Options for creating a printer context
+ */
+export interface PrinterContextOptions {
+  /** Schema registry containing allowed tables and columns */
+  schema: SchemaRegistry;
+  /** Query execution settings */
+  settings?: QuerySettings;
+  /**
+   * Runtime field mappings for dynamic value translation.
+   * Maps internal ClickHouse values to external user-facing values.
+   */
+  fieldMappings?: FieldMappings;
+  /**
+   * REQUIRED: Conditions always applied at the table level.
+   * Must include tenant columns (e.g., organization_id) for multi-tenant tables.
+   * Applied to every table reference including subqueries, CTEs, and JOINs.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   organization_id: { op: "eq", value: "org_123" },
+   *   project_id: { op: "eq", value: "proj_456" },
+   *   triggered_at: { op: "gte", value: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
+   * }
+   * ```
+   */
+  enforcedWhereClause: Record<string, WhereClauseCondition>;
+  /**
+   * Time range for `timeBucket()` interval calculation.
+   * When provided, `timeBucket()` uses this to determine the appropriate bucket size.
+   */
+  timeRange?: TimeRange;
+}
+
+/**
+ * Create a new PrinterContext
+ */
+export function createPrinterContext(options: PrinterContextOptions): PrinterContext {
+  return new PrinterContext(
+    options.schema,
+    options.settings,
+    options.fieldMappings,
+    options.enforcedWhereClause,
+    options.timeRange
+  );
+}
diff --git a/internal-packages/tsql/src/query/property_types.ts b/internal-packages/tsql/src/query/property_types.ts
new file mode 100644
index 00000000000..ff2d74c8ef6
--- /dev/null
+++ b/internal-packages/tsql/src/query/property_types.ts
@@ -0,0 +1,720 @@
+// TypeScript translation of posthog/hogql/transforms/property_types.py
+
+import type {
+  AST,
+  Expr,
+  Field,
+  PropertyType,
+  FieldType,
+  BaseTableType,
+  VirtualTableType,
+  LazyJoinType,
+  LazyTableType,
+  Call,
+  Constant,
+  CallType,
+  DateTimeType,
+} from "./ast";
+import type { TSQLContext } from "./context";
+import type { BooleanDatabaseField, DateTimeDatabaseField, Table } from "./models";
+
+// Helper function to escape TSQL identifiers
+function escapeTSQLIdentifier(identifier: string | number): string {
+  if (typeof identifier === "number") {
+    return String(identifier);
+  }
+  if (identifier.includes("%")) {
+    throw new Error(
+      `The TSQL identifier "${identifier}" is not permitted as it contains the "%" character`
+    );
+  }
+  // TSQL allows dollars in the identifier
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) {
+    return identifier;
+  }
+  // Escape backticks and other special characters
+  const backquoteEscapeChars: Record<string, string> = {
+    "\b": "\\b",
+    "\f": "\\f",
+    "\r": "\\r",
+    "\n": "\\n",
+    "\t": "\\t",
+    "\0": "\\0",
+    a: "\\a",
+    "\v": "\\v",
+    "\\": "\\\\",
+    "`": "\\`",
+  };
+  return `\`${identifier
+    .split("")
+    .map((c) => backquoteEscapeChars[c] || c)
+    .join("")}\``;
+}
+
+// Visitor dispatcher - converts node type to visitor method name
+// Matches Python's camel_case_pattern.sub("_", class_name).lower() logic
+function getVisitorMethodName(node: AST): string {
+  // Get the constructor name or use a type guard to determine the type
+  const nodeType = (node as any).constructor?.name || detectNodeType(node);
+
+  if (!nodeType) {
+    return "visit_unknown";
+  }
+
+  // Convert CamelCase to snake_case (e.g., "PropertyType" -> "property_type")
+  const snakeCase = nodeType
+    .replace(/([A-Z])/g, "_$1")
+    .toLowerCase()
+    .replace(/^_/, "");
+
+  // Handle special cases (matching Python replacements)
+  const replacements: Record<string, string> = {
+    tsqlxtag: "tsqlx_tag",
+    tsqlxattribute: "tsqlx_attribute",
+    uuidtype: "uuid_type",
+    string_jsontype: "string_json_type",
+  };
+
+  return replacements[snakeCase] || snakeCase;
+}
+
+// Type detection helper (since we can't use instanceof with interfaces)
+function detectNodeType(node: AST): string {
+  // Use property presence to detect node types
+  if ("chain" in node && "type" in node && !("name" in node)) {
+    return "Field";
+  }
+  if ("chain" in node && "field_type" in node) {
+    return "PropertyType";
+  }
+  if ("name" in node && "args" in node && !("expr" in node)) {
+    return "Call";
+  }
+  if ("value" in node && !("name" in node) && !("args" in node)) {
+    return "Constant";
+  }
+  // Add more type detection as needed
+  return "";
+}
+
+// Base visitor class - matches Python Visitor pattern
+abstract class Visitor<T> {
+  visit(node: AST | null | undefined): T {
+    if (node === null || node === undefined) {
+      return node as T;
+    }
+
+    // Try using accept method if available (double dispatch)
+    if (node.accept) {
+      return node.accept(this) as T;
+    }
+
+    // Fallback: use dispatcher
+    const methodName = getVisitorMethodName(node);
+    const method = (this as any)[methodName];
+
+    if (method && typeof method === "function") {
+      return method.call(this, node) as T;
+    }
+
+    // Try visit_unknown as fallback
+    if ((this as any).visit_unknown) {
+      return (this as any).visit_unknown(node) as T;
+    }
+
+    throw new Error(`${this.constructor.name} has no method ${methodName} or visit_unknown`);
+  }
+}
+
+// TraversingVisitor - matches Python TraversingVisitor
+class TraversingVisitor extends Visitor<void> {
+  visitPropertyType(node: PropertyType): void {
+    this.visit(node.field_type);
+  }
+
+  visitField(node: Field): void {
+    if (node.type) {
+      this.visit(node.type as any);
+    }
+  }
+
+  visitCall(node: Call): void {
+    for (const arg of node.args) {
+      this.visit(arg);
+    }
+    if (node.params) {
+      for (const param of node.params) {
+        this.visit(param);
+      }
+    }
+  }
+
+  visitConstant(node: Constant): void {
+    if (node.type) {
+      this.visit(node.type as any);
+    }
+  }
+
+  // Default handler for unknown types - traverse common properties
+  visit_unknown(node: AST): void {
+    // Traverse children based on common AST node properties
+    if ("expr" in node) {
+      this.visit((node as any).expr);
+    }
+    if ("exprs" in node) {
+      for (const expr of (node as any).exprs) {
+        this.visit(expr);
+      }
+    }
+    if ("left" in node && "right" in node) {
+      this.visit((node as any).left);
+      this.visit((node as any).right);
+    }
+    if ("args" in node) {
+      for (const arg of (node as any).args) {
+        this.visit(arg);
+      }
+    }
+    if ("type" in node) {
+      this.visit((node as any).type);
+    }
+  }
+}
+
+// CloningVisitor - matches Python CloningVisitor
+class CloningVisitor extends Visitor<any> {
+  protected clearTypes: boolean;
+  protected clearLocations: boolean;
+
+  constructor(clearTypes: boolean = true, clearLocations: boolean = false) {
+    super();
+    this.clearTypes = clearTypes;
+    this.clearLocations = clearLocations;
+  }
+
+  visitField(node: Field): Field {
+    return {
+      ...node,
+      type: this.clearTypes ? undefined : node.type ? this.visit(node.type as any) : node.type,
+      start: this.clearLocations ? undefined : node.start,
+      end: this.clearLocations ? undefined : node.end,
+    };
+  }
+
+  visitPropertyType(node: PropertyType): PropertyType {
+    return {
+      ...node,
+      field_type: this.visit(node.field_type) as FieldType,
+      start: this.clearLocations ? undefined : node.start,
+      end: this.clearLocations ? undefined : node.end,
+    };
+  }
+
+  visitCall(node: Call): Call {
+    return {
+      ...node,
+      args: node.args.map((arg) => this.visit(arg)),
+      params: node.params ? node.params.map((param) => this.visit(param)) : undefined,
+      start: this.clearLocations ? undefined : node.start,
+      end: this.clearLocations ? undefined : node.end,
+      type: this.clearTypes ? undefined : node.type,
+    };
+  }
+
+  visitConstant(node: Constant): Constant {
+    return {
+      ...node,
+      start: this.clearLocations ? undefined : node.start,
+      end: this.clearLocations ? undefined : node.end,
+      type: this.clearTypes ? undefined : node.type,
+    };
+  }
+
+  // Default handler for unknown types - shallow clone
+  visit_unknown(node: AST): any {
+    const cloned: any = { ...node };
+
+    // Clone common properties
+    if ("expr" in node) {
+      cloned.expr = this.visit((node as any).expr);
+    }
+    if ("exprs" in node) {
+      cloned.exprs = (node as any).exprs.map((e: any) => this.visit(e));
+    }
+    if ("left" in node && "right" in node) {
+      cloned.left = this.visit((node as any).left);
+      cloned.right = this.visit((node as any).right);
+    }
+    if ("args" in node) {
+      cloned.args = (node as any).args.map((a: any) => this.visit(a));
+    }
+    if ("type" in node) {
+      cloned.type = this.clearTypes ? undefined : this.visit((node as any).type);
+    }
+
+    if (this.clearLocations) {
+      cloned.start = undefined;
+      cloned.end = undefined;
+    }
+
+    return cloned;
+  }
+}
+
+// PropertyFinder: Traverses AST to find all property references
+class PropertyFinder extends TraversingVisitor {
+  context: TSQLContext;
+  personProperties: Set<string> = new Set();
+  eventProperties: Set<string> = new Set();
+  groupProperties: Map<number, Set<string>> = new Map();
+  foundTimestamps: boolean = false;
+
+  constructor(context: TSQLContext) {
+    super();
+    this.context = context;
+  }
+
+  visitPropertyType(node: PropertyType): void {
+    if (node.field_type.name === "properties" && node.chain.length === 1) {
+      const tableType = node.field_type.table_type;
+      if (this.isBaseTableType(tableType)) {
+        const table = tableType.resolve_database_table?.(this.context);
+        if (table) {
+          const tableName = table.to_printed_tsql?.() || "";
+          const propertyName = String(node.chain[0]);
+
+          if (tableName === "persons" || tableName === "raw_persons") {
+            this.personProperties.add(propertyName);
+          } else if (tableName === "groups") {
+            if (this.isLazyJoinType(tableType)) {
+              if (tableType.field.startsWith("group_")) {
+                const groupId = parseInt(tableType.field.split("_")[1], 10);
+                if (!this.groupProperties.has(groupId)) {
+                  this.groupProperties.set(groupId, new Set());
+                }
+                this.groupProperties.get(groupId)!.add(propertyName);
+              }
+            } else if (this.isLazyTableType(tableType)) {
+              const globalGroupId = this.context.globals?.group_id;
+              if (typeof globalGroupId === "number") {
+                if (!this.groupProperties.has(globalGroupId)) {
+                  this.groupProperties.set(globalGroupId, new Set());
+                }
+                this.groupProperties.get(globalGroupId)!.add(propertyName);
+              }
+            }
+          } else if (tableName === "events") {
+            if (this.isVirtualTableType(tableType) && tableType.field === "poe") {
+              this.personProperties.add(propertyName);
+            } else {
+              this.eventProperties.add(propertyName);
+            }
+          }
+        }
+      }
+    }
+    super.visitPropertyType(node);
+  }
+
+  visitField(node: Field): void {
+    super.visitField(node);
+    if (this.isFieldType(node.type)) {
+      const dbField = (node.type as any).resolve_database_field?.(this.context);
+      if (this.isDateTimeDatabaseField(dbField)) {
+        this.foundTimestamps = true;
+      }
+    }
+  }
+
+  private isBaseTableType(type: any): type is BaseTableType {
+    return type && typeof type.resolve_database_table === "function";
+  }
+
+  private isLazyJoinType(type: any): type is LazyJoinType {
+    return type && "lazy_join" in type && "field" in type;
+  }
+
+  private isLazyTableType(type: any): type is LazyTableType {
+    return type && "table" in type && !("lazy_join" in type);
+  }
+
+  private isVirtualTableType(type: any): type is VirtualTableType {
+    return type && "virtual_table" in type && "field" in type;
+  }
+
+  private isFieldType(type: any): type is FieldType {
+    return type && typeof type.resolve_database_field === "function";
+  }
+
+  private isDateTimeDatabaseField(field: any): field is DateTimeDatabaseField {
+    return field && "name" in field; // Simplified check
+  }
+}
+
+// PropertySwapper: Transforms property accesses with type conversions
+export class PropertySwapper extends CloningVisitor {
+  timezone: string;
+  eventProperties: Map<string, string>;
+  personProperties: Map<string, string>;
+  groupProperties: Map<string, string>;
+  context: TSQLContext;
+  setTimeZones: boolean;
+
+  constructor(
+    timezone: string,
+    eventProperties: Map<string, string> | Record<string, string>,
+    personProperties: Map<string, string> | Record<string, string>,
+    groupProperties: Map<string, string> | Record<string, string>,
+    context: TSQLContext,
+    setTimeZones: boolean
+  ) {
+    super(false); // Don't clear types
+    this.timezone = timezone;
+    this.eventProperties =
+      eventProperties instanceof Map ? eventProperties : new Map(Object.entries(eventProperties));
+    this.personProperties =
+      personProperties instanceof Map
+        ? personProperties
+        : new Map(Object.entries(personProperties));
+    this.groupProperties =
+      groupProperties instanceof Map ? groupProperties : new Map(Object.entries(groupProperties));
+    this.context = context;
+    this.setTimeZones = setTimeZones;
+  }
+
+  visitField(node: Field): any {
+    if (this.isFieldType(node.type)) {
+      if (this.setTimeZones) {
+        const dbField = (node.type as any).resolve_database_field?.(this.context);
+        if (this.isDateTimeDatabaseField(dbField)) {
+          return this.createToTimeZoneCall(node);
+        }
+      }
+
+      if (this.isLazyJoinType(node.type.table_type)) {
+        const lazyJoinType = node.type.table_type;
+        const resolvedTable = lazyJoinType.lazy_join.resolve_table?.(this.context);
+        // Check if it's an S3Table-like table (has fields property)
+        if (resolvedTable && "fields" in resolvedTable) {
+          const field = node.chain[node.chain.length - 1];
+          const fieldType = resolvedTable.fields[String(field)];
+          let propType = "String";
+
+          if (this.isDateTimeDatabaseField(fieldType)) {
+            propType = "DateTime";
+          } else if (this.isBooleanDatabaseField(fieldType)) {
+            propType = "Boolean";
+          }
+
+          return this.fieldTypeToPropertyCall(node, propType);
+        }
+      }
+    }
+
+    const type = node.type;
+    if (
+      this.isPropertyType(type) &&
+      type.field_type.name === "properties" &&
+      type.chain.length === 1
+    ) {
+      const propertyName = String(type.chain[0]);
+      const tableType = type.field_type.table_type;
+
+      if (this.isVirtualTableType(tableType) && tableType.field === "poe") {
+        if (this.personProperties.has(propertyName)) {
+          return this.convertStringPropertyToType(node, "person", propertyName);
+        }
+      } else if (this.isBaseTableType(tableType)) {
+        const table = tableType.resolve_database_table?.(this.context);
+        if (table) {
+          const tableName = table.to_printed_tsql?.() || "";
+
+          if (tableName === "persons" || tableName === "raw_persons") {
+            if (this.personProperties.has(propertyName)) {
+              return this.convertStringPropertyToType(node, "person", propertyName);
+            }
+          } else if (tableName === "groups") {
+            if (this.isLazyJoinType(tableType)) {
+              if (tableType.field.startsWith("group_")) {
+                const groupId = parseInt(tableType.field.split("_")[1], 10);
+                const groupKey = `${groupId}_${propertyName}`;
+                if (this.groupProperties.has(groupKey)) {
+                  return this.convertStringPropertyToType(node, "group", groupKey);
+                }
+              }
+            } else if (this.isLazyTableType(tableType)) {
+              const globalGroupId = this.context.globals?.group_id;
+              if (typeof globalGroupId === "number") {
+                const groupKey = `${globalGroupId}_${propertyName}`;
+                if (this.groupProperties.has(groupKey)) {
+                  return this.convertStringPropertyToType(node, "group", groupKey);
+                }
+              }
+            }
+          } else if (tableName === "events") {
+            if (this.eventProperties.has(propertyName)) {
+              return this.convertStringPropertyToType(node, "event", propertyName);
+            }
+          }
+        }
+      }
+    }
+
+    if (
+      this.isPropertyType(type) &&
+      type.field_type.name === "person_properties" &&
+      type.chain.length === 1
+    ) {
+      const propertyName = String(type.chain[0]);
+      const tableType = type.field_type.table_type;
+
+      if (this.isBaseTableType(tableType)) {
+        const table = tableType.resolve_database_table?.(this.context);
+        if (table) {
+          const tableName = table.to_printed_tsql?.() || "";
+          if (tableName === "events") {
+            if (this.personProperties.has(propertyName)) {
+              return this.convertStringPropertyToType(node, "person", propertyName);
+            }
+          }
+        }
+      }
+    }
+
+    return super.visitField(node);
+  }
+
+  private convertStringPropertyToType(
+    node: Field,
+    propertyType: "event" | "person" | "group",
+    propertyName: string
+  ): Expr {
+    let fieldTypeValue: string | undefined;
+    if (propertyType === "person") {
+      fieldTypeValue = this.personProperties.get(propertyName);
+    } else if (propertyType === "group") {
+      fieldTypeValue = this.groupProperties.get(propertyName);
+    } else {
+      fieldTypeValue = this.eventProperties.get(propertyName);
+    }
+
+    const fieldType = fieldTypeValue === "Numeric" ? "Float" : fieldTypeValue || "String";
+    this.addPropertyNotice(node, propertyType, fieldType);
+
+    return this.fieldTypeToPropertyCall(node, fieldType);
+  }
+
+  private fieldTypeToPropertyCall(node: Field, fieldType: string): Expr {
+    if (fieldType === "DateTime") {
+      return this.createToDateTimeCall(node);
+    }
+    if (fieldType === "Float") {
+      return this.createToFloatCall(node);
+    }
+    if (fieldType === "Boolean") {
+      return this.createToBoolCall(node);
+    }
+    return node;
+  }
+
+  private createToTimeZoneCall(node: Field): Call {
+    return {
+      expression_type: "call",
+      name: "toTimeZone",
+      args: [node, this.createConstant(this.timezone)],
+      type: {
+        name: "toTimeZone",
+        arg_types: [{ data_type: "datetime" } as DateTimeType],
+        return_type: { data_type: "datetime" } as DateTimeType,
+      } as CallType,
+      start: node.start,
+      end: node.end,
+    } as Call;
+  }
+
+  private createToDateTimeCall(node: Field): Call {
+    return {
+      expression_type: "call",
+      name: "toDateTime",
+      args: [node],
+      start: node.start,
+      end: node.end,
+    };
+  }
+
+  private createToFloatCall(node: Field): Call {
+    return {
+      expression_type: "call",
+      name: "toFloat",
+      args: [node],
+      start: node.start,
+      end: node.end,
+    };
+  }
+
+  private createToBoolCall(node: Field): Call {
+    return {
+      expression_type: "call",
+      name: "toBool",
+      args: [
+        {
+          name: "transform",
+          args: [
+            {
+              name: "toString",
+              args: [node],
+              start: node.start,
+              end: node.end,
+            } as Call,
+            this.createConstant(["true", "false"]),
+            this.createConstant([1, 0]),
+            this.createConstant(null),
+          ],
+          start: node.start,
+          end: node.end,
+        } as Call,
+      ],
+      start: node.start,
+      end: node.end,
+    } as Call;
+  }
+
+  private createConstant(value: any): Constant {
+    return {
+      expression_type: "constant",
+      value,
+    };
+  }
+
+  private addPropertyNotice(
+    node: Field,
+    propertyType: "event" | "person" | "group",
+    fieldType: string
+  ): void {
+    let propertyName = String(node.chain[node.chain.length - 1]);
+    let materializedColumn: any = null; // MaterializedColumn type not yet defined
+
+    if (propertyType === "person") {
+      //   if (this.context.modifiers.personsOnEventsMode !== "disabled") {
+      // materializedColumn = getMaterializedColumnForProperty('events', propertyName, 'person_properties');
+      //   } else {
+      // materializedColumn = getMaterializedColumnForProperty('person', propertyName, 'properties');
+      //   }
+    } else if (propertyType === "group") {
+      const nameParts = propertyName.split("_");
+      nameParts.shift();
+      propertyName = nameParts.join("_");
+      // materializedColumn = getMaterializedColumnForProperty('groups', propertyName, 'properties');
+    } else {
+      // materializedColumn = getMaterializedColumnForProperty('events', propertyName, 'properties');
+    }
+
+    let message = `${
+      propertyType.charAt(0).toUpperCase() + propertyType.slice(1)
+    } property '${propertyName}' is of type '${fieldType}'.`;
+    if (this.context.debug) {
+      if (materializedColumn !== null) {
+        message += " This property is materialized ⚡️.";
+      } else {
+        message += " This property is not materialized 🐢.";
+      }
+    }
+
+    this.addNotice(node, message);
+  }
+
+  private addNotice(node: Field, message: string): void {
+    if (node.start === undefined || node.end === undefined) {
+      return; // Don't add notices for nodes without location
+    }
+    // Only highlight the last part of the chain
+    const lastPart = node.chain[node.chain.length - 1];
+    const identifierLength = escapeTSQLIdentifier(lastPart).length;
+    this.context.notices.push({
+      start: Math.max(node.start, node.end - identifierLength),
+      end: node.end,
+      message,
+    });
+  }
+
+  private isFieldType(type: any): type is FieldType {
+    return type && typeof type.resolve_database_field === "function";
+  }
+
+  private isPropertyType(type: any): type is PropertyType {
+    return type && "field_type" in type && "chain" in type;
+  }
+
+  private isBaseTableType(type: any): type is BaseTableType {
+    return type && typeof type.resolve_database_table === "function";
+  }
+
+  private isLazyJoinType(type: any): type is LazyJoinType {
+    return type && "lazy_join" in type && "field" in type;
+  }
+
+  private isLazyTableType(type: any): type is LazyTableType {
+    return type && "table" in type && !("lazy_join" in type);
+  }
+
+  private isVirtualTableType(type: any): type is VirtualTableType {
+    return type && "virtual_table" in type && "field" in type;
+  }
+
+  private isDateTimeDatabaseField(field: any): field is DateTimeDatabaseField {
+    return field && "name" in field; // Simplified check
+  }
+
+  private isBooleanDatabaseField(field: any): field is BooleanDatabaseField {
+    return field && "name" in field; // Simplified check
+  }
+}
+
+// Main function to build property swapper
+export function buildPropertySwapper(node: AST, context: TSQLContext): void {
+  if (!context || !context.team_id) {
+    return;
+  }
+
+  // NOTE: In TypeScript, you'll need to fetch the team from your database/ORM
+  // This is a placeholder - replace with your actual team fetching logic
+  // if (!context.team) {
+  //     context.team = await Team.findById(context.team_id);
+  // }
+
+  if (!context.team) {
+    return;
+  }
+
+  // Find all properties
+  const propertyFinder = new PropertyFinder(context);
+  propertyFinder.visit(node);
+
+  // NOTE: In TypeScript, you'll need to query PropertyDefinition from your database
+  // This is a placeholder - replace with your actual property definition fetching logic
+  // const eventPropertyValues = await PropertyDefinition.find({
+  //     project_id: context.team.project_id,
+  //     name: { $in: Array.from(propertyFinder.eventProperties) },
+  //     type: { $in: [null, 'event'] },
+  // }).select('name property_type');
+  // const eventProperties = new Map(
+  //     eventPropertyValues.filter((p: any) => p.property_type).map((p: any) => [p.name, p.property_type])
+  // );
+
+  const eventProperties = new Map<string, string>();
+  const personProperties = new Map<string, string>();
+  const groupProperties = new Map<string, string>();
+
+  // TODO: Implement actual property definition fetching from database
+  // For now, these are empty maps
+
+  const timezone = (context.database as any)?._timezone || "UTC";
+  context.property_swapper = new PropertySwapper(
+    timezone,
+    eventProperties,
+    personProperties,
+    groupProperties,
+    context,
+    true
+  );
+}
diff --git a/internal-packages/tsql/src/query/results.test.ts b/internal-packages/tsql/src/query/results.test.ts
new file mode 100644
index 00000000000..49216992cf1
--- /dev/null
+++ b/internal-packages/tsql/src/query/results.test.ts
@@ -0,0 +1,234 @@
+import { describe, it, expect } from "vitest";
+import { transformResults, createResultTransformer } from "./results.js";
+import { column, type TableSchema } from "./schema.js";
+
+/**
+ * Test schema with valueMap
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    status: {
+      name: "status",
+      ...column("String"),
+      valueMap: {
+        COMPLETED_SUCCESSFULLY: "Completed",
+        COMPLETED_WITH_ERRORS: "Completed with errors",
+        SYSTEM_FAILURE: "System failure",
+        PENDING: "Pending",
+        EXECUTING: "Running",
+        FAILED: "Failed",
+        CANCELLED: "Cancelled",
+      },
+    },
+    environment_type: {
+      name: "environment_type",
+      ...column("String"),
+      valueMap: {
+        DEVELOPMENT: "Development",
+        STAGING: "Staging",
+        PRODUCTION: "Production",
+      },
+    },
+    task_identifier: { name: "task_identifier", ...column("String") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+/**
+ * Schema without valueMap
+ */
+const simpleSchema: TableSchema = {
+  name: "simple",
+  clickhouseName: "trigger_dev.simple",
+  columns: {
+    id: { name: "id", ...column("String") },
+    name: { name: "name", ...column("String") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+describe("transformResults", () => {
+  it("should transform internal values to user-friendly values", () => {
+    const rows = [
+      { id: "run_1", status: "COMPLETED_SUCCESSFULLY", task_identifier: "my-task" },
+      { id: "run_2", status: "PENDING", task_identifier: "other-task" },
+      { id: "run_3", status: "FAILED", task_identifier: "my-task" },
+    ];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    expect(transformed[0].status).toBe("Completed");
+    expect(transformed[1].status).toBe("Pending");
+    expect(transformed[2].status).toBe("Failed");
+  });
+
+  it("should transform multiple columns with valueMaps", () => {
+    const rows = [
+      { id: "run_1", status: "COMPLETED_SUCCESSFULLY", environment_type: "PRODUCTION" },
+      { id: "run_2", status: "PENDING", environment_type: "DEVELOPMENT" },
+    ];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    expect(transformed[0].status).toBe("Completed");
+    expect(transformed[0].environment_type).toBe("Production");
+    expect(transformed[1].status).toBe("Pending");
+    expect(transformed[1].environment_type).toBe("Development");
+  });
+
+  it("should not modify columns without valueMap", () => {
+    const rows = [
+      { id: "run_1", status: "COMPLETED_SUCCESSFULLY", task_identifier: "my-task" },
+    ];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    // id and task_identifier should be unchanged
+    expect(transformed[0].id).toBe("run_1");
+    expect(transformed[0].task_identifier).toBe("my-task");
+  });
+
+  it("should pass through values not in valueMap unchanged", () => {
+    const rows = [{ id: "run_1", status: "UNKNOWN_STATUS", task_identifier: "my-task" }];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    // UNKNOWN_STATUS is not in the valueMap, should be passed through
+    expect(transformed[0].status).toBe("UNKNOWN_STATUS");
+  });
+
+  it("should return original rows if no columns have valueMap", () => {
+    const rows = [
+      { id: "run_1", name: "test" },
+      { id: "run_2", name: "other" },
+    ];
+
+    const transformed = transformResults(rows, [simpleSchema]);
+
+    // Should return the same array (reference equality)
+    expect(transformed).toBe(rows);
+  });
+
+  it("should handle empty rows array", () => {
+    const rows: Array<{ id: string; status: string }> = [];
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    expect(transformed).toEqual([]);
+  });
+
+  it("should handle case-insensitive internal value matching", () => {
+    const rows = [
+      { id: "run_1", status: "completed_successfully" },
+      { id: "run_2", status: "COMPLETED_SUCCESSFULLY" },
+      { id: "run_3", status: "Completed_Successfully" },
+    ];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    // All should map to "Completed"
+    expect(transformed[0].status).toBe("Completed");
+    expect(transformed[1].status).toBe("Completed");
+    expect(transformed[2].status).toBe("Completed");
+  });
+
+  it("should preserve non-string column values", () => {
+    const rows = [{ id: "run_1", status: "COMPLETED_SUCCESSFULLY", count: 42, active: true }];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    expect(transformed[0].count).toBe(42);
+    expect(transformed[0].active).toBe(true);
+    expect(transformed[0].status).toBe("Completed");
+  });
+
+  it("should preserve row reference if no changes made", () => {
+    const rows = [{ id: "run_1", status: "UNKNOWN_STATUS" }];
+
+    const transformed = transformResults(rows, [taskRunsSchema]);
+
+    // The row has status that doesn't match any valueMap entry
+    // But the column does have a valueMap, so we still check it
+    // Since the value doesn't change, the row reference should be preserved
+    expect(transformed[0]).toBe(rows[0]);
+  });
+
+  it("should handle multiple table schemas", () => {
+    const anotherSchema: TableSchema = {
+      name: "events",
+      clickhouseName: "trigger_dev.events",
+      columns: {
+        id: { name: "id", ...column("String") },
+        event_type: {
+          name: "event_type",
+          ...column("String"),
+          valueMap: {
+            TASK_START: "Started",
+            TASK_END: "Ended",
+          },
+        },
+        organization_id: { name: "organization_id", ...column("String") },
+        project_id: { name: "project_id", ...column("String") },
+        environment_id: { name: "environment_id", ...column("String") },
+      },
+      tenantColumns: {
+        organizationId: "organization_id",
+        projectId: "project_id",
+        environmentId: "environment_id",
+      },
+    };
+
+    const rows = [
+      { status: "COMPLETED_SUCCESSFULLY", event_type: "TASK_START" },
+      { status: "PENDING", event_type: "TASK_END" },
+    ];
+
+    const transformed = transformResults(rows, [taskRunsSchema, anotherSchema]);
+
+    expect(transformed[0].status).toBe("Completed");
+    expect(transformed[0].event_type).toBe("Started");
+    expect(transformed[1].status).toBe("Pending");
+    expect(transformed[1].event_type).toBe("Ended");
+  });
+});
+
+describe("createResultTransformer", () => {
+  it("should create a reusable transformer function", () => {
+    const transform = createResultTransformer([taskRunsSchema]);
+
+    const rows1 = [{ id: "1", status: "COMPLETED_SUCCESSFULLY" }];
+    const rows2 = [{ id: "2", status: "FAILED" }];
+
+    const transformed1 = transform(rows1);
+    const transformed2 = transform(rows2);
+
+    expect(transformed1[0].status).toBe("Completed");
+    expect(transformed2[0].status).toBe("Failed");
+  });
+
+  it("should return original rows if no valueMap columns exist", () => {
+    const transform = createResultTransformer([simpleSchema]);
+
+    const rows = [{ id: "1", name: "test" }];
+    const transformed = transform(rows);
+
+    expect(transformed).toBe(rows);
+  });
+});
+
diff --git a/internal-packages/tsql/src/query/results.ts b/internal-packages/tsql/src/query/results.ts
new file mode 100644
index 00000000000..8edeb8f54e4
--- /dev/null
+++ b/internal-packages/tsql/src/query/results.ts
@@ -0,0 +1,201 @@
+/**
+ * Result transformation utilities for TSQL queries
+ *
+ * Transforms query result values from internal ClickHouse values
+ * to user-friendly display names using the column valueMap or fieldMapping.
+ */
+
+import type { TableSchema, ColumnSchema, FieldMappings } from "./schema.js";
+import { getUserFriendlyValue, hasFieldMapping, getExternalValue } from "./schema.js";
+
+/**
+ * Options for transforming query results
+ */
+export interface TransformResultsOptions {
+  /**
+   * If true, transform values even if the column was aliased (e.g., SELECT status AS s)
+   * Default: false (aliased columns are not transformed since the user explicitly chose a different name)
+   */
+  transformAliased?: boolean;
+  /**
+   * Runtime field mappings for dynamic value translation.
+   * Maps internal ClickHouse values to external user-facing values.
+   * Values not found in the mapping will be returned as null.
+   */
+  fieldMappings?: FieldMappings;
+}
+
+/**
+ * Transform query result rows, mapping internal values to user-friendly display names
+ *
+ * This function iterates over result rows and transforms any column values that have
+ * a `valueMap` or `fieldMapping` defined in their schema, converting internal ClickHouse values
+ * (e.g., 'COMPLETED_SUCCESSFULLY') back to user-friendly display names (e.g., 'Completed').
+ *
+ * For columns with `fieldMapping`, values not found in the mapping will be returned as null.
+ *
+ * @param rows - Array of result rows to transform
+ * @param schema - Array of table schemas containing column definitions with valueMaps
+ * @param options - Optional transformation options
+ * @returns New array of rows with transformed values
+ *
+ * @example
+ * ```typescript
+ * const schema: TableSchema[] = [{
+ *   name: "task_runs",
+ *   clickhouseName: "trigger_dev.task_runs_v2",
+ *   columns: {
+ *     status: {
+ *       name: "status",
+ *       type: "String",
+ *       valueMap: {
+ *         "COMPLETED_SUCCESSFULLY": "Completed",
+ *         "PENDING": "Pending",
+ *       },
+ *     },
+ *     project_ref: {
+ *       name: "project_ref",
+ *       clickhouseName: "project_id",
+ *       type: "String",
+ *       fieldMapping: "project",
+ *     },
+ *   },
+ *   tenantColumns: { organizationId: "organization_id", projectId: "project_id", environmentId: "environment_id" },
+ * }];
+ *
+ * const results = [{ status: "COMPLETED_SUCCESSFULLY", project_ref: "cm12345" }];
+ * const transformed = transformResults(results, schema, {
+ *   fieldMappings: { project: { "cm12345": "my-project-ref" } },
+ * });
+ * // transformed = [{ status: "Completed", project_ref: "my-project-ref" }]
+ * ```
+ */
+export function transformResults<T extends Record<string, unknown>>(
+  rows: T[],
+  schema: TableSchema[],
+  options: TransformResultsOptions = {}
+): T[] {
+  // Build a map of column names to their schemas (for columns that have transformations)
+  const columnTransformMaps = buildColumnTransformMaps(schema);
+
+  // If no columns have transformations, return the original rows unchanged
+  if (columnTransformMaps.size === 0) {
+    return rows;
+  }
+
+  // Transform each row
+  return rows.map((row) => transformRow(row, columnTransformMaps, options.fieldMappings));
+}
+
+/**
+ * Build a map of column names to their schemas for columns that have transformations
+ * (either valueMap or fieldMapping)
+ */
+function buildColumnTransformMaps(schema: TableSchema[]): Map<string, ColumnSchema> {
+  const columnMaps = new Map<string, ColumnSchema>();
+
+  for (const table of schema) {
+    for (const [columnName, columnSchema] of Object.entries(table.columns)) {
+      const hasValueMap = columnSchema.valueMap && Object.keys(columnSchema.valueMap).length > 0;
+      const hasFieldMap = hasFieldMapping(columnSchema);
+
+      if (hasValueMap || hasFieldMap) {
+        // Use the TSQL-exposed column name (not the ClickHouse name)
+        columnMaps.set(columnName, columnSchema);
+      }
+    }
+  }
+
+  return columnMaps;
+}
+
+/**
+ * Transform a single value using the column's valueMap or fieldMapping
+ * Returns the transformed value, or the original value if no transformation applies
+ * For fieldMapping, returns null if the value is not found in the mapping
+ */
+function transformSingleValue(
+  columnSchema: ColumnSchema,
+  value: string,
+  fieldMappings?: FieldMappings
+): string | null {
+  // First try static valueMap (always returns the original if no match)
+  if (columnSchema.valueMap && Object.keys(columnSchema.valueMap).length > 0) {
+    return getUserFriendlyValue(columnSchema, value);
+  }
+
+  // Then try runtime fieldMapping (returns null if not found)
+  if (hasFieldMapping(columnSchema) && columnSchema.fieldMapping && fieldMappings) {
+    const externalValue = getExternalValue(fieldMappings, columnSchema.fieldMapping, value);
+    // For fieldMapping, return null if not found (per user requirement)
+    return externalValue;
+  }
+
+  return value;
+}
+
+/**
+ * Transform a single row's values using the column valueMaps and fieldMappings
+ */
+function transformRow<T extends Record<string, unknown>>(
+  row: T,
+  columnTransformMaps: Map<string, ColumnSchema>,
+  fieldMappings?: FieldMappings
+): T {
+  const transformedRow: Record<string, unknown> = {};
+  let hasChanges = false;
+
+  for (const [key, value] of Object.entries(row)) {
+    const columnSchema = columnTransformMaps.get(key);
+
+    if (columnSchema && typeof value === "string") {
+      const transformedValue = transformSingleValue(columnSchema, value, fieldMappings);
+      transformedRow[key] = transformedValue;
+      if (transformedValue !== value) {
+        hasChanges = true;
+      }
+    } else {
+      transformedRow[key] = value;
+    }
+  }
+
+  // Return original row if no changes were made (preserves reference equality)
+  return hasChanges ? (transformedRow as T) : row;
+}
+
+/**
+ * Create a result transformer bound to a specific schema
+ *
+ * Useful when you need to transform multiple result sets with the same schema.
+ *
+ * @param schema - Array of table schemas
+ * @param options - Optional transformation options (including fieldMappings)
+ * @returns A function that transforms result rows
+ *
+ * @example
+ * ```typescript
+ * const transform = createResultTransformer(schema, {
+ *   fieldMappings: { project: { "cm12345": "my-project-ref" } },
+ * });
+ *
+ * const results1 = await query1();
+ * const transformed1 = transform(results1);
+ *
+ * const results2 = await query2();
+ * const transformed2 = transform(results2);
+ * ```
+ */
+export function createResultTransformer(
+  schema: TableSchema[],
+  options: TransformResultsOptions = {}
+): <T extends Record<string, unknown>>(rows: T[]) => T[] {
+  const columnTransformMaps = buildColumnTransformMaps(schema);
+
+  return <T extends Record<string, unknown>>(rows: T[]): T[] => {
+    if (columnTransformMaps.size === 0) {
+      return rows;
+    }
+    return rows.map((row) => transformRow(row, columnTransformMaps, options.fieldMappings));
+  };
+}
+
diff --git a/internal-packages/tsql/src/query/schema.test.ts b/internal-packages/tsql/src/query/schema.test.ts
new file mode 100644
index 00000000000..29656b1cb29
--- /dev/null
+++ b/internal-packages/tsql/src/query/schema.test.ts
@@ -0,0 +1,792 @@
+import { describe, it, expect } from "vitest";
+import {
+  column,
+  getUserFriendlyValue,
+  getInternalValue,
+  getAllowedUserValues,
+  isValidUserValue,
+  isVirtualColumn,
+  getVirtualColumnExpression,
+  hasFieldMapping,
+  getExternalValue,
+  getInternalValueFromMapping,
+  getInternalValueFromMappingCaseInsensitive,
+  sanitizeErrorMessage,
+  type ColumnSchema,
+  type FieldMappings,
+  type TableSchema,
+} from "./schema.js";
+
+describe("Value mapping helper functions", () => {
+  const columnWithValueMap: ColumnSchema = {
+    name: "status",
+    ...column("String"),
+    valueMap: {
+      COMPLETED_SUCCESSFULLY: "Completed",
+      COMPLETED_WITH_ERRORS: "Completed with errors",
+      SYSTEM_FAILURE: "System failure",
+      PENDING: "Pending",
+      EXECUTING: "Running",
+      FAILED: "Failed",
+    },
+  };
+
+  const columnWithAllowedValues: ColumnSchema = {
+    name: "status",
+    ...column("String"),
+    allowedValues: ["completed", "pending", "failed"],
+  };
+
+  const columnWithNoRestrictions: ColumnSchema = {
+    name: "task_identifier",
+    ...column("String"),
+  };
+
+  describe("getUserFriendlyValue", () => {
+    it("should return user-friendly value for internal value", () => {
+      expect(getUserFriendlyValue(columnWithValueMap, "COMPLETED_SUCCESSFULLY")).toBe("Completed");
+      expect(getUserFriendlyValue(columnWithValueMap, "PENDING")).toBe("Pending");
+      expect(getUserFriendlyValue(columnWithValueMap, "EXECUTING")).toBe("Running");
+    });
+
+    it("should be case-insensitive for internal value lookup", () => {
+      expect(getUserFriendlyValue(columnWithValueMap, "completed_successfully")).toBe("Completed");
+      expect(getUserFriendlyValue(columnWithValueMap, "Completed_Successfully")).toBe("Completed");
+      expect(getUserFriendlyValue(columnWithValueMap, "COMPLETED_SUCCESSFULLY")).toBe("Completed");
+    });
+
+    it("should return original value if no mapping exists", () => {
+      expect(getUserFriendlyValue(columnWithValueMap, "UNKNOWN_STATUS")).toBe("UNKNOWN_STATUS");
+    });
+
+    it("should return original value if column has no valueMap", () => {
+      expect(getUserFriendlyValue(columnWithNoRestrictions, "any_value")).toBe("any_value");
+    });
+  });
+
+  describe("getInternalValue", () => {
+    it("should return internal value for user-friendly value", () => {
+      expect(getInternalValue(columnWithValueMap, "Completed")).toBe("COMPLETED_SUCCESSFULLY");
+      expect(getInternalValue(columnWithValueMap, "Pending")).toBe("PENDING");
+      expect(getInternalValue(columnWithValueMap, "Running")).toBe("EXECUTING");
+    });
+
+    it("should be case-insensitive for user-friendly value lookup", () => {
+      expect(getInternalValue(columnWithValueMap, "completed")).toBe("COMPLETED_SUCCESSFULLY");
+      expect(getInternalValue(columnWithValueMap, "COMPLETED")).toBe("COMPLETED_SUCCESSFULLY");
+      expect(getInternalValue(columnWithValueMap, "Completed")).toBe("COMPLETED_SUCCESSFULLY");
+    });
+
+    it("should return original value if no mapping exists", () => {
+      expect(getInternalValue(columnWithValueMap, "Unknown")).toBe("Unknown");
+    });
+
+    it("should return original value if column has no valueMap", () => {
+      expect(getInternalValue(columnWithNoRestrictions, "any_value")).toBe("any_value");
+    });
+
+    it("should handle multi-word user-friendly values", () => {
+      expect(getInternalValue(columnWithValueMap, "Completed with errors")).toBe(
+        "COMPLETED_WITH_ERRORS"
+      );
+      expect(getInternalValue(columnWithValueMap, "completed with errors")).toBe(
+        "COMPLETED_WITH_ERRORS"
+      );
+      expect(getInternalValue(columnWithValueMap, "System failure")).toBe("SYSTEM_FAILURE");
+    });
+  });
+
+  describe("getAllowedUserValues", () => {
+    it("should return user-friendly values from valueMap", () => {
+      const values = getAllowedUserValues(columnWithValueMap);
+
+      expect(values).toContain("Completed");
+      expect(values).toContain("Pending");
+      expect(values).toContain("Running");
+      expect(values).toContain("Failed");
+      expect(values).toContain("Completed with errors");
+      expect(values).toContain("System failure");
+      expect(values).toHaveLength(6);
+    });
+
+    it("should return allowedValues if no valueMap exists", () => {
+      const values = getAllowedUserValues(columnWithAllowedValues);
+
+      expect(values).toEqual(["completed", "pending", "failed"]);
+    });
+
+    it("should prefer valueMap over allowedValues", () => {
+      const columnWithBoth: ColumnSchema = {
+        name: "status",
+        ...column("String"),
+        allowedValues: ["internal1", "internal2"],
+        valueMap: {
+          internal1: "User 1",
+          internal2: "User 2",
+        },
+      };
+
+      const values = getAllowedUserValues(columnWithBoth);
+
+      expect(values).toEqual(["User 1", "User 2"]);
+    });
+
+    it("should return empty array for column with no restrictions", () => {
+      const values = getAllowedUserValues(columnWithNoRestrictions);
+
+      expect(values).toEqual([]);
+    });
+  });
+
+  describe("isValidUserValue", () => {
+    it("should return true for valid user-friendly values", () => {
+      expect(isValidUserValue(columnWithValueMap, "Completed")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "Pending")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "Running")).toBe(true);
+    });
+
+    it("should be case-insensitive", () => {
+      expect(isValidUserValue(columnWithValueMap, "completed")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "COMPLETED")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "running")).toBe(true);
+    });
+
+    it("should return false for invalid values", () => {
+      expect(isValidUserValue(columnWithValueMap, "Unknown")).toBe(false);
+      expect(isValidUserValue(columnWithValueMap, "COMPLETED_SUCCESSFULLY")).toBe(false); // internal value, not user-friendly
+    });
+
+    it("should return true for any value if column has no restrictions", () => {
+      expect(isValidUserValue(columnWithNoRestrictions, "any_value")).toBe(true);
+      expect(isValidUserValue(columnWithNoRestrictions, "another")).toBe(true);
+    });
+
+    it("should validate against allowedValues if no valueMap", () => {
+      expect(isValidUserValue(columnWithAllowedValues, "completed")).toBe(true);
+      expect(isValidUserValue(columnWithAllowedValues, "COMPLETED")).toBe(true);
+      expect(isValidUserValue(columnWithAllowedValues, "unknown")).toBe(false);
+    });
+
+    it("should handle multi-word values", () => {
+      expect(isValidUserValue(columnWithValueMap, "Completed with errors")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "completed with errors")).toBe(true);
+      expect(isValidUserValue(columnWithValueMap, "System failure")).toBe(true);
+    });
+  });
+});
+
+describe("Virtual column helper functions", () => {
+  const virtualColumn: ColumnSchema = {
+    name: "execution_duration",
+    ...column("Nullable(Int64)"),
+    expression: "dateDiff('millisecond', started_at, completed_at)",
+    description: "Time between started_at and completed_at in milliseconds",
+  };
+
+  const regularColumn: ColumnSchema = {
+    name: "status",
+    ...column("String"),
+  };
+
+  const columnWithEmptyExpression: ColumnSchema = {
+    name: "bad_column",
+    ...column("String"),
+    expression: "",
+  };
+
+  describe("isVirtualColumn", () => {
+    it("should return true for columns with expression defined", () => {
+      expect(isVirtualColumn(virtualColumn)).toBe(true);
+    });
+
+    it("should return false for regular columns without expression", () => {
+      expect(isVirtualColumn(regularColumn)).toBe(false);
+    });
+
+    it("should return false for columns with empty expression", () => {
+      expect(isVirtualColumn(columnWithEmptyExpression)).toBe(false);
+    });
+
+    it("should return false for columns with undefined expression", () => {
+      const col: ColumnSchema = {
+        name: "test",
+        ...column("String"),
+        expression: undefined,
+      };
+      expect(isVirtualColumn(col)).toBe(false);
+    });
+  });
+
+  describe("getVirtualColumnExpression", () => {
+    it("should return the expression for virtual columns", () => {
+      expect(getVirtualColumnExpression(virtualColumn)).toBe(
+        "dateDiff('millisecond', started_at, completed_at)"
+      );
+    });
+
+    it("should return undefined for regular columns", () => {
+      expect(getVirtualColumnExpression(regularColumn)).toBeUndefined();
+    });
+
+    it("should return undefined for columns with empty expression", () => {
+      expect(getVirtualColumnExpression(columnWithEmptyExpression)).toBeUndefined();
+    });
+  });
+
+  describe("virtual column schema definition", () => {
+    it("should allow defining virtual columns with all standard column options", () => {
+      const virtualWithOptions: ColumnSchema = {
+        name: "computed_value",
+        type: "Float64",
+        expression: "usage_duration_ms / 1000.0",
+        selectable: true,
+        filterable: true,
+        sortable: true,
+        groupable: false, // Might not want to group by computed values
+        description: "Usage duration in seconds",
+      };
+
+      expect(isVirtualColumn(virtualWithOptions)).toBe(true);
+      expect(virtualWithOptions.groupable).toBe(false);
+      expect(virtualWithOptions.selectable).toBe(true);
+    });
+
+    it("should support complex expressions with ClickHouse functions", () => {
+      const complexVirtual: ColumnSchema = {
+        name: "is_long_running",
+        ...column("UInt8"),
+        expression:
+          "if(completed_at IS NOT NULL AND started_at IS NOT NULL, dateDiff('second', started_at, completed_at) > 60, 0)",
+      };
+
+      expect(isVirtualColumn(complexVirtual)).toBe(true);
+      expect(getVirtualColumnExpression(complexVirtual)).toContain("dateDiff");
+      expect(getVirtualColumnExpression(complexVirtual)).toContain("if(");
+    });
+  });
+});
+
+describe("Field mapping helper functions (runtime dynamic mappings)", () => {
+  const fieldMappings: FieldMappings = {
+    project: {
+      cm12345: "my-project-ref",
+      cm67890: "other-project",
+      cmABCDE: "Mixed-Case-Project",
+    },
+    environment: {
+      env123: "production",
+      env456: "staging",
+    },
+  };
+
+  const columnWithFieldMapping: ColumnSchema = {
+    name: "project_ref",
+    clickhouseName: "project_id",
+    ...column("String"),
+    fieldMapping: "project",
+  };
+
+  const columnWithoutFieldMapping: ColumnSchema = {
+    name: "status",
+    ...column("String"),
+  };
+
+  const columnWithEmptyFieldMapping: ColumnSchema = {
+    name: "test",
+    ...column("String"),
+    fieldMapping: "",
+  };
+
+  describe("hasFieldMapping", () => {
+    it("should return true for columns with fieldMapping defined", () => {
+      expect(hasFieldMapping(columnWithFieldMapping)).toBe(true);
+    });
+
+    it("should return false for columns without fieldMapping", () => {
+      expect(hasFieldMapping(columnWithoutFieldMapping)).toBe(false);
+    });
+
+    it("should return false for columns with empty fieldMapping", () => {
+      expect(hasFieldMapping(columnWithEmptyFieldMapping)).toBe(false);
+    });
+
+    it("should return false for columns with undefined fieldMapping", () => {
+      const col: ColumnSchema = {
+        name: "test",
+        ...column("String"),
+        fieldMapping: undefined,
+      };
+      expect(hasFieldMapping(col)).toBe(false);
+    });
+  });
+
+  describe("getExternalValue", () => {
+    it("should return external value for internal value", () => {
+      expect(getExternalValue(fieldMappings, "project", "cm12345")).toBe("my-project-ref");
+      expect(getExternalValue(fieldMappings, "project", "cm67890")).toBe("other-project");
+      expect(getExternalValue(fieldMappings, "environment", "env123")).toBe("production");
+    });
+
+    it("should return null if internal value is not found in mapping", () => {
+      expect(getExternalValue(fieldMappings, "project", "unknown_id")).toBeNull();
+      expect(getExternalValue(fieldMappings, "environment", "unknown_env")).toBeNull();
+    });
+
+    it("should return null if mapping name does not exist", () => {
+      expect(getExternalValue(fieldMappings, "nonexistent", "cm12345")).toBeNull();
+    });
+
+    it("should return null for empty mappings", () => {
+      expect(getExternalValue({}, "project", "cm12345")).toBeNull();
+    });
+
+    it("should be case-sensitive for internal values", () => {
+      // Internal IDs should be matched exactly
+      expect(getExternalValue(fieldMappings, "project", "CM12345")).toBeNull();
+      expect(getExternalValue(fieldMappings, "project", "cm12345")).toBe("my-project-ref");
+    });
+  });
+
+  describe("getInternalValueFromMapping", () => {
+    it("should return internal value for external value", () => {
+      expect(getInternalValueFromMapping(fieldMappings, "project", "my-project-ref")).toBe(
+        "cm12345"
+      );
+      expect(getInternalValueFromMapping(fieldMappings, "project", "other-project")).toBe(
+        "cm67890"
+      );
+      expect(getInternalValueFromMapping(fieldMappings, "environment", "production")).toBe(
+        "env123"
+      );
+    });
+
+    it("should return null if external value is not found", () => {
+      expect(getInternalValueFromMapping(fieldMappings, "project", "unknown-ref")).toBeNull();
+    });
+
+    it("should return null if mapping name does not exist", () => {
+      expect(
+        getInternalValueFromMapping(fieldMappings, "nonexistent", "my-project-ref")
+      ).toBeNull();
+    });
+
+    it("should return null for empty mappings", () => {
+      expect(getInternalValueFromMapping({}, "project", "my-project-ref")).toBeNull();
+    });
+
+    it("should be case-sensitive for external values", () => {
+      // This is the case-sensitive version
+      expect(getInternalValueFromMapping(fieldMappings, "project", "MY-PROJECT-REF")).toBeNull();
+      expect(getInternalValueFromMapping(fieldMappings, "project", "my-project-ref")).toBe(
+        "cm12345"
+      );
+    });
+  });
+
+  describe("getInternalValueFromMappingCaseInsensitive", () => {
+    it("should return internal value for external value (case-insensitive)", () => {
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "my-project-ref")
+      ).toBe("cm12345");
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "MY-PROJECT-REF")
+      ).toBe("cm12345");
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "My-Project-Ref")
+      ).toBe("cm12345");
+    });
+
+    it("should return null if external value is not found (even case-insensitive)", () => {
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "unknown-ref")
+      ).toBeNull();
+    });
+
+    it("should return null if mapping name does not exist", () => {
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "nonexistent", "my-project-ref")
+      ).toBeNull();
+    });
+
+    it("should return null for empty mappings", () => {
+      expect(
+        getInternalValueFromMappingCaseInsensitive({}, "project", "my-project-ref")
+      ).toBeNull();
+    });
+
+    it("should handle mixed case external values correctly", () => {
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "mixed-case-project")
+      ).toBe("cmABCDE");
+      expect(
+        getInternalValueFromMappingCaseInsensitive(fieldMappings, "project", "MIXED-CASE-PROJECT")
+      ).toBe("cmABCDE");
+    });
+  });
+
+  describe("field mapping column schema definition", () => {
+    it("should allow defining columns with fieldMapping", () => {
+      const col: ColumnSchema = {
+        name: "project_ref",
+        clickhouseName: "project_id",
+        type: "String",
+        fieldMapping: "project",
+        description: "Project reference (external identifier)",
+      };
+
+      expect(hasFieldMapping(col)).toBe(true);
+      expect(col.clickhouseName).toBe("project_id");
+      expect(col.fieldMapping).toBe("project");
+    });
+
+    it("should allow fieldMapping with all standard column options", () => {
+      const col: ColumnSchema = {
+        name: "project_ref",
+        clickhouseName: "project_id",
+        ...column("String"),
+        fieldMapping: "project",
+        selectable: true,
+        filterable: true,
+        sortable: true,
+        groupable: true,
+      };
+
+      expect(hasFieldMapping(col)).toBe(true);
+      expect(col.selectable).toBe(true);
+      expect(col.filterable).toBe(true);
+    });
+  });
+});
+
+describe("Error message sanitization", () => {
+  // Test schema mimicking the real runs schema
+  const runsSchema: TableSchema = {
+    name: "runs",
+    clickhouseName: "trigger_dev.task_runs_v2",
+    description: "Task runs table",
+    tenantColumns: {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+    columns: {
+      run_id: {
+        name: "run_id",
+        clickhouseName: "friendly_id",
+        ...column("String"),
+      },
+      triggered_at: {
+        name: "triggered_at",
+        clickhouseName: "created_at",
+        ...column("DateTime64"),
+      },
+      machine: {
+        name: "machine",
+        clickhouseName: "machine_preset",
+        ...column("String"),
+      },
+      status: {
+        name: "status",
+        // No clickhouseName - same as name
+        ...column("String"),
+      },
+      task_identifier: {
+        name: "task_identifier",
+        // No clickhouseName - same as name
+        ...column("String"),
+      },
+    },
+  };
+
+  describe("sanitizeErrorMessage", () => {
+    it("should replace fully qualified table.column references", () => {
+      const error = "Missing column trigger_dev.task_runs_v2.friendly_id in query";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Missing column runs.run_id in query");
+    });
+
+    it("should replace standalone table names", () => {
+      const error = "Table trigger_dev.task_runs_v2 does not exist";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Table runs does not exist");
+    });
+
+    it("should replace standalone column names with different clickhouseName", () => {
+      const error = "Unknown identifier: friendly_id";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Unknown identifier: run_id");
+    });
+
+    it("should replace multiple occurrences in the same message", () => {
+      const error =
+        "Cannot compare friendly_id with created_at: incompatible types in trigger_dev.task_runs_v2";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Cannot compare run_id with triggered_at: incompatible types in runs");
+    });
+
+    it("should not replace column names that have no clickhouseName mapping", () => {
+      const error = "Invalid value for column status";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Invalid value for column status");
+    });
+
+    it("should handle error messages with quoted identifiers", () => {
+      const error = "Column 'machine_preset' is not of type String";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Column 'machine' is not of type String");
+    });
+
+    it("should handle error messages with backtick identifiers", () => {
+      const error = "Unknown column `friendly_id` in table";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Unknown column `run_id` in table");
+    });
+
+    it("should not replace partial matches within larger identifiers", () => {
+      const error = "Column my_friendly_id_column not found";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      // Should not replace "friendly_id" within "my_friendly_id_column"
+      expect(sanitized).toBe("Column my_friendly_id_column not found");
+    });
+
+    it("should return original message if no schemas provided", () => {
+      const error = "Some error with trigger_dev.task_runs_v2";
+      const sanitized = sanitizeErrorMessage(error, []);
+      expect(sanitized).toBe("Some error with trigger_dev.task_runs_v2");
+    });
+
+    it("should return original message if no matches found", () => {
+      const error = "Generic database error occurred";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Generic database error occurred");
+    });
+
+    it("should handle multiple tables", () => {
+      const eventsSchema: TableSchema = {
+        name: "events",
+        clickhouseName: "trigger_dev.task_events",
+        description: "Task events table",
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+        columns: {
+          event_id: {
+            name: "event_id",
+            clickhouseName: "internal_event_id",
+            ...column("String"),
+          },
+        },
+      };
+
+      const error =
+        "Cannot join trigger_dev.task_runs_v2 with trigger_dev.task_events on internal_event_id";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema, eventsSchema]);
+      expect(sanitized).toBe("Cannot join runs with events on event_id");
+    });
+
+    it("should handle real ClickHouse error format", () => {
+      const error =
+        "Unable to query clickhouse: Code: 47. DB::Exception: Missing columns: 'friendly_id' while processing query";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      // Should remove the "Unable to query clickhouse:" prefix
+      expect(sanitized).toBe(
+        "Code: 47. DB::Exception: Missing columns: 'run_id' while processing query"
+      );
+    });
+
+    it("should remove 'Unable to query clickhouse:' prefix", () => {
+      const error = "Unable to query clickhouse: Something went wrong";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Something went wrong");
+      expect(sanitized).not.toContain("Unable to query clickhouse");
+    });
+
+    it("should handle error with column in parentheses", () => {
+      const error = "Function count(friendly_id) expects different arguments";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Function count(run_id) expects different arguments");
+    });
+
+    it("should handle error with column after comma", () => {
+      const error = "SELECT friendly_id, created_at FROM table";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("SELECT run_id, triggered_at FROM table");
+    });
+
+    it("should NOT replace column names in 'Did you mean' error messages", () => {
+      // When a user types an internal ClickHouse column name, we show "Did you mean X?"
+      // The sanitizer should NOT replace the column name in this case, as it would
+      // turn "Unknown column 'created_at'. Did you mean 'triggered_at'?" into
+      // "Unknown column 'triggered_at'. Did you mean 'triggered_at'?" which is confusing
+      const error = 'Unknown column "created_at". Did you mean "triggered_at"?';
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      // Should preserve both the original column name AND the suggestion
+      expect(sanitized).toBe('Unknown column "created_at". Did you mean "triggered_at"?');
+    });
+
+    it("should prioritize longer matches (table.column before standalone column)", () => {
+      // This tests that we replace "trigger_dev.task_runs_v2.friendly_id" as a unit,
+      // not "trigger_dev.task_runs_v2" and then "friendly_id" separately
+      const error = "Error in trigger_dev.task_runs_v2.friendly_id";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Error in runs.run_id");
+    });
+
+    it("should remove tenant isolation filters from error messages", () => {
+      const error =
+        "Unknown identifier in scope SELECT run_id FROM runs WHERE ((organization_id = 'org123') AND (project_id = 'proj456') AND (environment_id = 'env789')) AND (status = 'Failed')";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).not.toContain("organization_id");
+      expect(sanitized).not.toContain("project_id");
+      expect(sanitized).not.toContain("environment_id");
+      expect(sanitized).toContain("status = 'Failed'");
+    });
+
+    it("should remove redundant column aliases like 'run_id AS run_id'", () => {
+      const error = "Error in SELECT run_id AS run_id, machine AS machine FROM runs";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Error in SELECT run_id, machine FROM runs");
+    });
+
+    it("should remove redundant table aliases like 'runs AS runs'", () => {
+      const error = "Error in SELECT * FROM runs AS runs WHERE status = 'Failed'";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+      expect(sanitized).toBe("Error in SELECT * FROM runs WHERE status = 'Failed'");
+    });
+
+    it("should handle real error with tenant filters and aliases", () => {
+      const error =
+        "Unable to query clickhouse: Unknown expression identifier `triggered_ata` in scope SELECT run_id AS run_id, machine AS machine FROM runs AS runs WHERE ((organization_id = 'cm5qtzpb800007cp7h6ebwt2i') AND (project_id = 'cme2p1yep00007calt8ugarkr') AND (environment_id = 'cme2p1ygj00027caln51kyiwl')) AND (status = 'Complted') ORDER BY triggered_ata DESC LIMIT 100.";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+
+      // Should not contain internal prefix
+      expect(sanitized).not.toContain("Unable to query clickhouse");
+
+      // Should not contain internal IDs
+      expect(sanitized).not.toContain("cm5qtzpb800007cp7h6ebwt2i");
+      expect(sanitized).not.toContain("cme2p1yep00007calt8ugarkr");
+      expect(sanitized).not.toContain("cme2p1ygj00027caln51kyiwl");
+      expect(sanitized).not.toContain("organization_id");
+      expect(sanitized).not.toContain("project_id");
+      expect(sanitized).not.toContain("environment_id");
+
+      // Should not have redundant aliases
+      expect(sanitized).not.toContain("run_id AS run_id");
+      expect(sanitized).not.toContain("machine AS machine");
+      expect(sanitized).not.toContain("runs AS runs");
+
+      // Should still have the user's query parts
+      expect(sanitized).toContain("status = 'Complted'");
+      expect(sanitized).toContain("triggered_ata");
+      expect(sanitized).toContain("LIMIT 100");
+    });
+
+    it("should remove required filters like engine = 'V2'", () => {
+      // Schema with required filters
+      const schemaWithRequiredFilters: TableSchema = {
+        name: "runs",
+        clickhouseName: "trigger_dev.task_runs_v2",
+        description: "Task runs table",
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+        requiredFilters: [{ column: "engine", value: "V2" }],
+        columns: {
+          run_id: {
+            name: "run_id",
+            ...column("String"),
+          },
+        },
+      };
+
+      const error =
+        "Error in SELECT run_id FROM runs WHERE ((organization_id = 'org1') AND (engine = 'V2')) AND (status = 'Failed')";
+      const sanitized = sanitizeErrorMessage(error, [schemaWithRequiredFilters]);
+
+      expect(sanitized).not.toContain("engine = 'V2'");
+      expect(sanitized).not.toContain("organization_id");
+      expect(sanitized).toContain("status = 'Failed'");
+    });
+
+    it("should handle project and environment field mappings in tenant columns", () => {
+      // The schema uses 'project' and 'environment' as column names with field mappings
+      const schemaWithFieldMappedTenants: TableSchema = {
+        name: "runs",
+        clickhouseName: "trigger_dev.task_runs_v2",
+        description: "Task runs table",
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project",
+          environmentId: "environment",
+        },
+        columns: {
+          run_id: {
+            name: "run_id",
+            ...column("String"),
+          },
+        },
+      };
+
+      const error =
+        "Error WHERE ((organization_id = 'org1') AND (project = 'proj1') AND (environment = 'env1')) AND (status = 'ok')";
+      const sanitized = sanitizeErrorMessage(error, [schemaWithFieldMappedTenants]);
+
+      expect(sanitized).not.toContain("organization_id = 'org1'");
+      expect(sanitized).not.toContain("project = 'proj1'");
+      expect(sanitized).not.toContain("environment = 'env1'");
+      expect(sanitized).toContain("status = 'ok'");
+    });
+
+    it("should handle queries with only automatic WHERE filters (no user WHERE clause)", () => {
+      // When user writes: SELECT * FROM runs LIMIT 10
+      // The compiled query becomes: SELECT * FROM runs WHERE (org_id = '...') AND (proj_id = '...') AND (env_id = '...')
+      const error =
+        "Unable to query clickhouse: Some error in SELECT run_id FROM runs WHERE ((organization_id = 'org1') AND (project_id = 'proj1') AND (environment_id = 'env1')) LIMIT 10";
+      const sanitized = sanitizeErrorMessage(error, [runsSchema]);
+
+      expect(sanitized).not.toContain("Unable to query clickhouse");
+      expect(sanitized).not.toContain("organization_id");
+      expect(sanitized).not.toContain("project_id");
+      expect(sanitized).not.toContain("environment_id");
+      expect(sanitized).not.toContain("WHERE");
+      expect(sanitized).toContain("SELECT run_id FROM runs");
+      expect(sanitized).toContain("LIMIT 10");
+    });
+
+    it("should handle queries with only automatic filters including engine filter", () => {
+      const schemaWithEngine: TableSchema = {
+        name: "runs",
+        clickhouseName: "trigger_dev.task_runs_v2",
+        description: "Task runs table",
+        tenantColumns: {
+          organizationId: "organization_id",
+          projectId: "project_id",
+          environmentId: "environment_id",
+        },
+        requiredFilters: [{ column: "engine", value: "V2" }],
+        columns: {
+          run_id: {
+            name: "run_id",
+            ...column("String"),
+          },
+        },
+      };
+
+      const error =
+        "Error in SELECT * FROM runs WHERE ((organization_id = 'org1') AND (project_id = 'proj1') AND (environment_id = 'env1') AND (engine = 'V2')) ORDER BY run_id";
+      const sanitized = sanitizeErrorMessage(error, [schemaWithEngine]);
+
+      expect(sanitized).not.toContain("organization_id");
+      expect(sanitized).not.toContain("project_id");
+      expect(sanitized).not.toContain("environment_id");
+      expect(sanitized).not.toContain("engine");
+      expect(sanitized).not.toContain("WHERE");
+      expect(sanitized).toContain("SELECT * FROM runs");
+      expect(sanitized).toContain("ORDER BY run_id");
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/query/schema.ts b/internal-packages/tsql/src/query/schema.ts
new file mode 100644
index 00000000000..615d112c2f1
--- /dev/null
+++ b/internal-packages/tsql/src/query/schema.ts
@@ -0,0 +1,1013 @@
+// Schema definitions for TSQL query validation
+// Defines allowed tables, columns, and tenant isolation configuration
+
+import { QueryError } from "./errors";
+import type { BucketThreshold } from "./time_buckets";
+
+/**
+ * ClickHouse data types supported by TSQL
+ */
+export type ClickHouseType =
+  | "String"
+  | "UInt8"
+  | "UInt16"
+  | "UInt32"
+  | "UInt64"
+  | "Int8"
+  | "Int16"
+  | "Int32"
+  | "Int64"
+  | "Float32"
+  | "Float64"
+  | "Date"
+  | "Date32"
+  | "DateTime"
+  | "DateTime64"
+  | "DateTime64(3)"
+  | "DateTime64(9)"
+  | "Decimal64(12)"
+  | "UUID"
+  | "Bool"
+  | "JSON"
+  | "Nullable(String)"
+  | "Nullable(UInt8)"
+  | "Nullable(UInt16)"
+  | "Nullable(UInt32)"
+  | "Nullable(UInt64)"
+  | "Nullable(Int8)"
+  | "Nullable(Int16)"
+  | "Nullable(Int32)"
+  | "Nullable(Int64)"
+  | "Nullable(Float32)"
+  | "Nullable(Float64)"
+  | "Nullable(Date)"
+  | "Nullable(Date32)"
+  | "Nullable(DateTime)"
+  | "Nullable(DateTime64)"
+  | "Nullable(UUID)"
+  | "Nullable(Bool)"
+  | "LowCardinality(String)"
+  | `Array(${string})`
+  | `Map(${string}, ${string})`;
+
+/**
+ * Schema definition for a single column
+ */
+export interface ColumnSchema {
+  /** The name of the column as exposed to TSQL queries */
+  name: string;
+  /** The actual ClickHouse column name (if different from `name`) */
+  clickhouseName?: string;
+  /** The ClickHouse data type */
+  type: ClickHouseType;
+  /** Whether this column can be selected */
+  selectable?: boolean;
+  /** Whether this column can be used in WHERE clauses */
+  filterable?: boolean;
+  /** Whether this column can be used in ORDER BY clauses */
+  sortable?: boolean;
+  /** Whether this column can be used in GROUP BY clauses */
+  groupable?: boolean;
+  /** Description of the column for documentation/autocomplete */
+  description?: string;
+  /** Allowed values for this column (for enum-like columns) */
+  allowedValues?: string[];
+  /**
+   * Map of internal values to user-friendly display names (for enum-like columns)
+   * Key: internal ClickHouse value (e.g., "COMPLETED_SUCCESSFULLY")
+   * Value: user-friendly display name (e.g., "Completed")
+   *
+   * When set, users can write queries using the user-friendly names,
+   * and results will display user-friendly names instead of internal values.
+   */
+  valueMap?: Record<string, string>;
+  /**
+   * For virtual (computed) columns: the raw ClickHouse SQL expression.
+   * Use actual ClickHouse column names in the expression.
+   *
+   * When set, this column becomes a virtual column that doesn't exist in the
+   * underlying table but is computed from the expression at query time.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "execution_duration",
+   *   type: "Nullable(Int64)",
+   *   expression: "dateDiff('millisecond', started_at, completed_at)",
+   *   description: "Time between started_at and completed_at in milliseconds"
+   * }
+   * ```
+   */
+  expression?: string;
+  /**
+   * Custom render type for UI display.
+   *
+   * When set, the UI can use this to render the column with a custom component
+   * instead of the default renderer based on ClickHouseType.
+   *
+   * Common custom render types:
+   * - "runStatus" - Task run status badges
+   * - "cost" - Cost formatting (cents to dollars)
+   * - "duration" - Duration formatting (ms to human-readable)
+   *
+   * Custom types can be defined by consumers without modifying this package.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "status",
+   *   type: "LowCardinality(String)",
+   *   customRenderType: "runStatus",
+   * }
+   * ```
+   */
+  customRenderType?: string;
+  /**
+   * Example value for documentation purposes.
+   *
+   * Used in help/documentation UI to show users what values look like.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "run_id",
+   *   type: "String",
+   *   example: "run_abc123",
+   * }
+   * ```
+   */
+  example?: string;
+  /**
+   * Whether this is a core column that should be included in default queries.
+   *
+   * Core columns represent the essential information for a table and are suggested
+   * as alternatives when users attempt to use SELECT * (which has poor performance
+   * in columnar databases like ClickHouse).
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "run_id",
+   *   type: "String",
+   *   coreColumn: true,
+   * }
+   * ```
+   */
+  coreColumn?: boolean;
+  /**
+   * Name of the runtime field mapping to use for value translation.
+   * When set, values are translated using the mapping provided at query time.
+   *
+   * Unlike `valueMap` which is static and defined in the schema, `fieldMapping`
+   * references a mapping that is provided at runtime via `FieldMappings`.
+   *
+   * - During query compilation: external values → internal values
+   * - During result transformation: internal values → external values (or null if unmapped)
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "project_ref",
+   *   clickhouseName: "project_id",  // Maps to actual CH column
+   *   type: "String",
+   *   fieldMapping: "project",  // Uses runtime "project" mapping
+   * }
+   * ```
+   */
+  fieldMapping?: string;
+  /**
+   * Transform function for user input values in WHERE clauses.
+   *
+   * When set, this function is called to transform user-provided values before
+   * they are used in comparisons. This is useful for columns where:
+   * - Users query with prefixed IDs (e.g., "batch_xyz") but the column stores raw values ("xyz")
+   * - Values need normalization before comparison
+   *
+   * The function receives the user's input string and returns the transformed value
+   * to use in the actual ClickHouse query.
+   *
+   * For output transformation (adding prefixes in SELECT), use `expression` instead.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "batch_id",
+   *   type: "String",
+   *   // Strip "batch_" prefix from user input in WHERE clauses
+   *   whereTransform: (value) => value.replace(/^batch_/, ""),
+   *   // Add prefix back in SELECT output
+   *   expression: "if(batch_id = '', NULL, concat('batch_', batch_id))",
+   * }
+   * ```
+   */
+  whereTransform?: (value: string) => string;
+  /**
+   * Value to use when comparing to NULL for this column.
+   *
+   * When set, NULL comparisons (IS NULL, IS NOT NULL, = NULL, != NULL) are
+   * transformed to compare against this value instead. This is useful for
+   * JSON/Object columns where "empty" is represented as '{}' rather than NULL.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "error",
+   *   type: "JSON",
+   *   nullValue: "'{}'",  // error IS NULL → error = '{}'
+   * }
+   * ```
+   */
+  nullValue?: string;
+  /**
+   * Alternative text column to use when selecting or comparing the full JSON value.
+   *
+   * For JSON columns, this allows using a pre-materialized string column
+   * which is more efficient than reading from the JSON column directly.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "output",
+   *   type: "JSON",
+   *   textColumn: "output_text",
+   * }
+   * ```
+   */
+  textColumn?: string;
+  /**
+   * Prefix path for JSON column data access.
+   *
+   * When set, user paths like `output.message` are automatically transformed
+   * to `output.data.message` in the actual query, and result aliases exclude
+   * the prefix (e.g., `output_message` instead of `output_data_message`).
+   *
+   * This is useful when JSON data is stored wrapped in a container object
+   * (e.g., `{"data": actualData}`) to handle arrays and primitives.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "output",
+   *   type: "JSON",
+   *   dataPrefix: "data",  // output.message → output.data.message
+   * }
+   * ```
+   */
+  dataPrefix?: string;
+}
+
+/**
+ * Runtime field mappings for dynamic value translation.
+ *
+ * Structure: mappingName → (internalValue → externalValue)
+ *
+ * @example
+ * ```typescript
+ * const fieldMappings: FieldMappings = {
+ *   project: {
+ *     "cm12345": "my-project-ref",
+ *     "cm67890": "other-project-ref",
+ *   },
+ * };
+ * ```
+ */
+export type FieldMappings = Record<string, Record<string, string>>;
+
+/**
+ * Display format types for column values.
+ *
+ * These tell the UI how to render values without changing the underlying data type.
+ * Includes both existing custom render types and new format hint types.
+ */
+export type ColumnFormatType =
+  // Existing custom render types
+  | "runId"
+  | "runStatus"
+  | "duration"
+  | "durationNs"
+  | "durationSeconds"
+  | "costInDollars"
+  | "cost"
+  | "machine"
+  | "environment"
+  | "environmentType"
+  | "project"
+  | "queue"
+  | "tags"
+  | "number"
+  // Format hint types (used by prettyFormat())
+  | "bytes"
+  | "decimalBytes"
+  | "quantity"
+  | "percent";
+
+/**
+ * Metadata for a column in query results.
+ *
+ * This is returned by the TSQL compiler to describe each column in the SELECT clause,
+ * allowing the UI to render columns appropriately without inspecting result values.
+ */
+export interface OutputColumnMetadata {
+  /** Column name in the result set (after AS aliasing) */
+  name: string;
+  /** ClickHouse data type (from schema or inferred for computed expressions) */
+  type: ClickHouseType;
+  /**
+   * Custom render type from schema, if specified.
+   * When set, the UI should use a custom renderer instead of the default for the ClickHouseType.
+   */
+  customRenderType?: string;
+  /**
+   * Description from the schema column definition, if available.
+   * Only present for columns or virtual columns defined in the table schema.
+   */
+  description?: string;
+  /**
+   * Display format hint — tells the UI how to render numeric values.
+   *
+   * Set by `prettyFormat(expr, 'formatType')` in TSQL queries.
+   * The underlying value remains numeric (for charts), but the UI uses this
+   * hint for axis labels, table cells, and tooltips.
+   *
+   * Also auto-populated from `customRenderType` when not explicitly set.
+   */
+  format?: ColumnFormatType;
+}
+
+/**
+ * Configuration for tenant isolation columns
+ * These columns are automatically added to WHERE clauses
+ */
+export interface TenantColumnConfig {
+  /** The column name for organization ID filtering */
+  organizationId: string;
+  /** The column name for project ID filtering */
+  projectId: string;
+  /** The column name for environment ID filtering */
+  environmentId: string;
+}
+
+/**
+ * Required filter that is always applied to queries on a table
+ */
+export interface RequiredFilter {
+  /** The ClickHouse column name to filter on */
+  column: string;
+  /** The value the column must equal */
+  value: string;
+}
+
+/**
+ * Schema definition for a table
+ */
+export interface TableSchema {
+  /** The name of the table as exposed to TSQL queries */
+  name: string;
+  /** The fully qualified ClickHouse table name (e.g., "trigger_dev.task_runs_v2") */
+  clickhouseName: string;
+  /** Column definitions for this table */
+  columns: Record<string, ColumnSchema>;
+  /** Tenant isolation column configuration. Omit for global tables with no tenant scoping. */
+  tenantColumns?: TenantColumnConfig;
+  /** Description of the table for documentation/autocomplete */
+  description?: string;
+  /** Whether this table can be joined to other tables */
+  joinable?: boolean;
+  /**
+   * Required filters that are always applied to queries on this table.
+   * These are injected into the WHERE clause automatically, similar to tenant isolation.
+   */
+  requiredFilters?: RequiredFilter[];
+  /**
+   * The TSQL column name used as the time constraint for `timeBucket()`.
+   *
+   * When set, `timeBucket()` resolves to `toStartOfInterval(clickhouse_column, INTERVAL ...)`,
+   * using the ClickHouse column name mapped from this TSQL column.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   name: "runs",
+   *   timeConstraint: "triggered_at", // TSQL column name; maps to CH column "created_at"
+   *   columns: {
+   *     triggered_at: { name: "triggered_at", clickhouseName: "created_at", ...column("DateTime64") },
+   *   },
+   * }
+   * ```
+   */
+  timeConstraint?: string;
+  /**
+   * Custom time bucket thresholds for this table.
+   * When set, timeBucket() uses these instead of the global defaults.
+   * Useful when the table's time granularity differs from the standard (e.g., metrics
+   * pre-aggregated into 10-second buckets shouldn't go below 10-second intervals).
+   */
+  timeBucketThresholds?: BucketThreshold[];
+  /**
+   * Whether to add the FINAL keyword when querying this table.
+   * This should be set to `true` for ReplacingMergeTree tables where deduplication
+   * is needed to get correct results. Not needed for plain MergeTree tables.
+   */
+  useFinal?: boolean;
+}
+
+/**
+ * Schema registry containing all allowed tables
+ */
+export interface SchemaRegistry {
+  /** Map of table names to their schemas */
+  tables: Record<string, TableSchema>;
+  /** Default tenant column names (used when a table doesn't specify its own) */
+  defaultTenantColumns: TenantColumnConfig;
+}
+
+/**
+ * Create a basic column schema with common defaults
+ */
+export function column(
+  type: ClickHouseType,
+  options: Partial<Omit<ColumnSchema, "name" | "type">> = {}
+): Omit<ColumnSchema, "name"> {
+  return {
+    type,
+    selectable: true,
+    filterable: true,
+    sortable: true,
+    groupable: true,
+    ...options,
+  };
+}
+
+/**
+ * Create a schema registry from a list of table schemas
+ */
+export function createSchemaRegistry(
+  tables: TableSchema[],
+  defaultTenantColumns?: TenantColumnConfig
+): SchemaRegistry {
+  const tableMap: Record<string, TableSchema> = {};
+  for (const table of tables) {
+    tableMap[table.name] = table;
+  }
+  return {
+    tables: tableMap,
+    defaultTenantColumns: defaultTenantColumns ?? {
+      organizationId: "organization_id",
+      projectId: "project_id",
+      environmentId: "environment_id",
+    },
+  };
+}
+
+/**
+ * Look up a table schema by name
+ */
+export function findTable(schema: SchemaRegistry, tableName: string): TableSchema | undefined {
+  return schema.tables[tableName];
+}
+
+/**
+ * Look up a column schema by table and column name
+ */
+export function findColumn(
+  schema: SchemaRegistry,
+  tableName: string,
+  columnName: string
+): ColumnSchema | undefined {
+  const table = findTable(schema, tableName);
+  if (!table) return undefined;
+  return table.columns[columnName];
+}
+
+/**
+ * Validate that a table exists in the schema
+ * @throws QueryError if the table is not found
+ */
+export function validateTable(schema: SchemaRegistry, tableName: string): TableSchema {
+  const table = findTable(schema, tableName);
+  if (!table) {
+    const availableTables = Object.keys(schema.tables).join(", ");
+    throw new QueryError(
+      `Table "${tableName}" is not accessible. Available tables: ${availableTables || "(none)"}`
+    );
+  }
+  return table;
+}
+
+/**
+ * Validate that a column exists in a table and can be selected
+ * @throws QueryError if the column is not found or not selectable
+ */
+export function validateSelectColumn(
+  schema: SchemaRegistry,
+  tableName: string,
+  columnName: string
+): ColumnSchema {
+  const table = validateTable(schema, tableName);
+  const col = table.columns[columnName];
+  if (!col) {
+    const availableColumns = Object.keys(table.columns).join(", ");
+    throw new QueryError(
+      `Column "${columnName}" does not exist on table "${tableName}". Available columns: ${availableColumns}`
+    );
+  }
+  if (col.selectable === false) {
+    throw new QueryError(`Column "${columnName}" on table "${tableName}" is not selectable`);
+  }
+  return col;
+}
+
+/**
+ * Validate that a column can be used in a WHERE clause
+ * @throws QueryError if the column is not filterable
+ */
+export function validateFilterColumn(
+  schema: SchemaRegistry,
+  tableName: string,
+  columnName: string
+): ColumnSchema {
+  const table = validateTable(schema, tableName);
+  const col = table.columns[columnName];
+  if (!col) {
+    throw new QueryError(`Column "${columnName}" does not exist on table "${tableName}"`);
+  }
+  if (col.filterable === false) {
+    throw new QueryError(`Column "${columnName}" on table "${tableName}" cannot be used in WHERE`);
+  }
+  return col;
+}
+
+/**
+ * Validate that a column can be used in ORDER BY
+ * @throws QueryError if the column is not sortable
+ */
+export function validateSortColumn(
+  schema: SchemaRegistry,
+  tableName: string,
+  columnName: string
+): ColumnSchema {
+  const table = validateTable(schema, tableName);
+  const col = table.columns[columnName];
+  if (!col) {
+    throw new QueryError(`Column "${columnName}" does not exist on table "${tableName}"`);
+  }
+  if (col.sortable === false) {
+    throw new QueryError(
+      `Column "${columnName}" on table "${tableName}" cannot be used in ORDER BY`
+    );
+  }
+  return col;
+}
+
+/**
+ * Validate that a column can be used in GROUP BY
+ * @throws QueryError if the column is not groupable
+ */
+export function validateGroupColumn(
+  schema: SchemaRegistry,
+  tableName: string,
+  columnName: string
+): ColumnSchema {
+  const table = validateTable(schema, tableName);
+  const col = table.columns[columnName];
+  if (!col) {
+    throw new QueryError(`Column "${columnName}" does not exist on table "${tableName}"`);
+  }
+  if (col.groupable === false) {
+    throw new QueryError(
+      `Column "${columnName}" on table "${tableName}" cannot be used in GROUP BY`
+    );
+  }
+  return col;
+}
+
+/**
+ * Get the actual ClickHouse column name (handles aliasing)
+ */
+export function getClickHouseColumnName(col: ColumnSchema): string {
+  return col.clickhouseName ?? col.name;
+}
+
+/**
+ * Check if a column is a virtual (computed) column
+ *
+ * Virtual columns have an expression property that defines how they are computed
+ * from other columns. They don't exist in the underlying table.
+ *
+ * @param col - The column schema to check
+ * @returns true if the column is virtual, false otherwise
+ */
+export function isVirtualColumn(col: ColumnSchema): boolean {
+  return col.expression !== undefined && col.expression.length > 0;
+}
+
+/**
+ * Get the expression for a virtual column
+ *
+ * @param col - The column schema
+ * @returns The expression string, or undefined if not a virtual column
+ */
+export function getVirtualColumnExpression(col: ColumnSchema): string | undefined {
+  return isVirtualColumn(col) ? col.expression : undefined;
+}
+
+/**
+ * Get the user-friendly display value for an internal value (case-insensitive)
+ * Used for transforming query results back to user-friendly format
+ *
+ * @param col - The column schema
+ * @param internalValue - The internal ClickHouse value
+ * @returns The user-friendly display value, or the original value if no mapping exists
+ */
+export function getUserFriendlyValue(col: ColumnSchema, internalValue: string): string {
+  if (!col.valueMap) {
+    return internalValue;
+  }
+
+  // Direct lookup first (case-sensitive for exact match)
+  if (col.valueMap[internalValue] !== undefined) {
+    return col.valueMap[internalValue];
+  }
+
+  // Case-insensitive fallback
+  const lowerValue = internalValue.toLowerCase();
+  for (const [internal, friendly] of Object.entries(col.valueMap)) {
+    if (internal.toLowerCase() === lowerValue) {
+      return friendly;
+    }
+  }
+
+  return internalValue;
+}
+
+/**
+ * Get the internal ClickHouse value for a user-friendly value (case-insensitive)
+ * Used for transforming user queries to internal format
+ *
+ * @param col - The column schema
+ * @param userValue - The user-friendly display value
+ * @returns The internal ClickHouse value, or the original value if no mapping exists
+ */
+export function getInternalValue(col: ColumnSchema, userValue: string): string {
+  if (!col.valueMap) {
+    return userValue;
+  }
+
+  const lowerUserValue = userValue.toLowerCase();
+
+  // Search for matching user-friendly value (case-insensitive)
+  for (const [internal, friendly] of Object.entries(col.valueMap)) {
+    if (friendly.toLowerCase() === lowerUserValue) {
+      return internal;
+    }
+  }
+
+  return userValue;
+}
+
+/**
+ * Get all allowed user-friendly values for a column
+ * Used for validation and autocomplete
+ *
+ * @param col - The column schema
+ * @returns Array of allowed user-friendly values, or allowedValues if no valueMap exists
+ */
+export function getAllowedUserValues(col: ColumnSchema): string[] {
+  if (col.valueMap) {
+    return Object.values(col.valueMap);
+  }
+  return col.allowedValues ?? [];
+}
+
+/**
+ * Check if a user-provided value is valid for a column (case-insensitive)
+ *
+ * @param col - The column schema
+ * @param userValue - The user-provided value to validate
+ * @returns true if the value is valid, false otherwise
+ */
+export function isValidUserValue(col: ColumnSchema, userValue: string): boolean {
+  const allowedValues = getAllowedUserValues(col);
+  if (allowedValues.length === 0) {
+    return true; // No restrictions
+  }
+
+  const lowerUserValue = userValue.toLowerCase();
+  return allowedValues.some((v) => v.toLowerCase() === lowerUserValue);
+}
+
+// ============================================================
+// Field Mapping Utilities (Runtime Dynamic Mappings)
+// ============================================================
+
+/**
+ * Check if a column uses a runtime field mapping
+ *
+ * @param col - The column schema to check
+ * @returns true if the column has a fieldMapping defined
+ */
+export function hasFieldMapping(col: ColumnSchema): boolean {
+  return col.fieldMapping !== undefined && col.fieldMapping.length > 0;
+}
+
+/**
+ * Get the external (user-facing) value for an internal ClickHouse value
+ * using a runtime field mapping.
+ *
+ * @param mappings - The runtime field mappings
+ * @param mappingName - The name of the mapping to use (from column's fieldMapping)
+ * @param internalValue - The internal ClickHouse value
+ * @returns The external value, or null if not found in the mapping
+ */
+export function getExternalValue(
+  mappings: FieldMappings,
+  mappingName: string,
+  internalValue: string
+): string | null {
+  const mapping = mappings[mappingName];
+  if (!mapping) {
+    return null;
+  }
+
+  const externalValue = mapping[internalValue];
+  return externalValue !== undefined ? externalValue : null;
+}
+
+/**
+ * Get the internal ClickHouse value for an external (user-facing) value
+ * using a runtime field mapping. This performs a reverse lookup.
+ *
+ * @param mappings - The runtime field mappings
+ * @param mappingName - The name of the mapping to use (from column's fieldMapping)
+ * @param externalValue - The external (user-facing) value
+ * @returns The internal value, or null if not found in the mapping
+ */
+export function getInternalValueFromMapping(
+  mappings: FieldMappings,
+  mappingName: string,
+  externalValue: string
+): string | null {
+  const mapping = mappings[mappingName];
+  if (!mapping) {
+    return null;
+  }
+
+  // Reverse lookup: find internal value by external value
+  for (const [internal, external] of Object.entries(mapping)) {
+    if (external === externalValue) {
+      return internal;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get the internal ClickHouse value for an external value (case-insensitive)
+ * using a runtime field mapping.
+ *
+ * @param mappings - The runtime field mappings
+ * @param mappingName - The name of the mapping to use
+ * @param externalValue - The external (user-facing) value
+ * @returns The internal value, or null if not found
+ */
+export function getInternalValueFromMappingCaseInsensitive(
+  mappings: FieldMappings,
+  mappingName: string,
+  externalValue: string
+): string | null {
+  const mapping = mappings[mappingName];
+  if (!mapping) {
+    return null;
+  }
+
+  const lowerExternal = externalValue.toLowerCase();
+
+  // Case-insensitive reverse lookup
+  for (const [internal, external] of Object.entries(mapping)) {
+    if (external.toLowerCase() === lowerExternal) {
+      return internal;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get all column names available for autocomplete
+ */
+export function getTableColumnNames(schema: SchemaRegistry, tableName: string): string[] {
+  const table = findTable(schema, tableName);
+  if (!table) return [];
+  return Object.keys(table.columns);
+}
+
+/**
+ * Get all table names available for autocomplete
+ */
+export function getAllTableNames(schema: SchemaRegistry): string[] {
+  return Object.keys(schema.tables);
+}
+
+/**
+ * Get the names of core columns for a table.
+ *
+ * Core columns are the essential columns that should be used when users
+ * need a default set of columns (e.g., as an alternative to SELECT *).
+ *
+ * @param table - The table schema
+ * @returns Array of core column names, empty if none are marked as core
+ */
+export function getCoreColumns(table: TableSchema): string[] {
+  return Object.values(table.columns)
+    .filter((col) => col.coreColumn === true)
+    .map((col) => col.name);
+}
+
+// ============================================================
+// Error Message Sanitization
+// ============================================================
+
+/**
+ * Sanitize a ClickHouse error message by replacing internal ClickHouse names
+ * with their user-facing TSQL equivalents and removing internal implementation details.
+ *
+ * This function handles:
+ * - Fully qualified table names (e.g., `trigger_dev.task_runs_v2` → `runs`)
+ * - Column names with table prefix (e.g., `trigger_dev.task_runs_v2.friendly_id` → `runs.run_id`)
+ * - Standalone column names (e.g., `friendly_id` → `run_id`)
+ * - Removes tenant isolation filters (organization_id, project_id, environment_id)
+ * - Removes required filters (e.g., engine = 'V2')
+ * - Removes redundant aliases (e.g., `run_id AS run_id` → `run_id`)
+ *
+ * @param message - The error message from ClickHouse
+ * @param schemas - The table schemas defining name mappings
+ * @returns The sanitized error message with TSQL names
+ *
+ * @example
+ * ```typescript
+ * const sanitized = sanitizeErrorMessage(
+ *   "Missing column trigger_dev.task_runs_v2.friendly_id",
+ *   [runsSchema]
+ * );
+ * // Returns: "Missing column runs.run_id"
+ * ```
+ */
+export function sanitizeErrorMessage(message: string, schemas: TableSchema[]): string {
+  // Build reverse lookup maps
+  const tableNameMap = new Map<string, string>(); // clickhouseName -> tsqlName
+  const columnNameMap = new Map<string, { tsqlName: string; tableTsqlName: string }>(); // clickhouseName -> { tsqlName, tableTsqlName }
+
+  // Collect tenant column names and required filter columns to strip from errors
+  const columnsToStrip: string[] = [];
+  const tableAliasPatterns: RegExp[] = [];
+
+  for (const table of schemas) {
+    // Map table names
+    tableNameMap.set(table.clickhouseName, table.name);
+
+    // Collect tenant column names to strip (global tables have no tenant columns)
+    const tenantCols = table.tenantColumns;
+    if (tenantCols) {
+      columnsToStrip.push(tenantCols.organizationId, tenantCols.projectId, tenantCols.environmentId);
+    }
+
+    // Collect required filter columns to strip
+    if (table.requiredFilters) {
+      for (const filter of table.requiredFilters) {
+        columnsToStrip.push(filter.column);
+      }
+    }
+
+    // Build pattern to remove table aliases like "FROM runs AS runs"
+    tableAliasPatterns.push(
+      new RegExp(`\\b${escapeRegex(table.name)}\\s+AS\\s+${escapeRegex(table.name)}\\b`, "gi")
+    );
+
+    // Map column names
+    for (const col of Object.values(table.columns)) {
+      const clickhouseColName = col.clickhouseName ?? col.name;
+      if (clickhouseColName !== col.name) {
+        // Only add to map if there's actually a different ClickHouse name
+        columnNameMap.set(clickhouseColName, {
+          tsqlName: col.name,
+          tableTsqlName: table.name,
+        });
+      }
+    }
+  }
+
+  let result = message;
+
+  // Step 0: Remove internal prefixes that leak implementation details
+  result = result.replace(/^Unable to query clickhouse:\s*/i, "");
+
+  // Step 1: Remove tenant isolation and required filter conditions
+  // We need to handle multiple patterns:
+  // - (column = 'value') AND ...
+  // - ... AND (column = 'value')
+  // - (column = 'value') at end of expression
+  for (const colName of columnsToStrip) {
+    const escaped = escapeRegex(colName);
+    // Match: (column = 'value') AND  (with optional surrounding parens)
+    result = result.replace(new RegExp(`\\(${escaped}\\s*=\\s*'[^']*'\\)\\s*AND\\s*`, "gi"), "");
+    // Match: AND (column = 'value') (handles middle/end conditions)
+    result = result.replace(new RegExp(`\\s*AND\\s*\\(${escaped}\\s*=\\s*'[^']*'\\)`, "gi"), "");
+    // Match standalone: (column = 'value') with no AND (for when it's the only/last condition)
+    result = result.replace(new RegExp(`\\(${escaped}\\s*=\\s*'[^']*'\\)`, "gi"), "");
+  }
+
+  // Step 2: Clean up any leftover empty WHERE conditions or double parentheses
+  // Clean up empty nested parens: "(())" or "( () )" -> ""
+  result = result.replace(/\(\s*\(\s*\)\s*\)/g, "");
+  // Clean up empty parens: "()" -> ""
+  result = result.replace(/\(\s*\)/g, "");
+  // Clean up "WHERE  AND" -> "WHERE"
+  result = result.replace(/\bWHERE\s+AND\b/gi, "WHERE");
+  // Clean up double ANDs: "AND AND" -> "AND"
+  result = result.replace(/\bAND\s+AND\b/gi, "AND");
+  // Clean up "WHERE ((" with user condition "))" -> "WHERE (condition)"
+  // First normalize: "(( (condition) ))" patterns
+  result = result.replace(/\(\(\s*\(/g, "(");
+  result = result.replace(/\)\s*\)\)/g, ")");
+  // Clean double parens around single condition
+  result = result.replace(/\(\(([^()]+)\)\)/g, "($1)");
+  // Remove "WHERE ()" if the whole WHERE is now empty
+  result = result.replace(/\bWHERE\s*\(\s*\)\s*/gi, "");
+  // Clean up trailing " )" before ORDER/LIMIT/etc
+  result = result.replace(/\s+\)\s*(ORDER|LIMIT|GROUP|HAVING)/gi, " $1");
+  // Remove empty WHERE clause: "WHERE  ORDER" or "WHERE  LIMIT" -> just "ORDER" or "LIMIT"
+  result = result.replace(/\bWHERE\s+(ORDER|LIMIT|GROUP|HAVING)\b/gi, "$1");
+  // Remove empty WHERE at end of string: "WHERE " at end -> ""
+  result = result.replace(/\bWHERE\s*$/gi, "");
+  // Clean up multiple spaces
+  result = result.replace(/\s{2,}/g, " ");
+
+  // Step 3: Replace fully qualified column references first (table.column)
+  // This handles patterns like: trigger_dev.task_runs_v2.friendly_id
+  for (const table of schemas) {
+    for (const col of Object.values(table.columns)) {
+      const clickhouseColName = col.clickhouseName ?? col.name;
+      const fullyQualified = `${table.clickhouseName}.${clickhouseColName}`;
+      const tsqlQualified = `${table.name}.${col.name}`;
+
+      if (fullyQualified !== tsqlQualified) {
+        // Use word boundary-aware replacement
+        result = replaceAllOccurrences(result, fullyQualified, tsqlQualified);
+      }
+    }
+  }
+
+  // Step 4: Replace standalone table names (after column references to avoid partial matches)
+  // Sort by length descending to replace longer names first
+  const sortedTableNames = [...tableNameMap.entries()].sort((a, b) => b[0].length - a[0].length);
+  for (const [clickhouseName, tsqlName] of sortedTableNames) {
+    if (clickhouseName !== tsqlName) {
+      result = replaceAllOccurrences(result, clickhouseName, tsqlName);
+    }
+  }
+
+  // Step 5: Replace standalone column names (for unqualified references)
+  // Skip column replacement for "Did you mean" errors - these already have the correct names
+  // and replacing would turn "Unknown column 'created_at'. Did you mean 'triggered_at'?"
+  // into "Unknown column 'triggered_at'. Did you mean 'triggered_at'?" which is confusing
+  if (!result.includes('Did you mean "')) {
+    // Sort by length descending to replace longer names first
+    const sortedColumnNames = [...columnNameMap.entries()].sort(
+      (a, b) => b[0].length - a[0].length
+    );
+    for (const [clickhouseName, { tsqlName }] of sortedColumnNames) {
+      result = replaceAllOccurrences(result, clickhouseName, tsqlName);
+    }
+  }
+
+  // Step 6: Remove redundant column aliases like "run_id AS run_id"
+  result = result.replace(/\b(\w+)\s+AS\s+\1\b/gi, "$1");
+
+  // Step 7: Remove table aliases like "runs AS runs"
+  for (const pattern of tableAliasPatterns) {
+    result = result.replace(pattern, (match) => match.split(/\s+AS\s+/i)[0]);
+  }
+
+  return result;
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Replace all occurrences of a string, respecting word boundaries where sensible.
+ * Uses word-boundary matching to avoid replacing substrings within larger identifiers.
+ */
+function replaceAllOccurrences(text: string, search: string, replacement: string): string {
+  // Use word boundary matching - identifiers are typically surrounded by
+  // non-identifier characters (spaces, quotes, parentheses, operators, etc.)
+  // We use a pattern that matches the identifier when it's not part of a larger identifier
+  const pattern = new RegExp(`(?<![a-zA-Z0-9_])${escapeRegex(search)}(?![a-zA-Z0-9_])`, "g");
+
+  return text.replace(pattern, replacement);
+}
diff --git a/internal-packages/tsql/src/query/security.test.ts b/internal-packages/tsql/src/query/security.test.ts
new file mode 100644
index 00000000000..2fcca477770
--- /dev/null
+++ b/internal-packages/tsql/src/query/security.test.ts
@@ -0,0 +1,710 @@
+/**
+ * Security Tests for TSQL
+ *
+ * These tests verify that the TSQL parser and printer correctly prevent:
+ * 1. Cross-tenant data access
+ * 2. SQL injection attacks
+ */
+import { describe, expect, it } from "vitest";
+import { compileTSQL, type CompileTSQLOptions } from "../index.js";
+import { column, type TableSchema } from "./schema.js";
+
+/**
+ * Test schemas
+ */
+const taskRunsSchema: TableSchema = {
+  name: "task_runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    status: { name: "status", ...column("String") },
+    task_identifier: { name: "task_identifier", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime64") },
+    duration_ms: { name: "duration_ms", ...column("Nullable(UInt64)") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+    payload: { name: "payload", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+const taskEventsSchema: TableSchema = {
+  name: "task_events",
+  clickhouseName: "trigger_dev.task_events_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    run_id: { name: "run_id", ...column("String") },
+    event_type: { name: "event_type", ...column("String") },
+    timestamp: { name: "timestamp", ...column("DateTime64") },
+    organization_id: { name: "organization_id", ...column("String") },
+    project_id: { name: "project_id", ...column("String") },
+    environment_id: { name: "environment_id", ...column("String") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+const defaultOptions: CompileTSQLOptions = {
+  tableSchema: [taskRunsSchema, taskEventsSchema],
+  enforcedWhereClause: {
+    organization_id: { op: "eq", value: "org_tenant1" },
+    project_id: { op: "eq", value: "proj_tenant1" },
+    environment_id: { op: "eq", value: "env_tenant1" },
+  },
+};
+
+function compile(query: string, options: Partial<CompileTSQLOptions> = {}) {
+  return compileTSQL(query, { ...defaultOptions, ...options });
+}
+
+describe("Cross-Tenant Security", () => {
+  describe("Tenant guards are always injected", () => {
+    it("should inject tenant guards on simple SELECT", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs");
+
+      // Must contain all three tenant columns
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+
+      // Tenant values must be parameterized
+      expect(Object.values(params)).toContain("org_tenant1");
+      expect(Object.values(params)).toContain("proj_tenant1");
+      expect(Object.values(params)).toContain("env_tenant1");
+    });
+
+    it("should inject tenant guards even with user WHERE clause", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'completed'");
+
+      // Must still have tenant guards
+      expect(sql).toContain("organization_id");
+      expect(sql).toContain("project_id");
+      expect(sql).toContain("environment_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+    });
+
+    it("should inject tenant guards on all tables in JOIN", () => {
+      const { sql } = compile(`
+        SELECT r.id, e.event_type 
+        FROM task_runs r 
+        JOIN task_events e ON r.id = e.run_id
+      `);
+
+      // Both tables should have tenant guards
+      // Count occurrences of organization_id - should appear twice (once per table)
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should inject tenant guards in subqueries", () => {
+      const { sql } = compile(`
+        SELECT * FROM task_runs 
+        WHERE id IN (SELECT run_id FROM task_events WHERE event_type = 'completed')
+      `);
+
+      // Should have tenant guards in both main query and subquery
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should inject tenant guards on UNION queries", () => {
+      const { sql } = compile(`
+        SELECT id, status FROM task_runs WHERE status = 'completed'
+        UNION ALL
+        SELECT id, status FROM task_runs WHERE status = 'failed'
+      `);
+
+      // Both sides of UNION should have tenant guards
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe("Cannot bypass tenant guards", () => {
+    it("should not allow OR clause to bypass tenant guard", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'completed' OR 1=1");
+
+      // The tenant guards should be ANDed with the entire WHERE clause
+      // So even with OR 1=1, the tenant guard still applies
+      expect(sql).toContain("organization_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+
+      // The structure should be: and(tenant_guards, or(user_conditions))
+      // The user's OR should be nested inside the outer AND with tenant guards
+      // This ensures tenant_guard AND (status='completed' OR 1=1)
+      // NOT: tenant_guard AND status='completed' OR 1=1 (which would bypass)
+
+      // Verify the OR is contained within an outer AND structure
+      // The tenant guards use and() and the user's OR uses or()
+      expect(sql).toContain("or(");
+      expect(sql).toContain("and(");
+
+      // The and() should wrap everything - find where tenant columns appear
+      // They should be at the same level as the user's condition, both inside and()
+      const whereClause = sql.substring(sql.indexOf("WHERE"));
+      expect(whereClause).toMatch(/and\([^)]*organization_id/);
+    });
+
+    it("should not allow accessing other tenant's data via explicit condition", () => {
+      const { sql, params } = compile(
+        "SELECT * FROM task_runs WHERE organization_id = 'org_other_tenant'"
+      );
+
+      // Even if user specifies a different org_id, our tenant guard should override
+      // The compiled SQL should still use our tenant's ID
+      expect(Object.values(params)).toContain("org_tenant1");
+    });
+
+    it("should not allow UNION with unguarded query", () => {
+      // This should be rejected or the second part should still be guarded
+      const { sql } = compile(`
+        SELECT id FROM task_runs
+        UNION ALL
+        SELECT id FROM task_runs
+      `);
+
+      // Both parts must have tenant guards
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should not allow subquery to access other tenants", () => {
+      const { sql, params } = compile(`
+        SELECT * FROM task_runs 
+        WHERE id IN (
+          SELECT run_id FROM task_events
+        )
+      `);
+
+      // Subquery must also have tenant guards
+      expect(Object.values(params)).toContain("org_tenant1");
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe("Table allowlisting", () => {
+    it("should reject queries to unknown tables", () => {
+      expect(() => {
+        compile("SELECT * FROM users");
+      }).toThrow();
+    });
+
+    it("should reject queries to system tables", () => {
+      expect(() => {
+        compile("SELECT * FROM system.tables");
+      }).toThrow();
+    });
+
+    it("should reject queries trying to use database prefix", () => {
+      expect(() => {
+        compile("SELECT * FROM other_database.task_runs");
+      }).toThrow();
+    });
+  });
+});
+
+describe("SQL Injection Prevention", () => {
+  describe("String value injection", () => {
+    it("should reject queries with stacked statements in strings", () => {
+      // The parser correctly rejects this at parse time
+      expect(() => {
+        compile("SELECT * FROM task_runs WHERE status = 'completed'; DROP TABLE task_runs; --'");
+      }).toThrow();
+    });
+
+    it("should parameterize malicious-looking string values", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'DROP TABLE users'");
+
+      // The malicious payload should be in params, not in SQL
+      expect(sql).not.toContain("DROP TABLE");
+      expect(Object.values(params)).toContain("DROP TABLE users");
+    });
+
+    it("should handle quote escape attempts", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'test''injection'");
+
+      // Should be safely parameterized
+      expect(Object.values(params).some((v) => typeof v === "string")).toBe(true);
+    });
+
+    it("should handle backslash escape attempts", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'test\\'injection'");
+
+      // Should be safely parameterized
+      expect(sql).not.toContain("injection'");
+    });
+
+    it("should handle unicode characters in strings", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'test™injection'");
+
+      // Should be safely parameterized
+      expect(Object.values(params).some((v) => typeof v === "string")).toBe(true);
+    });
+
+    it("should handle null byte injection", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'test\\0injection'");
+
+      expect(Object.values(params).some((v) => typeof v === "string")).toBe(true);
+    });
+  });
+
+  describe("Comment injection", () => {
+    it("should not allow -- comments to truncate query", () => {
+      // The parser should either reject this or handle it safely
+      const result = compile("SELECT * FROM task_runs WHERE status = 'completed'");
+
+      // Tenant guards must still be present
+      expect(result.sql).toContain("organization_id");
+    });
+
+    it("should not allow /* */ comments for injection", () => {
+      const result = compile("SELECT * FROM task_runs WHERE status = 'completed'");
+
+      // Tenant guards must still be present
+      expect(result.sql).toContain("organization_id");
+    });
+  });
+
+  describe("Identifier injection", () => {
+    it("should reject identifiers with backtick injection", () => {
+      expect(() => {
+        compile("SELECT * FROM task_runs WHERE `status`; DROP TABLE users; --` = 'test'");
+      }).toThrow();
+    });
+
+    it("should not expose column names that could be used for injection", () => {
+      // Column names in the output are validated identifiers from the schema
+      // Malicious column names would need to be in the schema first
+      const { sql } = compile("SELECT id, status FROM task_runs");
+
+      // Column names should be simple identifiers without injection
+      expect(sql).toContain("id");
+      expect(sql).toContain("status");
+      expect(sql).not.toContain(";");
+    });
+
+    it("should reject table names with special characters", () => {
+      expect(() => {
+        compile("SELECT * FROM `task_runs; DROP TABLE users`");
+      }).toThrow();
+    });
+  });
+
+  describe("Numeric injection", () => {
+    it("should handle numeric values safely", () => {
+      const { sql } = compile("SELECT * FROM task_runs WHERE duration_ms > 1000");
+
+      // Numbers should be safely inlined or parameterized
+      expect(sql).toContain("1000");
+      expect(sql).not.toContain(";");
+    });
+
+    it("should handle negative numbers safely", () => {
+      const { sql } = compile("SELECT * FROM task_runs WHERE duration_ms > -1");
+
+      expect(sql).not.toContain(";");
+    });
+
+    it("should handle floating point safely", () => {
+      const { sql } = compile("SELECT * FROM task_runs WHERE duration_ms > 1.5");
+
+      expect(sql).toContain("1.5");
+    });
+  });
+
+  describe("Function injection", () => {
+    it("should only allow known safe functions", () => {
+      // Unknown functions should be rejected
+      expect(() => {
+        compile("SELECT file('/etc/passwd') FROM task_runs");
+      }).toThrow();
+    });
+
+    it("should reject system functions", () => {
+      expect(() => {
+        compile("SELECT system.tables() FROM task_runs");
+      }).toThrow();
+    });
+
+    it("should allow known aggregate functions", () => {
+      const { sql } = compile("SELECT count(*), sum(duration_ms) FROM task_runs");
+
+      expect(sql).toContain("count(*)");
+      expect(sql).toContain("sum(duration_ms)");
+    });
+  });
+
+  describe("Stacked query prevention", () => {
+    it("should not allow semicolon to start new statement", () => {
+      expect(() => {
+        compile("SELECT * FROM task_runs; DELETE FROM task_runs");
+      }).toThrow();
+    });
+
+    it("should not allow multiple statements", () => {
+      expect(() => {
+        compile("SELECT * FROM task_runs; SELECT * FROM task_events");
+      }).toThrow();
+    });
+  });
+
+  describe("UNION-based injection", () => {
+    it("should apply tenant guards to all UNION parts", () => {
+      const { sql, params } = compile(`
+        SELECT id, status FROM task_runs WHERE status = 'a'
+        UNION ALL
+        SELECT id, status FROM task_runs WHERE status = 'b'
+      `);
+
+      // Both parts should have tenant guards
+      expect(Object.values(params)).toContain("org_tenant1");
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+});
+
+describe("Parameter Safety", () => {
+  it("should use typed parameters", () => {
+    const { sql } = compile("SELECT * FROM task_runs WHERE status = 'test'");
+
+    // Parameters should have type annotations like {param: String}
+    expect(sql).toMatch(/\{tsql_\w+: \w+\}/);
+  });
+
+  it("should generate unique parameter names", () => {
+    const { params } = compile(`
+      SELECT * FROM task_runs 
+      WHERE status = 'a' AND task_identifier = 'b' AND payload = 'c'
+    `);
+
+    // All parameter keys should be unique
+    const keys = Object.keys(params);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+
+  it("should not include raw values in SQL for strings", () => {
+    const { sql } = compile("SELECT * FROM task_runs WHERE status = 'user_provided_value'");
+
+    // The literal string should not appear in SQL
+    expect(sql).not.toContain("user_provided_value");
+  });
+});
+
+describe("Optional Tenant Filters", () => {
+  /**
+   * Helper to extract the WHERE clause from SQL for more precise testing.
+   * This is needed because SELECT * expansion includes all columns,
+   * but we only want to check what's in the WHERE clause for tenant filtering.
+   */
+  function getWhereClause(sql: string): string {
+    const whereMatch = sql.match(/WHERE\s+(.*?)(?:\s+(?:ORDER|GROUP|LIMIT|$))/is);
+    return whereMatch ? whereMatch[1] : "";
+  }
+
+  describe("Organization ID is always required", () => {
+    it("should always inject organization guard even with optional project/env", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs", {
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          // project_id and environment_id omitted
+        },
+      });
+
+      const whereClause = getWhereClause(sql);
+
+      // Must contain organization_id in WHERE clause
+      expect(whereClause).toContain("organization_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+
+      // Should NOT contain project_id or environment_id guards in WHERE clause
+      expect(whereClause).not.toContain("project_id");
+      expect(whereClause).not.toContain("environment_id");
+    });
+  });
+
+  describe("Project ID is optional", () => {
+    it("should inject org and project guards when project is provided", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs", {
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          // environment_id omitted
+        },
+      });
+
+      const whereClause = getWhereClause(sql);
+
+      // Must contain organization_id and project_id in WHERE clause
+      expect(whereClause).toContain("organization_id");
+      expect(whereClause).toContain("project_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+      expect(Object.values(params)).toContain("proj_tenant1");
+
+      // Should NOT contain environment_id guard in WHERE clause
+      expect(whereClause).not.toContain("environment_id");
+    });
+
+    it("should allow querying across all projects when projectId is omitted", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs", {
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          // project_id and environment_id omitted
+        },
+      });
+
+      const whereClause = getWhereClause(sql);
+
+      // Only org guard should be present in WHERE clause
+      expect(whereClause).toContain("organization_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+      expect(whereClause).not.toContain("project_id");
+    });
+  });
+
+  describe("Environment ID is optional", () => {
+    it("should inject org, project, and env guards when all provided", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs");
+
+      const whereClause = getWhereClause(sql);
+
+      // All three should be present in WHERE clause (default options include all)
+      expect(whereClause).toContain("organization_id");
+      expect(whereClause).toContain("project_id");
+      expect(whereClause).toContain("environment_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+      expect(Object.values(params)).toContain("proj_tenant1");
+      expect(Object.values(params)).toContain("env_tenant1");
+    });
+
+    it("should allow querying across all environments when environmentId is omitted", () => {
+      const { sql, params } = compile("SELECT * FROM task_runs", {
+        enforcedWhereClause: {
+          organization_id: { op: "eq", value: "org_tenant1" },
+          project_id: { op: "eq", value: "proj_tenant1" },
+          // environment_id omitted
+        },
+      });
+
+      const whereClause = getWhereClause(sql);
+
+      // Org and project guards should be present in WHERE clause
+      expect(whereClause).toContain("organization_id");
+      expect(whereClause).toContain("project_id");
+      expect(Object.values(params)).toContain("org_tenant1");
+      expect(Object.values(params)).toContain("proj_tenant1");
+
+      // Environment guard should NOT be present in WHERE clause
+      expect(whereClause).not.toContain("environment_id");
+    });
+  });
+
+  describe("Cross-tenant security with optional filters", () => {
+    it("should still prevent cross-org access with org-only filter", () => {
+      const { sql, params } = compile(
+        "SELECT * FROM task_runs WHERE organization_id = 'org_other'",
+        {
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_tenant1" },
+            // project_id and environment_id omitted
+          },
+        }
+      );
+
+      // Our org guard should still be enforced
+      expect(Object.values(params)).toContain("org_tenant1");
+    });
+
+    it("should apply org guard to all tables in JOIN when using org-only filter", () => {
+      const { sql } = compile(
+        `
+        SELECT r.id, e.event_type 
+        FROM task_runs r 
+        JOIN task_events e ON r.id = e.run_id
+      `,
+        {
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_tenant1" },
+            // project_id and environment_id omitted
+          },
+        }
+      );
+
+      // Both tables should have org guards
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+
+      // Project and environment should NOT appear
+      expect(sql).not.toContain("project_id");
+      expect(sql).not.toContain("environment_id");
+    });
+
+    it("should apply org guard to UNION queries when using org-only filter", () => {
+      const { sql } = compile(
+        `
+        SELECT id, status FROM task_runs WHERE status = 'completed'
+        UNION ALL
+        SELECT id, status FROM task_runs WHERE status = 'failed'
+      `,
+        {
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_tenant1" },
+            // project_id and environment_id omitted
+          },
+        }
+      );
+
+      // Both parts should have org guards
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should apply org guard to subqueries when using org-only filter", () => {
+      const { sql, params } = compile(
+        `
+        SELECT * FROM task_runs 
+        WHERE id IN (SELECT run_id FROM task_events)
+      `,
+        {
+          enforcedWhereClause: {
+            organization_id: { op: "eq", value: "org_tenant1" },
+            // project_id and environment_id omitted
+          },
+        }
+      );
+
+      // Both main query and subquery should have org guards
+      expect(Object.values(params)).toContain("org_tenant1");
+      const orgIdMatches = sql.match(/organization_id/g) || [];
+      expect(orgIdMatches.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+});
+
+describe("Multi-join Tenant Guard Qualification", () => {
+  /**
+   * Security Test: Verifies that tenant guards are properly table-qualified in multi-join queries.
+   *
+   * The bug: createEnforcedGuard was building unqualified guard expressions like:
+   *   organization_id = 'org_tenant1'
+   *
+   * In a multi-table join where both tables have the same column (organization_id),
+   * an unqualified reference could potentially bind to the wrong table during resolution,
+   * or be ambiguous. The guards should be qualified like:
+   *   r.organization_id = 'org_tenant1' AND e.organization_id = 'org_tenant1'
+   *
+   * This ensures each table's guard binds to the correct table, not just any matching column.
+   */
+  it("should qualify tenant guards with table alias in JOIN queries", () => {
+    const { sql } = compile(`
+      SELECT r.id, e.event_type 
+      FROM task_runs r 
+      JOIN task_events e ON r.id = e.run_id
+    `);
+
+    // The guards should be table-qualified to prevent binding to the wrong table
+    // Look for pattern like: r.organization_id and e.organization_id (with table alias prefix)
+    // The exact format in ClickHouse SQL is just "alias.column" after resolution
+    
+    // Count qualified organization_id references (should have table prefixes)
+    // In the WHERE clause, we should see both r.organization_id and e.organization_id
+    const whereClause = sql.substring(sql.indexOf("WHERE"));
+    
+    // Both tables should have their own qualified tenant guards
+    // The pattern should be: table_alias.organization_id for each table
+    expect(whereClause).toMatch(/\br\b[^,]*organization_id/);
+    expect(whereClause).toMatch(/\be\b[^,]*organization_id/);
+  });
+
+  it("should qualify tenant guards with table alias in LEFT JOIN queries", () => {
+    const { sql } = compile(`
+      SELECT r.id, e.event_type 
+      FROM task_runs r 
+      LEFT JOIN task_events e ON r.id = e.run_id
+    `);
+
+    const whereClause = sql.substring(sql.indexOf("WHERE"));
+    
+    // Both tables should have qualified guards
+    expect(whereClause).toMatch(/\br\b[^,]*organization_id/);
+    expect(whereClause).toMatch(/\be\b[^,]*organization_id/);
+  });
+
+  it("should qualify tenant guards in multi-way JOIN queries", () => {
+    const { sql } = compile(`
+      SELECT r.id, e1.event_type, e2.event_type
+      FROM task_runs r 
+      JOIN task_events e1 ON r.id = e1.run_id
+      JOIN task_events e2 ON r.id = e2.run_id
+    `);
+
+    const whereClause = sql.substring(sql.indexOf("WHERE"));
+    
+    // All three table aliases should have qualified guards
+    expect(whereClause).toMatch(/\br\b[^,]*organization_id/);
+    expect(whereClause).toMatch(/\be1\b[^,]*organization_id/);
+    expect(whereClause).toMatch(/\be2\b[^,]*organization_id/);
+  });
+
+  it("should ensure guards cannot bind to wrong table by verifying separate qualifications", () => {
+    const { sql, params } = compile(`
+      SELECT r.id, e.event_type 
+      FROM task_runs r 
+      JOIN task_events e ON r.id = e.run_id
+      WHERE r.status = 'completed'
+    `);
+
+    // Count organization_id occurrences with different table prefixes
+    // This ensures each table gets its own guard, not shared/ambiguous references
+    const orgIdPattern = /(\w+)\.organization_id/g;
+    const matches = [...sql.matchAll(orgIdPattern)];
+    const tableAliases = matches.map(m => m[1]);
+    
+    // Should have at least 2 different table aliases for organization_id
+    // (one for task_runs alias 'r' and one for task_events alias 'e')
+    expect(tableAliases).toContain("r");
+    expect(tableAliases).toContain("e");
+    
+    // Both should use the same tenant value (parameterized)
+    expect(Object.values(params)).toContain("org_tenant1");
+  });
+});
+
+describe("Edge Cases", () => {
+  it("should handle empty string values", () => {
+    const { params } = compile("SELECT * FROM task_runs WHERE status = ''");
+
+    expect(Object.values(params)).toContain("");
+  });
+
+  it("should handle very long strings", () => {
+    const longString = "a".repeat(10000);
+    const { params } = compile(`SELECT * FROM task_runs WHERE status = '${longString}'`);
+
+    expect(Object.values(params)).toContain(longString);
+  });
+
+  it("should handle strings with newlines", () => {
+    const { params } = compile("SELECT * FROM task_runs WHERE status = 'line1\nline2'");
+
+    // Should handle newlines safely
+    expect(Object.values(params).some((v) => typeof v === "string" && v.includes("\n"))).toBe(true);
+  });
+
+  it("should handle special SQL keywords in strings", () => {
+    const { sql, params } = compile("SELECT * FROM task_runs WHERE status = 'SELECT * FROM users'");
+
+    // The SQL keywords should be in params, not interpreted
+    expect(sql).not.toMatch(/SELECT \* FROM users/);
+    expect(Object.values(params)).toContain("SELECT * FROM users");
+  });
+});
diff --git a/internal-packages/tsql/src/query/time_buckets.test.ts b/internal-packages/tsql/src/query/time_buckets.test.ts
new file mode 100644
index 00000000000..451e74bccc1
--- /dev/null
+++ b/internal-packages/tsql/src/query/time_buckets.test.ts
@@ -0,0 +1,181 @@
+import { describe, it, expect } from "vitest";
+import { calculateTimeBucketInterval, type TimeBucketInterval } from "./time_buckets.js";
+
+/**
+ * Helper to create a Date range from a start date and a duration
+ */
+function makeRange(from: Date, durationMs: number): { from: Date; to: Date } {
+  return { from, to: new Date(from.getTime() + durationMs) };
+}
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+describe("calculateTimeBucketInterval", () => {
+  describe("small ranges (seconds-level buckets)", () => {
+    it("should return 5 SECOND for a 1-minute range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 1 * MINUTE);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 5,
+        unit: "SECOND",
+      });
+    });
+
+    it("should return 5 SECOND for a 4-minute range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 4 * MINUTE);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 5,
+        unit: "SECOND",
+      });
+    });
+
+    it("should return 30 SECOND for a 10-minute range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 10 * MINUTE);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 30,
+        unit: "SECOND",
+      });
+    });
+
+    it("should return 30 SECOND for a 29-minute range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 29 * MINUTE);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 30,
+        unit: "SECOND",
+      });
+    });
+  });
+
+  describe("medium ranges (minute-level buckets)", () => {
+    it("should return 1 MINUTE for a 45-minute range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 45 * MINUTE);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "MINUTE",
+      });
+    });
+
+    it("should return 1 MINUTE for a 1-hour range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 1 * HOUR);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "MINUTE",
+      });
+    });
+
+    it("should return 5 MINUTE for a 3-hour range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 3 * HOUR);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 5,
+        unit: "MINUTE",
+      });
+    });
+
+    it("should return 15 MINUTE for a 12-hour range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 12 * HOUR);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 15,
+        unit: "MINUTE",
+      });
+    });
+  });
+
+  describe("large ranges (hour/day-level buckets)", () => {
+    it("should return 1 HOUR for a 2-day range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 2 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "HOUR",
+      });
+    });
+
+    it("should return 6 HOUR for a 7-day range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 7 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 6,
+        unit: "HOUR",
+      });
+    });
+
+    it("should return 1 DAY for a 30-day range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 30 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "DAY",
+      });
+    });
+
+    it("should return 1 WEEK for a 90-day range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 90 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "WEEK",
+      });
+    });
+  });
+
+  describe("very large ranges (month-level buckets)", () => {
+    it("should return 1 MONTH for a 365-day range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 365 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "MONTH",
+      });
+    });
+
+    it("should return 1 MONTH for a 2-year range", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 730 * DAY);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "MONTH",
+      });
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle zero-length range (from === to)", () => {
+      const date = new Date("2024-01-01T00:00:00Z");
+      const result = calculateTimeBucketInterval(date, date);
+      // Zero range is under 5 minutes, so 5 SECOND
+      expect(result).toEqual<TimeBucketInterval>({ value: 5, unit: "SECOND" });
+    });
+
+    it("should handle reversed dates (to < from) using absolute difference", () => {
+      const from = new Date("2024-01-08T00:00:00Z");
+      const to = new Date("2024-01-01T00:00:00Z");
+      // 7 days reversed → same as 7 days forward
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 6,
+        unit: "HOUR",
+      });
+    });
+
+    it("should handle boundary exactly at 5 minutes", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 5 * MINUTE);
+      // Exactly 5 minutes is NOT under 5 minutes, so should be 30 SECOND
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 30,
+        unit: "SECOND",
+      });
+    });
+
+    it("should handle boundary exactly at 24 hours", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 24 * HOUR);
+      // Exactly 24 hours is NOT under 24 hours, so should be 1 HOUR
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 1,
+        unit: "HOUR",
+      });
+    });
+
+    it("should handle very small range (1 second)", () => {
+      const { from, to } = makeRange(new Date("2024-01-01T00:00:00Z"), 1 * SECOND);
+      expect(calculateTimeBucketInterval(from, to)).toEqual<TimeBucketInterval>({
+        value: 5,
+        unit: "SECOND",
+      });
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/query/time_buckets.ts b/internal-packages/tsql/src/query/time_buckets.ts
new file mode 100644
index 00000000000..04edde007d3
--- /dev/null
+++ b/internal-packages/tsql/src/query/time_buckets.ts
@@ -0,0 +1,100 @@
+/**
+ * Time bucket interval calculation for the `timeBucket()` TSQL function.
+ *
+ * Given a time range, determines the most appropriate bucket interval
+ * to produce a reasonable number of data points (~50-100 buckets).
+ */
+
+/**
+ * A time bucket interval with a numeric value and time unit.
+ * Used to generate ClickHouse `INTERVAL N UNIT` syntax.
+ */
+export interface TimeBucketInterval {
+  /** The numeric value of the interval (e.g., 5 for "5 MINUTE") */
+  value: number;
+  /** The time unit */
+  unit: "SECOND" | "MINUTE" | "HOUR" | "DAY" | "WEEK" | "MONTH";
+}
+
+/**
+ * A threshold mapping a maximum time range duration to a bucket interval.
+ */
+export interface BucketThreshold {
+  /** Maximum range duration in seconds for this threshold to apply */
+  maxRangeSeconds: number;
+  /** The bucket interval to use when the range is under maxRangeSeconds */
+  interval: TimeBucketInterval;
+}
+
+/**
+ * Default time bucket thresholds: each entry defines a maximum time range duration (in seconds)
+ * and the corresponding bucket interval to use.
+ *
+ * The intervals are chosen to produce roughly 50-100 data points for the given range.
+ * Entries are ordered from smallest to largest range.
+ */
+export const BUCKET_THRESHOLDS: BucketThreshold[] = [
+  // Under 5 minutes → 5 second buckets (max 60 buckets)
+  { maxRangeSeconds: 5 * 60, interval: { value: 5, unit: "SECOND" } },
+  // Under 30 minutes → 30 second buckets (max 60 buckets)
+  { maxRangeSeconds: 30 * 60, interval: { value: 30, unit: "SECOND" } },
+  // Under 2 hours → 1 minute buckets (max 120 buckets)
+  { maxRangeSeconds: 2 * 60 * 60, interval: { value: 1, unit: "MINUTE" } },
+  // Under 6 hours → 5 minute buckets (max 72 buckets)
+  { maxRangeSeconds: 6 * 60 * 60, interval: { value: 5, unit: "MINUTE" } },
+  // Under 24 hours → 15 minute buckets (max 96 buckets)
+  { maxRangeSeconds: 24 * 60 * 60, interval: { value: 15, unit: "MINUTE" } },
+  // Under 3 days → 1 hour buckets (max 72 buckets)
+  { maxRangeSeconds: 3 * 24 * 60 * 60, interval: { value: 1, unit: "HOUR" } },
+  // Under 14 days → 6 hour buckets (max 56 buckets)
+  { maxRangeSeconds: 14 * 24 * 60 * 60, interval: { value: 6, unit: "HOUR" } },
+  // Under 60 days → 1 day buckets (max 60 buckets)
+  { maxRangeSeconds: 60 * 24 * 60 * 60, interval: { value: 1, unit: "DAY" } },
+  // Under 365 days → 1 week buckets (max ~52 buckets)
+  { maxRangeSeconds: 365 * 24 * 60 * 60, interval: { value: 1, unit: "WEEK" } },
+];
+
+/** Default interval for very large ranges (365+ days) */
+const DEFAULT_LARGE_INTERVAL: TimeBucketInterval = { value: 1, unit: "MONTH" };
+
+/**
+ * Calculate the most appropriate time bucket interval for a given time range.
+ *
+ * The interval is chosen to produce a reasonable number of data points (~50-100 buckets).
+ * For very small ranges (< 5 minutes), uses 5-second buckets.
+ * For very large ranges (> 365 days), uses 1-month buckets.
+ *
+ * @param from - Start of the time range
+ * @param to - End of the time range
+ * @returns The recommended bucket interval
+ *
+ * @example
+ * ```typescript
+ * // 1 hour range → 1 minute buckets
+ * calculateTimeBucketInterval(
+ *   new Date("2024-01-01T00:00:00Z"),
+ *   new Date("2024-01-01T01:00:00Z"),
+ * ); // { value: 1, unit: "MINUTE" }
+ *
+ * // 7 day range → 6 hour buckets
+ * calculateTimeBucketInterval(
+ *   new Date("2024-01-01"),
+ *   new Date("2024-01-08"),
+ * ); // { value: 6, unit: "HOUR" }
+ * ```
+ */
+export function calculateTimeBucketInterval(
+  from: Date,
+  to: Date,
+  thresholds?: BucketThreshold[]
+): TimeBucketInterval {
+  const rangeSeconds = Math.abs(to.getTime() - from.getTime()) / 1000;
+
+  for (const threshold of thresholds ?? BUCKET_THRESHOLDS) {
+    if (rangeSeconds < threshold.maxRangeSeconds) {
+      return threshold.interval;
+    }
+  }
+
+  return DEFAULT_LARGE_INTERVAL;
+}
diff --git a/internal-packages/tsql/src/query/timings.ts b/internal-packages/tsql/src/query/timings.ts
new file mode 100644
index 00000000000..d868fe06671
--- /dev/null
+++ b/internal-packages/tsql/src/query/timings.ts
@@ -0,0 +1,107 @@
+// TypeScript translation of posthog/hogql/timings.py
+
+/**
+ * Get performance counter in milliseconds (Node.js equivalent of perf_counter)
+ * Uses performance.now() which is available in:
+ * - Node.js 18+ (global)
+ * - Browser (global)
+ * - Node.js <18 via perf_hooks module
+ */
+function getPerformanceNow(): number {
+    // Check for global performance (Node.js 18+ or browser)
+    if (typeof globalThis !== 'undefined' && 'performance' in globalThis) {
+        const perf = (globalThis as any).performance;
+        if (perf && typeof perf.now === 'function') {
+            return perf.now();
+        }
+    }
+    
+    // Fallback to Date.now() if performance API is not available
+    // Note: This is less precise but works everywhere
+    return Date.now();
+}
+
+export interface QueryTiming {
+    key: string; // Key identifying the timing measurement
+    time: number; // Time in seconds
+}
+
+const TIMING_DECIMAL_PLACES = 3; // round to milliseconds
+
+// Not thread safe.
+// See trends_query_runner for an example of how to use for multithreaded queries
+export class TSQLTimings {
+    // Completed time in seconds for different parts of the TSQL query
+    timings: Record<string, number> = {};
+
+    // Used for housekeeping
+    private _timingPointer: string;
+    private _timingStarts: Record<string, number> = {};
+
+    constructor(_timingPointer: string = '.') {
+        this._timingPointer = _timingPointer;
+        this._timingStarts[this._timingPointer] = this.perfCounter();
+    }
+
+    cloneForSubquery(seriesIndex: number): TSQLTimings {
+        return new TSQLTimings(`${this._timingPointer}/series_${seriesIndex}`);
+    }
+
+    clearTimings(): void {
+        this.timings = {};
+    }
+
+    /**
+     * Measure execution time of a function.
+     * Usage: timings.measure('operation', () => { ... });
+     */
+    measure<T>(key: string, fn: () => T): T {
+        const lastKey = this._timingPointer;
+        const fullKey = `${this._timingPointer}/${key}`;
+        this._timingPointer = fullKey;
+        this._timingStarts[fullKey] = this.perfCounter();
+
+        try {
+            return fn();
+        } finally {
+            const duration = (this.perfCounter() - this._timingStarts[fullKey]) / 1000; // Convert to seconds
+            this.timings[fullKey] = (this.timings[fullKey] || 0.0) + duration;
+            delete this._timingStarts[fullKey];
+            this._timingPointer = lastKey;
+        }
+    }
+
+    /**
+     * Get performance counter in milliseconds (Node.js equivalent of perf_counter)
+     */
+    private perfCounter(): number {
+        return getPerformanceNow();
+    }
+
+    toDict(): Record<string, number> {
+        const timings = { ...this.timings };
+        // Process in reverse order to handle nested timings correctly
+        const keys = Object.keys(this._timingStarts).reverse();
+        for (const key of keys) {
+            const start = this._timingStarts[key];
+            const elapsed = (this.perfCounter() - start) / 1000; // Convert to seconds
+            timings[key] = this.round((timings[key] || 0.0) + elapsed);
+        }
+        return timings;
+    }
+
+    toList(backOutStack: boolean = true): QueryTiming[] {
+        const timingDict = backOutStack ? this.toDict() : this.timings;
+        return Object.entries(timingDict).map(([key, time]) => ({
+            key: key,
+            time: this.round(time),
+        }));
+    }
+
+    /**
+     * Round to specified decimal places (milliseconds precision)
+     */
+    private round(value: number): number {
+        return Math.round(value * Math.pow(10, TIMING_DECIMAL_PLACES)) / Math.pow(10, TIMING_DECIMAL_PLACES);
+    }
+}
diff --git a/internal-packages/tsql/src/query/validator.test.ts b/internal-packages/tsql/src/query/validator.test.ts
new file mode 100644
index 00000000000..11e90c70ad1
--- /dev/null
+++ b/internal-packages/tsql/src/query/validator.test.ts
@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import { validateQuery } from "./validator.js";
+import { parseTSQLSelect } from "../index.js";
+import { column, type TableSchema } from "./schema.js";
+
+const runsSchema: TableSchema = {
+  name: "runs",
+  clickhouseName: "trigger_dev.task_runs_v2",
+  columns: {
+    id: { name: "id", ...column("String") },
+    status: {
+      name: "status",
+      ...column("String", {
+        allowedValues: ["PENDING", "COMPLETED", "FAILED"],
+      }),
+    },
+    task_id: { name: "task_id", ...column("String") },
+    created_at: { name: "created_at", ...column("DateTime64") },
+  },
+  tenantColumns: {
+    organizationId: "organization_id",
+    projectId: "project_id",
+    environmentId: "environment_id",
+  },
+};
+
+function validateSQL(query: string, schema: TableSchema[] = [runsSchema]) {
+  const ast = parseTSQLSelect(query);
+  return validateQuery(ast, schema);
+}
+
+describe("validateQuery", () => {
+  describe("SELECT aliases", () => {
+    it("should allow ORDER BY to reference aliased columns", () => {
+      const result = validateSQL(
+        "SELECT status, count(*) as count FROM runs GROUP BY status ORDER BY count DESC"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should allow ORDER BY to reference multiple aliased columns", () => {
+      const result = validateSQL(
+        "SELECT status, count(*) as total, avg(created_at) as avg_time FROM runs GROUP BY status ORDER BY total DESC, avg_time ASC"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should report unknown columns that are not aliases as errors", () => {
+      const result = validateSQL(
+        "SELECT status, count(*) as count FROM runs GROUP BY status ORDER BY unknown_col DESC"
+      );
+      expect(result.valid).toBe(false); // unknown column is now an error
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].type).toBe("unknown_column");
+      expect(result.issues[0].severity).toBe("error");
+      expect(result.issues[0].columnName).toBe("unknown_col");
+    });
+
+    it("should allow ORDER BY to reference both aliases and real columns", () => {
+      const result = validateSQL(
+        "SELECT status, count(*) as count FROM runs GROUP BY status ORDER BY status ASC, count DESC"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should allow HAVING to reference implicit column names from aggregations", () => {
+      const result = validateSQL(
+        "SELECT COUNT(), status FROM runs GROUP BY status HAVING count > 20"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should allow HAVING to reference implicit names from multiple aggregations", () => {
+      const result = validateSQL(
+        "SELECT COUNT(), SUM(created_at), status FROM runs GROUP BY status HAVING count > 10 AND sum > 100"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should allow ORDER BY to reference implicit column names", () => {
+      const result = validateSQL(
+        "SELECT COUNT(), status FROM runs GROUP BY status ORDER BY count DESC"
+      );
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+  });
+
+  describe("column validation", () => {
+    it("should validate known columns", () => {
+      const result = validateSQL("SELECT id, status FROM runs LIMIT 10");
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should error on unknown columns", () => {
+      const result = validateSQL("SELECT id, unknown_column FROM runs LIMIT 10");
+      expect(result.valid).toBe(false); // unknown columns are now errors
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].type).toBe("unknown_column");
+      expect(result.issues[0].severity).toBe("error");
+      expect(result.issues[0].columnName).toBe("unknown_column");
+    });
+  });
+
+  describe("enum validation", () => {
+    it("should validate enum values", () => {
+      const result = validateSQL("SELECT id, status FROM runs WHERE status = 'COMPLETED' LIMIT 10");
+      expect(result.valid).toBe(true);
+      expect(result.issues).toHaveLength(0);
+    });
+
+    it("should error on invalid enum values", () => {
+      const result = validateSQL(
+        "SELECT id, status FROM runs WHERE status = 'INVALID_STATUS' LIMIT 10"
+      );
+      expect(result.valid).toBe(false);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].type).toBe("invalid_enum_value");
+      expect(result.issues[0].invalidValue).toBe("INVALID_STATUS");
+    });
+  });
+});
diff --git a/internal-packages/tsql/src/query/validator.ts b/internal-packages/tsql/src/query/validator.ts
new file mode 100644
index 00000000000..eb8591c8546
--- /dev/null
+++ b/internal-packages/tsql/src/query/validator.ts
@@ -0,0 +1,596 @@
+// Schema validation for TSQL queries
+// Validates column names and enum values against the schema
+
+import type {
+  SelectQuery,
+  SelectSetQuery,
+  Expression,
+  Field,
+  CompareOperation,
+  Constant,
+  And,
+  Or,
+  Not,
+  Alias,
+  OrderExpr,
+  Call,
+  JoinExpr,
+  BetweenExpr,
+  Array as ASTArray,
+  ArithmeticOperation,
+} from "./ast.js";
+import type { TableSchema, ColumnSchema } from "./schema.js";
+import { getAllowedUserValues, getCoreColumns, isValidUserValue } from "./schema.js";
+import { CompareOperationOp, ArithmeticOperationOp } from "./ast.js";
+
+/**
+ * Severity of a validation issue
+ */
+export type ValidationSeverity = "error" | "warning" | "info";
+
+/**
+ * A validation issue found in the query
+ */
+export interface ValidationIssue {
+  /** The error/warning message */
+  message: string;
+  /** Severity of the issue */
+  severity: ValidationSeverity;
+  /** The type of issue */
+  type: "unknown_column" | "unknown_table" | "invalid_enum_value" | "select_star";
+  /** Optional: the column name that caused the issue */
+  columnName?: string;
+  /** Optional: the table name that caused the issue */
+  tableName?: string;
+  /** Optional: the invalid value */
+  invalidValue?: string;
+  /** Optional: list of allowed values */
+  allowedValues?: string[];
+  /** Optional: suggested columns to use instead (for select_star) */
+  suggestedColumns?: string[];
+}
+
+/**
+ * Result of validating a query
+ */
+export interface ValidationResult {
+  /** Whether the query is valid */
+  valid: boolean;
+  /** List of issues found */
+  issues: ValidationIssue[];
+}
+
+/**
+ * Context for tracking tables and columns during validation
+ */
+interface ValidationContext {
+  /** Map of table aliases/names to their schemas */
+  tables: Map<string, TableSchema>;
+  /** The schema array for lookups */
+  schema: TableSchema[];
+  /** Accumulated issues */
+  issues: ValidationIssue[];
+  /** Set of column aliases defined in the SELECT clause */
+  selectAliases: Set<string>;
+}
+
+/**
+ * Validate a parsed TSQL query against a schema
+ *
+ * @param ast - The parsed query AST
+ * @param schema - Array of table schemas to validate against
+ * @returns Validation result with any issues found
+ */
+export function validateQuery(
+  ast: SelectQuery | SelectSetQuery,
+  schema: TableSchema[]
+): ValidationResult {
+  const context: ValidationContext = {
+    tables: new Map(),
+    schema,
+    issues: [],
+    selectAliases: new Set(),
+  };
+
+  if (ast.expression_type === "select_set_query") {
+    validateSelectSetQuery(ast, context);
+  } else {
+    validateSelectQuery(ast, context);
+  }
+
+  return {
+    valid: context.issues.filter((i) => i.severity === "error").length === 0,
+    issues: context.issues,
+  };
+}
+
+/**
+ * Get the implicit column name for an expression without an explicit alias.
+ * This matches the naming used in the printer for result columns.
+ *
+ * @param expr - The SELECT expression
+ * @returns The implicit name, or null if no implicit name applies
+ */
+function getImplicitName(expr: Expression): string | null {
+  // Handle Call (function/aggregation) - use lowercase function name
+  if ((expr as Call).expression_type === "call") {
+    const call = expr as Call;
+    return call.name.toLowerCase();
+  }
+
+  // Handle ArithmeticOperation - use operator function name
+  if ((expr as ArithmeticOperation).expression_type === "arithmetic_operation") {
+    const arith = expr as ArithmeticOperation;
+    switch (arith.op) {
+      case ArithmeticOperationOp.Add:
+        return "plus";
+      case ArithmeticOperationOp.Sub:
+        return "minus";
+      case ArithmeticOperationOp.Mult:
+        return "multiply";
+      case ArithmeticOperationOp.Div:
+        return "divide";
+      case ArithmeticOperationOp.Mod:
+        return "modulo";
+      default:
+        return "expression";
+    }
+  }
+
+  // Handle Constant - use string representation
+  if ((expr as Constant).expression_type === "constant") {
+    const constant = expr as Constant;
+    if (constant.value === null) {
+      return "NULL";
+    }
+    if (typeof constant.value === "string") {
+      return `'${constant.value}'`;
+    }
+    return String(constant.value);
+  }
+
+  // Field expressions don't get implicit names (they use the column name directly)
+  return null;
+}
+
+/**
+ * Validate a SELECT SET query (UNION, INTERSECT, etc.)
+ */
+function validateSelectSetQuery(node: SelectSetQuery, context: ValidationContext): void {
+  if (node.initial_select_query.expression_type === "select_set_query") {
+    validateSelectSetQuery(node.initial_select_query, context);
+  } else {
+    validateSelectQuery(node.initial_select_query, context);
+  }
+
+  for (const subsequent of node.subsequent_select_queries) {
+    if (subsequent.select_query.expression_type === "select_set_query") {
+      validateSelectSetQuery(subsequent.select_query as SelectSetQuery, context);
+    } else {
+      validateSelectQuery(subsequent.select_query as SelectQuery, context);
+    }
+  }
+}
+
+/**
+ * Check if an expression is a SELECT * (asterisk)
+ */
+function isSelectStar(expr: Expression): boolean {
+  if ((expr as Field).expression_type !== "field") return false;
+  const field = expr as Field;
+  // SELECT * or SELECT table.*
+  return (
+    (field.chain.length === 1 && field.chain[0] === "*") ||
+    (field.chain.length === 2 && field.chain[1] === "*")
+  );
+}
+
+/**
+ * Validate a SELECT query
+ */
+function validateSelectQuery(node: SelectQuery, context: ValidationContext): void {
+  // Save parent aliases and create fresh set for this query
+  const parentAliases = context.selectAliases;
+  context.selectAliases = new Set();
+
+  // First, extract tables from FROM clause to build context
+  if (node.select_from) {
+    extractTablesFromJoin(node.select_from, context);
+  }
+
+  // Check for SELECT * and emit warning
+  if (node.select) {
+    const hasSelectStar = node.select.some(isSelectStar);
+    if (hasSelectStar) {
+      // Collect core columns from all tables in context
+      const coreColumns: string[] = [];
+      for (const tableSchema of context.tables.values()) {
+        const tableCoreColumns = getCoreColumns(tableSchema);
+        coreColumns.push(...tableCoreColumns);
+      }
+
+      // Build info message about SELECT * behavior
+      let suggestionMsg = "SELECT * doesn't return all columns.";
+      if (coreColumns.length > 0) {
+        suggestionMsg += `It will return: ${coreColumns.join(", ")}. `;
+      }
+      suggestionMsg += "Specify columns explicitly to include other columns.";
+
+      context.issues.push({
+        message: suggestionMsg,
+        severity: "info",
+        type: "select_star",
+        suggestedColumns: coreColumns.length > 0 ? coreColumns : undefined,
+      });
+    }
+  }
+
+  // Extract column aliases from SELECT clause before validation
+  // This allows ORDER BY and HAVING to reference aliased columns
+  if (node.select) {
+    for (const expr of node.select) {
+      if ((expr as Alias).expression_type === "alias") {
+        // Explicit alias: SELECT ... AS name (stored lowercase for case-insensitive lookup)
+        context.selectAliases.add((expr as Alias).alias.toLowerCase());
+      } else {
+        // Check for implicit aliases from expressions without AS
+        const implicitName = getImplicitName(expr);
+        if (implicitName) {
+          context.selectAliases.add(implicitName);
+        }
+      }
+    }
+  }
+
+  // Validate SELECT columns
+  if (node.select) {
+    for (const expr of node.select) {
+      validateExpression(expr, context);
+    }
+  }
+
+  // Validate WHERE clause
+  if (node.where) {
+    validateExpression(node.where, context);
+  }
+
+  // Validate GROUP BY
+  if (node.group_by) {
+    for (const expr of node.group_by) {
+      validateExpression(expr, context);
+    }
+  }
+
+  // Validate HAVING
+  if (node.having) {
+    validateExpression(node.having, context);
+  }
+
+  // Validate ORDER BY
+  if (node.order_by) {
+    for (const expr of node.order_by) {
+      validateExpression(expr, context);
+    }
+  }
+
+  // Restore parent aliases
+  context.selectAliases = parentAliases;
+}
+
+/**
+ * Extract table schemas from JOIN expressions
+ */
+function extractTablesFromJoin(node: JoinExpr, context: ValidationContext): void {
+  if (node.table) {
+    const tableExpr = node.table;
+
+    if ((tableExpr as Field).expression_type === "field") {
+      const field = tableExpr as Field;
+      const tableName = field.chain[0];
+
+      if (typeof tableName === "string") {
+        // Find the table schema
+        const tableSchema = context.schema.find(
+          (t) => t.name.toLowerCase() === tableName.toLowerCase()
+        );
+
+        if (tableSchema) {
+          // Register with alias if provided, otherwise use table name
+          const key = node.alias || tableName;
+          context.tables.set(key.toLowerCase(), tableSchema);
+        } else {
+          // Unknown table
+          context.issues.push({
+            message: `Unknown table "${tableName}". Available tables: ${
+              context.schema.map((t) => t.name).join(", ") || "(none)"
+            }`,
+            severity: "warning",
+            type: "unknown_table",
+            tableName,
+          });
+        }
+      }
+    } else if (
+      (tableExpr as SelectQuery).expression_type === "select_query" ||
+      (tableExpr as SelectSetQuery).expression_type === "select_set_query"
+    ) {
+      // Subquery - validate it recursively
+      if ((tableExpr as SelectSetQuery).expression_type === "select_set_query") {
+        validateSelectSetQuery(tableExpr as SelectSetQuery, context);
+      } else {
+        validateSelectQuery(tableExpr as SelectQuery, context);
+      }
+    }
+  }
+
+  // Process next join in chain
+  if (node.next_join) {
+    extractTablesFromJoin(node.next_join, context);
+  }
+}
+
+/**
+ * Validate an expression and its children
+ */
+function validateExpression(expr: Expression, context: ValidationContext): void {
+  if (!expr || typeof expr !== "object") return;
+
+  const exprType = expr.expression_type;
+
+  switch (exprType) {
+    case "field":
+      validateField(expr as Field, context);
+      break;
+
+    case "compare_operation":
+      validateCompareOperation(expr as CompareOperation, context);
+      break;
+
+    case "and":
+      for (const e of (expr as And).exprs) {
+        validateExpression(e, context);
+      }
+      break;
+
+    case "or":
+      for (const e of (expr as Or).exprs) {
+        validateExpression(e, context);
+      }
+      break;
+
+    case "not":
+      validateExpression((expr as Not).expr, context);
+      break;
+
+    case "alias":
+      validateExpression((expr as Alias).expr, context);
+      break;
+
+    case "order_expr":
+      validateExpression((expr as OrderExpr).expr, context);
+      break;
+
+    case "call":
+      for (const arg of (expr as Call).args) {
+        validateExpression(arg, context);
+      }
+      break;
+
+    case "between_expr":
+      validateExpression((expr as BetweenExpr).expr, context);
+      validateExpression((expr as BetweenExpr).low, context);
+      validateExpression((expr as BetweenExpr).high, context);
+      break;
+
+    case "array":
+      for (const e of (expr as ASTArray).exprs) {
+        validateExpression(e, context);
+      }
+      break;
+
+    // Other expression types that we don't need to deeply validate
+    case "constant":
+    case "select_query":
+    case "select_set_query":
+      // Skip - constants don't need validation, subqueries are handled separately
+      break;
+  }
+}
+
+/**
+ * Validate a field reference
+ */
+function validateField(field: Field, context: ValidationContext): void {
+  const chain = field.chain;
+  if (chain.length === 0) return;
+
+  // Handle asterisk
+  if (chain[0] === "*") return;
+  if (chain.length === 2 && chain[1] === "*") return;
+
+  const firstPart = chain[0];
+  if (typeof firstPart !== "string") return;
+
+  // Case 1: Qualified reference like table.column
+  if (chain.length >= 2) {
+    const tableAlias = firstPart.toLowerCase();
+    const columnName = chain[1];
+
+    if (typeof columnName !== "string") return;
+
+    const tableSchema = context.tables.get(tableAlias);
+    if (tableSchema) {
+      // Check if column exists
+      if (!tableSchema.columns[columnName]) {
+        const availableColumns = Object.keys(tableSchema.columns).join(", ");
+        context.issues.push({
+          message: `Unknown column "${columnName}" on table "${tableAlias}". Available columns: ${availableColumns}`,
+          severity: "error",
+          type: "unknown_column",
+          columnName,
+          tableName: tableAlias,
+        });
+      }
+    }
+    return;
+  }
+
+  // Case 2: Unqualified reference - try to find in any table or SELECT alias
+  const columnName = firstPart;
+
+  // Check if it's a SELECT alias (e.g., from "count(*) as count")
+  // Case-insensitive: aliases are stored lowercase
+  if (context.selectAliases.has(columnName.toLowerCase())) {
+    return;
+  }
+
+  let found = false;
+
+  for (const tableSchema of context.tables.values()) {
+    if (tableSchema.columns[columnName]) {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found && context.tables.size > 0) {
+    // Only report if we have tables to check against
+    const allColumns = new Set<string>();
+    for (const tableSchema of context.tables.values()) {
+      for (const col of Object.keys(tableSchema.columns)) {
+        allColumns.add(col);
+      }
+    }
+    context.issues.push({
+      message: `Unknown column "${columnName}". Available columns: ${Array.from(allColumns).join(
+        ", "
+      )}`,
+      severity: "error",
+      type: "unknown_column",
+      columnName,
+    });
+  }
+}
+
+/**
+ * Validate a comparison operation, including enum value checks
+ */
+function validateCompareOperation(op: CompareOperation, context: ValidationContext): void {
+  // Validate both sides recursively
+  validateExpression(op.left, context);
+  validateExpression(op.right, context);
+
+  // Check for enum value validation
+  // We look for patterns like: column = 'value' or column IN ('value1', 'value2')
+  const columnInfo = extractColumnFromExpression(op.left, context);
+  if (!columnInfo) return;
+
+  const { columnSchema, columnName, tableName } = columnInfo;
+
+  // Only validate if the column has allowedValues or valueMap
+  const allowedValues = getAllowedUserValues(columnSchema);
+  if (allowedValues.length === 0) return;
+
+  // Check the comparison type
+  switch (op.op) {
+    case CompareOperationOp.Eq:
+    case CompareOperationOp.NotEq:
+      // Single value comparison
+      validateEnumValue(op.right, columnSchema, columnName, tableName, context);
+      break;
+
+    case CompareOperationOp.In:
+    case CompareOperationOp.NotIn:
+    case CompareOperationOp.GlobalIn:
+    case CompareOperationOp.GlobalNotIn:
+      // Array of values
+      if ((op.right as ASTArray).expression_type === "array") {
+        for (const elem of (op.right as ASTArray).exprs) {
+          validateEnumValue(elem, columnSchema, columnName, tableName, context);
+        }
+      }
+      break;
+  }
+}
+
+/**
+ * Extract column information from an expression if it's a simple column reference
+ */
+function extractColumnFromExpression(
+  expr: Expression,
+  context: ValidationContext
+): { columnSchema: ColumnSchema; columnName: string; tableName?: string } | null {
+  if ((expr as Field).expression_type !== "field") return null;
+
+  const field = expr as Field;
+  const chain = field.chain;
+
+  if (chain.length === 0) return null;
+
+  const firstPart = chain[0];
+  if (typeof firstPart !== "string") return null;
+
+  // Qualified reference: table.column
+  if (chain.length >= 2) {
+    const tableAlias = firstPart.toLowerCase();
+    const columnName = chain[1];
+
+    if (typeof columnName !== "string") return null;
+
+    const tableSchema = context.tables.get(tableAlias);
+    if (!tableSchema) return null;
+
+    const columnSchema = tableSchema.columns[columnName];
+    if (!columnSchema) return null;
+
+    return { columnSchema, columnName, tableName: tableAlias };
+  }
+
+  // Unqualified reference
+  const columnName = firstPart;
+  for (const [tableName, tableSchema] of context.tables.entries()) {
+    const columnSchema = tableSchema.columns[columnName];
+    if (columnSchema) {
+      return { columnSchema, columnName, tableName };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Validate that a value matches the allowed enum values for a column
+ * Supports both allowedValues and valueMap, with case-insensitive matching
+ */
+function validateEnumValue(
+  expr: Expression,
+  columnSchema: ColumnSchema,
+  columnName: string,
+  tableName: string | undefined,
+  context: ValidationContext
+): void {
+  if ((expr as Constant).expression_type !== "constant") return;
+
+  const constant = expr as Constant;
+  if (typeof constant.value !== "string") return;
+
+  const value = constant.value;
+
+  // Use isValidUserValue for case-insensitive validation against user-friendly values
+  if (!isValidUserValue(columnSchema, value)) {
+    const columnRef = tableName ? `${tableName}.${columnName}` : columnName;
+    // Show user-friendly values in the error message
+    const allowedValues = getAllowedUserValues(columnSchema);
+    context.issues.push({
+      message: `Invalid value "${value}" for column "${columnRef}". Allowed values: ${allowedValues.join(
+        ", "
+      )}`,
+      severity: "error",
+      type: "invalid_enum_value",
+      columnName,
+      tableName,
+      invalidValue: value,
+      allowedValues,
+    });
+  }
+}
diff --git a/internal-packages/tsql/tsconfig.json b/internal-packages/tsql/tsconfig.json
new file mode 100644
index 00000000000..98c833a1892
--- /dev/null
+++ b/internal-packages/tsql/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "lib": ["ES2019", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": false,
+    "types": ["vitest/globals"],
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "strict": true,
+    "paths": {
+      "@trigger.dev/core": ["../../packages/core/src/index"],
+      "@trigger.dev/core/*": ["../../packages/core/src/*"],
+      "@internal/clickhouse": ["../clickhouse/src/index"],
+      "@internal/clickhouse/*": ["../clickhouse/src/*"]
+    }
+  },
+  "exclude": ["node_modules"]
+}
diff --git a/internal-packages/tsql/vitest.config.ts b/internal-packages/tsql/vitest.config.ts
new file mode 100644
index 00000000000..1d779c09577
--- /dev/null
+++ b/internal-packages/tsql/vitest.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["**/*.test.ts"],
+    globals: true,
+    isolate: true,
+    fileParallelism: false,
+    poolOptions: {
+      threads: {
+        singleThread: true,
+      },
+    },
+    testTimeout: 60_000,
+    coverage: {
+      provider: "v8",
+    },
+  },
+});
diff --git a/package.json b/package.json
index 9ca9bfb6711..6777bef721b 100644
--- a/package.json
+++ b/package.json
@@ -70,6 +70,7 @@
   "dependencies": {
     "@changesets/cli": "2.26.2",
     "@remix-run/changelog-github": "^0.0.5",
+    "agentcrumbs": "^0.5.0",
     "node-fetch": "2.6.x"
   },
   "pnpm": {
@@ -79,9 +80,14 @@
       "graphile-worker@0.16.6": "patches/graphile-worker@0.16.6.patch",
       "redlock@5.0.0-beta.2": "patches/redlock@5.0.0-beta.2.patch",
       "@kubernetes/client-node@1.0.0": "patches/@kubernetes__client-node@1.0.0.patch",
-      "@sentry/remix@9.46.0": "patches/@sentry__remix@9.46.0.patch"
+      "@sentry/remix@9.46.0": "patches/@sentry__remix@9.46.0.patch",
+      "@upstash/ratelimit@1.1.3": "patches/@upstash__ratelimit.patch",
+      "antlr4ts@0.5.0-alpha.4": "patches/antlr4ts@0.5.0-alpha.4.patch",
+      "@window-splitter/state@0.4.1": "patches/@window-splitter__state@0.4.1.patch"
     },
     "overrides": {
+      "typescript": "5.5.4",
+      "@types/node": "20.14.14",
       "express@^4>body-parser": "1.20.3",
       "@remix-run/dev@2.1.0>tar-fs": "2.1.3",
       "testcontainers@10.28.0>tar-fs": "3.0.9",
@@ -91,7 +97,10 @@
       "axios@1.9.0": ">=1.12.0",
       "js-yaml@>=3.0.0 <3.14.2": "3.14.2",
       "js-yaml@>=4.0.0 <4.1.1": "4.1.1",
-      "jws@<3.2.3": "3.2.3"
+      "jws@<3.2.3": "3.2.3",
+      "qs@>=6.0.0 <6.14.1": "6.14.1",
+      "systeminformation@>=5.0.0 <5.27.14": "5.27.14",
+      "lodash@>=4.0.0 <4.17.23": "4.17.23"
     },
     "onlyBuiltDependencies": [
       "@depot/cli",
diff --git a/packages/build/CHANGELOG.md b/packages/build/CHANGELOG.md
index 5ce6b5f6a13..9e99c1f6396 100644
--- a/packages/build/CHANGELOG.md
+++ b/packages/build/CHANGELOG.md
@@ -1,5 +1,55 @@
 # @trigger.dev/build
 
+## 4.4.3
+
+### Patch Changes
+
+- Add syncSupabaseEnvVars to pull database connection strings and save them as trigger.dev environment variables ([#3152](https://github.com/triggerdotdev/trigger.dev/pull/3152))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/build/package.json b/packages/build/package.json
index f764f42801c..cbde207ae9e 100644
--- a/packages/build/package.json
+++ b/packages/build/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/build",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "trigger.dev build extensions",
   "license": "MIT",
   "publishConfig": {
@@ -78,7 +78,7 @@
   },
   "dependencies": {
     "@prisma/config": "^6.10.0",
-    "@trigger.dev/core": "workspace:4.3.0",
+    "@trigger.dev/core": "workspace:4.4.3",
     "mlly": "^1.7.1",
     "pkg-types": "^1.1.3",
     "resolve": "^1.22.8",
diff --git a/packages/build/src/extensions/core.ts b/packages/build/src/extensions/core.ts
index 62671dfd571..d8269fa1d95 100644
--- a/packages/build/src/extensions/core.ts
+++ b/packages/build/src/extensions/core.ts
@@ -5,3 +5,4 @@ export * from "./core/aptGet.js";
 export * from "./core/ffmpeg.js";
 export * from "./core/neonSyncEnvVars.js";
 export * from "./core/vercelSyncEnvVars.js";
+export * from "./core/syncSupabaseEnvVars.js";
diff --git a/packages/build/src/extensions/core/syncSupabaseEnvVars.ts b/packages/build/src/extensions/core/syncSupabaseEnvVars.ts
new file mode 100644
index 00000000000..f373c1e633f
--- /dev/null
+++ b/packages/build/src/extensions/core/syncSupabaseEnvVars.ts
@@ -0,0 +1,285 @@
+import { tryCatch } from "@trigger.dev/core/v3";
+import { BuildExtension } from "@trigger.dev/core/v3/build";
+import { syncEnvVars } from "../core.js";
+
+type EnvVar = { name: string; value: string; isParentEnv?: boolean };
+
+type SupabaseBranch = {
+  id: string;
+  name: string;
+  project_ref: string;
+  parent_project_ref: string;
+  is_default: boolean;
+  git_branch: string;
+  status: string;
+};
+
+type SupabaseBranchDetail = {
+  ref: string;
+  db_host: string;
+  db_port: number;
+  db_user: string;
+  db_pass: string;
+  jwt_secret: string;
+  status: string;
+};
+
+type SupabaseApiKey = {
+  name: string;
+  api_key: string;
+};
+
+// List of Supabase related environment variables to sync
+export const SUPABASE_ENV_VARS = [
+  "DATABASE_URL",
+  "POSTGRES_URL",
+  "SUPABASE_DB_URL",
+  "PGHOST",
+  "PGPORT",
+  "PGUSER",
+  "PGPASSWORD",
+  "PGDATABASE",
+  "SUPABASE_URL",
+  "SUPABASE_ANON_KEY",
+  "SUPABASE_SERVICE_ROLE_KEY",
+  "SUPABASE_JWT_SECRET",
+];
+
+function buildSupabaseEnvVarMappings(options: {
+  user: string;
+  password: string;
+  host: string;
+  port: number;
+  database: string;
+  ref: string;
+  jwtSecret: string;
+  anonKey?: string;
+  serviceRoleKey?: string;
+}): Record<string, string> {
+  const { user, password, host, port, database, ref, jwtSecret, anonKey, serviceRoleKey } = options;
+
+  const connectionString = `postgresql://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}/${database}?sslmode=require`;
+
+  const mappings: Record<string, string> = {
+    DATABASE_URL: connectionString,
+    POSTGRES_URL: connectionString,
+    SUPABASE_DB_URL: connectionString,
+    PGHOST: host,
+    PGPORT: String(port),
+    PGUSER: user,
+    PGPASSWORD: password,
+    PGDATABASE: database,
+    SUPABASE_URL: `https://${ref}.supabase.co`,
+    SUPABASE_JWT_SECRET: jwtSecret,
+  };
+
+  if (anonKey) {
+    mappings.SUPABASE_ANON_KEY = anonKey;
+  }
+
+  if (serviceRoleKey) {
+    mappings.SUPABASE_SERVICE_ROLE_KEY = serviceRoleKey;
+  }
+
+  return mappings;
+}
+
+export function syncSupabaseEnvVars(options?: {
+  projectId?: string;
+  /**
+   * Supabase Management API access token for authentication.
+   * It's recommended to use the SUPABASE_ACCESS_TOKEN environment variable instead of hardcoding this value.
+   */
+  supabaseAccessToken?: string;
+  branch?: string;
+  envVarPrefix?: string;
+}): BuildExtension {
+  const sync = syncEnvVars(async (ctx) => {
+    // Skip for development environments
+    if (ctx.environment === "dev") {
+      return [];
+    }
+
+    const projectId =
+      options?.projectId ?? process.env.SUPABASE_PROJECT_ID ?? ctx.env.SUPABASE_PROJECT_ID;
+    const supabaseAccessToken =
+      options?.supabaseAccessToken ??
+      process.env.SUPABASE_ACCESS_TOKEN ??
+      ctx.env.SUPABASE_ACCESS_TOKEN;
+    const branch = options?.branch ?? ctx.branch;
+    const envVarPrefix = options?.envVarPrefix ?? "";
+    const outputEnvVars = SUPABASE_ENV_VARS;
+
+    // Skip the whole process for Vercel environments
+    if (ctx.env.VERCEL) {
+      return [];
+    }
+
+    if (!projectId) {
+      throw new Error(
+        "syncSupabaseEnvVars: you did not pass in a projectId or set the SUPABASE_PROJECT_ID env var."
+      );
+    }
+
+    if (!supabaseAccessToken) {
+      throw new Error(
+        "syncSupabaseEnvVars: you did not pass in a supabaseAccessToken or set the SUPABASE_ACCESS_TOKEN env var."
+      );
+    }
+
+    const headers = {
+      Authorization: `Bearer ${supabaseAccessToken}`,
+    };
+
+    // Step 1: List branches
+    const branchesUrl = `https://api.supabase.com/v1/projects/${projectId}/branches`;
+    const [branchesFetchError, branchesResponse] = await tryCatch(
+      fetch(branchesUrl, { headers })
+    );
+
+    if (branchesFetchError) {
+      throw new Error(
+        `syncSupabaseEnvVars: network error fetching branches from ${branchesUrl}: ${branchesFetchError.message}`
+      );
+    }
+
+    if (!branchesResponse.ok) {
+      throw new Error(
+        `syncSupabaseEnvVars: failed to list branches from ${branchesUrl} (status ${branchesResponse.status})`
+      );
+    }
+
+    const [branchesParseError, branches] = await tryCatch(
+      branchesResponse.json() as Promise<SupabaseBranch[]>
+    );
+
+    if (branchesParseError) {
+      throw new Error(
+        `syncSupabaseEnvVars: failed to parse branches response from ${branchesUrl}: ${branchesParseError.message}`
+      );
+    }
+
+    if (branches.length === 0) {
+      return [];
+    }
+
+    // Step 2: Find the target branch based on environment
+    let targetBranch: SupabaseBranch | undefined;
+
+    if (ctx.environment === "prod") {
+      targetBranch = branches.find((b) => b.is_default);
+
+      if (!targetBranch) {
+        throw new Error(
+          "syncSupabaseEnvVars: no default Supabase branch found for the project."
+        );
+      }
+    } else {
+      if (!branch) {
+        throw new Error(
+          "syncSupabaseEnvVars: you did not pass in a branch and no branch was detected from context."
+        );
+      }
+
+      targetBranch = branches.find((b) => b.git_branch === branch || b.name === branch);
+
+      if (!targetBranch) {
+        return [];
+      }
+    }
+
+    // Step 3: Get branch configuration (connection details)
+    const branchDetailUrl = `https://api.supabase.com/v1/branches/${targetBranch.id}`;
+    const [detailFetchError, branchDetailResponse] = await tryCatch(
+      fetch(branchDetailUrl, { headers })
+    );
+
+    if (detailFetchError) {
+      throw new Error(
+        `syncSupabaseEnvVars: network error fetching branch details from ${branchDetailUrl}: ${detailFetchError.message}`
+      );
+    }
+
+    if (!branchDetailResponse.ok) {
+      throw new Error(
+        `syncSupabaseEnvVars: failed to fetch branch details from ${branchDetailUrl} (status ${branchDetailResponse.status})`
+      );
+    }
+
+    const [detailParseError, branchDetail] = await tryCatch(
+      branchDetailResponse.json() as Promise<SupabaseBranchDetail>
+    );
+
+    if (detailParseError) {
+      throw new Error(
+        `syncSupabaseEnvVars: failed to parse branch details response from ${branchDetailUrl}: ${detailParseError.message}`
+      );
+    }
+
+    // Step 4: Get API keys for the branch project
+    const apiKeysUrl = `https://api.supabase.com/v1/projects/${branchDetail.ref}/api-keys`;
+    const [apiKeysFetchError, apiKeysResponse] = await tryCatch(
+      fetch(apiKeysUrl, { headers })
+    );
+
+    let anonKey: string | undefined;
+    let serviceRoleKey: string | undefined;
+
+    if (apiKeysFetchError) {
+      console.warn(
+        `syncSupabaseEnvVars: failed to fetch API keys from ${apiKeysUrl}: ${apiKeysFetchError.message}`
+      );
+    } else if (!apiKeysResponse.ok) {
+      console.warn(
+        `syncSupabaseEnvVars: failed to fetch API keys from ${apiKeysUrl} (status ${apiKeysResponse.status})`
+      );
+    } else {
+      const [apiKeysParseError, apiKeys] = await tryCatch(
+        apiKeysResponse.json() as Promise<SupabaseApiKey[]>
+      );
+
+      if (apiKeysParseError) {
+        console.warn(
+          `syncSupabaseEnvVars: failed to parse API keys response from ${apiKeysUrl}: ${apiKeysParseError.message}`
+        );
+      } else {
+        anonKey = apiKeys.find((k) => k.name === "anon")?.api_key;
+        serviceRoleKey = apiKeys.find((k) => k.name === "service_role")?.api_key;
+      }
+    }
+
+    // Step 5: Build environment variable mappings
+    const envVarMappings = buildSupabaseEnvVarMappings({
+      user: branchDetail.db_user,
+      password: branchDetail.db_pass,
+      host: branchDetail.db_host,
+      port: branchDetail.db_port,
+      database: "postgres",
+      ref: branchDetail.ref,
+      jwtSecret: branchDetail.jwt_secret,
+      anonKey,
+      serviceRoleKey,
+    });
+
+    const newEnvVars: EnvVar[] = [];
+
+    for (const supabaseEnvVar of outputEnvVars) {
+      const prefixedKey = `${envVarPrefix}${supabaseEnvVar}`;
+      if (envVarMappings[supabaseEnvVar]) {
+        newEnvVars.push({
+          name: prefixedKey,
+          value: envVarMappings[supabaseEnvVar],
+        });
+      }
+    }
+
+    return newEnvVars;
+  });
+
+  return {
+    name: "SyncSupabaseEnvVarsExtension",
+    async onBuildComplete(context, manifest) {
+      await sync.onBuildComplete?.(context, manifest);
+    },
+  };
+}
diff --git a/packages/cli-v3/CHANGELOG.md b/packages/cli-v3/CHANGELOG.md
index 0f5f8a0990d..709c2091885 100644
--- a/packages/cli-v3/CHANGELOG.md
+++ b/packages/cli-v3/CHANGELOG.md
@@ -1,5 +1,74 @@
 # trigger.dev
 
+## 4.4.3
+
+### Patch Changes
+
+- Auto-cancel in-flight dev runs when the CLI exits, using a detached watchdog process that survives pnpm SIGKILL ([#3191](https://github.com/triggerdotdev/trigger.dev/pull/3191))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+  - `@trigger.dev/build@4.4.3`
+  - `@trigger.dev/schema-to-json@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/build@4.4.2`
+  - `@trigger.dev/core@4.4.2`
+  - `@trigger.dev/schema-to-json@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Add OTEL metrics pipeline for task workers. Workers collect process CPU/memory, Node.js runtime metrics (event loop utilization, event loop delay, heap usage), and user-defined custom metrics via `otel.metrics.getMeter()`. Metrics are exported to ClickHouse with 10-second aggregation buckets and 1m/5m rollups, and are queryable through the dashboard query engine with typed attribute columns, `prettyFormat()` for human-readable values, and AI query support. ([#3061](https://github.com/triggerdotdev/trigger.dev/pull/3061))
+- Updated dependencies:
+  - `@trigger.dev/build@4.4.1`
+  - `@trigger.dev/core@4.4.1`
+  - `@trigger.dev/schema-to-json@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Fix runner getting stuck indefinitely when `execute()` is called on a dead child process. ([#2978](https://github.com/triggerdotdev/trigger.dev/pull/2978))
+- Add optional `timeoutInSeconds` parameter to the `wait_for_run_to_complete` MCP tool. Defaults to 60 seconds. If the run doesn't complete within the timeout, the current state of the run is returned instead of waiting indefinitely. ([#3035](https://github.com/triggerdotdev/trigger.dev/pull/3035))
+- Fixed a minor issue in the deployment command on distinguishing between local builds for the cloud vs local builds for self-hosting setups. ([#3070](https://github.com/triggerdotdev/trigger.dev/pull/3070))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+  - `@trigger.dev/build@4.4.0`
+  - `@trigger.dev/schema-to-json@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+  - `@trigger.dev/build@4.3.3`
+  - `@trigger.dev/schema-to-json@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- fix(cli): update command should preserve existing package.json order ([#2810](https://github.com/triggerdotdev/trigger.dev/pull/2810))
+- Updated dependencies:
+  - `@trigger.dev/build@4.3.2`
+  - `@trigger.dev/core@4.3.2`
+  - `@trigger.dev/schema-to-json@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+  - `@trigger.dev/build@4.3.1`
+  - `@trigger.dev/schema-to-json@4.3.1`
+
 ## 4.3.0
 
 ### Minor Changes
diff --git a/packages/cli-v3/CLAUDE.md b/packages/cli-v3/CLAUDE.md
new file mode 100644
index 00000000000..bb81cd24498
--- /dev/null
+++ b/packages/cli-v3/CLAUDE.md
@@ -0,0 +1,38 @@
+# CLI Package
+
+The `trigger.dev` CLI package, published as `trigger.dev` on npm. Executable: `trigger`.
+
+## Dev vs Deploy
+
+### Dev Mode (`src/dev/`)
+Runs tasks locally in the user's Node.js process. No containers involved. Uses `src/dev/` for the dev command, connects to the local webapp for coordination.
+
+### Deploy Mode (`src/deploy/`)
+Bundles task code and builds Docker images for production:
+1. **Bundle**: `src/build/` bundles worker code using the build system
+2. **Archive**: `src/deploy/archiveContext.ts` packages files for deployment
+3. **Build image**: `src/deploy/buildImage.ts` creates Docker images (local Docker/Depot or remote builds)
+4. **Push**: Pushes image to registry, registers with webapp API
+
+## Customer Task Images
+
+Code in `src/entryPoints/` runs **inside customer containers** - this is a different runtime environment from the CLI itself. Changes here affect deployed task execution directly.
+
+The build system (`src/build/`) uses the config from `trigger.config.ts` in user projects to determine what to bundle, which build extensions to apply, and how to structure the output.
+
+## Commands
+
+CLI command definitions live in `src/commands/`. Key commands:
+- `dev.ts` - Local development mode
+- `deploy.ts` - Production deployment
+- `init.ts` - Project initialization
+- `login.ts` - Authentication
+- `promote.ts` - Deployment promotion
+
+## MCP Server
+
+`src/mcp/` provides an MCP server for AI-assisted task development.
+
+## SDK Documentation Rules
+
+The `rules/` directory at the repo root contains versioned SDK documentation that gets installed alongside customer projects. Update both `rules/` and `.claude/skills/trigger-dev-tasks/` when SDK features change.
diff --git a/packages/cli-v3/package.json b/packages/cli-v3/package.json
index 1dfc9aaf76a..2f466bc5c02 100644
--- a/packages/cli-v3/package.json
+++ b/packages/cli-v3/package.json
@@ -1,6 +1,6 @@
 {
   "name": "trigger.dev",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "A Command-Line Interface for Trigger.dev projects",
   "type": "module",
   "license": "MIT",
@@ -78,12 +78,14 @@
     "test:e2e": "vitest --run -c ./e2e/vitest.config.ts",
     "update-version": "tsx ../../scripts/updateVersion.ts",
     "install-mcp": "./install-mcp.sh",
-    "inspector": "npx @modelcontextprotocol/inspector dist/esm/index.js mcp --log-file .mcp.log --api-url http://localhost:3030"
+    "inspector": "npx @modelcontextprotocol/inspector dist/esm/index.js mcp --log-file .mcp.log --api-url http://localhost:3030",
+    "mcp:test": "tsx src/mcp/tools.test.ts",
+    "mcp:smoke": "tsx src/mcp/smoke.test.ts"
   },
   "dependencies": {
     "@clack/prompts": "0.11.0",
     "@depot/cli": "0.0.1-cli.2.80.0",
-    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
@@ -92,10 +94,10 @@
     "@opentelemetry/resources": "2.0.1",
     "@opentelemetry/sdk-trace-node": "2.0.1",
     "@opentelemetry/semantic-conventions": "1.36.0",
-    "@s2-dev/streamstore": "^0.17.6",
-    "@trigger.dev/build": "workspace:4.3.0",
-    "@trigger.dev/core": "workspace:4.3.0",
-    "@trigger.dev/schema-to-json": "workspace:4.3.0",
+    "@s2-dev/streamstore": "^0.22.5",
+    "@trigger.dev/build": "workspace:4.4.3",
+    "@trigger.dev/core": "workspace:4.4.3",
+    "@trigger.dev/schema-to-json": "workspace:4.4.3",
     "ansi-escapes": "^7.0.0",
     "braces": "^3.0.3",
     "c12": "^1.11.1",
@@ -138,7 +140,7 @@
     "std-env": "^3.7.0",
     "strip-ansi": "^7.1.0",
     "supports-color": "^10.0.0",
-    "tar": "^7.4.3",
+    "tar": "^7.5.4",
     "tiny-invariant": "^1.2.0",
     "tinyexec": "^0.3.1",
     "tinyglobby": "^0.2.10",
diff --git a/packages/cli-v3/src/apiClient.ts b/packages/cli-v3/src/apiClient.ts
index e099260203f..c70d9b11419 100644
--- a/packages/cli-v3/src/apiClient.ts
+++ b/packages/cli-v3/src/apiClient.ts
@@ -7,6 +7,8 @@ import {
   DevConfigResponseBody,
   DevDequeueRequestBody,
   DevDequeueResponseBody,
+  DevDisconnectRequestBody,
+  DevDisconnectResponseBody,
   EnvironmentVariableResponseBody,
   FailDeploymentRequestBody,
   FailDeploymentResponseBody,
@@ -56,18 +58,48 @@ import { z } from "zod";
 import { logger } from "./utilities/logger.js";
 import { VERSION } from "./version.js";
 
+const CliPlatformNotificationResponseSchema = z.object({
+  notification: z
+    .object({
+      id: z.string(),
+      payload: z.object({
+        version: z.string(),
+        data: z.object({
+          type: z.enum(["info", "warn", "error", "success"]),
+          title: z.string(),
+          description: z.string(),
+          actionLabel: z.string().optional(),
+          actionUrl: z.string().optional(),
+          discovery: z
+            .object({
+              filePatterns: z.array(z.string()),
+              contentPattern: z.string().optional(),
+              matchBehavior: z.enum(["show-if-found", "show-if-not-found"]),
+            })
+            .optional(),
+        }),
+      }),
+      showCount: z.number(),
+      firstSeenAt: z.string(),
+    })
+    .nullable(),
+});
+
 export class CliApiClient {
   private engineURL: string;
+  private source: "cli" | "mcp";
 
   constructor(
     public readonly apiURL: string,
     // TODO: consider making this required
     public readonly accessToken?: string,
-    public readonly branch?: string
+    public readonly branch?: string,
+    options?: { source?: "cli" | "mcp" }
   ) {
     this.apiURL = apiURL.replace(/\/$/, "");
     this.engineURL = this.apiURL;
     this.branch = branch;
+    this.source = options?.source ?? "cli";
   }
 
   async createAuthorizationCode() {
@@ -535,6 +567,25 @@ export class CliApiClient {
     );
   }
 
+  async getCliPlatformNotification(projectRef?: string, signal?: AbortSignal) {
+    if (!this.accessToken) {
+      return { success: true as const, data: { notification: null } };
+    }
+
+    const url = new URL("/api/v1/platform-notifications", this.apiURL);
+    if (projectRef) {
+      url.searchParams.set("projectRef", projectRef);
+    }
+
+    return wrapZodFetch(CliPlatformNotificationResponseSchema, url.href, {
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+      },
+      signal,
+    });
+  }
+
   async triggerTaskRun(taskId: string, body?: TriggerTaskRequestBody) {
     if (!this.accessToken) {
       throw new Error("triggerTaskRun: No access token");
@@ -557,6 +608,7 @@ export class CliApiClient {
       heartbeatRun: this.devHeartbeatRun.bind(this),
       startRunAttempt: this.devStartRunAttempt.bind(this),
       completeRunAttempt: this.devCompleteRunAttempt.bind(this),
+      disconnect: this.devDisconnect.bind(this),
       setEngineURL: this.setEngineURL.bind(this),
     } as const;
   }
@@ -681,6 +733,23 @@ export class CliApiClient {
     return eventSource;
   }
 
+  private async devDisconnect(
+    body: DevDisconnectRequestBody
+  ): Promise<ApiResult<DevDisconnectResponseBody>> {
+    if (!this.accessToken) {
+      throw new Error("devDisconnect: No access token");
+    }
+
+    return wrapZodFetch(DevDisconnectResponseBody, `${this.engineURL}/engine/v1/dev/disconnect`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        Accept: "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+  }
+
   private async devDequeue(
     body: DevDequeueRequestBody
   ): Promise<ApiResult<DevDequeueResponseBody>> {
@@ -799,6 +868,7 @@ export class CliApiClient {
     const headers: Record<string, string> = {
       Authorization: `Bearer ${this.accessToken}`,
       "Content-Type": "application/json",
+      "x-trigger-source": this.source,
     };
 
     if (this.branch) {
diff --git a/packages/cli-v3/src/commands/deploy.ts b/packages/cli-v3/src/commands/deploy.ts
index f4de03281c8..1ac161d3e4a 100644
--- a/packages/cli-v3/src/commands/deploy.ts
+++ b/packages/cli-v3/src/commands/deploy.ts
@@ -197,11 +197,18 @@ export function configureDeployCommand(program: Command) {
       )
       // Local build options
       .addOption(
-        new CommandOption("--force-local-build", "Deprecated alias for --local-build").implies({
-          localBuild: true,
-        })
+        new CommandOption("--force-local-build", "Deprecated alias for --local-build")
+          .implies({
+            localBuild: true,
+          })
+          .conflicts("nativeBuildServer")
+          .hideHelp()
+      )
+      .addOption(
+        new CommandOption("--local-build", "Build the deployment image locally").conflicts(
+          "nativeBuildServer"
+        )
       )
-      .addOption(new CommandOption("--local-build", "Build the deployment image locally"))
       .addOption(new CommandOption("--push", "Push the image after local builds").hideHelp())
       .addOption(
         new CommandOption("--no-push", "Do not push the image after local builds").hideHelp()
@@ -420,14 +427,19 @@ async function _deployCommand(dir: string, options: DeployCommandOptions) {
       gitMeta,
       type: features.run_engine_v2 ? "MANAGED" : "V1",
       runtime: buildManifest.runtime,
+      isLocalBuild: options.localBuild,
       isNativeBuild: false,
       triggeredVia: getTriggeredVia(),
     },
     envVars.TRIGGER_EXISTING_DEPLOYMENT_ID
   );
+
+  // When `externalBuildData` is not present the deployment implicitly goes into the local build path
+  // which is used in self-hosted setups. There are a few subtle differences between local builds for the cloud
+  // and local builds for self-hosted setups. We need to make the separation of the two paths clearer to avoid confusion.
   const isLocalBuild = options.localBuild || !deployment.externalBuildData;
-  // Would be best to actually store this separately in the deployment object. This is an okay proxy for now.
-  const remoteBuildExplicitlySkipped = options.localBuild && !!deployment.externalBuildData;
+  const authenticateToTriggerRegistry = options.localBuild;
+  const skipServerSideRegistryPush = options.localBuild;
 
   // Fail fast if we know local builds will fail
   if (isLocalBuild) {
@@ -559,7 +571,7 @@ async function _deployCommand(dir: string, options: DeployCommandOptions) {
     network: options.network,
     builder: options.builder,
     push: options.push,
-    authenticateToRegistry: remoteBuildExplicitlySkipped,
+    authenticateToRegistry: authenticateToTriggerRegistry,
   });
 
   logger.debug("Build result", buildResult);
@@ -657,7 +669,7 @@ async function _deployCommand(dir: string, options: DeployCommandOptions) {
     {
       imageDigest: buildResult.digest,
       skipPromotion: options.skipPromotion,
-      skipPushToRegistry: remoteBuildExplicitlySkipped,
+      skipPushToRegistry: skipServerSideRegistryPush,
     },
     (logMessage) => {
       if (options.plain || isCI) {
@@ -1143,9 +1155,8 @@ async function handleNativeBuildServerDeploy({
   const [readSessionError, readSession] = await tryCatch(
     stream.readSession(
       {
-        seq_num: 0,
-        wait: 60 * 20, // 20 minutes
-        as: "bytes",
+        start: { from: { seqNum: 0 }, clamp: true },
+        stop: { waitSecs: 60 * 20 }, // 20 minutes
       },
       { signal: abortController.signal }
     )
@@ -1164,12 +1175,11 @@ async function handleNativeBuildServerDeploy({
     return process.exit(0);
   }
 
-  const decoder = new TextDecoder();
   let finalDeploymentEvent: DeploymentFinalizedEvent["data"] | undefined;
   let queuedSpinnerStopped = false;
 
   for await (const record of readSession) {
-    const decoded = decoder.decode(record.body);
+    const decoded = record.body;
     const result = DeploymentEventFromString.safeParse(decoded);
     if (!result.success) {
       logger.debug("Failed to parse deployment event, skipping", {
@@ -1183,7 +1193,7 @@ async function handleNativeBuildServerDeploy({
 
     switch (event.type) {
       case "log": {
-        if (record.seq_num === 0) {
+        if (record.seqNum === 0) {
           $queuedSpinner.stop("Build started");
           console.log("│");
           queuedSpinnerStopped = true;
diff --git a/packages/cli-v3/src/commands/dev.ts b/packages/cli-v3/src/commands/dev.ts
index 5557e595817..73e79933dd0 100644
--- a/packages/cli-v3/src/commands/dev.ts
+++ b/packages/cli-v3/src/commands/dev.ts
@@ -1,6 +1,7 @@
 import { ResolvedConfig } from "@trigger.dev/core/v3/build";
 import { Command, Option as CommandOption } from "commander";
 import { z } from "zod";
+import { CliApiClient } from "../apiClient.js";
 import { CommonCommandOptions, commonOptions, wrapCommandAction } from "../cli/common.js";
 import { watchConfig } from "../config.js";
 import { DevSessionInstance, startDevSession } from "../dev/devSession.js";
@@ -9,6 +10,10 @@ import { chalkError } from "../utilities/cliOutput.js";
 import { resolveLocalEnvVars } from "../utilities/localEnvVars.js";
 import { printDevBanner, printStandloneInitialBanner } from "../utilities/initialBanner.js";
 import { logger } from "../utilities/logger.js";
+import {
+  awaitAndDisplayPlatformNotification,
+  fetchPlatformNotification,
+} from "../utilities/platformNotifications.js";
 import { runtimeChecks } from "../utilities/runtimeCheck.js";
 import { getProjectClient, LoginResultOk } from "../utilities/session.js";
 import { login } from "./login.js";
@@ -28,6 +33,7 @@ const DevCommandOptions = CommonCommandOptions.extend({
   config: z.string().optional(),
   projectRef: z.string().optional(),
   skipUpdateCheck: z.boolean().default(false),
+  skipPlatformNotifications: z.boolean().default(false),
   envFile: z.string().optional(),
   keepTmpFiles: z.boolean().default(false),
   maxConcurrentRuns: z.coerce.number().optional(),
@@ -97,6 +103,12 @@ export function configureDevCommand(program: Command) {
         ).hideHelp()
       )
       .addOption(new CommandOption("--disable-warnings", "Suppress warnings output").hideHelp())
+      .addOption(
+        new CommandOption(
+          "--skip-platform-notifications",
+          "Skip showing platform notifications"
+        ).hideHelp()
+      )
   ).action(async (options) => {
     wrapCommandAction("dev", DevCommandOptions, options, async (opts) => {
       await devCommand(opts);
@@ -205,8 +217,17 @@ async function startDev(options: StartDevOptions) {
       logger.loggerLevel = options.logLevel;
     }
 
+    const notificationPromise = options.skipPlatformNotifications
+      ? undefined
+      : fetchPlatformNotification({
+          apiClient: new CliApiClient(options.login.auth.apiUrl, options.login.auth.accessToken),
+          projectRef: options.projectRef,
+        });
+
     await printStandloneInitialBanner(true, options.profile);
 
+    await awaitAndDisplayPlatformNotification(notificationPromise);
+
     let displayedUpdateMessage = false;
 
     if (!options.skipUpdateCheck) {
diff --git a/packages/cli-v3/src/commands/login.ts b/packages/cli-v3/src/commands/login.ts
index f3b46405a73..59af7ee895a 100644
--- a/packages/cli-v3/src/commands/login.ts
+++ b/packages/cli-v3/src/commands/login.ts
@@ -20,6 +20,10 @@ import {
   writeAuthConfigCurrentProfileName,
 } from "../utilities/configFiles.js";
 import { printInitialBanner } from "../utilities/initialBanner.js";
+import {
+  awaitAndDisplayPlatformNotification,
+  fetchPlatformNotification,
+} from "../utilities/platformNotifications.js";
 import { LoginResult } from "../utilities/session.js";
 import { whoAmI } from "./whoami.js";
 import { logger } from "../utilities/logger.js";
@@ -285,6 +289,17 @@ export async function login(options?: LoginOptions): Promise<LoginResult> {
           options?.profile
         );
 
+        // Only fetch notifications for standalone login, not when embedded in dev
+        // (dev.ts handles its own notification fetch to avoid double counting)
+        const notificationPromise = opts.embedded
+          ? undefined
+          : fetchPlatformNotification({
+              apiClient: new CliApiClient(
+                authConfig?.apiUrl ?? opts.defaultApiUrl,
+                indexResult.token
+              ),
+            });
+
         const whoAmIResult = await whoAmI(
           {
             profile: options?.profile ?? "default",
@@ -309,6 +324,8 @@ export async function login(options?: LoginOptions): Promise<LoginResult> {
           outro("Logged in successfully");
         }
 
+        await awaitAndDisplayPlatformNotification(notificationPromise);
+
         span.end();
 
         return {
diff --git a/packages/cli-v3/src/commands/mcp.ts b/packages/cli-v3/src/commands/mcp.ts
index fd992f9059a..f533a8031e5 100644
--- a/packages/cli-v3/src/commands/mcp.ts
+++ b/packages/cli-v3/src/commands/mcp.ts
@@ -20,6 +20,7 @@ const McpCommandOptions = CommonCommandOptions.extend({
   projectRef: z.string().optional(),
   logFile: z.string().optional(),
   devOnly: z.boolean().default(false),
+  readonly: z.boolean().default(false),
   rulesInstallManifestPath: z.string().optional(),
   rulesInstallBranch: z.string().optional(),
 });
@@ -36,6 +37,10 @@ export function configureMcpCommand(program: Command) {
         "--dev-only",
         "Only run the MCP server for the dev environment. Attempts to access other environments will fail."
       )
+      .option(
+        "--readonly",
+        "Run in read-only mode. Write tools (deploy, trigger_task, cancel_run) are hidden from the AI."
+      )
       .option("--log-file <log file>", "The file to log to")
       .addOption(
         new CommandOption(
@@ -97,6 +102,7 @@ export async function mcpCommand(options: McpCommandOptions) {
 
   server.server.oninitialized = async () => {
     fileLogger?.log("initialized mcp command", { options, argv: process.argv });
+    await context.loadProjectProfile();
   };
 
   // Start receiving messages on stdin and sending messages on stdout
@@ -111,6 +117,7 @@ export async function mcpCommand(options: McpCommandOptions) {
     fileLogger,
     apiUrl: options.apiUrl ?? CLOUD_API_URL,
     profile: options.profile,
+    readonly: options.readonly,
   });
 
   registerTools(context);
diff --git a/packages/cli-v3/src/commands/update.ts b/packages/cli-v3/src/commands/update.ts
index f67e9bf7dbd..f94718213f7 100644
--- a/packages/cli-v3/src/commands/update.ts
+++ b/packages/cli-v3/src/commands/update.ts
@@ -1,12 +1,12 @@
 import { confirm, intro, isCancel, log, outro } from "@clack/prompts";
 import { Command } from "commander";
 import { detectPackageManager, installDependencies } from "nypm";
-import { basename, dirname, join, resolve } from "path";
+import { dirname, join, resolve } from "path";
 import { PackageJson, readPackageJSON, type ResolveOptions, resolvePackageJSON } from "pkg-types";
 import { z } from "zod";
 import { CommonCommandOptions, OutroCommandError, wrapCommandAction } from "../cli/common.js";
 import { chalkError, prettyError, prettyWarning } from "../utilities/cliOutput.js";
-import { removeFile, writeJSONFile } from "../utilities/fileSystem.js";
+import { removeFile, writeJSONFilePreserveOrder } from "../utilities/fileSystem.js";
 import { printStandloneInitialBanner, updateCheck } from "../utilities/initialBanner.js";
 import { logger } from "../utilities/logger.js";
 import { spinner } from "../utilities/windows.js";
@@ -227,7 +227,7 @@ export async function updateTriggerPackages(
 
   // Backup package.json
   const packageJsonBackupPath = `${packageJsonPath}.bak`;
-  await writeJSONFile(packageJsonBackupPath, readonlyPackageJson, true);
+  await writeJSONFilePreserveOrder(packageJsonBackupPath, readonlyPackageJson, true);
 
   const exitHandler = async (sig: any) => {
     log.warn(
@@ -241,10 +241,10 @@ export async function updateTriggerPackages(
 
   // Update package.json
   mutatePackageJsonWithUpdatedPackages(packageJson, mismatches, cliVersion);
-  await writeJSONFile(packageJsonPath, packageJson, true);
+  await writeJSONFilePreserveOrder(packageJsonPath, packageJson, true);
 
   async function revertPackageJsonChanges() {
-    await writeJSONFile(packageJsonPath, readonlyPackageJson, true);
+    await writeJSONFilePreserveOrder(packageJsonPath, readonlyPackageJson, true);
     await removeFile(packageJsonBackupPath);
   }
 
diff --git a/packages/cli-v3/src/deploy/buildImage.ts b/packages/cli-v3/src/deploy/buildImage.ts
index 2225d7db056..31a2b658545 100644
--- a/packages/cli-v3/src/deploy/buildImage.ts
+++ b/packages/cli-v3/src/deploy/buildImage.ts
@@ -205,6 +205,7 @@ async function remoteBuildImage(options: DepotBuildImageOptions): Promise<BuildI
     compression: options.compression,
     compressionLevel: options.compressionLevel,
     forceCompression: options.forceCompression,
+    isLocalBuild: false,
   });
 
   const args = [
@@ -538,6 +539,7 @@ async function localBuildImage(options: SelfHostedBuildImageOptions): Promise<Bu
     compression,
     compressionLevel,
     forceCompression,
+    isLocalBuild: true,
   });
 
   const args = [
@@ -1123,6 +1125,7 @@ function getOutputOptions({
   compression,
   compressionLevel,
   forceCompression,
+  isLocalBuild,
 }: {
   imageTag?: string;
   push?: boolean;
@@ -1130,8 +1133,25 @@ function getOutputOptions({
   compression?: "zstd" | "gzip";
   compressionLevel?: number;
   forceCompression?: boolean;
+  isLocalBuild: boolean;
 }): string[] {
-  // Always use OCI media types for compatibility
+  // type=docker exports directly into the local Docker daemon (what --load does).
+  // type=image builds a registry-format image that can be pushed.
+  // They're mutually exclusive: type=docker doesn't support push/compression,
+  // and type=image silently ignores "load=true".
+  // Only use type=docker for local builds to avoid affecting remote builds.
+  // Note: type=docker doesn't support compression options or rewrite-timestamp,
+  // so it will use the actual build time and default compression.
+  if (isLocalBuild && load && !push) {
+    const outputOptions: string[] = ["type=docker"];
+
+    if (imageTag) {
+      outputOptions.push(`name=${imageTag}`);
+    }
+
+    return outputOptions;
+  }
+
   const outputOptions: string[] = ["type=image", "oci-mediatypes=true", "rewrite-timestamp=true"];
 
   if (imageTag) {
@@ -1142,10 +1162,6 @@ function getOutputOptions({
     outputOptions.push("push=true");
   }
 
-  if (load) {
-    outputOptions.push("load=true");
-  }
-
   // Only add compression args when using zstd (gzip is the default, no args needed)
   if (compression === "zstd") {
     outputOptions.push("compression=zstd");
diff --git a/packages/cli-v3/src/dev/devSupervisor.ts b/packages/cli-v3/src/dev/devSupervisor.ts
index 67da7e59458..59b2d2a473b 100644
--- a/packages/cli-v3/src/dev/devSupervisor.ts
+++ b/packages/cli-v3/src/dev/devSupervisor.ts
@@ -1,3 +1,7 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { setTimeout as awaitTimeout } from "node:timers/promises";
 import {
   BuildManifest,
@@ -71,7 +75,12 @@ class DevSupervisor implements WorkerRuntime {
   private runLimiter?: ReturnType<typeof pLimit>;
   private taskRunProcessPool?: TaskRunProcessPool;
 
-  constructor(public readonly options: WorkerRuntimeOptions) {}
+  /** Detached watchdog process that cancels runs if the CLI is killed */
+  private watchdogProcess?: ChildProcess;
+  private activeRunsPath?: string;
+  private watchdogPidPath?: string;
+
+  constructor(public readonly options: WorkerRuntimeOptions) { }
 
   async init(): Promise<void> {
     logger.debug("[DevSupervisor] initialized worker runtime", { options: this.options });
@@ -108,8 +117,8 @@ class DevSupervisor implements WorkerRuntime {
       typeof processKeepAlive === "boolean"
         ? processKeepAlive
         : typeof processKeepAlive === "object"
-        ? processKeepAlive.enabled
-        : false;
+          ? processKeepAlive.enabled
+          : false;
 
     const maxPoolSize =
       typeof processKeepAlive === "object" ? processKeepAlive.devMaxPoolSize ?? 25 : 25;
@@ -138,25 +147,39 @@ class DevSupervisor implements WorkerRuntime {
     //start an SSE connection for presence
     this.disconnectPresence = await this.#startPresenceConnection();
 
-    // Handle SIGTERM to gracefully stop all run controllers
+    // Handle SIGTERM/SIGINT to gracefully stop all run controllers
     process.on("SIGTERM", this.#handleSigterm);
+    process.on("SIGINT", this.#handleSigterm);
+
+    // Spawn detached watchdog to cancel runs if CLI is killed (e.g. pnpm SIGKILL)
+    this.#spawnWatchdog();
 
     //start dequeuing
     await this.#dequeueRuns();
   }
 
   #handleSigterm = async () => {
-    logger.debug("[DevSupervisor] Received SIGTERM, stopping all run controllers");
+    logger.debug("[DevSupervisor] Received SIGTERM/SIGINT, stopping all run controllers");
 
-    const stopPromises = Array.from(this.runControllers.values()).map((controller) =>
-      controller.stop()
-    );
+    await this.shutdown();
 
-    await Promise.allSettled(stopPromises);
+    // Must exit explicitly since registering a custom SIGINT handler
+    // overrides Node's default process termination behavior.
+    process.exit(0);
   };
 
   async shutdown(): Promise<void> {
     process.off("SIGTERM", this.#handleSigterm);
+    process.off("SIGINT", this.#handleSigterm);
+
+    // Stop all local run controllers first so active-runs.json is up-to-date
+    const stopPromises = Array.from(this.runControllers.values()).map((controller) =>
+      controller.stop()
+    );
+    await Promise.allSettled(stopPromises);
+
+    // Kill watchdog on clean shutdown — no disconnect needed since runs are stopped locally
+    this.#killWatchdog();
 
     this.disconnectPresence?.();
     try {
@@ -177,6 +200,108 @@ class DevSupervisor implements WorkerRuntime {
     }
   }
 
+  #spawnWatchdog() {
+    const triggerDir = join(this.options.config.workingDir, ".trigger");
+    if (!existsSync(triggerDir)) {
+      mkdirSync(triggerDir, { recursive: true });
+    }
+
+    this.activeRunsPath = join(triggerDir, "active-runs.json");
+    this.watchdogPidPath = join(triggerDir, "watchdog.pid");
+
+    // Write empty active-runs file
+    this.#updateActiveRunsFile();
+
+    // Resolve the compiled watchdog script path relative to this file
+    const thisDir = fileURLToPath(new URL(".", import.meta.url));
+    const watchdogScript = join(thisDir, "devWatchdog.js");
+
+    if (!existsSync(watchdogScript)) {
+      logger.debug("[DevSupervisor] Watchdog script not found, skipping", { watchdogScript });
+      return;
+    }
+
+    try {
+      this.watchdogProcess = spawn(process.execPath, [watchdogScript], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          WATCHDOG_PARENT_PID: process.pid.toString(),
+          WATCHDOG_API_URL: this.config?.engineUrl ?? this.options.client.apiURL,
+          WATCHDOG_API_KEY: this.options.client.accessToken ?? "",
+          WATCHDOG_ACTIVE_RUNS: this.activeRunsPath,
+          WATCHDOG_PID_FILE: this.watchdogPidPath,
+          WATCHDOG_TMP_DIR: join(triggerDir, "tmp"),
+        },
+      });
+
+      this.watchdogProcess.unref();
+
+      logger.debug("[DevSupervisor] Spawned watchdog", {
+        watchdogPid: this.watchdogProcess.pid,
+        parentPid: process.pid,
+      });
+    } catch (error) {
+      logger.debug("[DevSupervisor] Failed to spawn watchdog", { error });
+    }
+  }
+
+  #killWatchdog() {
+    const knownPid = this.watchdogProcess?.pid;
+
+    if (knownPid) {
+      try {
+        process.kill(knownPid, "SIGTERM");
+      } catch {
+        // Already dead
+      }
+      this.watchdogProcess = undefined;
+    }
+
+    // Fallback: try via PID file, but only if the PID matches our spawned watchdog
+    // to avoid killing an unrelated process that reused a stale PID
+    if (this.watchdogPidPath) {
+      try {
+        const content = readFileSync(this.watchdogPidPath, "utf8");
+        const prefix = "trigger-watchdog:";
+        if (content.startsWith(prefix)) {
+          const pid = parseInt(content.slice(prefix.length), 10);
+          if (pid && (!knownPid || pid === knownPid)) {
+            process.kill(pid, "SIGTERM");
+          }
+        }
+      } catch {
+        // Already dead or no file
+      }
+    }
+
+    // Clean up files
+    try {
+      if (this.activeRunsPath) unlinkSync(this.activeRunsPath);
+    } catch { }
+    try {
+      if (this.watchdogPidPath) unlinkSync(this.watchdogPidPath);
+    } catch { }
+  }
+
+  #updateActiveRunsFile() {
+    if (!this.activeRunsPath) return;
+
+    try {
+      const data = {
+        parentPid: process.pid,
+        runFriendlyIds: Array.from(this.runControllers.keys()),
+      };
+      // Atomic write: write to temp file then rename to avoid corrupt reads
+      const tmpPath = this.activeRunsPath + ".tmp";
+      writeFileSync(tmpPath, JSON.stringify(data));
+      renameSync(tmpPath, this.activeRunsPath);
+    } catch (error) {
+      logger.debug("[DevSupervisor] Failed to update active-runs file", { error });
+    }
+  }
+
   async initializeWorker(
     manifest: BuildManifest,
     metafile: Metafile,
@@ -226,6 +351,7 @@ class DevSupervisor implements WorkerRuntime {
         packageVersion: manifest.packageVersion,
         cliPackageVersion: manifest.cliPackageVersion,
         tasks: backgroundWorker.manifest.tasks,
+        prompts: backgroundWorker.manifest.prompts,
         queues: backgroundWorker.manifest.queues,
         contentHash: manifest.contentHash,
         sourceFiles,
@@ -381,16 +507,20 @@ class DevSupervisor implements WorkerRuntime {
           taskRunProcessPool: this.taskRunProcessPool,
           cwd,
           onFinished: () => {
+
             logger.debug("[DevSupervisor] Run finished", { runId: message.run.friendlyId });
 
             //stop the run controller, and remove it
             runController?.stop();
             this.runControllers.delete(message.run.friendlyId);
+            this.#updateActiveRunsFile();
             this.#unsubscribeFromRunNotifications(message.run.friendlyId);
 
             //stop the worker if it is deprecated and there are no more runs
             if (worker.deprecated) {
-              this.#tryDeleteWorker(message.backgroundWorker.friendlyId).finally(() => {});
+              this.#tryDeleteWorker(message.backgroundWorker.friendlyId).catch((err) => {
+                logger.debug("[DevSupervisor] Failed to delete worker", { error: err });
+              });
             }
           },
           onSubscribeToRunNotifications: async (run, snapshot) => {
@@ -402,6 +532,7 @@ class DevSupervisor implements WorkerRuntime {
         });
 
         this.runControllers.set(message.run.friendlyId, runController);
+        this.#updateActiveRunsFile();
 
         if (this.runLimiter) {
           this.runLimiter(() => runController.start(message)).then(() => {
@@ -486,7 +617,9 @@ class DevSupervisor implements WorkerRuntime {
       }
 
       existingWorker.deprecate();
-      this.#tryDeleteWorker(workerId).finally(() => {});
+      this.#tryDeleteWorker(workerId).catch((err) => {
+        logger.debug("[DevSupervisor] Failed to delete worker", { error: err });
+      });
     }
 
     this.workers.set(worker.serverWorker.id, worker);
@@ -604,35 +737,98 @@ class DevSupervisor implements WorkerRuntime {
   }
 
   /** Deletes the worker if there are no active runs, after a delay */
+  /**
+   * Maximum number of deprecated workers to keep around.
+   * We retain a small buffer of old workers because the server may still
+   * dequeue runs locked to a recently-deprecated worker version.
+   * When the limit is exceeded, the oldest deprecated workers are cleaned up.
+   */
+  static readonly MAX_DEPRECATED_WORKERS = 2;
+
   async #tryDeleteWorker(friendlyId: string) {
     await awaitTimeout(5_000);
-    this.#deleteWorker(friendlyId);
+    this.#cleanupWorker(friendlyId);
   }
 
-  #deleteWorker(friendlyId: string) {
-    logger.debug("[DevSupervisor] Delete worker (if relevant)", {
-      workerId: friendlyId,
-    });
+  #hasActiveRunsForWorker(friendlyId: string): boolean {
+    for (const controller of this.runControllers.values()) {
+      try {
+        if (controller.workerFriendlyId === friendlyId) return true;
+      } catch {
+        // workerFriendlyId may throw if the controller is in an unexpected state
+      }
+    }
+    return false;
+  }
 
+  #cleanupWorker(friendlyId: string) {
     const worker = this.workers.get(friendlyId);
     if (!worker) {
       return;
     }
 
+    if (this.#hasActiveRunsForWorker(friendlyId)) {
+      logger.debug("[DevSupervisor] Worker still has active runs, skipping cleanup", {
+        workerId: friendlyId,
+      });
+      return;
+    }
+
     if (worker.serverWorker?.version) {
       this.taskRunProcessPool?.deprecateVersion(worker.serverWorker?.version);
     }
+
+    // Enforce limit on deprecated workers to bound disk usage.
+    // We keep a few around because the server may still dequeue runs for them.
+    this.#pruneDeprecatedWorkers();
+  }
+
+  #pruneDeprecatedWorkers() {
+    const deprecatedWorkers: Array<{ id: string; worker: BackgroundWorker }> = [];
+
+    for (const [id, worker] of this.workers.entries()) {
+      if (!worker.deprecated) continue;
+
+      if (!this.#hasActiveRunsForWorker(id)) {
+        deprecatedWorkers.push({ id, worker });
+      }
+    }
+
+    // Keep the most recent deprecated workers, remove the rest
+    if (deprecatedWorkers.length <= DevSupervisor.MAX_DEPRECATED_WORKERS) {
+      return;
+    }
+
+    // Remove oldest first (they appear first in insertion order of the Map)
+    const toRemove = deprecatedWorkers.slice(
+      0,
+      deprecatedWorkers.length - DevSupervisor.MAX_DEPRECATED_WORKERS
+    );
+
+    for (const { id, worker } of toRemove) {
+      logger.debug("[DevSupervisor] Pruning old deprecated worker and cleaning up build dir", {
+        workerId: id,
+        version: worker.serverWorker?.version,
+      });
+
+      if (worker.serverWorker?.version) {
+        this.taskRunProcessPool?.deprecateVersion(worker.serverWorker.version);
+      }
+
+      worker.stop();
+      this.workers.delete(id);
+    }
   }
 }
 
 type ValidationIssue =
   | {
-      type: "duplicateTaskId";
-      duplicationTaskIds: string[];
-    }
+    type: "duplicateTaskId";
+    duplicationTaskIds: string[];
+  }
   | {
-      type: "noTasksDefined";
-    };
+    type: "noTasksDefined";
+  };
 
 function validateWorkerManifest(manifest: WorkerManifest): ValidationIssue | undefined {
   const issues: ValidationIssue[] = [];
diff --git a/packages/cli-v3/src/dev/devWatchdog.ts b/packages/cli-v3/src/dev/devWatchdog.ts
new file mode 100644
index 00000000000..15dfae929f3
--- /dev/null
+++ b/packages/cli-v3/src/dev/devWatchdog.ts
@@ -0,0 +1,186 @@
+/**
+ * Dev Watchdog — a detached process that cancels in-flight runs when the dev CLI exits.
+ *
+ * Spawned by the dev CLI with `detached: true, stdio: "ignore", unref()`.
+ * Survives when pnpm sends SIGKILL to the CLI process tree.
+ *
+ * Lifecycle:
+ *   1. CLI spawns this script, passing config via env vars
+ *   2. Writes PID file for single-instance guarantee
+ *   3. Polls parent PID to detect when the CLI exits
+ *   4. On parent death: reads active-runs file → calls disconnect endpoint → exits
+ *
+ * Environment variables:
+ *   WATCHDOG_PARENT_PID    - The PID of the parent dev CLI process
+ *   WATCHDOG_API_URL       - The Trigger.dev API/engine URL
+ *   WATCHDOG_API_KEY       - The API key for authentication
+ *   WATCHDOG_ACTIVE_RUNS   - Path to the active-runs JSON file
+ *   WATCHDOG_PID_FILE      - Path to write the watchdog PID file
+ */
+
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+// @crumbs - watchdog runs as detached process, trail imported directly
+
+const POLL_INTERVAL_MS = 1000;
+
+// Safety timeout: if the watchdog has been running for 24 hours, exit regardless.
+// Prevents zombie watchdogs from PID reuse scenarios.
+const MAX_LIFETIME_MS = 24 * 60 * 60 * 1000;
+
+const parentPid = parseInt(process.env.WATCHDOG_PARENT_PID!, 10);
+const apiUrl = process.env.WATCHDOG_API_URL!;
+const apiKey = process.env.WATCHDOG_API_KEY!;
+const activeRunsPath = process.env.WATCHDOG_ACTIVE_RUNS!;
+const pidFilePath = process.env.WATCHDOG_PID_FILE!;
+const tmpDir = process.env.WATCHDOG_TMP_DIR;
+
+if (!parentPid || !apiUrl || !apiKey || !activeRunsPath || !pidFilePath) {
+  process.exit(1);
+}
+
+// Ensure directory exists
+const dir = dirname(pidFilePath);
+if (!existsSync(dir)) {
+  mkdirSync(dir, { recursive: true });
+}
+
+const PID_FILE_PREFIX = "trigger-watchdog:";
+
+// Single instance: kill any existing watchdog
+try {
+  const pidFileContent = readFileSync(pidFilePath, "utf8");
+  if (pidFileContent.startsWith(PID_FILE_PREFIX)) {
+    const existingPid = parseInt(pidFileContent.slice(PID_FILE_PREFIX.length), 10);
+    if (existingPid && existingPid !== process.pid) {
+      try {
+        process.kill(existingPid, 0); // Check if alive
+        process.kill(existingPid, "SIGTERM"); // Kill it
+      } catch {
+        // Already dead
+      }
+    }
+  }
+} catch {
+  // No PID file or invalid format
+}
+
+// Write our PID with prefix so we can verify ownership later
+writeFileSync(pidFilePath, `${PID_FILE_PREFIX}${process.pid}`);
+
+function cleanup() {
+  try {
+    unlinkSync(pidFilePath);
+  } catch {}
+  try {
+    unlinkSync(activeRunsPath);
+  } catch {}
+}
+
+function cleanupTmpDir() {
+  if (!tmpDir) return;
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+    // Best effort — may fail on Windows with EBUSY
+  }
+}
+
+function isParentAlive(): boolean {
+  try {
+    process.kill(parentPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readActiveRuns(): string[] {
+  try {
+    const data = JSON.parse(readFileSync(activeRunsPath, "utf8"));
+    return data.runFriendlyIds ?? [];
+  } catch {
+    return [];
+  }
+}
+
+async function callDisconnect(runFriendlyIds: string[]): Promise<void> {
+  const response = await fetch(`${apiUrl}/engine/v1/dev/disconnect`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ runFriendlyIds }),
+    signal: AbortSignal.timeout(10_000),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Disconnect failed with status ${response.status}`);
+  }
+}
+
+const MAX_DISCONNECT_ATTEMPTS = 5;
+const INITIAL_BACKOFF_MS = 500;
+
+async function onParentDied(): Promise<void> {
+  const runFriendlyIds = readActiveRuns();
+
+  if (runFriendlyIds.length > 0) {
+    for (let attempt = 0; attempt < MAX_DISCONNECT_ATTEMPTS; attempt++) {
+      try {
+        await callDisconnect(runFriendlyIds);
+        break;
+      } catch {
+        if (attempt < MAX_DISCONNECT_ATTEMPTS - 1) {
+          const backoff = INITIAL_BACKOFF_MS * 2 ** attempt;
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+        }
+        // Final attempt failed — runs will eventually time out via heartbeat
+      }
+    }
+  }
+
+  cleanupTmpDir();
+  cleanup();
+  process.exit(0);
+}
+
+// Guard against overlapping async callbacks
+let checking = false;
+
+const interval = setInterval(async () => {
+  if (checking) return;
+  checking = true;
+
+  try {
+    if (!isParentAlive()) {
+      clearInterval(interval);
+      clearTimeout(lifetimeTimeout);
+      await onParentDied();
+    }
+  } finally {
+    checking = false;
+  }
+}, POLL_INTERVAL_MS);
+
+// Safety timeout: exit after MAX_LIFETIME_MS to prevent zombie watchdogs
+const lifetimeTimeout = setTimeout(() => {
+  clearInterval(interval);
+  cleanup();
+  process.exit(0);
+}, MAX_LIFETIME_MS);
+
+// Unref the timeout so it doesn't keep the process alive if the interval is cleared
+lifetimeTimeout.unref();
+
+// Clean exit on any termination signal
+function handleSignal() {
+  clearInterval(interval);
+  clearTimeout(lifetimeTimeout);
+  cleanup();
+  process.exit(0);
+}
+
+process.on("SIGTERM", handleSignal);
+process.on("SIGINT", handleSignal);
diff --git a/packages/cli-v3/src/dev/taskRunProcessPool.ts b/packages/cli-v3/src/dev/taskRunProcessPool.ts
index 1d0640e52d5..810be7acb43 100644
--- a/packages/cli-v3/src/dev/taskRunProcessPool.ts
+++ b/packages/cli-v3/src/dev/taskRunProcessPool.ts
@@ -2,6 +2,7 @@ import {
   MachinePresetResources,
   ServerBackgroundWorker,
   WorkerManifest,
+  generateFriendlyId,
 } from "@trigger.dev/core/v3";
 import { TaskRunProcess } from "../executions/taskRunProcess.js";
 import { logger } from "../utilities/logger.js";
@@ -23,6 +24,8 @@ export class TaskRunProcessPool {
   private readonly maxExecutionsPerProcess: number;
   private readonly executionCountsPerProcess: Map<number, number> = new Map();
   private readonly deprecatedVersions: Set<string> = new Set();
+  private readonly idleTimers: Map<TaskRunProcess, NodeJS.Timeout> = new Map();
+  private static readonly IDLE_TIMEOUT_MS = 30_000;
 
   constructor(options: TaskRunProcessPoolOptions) {
     this.options = options;
@@ -38,6 +41,7 @@ export class TaskRunProcessPool {
     const versionProcesses = this.availableProcessesByVersion.get(version) || [];
 
     const processesToKill = versionProcesses.filter((process) => !process.isExecuting());
+    processesToKill.forEach((process) => this.clearIdleTimer(process));
     Promise.all(processesToKill.map((process) => this.killProcess(process))).then(() => {
       this.availableProcessesByVersion.delete(version);
     });
@@ -71,6 +75,7 @@ export class TaskRunProcessPool {
           version,
           availableProcesses.filter((p) => p !== reusableProcess)
         );
+        this.clearIdleTimer(reusableProcess);
 
         if (!this.busyProcessesByVersion.has(version)) {
           this.busyProcessesByVersion.set(version, new Set());
@@ -106,6 +111,7 @@ export class TaskRunProcessPool {
       env: {
         ...this.options.env,
         ...env,
+        TRIGGER_MACHINE_ID: generateFriendlyId("machine"),
       },
       serverWorker,
       machineResources,
@@ -154,6 +160,7 @@ export class TaskRunProcessPool {
           this.availableProcessesByVersion.set(version, []);
         }
         this.availableProcessesByVersion.get(version)!.push(process);
+        this.startIdleTimer(process, version);
       } catch (error) {
         logger.debug("[TaskRunProcessPool] Failed to cleanup process for reuse, killing it", {
           error,
@@ -213,7 +220,42 @@ export class TaskRunProcessPool {
     return process.isHealthy;
   }
 
+  private startIdleTimer(process: TaskRunProcess, version: string): void {
+    this.clearIdleTimer(process);
+
+    const timer = setTimeout(() => {
+      // Synchronously remove from available pool before async kill to prevent race with getProcess()
+      const available = this.availableProcessesByVersion.get(version);
+      if (available) {
+        const index = available.indexOf(process);
+        if (index !== -1) {
+          available.splice(index, 1);
+        }
+      }
+      this.idleTimers.delete(process);
+
+      logger.debug("[TaskRunProcessPool] Idle timeout reached, killing process", {
+        pid: process.pid,
+        version,
+      });
+
+      this.killProcess(process);
+    }, TaskRunProcessPool.IDLE_TIMEOUT_MS);
+
+    this.idleTimers.set(process, timer);
+  }
+
+  private clearIdleTimer(process: TaskRunProcess): void {
+    const timer = this.idleTimers.get(process);
+    if (timer) {
+      clearTimeout(timer);
+      this.idleTimers.delete(process);
+    }
+  }
+
   private async killProcess(process: TaskRunProcess): Promise<void> {
+    this.clearIdleTimer(process);
+
     if (!process.isHealthy) {
       logger.debug("[TaskRunProcessPool] Process is not healthy, skipping cleanup", {
         processId: process.pid,
@@ -245,6 +287,12 @@ export class TaskRunProcessPool {
       versions: Array.from(this.availableProcessesByVersion.keys()),
     });
 
+    // Clear all idle timers
+    for (const timer of this.idleTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.idleTimers.clear();
+
     // Kill all available processes across all versions
     const allAvailableProcesses = Array.from(this.availableProcessesByVersion.values()).flat();
     await Promise.all(allAvailableProcesses.map((process) => this.killProcess(process)));
diff --git a/packages/cli-v3/src/entryPoints/dev-index-worker.ts b/packages/cli-v3/src/entryPoints/dev-index-worker.ts
index da5c6ee7508..0b8ee54b0a1 100644
--- a/packages/cli-v3/src/entryPoints/dev-index-worker.ts
+++ b/packages/cli-v3/src/entryPoints/dev-index-worker.ts
@@ -3,6 +3,7 @@ import {
   type HandleErrorFunction,
   indexerToWorkerMessages,
   resourceCatalog,
+  type PromptManifest,
   type TaskManifest,
   TriggerConfig,
 } from "@trigger.dev/core/v3";
@@ -131,6 +132,20 @@ if (typeof config.maxDuration === "number") {
   });
 }
 
+// If the config has a TTL, we need to apply it to all tasks that don't have a TTL
+if (config.ttl !== undefined) {
+  tasks = tasks.map((task) => {
+    if (task.ttl === undefined) {
+      return {
+        ...task,
+        ttl: config.ttl,
+      } satisfies TaskManifest;
+    }
+
+    return task;
+  });
+}
+
 // If the config has a machine preset, we need to apply it to all tasks that don't have a machine preset
 if (typeof config.machine === "string") {
   tasks = tasks.map((task) => {
@@ -153,6 +168,7 @@ await sendMessageInCatalog(
   {
     manifest: {
       tasks,
+      prompts: convertPromptSchemasToJsonSchemas(resourceCatalog.listPromptManifests()),
       queues: resourceCatalog.listQueueManifests(),
       configPath: buildManifest.configPath,
       runtime: buildManifest.runtime,
@@ -192,6 +208,23 @@ await new Promise<void>((resolve) => {
   }, 10);
 });
 
+function convertPromptSchemasToJsonSchemas(prompts: PromptManifest[]): PromptManifest[] {
+  return prompts.map((prompt) => {
+    const schema = resourceCatalog.getPromptSchema(prompt.id);
+
+    if (schema) {
+      try {
+        const result = schemaToJsonSchema(schema);
+        return { ...prompt, variableSchema: result?.jsonSchema };
+      } catch {
+        return prompt;
+      }
+    }
+
+    return prompt;
+  });
+}
+
 async function convertSchemasToJsonSchemas(tasks: TaskManifest[]): Promise<TaskManifest[]> {
   const convertedTasks = tasks.map((task) => {
     const schema = resourceCatalog.getTaskSchema(task.id);
diff --git a/packages/cli-v3/src/entryPoints/dev-run-controller.ts b/packages/cli-v3/src/entryPoints/dev-run-controller.ts
index 5db271f9d61..fe486677452 100644
--- a/packages/cli-v3/src/entryPoints/dev-run-controller.ts
+++ b/packages/cli-v3/src/entryPoints/dev-run-controller.ts
@@ -596,7 +596,7 @@ export class DevRunController {
     const { taskRunProcess, isReused } = await this.opts.taskRunProcessPool.getProcess(
       this.opts.worker.manifest,
       {
-        id: "unmanaged",
+        id: this.opts.worker.serverWorker.id,
         contentHash: this.opts.worker.build.contentHash,
         version: this.opts.worker.serverWorker?.version,
         engine: "V2",
diff --git a/packages/cli-v3/src/entryPoints/dev-run-worker.ts b/packages/cli-v3/src/entryPoints/dev-run-worker.ts
index 7cd88ab5a9b..ae9a2667f51 100644
--- a/packages/cli-v3/src/entryPoints/dev-run-worker.ts
+++ b/packages/cli-v3/src/entryPoints/dev-run-worker.ts
@@ -33,6 +33,7 @@ import {
   traceContext,
   heartbeats,
   realtimeStreams,
+  inputStreams,
 } from "@trigger.dev/core/v3";
 import { TriggerTracer } from "@trigger.dev/core/v3/tracer";
 import {
@@ -59,6 +60,7 @@ import {
   StandardTraceContextManager,
   StandardHeartbeatsManager,
   StandardRealtimeStreamsManager,
+  StandardInputStreamManager,
 } from "@trigger.dev/core/v3/workers";
 import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
 import { readFile } from "node:fs/promises";
@@ -160,6 +162,14 @@ const standardRealtimeStreamsManager = new StandardRealtimeStreamsManager(
 );
 realtimeStreams.setGlobalManager(standardRealtimeStreamsManager);
 
+const standardInputStreamManager = new StandardInputStreamManager(
+  apiClientManager.clientOrThrow(),
+  getEnvVar("TRIGGER_STREAM_URL", getEnvVar("TRIGGER_API_URL")) ?? "https://api.trigger.dev",
+  (getEnvVar("TRIGGER_STREAMS_DEBUG") === "1" || getEnvVar("TRIGGER_STREAMS_DEBUG") === "true") ??
+    false
+);
+inputStreams.setGlobalManager(standardInputStreamManager);
+
 const waitUntilTimeoutInMs = getNumberEnvVar("TRIGGER_WAIT_UNTIL_TIMEOUT_MS", 60_000);
 const waitUntilManager = new StandardWaitUntilManager(waitUntilTimeoutInMs);
 waitUntil.setGlobalManager(waitUntilManager);
@@ -204,12 +214,18 @@ async function doBootstrap() {
 
     const tracingSDK = new TracingSDK({
       url: env.TRIGGER_OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
+      metricsUrl: env.TRIGGER_OTEL_METRICS_ENDPOINT,
       instrumentations: config.telemetry?.instrumentations ?? config.instrumentations ?? [],
       exporters: config.telemetry?.exporters ?? [],
       logExporters: config.telemetry?.logExporters ?? [],
+      metricExporters: config.telemetry?.metricExporters ?? [],
+      metricReaders: config.telemetry?.metricReaders ?? [],
       diagLogLevel: (env.TRIGGER_OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
       forceFlushTimeoutMillis: 30_000,
       resource: config.telemetry?.resource,
+      hostMetrics: true,
+      hostMetricGroups: ["process.cpu", "process.memory"],
+      nodejsRuntimeMetrics: true,
     });
 
     const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
@@ -327,6 +343,7 @@ function resetExecutionEnvironment() {
   usageTimeoutManager.reset();
   runMetadataManager.reset();
   standardRealtimeStreamsManager.reset();
+  standardInputStreamManager.reset();
   waitUntilManager.reset();
   _sharedWorkerRuntime?.reset();
   durableClock.reset();
@@ -374,6 +391,7 @@ const zodIpc = new ZodIpcConnection({
       }
 
       resetExecutionEnvironment();
+      standardInputStreamManager.setRunId(execution.run.id, execution.run.realtimeStreamsVersion);
 
       standardTraceContextManager.traceContext = traceContext;
       standardRunTimelineMetricsManager.registerMetricsFromExecution(metrics, isWarmStart);
@@ -619,8 +637,11 @@ const zodIpc = new ZodIpcConnection({
       }
       await flushAll(timeoutInMs);
     },
-    FLUSH: async ({ timeoutInMs }) => {
+    FLUSH: async ({ timeoutInMs, disableContext }) => {
       await flushAll(timeoutInMs);
+      if (disableContext) {
+        taskContext.disable();
+      }
     },
     RESOLVE_WAITPOINT: async ({ waitpoint }) => {
       _sharedWorkerRuntime?.resolveWaitpoints([waitpoint]);
diff --git a/packages/cli-v3/src/entryPoints/managed-index-worker.ts b/packages/cli-v3/src/entryPoints/managed-index-worker.ts
index 5ff9f1b62ed..efc226b99e0 100644
--- a/packages/cli-v3/src/entryPoints/managed-index-worker.ts
+++ b/packages/cli-v3/src/entryPoints/managed-index-worker.ts
@@ -3,6 +3,7 @@ import {
   type HandleErrorFunction,
   indexerToWorkerMessages,
   resourceCatalog,
+  type PromptManifest,
   type TaskManifest,
   TriggerConfig,
 } from "@trigger.dev/core/v3";
@@ -131,6 +132,20 @@ if (typeof config.maxDuration === "number") {
   });
 }
 
+// If the config has a TTL, we need to apply it to all tasks that don't have a TTL
+if (config.ttl !== undefined) {
+  tasks = tasks.map((task) => {
+    if (task.ttl === undefined) {
+      return {
+        ...task,
+        ttl: config.ttl,
+      } satisfies TaskManifest;
+    }
+
+    return task;
+  });
+}
+
 // If the config has a machine preset, we need to apply it to all tasks that don't have a machine preset
 if (typeof config.machine === "string") {
   tasks = tasks.map((task) => {
@@ -155,6 +170,7 @@ await sendMessageInCatalog(
   {
     manifest: {
       tasks,
+      prompts: convertPromptSchemasToJsonSchemas(resourceCatalog.listPromptManifests()),
       queues: resourceCatalog.listQueueManifests(),
       configPath: buildManifest.configPath,
       runtime: buildManifest.runtime,
@@ -200,6 +216,23 @@ await new Promise<void>((resolve) => {
   }, 10);
 });
 
+function convertPromptSchemasToJsonSchemas(prompts: PromptManifest[]): PromptManifest[] {
+  return prompts.map((prompt) => {
+    const schema = resourceCatalog.getPromptSchema(prompt.id);
+
+    if (schema) {
+      try {
+        const result = schemaToJsonSchema(schema);
+        return { ...prompt, variableSchema: result?.jsonSchema };
+      } catch {
+        return prompt;
+      }
+    }
+
+    return prompt;
+  });
+}
+
 async function convertSchemasToJsonSchemas(tasks: TaskManifest[]): Promise<TaskManifest[]> {
   const convertedTasks = tasks.map((task) => {
     const schema = resourceCatalog.getTaskSchema(task.id);
diff --git a/packages/cli-v3/src/entryPoints/managed-run-worker.ts b/packages/cli-v3/src/entryPoints/managed-run-worker.ts
index f1512f27f03..f8234aa68c4 100644
--- a/packages/cli-v3/src/entryPoints/managed-run-worker.ts
+++ b/packages/cli-v3/src/entryPoints/managed-run-worker.ts
@@ -32,6 +32,7 @@ import {
   traceContext,
   heartbeats,
   realtimeStreams,
+  inputStreams,
 } from "@trigger.dev/core/v3";
 import { TriggerTracer } from "@trigger.dev/core/v3/tracer";
 import {
@@ -59,6 +60,7 @@ import {
   StandardTraceContextManager,
   StandardHeartbeatsManager,
   StandardRealtimeStreamsManager,
+  StandardInputStreamManager,
 } from "@trigger.dev/core/v3/workers";
 import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
 import { readFile } from "node:fs/promises";
@@ -140,6 +142,14 @@ const standardRealtimeStreamsManager = new StandardRealtimeStreamsManager(
 );
 realtimeStreams.setGlobalManager(standardRealtimeStreamsManager);
 
+const standardInputStreamManager = new StandardInputStreamManager(
+  apiClientManager.clientOrThrow(),
+  getEnvVar("TRIGGER_STREAM_URL", getEnvVar("TRIGGER_API_URL")) ?? "https://api.trigger.dev",
+  (getEnvVar("TRIGGER_STREAMS_DEBUG") === "1" || getEnvVar("TRIGGER_STREAMS_DEBUG") === "true") ??
+    false
+);
+inputStreams.setGlobalManager(standardInputStreamManager);
+
 const waitUntilTimeoutInMs = getNumberEnvVar("TRIGGER_WAIT_UNTIL_TIMEOUT_MS", 60_000);
 const waitUntilManager = new StandardWaitUntilManager(waitUntilTimeoutInMs);
 waitUntil.setGlobalManager(waitUntilManager);
@@ -183,12 +193,23 @@ async function doBootstrap() {
 
     const tracingSDK = new TracingSDK({
       url: env.TRIGGER_OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
-      instrumentations: config.instrumentations ?? [],
+      metricsUrl: env.TRIGGER_OTEL_METRICS_ENDPOINT,
+      instrumentations: config.telemetry?.instrumentations ?? config.instrumentations ?? [],
       diagLogLevel: (env.TRIGGER_OTEL_LOG_LEVEL as TracingDiagnosticLogLevel) ?? "none",
       forceFlushTimeoutMillis: 30_000,
       exporters: config.telemetry?.exporters ?? [],
       logExporters: config.telemetry?.logExporters ?? [],
+      metricExporters: config.telemetry?.metricExporters ?? [],
+      metricReaders: config.telemetry?.metricReaders ?? [],
       resource: config.telemetry?.resource,
+      hostMetrics: true,
+      hostMetricGroups:
+        getEnvVar("TRIGGER_SYSTEM_METRICS_ENABLED") === "1"
+          ? undefined
+          : ["process.cpu", "process.memory"],
+      nodejsRuntimeMetrics: true,
+      filesystemMetrics: getEnvVar("TRIGGER_SYSTEM_METRICS_ENABLED") === "1",
+      diskIoMetrics: getEnvVar("TRIGGER_SYSTEM_METRICS_ENABLED") === "1",
     });
 
     const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
@@ -302,6 +323,7 @@ function resetExecutionEnvironment() {
   runMetadataManager.reset();
   waitUntilManager.reset();
   standardRealtimeStreamsManager.reset();
+  standardInputStreamManager.reset();
   _sharedWorkerRuntime?.reset();
   durableClock.reset();
   taskContext.disable();
@@ -353,6 +375,7 @@ const zodIpc = new ZodIpcConnection({
       }
 
       resetExecutionEnvironment();
+      standardInputStreamManager.setRunId(execution.run.id, execution.run.realtimeStreamsVersion);
 
       standardTraceContextManager.traceContext = traceContext;
 
@@ -607,8 +630,11 @@ const zodIpc = new ZodIpcConnection({
       }
       await flushAll(timeoutInMs);
     },
-    FLUSH: async ({ timeoutInMs }) => {
+    FLUSH: async ({ timeoutInMs, disableContext }) => {
       await flushAll(timeoutInMs);
+      if (disableContext) {
+        taskContext.disable();
+      }
     },
     RESOLVE_WAITPOINT: async ({ waitpoint }) => {
       _sharedWorkerRuntime?.resolveWaitpoints([waitpoint]);
diff --git a/packages/cli-v3/src/entryPoints/managed/taskRunProcessProvider.ts b/packages/cli-v3/src/entryPoints/managed/taskRunProcessProvider.ts
index 381dca908a8..f1bf0d6d621 100644
--- a/packages/cli-v3/src/entryPoints/managed/taskRunProcessProvider.ts
+++ b/packages/cli-v3/src/entryPoints/managed/taskRunProcessProvider.ts
@@ -1,4 +1,4 @@
-import { WorkerManifest } from "@trigger.dev/core/v3";
+import { WorkerManifest, generateFriendlyId } from "@trigger.dev/core/v3";
 import { TaskRunProcess } from "../../executions/taskRunProcess.js";
 import { RunnerEnv } from "./env.js";
 import { RunLogger, SendDebugLogOptions } from "./logger.js";
@@ -22,6 +22,7 @@ export class TaskRunProcessProvider {
   private readonly logger: RunLogger;
   private readonly processKeepAliveEnabled: boolean;
   private readonly processKeepAliveMaxExecutionCount: number;
+  private readonly machineId = generateFriendlyId("machine");
 
   // Process keep-alive state
   private persistentProcess: TaskRunProcess | null = null;
@@ -250,7 +251,7 @@ export class TaskRunProcessProvider {
       workerManifest: this.workerManifest,
       env: processEnv,
       serverWorker: {
-        id: "managed",
+        id: this.env.TRIGGER_DEPLOYMENT_ID,
         contentHash: this.env.TRIGGER_CONTENT_HASH,
         version: this.env.TRIGGER_DEPLOYMENT_VERSION,
         engine: "V2",
@@ -269,6 +270,7 @@ export class TaskRunProcessProvider {
     return {
       ...taskRunEnv,
       ...this.env.gatherProcessEnv(),
+      TRIGGER_MACHINE_ID: this.machineId,
       HEARTBEAT_INTERVAL_MS: String(this.env.TRIGGER_HEARTBEAT_INTERVAL_SECONDS * 1000),
     };
   }
diff --git a/packages/cli-v3/src/executions/taskRunProcess.test.ts b/packages/cli-v3/src/executions/taskRunProcess.test.ts
new file mode 100644
index 00000000000..82ab19639b2
--- /dev/null
+++ b/packages/cli-v3/src/executions/taskRunProcess.test.ts
@@ -0,0 +1,121 @@
+import { TaskRunProcess, type TaskRunProcessOptions } from "./taskRunProcess.js";
+import { describe, it, expect, vi } from "vitest";
+import { UnexpectedExitError } from "@trigger.dev/core/v3/errors";
+import type {
+  TaskRunExecution,
+  TaskRunExecutionPayload,
+  WorkerManifest,
+  ServerBackgroundWorker,
+  MachinePresetResources,
+} from "@trigger.dev/core/v3";
+
+function createTaskRunProcessOptions(
+  overrides: Partial<TaskRunProcessOptions> = {}
+): TaskRunProcessOptions {
+  return {
+    workerManifest: {
+      runtime: "node",
+      workerEntryPoint: "/dev/null",
+      configEntryPoint: "/dev/null",
+      otelImportHook: {},
+    } as unknown as WorkerManifest,
+    serverWorker: {} as unknown as ServerBackgroundWorker,
+    env: {},
+    machineResources: { cpu: 1, memory: 1 } as MachinePresetResources,
+    ...overrides,
+  };
+}
+
+function createExecution(runId: string, attemptNumber: number): TaskRunExecution {
+  return {
+    run: {
+      id: runId,
+      payload: "{}",
+      payloadType: "application/json",
+      tags: [],
+      isTest: false,
+      createdAt: new Date(),
+      startedAt: new Date(),
+      maxAttempts: 3,
+      version: "1",
+      durationMs: 0,
+      costInCents: 0,
+      baseCostInCents: 0,
+    },
+    attempt: {
+      number: attemptNumber,
+      startedAt: new Date(),
+      id: "deprecated",
+      backgroundWorkerId: "deprecated",
+      backgroundWorkerTaskId: "deprecated",
+      status: "deprecated" as any,
+    },
+    task: { id: "test-task", filePath: "test.ts" },
+    queue: { id: "queue-1", name: "test-queue" },
+    environment: { id: "env-1", slug: "test", type: "DEVELOPMENT" },
+    organization: { id: "org-1", slug: "test-org", name: "Test Org" },
+    project: { id: "proj-1", ref: "proj_test", slug: "test", name: "Test" },
+    machine: { name: "small-1x", cpu: 0.5, memory: 0.5, centsPerMs: 0 },
+  } as unknown as TaskRunExecution;
+}
+
+describe("TaskRunProcess", () => {
+  describe("execute() on a dead child process", () => {
+    it("should reject when child process has already exited and IPC send is skipped", async () => {
+      const proc = new TaskRunProcess(createTaskRunProcessOptions());
+
+      // Simulate a child process that has exited: _child exists but is not connected
+      const fakeChild = {
+        connected: false,
+        killed: false,
+        pid: 12345,
+        kill: vi.fn(),
+        on: vi.fn(),
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+      };
+
+      // Set internal state to mimic a process whose child has crashed
+      (proc as any)._child = fakeChild;
+      (proc as any)._childPid = 12345;
+      (proc as any)._isBeingKilled = false;
+
+      const execution = createExecution("run-1", 2);
+
+      // This should NOT hang forever - it should reject promptly.
+      //
+      // BUG: Currently execute() creates a promise, skips the IPC send because
+      // _child.connected is false, then awaits the promise which will never
+      // resolve because the child is dead and #handleExit already ran.
+      //
+      // The Promise.race with a timeout detects the hang.
+      const result = await Promise.race([
+        proc
+          .execute(
+            {
+              payload: { execution, traceContext: {}, metrics: [] },
+              messageId: "run_run-1",
+              env: {},
+            },
+            true
+          )
+          .then(
+            (v) => ({ type: "resolved" as const, value: v }),
+            (e) => ({ type: "rejected" as const, error: e })
+          ),
+        new Promise<{ type: "hung" }>((resolve) =>
+          setTimeout(() => resolve({ type: "hung" as const }), 2000)
+        ),
+      ]);
+
+      // The test fails (proving the bug) if execute() hangs
+      expect(result.type).not.toBe("hung");
+      expect(result.type).toBe("rejected");
+
+      if (result.type === "rejected") {
+        expect(result.error).toBeInstanceOf(UnexpectedExitError);
+        expect(result.error.stderr).toContain("not connected");
+      }
+    });
+  });
+});
diff --git a/packages/cli-v3/src/executions/taskRunProcess.ts b/packages/cli-v3/src/executions/taskRunProcess.ts
index 098b0f261c4..a329956c0d2 100644
--- a/packages/cli-v3/src/executions/taskRunProcess.ts
+++ b/packages/cli-v3/src/executions/taskRunProcess.ts
@@ -126,7 +126,7 @@ export class TaskRunProcess {
       return;
     }
 
-    await tryCatch(this.#flush());
+    await tryCatch(this.#flush({ disableContext: !kill }));
 
     if (kill) {
       await this.#gracefullyTerminate(this.options.gracefulTerminationTimeoutInMs);
@@ -240,10 +240,10 @@ export class TaskRunProcess {
     return this;
   }
 
-  async #flush(timeoutInMs: number = 5_000) {
+  async #flush({ timeoutInMs = 5_000, disableContext = false } = {}) {
     logger.debug("flushing task run process", { pid: this.pid });
 
-    await this._ipc?.sendWithAck("FLUSH", { timeoutInMs }, timeoutInMs + 1_000);
+    await this._ipc?.sendWithAck("FLUSH", { timeoutInMs, disableContext }, timeoutInMs + 1_000);
   }
 
   async #cancel(timeoutInMs: number = 30_000) {
@@ -297,6 +297,19 @@ export class TaskRunProcess {
         env: params.env,
         isWarmStart: isWarmStart ?? this.options.isWarmStart,
       });
+    } else {
+      // Child process is dead or disconnected — the IPC send was skipped so the attempt
+      // promise would hang forever. Reject it immediately to let the caller handle it.
+      this._attemptStatuses.set(key, "REJECTED");
+
+      // @ts-expect-error - rejecter is assigned in the promise constructor above
+      rejecter(
+        new UnexpectedExitError(
+          -1,
+          null,
+          "Child process is not connected, cannot execute task run"
+        )
+      );
     }
 
     const result = await promise;
diff --git a/packages/cli-v3/src/mcp/config.ts b/packages/cli-v3/src/mcp/config.ts
index 206b5910fa5..d878d881e7d 100644
--- a/packages/cli-v3/src/mcp/config.ts
+++ b/packages/cli-v3/src/mcp/config.ts
@@ -50,7 +50,13 @@ export const toolsMetadata = {
     name: "get_current_worker",
     title: "Get Current Worker",
     description:
-      "Get the current worker for the project. Useful when searching for a task and for looking up a task identifier/slug and payload schema, or looking for the latest version in a specific environment.",
+      "Get the current worker for the project, including version and registered task slugs. Use get_task_schema to get the payload schema for a specific task.",
+  },
+  get_task_schema: {
+    name: "get_task_schema",
+    title: "Get Task Schema",
+    description:
+      "Get the payload schema for a specific task. Use get_current_worker first to see available task slugs.",
   },
   trigger_task: {
     name: "trigger_task",
@@ -62,13 +68,19 @@ export const toolsMetadata = {
     name: "get_run_details",
     title: "Get Run Details",
     description:
-      "Get the details of a run. The run ID is the ID of the run that was triggered. It starts with run_",
+      "Get the details and trace of a run. Trace events are paginated — the first call returns run details and the first page of trace lines. Pass the returned cursor to fetch subsequent pages without re-fetching the trace. The run ID starts with run_.",
+  },
+  get_span_details: {
+    name: "get_span_details",
+    title: "Get Span Details",
+    description:
+      "Get detailed information about a specific span within a run trace. Use get_run_details first to see the trace and find span IDs (shown as [spanId] in the trace output). Returns timing, properties/attributes, error info, and for AI spans: model, tokens, cost, and response data.",
   },
   wait_for_run_to_complete: {
     name: "wait_for_run_to_complete",
     title: "Wait for Run to Complete",
     description:
-      "Wait for a run to complete. The run ID is the ID of the run that was triggered. It starts with run_",
+      "Wait for a run to complete. The run ID is the ID of the run that was triggered. It starts with run_. Has an optional timeoutInSeconds parameter (default 60s) - if the run doesn't complete within that time, the current state of the run will be returned.",
   },
   cancel_run: {
     name: "cancel_run",
@@ -100,4 +112,105 @@ export const toolsMetadata = {
     description:
       "List all preview branches for a project. Use this tool when you need to search for a preview branch or list all preview branches for a project.",
   },
+  query: {
+    name: "query",
+    title: "Query",
+    description:
+      "Execute a TRQL query against your Trigger.dev data. TRQL is a SQL-style query language for analyzing runs, metrics, and LLM usage. Call the get_query_schema tool first to discover available tables and columns before writing a query.",
+  },
+  get_query_schema: {
+    name: "get_query_schema",
+    title: "Get Query Schema",
+    description:
+      "Get the column schema for a specific TRQL table. Available tables: 'runs' (task execution data), 'metrics' (CPU, memory, custom metrics), 'llm_metrics' (LLM token usage, costs, latency). Returns columns, types, descriptions, and allowed values for the specified table.",
+  },
+  list_dashboards: {
+    name: "list_dashboards",
+    title: "List Dashboards",
+    description:
+      "List available built-in dashboards with their widgets. Each dashboard contains pre-built queries for common metrics like run success rates, costs, LLM usage, and more. Use run_dashboard to execute a dashboard's queries.",
+  },
+  run_dashboard_query: {
+    name: "run_dashboard_query",
+    title: "Run Dashboard Query",
+    description:
+      "Execute a single widget query from a built-in dashboard. Use list_dashboards first to see available dashboards, widget IDs, and their queries. Supports time period and scope options.",
+  },
+  whoami: {
+    name: "whoami",
+    title: "Who Am I",
+    description:
+      "Show the current authenticated user, active CLI profile, email, and API URL.",
+  },
+  list_profiles: {
+    name: "list_profiles",
+    title: "List Profiles",
+    description:
+      "List all configured CLI profiles. Shows which profile is currently active.",
+  },
+  switch_profile: {
+    name: "switch_profile",
+    title: "Switch Profile",
+    description:
+      "Switch the active CLI profile for this MCP session. This changes which Trigger.dev account and API URL are used for all subsequent tool calls.",
+  },
+  start_dev_server: {
+    name: "start_dev_server",
+    title: "Start Dev Server",
+    description:
+      "Start the Trigger.dev dev server (`trigger dev`) in the background. Waits up to 30 seconds for the worker to be ready. Use `dev_server_status` to check output and `stop_dev_server` to stop it.",
+  },
+  stop_dev_server: {
+    name: "stop_dev_server",
+    title: "Stop Dev Server",
+    description: "Stop the running Trigger.dev dev server.",
+  },
+  dev_server_status: {
+    name: "dev_server_status",
+    title: "Dev Server Status",
+    description:
+      "Check the status of the dev server and view recent output. Shows whether it is stopped, starting, ready, or has errors, along with recent log lines.",
+  },
+  list_prompts: {
+    name: "list_prompts",
+    title: "List Prompts",
+    description:
+      "List all managed prompts in the project environment. Shows slug, current version, override status, and version count.",
+  },
+  get_prompt_versions: {
+    name: "get_prompt_versions",
+    title: "Get Prompt Versions",
+    description:
+      "List all versions for a specific prompt. Shows version number, labels (current, override, latest), source (code or dashboard), model, and content.",
+  },
+  promote_prompt_version: {
+    name: "promote_prompt_version",
+    title: "Promote Prompt Version",
+    description:
+      "Promote a prompt version to be the current active version. Only code-sourced versions can be promoted — dashboard overrides must use the override tools instead.",
+  },
+  create_prompt_override: {
+    name: "create_prompt_override",
+    title: "Create Prompt Override",
+    description:
+      "Create a dashboard override for a prompt. The override takes precedence over the current code version when resolving the prompt. Provide the full text content for the override.",
+  },
+  update_prompt_override: {
+    name: "update_prompt_override",
+    title: "Update Prompt Override",
+    description:
+      "Update the active dashboard override for a prompt. Only works if an override is currently active.",
+  },
+  remove_prompt_override: {
+    name: "remove_prompt_override",
+    title: "Remove Prompt Override",
+    description:
+      "Remove the active dashboard override for a prompt, reverting to the current code version.",
+  },
+  reactivate_prompt_override: {
+    name: "reactivate_prompt_override",
+    title: "Reactivate Prompt Override",
+    description:
+      "Reactivate a previous dashboard-sourced version as the active override. Use get_prompt_versions to find dashboard versions that can be reactivated.",
+  },
 };
diff --git a/packages/cli-v3/src/mcp/context.ts b/packages/cli-v3/src/mcp/context.ts
index 75f6abd2a33..30a28857b89 100644
--- a/packages/cli-v3/src/mcp/context.ts
+++ b/packages/cli-v3/src/mcp/context.ts
@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { tryCatch } from "@trigger.dev/core/utils";
 import { ApiClient } from "@trigger.dev/core/v3";
+import fs from "node:fs";
 import path from "node:path";
 import { CliApiClient } from "../apiClient.js";
 import { loadConfig } from "../config.js";
@@ -13,21 +14,52 @@ import {
 import { FileLogger } from "./logger.js";
 import { fileURLToPath } from "node:url";
 
+const MCP_CONFIG_DIR = ".trigger";
+const MCP_CONFIG_FILE = "mcp.json";
+
+type McpProjectConfig = {
+  profile?: string;
+};
+
+function readMcpProjectConfig(projectDir: string): McpProjectConfig | undefined {
+  try {
+    const filePath = path.join(projectDir, MCP_CONFIG_DIR, MCP_CONFIG_FILE);
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content) as McpProjectConfig;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeMcpProjectConfig(projectDir: string, config: McpProjectConfig): void {
+  const dir = path.join(projectDir, MCP_CONFIG_DIR);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(path.join(dir, MCP_CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+}
+
 export type McpContextOptions = {
   projectRef?: string;
   fileLogger?: FileLogger;
   apiUrl?: string;
   profile?: string;
   devOnly?: boolean;
+  readonly?: boolean;
 };
 
 export class McpContext {
   public readonly server: McpServer;
   public readonly options: McpContextOptions;
+  private _profileLoaded: Promise<void> | undefined;
+  private _resolveProfileLoaded: (() => void) | undefined;
 
   constructor(server: McpServer, options: McpContextOptions) {
     this.server = server;
     this.options = options;
+    this._profileLoaded = new Promise((resolve) => {
+      this._resolveProfileLoaded = resolve;
+    });
   }
 
   get logger() {
@@ -35,6 +67,8 @@ export class McpContext {
   }
 
   public async getAuth() {
+    // Wait for project profile to be loaded before authenticating
+    await this._profileLoaded;
     const auth = await mcpAuth({
       server: this.server,
       defaultApiUrl: this.options.apiUrl,
@@ -75,7 +109,9 @@ export class McpContext {
       );
     }
 
-    return new ApiClient(cliApiClient.apiURL, jwt.data.token);
+    return new ApiClient(cliApiClient.apiURL, jwt.data.token, undefined, {
+      additionalHeaders: { "x-trigger-source": "mcp" },
+    });
   }
 
   public async getCwd() {
@@ -168,6 +204,40 @@ export class McpContext {
     };
   }
 
+  public switchProfile(profile: string, projectDir?: string) {
+    this.options.profile = profile;
+
+    // Persist to project-scoped config if we can resolve the project dir
+    if (projectDir) {
+      try {
+        const existing = readMcpProjectConfig(projectDir) ?? {};
+        writeMcpProjectConfig(projectDir, { ...existing, profile });
+      } catch {
+        // Non-fatal — profile still switched in memory
+      }
+    }
+  }
+
+  /**
+   * Load the persisted profile from the project-scoped .trigger/mcp.json.
+   * Overrides the default global profile with the project-scoped one.
+   * Must be called once after initialization — tools wait for this before authenticating.
+   */
+  public async loadProjectProfile() {
+    try {
+      const cwd = await this.getCwd();
+      if (!cwd) return;
+
+      const config = readMcpProjectConfig(cwd);
+      if (config?.profile) {
+        this.options.profile = config.profile;
+        this.logger?.log("Loaded project profile", { profile: config.profile, cwd });
+      }
+    } finally {
+      this._resolveProfileLoaded?.();
+    }
+  }
+
   public async getDashboardUrl(path: string) {
     const auth = await this.getAuth();
     return `${auth.dashboardUrl}${path}`;
diff --git a/packages/cli-v3/src/mcp/formatters.ts b/packages/cli-v3/src/mcp/formatters.ts
index eee9ccf18fe..c90ae0570df 100644
--- a/packages/cli-v3/src/mcp/formatters.ts
+++ b/packages/cli-v3/src/mcp/formatters.ts
@@ -3,6 +3,7 @@ import {
   ListRunResponseItem,
   RetrieveRunResponse,
   RetrieveRunTraceResponseBody,
+  RetrieveSpanDetailResponseBody,
 } from "@trigger.dev/core/v3/schemas";
 import type { CursorPageResponse } from "@trigger.dev/core/v3/zodfetch";
 
@@ -235,10 +236,11 @@ function formatSpan(
 
   // Format span header
   const statusIndicator = getStatusIndicator(span.data);
-  const duration = formatDuration(span.data.duration);
+  // Trace durations are nanoseconds from ClickHouse
+  const duration = formatDuration(span.data.duration / 1_000_000);
   const startTime = formatDateTime(span.data.startTime);
 
-  lines.push(`${indent}${prefix} ${span.data.message} ${statusIndicator}`);
+  lines.push(`${indent}${prefix} [${span.id}] ${span.data.message} ${statusIndicator}`);
   lines.push(`${indent}   Duration: ${duration}`);
   lines.push(`${indent}   Started: ${startTime}`);
 
@@ -427,3 +429,126 @@ function formatRunSummary(run: ListRunResponseItem): string {
 
   return parts.join(" | ");
 }
+
+/** Format query results as a compact text table. Falls back to compact JSON for nested data. */
+export function formatQueryResults(rows: Record<string, unknown>[]): string {
+  if (rows.length === 0) return "_No results_";
+
+  const columns = Object.keys(rows[0]!);
+
+  // Check if any values are objects/arrays — use compact JSON for those
+  const hasComplex = rows.some((row) =>
+    columns.some((col) => {
+      const val = row[col];
+      return val !== null && typeof val === "object";
+    })
+  );
+
+  if (hasComplex) {
+    return rows.map((row) => JSON.stringify(row)).join("\n");
+  }
+
+  const header = columns.join(" | ");
+  const separator = columns.map(() => "---").join(" | ");
+  const body = rows.map((row) =>
+    columns
+      .map((col) => {
+        const val = row[col];
+        return val === null || val === undefined ? "" : String(val);
+      })
+      .join(" | ")
+  );
+
+  return [header, separator, ...body].join("\n");
+}
+
+export function formatSpanDetail(span: RetrieveSpanDetailResponseBody): string {
+  const lines: string[] = [];
+
+  const statusIndicator = span.isCancelled
+    ? "[CANCELLED]"
+    : span.isError
+    ? "[ERROR]"
+    : span.isPartial
+    ? "[IN PROGRESS]"
+    : "[COMPLETED]";
+
+  lines.push(`## Span: ${span.message} ${statusIndicator}`);
+  lines.push(`Span ID: ${span.spanId}`);
+  if (span.parentId) lines.push(`Parent ID: ${span.parentId}`);
+  lines.push(`Run ID: ${span.runId}`);
+  lines.push(`Level: ${span.level}`);
+  lines.push(`Started: ${formatDateTime(span.startTime)}`);
+  lines.push(`Duration: ${formatDuration(span.durationMs)}`);
+  if (span.entityType) lines.push(`Entity Type: ${span.entityType}`);
+
+  if (span.ai) {
+    lines.push("");
+    lines.push("### AI Details");
+    lines.push(`Model: ${span.ai.model}`);
+    lines.push(`Provider: ${span.ai.provider}`);
+    lines.push(`Operation: ${span.ai.operationName}`);
+    lines.push(
+      `Tokens: ${span.ai.inputTokens} in / ${span.ai.outputTokens} out (${span.ai.totalTokens} total)`
+    );
+    if (span.ai.cachedTokens) {
+      lines.push(`Cached tokens: ${span.ai.cachedTokens}`);
+    }
+    if (span.ai.reasoningTokens) {
+      lines.push(`Reasoning tokens: ${span.ai.reasoningTokens}`);
+    }
+    if (span.ai.totalCost !== undefined) {
+      lines.push(`Cost: $${span.ai.totalCost.toFixed(6)}`);
+      if (span.ai.inputCost !== undefined && span.ai.outputCost !== undefined) {
+        lines.push(
+          `  Input: $${span.ai.inputCost.toFixed(6)}, Output: $${span.ai.outputCost.toFixed(6)}`
+        );
+      }
+    }
+    if (span.ai.tokensPerSecond !== undefined) {
+      lines.push(`Speed: ${span.ai.tokensPerSecond} tokens/sec`);
+    }
+    if (span.ai.msToFirstChunk !== undefined) {
+      lines.push(`Time to first chunk: ${span.ai.msToFirstChunk.toFixed(0)}ms`);
+    }
+    if (span.ai.finishReason) {
+      lines.push(`Finish reason: ${span.ai.finishReason}`);
+    }
+    if (span.ai.responseText) {
+      lines.push("");
+      lines.push("### AI Response");
+      lines.push(span.ai.responseText);
+    }
+  }
+
+  if (span.properties && Object.keys(span.properties).length > 0) {
+    lines.push("");
+    lines.push("### Properties");
+    lines.push(JSON.stringify(span.properties, null, 2));
+  }
+
+  if (span.events && span.events.length > 0) {
+    lines.push("");
+    lines.push(`### Events (${span.events.length})`);
+    const maxEvents = 10;
+    for (let i = 0; i < Math.min(span.events.length, maxEvents); i++) {
+      const event = span.events[i];
+      if (typeof event === "object" && event !== null) {
+        lines.push(JSON.stringify(event, null, 2));
+      }
+    }
+    if (span.events.length > maxEvents) {
+      lines.push(`... and ${span.events.length - maxEvents} more events`);
+    }
+  }
+
+  if (span.triggeredRuns && span.triggeredRuns.length > 0) {
+    lines.push("");
+    lines.push("### Triggered Runs");
+    for (const run of span.triggeredRuns) {
+      lines.push(`- ${run.runId} (${run.taskIdentifier}) - ${run.status.toLowerCase()}`);
+    }
+  }
+
+  return lines.join("\n");
+}
diff --git a/packages/cli-v3/src/mcp/mintlifyClient.ts b/packages/cli-v3/src/mcp/mintlifyClient.ts
index d7bc98c7db5..f60ee40ae1b 100644
--- a/packages/cli-v3/src/mcp/mintlifyClient.ts
+++ b/packages/cli-v3/src/mcp/mintlifyClient.ts
@@ -1,5 +1,5 @@
 export async function performSearch(query: string, signal: AbortSignal) {
-  const body = callToolBody("SearchTriggerDev", { query });
+  const body = callToolBody("search_trigger_dev", { query });
 
   const response = await fetch("https://trigger.dev/docs/mcp", {
     method: "POST",
diff --git a/packages/cli-v3/src/mcp/schemas.ts b/packages/cli-v3/src/mcp/schemas.ts
index b98faca0dab..b5b7d7518da 100644
--- a/packages/cli-v3/src/mcp/schemas.ts
+++ b/packages/cli-v3/src/mcp/schemas.ts
@@ -123,16 +123,45 @@ export const CommonRunsInput = CommonProjectsInput.extend({
 
 export type CommonRunsInput = z.output<typeof CommonRunsInput>;
 
+export const WaitForRunInput = CommonRunsInput.extend({
+  timeoutInSeconds: z
+    .number()
+    .describe(
+      "The maximum time in seconds to wait for the run to complete. If the run doesn't complete within this time, the current state of the run will be returned. Defaults to 60 seconds."
+    )
+    .default(60),
+});
+
+export type WaitForRunInput = z.output<typeof WaitForRunInput>;
+
 export const GetRunDetailsInput = CommonRunsInput.extend({
   maxTraceLines: z
     .number()
     .int()
-    .describe("The maximum number of lines to show in the trace. Defaults to 500")
+    .describe(
+      "The maximum number of trace lines per page. Defaults to 200. Use the `cursor` parameter to fetch subsequent pages."
+    )
+    .default(200),
+  cursor: z
+    .string()
+    .describe(
+      "Pagination cursor returned from a previous get_run_details call. Pass this to fetch the next page of trace events."
+    )
     .optional(),
 });
 
 export type GetRunDetailsInput = z.output<typeof GetRunDetailsInput>;
 
+export const GetSpanDetailsInput = CommonRunsInput.extend({
+  spanId: z
+    .string()
+    .describe(
+      "The span ID to get details for. You can find span IDs in the trace output from get_run_details — they appear as [spanId] before each span message."
+    ),
+});
+
+export type GetSpanDetailsInput = z.output<typeof GetSpanDetailsInput>;
+
 export const ListRunsInput = CommonProjectsInput.extend({
   cursor: z.string().describe("The cursor to use for pagination, starts with run_").optional(),
   limit: z
@@ -190,6 +219,91 @@ export const ListDeploysInput = CommonDeployInput.extend(ApiDeploymentListParams
 
 export type ListDeploysInput = z.output<typeof ListDeploysInput>;
 
+export const QueryInput = CommonProjectsInput.extend({
+  query: z
+    .string()
+    .describe(
+      "The TRQL query to execute. TRQL is a SQL-style language for analyzing your Trigger.dev data. Use the get_query_schema tool first to discover available tables and columns."
+    ),
+  scope: z
+    .enum(["environment", "project", "organization"])
+    .default("environment")
+    .describe(
+      "Data access scope. 'environment' (default) limits to the current environment, 'project' spans all environments, 'organization' spans all projects."
+    ),
+  period: z
+    .string()
+    .optional()
+    .describe(
+      "Time period shorthand, e.g. '1h', '7d', '30d'. Mutually exclusive with from/to."
+    ),
+  from: z
+    .string()
+    .optional()
+    .describe("Start of time range (ISO 8601). Must be paired with 'to'."),
+  to: z
+    .string()
+    .optional()
+    .describe("End of time range (ISO 8601). Must be paired with 'from'."),
+});
+
+export type QueryInput = z.output<typeof QueryInput>;
+
+export const QuerySchemaInput = CommonProjectsInput.pick({
+  projectRef: true,
+  configPath: true,
+  environment: true,
+  branch: true,
+}).extend({
+  table: z
+    .string()
+    .describe(
+      "The table name to get the schema for (e.g. 'runs', 'metrics', 'llm_metrics')."
+    ),
+});
+
+export type QuerySchemaInput = z.output<typeof QuerySchemaInput>;
+
+export const ListDashboardsInput = CommonProjectsInput.pick({
+  projectRef: true,
+  configPath: true,
+  environment: true,
+  branch: true,
+});
+
+export type ListDashboardsInput = z.output<typeof ListDashboardsInput>;
+
+export const RunDashboardQueryInput = CommonProjectsInput.extend({
+  dashboardKey: z
+    .string()
+    .describe(
+      "The dashboard key (e.g. 'overview', 'llm'). Use list_dashboards to discover available dashboards."
+    ),
+  widgetId: z
+    .string()
+    .describe(
+      "The widget ID to execute. Use list_dashboards to see available widget IDs and their queries."
+    ),
+  period: z
+    .string()
+    .optional()
+    .describe("Time period shorthand, e.g. '1h', '7d', '30d'. Defaults to 1d."),
+  from: z
+    .string()
+    .optional()
+    .describe("Start of time range (ISO 8601). Must be paired with 'to'."),
+  to: z
+    .string()
+    .optional()
+    .describe("End of time range (ISO 8601). Must be paired with 'from'."),
+  scope: z
+    .enum(["environment", "project", "organization"])
+    .default("environment")
+    .describe("Data access scope."),
+});
+
+export type RunDashboardQueryInput = z.output<typeof RunDashboardQueryInput>;
+
 export const ListPreviewBranchesInput = z.object({
   projectRef: ProjectRefSchema,
   configPath: z
diff --git a/packages/cli-v3/src/mcp/smoke.test.ts b/packages/cli-v3/src/mcp/smoke.test.ts
new file mode 100644
index 00000000000..d14403aa2cf
--- /dev/null
+++ b/packages/cli-v3/src/mcp/smoke.test.ts
@@ -0,0 +1,258 @@
+/**
+ * Smoke test for MCP tools against a running webapp.
+ *
+ * Usage:
+ *   npx tsx src/mcp/smoke.test.ts [--api-url URL] [--project-ref REF]
+ *
+ * Requires:
+ *   - Webapp running (default http://localhost:3030)
+ *   - Valid CLI auth profile
+ *
+ * Tests all read-only tools and verifies they return non-error responses.
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+type TestResult = {
+  tool: string;
+  status: "pass" | "fail" | "skip";
+  duration: number;
+  error?: string;
+  preview?: string;
+};
+
+async function callTool(
+  client: Client,
+  name: string,
+  args: Record<string, unknown> = {}
+): Promise<{ isError: boolean; text: string }> {
+  const result = await client.callTool({ name, arguments: args });
+
+  const text = (result.content as Array<{ type: string; text?: string }>)
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text!)
+    .join("\n");
+
+  return { isError: !!result.isError, text };
+}
+
+function preview(text: string, maxLen = 80): string {
+  const first = text.split("\n")[0] ?? "";
+  return first.length > maxLen ? first.slice(0, maxLen) + "..." : first;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  let apiUrl = "http://localhost:3030";
+  const apiUrlIdx = args.indexOf("--api-url");
+  if (apiUrlIdx !== -1) {
+    apiUrl = args[apiUrlIdx + 1] ?? apiUrl;
+    args.splice(apiUrlIdx, 2);
+  }
+
+  let projectRef = "proj_rrkpdguyagvsoktglnod";
+  const projIdx = args.indexOf("--project-ref");
+  if (projIdx !== -1) {
+    projectRef = args[projIdx + 1] ?? projectRef;
+    args.splice(projIdx, 2);
+  }
+
+  const env = "dev";
+  const commonArgs = { projectRef, environment: env };
+
+  const cliPath = path.resolve(__dirname, "..", "..", "dist", "esm", "index.js");
+
+  const transport = new StdioClientTransport({
+    command: "node",
+    args: [cliPath, "mcp", "--api-url", apiUrl],
+    stderr: "pipe",
+  });
+
+  const client = new Client(
+    { name: "mcp-smoke-test", version: "1.0.0" },
+    { capabilities: {} }
+  );
+
+  await client.connect(transport);
+
+  const results: TestResult[] = [];
+
+  async function test(
+    name: string,
+    toolArgs: Record<string, unknown> = {},
+    validate?: (text: string) => void
+  ) {
+    const start = Date.now();
+    try {
+      const { isError, text } = await callTool(client, name, toolArgs);
+      const duration = Date.now() - start;
+
+      if (isError) {
+        results.push({ tool: name, status: "fail", duration, error: preview(text), preview: preview(text) });
+        return null;
+      }
+
+      if (validate) {
+        validate(text);
+      }
+
+      results.push({ tool: name, status: "pass", duration, preview: preview(text) });
+      return text;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const msg = err instanceof Error ? err.message : String(err);
+      results.push({ tool: name, status: "fail", duration, error: msg });
+      return null;
+    }
+  }
+
+  function assert(condition: boolean, message: string) {
+    if (!condition) throw new Error(message);
+  }
+
+  console.log(`\nMCP Smoke Test — ${apiUrl} — ${projectRef}\n`);
+
+  // 1. search_docs (no auth needed)
+  await test("search_docs", { query: "how to create a task" }, (text) => {
+    assert(text.includes("http"), "Expected doc links in response");
+  });
+
+  // 2. list_orgs
+  await test("list_orgs");
+
+  // 3. list_projects
+  await test("list_projects");
+
+  // 4. whoami
+  await test("whoami", {}, (text) => {
+    assert(text.includes("Profile:"), "Expected profile info");
+    assert(text.includes("Email:"), "Expected email");
+  });
+
+  // 5. list_profiles
+  await test("list_profiles", {}, (text) => {
+    assert(text.includes("default"), "Expected default profile");
+  });
+
+  // 6. get_current_worker
+  const workerText = await test("get_current_worker", commonArgs, (text) => {
+    assert(text.includes("tasks registered"), "Expected task count");
+    assert(!text.includes("payloadSchema"), "Should NOT contain inline payload schemas");
+  });
+
+  // 7. get_task_schema — pick a task from worker output
+  if (workerText) {
+    const taskMatch = workerText.match(/^- (\S+) in /m);
+    if (taskMatch) {
+      await test("get_task_schema", { ...commonArgs, taskSlug: taskMatch[1] }, (text) => {
+        assert(text.includes("File:"), "Expected file path");
+      });
+    }
+  }
+
+  // 8. list_runs
+  const runsText = await test("list_runs", { ...commonArgs, limit: 3 }, (text) => {
+    assert(text.includes("Found"), "Expected run count");
+  });
+
+  // 9. get_run_details — pick a run from list output
+  if (runsText) {
+    const runMatch = runsText.match(/run_\w+/);
+    if (runMatch) {
+      await test("get_run_details", { ...commonArgs, runId: runMatch[0], maxTraceLines: 10 }, (text) => {
+        assert(text.includes("Run Details"), "Expected run details header");
+        assert(text.includes("Run Trace"), "Expected trace section");
+      });
+    }
+  }
+
+  // 10. list_deploys
+  await test("list_deploys", { ...commonArgs, environment: "prod", limit: 3 });
+
+  // 11. list_preview_branches
+  await test("list_preview_branches", { projectRef });
+
+  // 12. get_query_schema — single table
+  await test("get_query_schema", { ...commonArgs, table: "runs" }, (text) => {
+    assert(text.includes("runs"), "Expected runs table");
+    assert(text.includes("run_id"), "Expected run_id column");
+    assert(!text.includes("### metrics"), "Should NOT contain other tables");
+  });
+
+  // 13. get_query_schema — invalid table shows available
+  await test("get_query_schema", { ...commonArgs, table: "nonexistent" }).then(() => {
+    // This should fail — flip the result
+    const last = results[results.length - 1]!;
+    if (last.status === "fail" && last.error?.includes("not found")) {
+      last.status = "pass";
+      last.preview = "Correctly rejected invalid table";
+      last.error = undefined;
+    }
+  });
+
+  // 14. query
+  await test("query", { ...commonArgs, query: "SELECT status, count() as total FROM runs GROUP BY status ORDER BY total DESC LIMIT 5", period: "7d" }, (text) => {
+    assert(text.includes("Query Results"), "Expected results header");
+    assert(text.includes("status"), "Expected status column");
+    assert(!text.includes("```json"), "Should use text table, not JSON code block");
+  });
+
+  // 15. list_dashboards
+  await test("list_dashboards", commonArgs, (text) => {
+    assert(text.includes("overview"), "Expected overview dashboard");
+    assert(text.includes("llm"), "Expected llm dashboard");
+  });
+
+  // 16. run_dashboard_query
+  await test("run_dashboard_query", { ...commonArgs, dashboardKey: "overview", widgetId: "9lDDdebQ", period: "7d" }, (text) => {
+    assert(text.includes("Total runs"), "Expected widget title");
+  });
+
+  // 17. dev_server_status (should show stopped)
+  await test("dev_server_status", {}, (text) => {
+    assert(text.includes("stopped"), "Expected stopped status");
+  });
+
+  // Print results
+  await client.close();
+
+  console.log("");
+  console.log("─".repeat(90));
+  console.log("");
+
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  for (const r of results) {
+    const icon = r.status === "pass" ? "✓" : r.status === "fail" ? "✗" : "○";
+    const dur = `${r.duration}ms`.padStart(6);
+    const status = r.status === "pass" ? "\x1b[32mpass\x1b[0m" : r.status === "fail" ? "\x1b[31mfail\x1b[0m" : "\x1b[33mskip\x1b[0m";
+
+    console.log(`  ${icon} ${r.tool.padEnd(25)} ${status} ${dur}  ${r.error ?? r.preview ?? ""}`);
+
+    if (r.status === "pass") passed++;
+    else if (r.status === "fail") failed++;
+    else skipped++;
+  }
+
+  console.log("");
+  console.log(`  ${passed} passed, ${failed} failed, ${skipped} skipped (${results.length} total)`);
+  console.log("");
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});
diff --git a/packages/cli-v3/src/mcp/tools.test.ts b/packages/cli-v3/src/mcp/tools.test.ts
new file mode 100644
index 00000000000..eef627fd5aa
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools.test.ts
@@ -0,0 +1,132 @@
+/**
+ * CLI utility for testing MCP tools.
+ *
+ * Usage:
+ *   npx tsx src/mcp/test-tools.ts [--api-url URL] [command] [args...]
+ *
+ * Commands:
+ *   list                     List all registered tools
+ *   call <tool> [json-args]  Call a tool with optional JSON arguments
+ *
+ * Examples:
+ *   npx tsx src/mcp/test-tools.ts list
+ *   npx tsx src/mcp/test-tools.ts call get_query_schema '{"environment":"prod"}'
+ *   npx tsx src/mcp/test-tools.ts call list_dashboards
+ *   npx tsx src/mcp/test-tools.ts call query '{"query":"SELECT count() FROM runs","period":"7d"}'
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Parse --api-url flag
+  let apiUrl = "http://localhost:3030";
+  const apiUrlIdx = args.indexOf("--api-url");
+  if (apiUrlIdx !== -1) {
+    apiUrl = args[apiUrlIdx + 1] ?? apiUrl;
+    args.splice(apiUrlIdx, 2);
+  }
+
+  // Parse --readonly flag
+  const readonlyIdx = args.indexOf("--readonly");
+  const readonly = readonlyIdx !== -1;
+  if (readonly) {
+    args.splice(readonlyIdx, 1);
+  }
+
+  const command = args[0] ?? "list";
+
+  // Spawn the MCP server as a subprocess
+  const cliPath = path.resolve(__dirname, "..", "..", "dist", "esm", "index.js");
+  const mcpArgs = [cliPath, "mcp", "--api-url", apiUrl];
+  if (readonly) {
+    mcpArgs.push("--readonly");
+  }
+
+  const transport = new StdioClientTransport({
+    command: "node",
+    args: mcpArgs,
+    stderr: "pipe",
+  });
+
+  const client = new Client(
+    { name: "mcp-test-cli", version: "1.0.0" },
+    { capabilities: {} }
+  );
+
+  await client.connect(transport);
+
+  try {
+    if (command === "list") {
+      const { tools } = await client.listTools();
+      console.log(`\n${tools.length} tools registered:\n`);
+      for (const tool of tools) {
+        const params = tool.inputSchema?.properties
+          ? Object.keys(tool.inputSchema.properties as Record<string, unknown>).join(", ")
+          : "";
+        console.log(`  ${tool.name}(${params})`);
+        if (tool.description) {
+          // Show first line of description
+          const firstLine = tool.description!.split("\n")[0]!.slice(0, 100);
+          console.log(`    ${firstLine}`);
+        }
+        console.log();
+      }
+    } else if (command === "call") {
+      const toolName = args[1];
+      if (!toolName) {
+        console.error("Usage: call <tool-name> [json-arguments]");
+        process.exit(1);
+      }
+
+      let toolArgs: Record<string, unknown> = {};
+      if (args[2]) {
+        try {
+          toolArgs = JSON.parse(args[2]);
+        } catch {
+          console.error(`Invalid JSON arguments: ${args[2]}`);
+          process.exit(1);
+        }
+      }
+
+      console.log(`\nCalling ${toolName}...`);
+      if (Object.keys(toolArgs).length > 0) {
+        console.log(`Arguments: ${JSON.stringify(toolArgs, null, 2)}`);
+      }
+      console.log();
+
+      const result = await client.callTool({ name: toolName, arguments: toolArgs });
+
+      if (result.isError) {
+        console.error("Error:", JSON.stringify(result.content, null, 2));
+        process.exit(1);
+      }
+
+      for (const item of result.content as Array<{ type: string; text?: string }>) {
+        if (item.type === "text" && item.text) {
+          console.log(item.text);
+        } else {
+          console.log(JSON.stringify(item, null, 2));
+        }
+      }
+    } else {
+      console.error(`Unknown command: ${command}`);
+      console.error("Available commands: list, call");
+      process.exit(1);
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});
diff --git a/packages/cli-v3/src/mcp/tools.ts b/packages/cli-v3/src/mcp/tools.ts
index 5c69bb82fe3..fd013b77644 100644
--- a/packages/cli-v3/src/mcp/tools.ts
+++ b/packages/cli-v3/src/mcp/tools.ts
@@ -7,16 +7,44 @@ import {
   listOrgsTool,
   listProjectsTool,
 } from "./tools/orgs.js";
+import { listDashboardsTool, runDashboardQueryTool } from "./tools/dashboards.js";
+import { startDevServerTool, stopDevServerTool, devServerStatusTool } from "./tools/devServer.js";
 import { listPreviewBranchesTool } from "./tools/previewBranches.js";
+import { listProfilesTool, switchProfileTool, whoamiTool } from "./tools/profiles.js";
+import { getQuerySchemaTool, queryTool } from "./tools/query.js";
 import {
   cancelRunTool,
   getRunDetailsTool,
+  getSpanDetailsTool,
   listRunsTool,
   waitForRunToCompleteTool,
 } from "./tools/runs.js";
-import { getCurrentWorker, triggerTaskTool } from "./tools/tasks.js";
+import { getCurrentWorker, getTaskSchemaTool, triggerTaskTool } from "./tools/tasks.js";
+import {
+  listPromptsTool,
+  getPromptVersionsTool,
+  promotePromptVersionTool,
+  createPromptOverrideTool,
+  updatePromptOverrideTool,
+  removePromptOverrideTool,
+  reactivatePromptOverrideTool,
+} from "./tools/prompts.js";
 import { respondWithError } from "./utils.js";
 
+/** Tool names that perform write/mutating operations. */
+const WRITE_TOOLS = new Set([
+  deployTool.name,
+  triggerTaskTool.name,
+  cancelRunTool.name,
+  createProjectInOrgTool.name,
+  initializeProjectTool.name,
+  promotePromptVersionTool.name,
+  createPromptOverrideTool.name,
+  updatePromptOverrideTool.name,
+  removePromptOverrideTool.name,
+  reactivatePromptOverrideTool.name,
+]);
+
 export function registerTools(context: McpContext) {
   const tools = [
     searchDocsTool,
@@ -25,21 +53,51 @@ export function registerTools(context: McpContext) {
     createProjectInOrgTool,
     initializeProjectTool,
     getCurrentWorker,
+    getTaskSchemaTool,
     triggerTaskTool,
     listRunsTool,
     getRunDetailsTool,
+    getSpanDetailsTool,
     waitForRunToCompleteTool,
     cancelRunTool,
     deployTool,
     listDeploysTool,
     listPreviewBranchesTool,
+    getQuerySchemaTool,
+    queryTool,
+    listDashboardsTool,
+    runDashboardQueryTool,
+    whoamiTool,
+    listProfilesTool,
+    switchProfileTool,
+    startDevServerTool,
+    stopDevServerTool,
+    devServerStatusTool,
+    listPromptsTool,
+    getPromptVersionsTool,
+    promotePromptVersionTool,
+    createPromptOverrideTool,
+    updatePromptOverrideTool,
+    removePromptOverrideTool,
+    reactivatePromptOverrideTool,
   ];
 
   for (const tool of tools) {
+    // In readonly mode, skip write tools entirely so the LLM never sees them
+    if (context.options.readonly && WRITE_TOOLS.has(tool.name)) {
+      continue;
+    }
+
+    const isWrite = WRITE_TOOLS.has(tool.name);
+
     context.server.registerTool(
       tool.name,
       {
-        annotations: { title: tool.title },
+        annotations: {
+          title: tool.title,
+          readOnlyHint: !isWrite,
+          destructiveHint: isWrite,
+        },
         description: tool.description,
         inputSchema: tool.inputSchema,
       },
diff --git a/packages/cli-v3/src/mcp/tools/dashboards.ts b/packages/cli-v3/src/mcp/tools/dashboards.ts
new file mode 100644
index 00000000000..fcbcbb42a2a
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools/dashboards.ts
@@ -0,0 +1,156 @@
+import type { ListDashboardsResponseBody } from "@trigger.dev/core/v3/schemas";
+import { toolsMetadata } from "../config.js";
+import { formatQueryResults } from "../formatters.js";
+import { ListDashboardsInput, RunDashboardQueryInput } from "../schemas.js";
+import { respondWithError, toolHandler } from "../utils.js";
+
+// Cache dashboard listings keyed by project/environment.
+const dashboardCache = new Map<string, { data: ListDashboardsResponseBody; expiresAt: number }>();
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+export const listDashboardsTool = {
+  name: toolsMetadata.list_dashboards.name,
+  title: toolsMetadata.list_dashboards.title,
+  description: toolsMetadata.list_dashboards.description,
+  inputSchema: ListDashboardsInput.shape,
+  handler: toolHandler(ListDashboardsInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling list_dashboards", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:query"],
+      branch: input.branch,
+    });
+
+    const cacheKey = `${projectRef}:${input.environment}:${input.branch ?? ""}`;
+    const cached = dashboardCache.get(cacheKey);
+    let result: ListDashboardsResponseBody;
+    if (cached && Date.now() < cached.expiresAt) {
+      result = cached.data;
+    } else {
+      result = await apiClient.listDashboards();
+      dashboardCache.set(cacheKey, { data: result, expiresAt: Date.now() + CACHE_TTL_MS });
+    }
+
+    const content: string[] = ["## Available Dashboards", ""];
+
+    for (const dashboard of result.dashboards) {
+      content.push(`### ${dashboard.title} (key: \`${dashboard.key}\`)`);
+      content.push("");
+      content.push("| Widget ID | Title | Type |");
+      content.push("|-----------|-------|------|");
+
+      for (const widget of dashboard.widgets) {
+        content.push(`| \`${widget.id}\` | ${widget.title} | ${widget.type} |`);
+      }
+
+      content.push("");
+    }
+
+    content.push(
+      "Use the `run_dashboard_query` tool with a dashboard key and widget ID to execute a specific query."
+    );
+
+    return {
+      content: [{ type: "text" as const, text: content.join("\n") }],
+    };
+  }),
+};
+
+export const runDashboardQueryTool = {
+  name: toolsMetadata.run_dashboard_query.name,
+  title: toolsMetadata.run_dashboard_query.title,
+  description: toolsMetadata.run_dashboard_query.description,
+  inputSchema: RunDashboardQueryInput.shape,
+  handler: toolHandler(RunDashboardQueryInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling run_dashboard_query", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:query"],
+      branch: input.branch,
+    });
+
+    // Use cached dashboard listing if available, otherwise fetch
+    const cacheKey = `${projectRef}:${input.environment}:${input.branch ?? ""}`;
+    const cached = dashboardCache.get(cacheKey);
+    let dashboards: ListDashboardsResponseBody;
+    if (cached && Date.now() < cached.expiresAt) {
+      dashboards = cached.data;
+    } else {
+      dashboards = await apiClient.listDashboards();
+      dashboardCache.set(cacheKey, { data: dashboards, expiresAt: Date.now() + CACHE_TTL_MS });
+    }
+    const dashboard = dashboards.dashboards.find((d) => d.key === input.dashboardKey);
+
+    if (!dashboard) {
+      const available = dashboards.dashboards.map((d) => d.key).join(", ");
+      return respondWithError(
+        `Dashboard "${input.dashboardKey}" not found. Available dashboards: ${available}`
+      );
+    }
+
+    const widget = dashboard.widgets.find((w) => w.id === input.widgetId);
+
+    if (!widget) {
+      const available = dashboard.widgets.map((w) => `${w.id} (${w.title})`).join(", ");
+      return respondWithError(
+        `Widget "${input.widgetId}" not found in dashboard "${input.dashboardKey}". Available widgets: ${available}`
+      );
+    }
+
+    // Execute the widget's query
+    const result = await apiClient.executeQuery(widget.query, {
+      scope: input.scope,
+      period: input.period ?? "1d",
+      from: input.from,
+      to: input.to,
+      format: "json",
+    });
+
+    if (result.format === "json") {
+      const rowCount = result.results.length;
+      const formatted = formatQueryResults(result.results as Record<string, unknown>[]);
+
+      const content = [
+        `## ${widget.title}`,
+        "",
+        `**Dashboard:** ${dashboard.title} | **Widget:** \`${widget.id}\` | **${rowCount} row${rowCount === 1 ? "" : "s"}**`,
+        "",
+        formatted,
+      ];
+
+      return {
+        content: [{ type: "text" as const, text: content.join("\n") }],
+      };
+    }
+
+    return {
+      content: [{ type: "text" as const, text: result.results }],
+    };
+  }),
+};
diff --git a/packages/cli-v3/src/mcp/tools/deploys.ts b/packages/cli-v3/src/mcp/tools/deploys.ts
index ab09659a54f..2b071f44e9f 100644
--- a/packages/cli-v3/src/mcp/tools/deploys.ts
+++ b/packages/cli-v3/src/mcp/tools/deploys.ts
@@ -138,13 +138,36 @@ export const listDeploysTool = {
 
     const result = await apiClient.listDeployments(input);
 
+    const lines: string[] = [];
+    const deploys = result.data;
+
+    lines.push(`Found ${deploys.length} deployment${deploys.length === 1 ? "" : "s"}`);
+    lines.push("");
+
+    for (const deploy of deploys) {
+      const deployedAt = deploy.deployedAt
+        ? new Date(deploy.deployedAt).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")
+        : "not deployed";
+      const git = deploy.git && typeof deploy.git === "object" && "commitMessage" in deploy.git
+        ? ` | ${deploy.git.commitMessage}`
+        : "";
+      lines.push(
+        `- ${deploy.shortCode} | v${deploy.version} | ${deploy.status} | ${deployedAt}${git}`
+      );
+    }
+
+    if (result.pagination?.next) {
+      lines.push("");
+      lines.push("Next page available →");
+    }
+
     return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      content: [{ type: "text", text: lines.join("\n") }],
     };
   }),
 };
 
-async function resolveCLIExec(context: McpContext, cwd?: string): Promise<[string, string]> {
+export async function resolveCLIExec(context: McpContext, cwd?: string): Promise<[string, string]> {
   // Lets first try to get the version of the CLI package
   const installedCLI = await tryResolveTriggerCLIPath(context, cwd);
 
diff --git a/packages/cli-v3/src/mcp/tools/devServer.ts b/packages/cli-v3/src/mcp/tools/devServer.ts
new file mode 100644
index 00000000000..9a21477edac
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools/devServer.ts
@@ -0,0 +1,245 @@
+import { z } from "zod";
+import { x, type Result } from "tinyexec";
+import stripAnsi from "strip-ansi";
+import { toolsMetadata } from "../config.js";
+import { respondWithError, toolHandler } from "../utils.js";
+import { resolveCLIExec } from "./deploys.js";
+
+type DevState = "stopped" | "starting" | "ready" | "error";
+
+// State for the running dev server process
+let devProcess: Result | null = null;
+let devState: DevState = "stopped";
+let devLogs: string[] = [];
+let devCwd: string | undefined;
+const MAX_LOG_LINES = 200;
+
+function getDevState(): DevState {
+  return devState;
+}
+
+function pushLog(line: string) {
+  devLogs.push(line);
+  if (devLogs.length > MAX_LOG_LINES) {
+    devLogs = devLogs.slice(-MAX_LOG_LINES);
+  }
+}
+
+const StartDevServerInput = {
+  configPath: z
+    .string()
+    .describe(
+      "The path to the trigger.config.ts file or project directory. Only needed when the trigger.config.ts file is not at the root dir."
+    )
+    .optional(),
+};
+
+export const startDevServerTool = {
+  name: toolsMetadata.start_dev_server.name,
+  title: toolsMetadata.start_dev_server.title,
+  description: toolsMetadata.start_dev_server.description,
+  inputSchema: StartDevServerInput,
+  handler: toolHandler(StartDevServerInput, async (input, { ctx }) => {
+    ctx.logger?.log("calling start_dev_server", { input });
+
+    if (devProcess && devState !== "stopped") {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Dev server is already ${devState}. Use \`dev_server_status\` to see output or \`stop_dev_server\` to stop it.`,
+          },
+        ],
+      };
+    }
+
+    const cwd = await ctx.getProjectDir({ cwd: input.configPath });
+
+    if (!cwd.ok) {
+      return respondWithError(cwd.error);
+    }
+
+    const auth = await ctx.getAuth();
+
+    const args = ["dev", "--api-url", auth.auth.apiUrl, "--skip-mcp-install"];
+
+    if (ctx.options.profile) {
+      args.push("--profile", ctx.options.profile);
+    }
+
+    const [nodePath, cliPath] = await resolveCLIExec(ctx, cwd.cwd);
+
+    ctx.logger?.log("start_dev_server args", { nodePath, cliPath, args, cwd: cwd.cwd });
+
+    // Reset state
+    devState = "starting";
+    devLogs = [];
+    devCwd = cwd.cwd;
+
+    devProcess = x(nodePath, [cliPath, ...args], {
+      nodeOptions: {
+        cwd: cwd.cwd,
+        env: {
+          TRIGGER_MCP_SERVER: "1",
+        },
+      },
+    });
+
+    // Stream output in the background
+    const myProcess = devProcess;
+    const readOutput = async () => {
+      try {
+        for await (const line of myProcess) {
+          const clean = stripAnsi(line);
+          pushLog(clean);
+
+          if (clean.includes("Local worker ready")) {
+            devState = "ready";
+          }
+
+          if (clean.includes("Build failed")) {
+            devState = "error";
+          }
+        }
+      } catch {
+        // Process ended
+      }
+
+      // Only update module state if no new server has been started since
+      if (devProcess !== myProcess) {
+        return;
+      }
+
+      const exitCode = myProcess.exitCode;
+      if (devState !== "error") {
+        devState = "stopped";
+      }
+      pushLog(`[process exited with code ${exitCode ?? "unknown"}]`);
+      devProcess = null;
+    };
+
+    // Don't await — let it run in the background
+    readOutput();
+
+    // Wait up to 30s for "ready" or "error"
+    const startTime = Date.now();
+    const TIMEOUT_MS = 30_000;
+
+    while (Date.now() - startTime < TIMEOUT_MS) {
+      const state = getDevState();
+      if (state === "ready" || state === "error" || state === "stopped") {
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+
+    const recentLogs = devLogs.slice(-30).join("\n");
+    const finalState = getDevState();
+
+    if (finalState === "ready") {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Dev server is ready.\n\n\`\`\`\n${recentLogs}\n\`\`\``,
+          },
+        ],
+      };
+    }
+
+    if (finalState === "error") {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Dev server started but has build errors:\n\n\`\`\`\n${recentLogs}\n\`\`\``,
+          },
+        ],
+      };
+    }
+
+    if (finalState === "starting") {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Dev server is still starting (timed out after 30s). Use \`dev_server_status\` to check progress.\n\n\`\`\`\n${recentLogs}\n\`\`\``,
+          },
+        ],
+      };
+    }
+
+    return respondWithError(`Dev server stopped unexpectedly:\n${recentLogs}`);
+  }),
+};
+
+export const stopDevServerTool = {
+  name: toolsMetadata.stop_dev_server.name,
+  title: toolsMetadata.stop_dev_server.title,
+  description: toolsMetadata.stop_dev_server.description,
+  inputSchema: {},
+  handler: toolHandler({}, async (_input, { ctx }) => {
+    ctx.logger?.log("calling stop_dev_server");
+
+    if (!devProcess || devState === "stopped") {
+      return {
+        content: [{ type: "text" as const, text: "Dev server is not running." }],
+      };
+    }
+
+    devProcess.kill();
+    devState = "stopped";
+    devProcess = null;
+
+    return {
+      content: [{ type: "text" as const, text: "Dev server stopped." }],
+    };
+  }),
+};
+
+export const devServerStatusTool = {
+  name: toolsMetadata.dev_server_status.name,
+  title: toolsMetadata.dev_server_status.title,
+  description: toolsMetadata.dev_server_status.description,
+  inputSchema: {
+    lines: z
+      .number()
+      .int()
+      .default(50)
+      .describe("Number of recent log lines to return. Defaults to 50."),
+  },
+  handler: toolHandler(
+    {
+      lines: z.number().int().default(50),
+    },
+    async (input, { ctx }) => {
+      ctx.logger?.log("calling dev_server_status");
+
+      const recentLogs = devLogs.slice(-input.lines).join("\n");
+
+      const content = [
+        `## Dev Server Status: ${devState}`,
+        "",
+      ];
+
+      if (devCwd) {
+        content.push(`**Directory:** ${devCwd}`);
+      }
+
+      content.push(`**Log buffer:** ${devLogs.length} lines`);
+      content.push("");
+
+      if (recentLogs) {
+        content.push("```");
+        content.push(recentLogs);
+        content.push("```");
+      } else {
+        content.push("_No output yet_");
+      }
+
+      return {
+        content: [{ type: "text" as const, text: content.join("\n") }],
+      };
+    }
+  ),
+};
diff --git a/packages/cli-v3/src/mcp/tools/previewBranches.ts b/packages/cli-v3/src/mcp/tools/previewBranches.ts
index abadda29ab3..90cfcc3cc13 100644
--- a/packages/cli-v3/src/mcp/tools/previewBranches.ts
+++ b/packages/cli-v3/src/mcp/tools/previewBranches.ts
@@ -28,8 +28,22 @@ export const listPreviewBranchesTool = {
       return respondWithError(branches.error);
     }
 
+    const lines: string[] = [];
+    const branchList = branches.data.branches;
+
+    if (branchList.length === 0) {
+      lines.push("No preview branches found.");
+    } else {
+      lines.push(`Found ${branchList.length} preview branch${branchList.length === 1 ? "" : "es"}`);
+      lines.push("");
+      for (const branch of branchList) {
+        const paused = branch.isPaused ? " (paused)" : "";
+        lines.push(`- ${branch.name}${paused}`);
+      }
+    }
+
     return {
-      content: [{ type: "text", text: JSON.stringify(branches.data, null, 2) }],
+      content: [{ type: "text", text: lines.join("\n") }],
     };
   }),
 };
diff --git a/packages/cli-v3/src/mcp/tools/profiles.ts b/packages/cli-v3/src/mcp/tools/profiles.ts
new file mode 100644
index 00000000000..56dfab7e331
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools/profiles.ts
@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { toolsMetadata } from "../config.js";
+import { respondWithError, toolHandler } from "../utils.js";
+import {
+  listAuthConfigProfiles,
+  readAuthConfigProfile,
+  readAuthConfigCurrentProfileName,
+} from "../../utilities/configFiles.js";
+
+export const whoamiTool = {
+  name: toolsMetadata.whoami.name,
+  title: toolsMetadata.whoami.title,
+  description: toolsMetadata.whoami.description,
+  inputSchema: {},
+  handler: toolHandler({}, async (_input, { ctx }) => {
+    ctx.logger?.log("calling whoami");
+
+    try {
+      const auth = await ctx.getAuth();
+
+      const content = [
+        "## Current Session",
+        "",
+        `**Profile:** ${auth.profile}`,
+        `**Email:** ${auth.email}`,
+        `**User ID:** ${auth.userId}`,
+        `**API URL:** ${auth.auth.apiUrl}`,
+        `**Dashboard:** ${auth.dashboardUrl}`,
+      ];
+
+      return {
+        content: [{ type: "text" as const, text: content.join("\n") }],
+      };
+    } catch (error) {
+      return respondWithError("Not authenticated. Use an authenticated tool to trigger login.");
+    }
+  }),
+};
+
+export const listProfilesTool = {
+  name: toolsMetadata.list_profiles.name,
+  title: toolsMetadata.list_profiles.title,
+  description: toolsMetadata.list_profiles.description,
+  inputSchema: {},
+  handler: toolHandler({}, async (_input, { ctx }) => {
+    ctx.logger?.log("calling list_profiles");
+
+    const profiles = listAuthConfigProfiles();
+    const currentProfile = ctx.options.profile ?? readAuthConfigCurrentProfileName();
+
+    if (profiles.length === 0) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No profiles configured. Use an authenticated tool to trigger login and create a profile.",
+          },
+        ],
+      };
+    }
+
+    const content = ["## CLI Profiles", ""];
+
+    for (const name of profiles) {
+      const config = readAuthConfigProfile(name);
+      const isCurrent = name === currentProfile;
+      const marker = isCurrent ? " (active)" : "";
+      const apiUrl = config?.apiUrl ?? "https://cloud.trigger.dev";
+
+      content.push(`- **${name}**${marker} — ${apiUrl}`);
+    }
+
+    content.push("");
+    content.push(
+      "Use `switch_profile` to change the active profile for this session."
+    );
+
+    return {
+      content: [{ type: "text" as const, text: content.join("\n") }],
+    };
+  }),
+};
+
+const SwitchProfileInput = {
+  profile: z
+    .string()
+    .describe("The profile name to switch to. Use list_profiles to see available profiles."),
+};
+
+export const switchProfileTool = {
+  name: toolsMetadata.switch_profile.name,
+  title: toolsMetadata.switch_profile.title,
+  description: toolsMetadata.switch_profile.description,
+  inputSchema: SwitchProfileInput,
+  handler: toolHandler(SwitchProfileInput, async (input, { ctx }) => {
+    ctx.logger?.log("calling switch_profile", { input });
+
+    const profiles = listAuthConfigProfiles();
+
+    if (!profiles.includes(input.profile)) {
+      const available = profiles.length > 0 ? profiles.join(", ") : "(none)";
+      return respondWithError(
+        `Profile "${input.profile}" not found. Available profiles: ${available}`
+      );
+    }
+
+    const previousProfile = ctx.options.profile ?? readAuthConfigCurrentProfileName();
+    const projectDir = await ctx.getCwd();
+
+    // Switch in-memory first (don't persist until auth succeeds)
+    ctx.switchProfile(input.profile);
+
+    // Verify the new profile works by fetching auth
+    try {
+      const auth = await ctx.getAuth();
+
+      // Auth succeeded — now persist to project config
+      if (projectDir) {
+        ctx.switchProfile(input.profile, projectDir);
+      }
+
+      const persisted = projectDir ? " (saved to project)" : " (session only)";
+
+      const content = [
+        `Switched from **${previousProfile}** to **${input.profile}**${persisted}`,
+        "",
+        `**Email:** ${auth.email}`,
+        `**API URL:** ${auth.auth.apiUrl}`,
+      ];
+
+      return {
+        content: [{ type: "text" as const, text: content.join("\n") }],
+      };
+    } catch (error) {
+      // Revert in-memory only (nothing was persisted)
+      ctx.switchProfile(previousProfile);
+      return respondWithError(
+        `Failed to authenticate with profile "${input.profile}". Reverted to "${previousProfile}".`
+      );
+    }
+  }),
+};
diff --git a/packages/cli-v3/src/mcp/tools/prompts.ts b/packages/cli-v3/src/mcp/tools/prompts.ts
new file mode 100644
index 00000000000..7c23f64c24b
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools/prompts.ts
@@ -0,0 +1,330 @@
+import { z } from "zod";
+import { toolsMetadata } from "../config.js";
+import { CommonProjectsInput } from "../schemas.js";
+import { respondWithError, toolHandler } from "../utils.js";
+
+// ---------------------------------------------------------------------------
+// Input schemas
+// ---------------------------------------------------------------------------
+
+const ListPromptsInput = CommonProjectsInput;
+
+const PromptSlugInput = CommonProjectsInput.extend({
+  slug: z.string().describe("The prompt slug"),
+});
+
+const PromoteInput = CommonProjectsInput.extend({
+  slug: z.string().describe("The prompt slug"),
+  version: z.coerce.number().int().positive().describe("The version number to promote to current"),
+});
+
+const CreateOverrideInput = CommonProjectsInput.extend({
+  slug: z.string().describe("The prompt slug"),
+  textContent: z.string().describe("The full text content for the override"),
+  model: z.string().optional().describe("Optional model override"),
+  commitMessage: z.string().optional().describe("Optional commit message describing the change"),
+});
+
+const UpdateOverrideInput = CommonProjectsInput.extend({
+  slug: z.string().describe("The prompt slug"),
+  textContent: z.string().optional().describe("Updated text content"),
+  model: z.string().optional().describe("Updated model"),
+  commitMessage: z.string().optional().describe("Commit message describing the change"),
+});
+
+const RemoveOverrideInput = PromptSlugInput;
+
+const ReactivateOverrideInput = CommonProjectsInput.extend({
+  slug: z.string().describe("The prompt slug"),
+  version: z
+    .coerce.number()
+    .int()
+    .positive()
+    .describe("The dashboard-sourced version number to reactivate as override"),
+});
+
+// ---------------------------------------------------------------------------
+// Read tools
+// ---------------------------------------------------------------------------
+
+export const listPromptsTool = {
+  name: toolsMetadata.list_prompts.name,
+  title: toolsMetadata.list_prompts.title,
+  description: toolsMetadata.list_prompts.description,
+  inputSchema: ListPromptsInput.shape,
+  handler: toolHandler(ListPromptsInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:prompts"],
+      branch: input.branch,
+    });
+
+    const result = await apiClient.listPrompts();
+
+    if (result.data.length === 0) {
+      return { content: [{ type: "text" as const, text: "No prompts found." }] };
+    }
+
+    const lines = ["## Prompts\n"];
+    for (const p of result.data) {
+      const status = p.hasOverride ? " (override active)" : "";
+      const version = p.currentVersion != null ? `v${p.currentVersion}` : "no current";
+      lines.push(`- **${p.slug}** — ${version}${status}`);
+      if (p.description) lines.push(`  ${p.description}`);
+      if (p.defaultModel) lines.push(`  Model: ${p.defaultModel}`);
+    }
+
+    return { content: [{ type: "text" as const, text: lines.join("\n") }] };
+  }),
+};
+
+export const getPromptVersionsTool = {
+  name: toolsMetadata.get_prompt_versions.name,
+  title: toolsMetadata.get_prompt_versions.title,
+  description: toolsMetadata.get_prompt_versions.description,
+  inputSchema: PromptSlugInput.shape,
+  handler: toolHandler(PromptSlugInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:prompts"],
+      branch: input.branch,
+    });
+
+    const result = await apiClient.listPromptVersions(input.slug);
+
+    if (result.data.length === 0) {
+      return { content: [{ type: "text" as const, text: "No versions found." }] };
+    }
+
+    const lines = [`## Versions for "${input.slug}"\n`];
+    for (const v of result.data) {
+      const labels = v.labels.length > 0 ? ` [${v.labels.join(", ")}]` : "";
+      const model = v.model ? ` · ${v.model}` : "";
+      const msg = v.commitMessage ? ` — "${v.commitMessage}"` : "";
+      lines.push(`- **v${v.version}**${labels} (${v.source})${model}${msg}`);
+      if (v.textContent) {
+        const preview =
+          v.textContent.length > 120 ? v.textContent.slice(0, 120) + "..." : v.textContent;
+        lines.push(`  Content: ${preview}`);
+      }
+    }
+
+    return { content: [{ type: "text" as const, text: lines.join("\n") }] };
+  }),
+};
+
+// ---------------------------------------------------------------------------
+// Write tools
+// ---------------------------------------------------------------------------
+
+export const promotePromptVersionTool = {
+  name: toolsMetadata.promote_prompt_version.name,
+  title: toolsMetadata.promote_prompt_version.title,
+  description: toolsMetadata.promote_prompt_version.description,
+  inputSchema: PromoteInput.shape,
+  handler: toolHandler(PromoteInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["admin"],
+      branch: input.branch,
+    });
+
+    await apiClient.promotePromptVersion(input.slug, { version: input.version });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Promoted "${input.slug}" v${input.version} to current.`,
+        },
+      ],
+    };
+  }),
+};
+
+export const createPromptOverrideTool = {
+  name: toolsMetadata.create_prompt_override.name,
+  title: toolsMetadata.create_prompt_override.title,
+  description: toolsMetadata.create_prompt_override.description,
+  inputSchema: CreateOverrideInput.shape,
+  handler: toolHandler(CreateOverrideInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["admin"],
+      branch: input.branch,
+    });
+
+    const result = await apiClient.createPromptOverride(input.slug, {
+      textContent: input.textContent,
+      model: input.model,
+      commitMessage: input.commitMessage,
+      source: "mcp",
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Created override for "${input.slug}" as v${result.version}.`,
+        },
+      ],
+    };
+  }),
+};
+
+export const updatePromptOverrideTool = {
+  name: toolsMetadata.update_prompt_override.name,
+  title: toolsMetadata.update_prompt_override.title,
+  description: toolsMetadata.update_prompt_override.description,
+  inputSchema: UpdateOverrideInput.shape,
+  handler: toolHandler(UpdateOverrideInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["admin"],
+      branch: input.branch,
+    });
+
+    await apiClient.updatePromptOverride(input.slug, {
+      textContent: input.textContent,
+      model: input.model,
+      commitMessage: input.commitMessage,
+    });
+
+    return {
+      content: [
+        { type: "text" as const, text: `Updated override for "${input.slug}".` },
+      ],
+    };
+  }),
+};
+
+export const removePromptOverrideTool = {
+  name: toolsMetadata.remove_prompt_override.name,
+  title: toolsMetadata.remove_prompt_override.title,
+  description: toolsMetadata.remove_prompt_override.description,
+  inputSchema: RemoveOverrideInput.shape,
+  handler: toolHandler(RemoveOverrideInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["admin"],
+      branch: input.branch,
+    });
+
+    await apiClient.removePromptOverride(input.slug);
+
+    return {
+      content: [
+        { type: "text" as const, text: `Removed override for "${input.slug}".` },
+      ],
+    };
+  }),
+};
+
+export const reactivatePromptOverrideTool = {
+  name: toolsMetadata.reactivate_prompt_override.name,
+  title: toolsMetadata.reactivate_prompt_override.title,
+  description: toolsMetadata.reactivate_prompt_override.description,
+  inputSchema: ReactivateOverrideInput.shape,
+  handler: toolHandler(ReactivateOverrideInput.shape, async (input, { ctx }) => {
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["admin"],
+      branch: input.branch,
+    });
+
+    await apiClient.reactivatePromptOverride(input.slug, { version: input.version });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Reactivated v${input.version} as override for "${input.slug}".`,
+        },
+      ],
+    };
+  }),
+};
diff --git a/packages/cli-v3/src/mcp/tools/query.ts b/packages/cli-v3/src/mcp/tools/query.ts
new file mode 100644
index 00000000000..e09cb9d9048
--- /dev/null
+++ b/packages/cli-v3/src/mcp/tools/query.ts
@@ -0,0 +1,158 @@
+import type { QuerySchemaResponseBody, QuerySchemaTable } from "@trigger.dev/core/v3/schemas";
+import { toolsMetadata } from "../config.js";
+import { formatQueryResults } from "../formatters.js";
+import { QueryInput, QuerySchemaInput } from "../schemas.js";
+import { respondWithError, toolHandler } from "../utils.js";
+
+// Cache query schema keyed by project/environment (rarely changes)
+const schemaCache = new Map<string, { data: QuerySchemaResponseBody; expiresAt: number }>();
+const SCHEMA_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+export const queryTool = {
+  name: toolsMetadata.query.name,
+  title: toolsMetadata.query.title,
+  description: toolsMetadata.query.description,
+  inputSchema: QueryInput.shape,
+  handler: toolHandler(QueryInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling query", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:query"],
+      branch: input.branch,
+    });
+
+    const result = await apiClient.executeQuery(input.query, {
+      scope: input.scope,
+      period: input.period,
+      from: input.from,
+      to: input.to,
+      format: "json",
+    });
+
+    if (result.format === "json") {
+      const rowCount = result.results.length;
+      const formatted = formatQueryResults(result.results as Record<string, unknown>[]);
+
+      const content = [
+        `## Query Results (${rowCount} row${rowCount === 1 ? "" : "s"})`,
+        "",
+        formatted,
+      ];
+
+      return {
+        content: [{ type: "text" as const, text: content.join("\n") }],
+      };
+    }
+
+    return {
+      content: [{ type: "text" as const, text: result.results }],
+    };
+  }),
+};
+
+function formatSchemaTable(table: QuerySchemaTable): string {
+  const lines: string[] = [];
+
+  lines.push(`### ${table.name}`);
+  if (table.description) {
+    lines.push(table.description);
+  }
+  if (table.timeColumn) {
+    lines.push(`**Time column:** \`${table.timeColumn}\``);
+  }
+  lines.push("");
+
+  // Format columns as a table
+  lines.push("| Column | Type | Description |");
+  lines.push("|--------|------|-------------|");
+
+  for (const col of table.columns) {
+    const parts: string[] = [];
+
+    if (col.description) {
+      parts.push(col.description);
+    }
+    if (col.allowedValues && col.allowedValues.length > 0) {
+      parts.push(`Values: ${col.allowedValues.join(", ")}`);
+    }
+    if (col.example) {
+      parts.push(`e.g. \`${col.example}\``);
+    }
+
+    const core = col.coreColumn ? " *" : "";
+    const desc = parts.join(". ").replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+
+    lines.push(`| \`${col.name}\`${core} | ${col.type} | ${desc} |`);
+  }
+
+  lines.push("");
+  lines.push("\\* = core column (included in default queries)");
+
+  return lines.join("\n");
+}
+
+export const getQuerySchemaTool = {
+  name: toolsMetadata.get_query_schema.name,
+  title: toolsMetadata.get_query_schema.title,
+  description: toolsMetadata.get_query_schema.description,
+  inputSchema: QuerySchemaInput.shape,
+  handler: toolHandler(QuerySchemaInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling get_query_schema", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: ["read:query"],
+      branch: input.branch,
+    });
+
+    const cacheKey = `${projectRef}:${input.environment}:${input.branch ?? ""}`;
+    const cached = schemaCache.get(cacheKey);
+    let schema: QuerySchemaResponseBody;
+    if (cached && Date.now() < cached.expiresAt) {
+      schema = cached.data;
+    } else {
+      schema = await apiClient.getQuerySchema();
+      schemaCache.set(cacheKey, { data: schema, expiresAt: Date.now() + SCHEMA_CACHE_TTL_MS });
+    }
+
+    const table = schema.tables.find((t) => t.name === input.table);
+
+    if (!table) {
+      const available = schema.tables.map((t) => `${t.name} (${t.description ?? ""})`).join(", ");
+      return respondWithError(
+        `Table "${input.table}" not found. Available tables: ${available}`
+      );
+    }
+
+    const content = [formatSchemaTable(table)];
+
+    return {
+      content: [{ type: "text" as const, text: content.join("\n") }],
+    };
+  }),
+};
diff --git a/packages/cli-v3/src/mcp/tools/runs.ts b/packages/cli-v3/src/mcp/tools/runs.ts
index 13fe601da0e..5b576cfc41d 100644
--- a/packages/cli-v3/src/mcp/tools/runs.ts
+++ b/packages/cli-v3/src/mcp/tools/runs.ts
@@ -1,9 +1,45 @@
 import { AnyRunShape } from "@trigger.dev/core/v3";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { toolsMetadata } from "../config.js";
-import { formatRun, formatRunList, formatRunShape, formatRunTrace } from "../formatters.js";
-import { CommonRunsInput, GetRunDetailsInput, ListRunsInput } from "../schemas.js";
+import { formatRun, formatRunList, formatRunShape, formatRunTrace, formatSpanDetail } from "../formatters.js";
+import { CommonRunsInput, GetRunDetailsInput, GetSpanDetailsInput, ListRunsInput, WaitForRunInput } from "../schemas.js";
 import { respondWithError, toolHandler } from "../utils.js";
 
+// Cache formatted traces in temp files keyed by runId.
+// Each entry stores the file path and total line count.
+const traceCache = new Map<string, { filePath: string; totalLines: number; expiresAt: number }>();
+const TRACE_CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+function getTraceCacheDir(): string {
+  const dir = path.join(os.tmpdir(), "trigger-mcp-traces");
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+/** Read a page of lines from a file. Returns the lines and whether there are more. */
+function readLinesPage(
+  filePath: string,
+  offset: number,
+  limit: number,
+  totalLines: number
+): { lines: string[]; hasMore: boolean; nextCursor: string | null } {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const allLines = content.split("\n");
+  const pageLines = allLines.slice(offset, offset + limit);
+  const end = offset + limit;
+  const hasMore = end < totalLines;
+
+  return {
+    lines: pageLines,
+    hasMore,
+    nextCursor: hasMore ? String(end) : null,
+  };
+}
+
 export const getRunDetailsTool = {
   name: toolsMetadata.get_run_details.name,
   title: toolsMetadata.get_run_details.title,
@@ -30,25 +66,98 @@ export const getRunDetailsTool = {
       branch: input.branch,
     });
 
-    const [runResult, traceResult] = await Promise.all([
-      apiClient.retrieveRun(input.runId),
-      apiClient.retrieveRunTrace(input.runId),
-    ]);
+    const limit = input.maxTraceLines;
+    const offset = input.cursor ? parseInt(input.cursor, 10) : 0;
+
+    // Check if we have a cached trace file for this run
+    let cached = traceCache.get(input.runId);
+    if (cached && Date.now() >= cached.expiresAt) {
+      // Expired — clean up
+      try {
+        fs.unlinkSync(cached.filePath);
+      } catch {}
+      traceCache.delete(input.runId);
+      cached = undefined;
+    }
 
-    const formattedRun = formatRun(runResult);
-    const formattedTrace = formatRunTrace(traceResult.trace, input.maxTraceLines);
+    let formattedRun: string | undefined;
+    let runUrl: string | undefined;
+
+    if (!cached) {
+      // Fetch and cache the full trace
+      const [runResult, traceResult] = await Promise.all([
+        apiClient.retrieveRun(input.runId),
+        apiClient.retrieveRunTrace(input.runId),
+      ]);
+
+      formattedRun = formatRun(runResult);
+      runUrl = await ctx.getDashboardUrl(`/projects/v3/${projectRef}/runs/${runResult.id}`);
+
+      // Format the full trace (no line limit — we're writing to a file)
+      const fullTrace = formatRunTrace(traceResult.trace, Infinity);
+      const traceLines = fullTrace.split("\n");
+
+      // Write to temp file
+      const filePath = path.join(getTraceCacheDir(), `${input.runId}.txt`);
+      fs.writeFileSync(filePath, fullTrace, "utf-8");
+
+      // Only cache runs in terminal states — active runs need fresh traces
+      const terminalStatuses = new Set([
+        "COMPLETED",
+        "CANCELED",
+        "FAILED",
+        "CRASHED",
+        "SYSTEM_FAILURE",
+        "EXPIRED",
+        "TIMED_OUT",
+      ]);
+
+      cached = {
+        filePath,
+        totalLines: traceLines.length,
+        expiresAt: Date.now() + TRACE_CACHE_TTL_MS,
+      };
+
+      if (terminalStatuses.has(runResult.status)) {
+        traceCache.set(input.runId, cached);
+      }
+    }
 
-    const runUrl = await ctx.getDashboardUrl(`/projects/v3/${projectRef}/runs/${runResult.id}`);
+    // Read the requested page
+    const page = readLinesPage(cached.filePath, offset, limit, cached.totalLines);
 
-    const content = [
-      "## Run Details",
-      formattedRun,
-      "",
-      "## Run Trace",
-      formattedTrace,
-      "",
-      `[View in dashboard](${runUrl})`,
-    ];
+    const content: string[] = [];
+
+    // Only include run details on the first page
+    if (offset === 0) {
+      if (!formattedRun) {
+        // Cursor pagination — fetch run details for context
+        const runResult = await apiClient.retrieveRun(input.runId);
+        formattedRun = formatRun(runResult);
+        runUrl = await ctx.getDashboardUrl(`/projects/v3/${projectRef}/runs/${runResult.id}`);
+      }
+
+      content.push("## Run Details");
+      content.push(formattedRun);
+      content.push("");
+    }
+
+    content.push(
+      `## Run Trace (lines ${offset + 1}-${offset + page.lines.length} of ${cached.totalLines})`
+    );
+    content.push(page.lines.join("\n"));
+
+    if (page.hasMore) {
+      content.push("");
+      content.push(
+        `**More trace available.** Call \`get_run_details\` again with \`cursor: "${page.nextCursor}"\` and \`runId: "${input.runId}"\` to see the next page.`
+      );
+    }
+
+    if (runUrl && offset === 0) {
+      content.push("");
+      content.push(`[View in dashboard](${runUrl})`);
+    }
 
     return {
       content: [
@@ -61,12 +170,57 @@ export const getRunDetailsTool = {
   }),
 };
 
+export const getSpanDetailsTool = {
+  name: toolsMetadata.get_span_details.name,
+  title: toolsMetadata.get_span_details.title,
+  description: toolsMetadata.get_span_details.description,
+  inputSchema: GetSpanDetailsInput.shape,
+  handler: toolHandler(GetSpanDetailsInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling get_span_details", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const apiClient = await ctx.getApiClient({
+      projectRef,
+      environment: input.environment,
+      scopes: [`read:runs:${input.runId}`],
+      branch: input.branch,
+    });
+
+    const spanDetail = await apiClient.retrieveSpan(input.runId, input.spanId);
+    const formatted = formatSpanDetail(spanDetail);
+
+    const runUrl = await ctx.getDashboardUrl(
+      `/projects/v3/${projectRef}/runs/${input.runId}`
+    );
+
+    const content = [formatted];
+    if (runUrl) {
+      content.push("");
+      content.push(`[View run in dashboard](${runUrl})`);
+    }
+
+    return {
+      content: [{ type: "text", text: content.join("\n") }],
+    };
+  }),
+};
+
 export const waitForRunToCompleteTool = {
   name: toolsMetadata.wait_for_run_to_complete.name,
   title: toolsMetadata.wait_for_run_to_complete.title,
   description: toolsMetadata.wait_for_run_to_complete.description,
-  inputSchema: CommonRunsInput.shape,
-  handler: toolHandler(CommonRunsInput.shape, async (input, { ctx, signal }) => {
+  inputSchema: WaitForRunInput.shape,
+  handler: toolHandler(WaitForRunInput.shape, async (input, { ctx, signal }) => {
     ctx.logger?.log("calling wait_for_run_to_complete", { input });
 
     if (ctx.options.devOnly && input.environment !== "dev") {
@@ -87,20 +241,35 @@ export const waitForRunToCompleteTool = {
       branch: input.branch,
     });
 
-    const runSubscription = apiClient.subscribeToRun(input.runId, { signal });
+    const timeoutMs = input.timeoutInSeconds * 1000;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = signal
+      ? AbortSignal.any([signal, timeoutSignal])
+      : timeoutSignal;
+
+    const runSubscription = apiClient.subscribeToRun(input.runId, { signal: combinedSignal });
     const readableStream = runSubscription.getReader();
 
     let run: AnyRunShape | null = null;
-
-    while (true) {
-      const { done, value } = await readableStream.read();
-      if (done) {
-        break;
+    let timedOut = false;
+
+    try {
+      while (true) {
+        const { done, value } = await readableStream.read();
+        if (done) {
+          break;
+        }
+        run = value;
+
+        if (value.isCompleted) {
+          break;
+        }
       }
-      run = value;
-
-      if (value.isCompleted) {
-        break;
+    } catch (error) {
+      if (timeoutSignal.aborted) {
+        timedOut = true;
+      } else {
+        throw error;
       }
     }
 
@@ -108,8 +277,12 @@ export const waitForRunToCompleteTool = {
       return respondWithError("Run not found");
     }
 
+    const prefix = timedOut
+      ? `Timed out after ${input.timeoutInSeconds}s. Returning current run state:\n\n`
+      : "";
+
     return {
-      content: [{ type: "text", text: formatRunShape(run) }],
+      content: [{ type: "text", text: prefix + formatRunShape(run) }],
     };
   }),
 };
@@ -148,8 +321,15 @@ export const cancelRunTool = {
       `/projects/v3/${projectRef}/runs/${retrieveResult.id}`
     );
 
+    const content = [
+      `Run ${retrieveResult.id} canceled.`,
+      `Status: ${retrieveResult.status}`,
+      `Task: ${retrieveResult.taskIdentifier}`,
+      `[View in dashboard](${runUrl})`,
+    ];
+
     return {
-      content: [{ type: "text", text: JSON.stringify({ ...retrieveResult, runUrl }, null, 2) }],
+      content: [{ type: "text", text: content.join("\n") }],
     };
   }),
 };
diff --git a/packages/cli-v3/src/mcp/tools/tasks.ts b/packages/cli-v3/src/mcp/tools/tasks.ts
index 41c988ce1a7..fda3cc8943e 100644
--- a/packages/cli-v3/src/mcp/tools/tasks.ts
+++ b/packages/cli-v3/src/mcp/tools/tasks.ts
@@ -1,6 +1,6 @@
+import { z } from "zod";
 import { toolsMetadata } from "../config.js";
 import { CommonProjectsInput, TriggerTaskInput } from "../schemas.js";
-import { ToolMeta } from "../types.js";
 import { respondWithError, toolHandler } from "../utils.js";
 
 export const getCurrentWorker = {
@@ -44,16 +44,13 @@ export const getCurrentWorker = {
       contents.push(`The worker has ${worker.tasks.length} tasks registered:`);
 
       for (const task of worker.tasks) {
-        if (task.payloadSchema) {
-          contents.push(
-            `- ${task.slug} in ${task.filePath} (payload schema: ${JSON.stringify(
-              task.payloadSchema
-            )})`
-          );
-        } else {
-          contents.push(`- ${task.slug} in ${task.filePath}`);
-        }
+        contents.push(`- ${task.slug} in ${task.filePath}`);
       }
+
+      contents.push("");
+      contents.push(
+        "Use the `get_task_schema` tool with a task slug to get its payload schema."
+      );
     } else {
       contents.push(`The worker has no tasks registered.`);
     }
@@ -156,3 +153,74 @@ export const triggerTaskTool = {
     };
   }),
 };
+
+const GetTaskSchemaInput = CommonProjectsInput.extend({
+  taskSlug: z
+    .string()
+    .describe(
+      "The task slug/identifier to get the payload schema for. Use get_current_worker to see available tasks."
+    ),
+});
+
+export const getTaskSchemaTool = {
+  name: toolsMetadata.get_task_schema.name,
+  title: toolsMetadata.get_task_schema.title,
+  description: toolsMetadata.get_task_schema.description,
+  inputSchema: GetTaskSchemaInput.shape,
+  handler: toolHandler(GetTaskSchemaInput.shape, async (input, { ctx }) => {
+    ctx.logger?.log("calling get_task_schema", { input });
+
+    if (ctx.options.devOnly && input.environment !== "dev") {
+      return respondWithError(
+        `This MCP server is only available for the dev environment. You tried to access the ${input.environment} environment. Remove the --dev-only flag to access other environments.`
+      );
+    }
+
+    const projectRef = await ctx.getProjectRef({
+      projectRef: input.projectRef,
+      cwd: input.configPath,
+    });
+
+    const cliApiClient = await ctx.getCliApiClient(input.branch);
+
+    const workerResult = await cliApiClient.getWorkerByTag(
+      projectRef,
+      input.environment,
+      "current"
+    );
+
+    if (!workerResult.success) {
+      return respondWithError(workerResult.error);
+    }
+
+    const task = workerResult.data.worker.tasks.find((t) => t.slug === input.taskSlug);
+
+    if (!task) {
+      const available = workerResult.data.worker.tasks.map((t) => t.slug).join(", ");
+      return respondWithError(
+        `Task "${input.taskSlug}" not found. Available tasks: ${available}`
+      );
+    }
+
+    const content = [
+      `## ${task.slug}`,
+      "",
+      `**File:** ${task.filePath}`,
+    ];
+
+    if (task.payloadSchema) {
+      content.push("");
+      content.push("**Payload schema:**");
+      content.push("```json");
+      content.push(JSON.stringify(task.payloadSchema, null, 2));
+      content.push("```");
+    } else {
+      content.push("");
+      content.push("No payload schema defined — this task accepts any payload.");
+    }
+
+    return {
+      content: [{ type: "text", text: content.join("\n") }],
+    };
+  }),
+};
diff --git a/packages/cli-v3/src/utilities/colorMarkup.test.ts b/packages/cli-v3/src/utilities/colorMarkup.test.ts
new file mode 100644
index 00000000000..c6e64845ad2
--- /dev/null
+++ b/packages/cli-v3/src/utilities/colorMarkup.test.ts
@@ -0,0 +1,92 @@
+import { describe, it, expect } from "vitest";
+import chalk from "chalk";
+import { applyColorMarkup } from "./colorMarkup.js";
+
+// Force chalk to produce color codes in tests
+chalk.level = 3;
+
+describe("applyColorMarkup", () => {
+  it("returns plain text when no markup is present", () => {
+    expect(applyColorMarkup("Hello world")).toBe("Hello world");
+  });
+
+  it("applies fallback style to plain text when provided", () => {
+    expect(applyColorMarkup("Hello", chalk.bold)).toBe(chalk.bold("Hello"));
+  });
+
+  it("applies a single color tag", () => {
+    expect(applyColorMarkup("{red}error{/red}")).toBe(chalk.red("error"));
+  });
+
+  it("applies color to a portion of text", () => {
+    const result = applyColorMarkup("Status: {green}OK{/green}");
+    expect(result).toBe("Status: " + chalk.green("OK"));
+  });
+
+  it("applies multiple color regions", () => {
+    const result = applyColorMarkup("{red}bad{/red} and {green}good{/green}");
+    expect(result).toBe(chalk.red("bad") + " and " + chalk.green("good"));
+  });
+
+  it("applies bold tag", () => {
+    expect(applyColorMarkup("{bold}important{/bold}")).toBe(chalk.bold("important"));
+  });
+
+  it("applies fallback to non-tagged text only", () => {
+    const result = applyColorMarkup("Please {red}upgrade{/red} now", chalk.bold);
+    expect(result).toBe(chalk.bold("Please ") + chalk.red("upgrade") + chalk.bold(" now"));
+  });
+
+  it("passes through invalid tag names as literal text", () => {
+    expect(applyColorMarkup("Hello {foo}world{/foo}")).toBe("Hello {foo}world{/foo}");
+  });
+
+  it("passes through braces with non-tag content", () => {
+    expect(applyColorMarkup("Use {curly} braces")).toBe("Use {curly} braces");
+  });
+
+  it("falls back on unclosed tag", () => {
+    const result = applyColorMarkup("{red}oops", chalk.bold);
+    expect(result).toBe(chalk.bold("{red}oops"));
+  });
+
+  it("falls back on mismatched close tag", () => {
+    const result = applyColorMarkup("{red}text{/green}", chalk.bold);
+    expect(result).toBe(chalk.bold("{red}text{/green}"));
+  });
+
+  it("falls back on nested tags", () => {
+    const result = applyColorMarkup("{red}{bold}nested{/bold}{/red}", chalk.bold);
+    expect(result).toBe(chalk.bold("{red}{bold}nested{/bold}{/red}"));
+  });
+
+  it("falls back on close tag without open", () => {
+    const result = applyColorMarkup("text{/red}");
+    expect(result).toBe("text{/red}");
+  });
+
+  it("handles empty string", () => {
+    expect(applyColorMarkup("")).toBe("");
+  });
+
+  it("handles tag with empty content", () => {
+    expect(applyColorMarkup("{red}{/red}")).toBe(chalk.red(""));
+  });
+
+  it("handles all valid color tags", () => {
+    const tags = [
+      "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray",
+      "redBright", "greenBright", "yellowBright", "blueBright",
+      "magentaBright", "cyanBright", "whiteBright",
+    ];
+    for (const tag of tags) {
+      const result = applyColorMarkup(`{${tag}}test{/${tag}}`);
+      const expected = (chalk as Record<string, (s: string) => string>)[tag]("test");
+      expect(result).toBe(expected);
+    }
+  });
+
+  it("handles text with only braces but no valid tags", () => {
+    expect(applyColorMarkup("{} and {/}")).toBe("{} and {/}");
+  });
+});
diff --git a/packages/cli-v3/src/utilities/colorMarkup.ts b/packages/cli-v3/src/utilities/colorMarkup.ts
new file mode 100644
index 00000000000..17c45eea3f6
--- /dev/null
+++ b/packages/cli-v3/src/utilities/colorMarkup.ts
@@ -0,0 +1,139 @@
+import chalk from "chalk";
+
+const VALID_TAGS = new Set([
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "gray",
+  "redBright",
+  "greenBright",
+  "yellowBright",
+  "blueBright",
+  "magentaBright",
+  "cyanBright",
+  "whiteBright",
+  "bold",
+]);
+
+type Token = { type: "text"; value: string } | { type: "styled"; tag: string; value: string };
+
+/**
+ * Parse `{tag}text{/tag}` markup and apply chalk colors.
+ * On malformed input (unclosed, mismatched, or nested tags), returns the entire
+ * string styled with `fallbackStyle` (or unstyled if no fallback).
+ */
+export function applyColorMarkup(
+  text: string,
+  fallbackStyle?: (t: string) => string
+): string {
+  const tokens = tokenize(text);
+  if (!tokens) {
+    // Malformed markup — apply fallback to entire string
+    return fallbackStyle ? fallbackStyle(text) : text;
+  }
+
+  if (tokens.length === 0) return "";
+
+  return tokens
+    .map((token) => {
+      if (token.type === "text") {
+        return fallbackStyle ? fallbackStyle(token.value) : token.value;
+      }
+      const colorFn = (chalk as unknown as Record<string, unknown>)[token.tag];
+      if (typeof colorFn === "function") {
+        return (colorFn as (t: string) => string)(token.value);
+      }
+      return fallbackStyle ? fallbackStyle(token.value) : token.value;
+    })
+    .join("");
+}
+
+/**
+ * Tokenize a string with `{tag}...{/tag}` markup.
+ * Returns null if the markup is malformed (unclosed, mismatched, or nested tags).
+ * Braces with unrecognized tag names pass through as literal text.
+ */
+function tokenize(text: string): Token[] | null {
+  const tokens: Token[] = [];
+  let pos = 0;
+  let currentText = "";
+  let insideTag: string | null = null;
+
+  while (pos < text.length) {
+    const braceIdx = text.indexOf("{", pos);
+
+    if (braceIdx === -1) {
+      currentText += text.slice(pos);
+      break;
+    }
+
+    const closeIdx = text.indexOf("}", braceIdx);
+    if (closeIdx === -1) {
+      // No closing brace — treat rest as literal
+      currentText += text.slice(pos);
+      break;
+    }
+
+    const tagContent = text.slice(braceIdx + 1, closeIdx);
+
+    // Check for closing tag
+    if (tagContent.startsWith("/")) {
+      const closingName = tagContent.slice(1);
+
+      if (VALID_TAGS.has(closingName)) {
+        if (insideTag === null) {
+          // Close tag without open — malformed
+          return null;
+        }
+        if (insideTag !== closingName) {
+          // Mismatched close — malformed
+          return null;
+        }
+
+        // Add text before this brace to the styled content
+        currentText += text.slice(pos, braceIdx);
+        tokens.push({ type: "styled", tag: insideTag, value: currentText });
+        currentText = "";
+        insideTag = null;
+        pos = closeIdx + 1;
+        continue;
+      }
+    }
+
+    // Check for opening tag
+    if (VALID_TAGS.has(tagContent)) {
+      if (insideTag !== null) {
+        // Nesting — malformed
+        return null;
+      }
+
+      currentText += text.slice(pos, braceIdx);
+      if (currentText) {
+        tokens.push({ type: "text", value: currentText });
+        currentText = "";
+      }
+      insideTag = tagContent;
+      pos = closeIdx + 1;
+      continue;
+    }
+
+    // Not a recognized tag — treat braces as literal text
+    currentText += text.slice(pos, closeIdx + 1);
+    pos = closeIdx + 1;
+  }
+
+  // If we're still inside a tag at the end, that's malformed
+  if (insideTag !== null) {
+    return null;
+  }
+
+  if (currentText) {
+    tokens.push({ type: "text", value: currentText });
+  }
+
+  return tokens;
+}
diff --git a/packages/cli-v3/src/utilities/configFiles.ts b/packages/cli-v3/src/utilities/configFiles.ts
index dfbdbf5df63..2e6455c68d1 100644
--- a/packages/cli-v3/src/utilities/configFiles.ts
+++ b/packages/cli-v3/src/utilities/configFiles.ts
@@ -92,6 +92,11 @@ export function writeAuthConfigProfile(
   writeAuthConfigFile(config);
 }
 
+export function listAuthConfigProfiles(): string[] {
+  const config = getConfig();
+  return Object.keys(config.profiles);
+}
+
 export function readAuthConfigProfile(
   profile: string = DEFFAULT_PROFILE
 ): CliConfigProfileSettings | undefined {
diff --git a/packages/cli-v3/src/utilities/discoveryCheck.test.ts b/packages/cli-v3/src/utilities/discoveryCheck.test.ts
new file mode 100644
index 00000000000..8c4b75420c1
--- /dev/null
+++ b/packages/cli-v3/src/utilities/discoveryCheck.test.ts
@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { evaluateDiscovery, type DiscoverySpec } from "./discoveryCheck.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "discovery-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("evaluateDiscovery", () => {
+  describe("show-if-found with file existence", () => {
+    it("returns true when file exists", async () => {
+      await fs.writeFile(path.join(tmpDir, "trigger.config.ts"), "export default {}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.ts"],
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("returns false when file does not exist", async () => {
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.ts"],
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(false);
+    });
+  });
+
+  describe("show-if-not-found with file existence", () => {
+    it("returns false when file exists", async () => {
+      await fs.writeFile(path.join(tmpDir, ".mcp.json"), "{}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: [".mcp.json"],
+        matchBehavior: "show-if-not-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(false);
+    });
+
+    it("returns true when file does not exist", async () => {
+      const spec: DiscoverySpec = {
+        filePatterns: [".mcp.json"],
+        matchBehavior: "show-if-not-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+  });
+
+  describe("content pattern matching", () => {
+    it("show-if-found: returns true when content matches", async () => {
+      await fs.writeFile(
+        path.join(tmpDir, "trigger.config.ts"),
+        'import { syncVercelEnvVars } from "@trigger.dev/build";'
+      );
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.ts"],
+        contentPattern: "syncVercelEnvVars",
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("show-if-found: returns false when file exists but content does not match", async () => {
+      await fs.writeFile(path.join(tmpDir, "trigger.config.ts"), "export default {}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.ts"],
+        contentPattern: "syncVercelEnvVars",
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(false);
+    });
+
+    it("show-if-not-found: returns true when file exists but content does not match", async () => {
+      await fs.writeFile(path.join(tmpDir, ".mcp.json"), '{"mcpServers": {}}');
+
+      const spec: DiscoverySpec = {
+        filePatterns: [".mcp.json"],
+        contentPattern: "trigger",
+        matchBehavior: "show-if-not-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("show-if-not-found: returns false when content matches", async () => {
+      await fs.writeFile(
+        path.join(tmpDir, ".mcp.json"),
+        '{"mcpServers": {"trigger": {"url": "https://mcp.trigger.dev"}}}'
+      );
+
+      const spec: DiscoverySpec = {
+        filePatterns: [".mcp.json"],
+        contentPattern: "trigger",
+        matchBehavior: "show-if-not-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(false);
+    });
+
+    it("supports regex content patterns", async () => {
+      await fs.writeFile(path.join(tmpDir, "config.ts"), "syncVercelEnvVars({ foo: true })");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["config.ts"],
+        contentPattern: "syncVercel\\w+",
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+  });
+
+  describe("glob patterns", () => {
+    it("matches files with glob patterns", async () => {
+      await fs.writeFile(path.join(tmpDir, "trigger.config.ts"), "export default {}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.*"],
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("matches files in subdirectories with glob", async () => {
+      await fs.mkdir(path.join(tmpDir, ".cursor"), { recursive: true });
+      await fs.writeFile(path.join(tmpDir, ".cursor", "mcp.json"), "{}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: [".cursor/mcp.json"],
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+  });
+
+  describe("multiple file patterns", () => {
+    it("returns true if any pattern matches (show-if-found)", async () => {
+      await fs.writeFile(path.join(tmpDir, "trigger.config.js"), "module.exports = {}");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["trigger.config.ts", "trigger.config.js"],
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("returns true only if no pattern matches (show-if-not-found)", async () => {
+      const spec: DiscoverySpec = {
+        filePatterns: [".mcp.json", ".cursor/mcp.json"],
+        matchBehavior: "show-if-not-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+
+    it("content match short-circuits on first matching file", async () => {
+      await fs.writeFile(path.join(tmpDir, "a.ts"), "no match here");
+      await fs.writeFile(path.join(tmpDir, "b.ts"), "syncVercelEnvVars found");
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["a.ts", "b.ts"],
+        contentPattern: "syncVercelEnvVars",
+        matchBehavior: "show-if-found",
+      };
+
+      expect(await evaluateDiscovery(spec, tmpDir)).toBe(true);
+    });
+  });
+
+  describe("error handling (fail closed)", () => {
+    it("returns false when file cannot be read for content check", async () => {
+      // Create a file then make it unreadable
+      const filePath = path.join(tmpDir, "unreadable.ts");
+      await fs.writeFile(filePath, "content");
+      await fs.chmod(filePath, 0o000);
+
+      const spec: DiscoverySpec = {
+        filePatterns: ["unreadable.ts"],
+        contentPattern: "content",
+        matchBehavior: "show-if-found",
+      };
+
+      // On some systems (e.g., running as root), chmod may not restrict reads
+      // So we just verify it doesn't throw
+      const result = await evaluateDiscovery(spec, tmpDir);
+      expect(typeof result).toBe("boolean");
+
+      // Restore permissions for cleanup
+      await fs.chmod(filePath, 0o644);
+    });
+  });
+});
diff --git a/packages/cli-v3/src/utilities/discoveryCheck.ts b/packages/cli-v3/src/utilities/discoveryCheck.ts
new file mode 100644
index 00000000000..8f0ceb46a64
--- /dev/null
+++ b/packages/cli-v3/src/utilities/discoveryCheck.ts
@@ -0,0 +1,168 @@
+import { glob, isDynamicPattern } from "tinyglobby";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { expandTilde, pathExists, readFile } from "./fileSystem.js";
+import { logger } from "./logger.js";
+import path from "node:path";
+
+export type DiscoverySpec = {
+  filePatterns: string[];
+  contentPattern?: string;
+  matchBehavior: "show-if-found" | "show-if-not-found";
+};
+
+const REGEX_METACHARACTERS = /[\\^$.|?*+(){}[\]]/;
+
+/**
+ * Evaluates a discovery spec against the local filesystem.
+ * Returns `true` if the notification should be shown, `false` otherwise.
+ * Fails closed: any error returns `false` (suppress notification).
+ */
+export async function evaluateDiscovery(
+  spec: DiscoverySpec,
+  projectRoot: string
+): Promise<boolean> {
+  const [error, result] = await tryCatch(doEvaluate(spec, projectRoot));
+
+  if (error) {
+    logger.debug("Discovery check failed, suppressing notification", { error });
+    return false;
+  }
+
+  return result;
+}
+
+async function doEvaluate(spec: DiscoverySpec, projectRoot: string): Promise<boolean> {
+  logger.debug("Discovery: starting evaluation", {
+    filePatterns: spec.filePatterns,
+    contentPattern: spec.contentPattern,
+    matchBehavior: spec.matchBehavior,
+    projectRoot,
+  });
+
+  const matchedFiles = await resolveFilePatterns(spec.filePatterns, projectRoot);
+  const hasFileMatch = matchedFiles.length > 0;
+
+  if (!hasFileMatch) {
+    const result = spec.matchBehavior === "show-if-not-found";
+    logger.debug("Discovery: no files matched any pattern", { result });
+    return result;
+  }
+
+  // Files matched — if no content pattern, decide based on file match alone
+  if (!spec.contentPattern) {
+    const result = spec.matchBehavior === "show-if-found";
+    logger.debug("Discovery: files matched, no content pattern to check", {
+      matchedFiles,
+      result,
+    });
+    return result;
+  }
+
+  // Check content in matched files
+  const hasContentMatch = await checkContentPattern(matchedFiles, spec.contentPattern);
+
+  const result =
+    spec.matchBehavior === "show-if-found" ? hasContentMatch : !hasContentMatch;
+
+  logger.debug("Discovery: evaluation complete", {
+    matchedFiles,
+    contentPattern: spec.contentPattern,
+    hasContentMatch,
+    result,
+  });
+
+  return result;
+}
+
+async function resolveFilePatterns(
+  patterns: string[],
+  projectRoot: string
+): Promise<string[]> {
+  const matched: string[] = [];
+
+  for (const pattern of patterns) {
+    const isHomeDirPattern = pattern.startsWith("~/");
+    const resolvedPattern = isHomeDirPattern ? expandTilde(pattern) : pattern;
+    const cwd = isHomeDirPattern ? "/" : projectRoot;
+    const isGlob = isDynamicPattern(resolvedPattern);
+
+    logger.debug("Discovery: resolving pattern", {
+      pattern,
+      resolvedPattern,
+      cwd,
+      isGlob,
+      isHomeDirPattern,
+    });
+
+    if (isGlob) {
+      const files = await glob({
+        patterns: [resolvedPattern],
+        cwd,
+        absolute: true,
+        dot: true,
+      });
+      if (files.length > 0) {
+        logger.debug("Discovery: glob matched files", { pattern, files });
+      }
+      matched.push(...files);
+    } else {
+      const absolutePath = isHomeDirPattern
+        ? resolvedPattern
+        : path.resolve(projectRoot, resolvedPattern);
+      const exists = await pathExists(absolutePath);
+      logger.debug("Discovery: literal path check", { pattern, absolutePath, exists });
+      if (exists) {
+        matched.push(absolutePath);
+      }
+    }
+  }
+
+  return matched;
+}
+
+async function checkContentPattern(
+  files: string[],
+  contentPattern: string
+): Promise<boolean> {
+  const useFastPath = !REGEX_METACHARACTERS.test(contentPattern);
+
+  // Pre-compile regex once outside the loop to avoid repeated compilation
+  // and to catch invalid patterns early
+  let regex: RegExp | undefined;
+  if (!useFastPath) {
+    try {
+      regex = new RegExp(contentPattern);
+    } catch (error) {
+      logger.debug("Discovery: invalid regex pattern, skipping content check", {
+        contentPattern,
+        error,
+      });
+      return false;
+    }
+  }
+
+  logger.debug("Discovery: checking content pattern", {
+    contentPattern,
+    useFastPath,
+    fileCount: files.length,
+  });
+
+  for (const filePath of files) {
+    const [error, content] = await tryCatch(readFile(filePath));
+
+    if (error) {
+      logger.debug("Discovery: failed to read file, skipping", { filePath, error });
+      continue;
+    }
+
+    const matches = useFastPath ? content.includes(contentPattern) : regex!.test(content);
+
+    logger.debug("Discovery: content check result", { filePath, matches });
+
+    if (matches) {
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/packages/cli-v3/src/utilities/fileSystem.ts b/packages/cli-v3/src/utilities/fileSystem.ts
index 87d74732eb6..e74a1184c1a 100644
--- a/packages/cli-v3/src/utilities/fileSystem.ts
+++ b/packages/cli-v3/src/utilities/fileSystem.ts
@@ -159,10 +159,26 @@ export async function safeReadJSONFile(path: string) {
   }
 }
 
+/**
+ * Use this for deterministic builds. Uses `json-stable-stringify` to sort keys alphabetically.
+ * @param path - The path to the file to write
+ * @param json - The JSON object to write
+ * @param pretty - Whether to pretty print the JSON
+ */
 export async function writeJSONFile(path: string, json: any, pretty = false) {
   await safeWriteFile(path, stringify(json, pretty ? { space: 2 } : undefined) ?? "");
 }
 
+/**
+ * Use this when you want to preserve the original key ordering (e.g. user's package.json)
+ * @param path - The path to the file to write
+ * @param json - The JSON object to write
+ * @param pretty - Whether to pretty print the JSON
+ */
+export async function writeJSONFilePreserveOrder(path: string, json: any, pretty = false) {
+  await safeWriteFile(path, JSON.stringify(json, undefined, pretty ? 2 : undefined));
+}
+
 // Will create the directory if it doesn't exist
 export async function safeWriteFile(path: string, contents: string) {
   await fsModule.mkdir(pathModule.dirname(path), { recursive: true });
diff --git a/packages/cli-v3/src/utilities/platformNotifications.ts b/packages/cli-v3/src/utilities/platformNotifications.ts
new file mode 100644
index 00000000000..cfdbc83ff48
--- /dev/null
+++ b/packages/cli-v3/src/utilities/platformNotifications.ts
@@ -0,0 +1,126 @@
+import { log } from "@clack/prompts";
+import chalk from "chalk";
+import { tryCatch } from "@trigger.dev/core/utils";
+import { CliApiClient } from "../apiClient.js";
+import { chalkGrey } from "./cliOutput.js";
+import { applyColorMarkup } from "./colorMarkup.js";
+import { evaluateDiscovery } from "./discoveryCheck.js";
+import { logger } from "./logger.js";
+import { spinner } from "./windows.js";
+
+type CliLogLevel = "info" | "warn" | "error" | "success";
+
+type PlatformNotification = {
+  level: CliLogLevel;
+  title: string;
+  description: string;
+  actionUrl?: string;
+};
+
+type FetchNotificationOptions = {
+  apiClient: CliApiClient;
+  projectRef?: string;
+  projectRoot?: string;
+};
+
+export async function fetchPlatformNotification(
+  options: FetchNotificationOptions
+): Promise<PlatformNotification | undefined> {
+  const [error, result] = await tryCatch(
+    options.apiClient.getCliPlatformNotification(
+      options.projectRef,
+      AbortSignal.timeout(7000)
+    )
+  );
+
+  if (error) {
+    logger.debug("Platform notifications failed silently", { error });
+    return undefined;
+  }
+
+  if (!result.success) {
+    logger.debug("Platform notification fetch failed", { result });
+    return undefined;
+  }
+
+  const notification = result.data.notification;
+  if (!notification) return undefined;
+
+  const { type, discovery, title, description, actionUrl } = notification.payload.data;
+
+  if (discovery) {
+    const root = options.projectRoot ?? process.cwd();
+    const shouldShow = await evaluateDiscovery(discovery, root);
+    if (!shouldShow) {
+      logger.debug("Notification suppressed by discovery check", {
+        notificationId: notification.id,
+        discovery,
+      });
+      return undefined;
+    }
+  }
+
+  return { level: type, title, description, actionUrl };
+}
+
+function displayPlatformNotification(
+  notification: PlatformNotification | undefined
+): void {
+  if (!notification) return;
+
+  const message = formatNotificationMessage(notification);
+  log[notification.level](message);
+}
+
+function formatNotificationMessage(notification: PlatformNotification): string {
+  const { title, description, actionUrl } = notification;
+  const styledTitle = applyColorMarkup(title, (t) => chalk.bold(t));
+  const styledDescription = applyColorMarkup(description, chalkGrey);
+  const lines = [styledTitle, styledDescription];
+  if (actionUrl) {
+    lines.push(chalk.underline(chalkGrey(actionUrl)));
+  }
+  return lines.join("\n");
+}
+
+const SPINNER_DELAY_MS = 200;
+
+/**
+ * Awaits a notification promise, showing a loading spinner if the fetch
+ * takes longer than 200ms. The spinner is replaced by the notification
+ * content, or removed cleanly if there's nothing to show.
+ */
+export async function awaitAndDisplayPlatformNotification(
+  notificationPromise: Promise<PlatformNotification | undefined> | undefined
+): Promise<void> {
+  if (!notificationPromise) return;
+
+  try {
+    // Race against a short delay — if the promise resolves quickly, skip the spinner
+    const pending = Symbol("pending");
+    const raceResult = await Promise.race([
+      notificationPromise,
+      new Promise<typeof pending>((resolve) =>
+        setTimeout(() => resolve(pending), SPINNER_DELAY_MS)
+      ),
+    ]);
+
+    if (raceResult !== pending) {
+      displayPlatformNotification(raceResult);
+      return;
+    }
+
+    // Still pending after delay — show a spinner while waiting
+    const $spinner = spinner();
+    $spinner.start("Checking for notifications");
+    const notification = await notificationPromise;
+
+    if (notification) {
+      $spinner.stop(formatNotificationMessage(notification));
+    } else {
+      $spinner.stop("No new notifications");
+    }
+  } catch (error) {
+    logger.debug("Platform notification display failed silently", { error });
+  }
+}
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index b364ad422f7..db5412c2081 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,59 @@
 # internal-platform
 
+## 4.4.3
+
+### Patch Changes
+
+- Auto-cancel in-flight dev runs when the CLI exits, using a detached watchdog process that survives pnpm SIGKILL ([#3191](https://github.com/triggerdotdev/trigger.dev/pull/3191))
+
+## 4.4.2
+
+## 4.4.1
+
+## 4.4.0
+
+### Patch Changes
+
+- Add `maxDelay` option to debounce feature. This allows setting a maximum time limit for how long a debounced run can be delayed, ensuring execution happens within a specified window even with continuous triggers. ([#2984](https://github.com/triggerdotdev/trigger.dev/pull/2984))
+
+  ```typescript
+  await myTask.trigger(payload, {
+    debounce: {
+      key: "my-key",
+      delay: "5s",
+      maxDelay: "30m", // Execute within 30 minutes regardless of continuous triggers
+    },
+  });
+  ```
+
+- Fixed a minor issue in the deployment command on distinguishing between local builds for the cloud vs local builds for self-hosting setups. ([#3070](https://github.com/triggerdotdev/trigger.dev/pull/3070))
+- fix: vendor superjson to fix ESM/CJS compatibility ([#2949](https://github.com/triggerdotdev/trigger.dev/pull/2949))
+
+  Bundle superjson during build to avoid `ERR_REQUIRE_ESM` errors on Node.js versions that don't support `require(ESM)` by default (< 22.12.0) and AWS Lambda which intentionally disables it.
+
+- Add Vercel integration support to API schemas: `commitSHA` and `integrationDeployments` on deployment responses, and `source` field for environment variable imports. ([#2994](https://github.com/triggerdotdev/trigger.dev/pull/2994))
+
+## 4.3.3
+
+### Patch Changes
+
+- Add support for AI SDK v6 (Vercel AI SDK) ([#2919](https://github.com/triggerdotdev/trigger.dev/pull/2919))
+
+  - Updated peer dependency to allow `ai@^6.0.0` alongside v4 and v5
+  - Updated internal code to handle async validation from AI SDK v6's Schema type
+
+- Expose user-provided idempotency key and scope in task context. `ctx.run.idempotencyKey` now returns the original key passed to `idempotencyKeys.create()` instead of the hash, and `ctx.run.idempotencyKeyScope` shows the scope ("run", "attempt", or "global"). ([#2903](https://github.com/triggerdotdev/trigger.dev/pull/2903))
+- Fix batch trigger failing with "ReadableStream is locked" error when network failures occur mid-stream. Added safe stream cancellation that gracefully handles locked streams during retry attempts. ([#2917](https://github.com/triggerdotdev/trigger.dev/pull/2917))
+- Add a maxDepth to flatten/unflattenAttributes to prevent possible issues ([#2890](https://github.com/triggerdotdev/trigger.dev/pull/2890))
+
+## 4.3.2
+
+## 4.3.1
+
+### Patch Changes
+
+- Added support for idempotency reset ([#2777](https://github.com/triggerdotdev/trigger.dev/pull/2777))
+
 ## 4.3.0
 
 ### Minor Changes
diff --git a/packages/core/CLAUDE.md b/packages/core/CLAUDE.md
new file mode 100644
index 00000000000..78e438387e6
--- /dev/null
+++ b/packages/core/CLAUDE.md
@@ -0,0 +1,25 @@
+# Core Package
+
+`@trigger.dev/core` - shared types, schemas, and utilities used across the SDK, CLI, and webapp.
+
+## Critical Import Rule
+
+**NEVER import the root** (`@trigger.dev/core`). Always use subpath imports:
+
+```typescript
+import { ... } from "@trigger.dev/core/v3";
+import { ... } from "@trigger.dev/core/v3/utils";
+import { ... } from "@trigger.dev/core/logger";
+import { ... } from "@trigger.dev/core/schemas";
+```
+
+## Cross-Cutting Impact
+
+Changes here affect both the customer-facing SDK and the server-side webapp. Exercise caution - breaking changes can affect deployed user tasks and the platform simultaneously.
+
+## Contents
+
+- Protocol definitions and message types
+- API schemas (Zod validation)
+- Shared constants and enums
+- Utility functions used across packages
diff --git a/packages/core/package.json b/packages/core/package.json
index fefd0224fea..1ecf044bf6e 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/core",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "Core code used across the Trigger.dev SDK and platform",
   "license": "MIT",
   "publishConfig": {
@@ -157,11 +157,13 @@
   },
   "sideEffects": false,
   "scripts": {
-    "clean": "rimraf dist .tshy .tshy-build .turbo",
+    "clean": "rimraf dist .tshy .tshy-build .turbo src/v3/vendor",
     "update-version": "tsx ../../scripts/updateVersion.ts",
-    "build": "tshy && pnpm run update-version",
-    "dev": "tshy --watch",
-    "typecheck": "tsc --noEmit -p tsconfig.src.json",
+    "bundle-vendor": "node scripts/bundle-superjson.mjs",
+    "build": "pnpm run bundle-vendor && tshy && node scripts/bundle-superjson.mjs --copy && pnpm run update-version",
+    "dev": "pnpm run bundle-vendor && tshy --watch",
+    "typecheck": "pnpm run bundle-vendor && tsc --noEmit -p tsconfig.src.json",
+    "pretest": "pnpm run bundle-vendor",
     "test": "vitest",
     "check-exports": "attw --pack ."
   },
@@ -174,14 +176,17 @@
     "@opentelemetry/api-logs": "0.203.0",
     "@opentelemetry/core": "2.0.1",
     "@opentelemetry/exporter-logs-otlp-http": "0.203.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
+    "@opentelemetry/host-metrics": "^0.37.0",
     "@opentelemetry/instrumentation": "0.203.0",
     "@opentelemetry/resources": "2.0.1",
     "@opentelemetry/sdk-logs": "0.203.0",
+    "@opentelemetry/sdk-metrics": "2.0.1",
     "@opentelemetry/sdk-trace-base": "2.0.1",
     "@opentelemetry/sdk-trace-node": "2.0.1",
     "@opentelemetry/semantic-conventions": "1.36.0",
-    "@s2-dev/streamstore": "0.17.3",
+    "@s2-dev/streamstore": "0.22.5",
     "dequal": "^2.0.3",
     "eventsource": "^3.0.5",
     "eventsource-parser": "^3.0.0",
@@ -193,7 +198,6 @@
     "socket.io": "4.7.4",
     "socket.io-client": "4.7.5",
     "std-env": "^3.8.1",
-    "superjson": "^2.2.1",
     "tinyexec": "^0.3.2",
     "uncrypto": "^0.1.3",
     "zod": "3.25.76",
@@ -208,10 +212,11 @@
     "@types/humanize-duration": "^3.27.1",
     "@types/lodash.get": "^4.4.9",
     "@types/readable-stream": "^4.0.14",
-    "ai": "^3.4.33",
+    "ai": "^6.0.0",
     "defu": "^6.1.4",
     "esbuild": "^0.23.0",
     "rimraf": "^3.0.2",
+    "superjson": "^2.2.1",
     "ts-essentials": "10.0.1",
     "tshy": "^3.0.2",
     "tsx": "4.17.0"
diff --git a/packages/core/scripts/bundle-superjson.mjs b/packages/core/scripts/bundle-superjson.mjs
new file mode 100644
index 00000000000..c4e9a7b0018
--- /dev/null
+++ b/packages/core/scripts/bundle-superjson.mjs
@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * This script bundles superjson and its dependency (copy-anything) into
+ * vendored CJS and ESM bundles to avoid the ERR_REQUIRE_ESM error.
+ *
+ * superjson v2.x is ESM-only, which causes issues on:
+ * - Node.js versions before 22.12.0 (require(ESM) not enabled by default)
+ * - AWS Lambda (intentionally disables require(ESM))
+ *
+ * The output files are gitignored and regenerated during each build.
+ * This script runs automatically as part of `pnpm run build`.
+ *
+ * Usage:
+ *   node scripts/bundle-superjson.mjs          # Bundle to src/v3/vendor
+ *   node scripts/bundle-superjson.mjs --copy   # Also copy to dist directories
+ */
+
+import * as esbuild from "esbuild";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync, mkdirSync, copyFileSync } from "node:fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "..");
+const vendorDir = join(packageRoot, "src", "v3", "vendor");
+
+// Get the installed superjson version for the banner
+const superjsonPkg = JSON.parse(
+  readFileSync(join(packageRoot, "node_modules", "superjson", "package.json"), "utf-8")
+);
+const banner = `/**
+ * Bundled superjson v${superjsonPkg.version}
+ *
+ * This file is auto-generated by scripts/bundle-superjson.mjs
+ * Do not edit directly - run the script to regenerate.
+ *
+ * Original package: https://github.com/flightcontrolhq/superjson
+ * License: MIT
+ */`;
+
+async function bundle() {
+  // Ensure vendor directory exists
+  mkdirSync(vendorDir, { recursive: true });
+
+  // Bundle for CommonJS
+  await esbuild.build({
+    entryPoints: [join(packageRoot, "node_modules", "superjson", "dist", "index.js")],
+    bundle: true,
+    format: "cjs",
+    platform: "node",
+    target: "node18",
+    outfile: join(vendorDir, "superjson.cjs"),
+    banner: { js: banner },
+    // Don't minify to keep it debuggable
+    minify: false,
+  });
+
+  // Bundle for ESM
+  await esbuild.build({
+    entryPoints: [join(packageRoot, "node_modules", "superjson", "dist", "index.js")],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node18",
+    outfile: join(vendorDir, "superjson.mjs"),
+    banner: { js: banner },
+    minify: false,
+  });
+
+  console.log("Bundled superjson v" + superjsonPkg.version);
+  console.log("  -> src/v3/vendor/superjson.cjs (CommonJS)");
+  console.log("  -> src/v3/vendor/superjson.mjs (ESM)");
+
+  // Copy to dist directories if --copy flag is passed
+  if (process.argv.includes("--copy")) {
+    const distCommonjsVendor = join(packageRoot, "dist", "commonjs", "v3", "vendor");
+    const distEsmVendor = join(packageRoot, "dist", "esm", "v3", "vendor");
+
+    mkdirSync(distCommonjsVendor, { recursive: true });
+    mkdirSync(distEsmVendor, { recursive: true });
+
+    copyFileSync(join(vendorDir, "superjson.cjs"), join(distCommonjsVendor, "superjson.cjs"));
+    copyFileSync(join(vendorDir, "superjson.mjs"), join(distEsmVendor, "superjson.mjs"));
+
+    console.log("Copied to dist directories");
+  }
+}
+
+bundle().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/packages/core/src/v3/apiClient/core.ts b/packages/core/src/v3/apiClient/core.ts
index 1f3dca03feb..5541bb2a9a1 100644
--- a/packages/core/src/v3/apiClient/core.ts
+++ b/packages/core/src/v3/apiClient/core.ts
@@ -40,7 +40,9 @@ export type ZodFetchOptions<TData = any> = {
 
 export type AnyZodFetchOptions = ZodFetchOptions<any>;
 
-export type ApiRequestOptions = Pick<ZodFetchOptions, "retry">;
+export type ApiRequestOptions = Pick<ZodFetchOptions, "retry"> & {
+  additionalHeaders?: Record<string, string>;
+};
 
 type KeysEnum<T> = { [P in keyof Required<T>]: true };
 
@@ -49,6 +51,7 @@ type KeysEnum<T> = { [P in keyof Required<T>]: true };
 // compiler such that any missing / extraneous keys will cause an error.
 const requestOptionsKeys: KeysEnum<ApiRequestOptions> = {
   retry: true,
+  additionalHeaders: true,
 };
 
 export const isRequestOptions = (obj: unknown): obj is ApiRequestOptions => {
diff --git a/packages/core/src/v3/apiClient/index.ts b/packages/core/src/v3/apiClient/index.ts
index 7b07b2fb60a..89a551954f0 100644
--- a/packages/core/src/v3/apiClient/index.ts
+++ b/packages/core/src/v3/apiClient/index.ts
@@ -17,6 +17,8 @@ import {
   CreateBatchRequestBody,
   CreateBatchResponse,
   CreateEnvironmentVariableRequestBody,
+  CreateInputStreamWaitpointRequestBody,
+  CreateInputStreamWaitpointResponseBody,
   CreateScheduleOptions,
   CreateStreamResponseBody,
   CreateUploadPayloadUrlResponseBody,
@@ -30,14 +32,31 @@ import {
   ListScheduleOptions,
   QueueItem,
   QueueTypeName,
+  QueryExecuteRequestBody,
+  QueryExecuteResponseBody,
+  QueryExecuteCSVResponseBody,
+  QuerySchemaResponseBody,
+  ListDashboardsResponseBody,
   ReplayRunResponse,
   RescheduleRunRequestBody,
   ResetIdempotencyKeyResponse,
   RetrieveBatchV2Response,
   RetrieveQueueParam,
+  ResolvePromptRequestBody,
+  ResolvePromptResponseBody,
+  ListPromptsResponseBody,
+  ListPromptVersionsResponseBody,
+  PromotePromptVersionRequestBody,
+  CreatePromptOverrideRequestBody,
+  UpdatePromptOverrideRequestBody,
+  ReactivatePromptOverrideRequestBody,
+  PromptOkResponseBody,
+  PromptOverrideCreatedResponseBody,
   RetrieveRunResponse,
   RetrieveRunTraceResponseBody,
+  RetrieveSpanDetailResponseBody,
   ScheduleObject,
+  SendInputStreamResponseBody,
   StreamBatchItemsResponse,
   TaskRunExecutionResult,
   TriggerTaskRequestBody,
@@ -171,6 +190,7 @@ export class ApiClient {
   public readonly accessToken: string;
   public readonly previewBranch?: string;
   public readonly futureFlags: ApiClientFutureFlags;
+  private readonly additionalHeaders?: Record<string, string>;
   private readonly defaultRequestOptions: ZodFetchOptions;
 
   constructor(
@@ -183,7 +203,9 @@ export class ApiClient {
     this.accessToken = accessToken;
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.previewBranch = previewBranch;
-    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, requestOptions);
+    const { additionalHeaders, ...restRequestOptions } = requestOptions;
+    this.additionalHeaders = additionalHeaders;
+    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, restRequestOptions);
     this.futureFlags = futureFlags;
   }
 
@@ -444,14 +466,14 @@ export class ApiClient {
 
         if (retryResult.retry) {
           // Cancel the request stream before retry to prevent tee() from buffering
-          await forRequest.cancel();
+          await safeStreamCancel(forRequest);
           await sleep(retryResult.delay);
           // Use the backup stream for retry
           return this.#streamBatchItemsWithRetry(batchId, forRetry, retryOptions, attempt + 1);
         }
 
         // Not retrying - cancel the backup stream
-        await forRetry.cancel();
+        await safeStreamCancel(forRetry);
 
         const errText = await response.text().catch((e) => (e as Error).message);
         let errJSON: Object | undefined;
@@ -471,7 +493,7 @@ export class ApiClient {
 
       if (!parsed.success) {
         // Cancel backup stream since we're throwing
-        await forRetry.cancel();
+        await safeStreamCancel(forRetry);
         throw new Error(
           `Invalid response from server for batch ${batchId}: ${parsed.error.message}`
         );
@@ -484,14 +506,14 @@ export class ApiClient {
 
         if (delay) {
           // Cancel the request stream before retry to prevent tee() from buffering
-          await forRequest.cancel();
+          await safeStreamCancel(forRequest);
           // Retry with the backup stream
           await sleep(delay);
           return this.#streamBatchItemsWithRetry(batchId, forRetry, retryOptions, attempt + 1);
         }
 
         // No more retries - cancel backup stream and throw descriptive error
-        await forRetry.cancel();
+        await safeStreamCancel(forRetry);
         throw new BatchNotSealedError({
           batchId,
           enqueuedCount: parsed.data.enqueuedCount ?? 0,
@@ -502,7 +524,7 @@ export class ApiClient {
       }
 
       // Success - cancel the backup stream to release resources
-      await forRetry.cancel();
+      await safeStreamCancel(forRetry);
 
       return parsed.data;
     } catch (error) {
@@ -519,13 +541,13 @@ export class ApiClient {
       const delay = calculateNextRetryDelay(retryOptions, attempt);
       if (delay) {
         // Cancel the request stream before retry to prevent tee() from buffering
-        await forRequest.cancel();
+        await safeStreamCancel(forRequest);
         await sleep(delay);
         return this.#streamBatchItemsWithRetry(batchId, forRetry, retryOptions, attempt + 1);
       }
 
       // No more retries - cancel the backup stream
-      await forRetry.cancel();
+      await safeStreamCancel(forRetry);
 
       // Wrap in a more descriptive error
       const cause = error instanceof Error ? error : new Error(String(error));
@@ -537,9 +559,10 @@ export class ApiClient {
   }
 
   createUploadPayloadUrl(filename: string, requestOptions?: ZodFetchOptions) {
+    const encoded = encodeURIComponent(filename);
     return zodfetch(
       CreateUploadPayloadUrlResponseBody,
-      `${this.baseUrl}/api/v1/packets/${filename}`,
+      `${this.baseUrl}/api/v2/packets/${encoded}`,
       {
         method: "PUT",
         headers: this.#getHeaders(false),
@@ -549,9 +572,10 @@ export class ApiClient {
   }
 
   getPayloadUrl(filename: string, requestOptions?: ZodFetchOptions) {
+    const encoded = encodeURIComponent(filename);
     return zodfetch(
       CreateUploadPayloadUrlResponseBody,
-      `${this.baseUrl}/api/v1/packets/${filename}`,
+      `${this.baseUrl}/api/v1/packets/${encoded}`,
       {
         method: "GET",
         headers: this.#getHeaders(false),
@@ -584,6 +608,18 @@ export class ApiClient {
     );
   }
 
+  retrieveSpan(runId: string, spanId: string, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      RetrieveSpanDetailResponseBody,
+      `${this.baseUrl}/api/v1/runs/${runId}/spans/${spanId}`,
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   listRuns(
     query?: ListRunsQueryParams,
     requestOptions?: ZodFetchOptions
@@ -1314,6 +1350,8 @@ export class ApiClient {
       onComplete?: () => void;
       onError?: (error: Error) => void;
       lastEventId?: string;
+      /** Called for each SSE event with the full event metadata (id, timestamp). */
+      onPart?: (part: SSEStreamPart<T>) => void;
     }
   ): Promise<AsyncIterableStream<T>> {
     const streamFactory = new SSEStreamSubscriptionFactory(options?.baseUrl ?? this.baseUrl, {
@@ -1330,10 +1368,14 @@ export class ApiClient {
 
     const stream = await subscription.subscribe();
 
+    const onPart = options?.onPart;
+
     return stream.pipeThrough(
       new TransformStream<SSEStreamPart, T>({
         transform(chunk, controller) {
-          controller.enqueue(chunk.chunk as T);
+          const data = chunk.chunk as T;
+          onPart?.(chunk as SSEStreamPart<T>);
+          controller.enqueue(data);
         },
       })
     );
@@ -1382,6 +1424,41 @@ export class ApiClient {
     );
   }
 
+  async sendInputStream(
+    runId: string,
+    streamId: string,
+    data: unknown,
+    requestOptions?: ZodFetchOptions
+  ) {
+    return zodfetch(
+      SendInputStreamResponseBody,
+      `${this.baseUrl}/realtime/v1/streams/${runId}/input/${streamId}`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify({ data }),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  async createInputStreamWaitpoint(
+    runFriendlyId: string,
+    body: CreateInputStreamWaitpointRequestBody,
+    requestOptions?: ZodFetchOptions
+  ) {
+    return zodfetch(
+      CreateInputStreamWaitpointResponseBody,
+      `${this.baseUrl}/api/v1/runs/${runFriendlyId}/input-streams/wait`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify(body),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   async generateJWTClaims(requestOptions?: ZodFetchOptions): Promise<Record<string, any>> {
     return zodfetch(
       z.record(z.any()),
@@ -1406,6 +1483,64 @@ export class ApiClient {
     );
   }
 
+  async executeQuery(
+    query: string,
+    options?: {
+      scope?: "environment" | "project" | "organization";
+      period?: string;
+      from?: string;
+      to?: string;
+      format?: "json" | "csv";
+    },
+    requestOptions?: ZodFetchOptions
+  ): Promise<QueryExecuteResponseBody> {
+    const body = {
+      query,
+      scope: options?.scope ?? "environment",
+      period: options?.period,
+      from: options?.from,
+      to: options?.to,
+      format: options?.format ?? "json",
+    };
+
+    return zodfetch(
+      QueryExecuteResponseBody,
+      `${this.baseUrl}/api/v1/query`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify(body),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  async getQuerySchema(requestOptions?: ZodFetchOptions): Promise<QuerySchemaResponseBody> {
+    return zodfetch(
+      QuerySchemaResponseBody,
+      `${this.baseUrl}/api/v1/query/schema`,
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  async listDashboards(
+    requestOptions?: ZodFetchOptions
+  ): Promise<ListDashboardsResponseBody> {
+    return zodfetch(
+      ListDashboardsResponseBody,
+      `${this.baseUrl}/api/v1/query/dashboards`,
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   #getHeaders(spanParentAsLink: boolean, additionalHeaders?: Record<string, string | undefined>) {
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
@@ -1423,6 +1558,18 @@ export class ApiClient {
       ),
     };
 
+    if (this.additionalHeaders) {
+      for (const [key, value] of Object.entries(this.additionalHeaders)) {
+        if (!(key in headers)) {
+          headers[key] = value;
+        }
+      }
+    }
+
+    if (!headers["x-trigger-source"]) {
+      headers["x-trigger-source"] = "sdk";
+    }
+
     if (this.previewBranch) {
       headers["x-trigger-branch"] = this.previewBranch;
     }
@@ -1461,6 +1608,86 @@ export class ApiClient {
     return headers;
   }
 
+  resolvePrompt(
+    slug: string,
+    body: ResolvePromptRequestBody,
+    requestOptions?: ZodFetchOptions
+  ) {
+    return zodfetch(
+      ResolvePromptResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}`,
+      {
+        method: "POST",
+        headers: this.#getHeaders(false),
+        body: JSON.stringify(body),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  listPrompts(requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      ListPromptsResponseBody,
+      `${this.baseUrl}/api/v1/prompts`,
+      { method: "GET", headers: this.#getHeaders(false) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  listPromptVersions(slug: string, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      ListPromptVersionsResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/versions`,
+      { method: "GET", headers: this.#getHeaders(false) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  promotePromptVersion(slug: string, body: PromotePromptVersionRequestBody, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      PromptOkResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/promote`,
+      { method: "POST", headers: this.#getHeaders(false), body: JSON.stringify(body) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  createPromptOverride(slug: string, body: CreatePromptOverrideRequestBody, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      PromptOverrideCreatedResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/override`,
+      { method: "POST", headers: this.#getHeaders(false), body: JSON.stringify(body) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  updatePromptOverride(slug: string, body: UpdatePromptOverrideRequestBody, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      PromptOkResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/override`,
+      { method: "PUT", headers: this.#getHeaders(false), body: JSON.stringify(body) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  removePromptOverride(slug: string, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      PromptOkResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/override`,
+      { method: "DELETE", headers: this.#getHeaders(false) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
+  reactivatePromptOverride(slug: string, body: ReactivatePromptOverrideRequestBody, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      PromptOkResponseBody,
+      `${this.baseUrl}/api/v1/prompts/${slug}/override/reactivate`,
+      { method: "POST", headers: this.#getHeaders(false), body: JSON.stringify(body) },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   #getRealtimeHeaders() {
     let headers: Record<string, string> = {
       Authorization: `Bearer ${this.accessToken}`,
@@ -1731,6 +1958,30 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Safely cancels a ReadableStream, handling the case where it might be locked.
+ *
+ * When fetch uses a ReadableStream as a request body and an error occurs mid-transfer
+ * (connection reset, timeout, etc.), the stream may remain locked by fetch's internal reader.
+ * Attempting to cancel a locked stream throws "Invalid state: ReadableStream is locked".
+ *
+ * This function gracefully handles that case by catching the error and doing nothing -
+ * the stream will be cleaned up by garbage collection when the reader is released.
+ */
+async function safeStreamCancel(stream: ReadableStream<unknown>): Promise<void> {
+  try {
+    await stream.cancel();
+  } catch (error) {
+    // Ignore "locked" errors - the stream will be cleaned up when the reader is released.
+    // This happens when fetch crashes mid-read and doesn't release the reader lock.
+    if (error instanceof TypeError && String(error).includes("locked")) {
+      return;
+    }
+    // Re-throw unexpected errors
+    throw error;
+  }
+}
+
 // ============================================================================
 // NDJSON Stream Helpers
 // ============================================================================
diff --git a/packages/core/src/v3/apiClient/streamBatchItems.test.ts b/packages/core/src/v3/apiClient/streamBatchItems.test.ts
index c148f9b68eb..23a42b57329 100644
--- a/packages/core/src/v3/apiClient/streamBatchItems.test.ts
+++ b/packages/core/src/v3/apiClient/streamBatchItems.test.ts
@@ -398,6 +398,58 @@ describe("streamBatchItems stream cancellation on retry", () => {
     expect(cancelCallCount).toBeGreaterThanOrEqual(1);
   });
 
+  it("handles locked stream when connection error occurs mid-read", async () => {
+    // This test simulates the real-world scenario where fetch throws an error
+    // while still holding the reader lock on the request body stream.
+    // This can happen with connection resets, timeouts, or network failures.
+    let callIndex = 0;
+
+    const mockFetch = vi.fn().mockImplementation(async (_url: string, init?: RequestInit) => {
+      const currentAttempt = callIndex;
+      callIndex++;
+
+      if (init?.body && init.body instanceof ReadableStream) {
+        if (currentAttempt === 0) {
+          // First attempt: Get a reader and start reading, but throw while still holding the lock.
+          // This simulates a connection error that happens mid-transfer.
+          const reader = init.body.getReader();
+          await reader.read(); // Start reading
+          // DON'T release the lock - this simulates fetch crashing mid-read
+          throw new TypeError("Connection reset by peer");
+        }
+
+        // Subsequent attempts: consume and release normally
+        await consumeAndRelease(init.body);
+      }
+
+      // Second attempt: success
+      return {
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            id: "batch_test123",
+            itemsAccepted: 10,
+            itemsDeduplicated: 0,
+            sealed: true,
+          }),
+      };
+    });
+    globalThis.fetch = mockFetch;
+
+    const client = new ApiClient("http://localhost:3030", "tr_test_key");
+
+    // This should NOT throw "ReadableStream is locked" error
+    // Instead it should gracefully handle the locked stream and retry
+    const result = await client.streamBatchItems(
+      "batch_test123",
+      [{ index: 0, task: "test-task", payload: "{}" }],
+      { retry: { maxAttempts: 3, minTimeoutInMs: 10, maxTimeoutInMs: 50 } }
+    );
+
+    expect(result.sealed).toBe(true);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
   it("does not leak memory by leaving tee branches unconsumed during multiple retries", async () => {
     let cancelCallCount = 0;
     let callIndex = 0;
diff --git a/packages/core/src/v3/config.ts b/packages/core/src/v3/config.ts
index 9c6871a2646..40334f04280 100644
--- a/packages/core/src/v3/config.ts
+++ b/packages/core/src/v3/config.ts
@@ -1,5 +1,6 @@
 import type { Instrumentation } from "@opentelemetry/instrumentation";
 import type { SpanExporter } from "@opentelemetry/sdk-trace-base";
+import type { MetricReader, PushMetricExporter } from "@opentelemetry/sdk-metrics";
 import type { BuildExtension } from "./build/extensions.js";
 import type {
   AnyOnFailureHookFunction,
@@ -109,6 +110,20 @@ export type TriggerConfig = {
      */
     logExporters?: Array<LogRecordExporter>;
 
+    /**
+     * Metric exporters to use for OpenTelemetry. This is useful if you want to export metrics to external services.
+     * Each exporter is automatically wrapped in a PeriodicExportingMetricReader.
+     *
+     * For more control over the reader configuration, use `metricReaders` instead.
+     */
+    metricExporters?: Array<PushMetricExporter>;
+
+    /**
+     * Metric readers for OpenTelemetry. Add custom metric readers to export
+     * metrics to external services alongside the default Trigger.dev exporter.
+     */
+    metricReaders?: Array<MetricReader>;
+
     /**
      * Resource to use for OpenTelemetry. This is useful if you want to add custom resources to your tasks.
      *
@@ -161,6 +176,25 @@ export type TriggerConfig = {
    */
   maxDuration: number;
 
+  /**
+   * Set a default time-to-live (TTL) for all task runs in the project. If a run is not executed within this time, it will be removed from the queue and never execute.
+   *
+   * This can be a string like "1h" (1 hour), "30m" (30 minutes), "1d" (1 day), or a number of seconds.
+   *
+   * You can override this on a per-task basis by setting the `ttl` option on the task definition, or per-trigger by setting the `ttl` option when triggering.
+   *
+   * @example
+   *
+   * ```ts
+   * export default defineConfig({
+   *   project: "my-project",
+   *   maxDuration: 3600,
+   *   ttl: "1h",
+   * });
+   * ```
+   */
+  ttl?: string | number;
+
   /**
    * Enable console logging while running the dev CLI. This will print out logs from console.log, console.warn, and console.error. By default all logs are sent to the trigger.dev backend, and not logged to the console.
    */
diff --git a/packages/core/src/v3/errors.ts b/packages/core/src/v3/errors.ts
index fd03bf445fb..87fff767d7b 100644
--- a/packages/core/src/v3/errors.ts
+++ b/packages/core/src/v3/errors.ts
@@ -307,6 +307,9 @@ export function shouldRetryError(error: TaskRunError): boolean {
         case "TASK_DEQUEUED_QUEUE_NOT_FOUND":
         case "TASK_HAS_N0_EXECUTION_SNAPSHOT":
         case "TASK_RUN_DEQUEUED_MAX_RETRIES":
+        case "BATCH_ITEM_COULD_NOT_TRIGGER":
+        case "PAYLOAD_TOO_LARGE":
+        case "UNSPECIFIED_ERROR":
           return false;
 
         //new heartbeat error
diff --git a/packages/core/src/v3/idempotency-key-catalog-api.ts b/packages/core/src/v3/idempotency-key-catalog-api.ts
new file mode 100644
index 00000000000..d83b62d8825
--- /dev/null
+++ b/packages/core/src/v3/idempotency-key-catalog-api.ts
@@ -0,0 +1,5 @@
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+import { IdempotencyKeyCatalogAPI } from "./idempotency-key-catalog/index.js";
+/** Entrypoint for idempotency key catalog API */
+export const idempotencyKeyCatalog = IdempotencyKeyCatalogAPI.getInstance();
diff --git a/packages/core/src/v3/idempotency-key-catalog/catalog.ts b/packages/core/src/v3/idempotency-key-catalog/catalog.ts
new file mode 100644
index 00000000000..bcc74c90c9b
--- /dev/null
+++ b/packages/core/src/v3/idempotency-key-catalog/catalog.ts
@@ -0,0 +1,11 @@
+export type IdempotencyKeyScope = "run" | "attempt" | "global";
+
+export type IdempotencyKeyOptions = {
+  key: string;
+  scope: IdempotencyKeyScope;
+};
+
+export interface IdempotencyKeyCatalog {
+  registerKeyOptions(hash: string, options: IdempotencyKeyOptions): void;
+  getKeyOptions(hash: string): IdempotencyKeyOptions | undefined;
+}
diff --git a/packages/core/src/v3/idempotency-key-catalog/index.ts b/packages/core/src/v3/idempotency-key-catalog/index.ts
new file mode 100644
index 00000000000..685639ed498
--- /dev/null
+++ b/packages/core/src/v3/idempotency-key-catalog/index.ts
@@ -0,0 +1,36 @@
+const API_NAME = "idempotency-key-catalog";
+
+import { getGlobal, registerGlobal } from "../utils/globals.js";
+import type { IdempotencyKeyCatalog, IdempotencyKeyOptions } from "./catalog.js";
+import { LRUIdempotencyKeyCatalog } from "./lruIdempotencyKeyCatalog.js";
+
+export class IdempotencyKeyCatalogAPI {
+  private static _instance?: IdempotencyKeyCatalogAPI;
+
+  private constructor() {}
+
+  public static getInstance(): IdempotencyKeyCatalogAPI {
+    if (!this._instance) {
+      this._instance = new IdempotencyKeyCatalogAPI();
+    }
+    return this._instance;
+  }
+
+  public registerKeyOptions(hash: string, options: IdempotencyKeyOptions): void {
+    this.#getCatalog().registerKeyOptions(hash, options);
+  }
+
+  public getKeyOptions(hash: string): IdempotencyKeyOptions | undefined {
+    return this.#getCatalog().getKeyOptions(hash);
+  }
+
+  #getCatalog(): IdempotencyKeyCatalog {
+    let catalog = getGlobal(API_NAME);
+    if (!catalog) {
+      // Auto-initialize with LRU catalog on first access
+      catalog = new LRUIdempotencyKeyCatalog();
+      registerGlobal(API_NAME, catalog, true);
+    }
+    return catalog;
+  }
+}
diff --git a/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.test.ts b/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.test.ts
new file mode 100644
index 00000000000..ba523f60407
--- /dev/null
+++ b/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.test.ts
@@ -0,0 +1,209 @@
+import { describe, it, expect } from "vitest";
+import { LRUIdempotencyKeyCatalog } from "./lruIdempotencyKeyCatalog.js";
+
+describe("LRUIdempotencyKeyCatalog", () => {
+  describe("registerKeyOptions and getKeyOptions", () => {
+    it("should store and retrieve options", () => {
+      const catalog = new LRUIdempotencyKeyCatalog();
+      const options = { key: "my-key", scope: "global" as const };
+
+      catalog.registerKeyOptions("hash1", options);
+
+      expect(catalog.getKeyOptions("hash1")).toEqual(options);
+    });
+
+    it("should return undefined for non-existent keys", () => {
+      const catalog = new LRUIdempotencyKeyCatalog();
+
+      expect(catalog.getKeyOptions("non-existent")).toBeUndefined();
+    });
+
+    it("should store multiple keys", () => {
+      const catalog = new LRUIdempotencyKeyCatalog();
+      const options1 = { key: "key1", scope: "global" as const };
+      const options2 = { key: "key2", scope: "run" as const };
+      const options3 = { key: "key3", scope: "attempt" as const };
+
+      catalog.registerKeyOptions("hash1", options1);
+      catalog.registerKeyOptions("hash2", options2);
+      catalog.registerKeyOptions("hash3", options3);
+
+      expect(catalog.getKeyOptions("hash1")).toEqual(options1);
+      expect(catalog.getKeyOptions("hash2")).toEqual(options2);
+      expect(catalog.getKeyOptions("hash3")).toEqual(options3);
+    });
+
+    it("should update options when registering same key twice", () => {
+      const catalog = new LRUIdempotencyKeyCatalog();
+      const options1 = { key: "key1", scope: "global" as const };
+      const options2 = { key: "key1-updated", scope: "run" as const };
+
+      catalog.registerKeyOptions("hash1", options1);
+      catalog.registerKeyOptions("hash1", options2);
+
+      expect(catalog.getKeyOptions("hash1")).toEqual(options2);
+    });
+  });
+
+  describe("LRU eviction", () => {
+    it("should evict oldest entry when over capacity", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(3);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+
+      // All three should exist
+      expect(catalog.getKeyOptions("hash1")).toBeDefined();
+      expect(catalog.getKeyOptions("hash2")).toBeDefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+
+      // After the gets above, the LRU order from oldest to newest is: hash1, hash2, hash3
+      // (each get moves the key to the most recent position)
+
+      // Add a fourth - hash1 should be evicted (it was accessed first, so it's the oldest)
+      catalog.registerKeyOptions("hash4", { key: "key4", scope: "global" });
+
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash2")).toBeDefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+      expect(catalog.getKeyOptions("hash4")).toBeDefined();
+    });
+
+    it("should evict least recently registered entry when capacity exceeded", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(3);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+
+      // Adding fourth should evict hash1 (oldest)
+      catalog.registerKeyOptions("hash4", { key: "key4", scope: "global" });
+
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash2")).toBeDefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+      expect(catalog.getKeyOptions("hash4")).toBeDefined();
+    });
+
+    it("should evict multiple entries when adding many at once would exceed capacity", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(2);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+      catalog.registerKeyOptions("hash4", { key: "key4", scope: "global" });
+
+      // Only hash3 and hash4 should remain
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash2")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+      expect(catalog.getKeyOptions("hash4")).toBeDefined();
+    });
+
+    it("should work with maxSize of 1", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(1);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      expect(catalog.getKeyOptions("hash1")).toBeDefined();
+
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash2")).toBeDefined();
+    });
+  });
+
+  describe("LRU ordering", () => {
+    it("should move accessed key to most recent position", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(3);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+
+      // Access hash1, moving it to most recent
+      catalog.getKeyOptions("hash1");
+
+      // Add hash4 - should evict hash2 (now the oldest)
+      catalog.registerKeyOptions("hash4", { key: "key4", scope: "global" });
+
+      expect(catalog.getKeyOptions("hash1")).toBeDefined();
+      expect(catalog.getKeyOptions("hash2")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+      expect(catalog.getKeyOptions("hash4")).toBeDefined();
+    });
+
+    it("should move re-registered key to most recent position", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(3);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+
+      // Re-register hash1, moving it to most recent
+      catalog.registerKeyOptions("hash1", { key: "key1-updated", scope: "run" });
+
+      // Add hash4 - should evict hash2 (now the oldest)
+      catalog.registerKeyOptions("hash4", { key: "key4", scope: "global" });
+
+      expect(catalog.getKeyOptions("hash1")).toEqual({ key: "key1-updated", scope: "run" });
+      expect(catalog.getKeyOptions("hash2")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+      expect(catalog.getKeyOptions("hash4")).toBeDefined();
+    });
+
+    it("should not affect order when getting non-existent key", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(2);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+      catalog.registerKeyOptions("hash2", { key: "key2", scope: "global" });
+
+      // Try to get non-existent key
+      catalog.getKeyOptions("non-existent");
+
+      // Add hash3 - should still evict hash1 (oldest)
+      catalog.registerKeyOptions("hash3", { key: "key3", scope: "global" });
+
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+      expect(catalog.getKeyOptions("hash2")).toBeDefined();
+      expect(catalog.getKeyOptions("hash3")).toBeDefined();
+    });
+  });
+
+  describe("default maxSize", () => {
+    it("should use default maxSize of 1000", () => {
+      const catalog = new LRUIdempotencyKeyCatalog();
+
+      // Register 1001 entries
+      for (let i = 0; i < 1001; i++) {
+        catalog.registerKeyOptions(`hash${i}`, { key: `key${i}`, scope: "global" });
+      }
+
+      // First entry should be evicted
+      expect(catalog.getKeyOptions("hash0")).toBeUndefined();
+      // Last entry should exist
+      expect(catalog.getKeyOptions("hash1000")).toBeDefined();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle negative maxSize by clamping to 0", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(-5);
+
+      // With maxSize clamped to 0, nothing should be stored
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+
+      // Should be immediately evicted since maxSize is 0
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+    });
+
+    it("should handle maxSize of 0", () => {
+      const catalog = new LRUIdempotencyKeyCatalog(0);
+
+      catalog.registerKeyOptions("hash1", { key: "key1", scope: "global" });
+
+      // Should be immediately evicted since maxSize is 0
+      expect(catalog.getKeyOptions("hash1")).toBeUndefined();
+    });
+  });
+});
diff --git a/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.ts b/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.ts
new file mode 100644
index 00000000000..2fcd072d15c
--- /dev/null
+++ b/packages/core/src/v3/idempotency-key-catalog/lruIdempotencyKeyCatalog.ts
@@ -0,0 +1,36 @@
+import type { IdempotencyKeyCatalog, IdempotencyKeyOptions } from "./catalog.js";
+
+export class LRUIdempotencyKeyCatalog implements IdempotencyKeyCatalog {
+  private cache: Map<string, IdempotencyKeyOptions>;
+  private readonly maxSize: number;
+
+  constructor(maxSize: number = 1_000) {
+    this.cache = new Map();
+    // Clamp to non-negative to prevent infinite loop in eviction
+    this.maxSize = Math.max(0, maxSize);
+  }
+
+  registerKeyOptions(hash: string, options: IdempotencyKeyOptions): void {
+    // Delete and re-add to update position (most recently used)
+    this.cache.delete(hash);
+    this.cache.set(hash, options);
+
+    // Evict oldest entries if over capacity
+    while (this.cache.size > this.maxSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== undefined) {
+        this.cache.delete(oldest);
+      }
+    }
+  }
+
+  getKeyOptions(hash: string): IdempotencyKeyOptions | undefined {
+    const options = this.cache.get(hash);
+    if (options) {
+      // Move to end (most recently used)
+      this.cache.delete(hash);
+      this.cache.set(hash, options);
+    }
+    return options;
+  }
+}
diff --git a/packages/core/src/v3/idempotencyKeys.ts b/packages/core/src/v3/idempotencyKeys.ts
index 467608840bf..3a6946ccbd0 100644
--- a/packages/core/src/v3/idempotencyKeys.ts
+++ b/packages/core/src/v3/idempotencyKeys.ts
@@ -1,14 +1,49 @@
 import { apiClientManager } from "./apiClientManager-api.js";
+import { idempotencyKeyCatalog } from "./idempotency-key-catalog-api.js";
+import type {
+  IdempotencyKeyOptions,
+  IdempotencyKeyScope,
+} from "./idempotency-key-catalog/catalog.js";
 import { taskContext } from "./task-context-api.js";
 import { IdempotencyKey } from "./types/idempotencyKeys.js";
 import { digestSHA256 } from "./utils/crypto.js";
 import type { ZodFetchOptions } from "./apiClient/core.js";
 
+// Re-export types from catalog for backwards compatibility
+export type { IdempotencyKeyScope, IdempotencyKeyOptions } from "./idempotency-key-catalog/catalog.js";
+
+/**
+ * Extracts the user-provided key and scope from an idempotency key created with `idempotencyKeys.create()`.
+ *
+ * @param idempotencyKey The idempotency key to extract options from
+ * @returns The original key and scope, or undefined if the key doesn't have attached options
+ *
+ * @example
+ * ```typescript
+ * const key = await idempotencyKeys.create("my-key", { scope: "global" });
+ * const options = getIdempotencyKeyOptions(key);
+ * // options = { key: "my-key", scope: "global" }
+ * ```
+ */
+export function getIdempotencyKeyOptions(
+  idempotencyKey: IdempotencyKey | string
+): IdempotencyKeyOptions | undefined {
+  // Look up options from the catalog using the hash string
+  if (typeof idempotencyKey === "string") {
+    return idempotencyKeyCatalog.getKeyOptions(idempotencyKey);
+  }
+  return undefined;
+}
+
 export function isIdempotencyKey(
   value: string | string[] | IdempotencyKey
 ): value is IdempotencyKey {
   // Cannot check the brand at runtime because it doesn't exist (it's a TypeScript-only construct)
-  return typeof value === "string" && value.length === 64;
+  // Check for primitive strings only (we no longer use String objects)
+  if (typeof value === "string") {
+    return value.length === 64;
+  }
+  return false;
 }
 
 export function flattenIdempotencyKey(
@@ -91,16 +126,22 @@ export async function makeIdempotencyKey(
  */
 export async function createIdempotencyKey(
   key: string | string[],
-  options?: { scope?: "run" | "attempt" | "global" }
+  options?: { scope?: IdempotencyKeyScope }
 ): Promise<IdempotencyKey> {
-  const idempotencyKey = await generateIdempotencyKey(
-    [...(Array.isArray(key) ? key : [key])].concat(injectScope(options?.scope ?? "run"))
-  );
+  const scope = options?.scope ?? "run";
+  const keyArray = Array.isArray(key) ? key : [key];
+  const userKey = keyArray.join("-");
+
+  const idempotencyKey = await generateIdempotencyKey(keyArray.concat(injectScope(scope)));
+
+  // Register the original key and scope in the catalog for later extraction
+  idempotencyKeyCatalog.registerKeyOptions(idempotencyKey, { key: userKey, scope });
 
+  // Return primitive string cast as IdempotencyKey
   return idempotencyKey as IdempotencyKey;
 }
 
-function injectScope(scope: "run" | "attempt" | "global"): string[] {
+function injectScope(scope: IdempotencyKeyScope): string[] {
   switch (scope) {
     case "run": {
       if (taskContext?.ctx) {
@@ -137,17 +178,92 @@ export function attemptKey(ctx: AttemptKeyMaterial): string {
   return `${ctx.run.id}-${ctx.attempt.number}`;
 }
 
-/** Resets an idempotency key, effectively deleting it from the associated task.*/
+export type ResetIdempotencyKeyOptions = {
+  scope?: IdempotencyKeyScope;
+  /** Required if scope is "run" or "attempt" to reconstruct the hash */
+  parentRunId?: string;
+  /** Required if scope is "attempt" to reconstruct the hash */
+  attemptNumber?: number;
+};
+
+/**
+ * Resets an idempotency key, effectively deleting it from the associated task.
+ *
+ * @param taskIdentifier The task identifier (e.g., "my-task")
+ * @param idempotencyKey The idempotency key to reset. Can be:
+ *   - An `IdempotencyKey` created with `idempotencyKeys.create()` (options are extracted automatically)
+ *   - A string or string array (requires `options.scope` and potentially `options.parentRunId`)
+ * @param options Options for reconstructing the hash if needed
+ * @param requestOptions Optional fetch options
+ *
+ * @example
+ * ```typescript
+ * // Using a key created with idempotencyKeys.create() - options are extracted automatically
+ * const key = await idempotencyKeys.create("my-key", { scope: "global" });
+ * await idempotencyKeys.reset("my-task", key);
+ *
+ * // Using a raw string with global scope
+ * await idempotencyKeys.reset("my-task", "my-key", { scope: "global" });
+ *
+ * // Using a raw string with run scope (requires parentRunId)
+ * await idempotencyKeys.reset("my-task", "my-key", {
+ *   scope: "run",
+ *   parentRunId: "run_abc123"
+ * });
+ * ```
+ */
 export async function resetIdempotencyKey(
   taskIdentifier: string,
-  idempotencyKey: string,
+  idempotencyKey: IdempotencyKey | string | string[],
+  options?: ResetIdempotencyKeyOptions,
   requestOptions?: ZodFetchOptions
 ): Promise<{ id: string }> {
   const client = apiClientManager.clientOrThrow();
 
-  return client.resetIdempotencyKey(
-    taskIdentifier,
-    idempotencyKey,
-    requestOptions
-  );
+  // If the key is already a 64-char hash, use it directly
+  if (typeof idempotencyKey === "string" && idempotencyKey.length === 64) {
+    return client.resetIdempotencyKey(taskIdentifier, idempotencyKey, requestOptions);
+  }
+
+  // Try to extract options from an IdempotencyKey created with idempotencyKeys.create()
+  const attachedOptions =
+    typeof idempotencyKey === "string"
+      ? getIdempotencyKeyOptions(idempotencyKey)
+      : undefined;
+
+  const scope = attachedOptions?.scope ?? options?.scope ?? "run";
+  const keyArray = Array.isArray(idempotencyKey)
+    ? idempotencyKey
+    : [attachedOptions?.key ?? String(idempotencyKey)];
+
+  // Build scope suffix based on scope type
+  let scopeSuffix: string[] = [];
+  switch (scope) {
+    case "run": {
+      const parentRunId = options?.parentRunId ?? taskContext?.ctx?.run.id;
+      if (!parentRunId) {
+        throw new Error(
+          "resetIdempotencyKey: parentRunId is required for 'run' scope when called outside a task context"
+        );
+      }
+      scopeSuffix = [parentRunId];
+      break;
+    }
+    case "attempt": {
+      const parentRunId = options?.parentRunId ?? taskContext?.ctx?.run.id;
+      const attemptNumber = options?.attemptNumber ?? taskContext?.ctx?.attempt.number;
+      if (!parentRunId || attemptNumber === undefined) {
+        throw new Error(
+          "resetIdempotencyKey: parentRunId and attemptNumber are required for 'attempt' scope when called outside a task context"
+        );
+      }
+      scopeSuffix = [parentRunId, attemptNumber.toString()];
+      break;
+    }
+  }
+
+  // Generate the hash using the same algorithm as createIdempotencyKey
+  const hash = await generateIdempotencyKey(keyArray.concat(scopeSuffix));
+
+  return client.resetIdempotencyKey(taskIdentifier, hash, requestOptions);
 }
diff --git a/packages/core/src/v3/imports/superjson-cjs.cts b/packages/core/src/v3/imports/superjson-cjs.cts
new file mode 100644
index 00000000000..89ed3d2458d
--- /dev/null
+++ b/packages/core/src/v3/imports/superjson-cjs.cts
@@ -0,0 +1,17 @@
+// Use vendored superjson bundle to avoid ESM/CJS compatibility issues
+// See: https://github.com/triggerdotdev/trigger.dev/issues/2937
+// @ts-ignore
+const superjson = require("../vendor/superjson.cjs");
+
+// @ts-ignore
+superjson.default.registerCustom<Buffer, number[]>(
+  {
+    isApplicable: (v: unknown): v is Buffer => typeof Buffer === "function" && Buffer.isBuffer(v),
+    serialize: (v: Buffer) => [...v],
+    deserialize: (v: number[]) => Buffer.from(v),
+  },
+  "buffer"
+);
+
+// @ts-ignore
+module.exports.default = superjson.default;
diff --git a/packages/core/src/v3/imports/superjson.ts b/packages/core/src/v3/imports/superjson.ts
new file mode 100644
index 00000000000..1545c083e04
--- /dev/null
+++ b/packages/core/src/v3/imports/superjson.ts
@@ -0,0 +1,16 @@
+// Use vendored superjson bundle to avoid ESM/CJS compatibility issues
+// See: https://github.com/triggerdotdev/trigger.dev/issues/2937
+// @ts-ignore
+import superjson from "../vendor/superjson.mjs";
+
+superjson.registerCustom<Buffer, number[]>(
+  {
+    isApplicable: (v: unknown): v is Buffer => typeof Buffer === "function" && Buffer.isBuffer(v),
+    serialize: (v: Buffer) => [...v],
+    deserialize: (v: number[]) => Buffer.from(v),
+  },
+  "buffer"
+);
+
+// @ts-ignore
+export default superjson;
diff --git a/packages/core/src/v3/index.ts b/packages/core/src/v3/index.ts
index f4c114c5f9d..2757363f4be 100644
--- a/packages/core/src/v3/index.ts
+++ b/packages/core/src/v3/index.ts
@@ -20,6 +20,8 @@ export * from "./lifecycle-hooks-api.js";
 export * from "./locals-api.js";
 export * from "./heartbeats-api.js";
 export * from "./realtime-streams-api.js";
+export * from "./input-streams-api.js";
+export * from "./waitpoints/index.js";
 export * from "./schemas/index.js";
 export { SemanticInternalAttributes } from "./semanticInternalAttributes.js";
 export * from "./resource-catalog-api.js";
@@ -49,6 +51,7 @@ export {
   NULL_SENTINEL,
 } from "./utils/flattenAttributes.js";
 export { omit } from "./utils/omit.js";
+export { generateFriendlyId, fromFriendlyId } from "./isomorphic/friendlyId.js";
 export {
   calculateNextRetryDelay,
   calculateResetAt,
diff --git a/packages/core/src/v3/input-streams-api.ts b/packages/core/src/v3/input-streams-api.ts
new file mode 100644
index 00000000000..17875db5053
--- /dev/null
+++ b/packages/core/src/v3/input-streams-api.ts
@@ -0,0 +1,7 @@
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+import { InputStreamsAPI } from "./inputStreams/index.js";
+
+export const inputStreams = InputStreamsAPI.getInstance();
+
+export * from "./inputStreams/types.js";
diff --git a/packages/core/src/v3/inputStreams/index.ts b/packages/core/src/v3/inputStreams/index.ts
new file mode 100644
index 00000000000..4a871d6bfcc
--- /dev/null
+++ b/packages/core/src/v3/inputStreams/index.ts
@@ -0,0 +1,69 @@
+import { getGlobal, registerGlobal } from "../utils/globals.js";
+import { NoopInputStreamManager } from "./noopManager.js";
+import { InputStreamManager, InputStreamOncePromise } from "./types.js";
+import { InputStreamOnceOptions } from "../realtimeStreams/types.js";
+
+const API_NAME = "input-streams";
+
+const NOOP_MANAGER = new NoopInputStreamManager();
+
+export class InputStreamsAPI implements InputStreamManager {
+  private static _instance?: InputStreamsAPI;
+
+  private constructor() {}
+
+  public static getInstance(): InputStreamsAPI {
+    if (!this._instance) {
+      this._instance = new InputStreamsAPI();
+    }
+
+    return this._instance;
+  }
+
+  setGlobalManager(manager: InputStreamManager): boolean {
+    return registerGlobal(API_NAME, manager);
+  }
+
+  #getManager(): InputStreamManager {
+    return getGlobal(API_NAME) ?? NOOP_MANAGER;
+  }
+
+  public setRunId(runId: string, streamsVersion?: string): void {
+    this.#getManager().setRunId(runId, streamsVersion);
+  }
+
+  public on(
+    streamId: string,
+    handler: (data: unknown) => void | Promise<void>
+  ): { off: () => void } {
+    return this.#getManager().on(streamId, handler);
+  }
+
+  public once(streamId: string, options?: InputStreamOnceOptions): InputStreamOncePromise<unknown> {
+    return this.#getManager().once(streamId, options);
+  }
+
+  public peek(streamId: string): unknown | undefined {
+    return this.#getManager().peek(streamId);
+  }
+
+  public lastSeqNum(streamId: string): number | undefined {
+    return this.#getManager().lastSeqNum(streamId);
+  }
+
+  public clearHandlers(): void {
+    this.#getManager().clearHandlers();
+  }
+
+  public reset(): void {
+    this.#getManager().reset();
+  }
+
+  public disconnect(): void {
+    this.#getManager().disconnect();
+  }
+
+  public connectTail(runId: string, fromSeq?: number): void {
+    this.#getManager().connectTail(runId, fromSeq);
+  }
+}
diff --git a/packages/core/src/v3/inputStreams/manager.ts b/packages/core/src/v3/inputStreams/manager.ts
new file mode 100644
index 00000000000..f393f4a169a
--- /dev/null
+++ b/packages/core/src/v3/inputStreams/manager.ts
@@ -0,0 +1,353 @@
+import { ApiClient } from "../apiClient/index.js";
+import {
+  InputStreamManager,
+  InputStreamOncePromise,
+  InputStreamOnceResult,
+  InputStreamTimeoutError,
+} from "./types.js";
+import { InputStreamOnceOptions } from "../realtimeStreams/types.js";
+
+type InputStreamHandler = (data: unknown) => void | Promise<void>;
+
+type OnceWaiter = {
+  resolve: (result: InputStreamOnceResult<unknown>) => void;
+  reject: (error: Error) => void;
+  timeoutHandle?: ReturnType<typeof setTimeout>;
+};
+
+
+type TailState = {
+  abortController: AbortController;
+  promise: Promise<void>;
+};
+
+export class StandardInputStreamManager implements InputStreamManager {
+  private handlers = new Map<string, Set<InputStreamHandler>>();
+  private onceWaiters = new Map<string, OnceWaiter[]>();
+  private buffer = new Map<string, unknown[]>();
+  private tails = new Map<string, TailState>();
+  private seqNums = new Map<string, number>();
+  private currentRunId: string | null = null;
+  private streamsVersion: string | undefined;
+
+  constructor(
+    private apiClient: ApiClient,
+    private baseUrl: string,
+    private debug: boolean = false
+  ) {}
+
+  lastSeqNum(streamId: string): number | undefined {
+    return this.seqNums.get(streamId);
+  }
+
+  setRunId(runId: string, streamsVersion?: string): void {
+    this.currentRunId = runId;
+    this.streamsVersion = streamsVersion;
+  }
+
+  on(streamId: string, handler: InputStreamHandler): { off: () => void } {
+    this.#requireV2Streams();
+
+    let handlerSet = this.handlers.get(streamId);
+    if (!handlerSet) {
+      handlerSet = new Set();
+      this.handlers.set(streamId, handlerSet);
+    }
+    handlerSet.add(handler);
+
+    // Lazily connect a tail for this stream
+    this.#ensureStreamTailConnected(streamId);
+
+    // Flush any buffered data for this stream
+    const buffered = this.buffer.get(streamId);
+    if (buffered && buffered.length > 0) {
+      for (const data of buffered) {
+        this.#invokeHandler(handler, data);
+      }
+      this.buffer.delete(streamId);
+    }
+
+    return {
+      off: () => {
+        handlerSet?.delete(handler);
+        if (handlerSet?.size === 0) {
+          this.handlers.delete(streamId);
+        }
+      },
+    };
+  }
+
+  once(streamId: string, options?: InputStreamOnceOptions): InputStreamOncePromise<unknown> {
+    this.#requireV2Streams();
+
+    // Lazily connect a tail for this stream
+    this.#ensureStreamTailConnected(streamId);
+
+    // Check buffer first
+    const buffered = this.buffer.get(streamId);
+    if (buffered && buffered.length > 0) {
+      const data = buffered.shift()!;
+      if (buffered.length === 0) {
+        this.buffer.delete(streamId);
+      }
+      return new InputStreamOncePromise((resolve) => {
+        resolve({ ok: true, output: data });
+      });
+    }
+
+    return new InputStreamOncePromise<unknown>((resolve, reject) => {
+      const waiter: OnceWaiter = { resolve, reject };
+
+      // Handle abort signal
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          reject(new Error("Aborted"));
+          return;
+        }
+        options.signal.addEventListener(
+          "abort",
+          () => {
+            if (waiter.timeoutHandle) {
+              clearTimeout(waiter.timeoutHandle);
+            }
+            this.#removeOnceWaiter(streamId, waiter);
+            reject(new Error("Aborted"));
+          },
+          { once: true }
+        );
+      }
+
+      // Handle timeout — resolve with error result instead of rejecting
+      if (options?.timeoutMs) {
+        waiter.timeoutHandle = setTimeout(() => {
+          this.#removeOnceWaiter(streamId, waiter);
+          resolve({
+            ok: false,
+            error: new InputStreamTimeoutError(streamId, options.timeoutMs!),
+          });
+        }, options.timeoutMs);
+      }
+
+      let waiters = this.onceWaiters.get(streamId);
+      if (!waiters) {
+        waiters = [];
+        this.onceWaiters.set(streamId, waiters);
+      }
+      waiters.push(waiter);
+    });
+  }
+
+  peek(streamId: string): unknown | undefined {
+    const buffered = this.buffer.get(streamId);
+    if (buffered && buffered.length > 0) {
+      return buffered[0];
+    }
+    return undefined;
+  }
+
+  clearHandlers(): void {
+    this.handlers.clear();
+
+    // Abort tails that no longer have any once waiters either
+    for (const [streamId, tail] of this.tails) {
+      const hasWaiters = this.onceWaiters.has(streamId) && this.onceWaiters.get(streamId)!.length > 0;
+      if (!hasWaiters) {
+        tail.abortController.abort();
+        this.tails.delete(streamId);
+      }
+    }
+  }
+
+  connectTail(runId: string, _fromSeq?: number): void {
+    // No-op: tails are now created per-stream lazily
+  }
+
+  disconnect(): void {
+    for (const [, tail] of this.tails) {
+      tail.abortController.abort();
+    }
+    this.tails.clear();
+  }
+
+  reset(): void {
+    this.disconnect();
+    this.currentRunId = null;
+    this.streamsVersion = undefined;
+    this.seqNums.clear();
+    this.handlers.clear();
+
+    // Reject all pending once waiters
+    for (const [, waiters] of this.onceWaiters) {
+      for (const waiter of waiters) {
+        if (waiter.timeoutHandle) {
+          clearTimeout(waiter.timeoutHandle);
+        }
+        waiter.reject(new Error("Input stream manager reset"));
+      }
+    }
+    this.onceWaiters.clear();
+    this.buffer.clear();
+  }
+
+  #requireV2Streams(): void {
+    if (this.currentRunId && this.streamsVersion !== "v2") {
+      throw new Error(
+        "Input streams require v2 realtime streams. Enable them with: { future: { v2RealtimeStreams: true } }"
+      );
+    }
+  }
+
+  #ensureStreamTailConnected(streamId: string): void {
+    if (!this.tails.has(streamId) && this.currentRunId) {
+      const abortController = new AbortController();
+      const promise = this.#runTail(this.currentRunId, streamId, abortController.signal)
+        .catch((error) => {
+          if (this.debug) {
+            console.error(`[InputStreamManager] Tail error for "${streamId}":`, error);
+          }
+        })
+        .finally(() => {
+          this.tails.delete(streamId);
+
+          // Auto-reconnect if there are still active handlers or waiters
+          const hasHandlers =
+            this.handlers.has(streamId) && this.handlers.get(streamId)!.size > 0;
+          const hasWaiters =
+            this.onceWaiters.has(streamId) && this.onceWaiters.get(streamId)!.length > 0;
+          if (hasHandlers || hasWaiters) {
+            this.#ensureStreamTailConnected(streamId);
+          }
+        });
+      this.tails.set(streamId, { abortController, promise });
+    }
+  }
+
+  async #runTail(runId: string, streamId: string, signal: AbortSignal): Promise<void> {
+    try {
+      const lastSeq = this.seqNums.get(streamId);
+      const stream = await this.apiClient.fetchStream<unknown>(
+        runId,
+        `input/${streamId}`,
+        {
+          signal,
+          baseUrl: this.baseUrl,
+          // Max allowed by the SSE endpoint is 600s; the tail will reconnect on close
+          timeoutInSeconds: 600,
+          // Resume from last seen sequence number to avoid replaying history on reconnect
+          lastEventId: lastSeq !== undefined ? String(lastSeq) : undefined,
+          onPart: (part) => {
+            const seqNum = parseInt(part.id, 10);
+            if (Number.isFinite(seqNum)) {
+              this.seqNums.set(streamId, seqNum);
+            }
+          },
+          onComplete: () => {
+            if (this.debug) {
+              console.log(`[InputStreamManager] Tail stream completed for "${streamId}"`);
+            }
+          },
+          onError: (error) => {
+            if (this.debug) {
+              console.error(`[InputStreamManager] Tail stream error for "${streamId}":`, error);
+            }
+          },
+        }
+      );
+
+      for await (const record of stream) {
+        if (signal.aborted) break;
+
+        // S2 SSE returns record bodies as JSON strings; parse if needed
+        let data: unknown;
+        if (typeof record === "string") {
+          try {
+            data = JSON.parse(record);
+          } catch {
+            data = record;
+          }
+        } else {
+          data = record;
+        }
+
+        this.#dispatch(streamId, data);
+      }
+    } catch (error) {
+      // AbortError is expected when disconnecting
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  #dispatch(streamId: string, data: unknown): void {
+    // First try to resolve a once waiter
+    const waiters = this.onceWaiters.get(streamId);
+    if (waiters && waiters.length > 0) {
+      const waiter = waiters.shift()!;
+      if (waiters.length === 0) {
+        this.onceWaiters.delete(streamId);
+      }
+      if (waiter.timeoutHandle) {
+        clearTimeout(waiter.timeoutHandle);
+      }
+      waiter.resolve({ ok: true, output: data });
+      // Also invoke persistent handlers
+      this.#invokeHandlers(streamId, data);
+      return;
+    }
+
+    // Invoke persistent handlers
+    const handlers = this.handlers.get(streamId);
+    if (handlers && handlers.size > 0) {
+      this.#invokeHandlers(streamId, data);
+      return;
+    }
+
+    // No handlers, buffer the data
+    let buffered = this.buffer.get(streamId);
+    if (!buffered) {
+      buffered = [];
+      this.buffer.set(streamId, buffered);
+    }
+    buffered.push(data);
+  }
+
+  #invokeHandlers(streamId: string, data: unknown): void {
+    const handlers = this.handlers.get(streamId);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      this.#invokeHandler(handler, data);
+    }
+  }
+
+  #invokeHandler(handler: InputStreamHandler, data: unknown): void {
+    try {
+      const result = handler(data);
+      // If the handler returns a promise, catch errors silently
+      if (result && typeof result === "object" && "catch" in result) {
+        (result as Promise<void>).catch((error) => {
+          if (this.debug) {
+            console.error("[InputStreamManager] Handler error:", error);
+          }
+        });
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[InputStreamManager] Handler error:", error);
+      }
+    }
+  }
+
+  #removeOnceWaiter(streamId: string, waiter: OnceWaiter): void {
+    const waiters = this.onceWaiters.get(streamId);
+    if (!waiters) return;
+    const index = waiters.indexOf(waiter);
+    if (index !== -1) {
+      waiters.splice(index, 1);
+    }
+    if (waiters.length === 0) {
+      this.onceWaiters.delete(streamId);
+    }
+  }
+}
diff --git a/packages/core/src/v3/inputStreams/noopManager.ts b/packages/core/src/v3/inputStreams/noopManager.ts
new file mode 100644
index 00000000000..6d72d9e2f76
--- /dev/null
+++ b/packages/core/src/v3/inputStreams/noopManager.ts
@@ -0,0 +1,29 @@
+import { InputStreamManager, InputStreamOncePromise } from "./types.js";
+import { InputStreamOnceOptions } from "../realtimeStreams/types.js";
+
+export class NoopInputStreamManager implements InputStreamManager {
+  setRunId(_runId: string, _streamsVersion?: string): void {}
+
+  on(_streamId: string, _handler: (data: unknown) => void | Promise<void>): { off: () => void } {
+    return { off: () => {} };
+  }
+
+  once(_streamId: string, _options?: InputStreamOnceOptions): InputStreamOncePromise<unknown> {
+    return new InputStreamOncePromise(() => {
+      // Never resolves in noop mode
+    });
+  }
+
+  peek(_streamId: string): unknown | undefined {
+    return undefined;
+  }
+
+  lastSeqNum(_streamId: string): number | undefined {
+    return undefined;
+  }
+
+  clearHandlers(): void {}
+  reset(): void {}
+  disconnect(): void {}
+  connectTail(_runId: string, _fromSeq?: number): void {}
+}
diff --git a/packages/core/src/v3/inputStreams/types.ts b/packages/core/src/v3/inputStreams/types.ts
new file mode 100644
index 00000000000..0816c06493f
--- /dev/null
+++ b/packages/core/src/v3/inputStreams/types.ts
@@ -0,0 +1,93 @@
+import { InputStreamOnceOptions } from "../realtimeStreams/types.js";
+
+export class InputStreamTimeoutError extends Error {
+  constructor(
+    public readonly streamId: string,
+    public readonly timeoutMs: number
+  ) {
+    super(`Timeout waiting for input stream "${streamId}" after ${timeoutMs}ms`);
+    this.name = "InputStreamTimeoutError";
+  }
+}
+
+export type InputStreamOnceResult<TData> =
+  | { ok: true; output: TData }
+  | { ok: false; error: InputStreamTimeoutError };
+
+export class InputStreamOncePromise<TData> extends Promise<InputStreamOnceResult<TData>> {
+  constructor(
+    executor: (
+      resolve: (
+        value: InputStreamOnceResult<TData> | PromiseLike<InputStreamOnceResult<TData>>
+      ) => void,
+      reject: (reason?: any) => void
+    ) => void
+  ) {
+    super(executor);
+  }
+
+  unwrap(): Promise<TData> {
+    return this.then((result) => {
+      if (result.ok) {
+        return result.output;
+      } else {
+        throw result.error;
+      }
+    });
+  }
+}
+
+export interface InputStreamManager {
+  /**
+   * Set the current run ID and streams version. The tail connection will be
+   * established lazily when `on()` or `once()` is first called, but only
+   * for v2 (S2-backed) realtime streams.
+   */
+  setRunId(runId: string, streamsVersion?: string): void;
+
+  /**
+   * Register a handler that fires every time data arrives on the given input stream.
+   * Handlers are automatically cleaned up when the task run completes.
+   * Returns `{ off }` for early unsubscription if needed.
+   */
+  on(streamId: string, handler: (data: unknown) => void | Promise<void>): { off: () => void };
+
+  /**
+   * Wait for the next piece of data on the given input stream.
+   * Returns a result object `{ ok, output }` or `{ ok, error }`.
+   * Chain `.unwrap()` to get the data directly or throw on timeout.
+   */
+  once(streamId: string, options?: InputStreamOnceOptions): InputStreamOncePromise<unknown>;
+
+  /**
+   * Non-blocking peek at the most recent data on the given input stream.
+   */
+  peek(streamId: string): unknown | undefined;
+
+  /**
+   * The last S2 sequence number seen for the given input stream.
+   * Used by `.wait()` to tell the server where to check for existing data.
+   */
+  lastSeqNum(streamId: string): number | undefined;
+
+  /**
+   * Clear all persistent `.on()` handlers and abort tails that have no remaining once waiters.
+   * Called automatically when a task run completes.
+   */
+  clearHandlers(): void;
+
+  /**
+   * Reset state between task executions.
+   */
+  reset(): void;
+
+  /**
+   * Disconnect any active tails / connections.
+   */
+  disconnect(): void;
+
+  /**
+   * Connect a tail to receive input stream records for the given run.
+   */
+  connectTail(runId: string, fromSeq?: number): void;
+}
diff --git a/packages/core/src/v3/isomorphic/duration.ts b/packages/core/src/v3/isomorphic/duration.ts
index b4c5cd20d3b..9315f79683d 100644
--- a/packages/core/src/v3/isomorphic/duration.ts
+++ b/packages/core/src/v3/isomorphic/duration.ts
@@ -1,5 +1,15 @@
-export function parseNaturalLanguageDuration(duration: string): Date | undefined {
-  // Handle Code scanning alert #44 (https://github.com/triggerdotdev/trigger.dev/security/code-scanning/44) by limiting the length of the input string
+/**
+ * Parses a natural language duration string into milliseconds.
+ *
+ * @param duration - Duration string like "1s", "5m", "2h", "1d", "1w"
+ * @returns The duration in milliseconds, or undefined if invalid
+ *
+ * @example
+ * parseNaturalLanguageDurationInMs("30m") // 1800000
+ * parseNaturalLanguageDurationInMs("2h") // 7200000
+ */
+export function parseNaturalLanguageDurationInMs(duration: string): number | undefined {
+  // Handle Code scanning alert #44 by limiting the length of the input string
   if (duration.length > 100) {
     return undefined;
   }
@@ -60,11 +70,12 @@ export function parseNaturalLanguageDuration(duration: string): Date | undefined
     }
   }
 
-  if (hasMatch) {
-    return new Date(Date.now() + totalMilliseconds);
-  }
+  return hasMatch ? totalMilliseconds : undefined;
+}
 
-  return undefined;
+export function parseNaturalLanguageDuration(duration: string): Date | undefined {
+  const ms = parseNaturalLanguageDurationInMs(duration);
+  return ms !== undefined ? new Date(Date.now() + ms) : undefined;
 }
 
 export function safeParseNaturalLanguageDuration(duration: string): Date | undefined {
diff --git a/packages/core/src/v3/isomorphic/friendlyId.ts b/packages/core/src/v3/isomorphic/friendlyId.ts
index 90fa31bd573..a230f8c7450 100644
--- a/packages/core/src/v3/isomorphic/friendlyId.ts
+++ b/packages/core/src/v3/isomorphic/friendlyId.ts
@@ -96,6 +96,7 @@ export const WaitpointId = new IdUtil("waitpoint");
 export const BatchId = new IdUtil("batch");
 export const BulkActionId = new IdUtil("bulk");
 export const AttemptId = new IdUtil("attempt");
+export const ErrorId = new IdUtil("error");
 
 export class IdGenerator {
   private alphabet: string;
diff --git a/packages/core/src/v3/otel/diskIoMetrics.ts b/packages/core/src/v3/otel/diskIoMetrics.ts
new file mode 100644
index 00000000000..4018b58e5c7
--- /dev/null
+++ b/packages/core/src/v3/otel/diskIoMetrics.ts
@@ -0,0 +1,92 @@
+import { type MeterProvider } from "@opentelemetry/sdk-metrics";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+
+const SECTOR_SIZE = 512;
+
+const FILTERED_DEVICE_PREFIXES = ["loop", "ram", "dm-"];
+
+type DiskStats = {
+  device: string;
+  readsCompleted: number;
+  sectorsRead: number;
+  writesCompleted: number;
+  sectorsWritten: number;
+};
+
+function parseProcDiskstats(content: string): DiskStats[] {
+  const entries: DiskStats[] = [];
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const fields = trimmed.split(/\s+/);
+    if (fields.length < 14) continue;
+
+    const device = fields[2]!;
+
+    if (FILTERED_DEVICE_PREFIXES.some((prefix) => device.startsWith(prefix))) {
+      continue;
+    }
+
+    entries.push({
+      device,
+      readsCompleted: parseInt(fields[3]!, 10),
+      sectorsRead: parseInt(fields[5]!, 10),
+      writesCompleted: parseInt(fields[7]!, 10),
+      sectorsWritten: parseInt(fields[9]!, 10),
+    });
+  }
+
+  return entries;
+}
+
+export function startDiskIoMetrics(meterProvider: MeterProvider) {
+  try {
+    fs.accessSync("/proc/diskstats", fs.constants.R_OK);
+  } catch {
+    return;
+  }
+
+  const meter = meterProvider.getMeter("system-disk", "1.0.0");
+
+  const ioCounter = meter.createObservableCounter("system.disk.io", {
+    description: "Disk I/O bytes read and written per device",
+    unit: "By",
+  });
+
+  const opsCounter = meter.createObservableCounter("system.disk.operations", {
+    description: "Disk read/write operation counts per device",
+    unit: "{operation}",
+  });
+
+  meter.addBatchObservableCallback(
+    async (obs) => {
+      try {
+        const content = await fsPromises.readFile("/proc/diskstats", "utf-8");
+        const stats = parseProcDiskstats(content);
+
+        for (const entry of stats) {
+          const readAttrs = {
+            "system.device": entry.device,
+            "disk.io.direction": "read",
+          };
+          const writeAttrs = {
+            "system.device": entry.device,
+            "disk.io.direction": "write",
+          };
+
+          obs.observe(ioCounter, entry.sectorsRead * SECTOR_SIZE, readAttrs);
+          obs.observe(ioCounter, entry.sectorsWritten * SECTOR_SIZE, writeAttrs);
+
+          obs.observe(opsCounter, entry.readsCompleted, readAttrs);
+          obs.observe(opsCounter, entry.writesCompleted, writeAttrs);
+        }
+      } catch {
+        // Skip entire cycle on failure
+      }
+    },
+    [ioCounter, opsCounter]
+  );
+}
diff --git a/packages/core/src/v3/otel/filesystemMetrics.ts b/packages/core/src/v3/otel/filesystemMetrics.ts
new file mode 100644
index 00000000000..aa22e9900f7
--- /dev/null
+++ b/packages/core/src/v3/otel/filesystemMetrics.ts
@@ -0,0 +1,134 @@
+import { type MeterProvider } from "@opentelemetry/sdk-metrics";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+
+const VIRTUAL_FS_TYPES = new Set([
+  "proc",
+  "sysfs",
+  "devpts",
+  "tmpfs",
+  "devtmpfs",
+  "cgroup",
+  "cgroup2",
+  "squashfs",
+  "autofs",
+  "debugfs",
+  "securityfs",
+  "pstore",
+  "bpf",
+  "tracefs",
+  "hugetlbfs",
+  "mqueue",
+  "fusectl",
+  "configfs",
+  "binfmt_misc",
+]);
+
+type MountEntry = {
+  device: string;
+  mountpoint: string;
+  fsType: string;
+  options: string;
+};
+
+function parseProcMounts(content: string): MountEntry[] {
+  const entries: MountEntry[] = [];
+
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+
+    const parts = line.split(" ");
+    if (parts.length < 4) continue;
+
+    const fsType = parts[2]!;
+    if (VIRTUAL_FS_TYPES.has(fsType)) continue;
+
+    entries.push({
+      device: parts[0]!,
+      mountpoint: unescapeMountPath(parts[1]!),
+      fsType,
+      options: parts[3]!,
+    });
+  }
+
+  return entries;
+}
+
+function unescapeMountPath(path: string): string {
+  return path.replace(/\\040/g, " ").replace(/\\011/g, "\t");
+}
+
+export function startFilesystemMetrics(meterProvider: MeterProvider) {
+  try {
+    fs.accessSync("/proc/mounts", fs.constants.R_OK);
+  } catch {
+    return;
+  }
+
+  if (typeof fsPromises.statfs !== "function") {
+    return;
+  }
+
+  const meter = meterProvider.getMeter("system-filesystem", "1.0.0");
+
+  const usageCounter = meter.createObservableUpDownCounter("system.filesystem.usage", {
+    description: "Filesystem bytes used, free, and reserved per mountpoint",
+    unit: "By",
+  });
+
+  const utilizationGauge = meter.createObservableGauge("system.filesystem.utilization", {
+    description: "Fraction of filesystem space used (0-1)",
+    unit: "1",
+  });
+
+  meter.addBatchObservableCallback(
+    async (obs) => {
+      try {
+        const mountsContent = await fsPromises.readFile("/proc/mounts", "utf-8");
+        const mounts = parseProcMounts(mountsContent);
+
+        for (const mount of mounts) {
+          try {
+            const stats = await fsPromises.statfs(mount.mountpoint);
+            const bsize = stats.bsize;
+            const total = stats.blocks * bsize;
+            const free = stats.bavail * bsize;
+            const reserved = (stats.bfree - stats.bavail) * bsize;
+            const used = total - stats.bfree * bsize;
+
+            const mode = mount.options.startsWith("ro") ? "ro" : "rw";
+
+            const baseAttrs = {
+              "system.device": mount.device,
+              "system.filesystem.type": mount.fsType,
+              "system.filesystem.mountpoint": mount.mountpoint,
+              "system.filesystem.mode": mode,
+            };
+
+            obs.observe(usageCounter, used, {
+              ...baseAttrs,
+              "system.filesystem.state": "used",
+            });
+            obs.observe(usageCounter, free, {
+              ...baseAttrs,
+              "system.filesystem.state": "free",
+            });
+            obs.observe(usageCounter, reserved, {
+              ...baseAttrs,
+              "system.filesystem.state": "reserved",
+            });
+
+            if (total > 0) {
+              obs.observe(utilizationGauge, used / total, baseAttrs);
+            }
+          } catch {
+            // Skip this mount on statfs failure
+          }
+        }
+      } catch {
+        // Skip entire cycle on failure
+      }
+    },
+    [usageCounter, utilizationGauge]
+  );
+}
diff --git a/packages/core/src/v3/otel/machineId.ts b/packages/core/src/v3/otel/machineId.ts
new file mode 100644
index 00000000000..79f7bc4ba2a
--- /dev/null
+++ b/packages/core/src/v3/otel/machineId.ts
@@ -0,0 +1,4 @@
+import { generateFriendlyId } from "../isomorphic/friendlyId.js";
+import { getEnvVar } from "../utils/getEnv.js";
+
+export const machineId = getEnvVar("TRIGGER_MACHINE_ID") ?? generateFriendlyId("machine");
diff --git a/packages/core/src/v3/otel/nodejsRuntimeMetrics.ts b/packages/core/src/v3/otel/nodejsRuntimeMetrics.ts
new file mode 100644
index 00000000000..aeb4ce4bee5
--- /dev/null
+++ b/packages/core/src/v3/otel/nodejsRuntimeMetrics.ts
@@ -0,0 +1,81 @@
+import { type MeterProvider } from "@opentelemetry/sdk-metrics";
+import type { ObservableGauge } from "@opentelemetry/api";
+import { performance, monitorEventLoopDelay } from "node:perf_hooks";
+
+function tryMonitorEventLoopDelay() {
+  try {
+    const eld = monitorEventLoopDelay({ resolution: 20 });
+    eld.enable();
+    return eld;
+  } catch {
+    // monitorEventLoopDelay is not implemented in Bun
+    return undefined;
+  }
+}
+
+export function startNodejsRuntimeMetrics(meterProvider: MeterProvider) {
+  const meter = meterProvider.getMeter("nodejs-runtime", "1.0.0");
+
+  // Event loop utilization (diff between collection intervals)
+  let lastElu = performance.eventLoopUtilization();
+
+  const eluGauge = meter.createObservableGauge("nodejs.event_loop.utilization", {
+    description: "Event loop utilization over the last collection interval",
+    unit: "1",
+  });
+
+  // Event loop delay histogram (from perf_hooks) — not available in Bun
+  const eld = tryMonitorEventLoopDelay();
+
+  const observables: ObservableGauge[] = [eluGauge];
+
+  let eldP95: ObservableGauge | undefined;
+  let eldMax: ObservableGauge | undefined;
+
+  if (eld) {
+    eldP95 = meter.createObservableGauge("nodejs.event_loop.delay.p95", {
+      description: "p95 event loop delay",
+      unit: "s",
+    });
+    eldMax = meter.createObservableGauge("nodejs.event_loop.delay.max", {
+      description: "Max event loop delay",
+      unit: "s",
+    });
+    observables.push(eldP95, eldMax);
+  }
+
+  // Heap metrics
+  const heapUsed = meter.createObservableGauge("nodejs.heap.used", {
+    description: "V8 heap used",
+    unit: "By",
+  });
+  const heapTotal = meter.createObservableGauge("nodejs.heap.total", {
+    description: "V8 heap total allocated",
+    unit: "By",
+  });
+  observables.push(heapUsed, heapTotal);
+
+  // Single batch callback for all metrics
+  meter.addBatchObservableCallback(
+    (obs) => {
+      // ELU
+      const currentElu = performance.eventLoopUtilization();
+      const diff = performance.eventLoopUtilization(currentElu, lastElu);
+      lastElu = currentElu;
+      obs.observe(eluGauge, diff.utilization);
+
+      // Event loop delay (nanoseconds -> seconds)
+      if (eld && eldP95 && eldMax) {
+        obs.observe(eldP95, eld.percentile(95) / 1e9);
+        obs.observe(eldMax, eld.max / 1e9);
+        eld.reset();
+      }
+
+      // Heap
+      const mem = process.memoryUsage();
+      obs.observe(heapUsed, mem.heapUsed);
+      obs.observe(heapTotal, mem.heapTotal);
+    },
+    observables
+  );
+}
diff --git a/packages/core/src/v3/otel/tracingSDK.ts b/packages/core/src/v3/otel/tracingSDK.ts
index 694212f71b4..a301946c755 100644
--- a/packages/core/src/v3/otel/tracingSDK.ts
+++ b/packages/core/src/v3/otel/tracingSDK.ts
@@ -4,11 +4,14 @@ import {
   TraceFlags,
   TracerProvider,
   diag,
+  metrics,
 } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { TraceState } from "@opentelemetry/core";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { HostMetrics } from "@opentelemetry/host-metrics";
 import { registerInstrumentations, type Instrumentation } from "@opentelemetry/instrumentation";
 import {
   detectResources,
@@ -24,6 +27,13 @@ import {
   ReadableLogRecord,
   SimpleLogRecordProcessor,
 } from "@opentelemetry/sdk-logs";
+import {
+  AggregationType,
+  MeterProvider,
+  PeriodicExportingMetricReader,
+  type MetricReader,
+  type PushMetricExporter,
+} from "@opentelemetry/sdk-metrics";
 import { RandomIdGenerator, SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import {
   BatchSpanProcessor,
@@ -32,7 +42,6 @@ import {
   SimpleSpanProcessor,
   SpanExporter,
 } from "@opentelemetry/sdk-trace-node";
-import { SemanticResourceAttributes, SEMATTRS_HTTP_URL } from "@opentelemetry/semantic-conventions";
 import { VERSION } from "../../version.js";
 import {
   OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
@@ -47,11 +56,17 @@ import {
 import { SemanticInternalAttributes } from "../semanticInternalAttributes.js";
 import { taskContext } from "../task-context-api.js";
 import {
+  BufferingMetricExporter,
   TaskContextLogProcessor,
+  TaskContextMetricExporter,
   TaskContextSpanProcessor,
 } from "../taskContext/otelProcessors.js";
 import { traceContext } from "../trace-context-api.js";
 import { getEnvVar } from "../utils/getEnv.js";
+import { machineId } from "./machineId.js";
+import { startDiskIoMetrics } from "./diskIoMetrics.js";
+import { startFilesystemMetrics } from "./filesystemMetrics.js";
+import { startNodejsRuntimeMetrics } from "./nodejsRuntimeMetrics.js";
 
 export type TracingDiagnosticLogLevel =
   | "none"
@@ -64,12 +79,26 @@ export type TracingDiagnosticLogLevel =
 
 export type TracingSDKConfig = {
   url: string;
+  metricsUrl?: string;
   forceFlushTimeoutMillis?: number;
   instrumentations?: Instrumentation[];
   exporters?: SpanExporter[];
   logExporters?: LogRecordExporter[];
+  metricExporters?: PushMetricExporter[];
+  metricReaders?: MetricReader[];
   diagLogLevel?: TracingDiagnosticLogLevel;
   resource?: Resource;
+  hostMetrics?: boolean;
+  /** Limit host metrics collection to specific groups (e.g. ["process.cpu", "process.memory"]) */
+  hostMetricGroups?: string[];
+  /** Enable Node.js runtime metrics (event loop utilization, heap usage, etc.) */
+  nodejsRuntimeMetrics?: boolean;
+  /** Enable filesystem metrics (Linux only, reads /proc/mounts + fs.statfs) */
+  filesystemMetrics?: boolean;
+  /** Enable disk I/O metrics (Linux only, reads /proc/diskstats) */
+  diskIoMetrics?: boolean;
+  /** Metric instrument name patterns to drop (supports wildcards, e.g. "system.cpu.*") */
+  droppedMetrics?: string[];
 };
 
 const idGenerator = new RandomIdGenerator();
@@ -78,6 +107,7 @@ export class TracingSDK {
   private readonly _logProvider: LoggerProvider;
   private readonly _spanExporter: SpanExporter;
   private readonly _traceProvider: NodeTracerProvider;
+  private readonly _meterProvider: MeterProvider;
 
   public readonly getLogger: LoggerProvider["getLogger"];
   public readonly getTracer: TracerProvider["getTracer"];
@@ -99,13 +129,13 @@ export class TracingSDK {
     })
       .merge(
         resourceFromAttributes({
-          [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
-          [SemanticResourceAttributes.SERVICE_NAME]:
-            getEnvVar("TRIGGER_OTEL_SERVICE_NAME") ?? "trigger.dev",
+          "cloud.provider": "trigger.dev",
+          "service.name": getEnvVar("TRIGGER_OTEL_SERVICE_NAME") ?? "trigger.dev",
           [SemanticInternalAttributes.TRIGGER]: true,
           [SemanticInternalAttributes.CLI_VERSION]: VERSION,
           [SemanticInternalAttributes.SDK_VERSION]: VERSION,
           [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript",
+          [SemanticInternalAttributes.MACHINE_ID]: machineId,
         })
       )
       .merge(resourceFromAttributes(envResourceAttributes))
@@ -259,16 +289,99 @@ export class TracingSDK {
 
     logs.setGlobalLoggerProvider(loggerProvider);
 
+    // Metrics setup
+    const metricsUrl =
+      config.metricsUrl ??
+      getEnvVar("TRIGGER_OTEL_METRICS_ENDPOINT") ??
+      `${config.url}/v1/metrics`;
+
+    const rawMetricExporter = new OTLPMetricExporter({
+      url: metricsUrl,
+      timeoutMillis: config.forceFlushTimeoutMillis,
+    });
+
+    const collectionIntervalMs = parseInt(
+      getEnvVar("TRIGGER_OTEL_METRICS_COLLECTION_INTERVAL_MILLIS") ?? "10000"
+    );
+    const exportIntervalMs = parseInt(
+      getEnvVar("TRIGGER_OTEL_METRICS_EXPORT_INTERVAL_MILLIS") ?? "30000"
+    );
+
+    // Chain: PeriodicReader(10s) → TaskContextMetricExporter → BufferingMetricExporter(30s) → OTLP
+    const bufferingExporter = new BufferingMetricExporter(rawMetricExporter, exportIntervalMs);
+    const metricExporter = new TaskContextMetricExporter(bufferingExporter);
+
+    const exportTimeoutMillis = parseInt(
+      getEnvVar("TRIGGER_OTEL_METRICS_EXPORT_TIMEOUT_MILLIS") ?? "30000"
+    );
+
+    const metricReaders: MetricReader[] = [
+      new PeriodicExportingMetricReader({
+        exporter: metricExporter,
+        exportIntervalMillis: collectionIntervalMs,
+        exportTimeoutMillis: Math.min(exportTimeoutMillis, collectionIntervalMs),
+      }),
+      ...(config.metricExporters ?? []).map(
+        (exporter) =>
+          new PeriodicExportingMetricReader({
+            exporter,
+            exportIntervalMillis: collectionIntervalMs,
+            exportTimeoutMillis: Math.min(exportTimeoutMillis, collectionIntervalMs),
+          })
+      ),
+      ...(config.metricReaders ?? []),
+    ];
+
+    const meterProvider = new MeterProvider({
+      resource: commonResources,
+      readers: metricReaders,
+      views: (config.droppedMetrics ?? []).map((pattern) => ({
+        instrumentName: pattern,
+        aggregation: { type: AggregationType.DROP },
+      })),
+    });
+
+    this._meterProvider = meterProvider;
+    metrics.setGlobalMeterProvider(meterProvider);
+
+    if (config.hostMetrics) {
+      const hostMetrics = new HostMetrics({
+        meterProvider,
+        metricGroups: config.hostMetricGroups,
+      });
+      hostMetrics.start();
+    }
+
+    if (config.nodejsRuntimeMetrics) {
+      startNodejsRuntimeMetrics(meterProvider);
+    }
+
+    if (config.filesystemMetrics) {
+      startFilesystemMetrics(meterProvider);
+    }
+
+    if (config.diskIoMetrics) {
+      startDiskIoMetrics(meterProvider);
+    }
+
     this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
     this.getTracer = traceProvider.getTracer.bind(traceProvider);
   }
 
   public async flush() {
-    await Promise.all([this._traceProvider.forceFlush(), this._logProvider.forceFlush()]);
+    await Promise.all([
+      this._traceProvider.forceFlush(),
+      this._logProvider.forceFlush(),
+      this._meterProvider.forceFlush(),
+    ]);
   }
 
   public async shutdown() {
-    await Promise.all([this._traceProvider.shutdown(), this._logProvider.shutdown()]);
+    await Promise.all([
+      this._traceProvider.shutdown(),
+      this._logProvider.shutdown(),
+      this._meterProvider.shutdown(),
+    ]);
   }
 }
 
@@ -465,7 +578,7 @@ function isSpanInternalOnly(span: ReadableSpan): boolean {
     return true;
   }
 
-  const httpUrl = span.attributes[SEMATTRS_HTTP_URL] ?? span.attributes["url.full"];
+  const httpUrl = span.attributes["http.url"] ?? span.attributes["url.full"];
 
   const url = safeParseUrl(httpUrl);
 
diff --git a/packages/core/src/v3/realtimeStreams/streamInstance.ts b/packages/core/src/v3/realtimeStreams/streamInstance.ts
index 5efbcb225a3..6d8106ffe6c 100644
--- a/packages/core/src/v3/realtimeStreams/streamInstance.ts
+++ b/packages/core/src/v3/realtimeStreams/streamInstance.ts
@@ -52,6 +52,7 @@ export class StreamInstance<T> implements StreamsWriter {
             basin: parsedResponse.basin,
             stream: parsedResponse.streamName ?? this.options.key,
             accessToken: parsedResponse.accessToken,
+            endpoint: parsedResponse.endpoint,
             source: this.options.source,
             signal: this.options.signal,
             debug: this.options.debug,
@@ -103,6 +104,7 @@ type ParsedStreamResponse =
       version: "v2";
       accessToken: string;
       basin: string;
+      endpoint?: string;
       flushIntervalMs?: number;
       maxRetries?: number;
       streamName?: string;
@@ -123,6 +125,7 @@ function parseCreateStreamResponse(
     return { version: "v1" };
   }
 
+  const endpoint = headers?.["x-s2-endpoint"];
   const flushIntervalMs = headers?.["x-s2-flush-interval-ms"];
   const maxRetries = headers?.["x-s2-max-retries"];
   const streamName = headers?.["x-s2-stream-name"];
@@ -131,6 +134,7 @@ function parseCreateStreamResponse(
     version: "v2",
     accessToken,
     basin,
+    endpoint,
     flushIntervalMs: flushIntervalMs ? parseInt(flushIntervalMs) : undefined,
     maxRetries: maxRetries ? parseInt(maxRetries) : undefined,
     streamName,
diff --git a/packages/core/src/v3/realtimeStreams/streamsWriterV2.ts b/packages/core/src/v3/realtimeStreams/streamsWriterV2.ts
index 568ff5574e6..91713630dbe 100644
--- a/packages/core/src/v3/realtimeStreams/streamsWriterV2.ts
+++ b/packages/core/src/v3/realtimeStreams/streamsWriterV2.ts
@@ -6,12 +6,13 @@ export type StreamsWriterV2Options<T = any> = {
   basin: string;
   stream: string;
   accessToken: string;
+  endpoint?: string; // Custom S2 endpoint (for s2-lite)
   source: ReadableStream<T>;
   signal?: AbortSignal;
   flushIntervalMs?: number; // Used as lingerDuration for BatchTransform (default 200ms)
   maxRetries?: number; // Not used with appendSession, kept for compatibility
   debug?: boolean; // Enable debug logging (default false)
-  maxQueuedBytes?: number; // Max queued bytes for appendSession (default 10MB)
+  maxInflightBytes?: number; // Max queued bytes for appendSession (default 10MB)
 };
 
 /**
@@ -50,18 +51,28 @@ export class StreamsWriterV2<T = any> implements StreamsWriter {
   private streamPromise: Promise<void>;
   private readonly flushIntervalMs: number;
   private readonly debug: boolean;
-  private readonly maxQueuedBytes: number;
+  private readonly maxInflightBytes: number;
   private aborted = false;
   private sessionWritable: WritableStream<any> | null = null;
 
   constructor(private options: StreamsWriterV2Options<T>) {
     this.debug = options.debug ?? false;
-    this.s2Client = new S2({ accessToken: options.accessToken });
+    this.s2Client = new S2({
+      accessToken: options.accessToken,
+      ...(options.endpoint
+        ? {
+            endpoints: {
+              account: options.endpoint,
+              basin: options.endpoint,
+            },
+          }
+        : {}),
+    });
     this.flushIntervalMs = options.flushIntervalMs ?? 200;
-    this.maxQueuedBytes = options.maxQueuedBytes ?? 1024 * 1024 * 10; // 10MB default
+    this.maxInflightBytes = options.maxInflightBytes ?? 1024 * 1024 * 10; // 10MB default
 
     this.log(
-      `[S2MetadataStream] Initializing: basin=${options.basin}, stream=${options.stream}, flushIntervalMs=${this.flushIntervalMs}, maxQueuedBytes=${this.maxQueuedBytes}`
+      `[S2MetadataStream] Initializing: basin=${options.basin}, stream=${options.stream}, flushIntervalMs=${this.flushIntervalMs}, maxInflightBytes=${this.maxInflightBytes}`
     );
 
     // Check if already aborted
@@ -124,7 +135,7 @@ export class StreamsWriterV2<T = any> implements StreamsWriter {
       const stream = basin.stream(this.options.stream);
 
       const session = await stream.appendSession({
-        maxQueuedBytes: this.maxQueuedBytes,
+        maxInflightBytes: this.maxInflightBytes,
       });
 
       this.sessionWritable = session.writable;
@@ -141,7 +152,7 @@ export class StreamsWriterV2<T = any> implements StreamsWriter {
                 return;
               }
               // Convert each chunk to JSON string and wrap in AppendRecord
-              controller.enqueue(AppendRecord.make(JSON.stringify({ data: chunk, id: nanoid(7) })));
+              controller.enqueue(AppendRecord.string({ body: JSON.stringify({ data: chunk, id: nanoid(7) }) }));
             },
           })
         )
@@ -158,9 +169,9 @@ export class StreamsWriterV2<T = any> implements StreamsWriter {
       const lastAcked = session.lastAckedPosition();
 
       if (lastAcked?.end) {
-        const recordsWritten = lastAcked.end.seq_num;
+        const recordsWritten = lastAcked.end.seqNum;
         this.log(
-          `[S2MetadataStream] Written ${recordsWritten} records, ending at seq_num=${lastAcked.end.seq_num}`
+          `[S2MetadataStream] Written ${recordsWritten} records, ending at seqNum=${lastAcked.end.seqNum}`
         );
       }
     } catch (error) {
diff --git a/packages/core/src/v3/realtimeStreams/types.ts b/packages/core/src/v3/realtimeStreams/types.ts
index 25f116d5d96..174970c2830 100644
--- a/packages/core/src/v3/realtimeStreams/types.ts
+++ b/packages/core/src/v3/realtimeStreams/types.ts
@@ -1,6 +1,10 @@
 import { AnyZodFetchOptions, ApiRequestOptions } from "../apiClient/core.js";
+import type { InputStreamOncePromise } from "../inputStreams/types.js";
+export { InputStreamOncePromise, InputStreamTimeoutError } from "../inputStreams/types.js";
+export type { InputStreamOnceResult } from "../inputStreams/types.js";
 import { AsyncIterableStream } from "../streams/asyncIterableStream.js";
 import { Prettify } from "../types/utils.js";
+import type { ManualWaitpointPromise } from "../waitpoints/index.js";
 
 export type RealtimeStreamOperationOptions = {
   signal?: AbortSignal;
@@ -143,3 +147,106 @@ export type WriterStreamOptions<TPart> = Prettify<
     }) => Promise<void> | void;
   }
 >;
+
+// --- Input streams (inbound data to running tasks) ---
+
+/**
+ * A defined input stream that can receive typed data from external callers.
+ *
+ * Inside a task, use `.on()`, `.once()`, or `.peek()` to receive data.
+ * Outside a task, use `.send()` to send data to a running task.
+ */
+export type RealtimeDefinedInputStream<TData> = {
+  id: string;
+  /**
+   * Register a handler that fires every time data arrives on this input stream.
+   * Handlers are automatically cleaned up when the task run completes, so calling
+   * `.off()` is optional. Returns a subscription with `.off()` for early unsubscription.
+   */
+  on: (handler: (data: TData) => void | Promise<void>) => InputStreamSubscription;
+  /**
+   * Wait for the next piece of data on this input stream.
+   * Returns a result object `{ ok, output }` or `{ ok, error }`.
+   * Chain `.unwrap()` to get the data directly or throw on timeout.
+   */
+  once: (options?: InputStreamOnceOptions) => InputStreamOncePromise<TData>;
+  /**
+   * Non-blocking peek at the most recent data received on this input stream.
+   * Returns `undefined` if no data has been received yet.
+   */
+  peek: () => TData | undefined;
+  /**
+   * Suspend the task until data arrives on this input stream.
+   *
+   * Unlike `.once()` which keeps the task process alive while waiting,
+   * `.wait()` suspends the task entirely — freeing compute resources.
+   * The task resumes when data is sent via `.send()`.
+   *
+   * Uses a waitpoint token internally. Can only be called inside a task.run().
+   */
+  wait: (options?: InputStreamWaitOptions) => ManualWaitpointPromise<TData>;
+  /**
+   * Send data to this input stream on a specific run.
+   * This is used from outside the task (e.g., from your backend or another task).
+   */
+  send: (runId: string, data: TData, options?: SendInputStreamOptions) => Promise<void>;
+};
+
+export type InputStreamSubscription = {
+  off: () => void;
+};
+
+export type InputStreamOnceOptions = {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+};
+
+export type SendInputStreamOptions = {
+  requestOptions?: ApiRequestOptions;
+};
+
+export type InputStreamWaitOptions = {
+  /**
+   * Maximum time to wait before the waitpoint times out.
+   * Uses the same period format as `wait.createToken()`.
+   * If the timeout is reached, the result will be `{ ok: false, error }`.
+   *
+   * @example "30s", "5m", "1h", "24h", "7d"
+   */
+  timeout?: string;
+
+  /**
+   * Idempotency key for the underlying waitpoint token.
+   * If the same key is used again (and hasn't expired), the existing
+   * waitpoint is reused. This means if the task retries, it will
+   * resume waiting on the same waitpoint rather than creating a new one.
+   */
+  idempotencyKey?: string;
+
+  /**
+   * TTL for the idempotency key. After this period, the same key
+   * will create a new waitpoint.
+   */
+  idempotencyKeyTTL?: string;
+
+  /**
+   * Tags for the underlying waitpoint token, useful for querying
+   * and filtering waitpoints via `wait.listTokens()`.
+   */
+  tags?: string[];
+};
+
+export type InferInputStreamType<T> = T extends RealtimeDefinedInputStream<infer TData>
+  ? TData
+  : unknown;
+
+/**
+ * Internal record format for multiplexed input stream data on S2.
+ * All input streams for a run share a single S2 stream, demuxed by `stream` field.
+ */
+export type InputStreamRecord = {
+  stream: string;
+  data: unknown;
+  ts: number;
+  id: string;
+};
diff --git a/packages/core/src/v3/resource-catalog/catalog.ts b/packages/core/src/v3/resource-catalog/catalog.ts
index 9ad14dd8484..5b3ab023639 100644
--- a/packages/core/src/v3/resource-catalog/catalog.ts
+++ b/packages/core/src/v3/resource-catalog/catalog.ts
@@ -1,5 +1,5 @@
-import { QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
-import { TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
+import { PromptManifest, QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
+import { PromptMetadataWithFunctions, TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
 
 export interface ResourceCatalog {
   setCurrentFileContext(filePath: string, entryPoint: string): void;
@@ -14,4 +14,8 @@ export interface ResourceCatalog {
   registerQueueMetadata(queue: QueueManifest): void;
   listQueueManifests(): Array<QueueManifest>;
   getTaskSchema(id: string): TaskSchema | undefined;
+  registerPromptMetadata(prompt: PromptMetadataWithFunctions): void;
+  listPromptManifests(): Array<PromptManifest>;
+  getPrompt(id: string): PromptMetadataWithFunctions | undefined;
+  getPromptSchema(id: string): TaskSchema | undefined;
 }
diff --git a/packages/core/src/v3/resource-catalog/index.ts b/packages/core/src/v3/resource-catalog/index.ts
index a564648fcc3..9ce7dee64cf 100644
--- a/packages/core/src/v3/resource-catalog/index.ts
+++ b/packages/core/src/v3/resource-catalog/index.ts
@@ -1,7 +1,7 @@
 const API_NAME = "resource-catalog";
 
-import { QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
-import { TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
+import { PromptManifest, QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
+import { PromptMetadataWithFunctions, TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
 import { getGlobal, registerGlobal, unregisterGlobal } from "../utils/globals.js";
 import { type ResourceCatalog } from "./catalog.js";
 import { NoopResourceCatalog } from "./noopResourceCatalog.js";
@@ -77,6 +77,22 @@ export class ResourceCatalogAPI {
     return this.#getCatalog().listQueueManifests();
   }
 
+  public registerPromptMetadata(prompt: PromptMetadataWithFunctions): void {
+    this.#getCatalog().registerPromptMetadata(prompt);
+  }
+
+  public listPromptManifests(): Array<PromptManifest> {
+    return this.#getCatalog().listPromptManifests();
+  }
+
+  public getPrompt(id: string): PromptMetadataWithFunctions | undefined {
+    return this.#getCatalog().getPrompt(id);
+  }
+
+  public getPromptSchema(id: string): TaskSchema | undefined {
+    return this.#getCatalog().getPromptSchema(id);
+  }
+
   #getCatalog(): ResourceCatalog {
     return getGlobal(API_NAME) ?? NOOP_RESOURCE_CATALOG;
   }
diff --git a/packages/core/src/v3/resource-catalog/noopResourceCatalog.ts b/packages/core/src/v3/resource-catalog/noopResourceCatalog.ts
index 53a953393aa..8f77544f05c 100644
--- a/packages/core/src/v3/resource-catalog/noopResourceCatalog.ts
+++ b/packages/core/src/v3/resource-catalog/noopResourceCatalog.ts
@@ -1,5 +1,5 @@
-import { QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
-import { TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
+import { PromptManifest, QueueManifest, TaskManifest, WorkerManifest } from "../schemas/index.js";
+import { type PromptMetadataWithFunctions, type TaskMetadataWithFunctions, type TaskSchema } from "../types/index.js";
 import { ResourceCatalog } from "./catalog.js";
 
 export class NoopResourceCatalog implements ResourceCatalog {
@@ -54,4 +54,20 @@ export class NoopResourceCatalog implements ResourceCatalog {
   listQueueManifests(): Array<QueueManifest> {
     return [];
   }
+
+  registerPromptMetadata(prompt: PromptMetadataWithFunctions): void {
+    // noop
+  }
+
+  listPromptManifests(): Array<PromptManifest> {
+    return [];
+  }
+
+  getPrompt(id: string): PromptMetadataWithFunctions | undefined {
+    return undefined;
+  }
+
+  getPromptSchema(id: string): TaskSchema | undefined {
+    return undefined;
+  }
 }
diff --git a/packages/core/src/v3/resource-catalog/standardResourceCatalog.ts b/packages/core/src/v3/resource-catalog/standardResourceCatalog.ts
index 3d2f1cadfd3..ea134a45663 100644
--- a/packages/core/src/v3/resource-catalog/standardResourceCatalog.ts
+++ b/packages/core/src/v3/resource-catalog/standardResourceCatalog.ts
@@ -1,11 +1,13 @@
 import {
+  PromptManifest,
+  PromptMetadata,
   TaskFileMetadata,
   TaskMetadata,
   TaskManifest,
   WorkerManifest,
   QueueManifest,
 } from "../schemas/index.js";
-import { TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
+import { PromptMetadataWithFunctions, TaskMetadataWithFunctions, TaskSchema } from "../types/index.js";
 import { ResourceCatalog } from "./catalog.js";
 
 export class StandardResourceCatalog implements ResourceCatalog {
@@ -13,6 +15,10 @@ export class StandardResourceCatalog implements ResourceCatalog {
   private _taskMetadata: Map<string, TaskMetadata> = new Map();
   private _taskFunctions: Map<string, TaskMetadataWithFunctions["fns"]> = new Map();
   private _taskFileMetadata: Map<string, TaskFileMetadata> = new Map();
+  private _promptMetadata: Map<string, PromptMetadata> = new Map();
+  private _promptFunctions: Map<string, PromptMetadataWithFunctions["fns"]> = new Map();
+  private _promptFileMetadata: Map<string, TaskFileMetadata> = new Map();
+  private _promptSchemas: Map<string, TaskSchema> = new Map();
   private _currentFileContext?: Omit<TaskFileMetadata, "exportName">;
   private _queueMetadata: Map<string, QueueManifest> = new Map();
 
@@ -165,6 +171,68 @@ export class StandardResourceCatalog implements ResourceCatalog {
     return this._taskMetadata.has(id);
   }
 
+  registerPromptMetadata(prompt: PromptMetadataWithFunctions): void {
+    if (!this._currentFileContext) {
+      return;
+    }
+
+    const { fns, schema, ...metadata } = prompt;
+
+    if (!prompt.id) {
+      return;
+    }
+
+    this._promptFileMetadata.set(prompt.id, {
+      ...this._currentFileContext,
+    });
+
+    this._promptMetadata.set(prompt.id, metadata);
+    this._promptFunctions.set(prompt.id, fns);
+
+    if (schema) {
+      this._promptSchemas.set(prompt.id, schema);
+    }
+  }
+
+  getPromptSchema(id: string): TaskSchema | undefined {
+    return this._promptSchemas.get(id);
+  }
+
+  listPromptManifests(): Array<PromptManifest> {
+    const result: Array<PromptManifest> = [];
+
+    for (const [id, metadata] of this._promptMetadata) {
+      const fileMetadata = this._promptFileMetadata.get(id);
+
+      if (!fileMetadata) {
+        continue;
+      }
+
+      result.push({
+        ...metadata,
+        ...fileMetadata,
+      });
+    }
+
+    return result;
+  }
+
+  getPrompt(id: string): PromptMetadataWithFunctions | undefined {
+    const metadata = this._promptMetadata.get(id);
+    const fileMetadata = this._promptFileMetadata.get(id);
+    const fns = this._promptFunctions.get(id);
+
+    if (!metadata || !fns || !fileMetadata) {
+      return undefined;
+    }
+
+    return {
+      ...metadata,
+      ...fileMetadata,
+      fns,
+    };
+  }
+
   disable() {
     // noop
   }
diff --git a/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.test.ts b/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.test.ts
index 5f515b95b79..6093790b012 100644
--- a/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.test.ts
+++ b/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.test.ts
@@ -498,7 +498,7 @@ describe("RunQueueConsumerPool", () => {
         await testConsumers[0].onDequeue(messages);
       }
 
-      expect(mockOnDequeue).toHaveBeenCalledWith(messages);
+      expect(mockOnDequeue).toHaveBeenCalledWith(messages, undefined);
 
       advanceTimeAndProcessMetrics(1100);
       const metrics = pool.getMetrics();
diff --git a/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.ts b/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.ts
index 2dd3d1b898b..d72cef75c7c 100644
--- a/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.ts
+++ b/packages/core/src/v3/runEngineWorker/supervisor/consumerPool.ts
@@ -351,12 +351,12 @@ export class RunQueueConsumerPool {
 
       const consumer = this.consumerFactory({
         ...this.consumerOptions,
-        onDequeue: async (messages) => {
+        onDequeue: async (messages, timing) => {
           // Always update queue length, default to 0 for empty dequeues or missing value
           this.updateQueueLength(messages[0]?.workerQueueLength ?? 0);
 
           // Forward to the original handler
-          await this.consumerOptions.onDequeue(messages);
+          await this.consumerOptions.onDequeue(messages, timing);
         },
       });
 
diff --git a/packages/core/src/v3/runEngineWorker/supervisor/events.ts b/packages/core/src/v3/runEngineWorker/supervisor/events.ts
index a51c504a3e6..df4a93686a9 100644
--- a/packages/core/src/v3/runEngineWorker/supervisor/events.ts
+++ b/packages/core/src/v3/runEngineWorker/supervisor/events.ts
@@ -6,6 +6,8 @@ export type WorkerEvents = {
     {
       time: Date;
       message: DequeuedMessage;
+      dequeueResponseMs?: number;
+      pollingIntervalMs?: number;
     },
   ];
   requestRunAttemptStart: [
diff --git a/packages/core/src/v3/runEngineWorker/supervisor/queueConsumer.ts b/packages/core/src/v3/runEngineWorker/supervisor/queueConsumer.ts
index 4379eb54f37..76faee40809 100644
--- a/packages/core/src/v3/runEngineWorker/supervisor/queueConsumer.ts
+++ b/packages/core/src/v3/runEngineWorker/supervisor/queueConsumer.ts
@@ -15,7 +15,7 @@ export type RunQueueConsumerOptions = {
   preDequeue?: PreDequeueFn;
   preSkip?: PreSkipFn;
   maxRunCount?: number;
-  onDequeue: (messages: WorkerApiDequeueResponseBody) => Promise<void>;
+  onDequeue: (messages: WorkerApiDequeueResponseBody, timing?: { dequeueResponseMs: number; pollingIntervalMs: number }) => Promise<void>;
 };
 
 export class RunQueueConsumer implements QueueConsumer {
@@ -23,13 +23,14 @@ export class RunQueueConsumer implements QueueConsumer {
   private readonly preDequeue?: PreDequeueFn;
   private readonly preSkip?: PreSkipFn;
   private readonly maxRunCount?: number;
-  private readonly onDequeue: (messages: WorkerApiDequeueResponseBody) => Promise<void>;
+  private readonly onDequeue: (messages: WorkerApiDequeueResponseBody, timing?: { dequeueResponseMs: number; pollingIntervalMs: number }) => Promise<void>;
 
   private readonly logger = new SimpleStructuredLogger("queue-consumer");
 
   private intervalMs: number;
   private idleIntervalMs: number;
   private isEnabled: boolean;
+  private lastScheduledIntervalMs: number;
 
   constructor(opts: RunQueueConsumerOptions) {
     this.isEnabled = false;
@@ -38,6 +39,7 @@ export class RunQueueConsumer implements QueueConsumer {
     this.preDequeue = opts.preDequeue;
     this.preSkip = opts.preSkip;
     this.maxRunCount = opts.maxRunCount;
+    this.lastScheduledIntervalMs = opts.idleIntervalMs;
     this.onDequeue = opts.onDequeue;
     this.client = opts.client;
   }
@@ -111,16 +113,18 @@ export class RunQueueConsumer implements QueueConsumer {
     let nextIntervalMs = this.idleIntervalMs;
 
     try {
+      const dequeueStart = performance.now();
       const response = await this.client.dequeue({
         maxResources: preDequeueResult?.maxResources,
         maxRunCount: this.maxRunCount,
       });
+      const dequeueResponseMs = Math.round(performance.now() - dequeueStart);
 
       if (!response.success) {
         this.logger.error("Failed to dequeue", { error: response.error });
       } else {
         try {
-          await this.onDequeue(response.data);
+          await this.onDequeue(response.data, { dequeueResponseMs, pollingIntervalMs: this.lastScheduledIntervalMs });
 
           if (response.data.length > 0) {
             nextIntervalMs = this.intervalMs;
@@ -141,6 +145,7 @@ export class RunQueueConsumer implements QueueConsumer {
       this.logger.verbose("scheduled dequeue with idle interval", { delayMs });
     }
 
+    this.lastScheduledIntervalMs = delayMs;
     setTimeout(this.dequeue.bind(this), delayMs);
   }
 }
diff --git a/packages/core/src/v3/runEngineWorker/supervisor/session.ts b/packages/core/src/v3/runEngineWorker/supervisor/session.ts
index e5a783b8d41..b2d344fb3dc 100644
--- a/packages/core/src/v3/runEngineWorker/supervisor/session.ts
+++ b/packages/core/src/v3/runEngineWorker/supervisor/session.ts
@@ -80,13 +80,15 @@ export class SupervisorSession extends EventEmitter<WorkerEvents> {
     });
   }
 
-  private async onDequeue(messages: WorkerApiDequeueResponseBody): Promise<void> {
+  private async onDequeue(messages: WorkerApiDequeueResponseBody, timing?: { dequeueResponseMs: number; pollingIntervalMs: number }): Promise<void> {
     this.logger.verbose("Dequeued messages with contents", { count: messages.length, messages });
 
     for (const message of messages) {
       this.emit("runQueueMessage", {
         time: new Date(),
         message,
+        dequeueResponseMs: timing?.dequeueResponseMs,
+        pollingIntervalMs: timing?.pollingIntervalMs,
       });
     }
   }
diff --git a/packages/core/src/v3/schemas/api-type.test.ts b/packages/core/src/v3/schemas/api-type.test.ts
new file mode 100644
index 00000000000..c936b3c769d
--- /dev/null
+++ b/packages/core/src/v3/schemas/api-type.test.ts
@@ -0,0 +1,141 @@
+import { describe, it, expect } from "vitest";
+import { InitializeDeploymentRequestBody } from "./api.js";
+import type { InitializeDeploymentRequestBody as InitializeDeploymentRequestBodyType } from "./api.js";
+
+describe("InitializeDeploymentRequestBody", () => {
+  const base = { contentHash: "abc123" };
+
+  describe("non-native build variant (isNativeBuild omitted or false)", () => {
+    it("parses with only required fields", () => {
+      const result = InitializeDeploymentRequestBody.safeParse(base);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.isNativeBuild).toBe(false);
+      }
+    });
+
+    it("parses with isNativeBuild explicitly false", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({ ...base, isNativeBuild: false });
+      expect(result.success).toBe(true);
+    });
+
+    it("parses with optional base fields", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        userId: "user_1",
+        type: "MANAGED",
+        runtime: "node",
+        initialStatus: "PENDING",
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("strips native-only fields when isNativeBuild is false", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        isNativeBuild: false,
+        skipPromotion: true,
+      });
+      // Zod discriminatedUnion matches the non-native branch and strips unknown keys
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect("skipPromotion" in result.data).toBe(false);
+      }
+    });
+  });
+
+  describe("native build variant (isNativeBuild: true)", () => {
+    it("parses with isNativeBuild true", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        isNativeBuild: true,
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.isNativeBuild).toBe(true);
+      }
+    });
+
+    it("parses with native-specific optional fields", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        isNativeBuild: true,
+        skipPromotion: true,
+        artifactKey: "artifact_abc",
+        configFilePath: "trigger.config.ts",
+        skipEnqueue: true,
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.skipPromotion).toBe(true);
+        expect(result.data.artifactKey).toBe("artifact_abc");
+        expect(result.data.configFilePath).toBe("trigger.config.ts");
+        expect(result.data.skipEnqueue).toBe(true);
+      }
+    });
+
+    it("skipEnqueue defaults to false when omitted", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        isNativeBuild: true,
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.skipEnqueue).toBe(false);
+      }
+    });
+  });
+
+  describe("rejects invalid inputs", () => {
+    it("rejects missing contentHash", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({});
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects invalid type enum value", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        type: "INVALID",
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects invalid initialStatus enum value", () => {
+      const result = InitializeDeploymentRequestBody.safeParse({
+        ...base,
+        initialStatus: "RUNNING",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("type-level checks", () => {
+    it("native variant exposes native-specific fields", () => {
+      const result = InitializeDeploymentRequestBody.parse({
+        ...base,
+        isNativeBuild: true,
+        skipPromotion: true,
+      });
+
+      if (result.isNativeBuild === true) {
+        const _skipPromotion: boolean | undefined = result.skipPromotion;
+        const _artifactKey: string | undefined = result.artifactKey;
+        const _configFilePath: string | undefined = result.configFilePath;
+        expect(_skipPromotion).toBe(true);
+        expect(_artifactKey).toBeUndefined();
+        expect(_configFilePath).toBeUndefined();
+      }
+    });
+
+    it("non-native variant narrows correctly", () => {
+      const result: InitializeDeploymentRequestBodyType =
+        InitializeDeploymentRequestBody.parse(base);
+
+      if (!result.isNativeBuild) {
+        // Should only have base fields — native-specific fields should not exist
+        const narrowed: { isNativeBuild?: false; contentHash: string } = result;
+        expect(narrowed.contentHash).toBe("abc123");
+      }
+    });
+  });
+});
diff --git a/packages/core/src/v3/schemas/api.ts b/packages/core/src/v3/schemas/api.ts
index abf6bf11240..6d324a10d11 100644
--- a/packages/core/src/v3/schemas/api.ts
+++ b/packages/core/src/v3/schemas/api.ts
@@ -149,6 +149,14 @@ export const RunTags = z.union([RunTag, RunTag.array()]);
 
 export type RunTags = z.infer<typeof RunTags>;
 
+/** Stores the original user-provided idempotency key and scope */
+export const IdempotencyKeyOptionsSchema = z.object({
+  key: z.string(),
+  scope: z.enum(["run", "attempt", "global"]),
+});
+
+export type IdempotencyKeyOptionsSchema = z.infer<typeof IdempotencyKeyOptionsSchema>;
+
 export const TriggerTaskRequestBody = z.object({
   payload: z.any(),
   context: z.any(),
@@ -191,6 +199,8 @@ export const TriggerTaskRequestBody = z.object({
       delay: z.string().or(z.coerce.date()).optional(),
       idempotencyKey: z.string().optional(),
       idempotencyKeyTTL: z.string().optional(),
+      /** The original user-provided idempotency key and scope */
+      idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
       machine: MachinePresetName.optional(),
       maxAttempts: z.number().int().optional(),
       maxDuration: z.number().optional(),
@@ -208,6 +218,7 @@ export const TriggerTaskRequestBody = z.object({
           key: z.string().max(512),
           delay: z.string(),
           mode: z.enum(["leading", "trailing"]).optional(),
+          maxDelay: z.string().optional(),
         })
         .optional(),
     })
@@ -240,6 +251,8 @@ export const BatchTriggerTaskItem = z.object({
       delay: z.string().or(z.coerce.date()).optional(),
       idempotencyKey: z.string().optional(),
       idempotencyKeyTTL: z.string().optional(),
+      /** The original user-provided idempotency key and scope */
+      idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
       lockToVersion: z.string().optional(),
       machine: MachinePresetName.optional(),
       maxAttempts: z.number().int().optional(),
@@ -263,6 +276,7 @@ export const BatchTriggerTaskItem = z.object({
           key: z.string().max(512),
           delay: z.string(),
           mode: z.enum(["leading", "trailing"]).optional(),
+          maxDelay: z.string().optional(),
         })
         .optional(),
     })
@@ -345,6 +359,8 @@ export const CreateBatchRequestBody = z.object({
   resumeParentOnCompletion: z.boolean().optional(),
   /** Idempotency key for the batch */
   idempotencyKey: z.string().optional(),
+  /** The original user-provided idempotency key and scope */
+  idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
 });
 
 export type CreateBatchRequestBody = z.infer<typeof CreateBatchRequestBody>;
@@ -469,10 +485,22 @@ export const FinalizeDeploymentRequestBody = z.object({
 
 export type FinalizeDeploymentRequestBody = z.infer<typeof FinalizeDeploymentRequestBody>;
 
+export const BuildServerMetadata = z.object({
+  buildId: z.string().optional(),
+  isNativeBuild: z.boolean().optional(),
+  artifactKey: z.string().optional(),
+  skipPromotion: z.boolean().optional(),
+  configFilePath: z.string().optional(),
+  skipEnqueue: z.boolean().optional(),
+});
+
+export type BuildServerMetadata = z.infer<typeof BuildServerMetadata>;
+
 export const ProgressDeploymentRequestBody = z.object({
   contentHash: z.string().optional(),
   gitMeta: GitMeta.optional(),
   runtime: z.string().optional(),
+  buildServerMetadata: BuildServerMetadata.optional(),
 });
 
 export type ProgressDeploymentRequestBody = z.infer<typeof ProgressDeploymentRequestBody>;
@@ -512,15 +540,8 @@ export const DeploymentTriggeredVia = z
 
 export type DeploymentTriggeredVia = z.infer<typeof DeploymentTriggeredVia>;
 
-export const BuildServerMetadata = z.object({
-  buildId: z.string().optional(),
-  isNativeBuild: z.boolean().optional(),
-  artifactKey: z.string().optional(),
-  skipPromotion: z.boolean().optional(),
-  configFilePath: z.string().optional(),
-});
-
-export type BuildServerMetadata = z.infer<typeof BuildServerMetadata>;
+// TriggerSource, TriggerAction, and RunAnnotations are defined in runEngine.ts
+// They are re-exported through the schemas barrel (index.ts)
 
 export const UpsertBranchRequestBody = z.object({
   git: GitMeta.optional(),
@@ -574,41 +595,54 @@ export const InitializeDeploymentResponseBody = z.object({
 
 export type InitializeDeploymentResponseBody = z.infer<typeof InitializeDeploymentResponseBody>;
 
-export const InitializeDeploymentRequestBody = z
-  .object({
-    contentHash: z.string(),
-    userId: z.string().optional(),
-    /** @deprecated This is now determined by the webapp. This is only used to warn users with old CLI versions. */
-    selfHosted: z.boolean().optional(),
-    gitMeta: GitMeta.optional(),
-    type: z.enum(["MANAGED", "UNMANAGED", "V1"]).optional(),
-    runtime: z.string().optional(),
-    initialStatus: z.enum(["PENDING", "BUILDING"]).optional(),
-    triggeredVia: DeploymentTriggeredVia.optional(),
-    buildId: z.string().optional(),
-  })
-  .and(
-    z.preprocess(
-      (val) => {
-        const obj = val as any;
-        if (!obj || !obj.isNativeBuild) {
-          return { ...obj, isNativeBuild: false };
-        }
-        return obj;
-      },
-      z.discriminatedUnion("isNativeBuild", [
-        z.object({
-          isNativeBuild: z.literal(true),
-          skipPromotion: z.boolean(),
-          artifactKey: z.string(),
-          configFilePath: z.string().optional(),
-        }),
-        z.object({
-          isNativeBuild: z.literal(false),
-        }),
-      ])
-    )
-  );
+const InitializeDeploymentRequestBodyBase = z.object({
+  contentHash: z.string(),
+  userId: z.string().optional(),
+  /** @deprecated This is now determined by the webapp. This is only used to warn users with old CLI versions. */
+  selfHosted: z.boolean().optional(),
+  gitMeta: GitMeta.optional(),
+  type: z.enum(["MANAGED", "UNMANAGED", "V1"]).optional(),
+  runtime: z.string().optional(),
+  initialStatus: z.enum(["PENDING", "BUILDING"]).optional(),
+  isLocalBuild: z.boolean().optional(),
+  triggeredVia: DeploymentTriggeredVia.optional(),
+  buildId: z.string().optional(),
+});
+type BaseOutput = z.output<typeof InitializeDeploymentRequestBodyBase>;
+
+type NativeBuildOutput = BaseOutput & {
+  isNativeBuild: true;
+  skipPromotion?: boolean;
+  artifactKey?: string;
+  configFilePath?: string;
+  skipEnqueue?: boolean;
+};
+
+type NonNativeBuildOutput = BaseOutput & {
+  isNativeBuild: false;
+  skipPromotion?: never;
+  artifactKey?: never;
+  configFilePath?: never;
+  skipEnqueue?: never;
+};
+
+const InitializeDeploymentRequestBodyFull = InitializeDeploymentRequestBodyBase.extend({
+  isNativeBuild: z.boolean().default(false),
+  skipPromotion: z.boolean().optional(),
+  artifactKey: z.string().optional(),
+  configFilePath: z.string().optional(),
+  skipEnqueue: z.boolean().optional().default(false),
+});
+
+export const InitializeDeploymentRequestBody = InitializeDeploymentRequestBodyFull.transform(
+  (data): NativeBuildOutput | NonNativeBuildOutput => {
+    if (data.isNativeBuild) {
+      return { ...data, isNativeBuild: true as const };
+    }
+    const { skipPromotion, artifactKey, configFilePath, skipEnqueue, ...rest } = data;
+    return { ...rest, isNativeBuild: false as const };
+  }
+);
 
 export type InitializeDeploymentRequestBody = z.infer<typeof InitializeDeploymentRequestBody>;
 
@@ -678,6 +712,7 @@ export const GetDeploymentResponseBody = z.object({
   version: z.string(),
   imageReference: z.string().nullish(),
   imagePlatform: z.string(),
+  commitSHA: z.string().nullish(),
   externalBuildData: ExternalBuildData.optional().nullable(),
   errorData: DeploymentErrorData.nullish(),
   worker: z
@@ -694,6 +729,17 @@ export const GetDeploymentResponseBody = z.object({
       ),
     })
     .optional(),
+  integrationDeployments: z
+    .array(
+      z.object({
+        id: z.string(),
+        integrationName: z.string(),
+        integrationDeploymentId: z.string(),
+        commitSHA: z.string(),
+        createdAt: z.coerce.date(),
+      })
+    )
+    .nullish(),
 });
 
 export type GetDeploymentResponseBody = z.infer<typeof GetDeploymentResponseBody>;
@@ -742,6 +788,8 @@ export const DeploymentEventFromString = z
 
 export const CreateUploadPayloadUrlResponseBody = z.object({
   presignedUrl: z.string(),
+  /** Present on `/api/v2/packets` PUT (upload handshake); omitted on v1 GET download presign. */
+  storagePath: z.string().optional(),
 });
 
 export const WorkersListResponseBody = z
@@ -795,6 +843,17 @@ export const DevDequeueResponseBody = z.object({
 });
 export type DevDequeueResponseBody = z.infer<typeof DevDequeueResponseBody>;
 
+export const DevDisconnectRequestBody = z.object({
+  runFriendlyIds: z.string().array(),
+});
+export type DevDisconnectRequestBody = z.infer<typeof DevDisconnectRequestBody>;
+
+export const DevDisconnectResponseBody = z.object({
+  cancelled: z.number(),
+  bulkActionId: z.string().optional(),
+});
+export type DevDisconnectResponseBody = z.infer<typeof DevDisconnectResponseBody>;
+
 export type CreateUploadPayloadUrlResponseBody = z.infer<typeof CreateUploadPayloadUrlResponseBody>;
 
 export const ReplayRunResponse = z.object({
@@ -1123,6 +1182,12 @@ export const ImportEnvironmentVariablesRequestBody = z.object({
   variables: z.record(z.string()),
   parentVariables: z.record(z.string()).optional(),
   override: z.boolean().optional(),
+  source: z
+    .discriminatedUnion("type", [
+      z.object({ type: z.literal("user"), userId: z.string() }),
+      z.object({ type: z.literal("integration"), integration: z.string() }),
+    ])
+    .optional(),
 });
 
 export type ImportEnvironmentVariablesRequestBody = z.infer<
@@ -1321,6 +1386,31 @@ export const CreateWaitpointTokenResponseBody = z.object({
 });
 export type CreateWaitpointTokenResponseBody = z.infer<typeof CreateWaitpointTokenResponseBody>;
 
+export const CreateInputStreamWaitpointRequestBody = z.object({
+  streamId: z.string(),
+  timeout: z.string().optional(),
+  idempotencyKey: z.string().optional(),
+  idempotencyKeyTTL: z.string().optional(),
+  tags: z.union([z.string(), z.array(z.string())]).optional(),
+  /**
+   * The last S2 sequence number the client has seen on this input stream.
+   * Used to check for data that arrived before .wait() was called.
+   * If undefined, the server checks from the beginning of the stream.
+   */
+  lastSeqNum: z.number().optional(),
+});
+export type CreateInputStreamWaitpointRequestBody = z.infer<
+  typeof CreateInputStreamWaitpointRequestBody
+>;
+
+export const CreateInputStreamWaitpointResponseBody = z.object({
+  waitpointId: z.string(),
+  isCached: z.boolean(),
+});
+export type CreateInputStreamWaitpointResponseBody = z.infer<
+  typeof CreateInputStreamWaitpointResponseBody
+>;
+
 export const waitpointTokenStatuses = ["WAITING", "COMPLETED", "TIMED_OUT"] as const;
 export const WaitpointTokenStatus = z.enum(waitpointTokenStatuses);
 export type WaitpointTokenStatus = z.infer<typeof WaitpointTokenStatus>;
@@ -1465,8 +1555,8 @@ export const ApiDeploymentListResponseItem = z.object({
   createdAt: z.coerce.date(),
   shortCode: z.string(),
   version: z.string(),
-  runtime: z.string(),
-  runtimeVersion: z.string(),
+  runtime: z.string().nullable(),
+  runtimeVersion: z.string().nullable(),
   status: z.enum([
     "PENDING",
     "BUILDING",
@@ -1539,6 +1629,54 @@ export const RetrieveRunTraceResponseBody = z.object({
 
 export type RetrieveRunTraceResponseBody = z.infer<typeof RetrieveRunTraceResponseBody>;
 
+export const RetrieveSpanDetailResponseBody = z.object({
+  spanId: z.string(),
+  parentId: z.string().nullable(),
+  runId: z.string(),
+  message: z.string(),
+  isError: z.boolean(),
+  isPartial: z.boolean(),
+  isCancelled: z.boolean(),
+  level: z.string(),
+  startTime: z.coerce.date(),
+  durationMs: z.number(),
+  properties: z.record(z.any()).optional(),
+  events: z.array(z.any()).optional(),
+  entityType: z.string().optional(),
+  ai: z
+    .object({
+      model: z.string(),
+      provider: z.string(),
+      operationName: z.string(),
+      inputTokens: z.number(),
+      outputTokens: z.number(),
+      totalTokens: z.number(),
+      cachedTokens: z.number().optional(),
+      reasoningTokens: z.number().optional(),
+      inputCost: z.number().optional(),
+      outputCost: z.number().optional(),
+      totalCost: z.number().optional(),
+      tokensPerSecond: z.number().optional(),
+      msToFirstChunk: z.number().optional(),
+      durationMs: z.number(),
+      finishReason: z.string().optional(),
+      responseText: z.string().optional(),
+    })
+    .optional(),
+  triggeredRuns: z
+    .array(
+      z.object({
+        runId: z.string(),
+        taskIdentifier: z.string(),
+        status: z.string(),
+        createdAt: z.coerce.date(),
+      })
+    )
+    .optional(),
+});
+
+export type RetrieveSpanDetailResponseBody = z.infer<typeof RetrieveSpanDetailResponseBody>;
+
 export const CreateStreamResponseBody = z.object({
   version: z.string(),
 });
@@ -1549,3 +1687,96 @@ export const AppendToStreamResponseBody = z.object({
   message: z.string().optional(),
 });
 export type AppendToStreamResponseBody = z.infer<typeof AppendToStreamResponseBody>;
+
+export const SendInputStreamResponseBody = z.object({
+  ok: z.boolean(),
+});
+export type SendInputStreamResponseBody = z.infer<typeof SendInputStreamResponseBody>;
+
+export const ResolvePromptRequestBody = z.object({
+  variables: z.record(z.unknown()).default({}),
+  label: z.string().optional(),
+  version: z.number().optional(),
+});
+export type ResolvePromptRequestBody = z.infer<typeof ResolvePromptRequestBody>;
+
+export const ResolvePromptResponseBody = z.object({
+  data: z.object({
+    promptId: z.string(),
+    slug: z.string(),
+    version: z.number(),
+    labels: z.array(z.string()),
+    template: z.string().optional(),
+    text: z.string().optional(),
+    model: z.string().optional().nullable(),
+    config: z.record(z.unknown()).optional().nullable(),
+  }),
+});
+export type ResolvePromptResponseBody = z.infer<typeof ResolvePromptResponseBody>;
+
+export const ListPromptsResponseBody = z.object({
+  data: z.array(
+    z.object({
+      slug: z.string(),
+      friendlyId: z.string(),
+      description: z.string().nullable(),
+      tags: z.array(z.string()),
+      defaultModel: z.string().nullable(),
+      currentVersion: z.number().nullable(),
+      hasOverride: z.boolean(),
+      updatedAt: z.string(),
+    })
+  ),
+});
+export type ListPromptsResponseBody = z.infer<typeof ListPromptsResponseBody>;
+
+export const ListPromptVersionsResponseBody = z.object({
+  data: z.array(
+    z.object({
+      id: z.string(),
+      version: z.number(),
+      labels: z.array(z.string()),
+      source: z.string(),
+      model: z.string().nullable(),
+      textContent: z.string().nullable(),
+      commitMessage: z.string().nullable(),
+      contentHash: z.string(),
+      createdAt: z.string(),
+    })
+  ),
+});
+export type ListPromptVersionsResponseBody = z.infer<typeof ListPromptVersionsResponseBody>;
+
+export const PromotePromptVersionRequestBody = z.object({
+  version: z.number().int().positive(),
+});
+export type PromotePromptVersionRequestBody = z.infer<typeof PromotePromptVersionRequestBody>;
+
+export const CreatePromptOverrideRequestBody = z.object({
+  textContent: z.string(),
+  model: z.string().optional(),
+  commitMessage: z.string().optional(),
+  source: z.string().optional(),
+});
+export type CreatePromptOverrideRequestBody = z.infer<typeof CreatePromptOverrideRequestBody>;
+
+export const UpdatePromptOverrideRequestBody = z.object({
+  textContent: z.string().optional(),
+  model: z.string().optional(),
+  commitMessage: z.string().optional(),
+});
+export type UpdatePromptOverrideRequestBody = z.infer<typeof UpdatePromptOverrideRequestBody>;
+
+export const ReactivatePromptOverrideRequestBody = z.object({
+  version: z.number().int().positive(),
+});
+export type ReactivatePromptOverrideRequestBody = z.infer<typeof ReactivatePromptOverrideRequestBody>;
+
+export const PromptOkResponseBody = z.object({ ok: z.boolean() });
+export type PromptOkResponseBody = z.infer<typeof PromptOkResponseBody>;
+
+export const PromptOverrideCreatedResponseBody = z.object({
+  ok: z.boolean(),
+  version: z.number(),
+});
+export type PromptOverrideCreatedResponseBody = z.infer<typeof PromptOverrideCreatedResponseBody>;
diff --git a/packages/core/src/v3/schemas/build.ts b/packages/core/src/v3/schemas/build.ts
index 8eb97f0f358..bda5efb0ad9 100644
--- a/packages/core/src/v3/schemas/build.ts
+++ b/packages/core/src/v3/schemas/build.ts
@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ConfigManifest } from "./config.js";
-import { QueueManifest, TaskFile, TaskManifest } from "./schemas.js";
+import { PromptManifest, QueueManifest, TaskFile, TaskManifest } from "./schemas.js";
 
 export const BuildExternal = z.object({
   name: z.string(),
@@ -86,6 +86,7 @@ export type IndexMessage = z.infer<typeof IndexMessage>;
 export const WorkerManifest = z.object({
   configPath: z.string(),
   tasks: TaskManifest.array(),
+  prompts: PromptManifest.array().optional(),
   queues: QueueManifest.array().optional(),
   workerEntryPoint: z.string(),
   controllerEntryPoint: z.string().optional(),
diff --git a/packages/core/src/v3/schemas/common.ts b/packages/core/src/v3/schemas/common.ts
index 302f4acc17d..f3757208335 100644
--- a/packages/core/src/v3/schemas/common.ts
+++ b/packages/core/src/v3/schemas/common.ts
@@ -187,6 +187,9 @@ export const TaskRunInternalError = z.object({
     "OUTDATED_SDK_VERSION",
     "TASK_DID_CONCURRENT_WAIT",
     "RECURSIVE_WAIT_DEADLOCK",
+    "BATCH_ITEM_COULD_NOT_TRIGGER",
+    "PAYLOAD_TOO_LARGE",
+    "UNSPECIFIED_ERROR",
   ]),
   message: z.string().optional(),
   stackTrace: z.string().optional(),
@@ -214,7 +217,10 @@ export const TaskRun = z.object({
   isTest: z.boolean().default(false),
   createdAt: z.coerce.date(),
   startedAt: z.coerce.date().default(() => new Date()),
+  /** The user-provided idempotency key (not the hash) */
   idempotencyKey: z.string().optional(),
+  /** The scope of the idempotency key */
+  idempotencyKeyScope: z.enum(["run", "attempt", "global"]).optional(),
   maxAttempts: z.number().optional(),
   version: z.string().optional(),
   metadata: z.record(DeserializedJsonSchema).optional(),
@@ -374,7 +380,10 @@ export const V3TaskRun = z.object({
   isTest: z.boolean().default(false),
   createdAt: z.coerce.date(),
   startedAt: z.coerce.date().default(() => new Date()),
+  /** The user-provided idempotency key (not the hash) */
   idempotencyKey: z.string().optional(),
+  /** The scope of the idempotency key */
+  idempotencyKeyScope: z.enum(["run", "attempt", "global"]).optional(),
   maxAttempts: z.number().optional(),
   version: z.string().optional(),
   metadata: z.record(DeserializedJsonSchema).optional(),
@@ -529,13 +538,13 @@ export type WaitpointTokenResult = z.infer<typeof WaitpointTokenResult>;
 
 export type WaitpointTokenTypedResult<T> =
   | {
-      ok: true;
-      output: T;
-    }
+    ok: true;
+    output: T;
+  }
   | {
-      ok: false;
-      error: Error;
-    };
+    ok: false;
+    error: Error;
+  };
 
 export const SerializedError = z.object({
   message: z.string(),
diff --git a/packages/core/src/v3/schemas/index.ts b/packages/core/src/v3/schemas/index.ts
index c2b17a72b65..11857d6197f 100644
--- a/packages/core/src/v3/schemas/index.ts
+++ b/packages/core/src/v3/schemas/index.ts
@@ -15,3 +15,4 @@ export * from "./webhooks.js";
 export * from "./checkpoints.js";
 export * from "./warmStart.js";
 export * from "./queues.js";
+export * from "./query.js";
diff --git a/packages/core/src/v3/schemas/messages.ts b/packages/core/src/v3/schemas/messages.ts
index c635e574454..b58babba717 100644
--- a/packages/core/src/v3/schemas/messages.ts
+++ b/packages/core/src/v3/schemas/messages.ts
@@ -213,6 +213,7 @@ export const WorkerToExecutorMessageCatalog = {
   FLUSH: {
     message: z.object({
       timeoutInMs: z.number(),
+      disableContext: z.boolean().optional(),
     }),
     callback: z.void(),
   },
diff --git a/packages/core/src/v3/schemas/query.ts b/packages/core/src/v3/schemas/query.ts
new file mode 100644
index 00000000000..3910ab4f5d7
--- /dev/null
+++ b/packages/core/src/v3/schemas/query.ts
@@ -0,0 +1,284 @@
+import { TypeOf, z } from "zod";
+import type { MachinePresetName } from "./common.js";
+import type { RuntimeEnvironmentType } from "./common.js";
+import type { IdempotencyKeyScope } from "../idempotency-key-catalog/catalog.js";
+
+/**
+ * Request body schema for executing a query
+ */
+export const QueryExecuteRequestBody = z.object({
+  query: z.string(),
+  scope: z.enum(["organization", "project", "environment"]).default("environment"),
+  period: z.string().nullish(),
+  from: z.string().nullish(),
+  to: z.string().nullish(),
+  format: z.enum(["json", "csv"]).default("json"),
+});
+
+export type QueryExecuteRequestBody = z.infer<typeof QueryExecuteRequestBody>;
+
+/**
+ * Response body schema for JSON format queries
+ */
+export const QueryExecuteJSONResponseBody = z.object({
+  format: z.literal("json"),
+  results: z.array(z.record(z.any())),
+});
+
+export type QueryExecuteJSONResponseBody = z.infer<typeof QueryExecuteJSONResponseBody>;
+
+/**
+ * Response body type for CSV format queries
+ */
+export const QueryExecuteCSVResponseBody = z.object({
+  format: z.literal("csv"),
+  results: z.string(),
+});
+
+export type QueryExecuteCSVResponseBody = z.infer<typeof QueryExecuteCSVResponseBody>;
+
+export const QueryExecuteResponseBody = z.discriminatedUnion("format", [
+  QueryExecuteJSONResponseBody,
+  QueryExecuteCSVResponseBody,
+]);
+export type QueryExecuteResponseBody = z.infer<typeof QueryExecuteResponseBody>;
+
+// ---------------------------------------------------------------------------
+// Query schema discovery types
+// ---------------------------------------------------------------------------
+
+/**
+ * Schema for a single column in the query schema response
+ */
+export const QuerySchemaColumn = z.object({
+  name: z.string(),
+  type: z.string(),
+  description: z.string().optional(),
+  example: z.string().optional(),
+  allowedValues: z.array(z.string()).optional(),
+  coreColumn: z.boolean().optional(),
+});
+
+export type QuerySchemaColumn = z.infer<typeof QuerySchemaColumn>;
+
+/**
+ * Schema for a single table in the query schema response
+ */
+export const QuerySchemaTable = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  timeColumn: z.string().optional(),
+  columns: z.array(QuerySchemaColumn),
+});
+
+export type QuerySchemaTable = z.infer<typeof QuerySchemaTable>;
+
+/**
+ * Response body for the query schema endpoint
+ */
+export const QuerySchemaResponseBody = z.object({
+  tables: z.array(QuerySchemaTable),
+});
+
+export type QuerySchemaResponseBody = z.infer<typeof QuerySchemaResponseBody>;
+
+// ---------------------------------------------------------------------------
+// Dashboard types
+// ---------------------------------------------------------------------------
+
+/**
+ * Summary of a widget in a dashboard (for listing)
+ */
+export const DashboardWidgetSummary = z.object({
+  id: z.string(),
+  title: z.string(),
+  query: z.string(),
+  type: z.enum(["bignumber", "chart", "table", "title"]),
+});
+
+export type DashboardWidgetSummary = z.infer<typeof DashboardWidgetSummary>;
+
+/**
+ * Summary of a dashboard (for listing)
+ */
+export const DashboardSummary = z.object({
+  key: z.string(),
+  title: z.string(),
+  widgets: z.array(DashboardWidgetSummary),
+});
+
+export type DashboardSummary = z.infer<typeof DashboardSummary>;
+
+/**
+ * Response body for listing dashboards
+ */
+export const ListDashboardsResponseBody = z.object({
+  dashboards: z.array(DashboardSummary),
+});
+
+export type ListDashboardsResponseBody = z.infer<typeof ListDashboardsResponseBody>;
+
+// ---------------------------------------------------------------------------
+// Query table row types
+// ---------------------------------------------------------------------------
+
+/**
+ * User-facing friendly run status values returned by the query system.
+ */
+export const runFriendlyStatus = [
+  "Delayed",
+  "Queued",
+  "Pending version",
+  "Dequeued",
+  "Executing",
+  "Waiting",
+  "Reattempting",
+  "Paused",
+  "Canceled",
+  "Interrupted",
+  "Completed",
+  "Failed",
+  "System failure",
+  "Crashed",
+  "Expired",
+  "Timed out",
+] as const;
+
+export type RunFriendlyStatus = (typeof runFriendlyStatus)[number];
+
+/**
+ * Full row type for the `runs` query table.
+ *
+ * Each property corresponds to a column available in TSQL queries against the
+ * `runs` table. Types are mapped from the underlying ClickHouse column types:
+ *
+ * - `String` → `string`
+ * - `UInt8` / `UInt32` / `Int64` / `Float64` → `number`
+ * - `DateTime64` → `string`
+ * - `Nullable(X)` → `X | null`
+ * - `Array(String)` → `string[]`
+ * - `JSON` → `Record<string, unknown>`
+ * - `LowCardinality(String)` with constrained values → narrow union type
+ */
+export interface RunsTableRow {
+  /** Unique run ID (e.g. `run_cm1a2b3c4d5e6f7g8h9i`) */
+  run_id: string;
+  /** Environment slug */
+  environment: string;
+  /** Project reference (e.g. `proj_howcnaxbfxdmwmxazktx`) */
+  project: string;
+  /** Environment type */
+  environment_type: RuntimeEnvironmentType;
+  /** Number of attempts (starts at 1) */
+  attempt_count: number;
+  /** Run status (friendly name) */
+  status: RunFriendlyStatus;
+  /** Whether the run is finished (0 or 1) */
+  is_finished: number;
+  /** Task identifier/slug */
+  task_identifier: string;
+  /** Queue name */
+  queue: string;
+  /** Batch ID (if part of a batch), or `null` */
+  batch_id: string | null;
+  /** Root run ID (for child runs), or `null` */
+  root_run_id: string | null;
+  /** Parent run ID (for child runs), or `null` */
+  parent_run_id: string | null;
+  /** Nesting depth (0 for root runs) */
+  depth: number;
+  /** Whether this is a root run (0 or 1) */
+  is_root_run: number;
+  /** Whether this is a child run (0 or 1) */
+  is_child_run: number;
+  /** Idempotency key */
+  idempotency_key: string;
+  /** Idempotency key scope (empty string means no idempotency key is set) */
+  idempotency_key_scope: IdempotencyKeyScope | "";
+  /** Region, or `null` */
+  region: string | null;
+  /** When the run was triggered (ISO 8601) */
+  triggered_at: string;
+  /** When the run was queued, or `null` */
+  queued_at: string | null;
+  /** When the run was dequeued, or `null` */
+  dequeued_at: string | null;
+  /** When execution began, or `null` */
+  executed_at: string | null;
+  /** When the run completed, or `null` */
+  completed_at: string | null;
+  /** Delayed execution until this time, or `null` */
+  delay_until: string | null;
+  /** Whether the run had a delay (0 or 1) */
+  has_delay: number;
+  /** When the run expired, or `null` */
+  expired_at: string | null;
+  /** TTL string for expiration (e.g. `"10m"`) */
+  ttl: string;
+  /** Time from execution start to completion in ms, or `null` */
+  execution_duration: number | null;
+  /** Time from trigger to completion in ms, or `null` */
+  total_duration: number | null;
+  /** Time from queued to dequeued in ms, or `null` */
+  queued_duration: number | null;
+  /** Compute usage duration in ms */
+  usage_duration: number;
+  /** Compute cost in dollars */
+  compute_cost: number;
+  /** Invocation cost in dollars */
+  invocation_cost: number;
+  /** Total cost in dollars (compute + invocation) */
+  total_cost: number;
+  /** The data returned from the task */
+  output: Record<string, unknown>;
+  /** Error data if the run failed */
+  error: Record<string, unknown>;
+  /** Tags added to the run */
+  tags: string[];
+  /** Code version in reverse date format (e.g. `"20240115.1"`) */
+  task_version: string;
+  /** SDK package version */
+  sdk_version: string;
+  /** CLI package version */
+  cli_version: string;
+  /** Machine preset the run executed on */
+  machine: MachinePresetName;
+  /** Whether this is a test run (0 or 1) */
+  is_test: number;
+  /** Concurrency key passed when triggering */
+  concurrency_key: string;
+  /** Max allowed compute duration in seconds, or `null` */
+  max_duration: number | null;
+  /** Bulk action group IDs that operated on this run */
+  bulk_action_group_ids: string[];
+}
+
+/** @internal Map of query table names to their full row types */
+type QueryTableMap = {
+  runs: RunsTableRow;
+};
+
+/**
+ * Type helper for Query results.
+ *
+ * @example
+ * ```typescript
+ * // All columns from the runs table
+ * type AllRuns = QueryTable<"runs">;
+ *
+ * // Only specific columns
+ * type MyResult = QueryTable<"runs", "status" | "run_id">;
+ *
+ * // Access a single field type
+ * type Status = QueryTable<"runs">["status"]; // RunFriendlyStatus
+ *
+ * // Use with query.execute
+ * const result = await query.execute<QueryTable<"runs", "status" | "run_id">>(
+ *   "SELECT status, run_id FROM runs"
+ * );
+ * ```
+ */
+export type QueryTable<
+  TTable extends keyof QueryTableMap,
+  TColumns extends keyof QueryTableMap[TTable] = keyof QueryTableMap[TTable],
+> = Pick<QueryTableMap[TTable], TColumns>;
diff --git a/packages/core/src/v3/schemas/resources.ts b/packages/core/src/v3/schemas/resources.ts
index 08764906ede..e681c728416 100644
--- a/packages/core/src/v3/schemas/resources.ts
+++ b/packages/core/src/v3/schemas/resources.ts
@@ -13,6 +13,7 @@ export const TaskResource = z.object({
   triggerSource: z.string().optional(),
   schedule: ScheduleMetadata.optional(),
   maxDuration: z.number().optional(),
+  ttl: z.string().or(z.number().nonnegative().int()).optional(),
   // JSONSchema type - using z.unknown() for runtime validation to accept JSONSchema7
   payloadSchema: z.unknown().optional(),
 });
@@ -28,11 +29,29 @@ export const BackgroundWorkerSourceFileMetadata = z.object({
 
 export type BackgroundWorkerSourceFileMetadata = z.infer<typeof BackgroundWorkerSourceFileMetadata>;
 
+export const PromptResource = z.object({
+  id: z.string(),
+  description: z.string().optional(),
+  filePath: z.string(),
+  exportName: z.string().optional(),
+  /** The default template content */
+  content: z.string().optional(),
+  /** Default model identifier */
+  model: z.string().optional(),
+  /** Default model config (temperature, maxTokens, etc.) */
+  config: z.record(z.unknown()).optional(),
+  /** JSONSchema7 for template variables */
+  variableSchema: z.unknown().optional(),
+});
+
+export type PromptResource = z.infer<typeof PromptResource>;
+
 export const BackgroundWorkerMetadata = z.object({
   packageVersion: z.string(),
   contentHash: z.string(),
   cliPackageVersion: z.string().optional(),
   tasks: z.array(TaskResource),
+  prompts: z.array(PromptResource).optional(),
   queues: z.array(QueueManifest).optional(),
   sourceFiles: z.array(BackgroundWorkerSourceFileMetadata).optional(),
   runtime: z.string().optional(),
diff --git a/packages/core/src/v3/schemas/runEngine.ts b/packages/core/src/v3/schemas/runEngine.ts
index e4057e7ca66..9378b290270 100644
--- a/packages/core/src/v3/schemas/runEngine.ts
+++ b/packages/core/src/v3/schemas/runEngine.ts
@@ -3,6 +3,27 @@ import { Enum, MachinePreset, RuntimeEnvironmentType, TaskRunExecution } from ".
 import { EnvironmentType } from "./schemas.js";
 import type * as DB_TYPES from "@trigger.dev/database";
 
+const anyString = z.custom<string & {}>((v) => typeof v === "string");
+
+export const TriggerSource = z
+  .enum(["sdk", "api", "dashboard", "cli", "mcp", "schedule"])
+  .or(anyString);
+
+export type TriggerSource = z.infer<typeof TriggerSource>;
+
+export const TriggerAction = z.enum(["trigger", "replay", "test"]).or(anyString);
+
+export type TriggerAction = z.infer<typeof TriggerAction>;
+
+export const RunAnnotations = z.object({
+  triggerSource: TriggerSource,
+  triggerAction: TriggerAction,
+  rootTriggerSource: TriggerSource,
+  rootScheduleId: z.string().optional(),
+});
+
+export type RunAnnotations = z.infer<typeof RunAnnotations>;
+
 export const TaskRunExecutionStatus = {
   RUN_CREATED: "RUN_CREATED",
   QUEUED: "QUEUED",
@@ -156,7 +177,8 @@ export type CompleteRunAttemptResult = z.infer<typeof CompleteRunAttemptResult>;
 export const CheckpointTypeEnum = {
   DOCKER: "DOCKER",
   KUBERNETES: "KUBERNETES",
-} satisfies Enum<DB_TYPES.CheckpointType>;
+  COMPUTE: "COMPUTE",
+} satisfies Enum<DB_TYPES.TaskRunCheckpointType>;
 export type CheckpointTypeEnum = (typeof CheckpointTypeEnum)[keyof typeof CheckpointTypeEnum];
 
 export const CheckpointType = z.enum(Object.values(CheckpointTypeEnum) as [CheckpointTypeEnum]);
@@ -259,6 +281,7 @@ export const DequeuedMessage = z.object({
     attemptNumber: z.number(),
     masterQueue: z.string(),
     traceContext: z.record(z.unknown()),
+    annotations: RunAnnotations.optional(),
   }),
   environment: z.object({
     id: z.string(),
@@ -266,6 +289,7 @@ export const DequeuedMessage = z.object({
   }),
   organization: z.object({
     id: z.string(),
+    hasPrivateLink: z.boolean().optional(),
   }),
   project: z.object({
     id: z.string(),
diff --git a/packages/core/src/v3/schemas/schemas.ts b/packages/core/src/v3/schemas/schemas.ts
index 233068c0b7b..4ec559ebf41 100644
--- a/packages/core/src/v3/schemas/schemas.ts
+++ b/packages/core/src/v3/schemas/schemas.ts
@@ -189,6 +189,7 @@ const taskMetadata = {
   triggerSource: z.string().optional(),
   schedule: ScheduleMetadata.optional(),
   maxDuration: z.number().optional(),
+  ttl: z.string().or(z.number().nonnegative().int()).optional(),
   payloadSchema: z.unknown().optional(),
 };
 
@@ -220,6 +221,26 @@ export const TaskManifest = z.object({
 
 export type TaskManifest = z.infer<typeof TaskManifest>;
 
+const promptMetadata = {
+  id: z.string(),
+  description: z.string().optional(),
+  content: z.string().optional(),
+  model: z.string().optional(),
+  config: z.record(z.unknown()).optional(),
+  variableSchema: z.unknown().optional(),
+};
+
+export const PromptMetadata = z.object(promptMetadata);
+
+export type PromptMetadata = z.infer<typeof PromptMetadata>;
+
+export const PromptManifest = z.object({
+  ...promptMetadata,
+  ...taskFileMetadata,
+});
+
+export type PromptManifest = z.infer<typeof PromptManifest>;
+
 export const PostStartCauses = z.enum(["index", "create", "restore"]);
 export type PostStartCauses = z.infer<typeof PostStartCauses>;
 
diff --git a/packages/core/src/v3/schemas/style.ts b/packages/core/src/v3/schemas/style.ts
index eab62c5b41b..2f833b800ac 100644
--- a/packages/core/src/v3/schemas/style.ts
+++ b/packages/core/src/v3/schemas/style.ts
@@ -11,11 +11,12 @@ const AccessoryItem = z.object({
   text: z.string(),
   variant: z.string().optional(),
   url: z.string().optional(),
+  icon: z.string().optional(),
 });
 
 const Accessory = z.object({
   items: z.array(AccessoryItem),
-  style: z.enum(["codepath"]).optional(),
+  style: z.enum(["codepath", "pills"]).optional(),
 });
 
 export type Accessory = z.infer<typeof Accessory>;
diff --git a/packages/core/src/v3/schemas/webhooks.ts b/packages/core/src/v3/schemas/webhooks.ts
index 5c45727dc53..b5ed927602e 100644
--- a/packages/core/src/v3/schemas/webhooks.ts
+++ b/packages/core/src/v3/schemas/webhooks.ts
@@ -117,6 +117,26 @@ const deploymentCommonProperties = {
     slug: z.string(),
     name: z.string(),
   }),
+  /** Git metadata for the deployment source code */
+  git: z
+    .object({
+      branch: z.string(),
+      commitSha: z.string(),
+      commitMessage: z.string(),
+      commitUrl: z.string(),
+      branchUrl: z.string(),
+      pullRequestNumber: z.number().optional(),
+      pullRequestTitle: z.string().optional(),
+      pullRequestUrl: z.string().optional(),
+      provider: z.string().optional(),
+    })
+    .optional(),
+  /** Vercel integration data */
+  vercel: z
+    .object({
+      deploymentUrl: z.string(),
+    })
+    .optional(),
 };
 
 const deploymentDeploymentCommonProperties = {
@@ -170,6 +190,62 @@ export type AlertWebhookDeploymentSuccessObject = z.infer<
 >;
 export type AlertWebhookDeploymentFailedObject = z.infer<typeof AlertWebhookDeploymentFailedObject>;
 
+/** Represents an error group alert webhook payload */
+export const AlertWebhookErrorGroupObject = z.object({
+  /** Classification of the error alert */
+  classification: z.enum(["new_issue", "regression", "unignored"]),
+  /** Error information */
+  error: z.object({
+    /** Error fingerprint identifier */
+    fingerprint: z.string(),
+    /** Error type */
+    type: z.string(),
+    /** Error message */
+    message: z.string(),
+    /** Sample stack trace */
+    stackTrace: z.string().optional(),
+    /** When the error was first seen */
+    firstSeen: z.coerce.date(),
+    /** When the error was last seen */
+    lastSeen: z.coerce.date(),
+    /** Number of occurrences */
+    occurrenceCount: z.number(),
+    /** Task identifier where the error occurred */
+    taskIdentifier: z.string(),
+  }),
+  /** Environment information */
+  environment: z.object({
+    /** Environment ID */
+    id: z.string(),
+    /** Environment name */
+    name: z.string(),
+  }),
+  /** Organization information */
+  organization: z.object({
+    /** Organization ID */
+    id: z.string(),
+    /** Organization slug */
+    slug: z.string(),
+    /** Organization name */
+    name: z.string(),
+  }),
+  /** Project information */
+  project: z.object({
+    /** Project ID */
+    id: z.string(),
+    /** Project reference */
+    ref: z.string(),
+    /** Project slug */
+    slug: z.string(),
+    /** Project name */
+    name: z.string(),
+  }),
+  /** URL to view the error in the dashboard */
+  dashboardUrl: z.string(),
+});
+
+export type AlertWebhookErrorGroupObject = z.infer<typeof AlertWebhookErrorGroupObject>;
+
 /** Common properties for all webhooks */
 const commonProperties = {
   /** Webhook ID */
@@ -200,9 +276,16 @@ export const Webhook = z.discriminatedUnion("type", [
     type: z.literal("alert.deployment.failed"),
     object: AlertWebhookDeploymentFailedObject,
   }),
+  /** Error group alert webhook */
+  z.object({
+    ...commonProperties,
+    type: z.literal("alert.error"),
+    object: AlertWebhookErrorGroupObject,
+  }),
 ]);
 
 export type Webhook = z.infer<typeof Webhook>;
 export type RunFailedWebhook = Extract<Webhook, { type: "alert.run.failed" }>;
 export type DeploymentSuccessWebhook = Extract<Webhook, { type: "alert.deployment.success" }>;
 export type DeploymentFailedWebhook = Extract<Webhook, { type: "alert.deployment.failed" }>;
+export type ErrorWebhook = Extract<Webhook, { type: "alert.error" }>;
diff --git a/packages/core/src/v3/semanticInternalAttributes.ts b/packages/core/src/v3/semanticInternalAttributes.ts
index 4d24235278a..3fb20a06499 100644
--- a/packages/core/src/v3/semanticInternalAttributes.ts
+++ b/packages/core/src/v3/semanticInternalAttributes.ts
@@ -19,6 +19,7 @@ export const SemanticInternalAttributes = {
   TASK_EXPORT_NAME: "ctx.task.exportName",
   QUEUE_NAME: "ctx.queue.name",
   QUEUE_ID: "ctx.queue.id",
+  MACHINE_ID: "ctx.machine.id",
   MACHINE_PRESET_NAME: "ctx.machine.name",
   MACHINE_PRESET_CPU: "ctx.machine.cpu",
   MACHINE_PRESET_MEMORY: "ctx.machine.memory",
@@ -65,4 +66,5 @@ export const SemanticInternalAttributes = {
   WARM_START: "warm_start",
   ATTEMPT_EXECUTION_COUNT: "$trigger.executionCount",
   TASK_EVENT_STORE: "$trigger.taskEventStore",
+  RUN_TAGS: "ctx.run.tags",
 };
diff --git a/packages/core/src/v3/serverOnly/idempotencyKeys.ts b/packages/core/src/v3/serverOnly/idempotencyKeys.ts
new file mode 100644
index 00000000000..91dac04fd43
--- /dev/null
+++ b/packages/core/src/v3/serverOnly/idempotencyKeys.ts
@@ -0,0 +1,69 @@
+import { IdempotencyKeyOptionsSchema } from "../schemas/api.js";
+
+/**
+ * Safely parses idempotencyKeyOptions from a database record and extracts the user-provided key.
+ * Returns the user-provided key if valid options exist, otherwise falls back to the hash.
+ *
+ * @param run - Object containing idempotencyKey (the hash) and idempotencyKeyOptions (JSON from DB)
+ * @returns The user-provided key, the hash as fallback, or null if neither exists
+ */
+export function getUserProvidedIdempotencyKey(run: {
+  idempotencyKey: string | null | undefined;
+  idempotencyKeyOptions: unknown;
+}): string | undefined {
+  const parsed = IdempotencyKeyOptionsSchema.safeParse(run.idempotencyKeyOptions);
+  if (parsed.success) {
+    return parsed.data.key;
+  }
+  return run.idempotencyKey ?? undefined;
+}
+
+/**
+ * Safely parses idempotencyKeyOptions and extracts the scope.
+ *
+ * @param run - Object containing idempotencyKeyOptions (JSON from DB)
+ * @returns The scope if valid options exist, otherwise undefined
+ */
+export function extractIdempotencyKeyScope(run: {
+  idempotencyKeyOptions: unknown;
+}): "run" | "attempt" | "global" | undefined {
+  const parsed = IdempotencyKeyOptionsSchema.safeParse(run.idempotencyKeyOptions);
+  if (parsed.success) {
+    return parsed.data.scope;
+  }
+  return undefined;
+}
+
+export function unsafeExtractIdempotencyKeyScope(run: {
+  idempotencyKeyOptions: unknown;
+}): "run" | "attempt" | "global" | undefined {
+  const unsafe = run.idempotencyKeyOptions as { scope?: "run" | "attempt" | "global" } | undefined | null;
+  return unsafe?.scope ?? undefined;
+}
+
+/**
+ * Extracts just the user-provided key from idempotencyKeyOptions, without falling back to the hash.
+ * Useful for ClickHouse replication where we want to store only the explicit user key.
+ *
+ * @param run - Object containing idempotencyKeyOptions (JSON from DB)
+ * @returns The user-provided key if valid options exist, otherwise undefined
+ */
+export function extractIdempotencyKeyUser(run: {
+  idempotencyKeyOptions: unknown;
+}): string | undefined {
+  const parsed = IdempotencyKeyOptionsSchema.safeParse(run.idempotencyKeyOptions);
+  if (parsed.success) {
+    return parsed.data.key;
+  }
+  return undefined;
+}
+
+export function unsafeExtractIdempotencyKeyUser(run: {
+  idempotencyKeyOptions: unknown;
+}): string | undefined {
+  const unsafe = run.idempotencyKeyOptions as { key?: string } | undefined | null;
+
+  return unsafe?.key ?? undefined;
+}
+
+
diff --git a/packages/core/src/v3/serverOnly/index.ts b/packages/core/src/v3/serverOnly/index.ts
index d4a74633dc4..8f56f0e3307 100644
--- a/packages/core/src/v3/serverOnly/index.ts
+++ b/packages/core/src/v3/serverOnly/index.ts
@@ -8,3 +8,4 @@ export * from "./jumpHash.js";
 export * from "../apiClient/version.js";
 export * from "./placementTags.js";
 export * from "./resourceMonitor.js";
+export * from "./idempotencyKeys.js";
diff --git a/packages/core/src/v3/taskContext/index.ts b/packages/core/src/v3/taskContext/index.ts
index b03b7ff4b6c..f76671160a6 100644
--- a/packages/core/src/v3/taskContext/index.ts
+++ b/packages/core/src/v3/taskContext/index.ts
@@ -1,13 +1,14 @@
 import { Attributes } from "@opentelemetry/api";
 import { ServerBackgroundWorker, TaskRunContext } from "../schemas/index.js";
 import { SemanticInternalAttributes } from "../semanticInternalAttributes.js";
-import { getGlobal, registerGlobal, unregisterGlobal } from "../utils/globals.js";
+import { getGlobal, registerGlobal } from "../utils/globals.js";
 import { TaskContext } from "./types.js";
 
 const API_NAME = "task-context";
 
 export class TaskContextAPI {
   private static _instance?: TaskContextAPI;
+  private _runDisabled = false;
 
   private constructor() {}
 
@@ -23,6 +24,10 @@ export class TaskContextAPI {
     return this.#getTaskContext() !== undefined;
   }
 
+  get isRunDisabled(): boolean {
+    return this._runDisabled;
+  }
+
   get ctx(): TaskRunContext | undefined {
     return this.#getTaskContext()?.ctx;
   }
@@ -98,11 +103,12 @@ export class TaskContextAPI {
   }
 
   public disable() {
-    unregisterGlobal(API_NAME);
+    this._runDisabled = true;
   }
 
   public setGlobalTaskContext(taskContext: TaskContext): boolean {
-    return registerGlobal(API_NAME, taskContext);
+    this._runDisabled = false;
+    return registerGlobal(API_NAME, taskContext, true);
   }
 
   #getTaskContext(): TaskContext | undefined {
diff --git a/packages/core/src/v3/taskContext/otelProcessors.ts b/packages/core/src/v3/taskContext/otelProcessors.ts
index 16f93d42a9b..1c0958d655d 100644
--- a/packages/core/src/v3/taskContext/otelProcessors.ts
+++ b/packages/core/src/v3/taskContext/otelProcessors.ts
@@ -1,5 +1,15 @@
-import { Context, trace, Tracer } from "@opentelemetry/api";
+import { Attributes, Context, trace, Tracer } from "@opentelemetry/api";
+import { ExportResult, ExportResultCode } from "@opentelemetry/core";
 import { LogRecordProcessor, SdkLogRecord } from "@opentelemetry/sdk-logs";
+import type {
+  AggregationOption,
+  AggregationTemporality,
+  InstrumentType,
+  MetricData,
+  PushMetricExporter,
+  ResourceMetrics,
+  ScopeMetrics,
+} from "@opentelemetry/sdk-metrics";
 import { Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { SemanticInternalAttributes } from "../semanticInternalAttributes.js";
 import { taskContext } from "../task-context-api.js";
@@ -20,6 +30,12 @@ export class TaskContextSpanProcessor implements SpanProcessor {
       span.setAttributes(
         flattenAttributes(taskContext.attributes, SemanticInternalAttributes.METADATA)
       );
+
+      // Set run tags as a proper array attribute (not flattened) so it arrives
+      // as an OTEL ArrayValue and can be extracted on the server side.
+      if (!taskContext.isRunDisabled && taskContext.ctx.run.tags?.length) {
+        span.setAttribute(SemanticInternalAttributes.RUN_TAGS, taskContext.ctx.run.tags);
+      }
     }
 
     if (!isPartialSpan(span) && !skipPartialSpan(span)) {
@@ -104,3 +120,194 @@ export class TaskContextLogProcessor implements LogRecordProcessor {
     return this._innerProcessor.shutdown();
   }
 }
+
+export class TaskContextMetricExporter implements PushMetricExporter {
+  selectAggregationTemporality?: (instrumentType: InstrumentType) => AggregationTemporality;
+  selectAggregation?: (instrumentType: InstrumentType) => AggregationOption;
+
+  constructor(private _innerExporter: PushMetricExporter) {
+    if (_innerExporter.selectAggregationTemporality) {
+      this.selectAggregationTemporality =
+        _innerExporter.selectAggregationTemporality.bind(_innerExporter);
+    }
+    if (_innerExporter.selectAggregation) {
+      this.selectAggregation = _innerExporter.selectAggregation.bind(_innerExporter);
+    }
+  }
+
+  export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void {
+    if (!taskContext.ctx) {
+      // No task context yet — pass through without adding context attributes
+      this._innerExporter.export(metrics, resultCallback);
+      return;
+    }
+
+    const ctx = taskContext.ctx;
+
+    let contextAttrs: Attributes;
+
+    if (taskContext.isRunDisabled) {
+      // Between runs: keep environment/project/org/machine attrs, strip run-specific ones
+      contextAttrs = {
+        [SemanticInternalAttributes.ENVIRONMENT_ID]: ctx.environment.id,
+        [SemanticInternalAttributes.ENVIRONMENT_TYPE]: ctx.environment.type,
+        [SemanticInternalAttributes.ORGANIZATION_ID]: ctx.organization.id,
+        [SemanticInternalAttributes.PROJECT_ID]: ctx.project.id,
+        [SemanticInternalAttributes.MACHINE_PRESET_NAME]: ctx.machine?.name,
+      };
+    } else {
+      // During a run: full context attrs
+      contextAttrs = {
+        [SemanticInternalAttributes.RUN_ID]: ctx.run.id,
+        [SemanticInternalAttributes.TASK_SLUG]: ctx.task.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: ctx.attempt.number,
+        [SemanticInternalAttributes.ENVIRONMENT_ID]: ctx.environment.id,
+        [SemanticInternalAttributes.ORGANIZATION_ID]: ctx.organization.id,
+        [SemanticInternalAttributes.PROJECT_ID]: ctx.project.id,
+        [SemanticInternalAttributes.MACHINE_PRESET_NAME]: ctx.machine?.name,
+        [SemanticInternalAttributes.ENVIRONMENT_TYPE]: ctx.environment.type,
+      };
+    }
+
+    if (taskContext.worker) {
+      contextAttrs[SemanticInternalAttributes.WORKER_ID] = taskContext.worker.id;
+      contextAttrs[SemanticInternalAttributes.WORKER_VERSION] = taskContext.worker.version;
+    }
+
+    if (!taskContext.isRunDisabled && ctx.run.tags?.length) {
+      contextAttrs[SemanticInternalAttributes.RUN_TAGS] = ctx.run.tags;
+    }
+
+    const modified: ResourceMetrics = {
+      resource: metrics.resource,
+      scopeMetrics: metrics.scopeMetrics.map((scope) => ({
+        ...scope,
+        metrics: scope.metrics.map(
+          (metric) =>
+            ({
+              ...metric,
+              dataPoints: metric.dataPoints.map((dp) => ({
+                ...dp,
+                attributes: { ...dp.attributes, ...contextAttrs },
+              })),
+            }) as MetricData
+        ),
+      })),
+    };
+
+    this._innerExporter.export(modified, resultCallback);
+  }
+
+  forceFlush(): Promise<void> {
+    return this._innerExporter.forceFlush();
+  }
+
+  shutdown(): Promise<void> {
+    return this._innerExporter.shutdown();
+  }
+}
+
+export class BufferingMetricExporter implements PushMetricExporter {
+  selectAggregationTemporality?: (instrumentType: InstrumentType) => AggregationTemporality;
+  selectAggregation?: (instrumentType: InstrumentType) => AggregationOption;
+
+  private _buffer: ResourceMetrics[] = [];
+  private _lastFlushTime = Date.now();
+
+  constructor(
+    private _innerExporter: PushMetricExporter,
+    private _flushIntervalMs: number
+  ) {
+    if (_innerExporter.selectAggregationTemporality) {
+      this.selectAggregationTemporality =
+        _innerExporter.selectAggregationTemporality.bind(_innerExporter);
+    }
+    if (_innerExporter.selectAggregation) {
+      this.selectAggregation = _innerExporter.selectAggregation.bind(_innerExporter);
+    }
+  }
+
+  export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void {
+    this._buffer.push(metrics);
+
+    const now = Date.now();
+    if (now - this._lastFlushTime >= this._flushIntervalMs) {
+      this._lastFlushTime = now;
+      const merged = this._mergeBuffer();
+      this._innerExporter.export(merged, resultCallback);
+    } else {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    }
+  }
+
+  forceFlush(): Promise<void> {
+    if (this._buffer.length > 0) {
+      this._lastFlushTime = Date.now();
+      const merged = this._mergeBuffer();
+      return new Promise<void>((resolve, reject) => {
+        this._innerExporter.export(merged, (result) => {
+          if (result.code === ExportResultCode.SUCCESS) {
+            resolve();
+          } else {
+            reject(result.error ?? new Error("Export failed"));
+          }
+        });
+      }).then(() => this._innerExporter.forceFlush());
+    }
+    return this._innerExporter.forceFlush();
+  }
+
+  shutdown(): Promise<void> {
+    return this.forceFlush().then(() => this._innerExporter.shutdown());
+  }
+
+  private _mergeBuffer(): ResourceMetrics {
+    const batch = this._buffer;
+    this._buffer = [];
+
+    if (batch.length === 1) {
+      return batch[0]!;
+    }
+
+    const base = batch[0]!;
+
+    // Merge all scopeMetrics by scope name, then metrics by descriptor name
+    const scopeMap = new Map<string, { scope: ScopeMetrics["scope"]; metricsMap: Map<string, MetricData> }>();
+
+    for (const rm of batch) {
+      for (const sm of rm.scopeMetrics) {
+        const scopeKey = sm.scope.name;
+        let scopeEntry = scopeMap.get(scopeKey);
+        if (!scopeEntry) {
+          scopeEntry = { scope: sm.scope, metricsMap: new Map() };
+          scopeMap.set(scopeKey, scopeEntry);
+        }
+
+        for (const metric of sm.metrics) {
+          const metricKey = metric.descriptor.name;
+          const existing = scopeEntry.metricsMap.get(metricKey);
+          if (existing) {
+            // Append data points from this collection to the existing metric
+            scopeEntry.metricsMap.set(metricKey, {
+              ...existing,
+              dataPoints: [...existing.dataPoints, ...metric.dataPoints],
+            } as MetricData);
+          } else {
+            scopeEntry.metricsMap.set(metricKey, {
+              ...metric,
+              dataPoints: [...metric.dataPoints],
+            } as MetricData);
+          }
+        }
+      }
+    }
+
+    return {
+      resource: base.resource,
+      scopeMetrics: Array.from(scopeMap.values()).map(({ scope, metricsMap }) => ({
+        scope,
+        metrics: Array.from(metricsMap.values()),
+      })),
+    };
+  }
+}
diff --git a/packages/core/src/v3/types/tasks.ts b/packages/core/src/v3/types/tasks.ts
index f463b20f49f..d04d088ef1a 100644
--- a/packages/core/src/v3/types/tasks.ts
+++ b/packages/core/src/v3/types/tasks.ts
@@ -21,6 +21,7 @@ import {
   MachineMemory,
   MachinePresetName,
   RetryOptions,
+  PromptMetadata,
   TaskMetadata,
   TaskRunContext,
 } from "../schemas/index.js";
@@ -277,6 +278,29 @@ type CommonTaskOptions<
    */
   maxDuration?: number;
 
+  /**
+   * Set a default time-to-live for runs of this task. If the run is not executed within this time, it will be removed from the queue and never execute.
+   *
+   * This can be a string like "1h" (1 hour), "30m" (30 minutes), "1d" (1 day), or a number of seconds.
+   *
+   * If omitted it will use the value in your `trigger.config.ts` file, if set.
+   *
+   * You can override this on a per-trigger basis by setting the `ttl` option when triggering the task.
+   *
+   * @example
+   *
+   * ```ts
+   * export const myTask = task({
+   *   id: "my-task",
+   *   ttl: "10m",
+   *   run: async (payload) => {
+   *     //...
+   *   },
+   * });
+   * ```
+   */
+  ttl?: string | number;
+
   /** This gets called when a task is triggered. It's where you put the code you want to execute.
    *
    * @param payload - The payload that is passed to your task when it's triggered. This must be JSON serializable.
@@ -945,6 +969,22 @@ export type TriggerOptions = {
      * @default "leading"
      */
     mode?: "leading" | "trailing";
+    /**
+     * Maximum total delay before the run must execute, regardless of subsequent triggers.
+     * This prevents indefinite delays when continuous triggers keep pushing the execution time.
+     *
+     * When specified, if a new trigger would push the execution time beyond this limit
+     * (measured from the first trigger), the current debounced run will be allowed to execute
+     * and a new run will be created for subsequent triggers.
+     *
+     * If not specified, falls back to the server's default maximum (typically 1 hour).
+     *
+     * Supported formats: `{number}s` (seconds), `{number}m` (minutes), `{number}h` (hours),
+     * `{number}d` (days), `{number}w` (weeks).
+     *
+     * @example "30m", "2h", "1d"
+     */
+    maxDelay?: string;
   };
 };
 
@@ -992,6 +1032,13 @@ export type TaskMetadataWithFunctions = TaskMetadata & {
   schema?: TaskSchema;
 };
 
+export type PromptMetadataWithFunctions = PromptMetadata & {
+  fns: {
+    resolve: (variables: Record<string, unknown>) => Promise<unknown>;
+  };
+  schema?: TaskSchema;
+};
+
 export type RunTypes<TTaskIdentifier extends string, TPayload, TOutput> = {
   output: TOutput;
   payload: TPayload;
diff --git a/packages/core/src/v3/types/tools.ts b/packages/core/src/v3/types/tools.ts
index 078c52feb6c..8c3aac80bf1 100644
--- a/packages/core/src/v3/types/tools.ts
+++ b/packages/core/src/v3/types/tools.ts
@@ -20,8 +20,8 @@ export function convertToolParametersToSchema<TToolParameters extends ToolTaskPa
 }
 
 function convertAISchemaToTaskSchema(schema: AISchema<any>): Schema {
-  return (payload: unknown) => {
-    const result = schema.validate?.(payload);
+  return async (payload: unknown) => {
+    const result = await schema.validate?.(payload);
 
     if (!result) {
       throw new Error("Invalid payload");
diff --git a/packages/core/src/v3/utils/flattenAttributes.ts b/packages/core/src/v3/utils/flattenAttributes.ts
index 568346d48a6..83d1a14f2cd 100644
--- a/packages/core/src/v3/utils/flattenAttributes.ts
+++ b/packages/core/src/v3/utils/flattenAttributes.ts
@@ -3,13 +3,16 @@ import { Attributes } from "@opentelemetry/api";
 export const NULL_SENTINEL = "$@null((";
 export const CIRCULAR_REFERENCE_SENTINEL = "$@circular((";
 
+const DEFAULT_MAX_DEPTH = 128;
+
 export function flattenAttributes(
   obj: unknown,
   prefix?: string,
-  maxAttributeCount?: number
+  maxAttributeCount?: number,
+  maxDepth: number = DEFAULT_MAX_DEPTH
 ): Attributes {
-  const flattener = new AttributeFlattener(maxAttributeCount);
-  flattener.doFlatten(obj, prefix);
+  const flattener = new AttributeFlattener(maxAttributeCount, maxDepth);
+  flattener.doFlatten(obj, prefix, 0);
   return flattener.attributes;
 }
 
@@ -18,7 +21,10 @@ class AttributeFlattener {
   private attributeCounter: number = 0;
   private result: Attributes = {};
 
-  constructor(private maxAttributeCount?: number) {}
+  constructor(
+    private maxAttributeCount?: number,
+    private maxDepth: number = DEFAULT_MAX_DEPTH
+  ) {}
 
   get attributes(): Attributes {
     return this.result;
@@ -37,11 +43,16 @@ class AttributeFlattener {
     return true;
   }
 
-  doFlatten(obj: unknown, prefix?: string) {
+  doFlatten(obj: unknown, prefix?: string, depth: number = 0) {
     if (!this.canAddMoreAttributes()) {
       return;
     }
 
+    // Check depth limit to prevent stack overflow
+    if (depth > this.maxDepth) {
+      return;
+    }
+
     // Check if obj is null or undefined
     if (obj === undefined) {
       return;
@@ -94,7 +105,7 @@ class AttributeFlattener {
       let index = 0;
       for (const item of obj) {
         if (!this.canAddMoreAttributes()) break;
-        this.#processValue(item, `${prefix || "set"}.[${index}]`);
+        this.#processValue(item, `${prefix || "set"}.[${index}]`, depth);
         index++;
       }
       return;
@@ -106,7 +117,7 @@ class AttributeFlattener {
         if (!this.canAddMoreAttributes()) break;
         // Use the key directly if it's a string, otherwise convert it
         const keyStr = typeof key === "string" ? key : String(key);
-        this.#processValue(value, `${prefix || "map"}.${keyStr}`);
+        this.#processValue(value, `${prefix || "map"}.${keyStr}`, depth);
       }
       return;
     }
@@ -196,15 +207,15 @@ class AttributeFlattener {
           if (!this.canAddMoreAttributes()) {
             break;
           }
-          this.#processValue(value[i], `${newPrefix}.[${i}]`);
+          this.#processValue(value[i], `${newPrefix}.[${i}]`, depth);
         }
       } else {
-        this.#processValue(value, newPrefix);
+        this.#processValue(value, newPrefix, depth);
       }
     }
   }
 
-  #processValue(value: unknown, prefix: string) {
+  #processValue(value: unknown, prefix: string, depth: number) {
     if (!this.canAddMoreAttributes()) {
       return;
     }
@@ -224,9 +235,9 @@ class AttributeFlattener {
       return;
     }
 
-    // Handle non-primitive values by recursing
+    // Handle non-primitive values by recursing (increment depth)
     if (typeof value === "object" || typeof value === "function") {
-      this.doFlatten(value as any, prefix);
+      this.doFlatten(value as any, prefix, depth + 1);
     } else {
       // Convert other types to strings (bigint, symbol, etc.)
       this.addAttribute(prefix, String(value));
@@ -240,7 +251,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 export function unflattenAttributes(
   obj: Attributes,
-  filteredKeys?: string[]
+  filteredKeys?: string[],
+  maxDepth: number = DEFAULT_MAX_DEPTH
 ): Record<string, unknown> | string | number | boolean | null | undefined {
   if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
     return obj;
@@ -285,6 +297,11 @@ export function unflattenAttributes(
       [] as (string | number)[]
     );
 
+    // Skip keys that exceed max depth to prevent memory exhaustion
+    if (parts.length > maxDepth) {
+      continue;
+    }
+
     let current: any = result;
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
diff --git a/packages/core/src/v3/utils/globals.ts b/packages/core/src/v3/utils/globals.ts
index 218ec97e299..08b62d379b2 100644
--- a/packages/core/src/v3/utils/globals.ts
+++ b/packages/core/src/v3/utils/globals.ts
@@ -1,6 +1,8 @@
 import { ApiClientConfiguration } from "../apiClientManager/types.js";
 import { Clock } from "../clock/clock.js";
 import { HeartbeatsManager } from "../heartbeats/types.js";
+import type { IdempotencyKeyCatalog } from "../idempotency-key-catalog/catalog.js";
+import { InputStreamManager } from "../inputStreams/types.js";
 import { LifecycleHooksManager } from "../lifecycleHooks/types.js";
 import { LocalsManager } from "../locals/types.js";
 import { RealtimeStreamsManager } from "../realtimeStreams/types.js";
@@ -61,6 +63,7 @@ type TriggerDotDevGlobalAPI = {
   clock?: Clock;
   usage?: UsageManager;
   ["resource-catalog"]?: ResourceCatalog;
+  ["idempotency-key-catalog"]?: IdempotencyKeyCatalog;
   ["task-context"]?: TaskContext;
   ["api-client"]?: ApiClientConfiguration;
   ["run-metadata"]?: RunMetadataManager;
@@ -72,4 +75,5 @@ type TriggerDotDevGlobalAPI = {
   ["trace-context"]?: TraceContextManager;
   ["heartbeats"]?: HeartbeatsManager;
   ["realtime-streams"]?: RealtimeStreamsManager;
+  ["input-streams"]?: InputStreamManager;
 };
diff --git a/packages/core/src/v3/utils/ioSerialization.ts b/packages/core/src/v3/utils/ioSerialization.ts
index 9bacc414221..35e3d41061a 100644
--- a/packages/core/src/v3/utils/ioSerialization.ts
+++ b/packages/core/src/v3/utils/ioSerialization.ts
@@ -13,6 +13,7 @@ import { SemanticInternalAttributes } from "../semanticInternalAttributes.js";
 import { TriggerTracer } from "../tracer.js";
 import { zodfetch } from "../zodfetch.js";
 import { flattenAttributes } from "./flattenAttributes.js";
+import superjson from "../imports/superjson.js";
 
 export type IOPacket = {
   data?: string | undefined;
@@ -32,9 +33,7 @@ export async function parsePacket(value: IOPacket, options?: ParsePacketOptions)
     case "application/json":
       return JSON.parse(value.data, makeSafeReviver(options));
     case "application/super+json":
-      const { parse } = await loadSuperJSON();
-
-      return parse(value.data);
+      return superjson.parse(value.data);
     case "text/plain":
       return value.data;
     case "application/store":
@@ -58,11 +57,9 @@ export async function parsePacketAsJson(
     case "application/json":
       return JSON.parse(value.data, makeSafeReviver(options));
     case "application/super+json":
-      const { parse, serialize } = await loadSuperJSON();
-
-      const superJsonResult = parse(value.data);
+      const superJsonResult = superjson.parse(value.data);
 
-      const { json } = serialize(superJsonResult);
+      const { json } = superjson.serialize(superJsonResult);
 
       return json;
     case "text/plain":
@@ -95,8 +92,7 @@ export async function stringifyIO(value: any): Promise<IOPacket> {
   }
 
   try {
-    const { stringify } = await loadSuperJSON();
-    const data = stringify(value);
+    const data = superjson.stringify(value);
 
     return { data, dataType: "application/super+json" };
   } catch {
@@ -173,6 +169,12 @@ async function exportPacket(packet: IOPacket, pathPrefix: string): Promise<IOPac
 
   const presignedResponse = await apiClientManager.client!.createUploadPayloadUrl(filename);
 
+  if (!presignedResponse.storagePath) {
+    throw new Error(
+      "Packet upload presign response missing storagePath; ensure the server supports /api/v2/packets"
+    );
+  }
+
   const uploadResponse = await zodfetch(
     z.any(),
     presignedResponse.presignedUrl,
@@ -195,7 +197,7 @@ async function exportPacket(packet: IOPacket, pathPrefix: string): Promise<IOPac
   }
 
   return {
-    data: filename,
+    data: presignedResponse.storagePath,
     dataType: "application/store",
   };
 }
@@ -302,14 +304,12 @@ export async function createPacketAttributes(
         [dataTypeKey]: packet.dataType,
       };
     case "application/super+json":
-      const { parse } = await loadSuperJSON();
-
       if (typeof packet.data === "undefined" || packet.data === null) {
         return;
       }
 
       try {
-        const parsed = parse(packet.data) as any;
+        const parsed = superjson.parse(packet.data) as any;
         const jsonified = JSON.parse(JSON.stringify(parsed, makeSafeReplacer()));
 
         const result = {
@@ -358,9 +358,7 @@ export async function createPacketAttributesAsJson(
       );
     }
     case "application/super+json": {
-      const { deserialize } = await loadSuperJSON();
-
-      const deserialized = deserialize(data) as any;
+      const deserialized = superjson.deserialize(data) as any;
       const jsonify = safeJsonParse(JSON.stringify(deserialized, makeSafeReplacer()));
 
       return imposeAttributeLimits(
@@ -390,18 +388,16 @@ export async function prettyPrintPacket(
       rawData = safeJsonParse(rawData);
     }
 
-    const { deserialize } = await loadSuperJSON();
-
     const hasCircularReferences = rawData && rawData.meta && hasCircularReference(rawData.meta);
 
     if (hasCircularReferences) {
-      return await prettyPrintPacket(deserialize(rawData), "application/json", {
+      return await prettyPrintPacket(superjson.deserialize(rawData), "application/json", {
         ...options,
         cloneReferences: false,
       });
     }
 
-    return await prettyPrintPacket(deserialize(rawData), "application/json", {
+    return await prettyPrintPacket(superjson.deserialize(rawData), "application/json", {
       ...options,
       cloneReferences: true,
     });
@@ -512,21 +508,6 @@ function getPacketExtension(outputType: string): string {
   }
 }
 
-async function loadSuperJSON() {
-  const superjson = await import("superjson");
-
-  superjson.registerCustom<Buffer, number[]>(
-    {
-      isApplicable: (v): v is Buffer => typeof Buffer === "function" && Buffer.isBuffer(v),
-      serialize: (v) => [...v],
-      deserialize: (v) => Buffer.from(v),
-    },
-    "buffer"
-  );
-
-  return superjson;
-}
-
 function safeJsonParse(value: string): any {
   try {
     return JSON.parse(value);
@@ -554,7 +535,6 @@ function safeJsonParse(value: string): any {
  * @throws {Error} If the newPayload is not valid JSON
  */
 export async function replaceSuperJsonPayload(original: string, newPayload: string) {
-  const superjson = await loadSuperJSON();
   const originalObject = superjson.parse(original);
   const newPayloadObject = JSON.parse(newPayload);
   const { meta } = superjson.serialize(originalObject);
diff --git a/packages/core/src/v3/waitpoints/index.ts b/packages/core/src/v3/waitpoints/index.ts
new file mode 100644
index 00000000000..fc70ff57f21
--- /dev/null
+++ b/packages/core/src/v3/waitpoints/index.ts
@@ -0,0 +1,35 @@
+import type { WaitpointTokenTypedResult } from "../schemas/common.js";
+
+export class WaitpointTimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WaitpointTimeoutError";
+  }
+}
+
+export class ManualWaitpointPromise<TOutput> extends Promise<
+  WaitpointTokenTypedResult<TOutput>
+> {
+  constructor(
+    executor: (
+      resolve: (
+        value:
+          | WaitpointTokenTypedResult<TOutput>
+          | PromiseLike<WaitpointTokenTypedResult<TOutput>>
+      ) => void,
+      reject: (reason?: any) => void
+    ) => void
+  ) {
+    super(executor);
+  }
+
+  unwrap(): Promise<TOutput> {
+    return this.then((result) => {
+      if (result.ok) {
+        return result.output;
+      } else {
+        throw new WaitpointTimeoutError(result.error.message);
+      }
+    });
+  }
+}
diff --git a/packages/core/src/v3/workers/index.ts b/packages/core/src/v3/workers/index.ts
index 58ee834ac2e..e5f8eecff98 100644
--- a/packages/core/src/v3/workers/index.ts
+++ b/packages/core/src/v3/workers/index.ts
@@ -14,6 +14,7 @@ export { StandardResourceCatalog } from "../resource-catalog/standardResourceCat
 export {
   TaskContextSpanProcessor,
   TaskContextLogProcessor,
+  TaskContextMetricExporter,
 } from "../taskContext/otelProcessors.js";
 export * from "../usage-api.js";
 export { DevUsageManager } from "../usage/devUsageManager.js";
@@ -31,3 +32,4 @@ export { populateEnv } from "./populateEnv.js";
 export { StandardTraceContextManager } from "../traceContext/manager.js";
 export { StandardHeartbeatsManager } from "../heartbeats/manager.js";
 export { StandardRealtimeStreamsManager } from "../realtimeStreams/manager.js";
+export { StandardInputStreamManager } from "../inputStreams/manager.js";
diff --git a/packages/core/src/v3/workers/taskExecutor.ts b/packages/core/src/v3/workers/taskExecutor.ts
index c232864884b..2b9ffecf151 100644
--- a/packages/core/src/v3/workers/taskExecutor.ts
+++ b/packages/core/src/v3/workers/taskExecutor.ts
@@ -13,6 +13,7 @@ import {
   accessoryAttributes,
   attemptKey,
   flattenAttributes,
+  inputStreams,
   lifecycleHooks,
   OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
   runMetadata,
@@ -1046,6 +1047,7 @@ export class TaskExecutor {
     signal: AbortSignal
   ) {
     await this.#callCleanupFunctions(payload, ctx, initOutput, signal);
+    inputStreams.clearHandlers();
     await this.#blockForWaitUntil();
   }
 
diff --git a/packages/core/test/flattenAttributes.test.ts b/packages/core/test/flattenAttributes.test.ts
index 8970ae6a7d2..28f137deaf9 100644
--- a/packages/core/test/flattenAttributes.test.ts
+++ b/packages/core/test/flattenAttributes.test.ts
@@ -500,6 +500,53 @@ describe("flattenAttributes", () => {
     expect(result["bigint"]).toBe("999");
     expect(typeof result["symbol"]).toBe("string");
   });
+
+  it("respects maxDepth limit", () => {
+    const obj = {
+      a: {
+        b: {
+          c: {
+            d: {
+              e: {
+                f: "deep",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    // With maxDepth of 3, should not include keys deeper than 3 levels
+    const result = flattenAttributes(obj, undefined, undefined, 3);
+
+    // a.b.c should exist (depth 3)
+    expect(result["a.b.c"]).toBeUndefined(); // c is an object, not a leaf
+    // a.b.c.d should not exist (would require going to depth 4)
+    expect(result["a.b.c.d"]).toBeUndefined();
+    expect(result["a.b.c.d.e.f"]).toBeUndefined();
+  });
+
+  it("does not crash with deeply nested objects", () => {
+    // Create object iteratively with 500 levels of nesting
+    let deepObj: any = { value: "leaf" };
+    for (let i = 0; i < 500; i++) {
+      deepObj = { n: deepObj };
+    }
+
+    // Should complete without stack overflow
+    expect(() => flattenAttributes(deepObj)).not.toThrow();
+  });
+
+  it("does not crash with deeply nested arrays", () => {
+    // Create deeply nested array structure iteratively
+    let deepArray: any = ["leaf"];
+    for (let i = 0; i < 500; i++) {
+      deepArray = [deepArray];
+    }
+
+    // Should complete without stack overflow
+    expect(() => flattenAttributes({ arr: deepArray })).not.toThrow();
+  });
 });
 
 describe("unflattenAttributes", () => {
@@ -581,4 +628,43 @@ describe("unflattenAttributes", () => {
       blogPosts: [{ title: "Post 1", author: "[Circular Reference]" }],
     });
   });
+
+  it("respects maxDepth limit and skips overly deep keys", () => {
+    // Create a flattened object with keys at various depths
+    const flattened = {
+      "a.b.c": "shallow", // depth 3 - should be included
+      "a.b.c.d.e.f.g": "deep", // depth 7 - should be skipped with maxDepth=5
+      "x.y": "also shallow", // depth 2 - should be included
+    };
+
+    const result = unflattenAttributes(flattened, undefined, 5);
+
+    // Shallow keys should be included
+    expect(result).toHaveProperty("a.b.c", "shallow");
+    expect(result).toHaveProperty("x.y", "also shallow");
+
+    // Deep key should be skipped (not create the nested structure)
+    expect((result as any)?.a?.b?.c?.d?.e?.f?.g).toBeUndefined();
+  });
+
+  it("uses default maxDepth of 128", () => {
+    // Create a key with 129 parts - should be skipped
+    const deepKey = Array(129).fill("x").join(".");
+    const flattened = {
+      [deepKey]: "too deep",
+      "a.b": "shallow",
+    };
+
+    const result = unflattenAttributes(flattened);
+
+    // Shallow key should work
+    expect(result).toHaveProperty("a.b", "shallow");
+
+    // Deep key should be skipped
+    let current: any = result;
+    for (let i = 0; i < 129 && current; i++) {
+      current = current?.x;
+    }
+    expect(current).toBeUndefined();
+  });
 });
diff --git a/packages/python/CHANGELOG.md b/packages/python/CHANGELOG.md
index 57a39087da3..446e66012b0 100644
--- a/packages/python/CHANGELOG.md
+++ b/packages/python/CHANGELOG.md
@@ -1,5 +1,68 @@
 # @trigger.dev/python
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+  - `@trigger.dev/build@4.4.3`
+  - `@trigger.dev/sdk@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/sdk@4.4.2`
+  - `@trigger.dev/build@4.4.2`
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/sdk@4.4.1`
+  - `@trigger.dev/build@4.4.1`
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+  - `@trigger.dev/sdk@4.4.0`
+  - `@trigger.dev/build@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/sdk@4.3.3`
+  - `@trigger.dev/core@4.3.3`
+  - `@trigger.dev/build@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/sdk@4.3.2`
+  - `@trigger.dev/build@4.3.2`
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/sdk@4.3.1`
+  - `@trigger.dev/core@4.3.1`
+  - `@trigger.dev/build@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/python/package.json b/packages/python/package.json
index f4ace48267e..c8c7dfcfe81 100644
--- a/packages/python/package.json
+++ b/packages/python/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/python",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "Python runtime and build extension for Trigger.dev",
   "license": "MIT",
   "publishConfig": {
@@ -45,7 +45,7 @@
     "check-exports": "attw --pack ."
   },
   "dependencies": {
-    "@trigger.dev/core": "workspace:4.3.0",
+    "@trigger.dev/core": "workspace:4.4.3",
     "tinyexec": "^0.3.2"
   },
   "devDependencies": {
@@ -56,12 +56,12 @@
     "tsx": "4.17.0",
     "esbuild": "^0.23.0",
     "@arethetypeswrong/cli": "^0.15.4",
-    "@trigger.dev/build": "workspace:4.3.0",
-    "@trigger.dev/sdk": "workspace:4.3.0"
+    "@trigger.dev/build": "workspace:4.4.3",
+    "@trigger.dev/sdk": "workspace:4.4.3"
   },
   "peerDependencies": {
-    "@trigger.dev/sdk": "workspace:^4.3.0",
-    "@trigger.dev/build": "workspace:^4.3.0"
+    "@trigger.dev/sdk": "workspace:^4.4.3",
+    "@trigger.dev/build": "workspace:^4.4.3"
   },
   "engines": {
     "node": ">=18.20.0"
diff --git a/packages/react-hooks/CHANGELOG.md b/packages/react-hooks/CHANGELOG.md
index 41febd39f02..a0f9233c1fc 100644
--- a/packages/react-hooks/CHANGELOG.md
+++ b/packages/react-hooks/CHANGELOG.md
@@ -1,5 +1,59 @@
 # @trigger.dev/react-hooks
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Add input streams for bidirectional communication with running tasks. Define typed input streams with `streams.input<T>({ id })`, then consume inside tasks via `.wait()` (suspends the process), `.once()` (waits for next message), or `.on()` (subscribes to a continuous stream). Send data from backends with `.send(runId, data)` or from frontends with the new `useInputStreamSend` React hook. ([#3146](https://github.com/triggerdotdev/trigger.dev/pull/3146))
+
+  Upgrade S2 SDK from 0.17 to 0.22 with support for custom endpoints (s2-lite) via the new `endpoints` configuration, `AppendRecord.string()` API, and `maxInflightBytes` session option.
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Fix `onComplete` callback firing prematurely when the realtime stream disconnects before the run finishes. ([#2929](https://github.com/triggerdotdev/trigger.dev/pull/2929))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/react-hooks/package.json b/packages/react-hooks/package.json
index ed38284acf9..239c7d77294 100644
--- a/packages/react-hooks/package.json
+++ b/packages/react-hooks/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/react-hooks",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "trigger.dev react hooks",
   "license": "MIT",
   "publishConfig": {
@@ -37,7 +37,7 @@
     "check-exports": "attw --pack ."
   },
   "dependencies": {
-    "@trigger.dev/core": "workspace:^4.3.0",
+    "@trigger.dev/core": "workspace:^4.4.3",
     "swr": "^2.2.5"
   },
   "devDependencies": {
diff --git a/packages/react-hooks/src/hooks/useInputStreamSend.ts b/packages/react-hooks/src/hooks/useInputStreamSend.ts
new file mode 100644
index 00000000000..d3f816f30e8
--- /dev/null
+++ b/packages/react-hooks/src/hooks/useInputStreamSend.ts
@@ -0,0 +1,60 @@
+"use client";
+
+import useSWRMutation from "swr/mutation";
+import { useApiClient, UseApiClientOptions } from "./useApiClient.js";
+
+export interface InputStreamSendInstance<TData> {
+  /** Send data to the input stream */
+  send: (data: TData) => void;
+  /** Whether a send is currently in progress */
+  isLoading: boolean;
+  /** Any error that occurred during the last send */
+  error?: Error;
+  /** Whether the hook is ready to send (has runId and access token) */
+  isReady: boolean;
+}
+
+/**
+ * Hook to send data to an input stream on a running task.
+ *
+ * @template TData - The type of data to send
+ * @param streamId - The input stream identifier
+ * @param runId - The run to send input stream data to
+ * @param options - API client options (e.g. accessToken)
+ *
+ * @example
+ * ```tsx
+ * const { send, isLoading } = useInputStreamSend("my-stream", runId, { accessToken });
+ * send({ message: "hello" });
+ * ```
+ */
+export function useInputStreamSend<TData>(
+  streamId: string,
+  runId?: string,
+  options?: UseApiClientOptions
+): InputStreamSendInstance<TData> {
+  const apiClient = useApiClient(options);
+
+  async function sendToStream(key: string, { arg }: { arg: { data: TData } }) {
+    if (!apiClient) {
+      throw new Error("Could not send to input stream: Missing access token");
+    }
+
+    if (!runId) {
+      throw new Error("Could not send to input stream: Missing run ID");
+    }
+
+    return await apiClient.sendInputStream(runId, streamId, arg.data);
+  }
+
+  const mutation = useSWRMutation(runId ? `input-stream:${runId}:${streamId}` : null, sendToStream);
+
+  return {
+    send: (data) => {
+      mutation.trigger({ data });
+    },
+    isLoading: mutation.isMutating,
+    isReady: !!runId && !!apiClient,
+    error: mutation.error,
+  };
+}
diff --git a/packages/react-hooks/src/hooks/useRealtime.ts b/packages/react-hooks/src/hooks/useRealtime.ts
index c14a228f624..6aabac358a0 100644
--- a/packages/react-hooks/src/hooks/useRealtime.ts
+++ b/packages/react-hooks/src/hooks/useRealtime.ts
@@ -149,8 +149,10 @@ export function useRealtimeRun<TTask extends AnyTask>(
   const hasCalledOnCompleteRef = useRef(false);
 
   // Effect to handle onComplete callback
+  // Only call onComplete when the run has actually finished (has finishedAt),
+  // not just when the subscription stream ends (which can happen due to network issues)
   useEffect(() => {
-    if (isComplete && run && options?.onComplete && !hasCalledOnCompleteRef.current) {
+    if (isComplete && run?.finishedAt && options?.onComplete && !hasCalledOnCompleteRef.current) {
       options.onComplete(run, error);
       hasCalledOnCompleteRef.current = true;
     }
@@ -313,8 +315,10 @@ export function useRealtimeRunWithStreams<
   const hasCalledOnCompleteRef = useRef(false);
 
   // Effect to handle onComplete callback
+  // Only call onComplete when the run has actually finished (has finishedAt),
+  // not just when the subscription stream ends (which can happen due to network issues)
   useEffect(() => {
-    if (isComplete && run && options?.onComplete && !hasCalledOnCompleteRef.current) {
+    if (isComplete && run?.finishedAt && options?.onComplete && !hasCalledOnCompleteRef.current) {
       options.onComplete(run, error);
       hasCalledOnCompleteRef.current = true;
     }
diff --git a/packages/react-hooks/src/index.ts b/packages/react-hooks/src/index.ts
index bc20cf837d4..23c8ca947d5 100644
--- a/packages/react-hooks/src/index.ts
+++ b/packages/react-hooks/src/index.ts
@@ -4,3 +4,4 @@ export * from "./hooks/useRun.js";
 export * from "./hooks/useRealtime.js";
 export * from "./hooks/useTaskTrigger.js";
 export * from "./hooks/useWaitToken.js";
+export * from "./hooks/useInputStreamSend.js";
diff --git a/packages/redis-worker/CHANGELOG.md b/packages/redis-worker/CHANGELOG.md
index ac090b29034..eee31aa62ba 100644
--- a/packages/redis-worker/CHANGELOG.md
+++ b/packages/redis-worker/CHANGELOG.md
@@ -1,5 +1,55 @@
 # @trigger.dev/redis-worker
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Fix slow batch queue processing by removing spurious cooloff on concurrency blocks and fixing a race condition where retry attempt counts were not atomically updated during message re-queue. ([#3079](https://github.com/triggerdotdev/trigger.dev/pull/3079))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/redis-worker/CLAUDE.md b/packages/redis-worker/CLAUDE.md
new file mode 100644
index 00000000000..511b9828c10
--- /dev/null
+++ b/packages/redis-worker/CLAUDE.md
@@ -0,0 +1,19 @@
+# Redis Worker
+
+`@trigger.dev/redis-worker` - custom Redis-based background job system. **This replaces graphile-worker/zodworker** for all new background job needs.
+
+## Key Files
+
+- `src/worker.ts` - Worker loop and job processing with concurrency control
+- `src/queue.ts` - Redis-backed job queue abstraction
+- `src/fair-queue/` - Fair dequeueing algorithm for queue selection
+
+## Usage
+
+Used by the webapp for background jobs (alerting, batch processing, common tasks) and by the run engine for TTL expiration and batch operations.
+
+All new background jobs in the webapp should use redis-worker. Do NOT add new jobs to zodworker (`@internal/zodworker`) or graphile-worker.
+
+## Testing
+
+Uses ioredis. Tests use testcontainers for Redis.
diff --git a/packages/redis-worker/package.json b/packages/redis-worker/package.json
index b6e56199cd9..fef723433cb 100644
--- a/packages/redis-worker/package.json
+++ b/packages/redis-worker/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/redis-worker",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "Redis worker for trigger.dev",
   "license": "MIT",
   "publishConfig": {
@@ -23,7 +23,7 @@
     "test": "vitest --sequence.concurrent=false --no-file-parallelism"
   },
   "dependencies": {
-    "@trigger.dev/core": "workspace:4.3.0",
+    "@trigger.dev/core": "workspace:4.4.3",
     "lodash.omit": "^4.5.0",
     "nanoid": "^5.0.7",
     "p-limit": "^6.2.0",
diff --git a/packages/redis-worker/src/fair-queue/concurrency.ts b/packages/redis-worker/src/fair-queue/concurrency.ts
index 23f5293a197..641899ccc8d 100644
--- a/packages/redis-worker/src/fair-queue/concurrency.ts
+++ b/packages/redis-worker/src/fair-queue/concurrency.ts
@@ -106,6 +106,30 @@ export class ConcurrencyManager {
     await pipeline.exec();
   }
 
+  /**
+   * Release concurrency slots for multiple messages in a single pipeline.
+   * More efficient than calling release() multiple times.
+   */
+  async releaseBatch(
+    messages: Array<{ queue: QueueDescriptor; messageId: string }>
+  ): Promise<void> {
+    if (messages.length === 0) {
+      return;
+    }
+
+    const pipeline = this.redis.pipeline();
+
+    for (const { queue, messageId } of messages) {
+      for (const group of this.groups) {
+        const groupId = group.extractGroupId(queue);
+        const key = this.keys.concurrencyKey(group.name, groupId);
+        pipeline.srem(key, messageId);
+      }
+    }
+
+    await pipeline.exec();
+  }
+
   /**
    * Get current concurrency for a specific group.
    */
@@ -114,6 +138,45 @@ export class ConcurrencyManager {
     return await this.redis.scard(key);
   }
 
+  /**
+   * Get available capacity for a queue across all concurrency groups.
+   * Returns the minimum available capacity across all groups.
+   */
+  async getAvailableCapacity(queue: QueueDescriptor): Promise<number> {
+    if (this.groups.length === 0) {
+      return 0;
+    }
+
+    // Build group data for parallel fetching
+    const groupData = this.groups.map((group) => ({
+      group,
+      groupId: group.extractGroupId(queue),
+    }));
+
+    // Fetch all current counts and limits in parallel
+    const [currents, limits] = await Promise.all([
+      Promise.all(
+        groupData.map(({ group, groupId }) =>
+          this.redis.scard(this.keys.concurrencyKey(group.name, groupId))
+        )
+      ),
+      Promise.all(
+        groupData.map(({ group, groupId }) =>
+          group.getLimit(groupId).then((limit) => limit || group.defaultLimit)
+        )
+      ),
+    ]);
+
+    // Calculate minimum available capacity across all groups
+    let minCapacity = Infinity;
+    for (let i = 0; i < groupData.length; i++) {
+      const available = Math.max(0, limits[i]! - currents[i]!);
+      minCapacity = Math.min(minCapacity, available);
+    }
+
+    return minCapacity === Infinity ? 0 : minCapacity;
+  }
+
   /**
    * Get concurrency limit for a specific group.
    */
diff --git a/packages/redis-worker/src/fair-queue/index.ts b/packages/redis-worker/src/fair-queue/index.ts
index 8b47a79f347..0c0b7921a6b 100644
--- a/packages/redis-worker/src/fair-queue/index.ts
+++ b/packages/redis-worker/src/fair-queue/index.ts
@@ -1,29 +1,34 @@
 import { createRedisClient, type Redis, type RedisOptions } from "@internal/redis";
-import { SpanKind } from "@internal/tracing";
+import { SpanKind, type Span } from "@internal/tracing";
 import { Logger } from "@trigger.dev/core/logger";
 import { nanoid } from "nanoid";
 import { setInterval } from "node:timers/promises";
 import { type z } from "zod";
 import { ConcurrencyManager } from "./concurrency.js";
 import { MasterQueue } from "./masterQueue.js";
+import { TenantDispatch } from "./tenantDispatch.js";
 import { type RetryStrategy, ExponentialBackoffRetry } from "./retry.js";
-import { FairQueueTelemetry, FairQueueAttributes, MessagingAttributes } from "./telemetry.js";
+import { isAbortError } from "../utils.js";
+import {
+  FairQueueTelemetry,
+  FairQueueAttributes,
+  MessagingAttributes,
+  BatchedSpanManager,
+} from "./telemetry.js";
 import type {
   ConcurrencyGroupConfig,
   DeadLetterMessage,
+  DispatchSchedulerContext,
   EnqueueBatchOptions,
   EnqueueOptions,
   FairQueueKeyProducer,
   FairQueueOptions,
   FairScheduler,
-  GlobalRateLimiter,
-  MessageHandler,
-  MessageHandlerContext,
   QueueCooloffState,
   QueueDescriptor,
-  QueueMessage,
   SchedulerContext,
   StoredMessage,
+  TenantQueues,
 } from "./types.js";
 import { VisibilityManager } from "./visibility.js";
 import { WorkerQueueManager } from "./workerQueue.js";
@@ -39,19 +44,24 @@ export * from "./scheduler.js";
 export * from "./schedulers/index.js";
 export * from "./retry.js";
 export * from "./telemetry.js";
+export * from "./tenantDispatch.js";
 
 /**
- * FairQueue is the main orchestrator for fair queue processing.
+ * FairQueue is the main orchestrator for fair queue message routing.
  *
- * It coordinates:
+ * FairQueue handles:
  * - Master queue with sharding (using jump consistent hash)
  * - Fair scheduling via pluggable schedulers
  * - Multi-level concurrency limiting
  * - Visibility timeouts with heartbeats
- * - Worker queues with blocking pop
+ * - Routing messages to worker queues
  * - Retry strategies with dead letter queue
  * - OpenTelemetry tracing and metrics
  *
+ * External consumers are responsible for:
+ * - Running their own worker queue consumer loops
+ * - Calling complete/release/fail APIs after processing
+ *
  * @typeParam TPayloadSchema - Zod schema for message payload validation
  */
 export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
@@ -61,7 +71,7 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   private masterQueue: MasterQueue;
   private concurrencyManager?: ConcurrencyManager;
   private visibilityManager: VisibilityManager;
-  private workerQueueManager?: WorkerQueueManager;
+  private workerQueueManager: WorkerQueueManager;
   private telemetry: FairQueueTelemetry;
   private logger: Logger;
 
@@ -76,30 +86,37 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   private visibilityTimeoutMs: number;
   private heartbeatIntervalMs: number;
   private reclaimIntervalMs: number;
-  private workerQueueEnabled: boolean;
-  private workerQueueBlockingTimeoutSeconds: number;
-  private workerQueueResolver?: (message: StoredMessage<z.infer<TPayloadSchema>>) => string;
+  private workerQueueResolver: (message: StoredMessage<z.infer<TPayloadSchema>>) => string;
+  private batchClaimSize: number;
 
   // Cooloff state
   private cooloffEnabled: boolean;
   private cooloffThreshold: number;
   private cooloffPeriodMs: number;
+  private maxCooloffStatesSize: number;
   private queueCooloffStates = new Map<string, QueueCooloffState>();
 
-  // Global rate limiter
-  private globalRateLimiter?: GlobalRateLimiter;
+  // Worker queue backpressure
+  private workerQueueMaxDepth: number;
+  private workerQueueDepthCheckId?: string;
+
+  // Consumer tracing
+  private consumerTraceMaxIterations: number;
+  private consumerTraceTimeoutSeconds: number;
+  private batchedSpanManager: BatchedSpanManager;
 
   // Runtime state
-  private messageHandler?: MessageHandler<z.infer<TPayloadSchema>>;
   private isRunning = false;
   private abortController: AbortController;
   private masterQueueConsumerLoops: Promise<void>[] = [];
-  private workerQueueConsumerLoops: Promise<void>[] = [];
   private reclaimLoop?: Promise<void>;
 
   // Queue descriptor cache for message processing
   private queueDescriptorCache = new Map<string, QueueDescriptor>();
 
+  // Two-level tenant dispatch
+  private tenantDispatch: TenantDispatch;
+
   constructor(private options: FairQueueOptions<TPayloadSchema>) {
     this.redis = createRedisClient(options.redis);
     this.keys = options.keys;
@@ -123,18 +140,25 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? this.visibilityTimeoutMs / 3;
     this.reclaimIntervalMs = options.reclaimIntervalMs ?? 5_000;
 
-    // Worker queue
-    this.workerQueueEnabled = options.workerQueue?.enabled ?? false;
-    this.workerQueueBlockingTimeoutSeconds = options.workerQueue?.blockingTimeoutSeconds ?? 10;
-    this.workerQueueResolver = options.workerQueue?.resolveWorkerQueue;
+    // Worker queue resolver (required)
+    this.workerQueueResolver = options.workerQueue.resolveWorkerQueue;
+
+    // Batch claiming
+    this.batchClaimSize = options.batchClaimSize ?? 10;
 
     // Cooloff
     this.cooloffEnabled = options.cooloff?.enabled ?? true;
     this.cooloffThreshold = options.cooloff?.threshold ?? 10;
     this.cooloffPeriodMs = options.cooloff?.periodMs ?? 10_000;
+    this.maxCooloffStatesSize = options.cooloff?.maxStatesSize ?? 1000;
 
-    // Global rate limiter
-    this.globalRateLimiter = options.globalRateLimiter;
+    // Worker queue backpressure
+    this.workerQueueMaxDepth = options.workerQueueMaxDepth ?? 0;
+    this.workerQueueDepthCheckId = options.workerQueueDepthCheckId;
+
+    // Consumer tracing
+    this.consumerTraceMaxIterations = options.consumerTraceMaxIterations ?? 500;
+    this.consumerTraceTimeoutSeconds = options.consumerTraceTimeoutSeconds ?? 60;
 
     // Initialize telemetry
     this.telemetry = new FairQueueTelemetry({
@@ -143,6 +167,18 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
       name: options.name ?? "fairqueue",
     });
 
+    // Initialize batched span manager for consumer tracing
+    this.batchedSpanManager = new BatchedSpanManager({
+      tracer: options.tracer,
+      name: options.name ?? "fairqueue",
+      maxIterations: this.consumerTraceMaxIterations,
+      timeoutSeconds: this.consumerTraceTimeoutSeconds,
+      getDynamicAttributes: () => ({
+        "cache.descriptor_size": this.queueDescriptorCache.size,
+        "cache.cooloff_states_size": this.queueCooloffStates.size,
+      }),
+    });
+
     // Initialize components
     this.masterQueue = new MasterQueue({
       redis: options.redis,
@@ -150,6 +186,13 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
       shardCount: this.shardCount,
     });
 
+    this.tenantDispatch = new TenantDispatch({
+      redis: options.redis,
+      keys: options.keys,
+      shardCount: this.shardCount,
+    });
+
+
     if (options.concurrencyGroups && options.concurrencyGroups.length > 0) {
       this.concurrencyManager = new ConcurrencyManager({
         redis: options.redis,
@@ -169,16 +212,15 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
       },
     });
 
-    if (this.workerQueueEnabled) {
-      this.workerQueueManager = new WorkerQueueManager({
-        redis: options.redis,
-        keys: options.keys,
-        logger: {
-          debug: (msg, ctx) => this.logger.debug(msg, ctx),
-          error: (msg, ctx) => this.logger.error(msg, ctx),
-        },
-      });
-    }
+    // Worker queue manager for pushing messages to worker queues
+    this.workerQueueManager = new WorkerQueueManager({
+      redis: options.redis,
+      keys: options.keys,
+      logger: {
+        debug: (msg, ctx) => this.logger.debug(msg, ctx),
+        error: (msg, ctx) => this.logger.error(msg, ctx),
+      },
+    });
 
     this.#registerCommands();
 
@@ -203,6 +245,9 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
       getMasterQueueLength: async (shardId: number) => {
         return await this.masterQueue.getShardQueueCount(shardId);
       },
+      getDispatchLength: async (shardId: number) => {
+        return await this.tenantDispatch.getShardTenantCount(shardId);
+      },
       getInflightCount: async (shardId: number) => {
         return await this.visibilityManager.getInflightCount(shardId);
       },
@@ -214,17 +259,6 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     });
   }
 
-  // ============================================================================
-  // Public API - Message Handler
-  // ============================================================================
-
-  /**
-   * Set the message handler for processing dequeued messages.
-   */
-  onMessage(handler: MessageHandler<z.infer<TPayloadSchema>>): void {
-    this.messageHandler = handler;
-  }
-
   // ============================================================================
   // Public API - Enqueueing
   // ============================================================================
@@ -240,8 +274,9 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
         const timestamp = options.timestamp ?? Date.now();
         const queueKey = this.keys.queueKey(options.queueId);
         const queueItemsKey = this.keys.queueItemsKey(options.queueId);
-        const shardId = this.masterQueue.getShardForQueue(options.queueId);
-        const masterQueueKey = this.keys.masterQueueKey(shardId);
+        const dispatchShardId = this.tenantDispatch.getShardForTenant(options.tenantId);
+        const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(options.tenantId);
+        const dispatchKey = this.keys.dispatchKey(dispatchShardId);
 
         // Validate payload if schema provided and validation enabled
         if (this.validateOnEnqueue && this.payloadSchema) {
@@ -277,35 +312,31 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
                 attempt: 1,
                 metadata: options.metadata,
               })
-            : options.queueId,
+            : undefined,
           metadata: options.metadata,
         };
 
-        // Use atomic Lua script to enqueue and update master queue
-        await this.redis.enqueueMessageAtomic(
+        // Use atomic Lua script to enqueue and update tenant dispatch indexes
+        await this.redis.enqueueMessageAtomicV2(
           queueKey,
           queueItemsKey,
-          masterQueueKey,
+          tenantQueueIndexKey,
+          dispatchKey,
           options.queueId,
           messageId,
           timestamp.toString(),
-          JSON.stringify(storedMessage)
+          JSON.stringify(storedMessage),
+          options.tenantId
         );
 
         span.setAttributes({
           [FairQueueAttributes.QUEUE_ID]: options.queueId,
           [FairQueueAttributes.TENANT_ID]: options.tenantId,
           [FairQueueAttributes.MESSAGE_ID]: messageId,
-          [FairQueueAttributes.SHARD_ID]: shardId.toString(),
+          [FairQueueAttributes.SHARD_ID]: dispatchShardId.toString(),
         });
 
-        this.telemetry.recordEnqueue(
-          this.telemetry.messageAttributes({
-            queueId: options.queueId,
-            tenantId: options.tenantId,
-            messageId,
-          })
-        );
+        this.telemetry.recordEnqueue();
 
         this.logger.debug("Message enqueued", {
           queueId: options.queueId,
@@ -333,8 +364,9 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
       async (span) => {
         const queueKey = this.keys.queueKey(options.queueId);
         const queueItemsKey = this.keys.queueItemsKey(options.queueId);
-        const shardId = this.masterQueue.getShardForQueue(options.queueId);
-        const masterQueueKey = this.keys.masterQueueKey(shardId);
+        const dispatchShardId = this.tenantDispatch.getShardForTenant(options.tenantId);
+        const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(options.tenantId);
+        const dispatchKey = this.keys.dispatchKey(dispatchShardId);
         const now = Date.now();
 
         // Store queue descriptor
@@ -379,7 +411,7 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
                   attempt: 1,
                   metadata: options.metadata,
                 })
-              : options.queueId,
+              : undefined,
             metadata: options.metadata,
           };
 
@@ -387,12 +419,14 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
           args.push(messageId, timestamp.toString(), JSON.stringify(storedMessage));
         }
 
-        // Use atomic Lua script for batch enqueue
-        await this.redis.enqueueBatchAtomic(
+        // Use atomic Lua script for batch enqueue with tenant dispatch indexes
+        await this.redis.enqueueBatchAtomicV2(
           queueKey,
           queueItemsKey,
-          masterQueueKey,
+          tenantQueueIndexKey,
+          dispatchKey,
           options.queueId,
+          options.tenantId,
           ...args
         );
 
@@ -400,16 +434,10 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
           [FairQueueAttributes.QUEUE_ID]: options.queueId,
           [FairQueueAttributes.TENANT_ID]: options.tenantId,
           [FairQueueAttributes.MESSAGE_COUNT]: messageIds.length,
-          [FairQueueAttributes.SHARD_ID]: shardId.toString(),
+          [FairQueueAttributes.SHARD_ID]: dispatchShardId.toString(),
         });
 
-        this.telemetry.recordEnqueueBatch(
-          messageIds.length,
-          this.telemetry.messageAttributes({
-            queueId: options.queueId,
-            tenantId: options.tenantId,
-          })
-        );
+        this.telemetry.recordEnqueueBatch(messageIds.length);
 
         this.logger.debug("Batch enqueued", {
           queueId: options.queueId,
@@ -575,12 +603,43 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     return await this.redis.zcard(dlqKey);
   }
 
+  /**
+   * Get the size of the in-memory queue descriptor cache.
+   * This cache stores metadata for queues that have been enqueued.
+   * The cache is cleaned up when queues are fully processed.
+   */
+  getQueueDescriptorCacheSize(): number {
+    return this.queueDescriptorCache.size;
+  }
+
+  /**
+   * Get the size of the in-memory cooloff states cache.
+   * This cache tracks queues that are in cooloff due to repeated failures.
+   * The cache is cleaned up when queues are fully processed or cooloff expires.
+   */
+  getQueueCooloffStatesSize(): number {
+    return this.queueCooloffStates.size;
+  }
+
+  /**
+   * Get all in-memory cache sizes for monitoring.
+   * Useful for adding as span attributes.
+   */
+  getCacheSizes(): { descriptorCacheSize: number; cooloffStatesSize: number } {
+    return {
+      descriptorCacheSize: this.queueDescriptorCache.size,
+      cooloffStatesSize: this.queueCooloffStates.size,
+    };
+  }
+
   // ============================================================================
   // Public API - Lifecycle
   // ============================================================================
 
   /**
-   * Start the consumer loops and reclaim loop.
+   * Start the master queue consumer loops and reclaim loop.
+   * FairQueue claims messages and pushes them to worker queues.
+   * External consumers are responsible for consuming from worker queues.
    */
   start(): void {
     if (this.isRunning) {
@@ -590,36 +649,19 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     this.isRunning = true;
     this.abortController = new AbortController();
 
-    if (this.workerQueueEnabled && this.workerQueueManager) {
-      // Two-stage processing: master queue consumers push to worker queues
-      // Start master queue consumers (one per shard)
-      for (let shardId = 0; shardId < this.shardCount; shardId++) {
-        const loop = this.#runMasterQueueConsumerLoop(shardId);
-        this.masterQueueConsumerLoops.push(loop);
-      }
-
-      // Start worker queue consumers (multiple per consumer count)
-      for (let consumerId = 0; consumerId < this.consumerCount; consumerId++) {
-        const loop = this.#runWorkerQueueConsumerLoop(consumerId);
-        this.workerQueueConsumerLoops.push(loop);
-      }
-    } else {
-      // Direct processing: consumers process from message queues directly
-      for (let consumerId = 0; consumerId < this.consumerCount; consumerId++) {
-        for (let shardId = 0; shardId < this.shardCount; shardId++) {
-          const loop = this.#runDirectConsumerLoop(consumerId, shardId);
-          this.masterQueueConsumerLoops.push(loop);
-        }
-      }
+    // Start master queue consumers (one per shard)
+    // These claim messages from queues and push to worker queues
+    for (let shardId = 0; shardId < this.shardCount; shardId++) {
+      const loop = this.#runMasterQueueConsumerLoop(shardId);
+      this.masterQueueConsumerLoops.push(loop);
     }
 
-    // Start reclaim loop
+    // Start reclaim loop for handling timed-out messages
     this.reclaimLoop = this.#runReclaimLoop();
 
     this.logger.info("FairQueue started", {
       consumerCount: this.consumerCount,
       shardCount: this.shardCount,
-      workerQueueEnabled: this.workerQueueEnabled,
       consumerIntervalMs: this.consumerIntervalMs,
     });
   }
@@ -635,14 +677,9 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     this.isRunning = false;
     this.abortController.abort();
 
-    await Promise.allSettled([
-      ...this.masterQueueConsumerLoops,
-      ...this.workerQueueConsumerLoops,
-      this.reclaimLoop,
-    ]);
+    await Promise.allSettled([...this.masterQueueConsumerLoops, this.reclaimLoop]);
 
     this.masterQueueConsumerLoops = [];
-    this.workerQueueConsumerLoops = [];
     this.reclaimLoop = undefined;
 
     this.logger.info("FairQueue stopped");
@@ -653,11 +690,16 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
    */
   async close(): Promise<void> {
     await this.stop();
+
+    // Clean up any remaining batched spans
+    this.batchedSpanManager.cleanupAll();
+
     await Promise.all([
       this.masterQueue.close(),
+      this.tenantDispatch.close(),
       this.concurrencyManager?.close(),
       this.visibilityManager.close(),
-      this.workerQueueManager?.close(),
+      this.workerQueueManager.close(),
       this.scheduler.close?.(),
       this.redis.quit(),
     ]);
@@ -676,10 +718,14 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   }
 
   /**
-   * Get total queue count across all shards.
+   * Get total tenant count across dispatch shards plus any legacy queues still draining.
    */
   async getTotalQueueCount(): Promise<number> {
-    return await this.masterQueue.getTotalQueueCount();
+    const [dispatchCount, legacyCount] = await Promise.all([
+      this.tenantDispatch.getTotalTenantCount(),
+      this.masterQueue.getTotalQueueCount(),
+    ]);
+    return dispatchCount + legacyCount;
   }
 
   /**
@@ -703,593 +749,661 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   async #runMasterQueueConsumerLoop(shardId: number): Promise<void> {
     const loopId = `master-shard-${shardId}`;
 
+    // Initialize batched span tracking for this loop
+    this.batchedSpanManager.initializeLoop(loopId);
+
     try {
-      for await (const _ of setInterval(this.consumerIntervalMs, null, {
-        signal: this.abortController.signal,
-      })) {
+      while (this.isRunning) {
+        // Check abort signal
+        if (this.abortController.signal.aborted) {
+          break;
+        }
+
+        let hadWork = false;
         try {
-          await this.#processMasterQueueShard(loopId, shardId);
+          hadWork = await this.batchedSpanManager.withBatchedSpan(
+            loopId,
+            async (span) => {
+              span.setAttribute("shard_id", shardId);
+              return await this.#processShardIteration(loopId, shardId, span);
+            },
+            {
+              iterationSpanName: "processMasterQueueShard",
+              attributes: { shard_id: shardId },
+            }
+          );
         } catch (error) {
           this.logger.error("Master queue consumer error", {
             loopId,
             shardId,
             error: error instanceof Error ? error.message : String(error),
           });
+          this.batchedSpanManager.markForRotation(loopId);
         }
+
+        // Wait between iterations to prevent CPU spin
+        // Short delay when there's work (yield to event loop), longer delay when idle
+        const waitMs = hadWork ? 1 : this.consumerIntervalMs;
+        await new Promise<void>((resolve, reject) => {
+          const abortHandler = () => {
+            clearTimeout(timeout);
+            reject(new Error("AbortError"));
+          };
+          const timeout = setTimeout(() => {
+            // Must remove listener when timeout fires, otherwise listeners accumulate
+            // (the { once: true } option only removes on abort, not on timeout)
+            this.abortController.signal.removeEventListener("abort", abortHandler);
+            resolve();
+          }, waitMs);
+          this.abortController.signal.addEventListener("abort", abortHandler, { once: true });
+        });
       }
     } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
+      if (isAbortError(error)) {
         this.logger.debug("Master queue consumer aborted", { loopId });
+        this.batchedSpanManager.cleanup(loopId);
         return;
       }
       throw error;
+    } finally {
+      this.batchedSpanManager.cleanup(loopId);
     }
   }
 
-  async #processMasterQueueShard(loopId: string, shardId: number): Promise<void> {
-    const masterQueueKey = this.keys.masterQueueKey(shardId);
+  /**
+   * Process a shard iteration. Runs both the new tenant dispatch path
+   * and the legacy master queue drain path.
+   */
+  async #processShardIteration(
+    loopId: string,
+    shardId: number,
+    parentSpan?: Span
+  ): Promise<boolean> {
+    let hadWork = false;
+
+    // Main path: new two-level tenant dispatch (gets full DRR scheduling)
+    hadWork = await this.#processDispatchShard(loopId, shardId, parentSpan);
+
+    // Drain path: legacy master queue (simple scheduling, no DRR)
+    // Check ZCARD first (O(1)) to skip the drain path when empty
+    const legacyCount = await this.masterQueue.getShardQueueCount(shardId);
+    if (legacyCount > 0) {
+      const drainHadWork = await this.#drainLegacyMasterQueueShard(loopId, shardId, parentSpan);
+      hadWork = hadWork || drainHadWork;
+    }
+
+    return hadWork;
+  }
 
-    // Create scheduler context
-    const context = this.#createSchedulerContext();
+  /**
+   * Main path: process queues using the two-level tenant dispatch index.
+   * Level 1: dispatch index → tenantIds. Level 2: per-tenant → queueIds.
+   */
+  async #processDispatchShard(
+    loopId: string,
+    shardId: number,
+    parentSpan?: Span
+  ): Promise<boolean> {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+
+    // Get dispatch index size for observability
+    const dispatchSize = await this.tenantDispatch.getShardTenantCount(shardId);
+    parentSpan?.setAttribute("dispatch_size", dispatchSize);
+    this.batchedSpanManager.incrementStat(loopId, "dispatch_size_sum", dispatchSize);
+
+    // Create dispatch-aware scheduler context
+    const schedulerContext: DispatchSchedulerContext = {
+      ...this.#createSchedulerContext(),
+      getQueuesForTenant: async (tenantId: string, limit?: number) => {
+        return this.tenantDispatch.getQueuesForTenant(tenantId, limit);
+      },
+    };
 
     // Get queues to process from scheduler
-    const tenantQueues = await this.scheduler.selectQueues(masterQueueKey, loopId, context);
+    let tenantQueues: TenantQueues[];
+
+    if (this.scheduler.selectQueuesFromDispatch) {
+      // Use dispatch-aware scheduler method (DRR with two-level lookup)
+      tenantQueues = await this.telemetry.trace(
+        "selectQueuesFromDispatch",
+        async (span) => {
+          span.setAttribute(FairQueueAttributes.SHARD_ID, shardId.toString());
+          span.setAttribute(FairQueueAttributes.CONSUMER_ID, loopId);
+          span.setAttribute("dispatch_size", dispatchSize);
+          const result = await this.scheduler.selectQueuesFromDispatch!(
+            dispatchKey,
+            loopId,
+            schedulerContext
+          );
+          span.setAttribute("tenant_count", result.length);
+          span.setAttribute(
+            "queue_count",
+            result.reduce((acc, t) => acc + t.queues.length, 0)
+          );
+          return result;
+        },
+        { kind: SpanKind.INTERNAL }
+      );
+    } else {
+      // Fallback: read dispatch index, build flat queue list, use legacy selectQueues
+      tenantQueues = await this.#fallbackDispatchToLegacyScheduler(
+        loopId,
+        shardId,
+        schedulerContext,
+        parentSpan
+      );
+    }
 
     if (tenantQueues.length === 0) {
-      return;
+      this.batchedSpanManager.incrementStat(loopId, "empty_iterations");
+      return false;
+    }
+
+    return this.#processSelectedQueues(loopId, shardId, tenantQueues);
+  }
+
+  /**
+   * Drain path: process remaining messages from the legacy master queue shard.
+   * Uses simple ZRANGEBYSCORE without DRR - just flushing pre-deploy messages.
+   */
+  async #drainLegacyMasterQueueShard(
+    loopId: string,
+    shardId: number,
+    parentSpan?: Span
+  ): Promise<boolean> {
+    const masterQueueKey = this.keys.masterQueueKey(shardId);
+    const now = Date.now();
+
+    // Simple fetch from old master queue - no DRR needed for drain
+    const results = await this.redis.zrangebyscore(
+      masterQueueKey,
+      "-inf",
+      now,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      100
+    );
+
+    if (results.length === 0) {
+      return false;
+    }
+
+    // Parse results into QueueWithScore, group by tenant
+    const byTenant = new Map<string, string[]>();
+    for (let i = 0; i < results.length; i += 2) {
+      const queueId = results[i];
+      const _score = results[i + 1];
+      if (queueId && _score) {
+        const tenantId = this.keys.extractTenantId(queueId);
+        const existing = byTenant.get(tenantId) ?? [];
+        existing.push(queueId);
+        byTenant.set(tenantId, existing);
+      }
+    }
+
+    // Build TenantQueues, filter at-capacity tenants
+    const tenantQueues: TenantQueues[] = [];
+    for (const [tenantId, queueIds] of byTenant) {
+      if (this.concurrencyManager) {
+        const atCapacity = await this.concurrencyManager.isAtCapacity("tenant", tenantId);
+        if (atCapacity) continue;
+      }
+      tenantQueues.push({ tenantId, queues: queueIds });
+    }
+
+    if (tenantQueues.length === 0) {
+      return false;
+    }
+
+    parentSpan?.setAttribute("drain_tenants", tenantQueues.length);
+    this.batchedSpanManager.incrementStat(loopId, "drain_tenants", tenantQueues.length);
+
+    return this.#processSelectedQueues(loopId, shardId, tenantQueues);
+  }
+
+  /**
+   * Fallback for schedulers that don't implement selectQueuesFromDispatch.
+   * Reads dispatch index, fetches per-tenant queues, groups by tenant,
+   * and filters at-capacity tenants. No DRR deficit tracking in this path.
+   */
+  async #fallbackDispatchToLegacyScheduler(
+    loopId: string,
+    shardId: number,
+    context: DispatchSchedulerContext,
+    parentSpan?: Span
+  ): Promise<TenantQueues[]> {
+    // Get tenants from dispatch
+    const tenants = await this.tenantDispatch.getTenantsFromShard(shardId);
+    if (tenants.length === 0) return [];
+
+    // For each tenant, get their queues and build grouped result
+    const tenantQueues: TenantQueues[] = [];
+    for (const { tenantId } of tenants) {
+      if (this.concurrencyManager) {
+        const atCapacity = await this.concurrencyManager.isAtCapacity("tenant", tenantId);
+        if (atCapacity) continue;
+      }
+      const queues = await this.tenantDispatch.getQueuesForTenant(tenantId);
+      if (queues.length > 0) {
+        tenantQueues.push({ tenantId, queues: queues.map((q) => q.queueId) });
+      }
     }
 
-    // Process queues and push to worker queues
+    return tenantQueues;
+  }
+
+  /**
+   * Shared claim loop: process selected queues from either dispatch or drain path.
+   * Claims messages and pushes to worker queues.
+   */
+  async #processSelectedQueues(
+    loopId: string,
+    shardId: number,
+    tenantQueues: TenantQueues[]
+  ): Promise<boolean> {
+    // Track stats
+    this.batchedSpanManager.incrementStat(loopId, "tenants_selected", tenantQueues.length);
+    this.batchedSpanManager.incrementStat(
+      loopId,
+      "queues_selected",
+      tenantQueues.reduce((acc, t) => acc + t.queues.length, 0)
+    );
+
+    let messagesProcessed = 0;
+
     for (const { tenantId, queues } of tenantQueues) {
       for (const queueId of queues) {
         // Check cooloff
         if (this.cooloffEnabled && this.#isInCooloff(queueId)) {
+          this.batchedSpanManager.incrementStat(loopId, "cooloff_skipped");
           continue;
         }
 
-        const processed = await this.#claimAndPushToWorkerQueue(loopId, queueId, tenantId, shardId);
+        // Check tenant capacity before attempting to process
+        if (this.concurrencyManager) {
+          const isAtCapacity = await this.concurrencyManager.isAtCapacity("tenant", tenantId);
+          if (isAtCapacity) {
+            this.batchedSpanManager.incrementStat(loopId, "tenant_capacity_skipped");
+            break;
+          }
+        }
+
+        const processedFromQueue = await this.telemetry.trace(
+          "claimAndPushToWorkerQueue",
+          async (span) => {
+            span.setAttribute(FairQueueAttributes.QUEUE_ID, queueId);
+            span.setAttribute(FairQueueAttributes.TENANT_ID, tenantId);
+            span.setAttribute(FairQueueAttributes.SHARD_ID, shardId.toString());
+            const count = await this.#claimAndPushToWorkerQueue(loopId, queueId, tenantId, shardId);
+            span.setAttribute("messages_claimed", count);
+            return count;
+          },
+          { kind: SpanKind.INTERNAL }
+        );
 
-        if (processed) {
-          await this.scheduler.recordProcessed?.(tenantId, queueId);
-          this.#resetCooloff(queueId);
+        if (processedFromQueue > 0) {
+          messagesProcessed += processedFromQueue;
+          this.batchedSpanManager.incrementStat(loopId, "messages_claimed", processedFromQueue);
+
+          if (this.scheduler.recordProcessedBatch) {
+            await this.telemetry.trace(
+              "recordProcessedBatch",
+              async (span) => {
+                span.setAttribute(FairQueueAttributes.QUEUE_ID, queueId);
+                span.setAttribute(FairQueueAttributes.TENANT_ID, tenantId);
+                span.setAttribute("count", processedFromQueue);
+                await this.scheduler.recordProcessedBatch!(tenantId, queueId, processedFromQueue);
+              },
+              { kind: SpanKind.INTERNAL }
+            );
+          } else if (this.scheduler.recordProcessed) {
+            for (let i = 0; i < processedFromQueue; i++) {
+              await this.telemetry.trace(
+                "recordProcessed",
+                async (span) => {
+                  span.setAttribute(FairQueueAttributes.QUEUE_ID, queueId);
+                  span.setAttribute(FairQueueAttributes.TENANT_ID, tenantId);
+                  await this.scheduler.recordProcessed!(tenantId, queueId);
+                },
+                { kind: SpanKind.INTERNAL }
+              );
+            }
+          }
         } else {
-          this.#incrementCooloff(queueId);
+          this.batchedSpanManager.incrementStat(loopId, "claim_skipped");
         }
       }
     }
+
+    return messagesProcessed > 0;
   }
 
   async #claimAndPushToWorkerQueue(
     loopId: string,
     queueId: string,
     tenantId: string,
-    shardId: number
-  ): Promise<boolean> {
+    _consumerShardId: number
+  ): Promise<number> {
+    // Dispatch shard is tenant-based (tenantId hash), not queue-based.
+    // In-flight/master queue shard is queue-based.
+    const dispatchShardId = this.tenantDispatch.getShardForTenant(tenantId);
     const queueKey = this.keys.queueKey(queueId);
     const queueItemsKey = this.keys.queueItemsKey(queueId);
-    const masterQueueKey = this.keys.masterQueueKey(shardId);
     const descriptor = this.queueDescriptorCache.get(queueId) ?? {
       id: queueId,
       tenantId,
       metadata: {},
     };
 
-    // Check concurrency before claiming
+    // Determine how many messages we can claim based on concurrency
+    let maxClaimCount = this.batchClaimSize;
     if (this.concurrencyManager) {
-      const check = await this.concurrencyManager.canProcess(descriptor);
-      if (!check.allowed) {
-        return false;
+      const availableCapacity = await this.concurrencyManager.getAvailableCapacity(descriptor);
+      if (availableCapacity === 0) {
+        // Queue at max concurrency - don't increment cooloff here.
+        // The outer loop already handles this case (concurrency blocked)
+        // and explicitly avoids cooloff for it. Cooloff here causes
+        // spurious 5s stalls when capacity races between the tenant
+        // pre-check and this per-queue check.
+        return 0;
       }
+      maxClaimCount = Math.min(maxClaimCount, availableCapacity);
     }
 
-    // Check global rate limit - wait if rate limited
-    if (this.globalRateLimiter) {
-      const result = await this.globalRateLimiter.limit();
-      if (!result.allowed && result.resetAt) {
-        const waitMs = Math.max(0, result.resetAt - Date.now());
-        if (waitMs > 0) {
-          this.logger.debug("Global rate limit reached, waiting", { waitMs, loopId });
-          await new Promise((resolve) => setTimeout(resolve, waitMs));
-        }
+    // Check worker queue depth to prevent unbounded growth.
+    // Messages in the worker queue are already in-flight with a visibility timeout.
+    // If the queue is too deep, consumers can't keep up, and messages risk timing out.
+    if (this.workerQueueMaxDepth > 0 && this.workerQueueDepthCheckId) {
+      const depth = await this.workerQueueManager.getLength(this.workerQueueDepthCheckId);
+      if (depth >= this.workerQueueMaxDepth) {
+        return 0;
       }
+      // Cap claim size to remaining capacity so we don't overshoot the depth limit
+      const remainingCapacity = this.workerQueueMaxDepth - depth;
+      maxClaimCount = Math.min(maxClaimCount, remainingCapacity);
     }
 
-    // Claim message with visibility timeout
-    const claimResult = await this.visibilityManager.claim<StoredMessage<z.infer<TPayloadSchema>>>(
-      queueId,
-      queueKey,
-      queueItemsKey,
-      loopId,
-      this.visibilityTimeoutMs
-    );
+    // Claim batch of messages with visibility timeout
+    const claimedMessages = await this.visibilityManager.claimBatch<
+      StoredMessage<z.infer<TPayloadSchema>>
+    >(queueId, queueKey, queueItemsKey, loopId, maxClaimCount, this.visibilityTimeoutMs);
 
-    if (!claimResult.claimed || !claimResult.message) {
-      // Queue is empty, update master queue
-      await this.redis.updateMasterQueueIfEmpty(masterQueueKey, queueKey, queueId);
-      return false;
+    if (claimedMessages.length === 0) {
+      // Queue is empty, update both old and new indexes and clean up caches
+      await this.#updateAllIndexesAfterDequeue(queueId, tenantId);
+      this.queueDescriptorCache.delete(queueId);
+      this.queueCooloffStates.delete(queueId);
+      return 0;
     }
 
-    const { message } = claimResult;
+    let processedCount = 0;
 
-    // Reserve concurrency slot
-    if (this.concurrencyManager) {
-      const reserved = await this.concurrencyManager.reserve(descriptor, message.messageId);
-      if (!reserved) {
-        // Release message back to queue
-        await this.visibilityManager.release(message.messageId, queueId, queueKey, queueItemsKey);
-        return false;
+    // Reserve concurrency and push each message to worker queue
+    for (let i = 0; i < claimedMessages.length; i++) {
+      const message = claimedMessages[i]!;
+
+      // Reserve concurrency slot
+      if (this.concurrencyManager) {
+        const reserved = await this.concurrencyManager.reserve(descriptor, message.messageId);
+        if (!reserved) {
+          // Release ALL remaining messages (from index i onward) back to queue
+          // This prevents messages from being stranded in the in-flight set
+          const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(tenantId);
+          const dispatchKey = this.keys.dispatchKey(dispatchShardId);
+          await this.visibilityManager.releaseBatch(
+            claimedMessages.slice(i),
+            queueId,
+            queueKey,
+            queueItemsKey,
+            tenantQueueIndexKey,
+            dispatchKey,
+            tenantId
+          );
+          // Stop processing more messages from this queue since we're at capacity
+          break;
+        }
       }
-    }
 
-    // Determine worker queue
-    const workerQueueId = message.payload.workerQueue ?? queueId;
+      // Resolve which worker queue this message should go to
+      const workerQueueId = this.workerQueueResolver(message.payload);
+
+      // Push to worker queue with format "messageId:queueId"
+      const messageKey = `${message.messageId}:${queueId}`;
+      await this.workerQueueManager.push(workerQueueId, messageKey);
+      processedCount++;
+    }
 
-    // Push to worker queue
-    const messageKey = `${message.messageId}:${queueId}`;
-    await this.workerQueueManager!.push(workerQueueId, messageKey);
+    if (processedCount > 0) {
+      this.#resetCooloff(queueId);
+    }
 
-    return true;
+    return processedCount;
   }
 
   // ============================================================================
-  // Private - Worker Queue Consumer Loop (Two-Stage)
+  // Public API - Message Lifecycle (for external consumers)
   // ============================================================================
 
-  async #runWorkerQueueConsumerLoop(consumerId: number): Promise<void> {
-    const loopId = `worker-${consumerId}`;
-    const workerQueueId = loopId; // Each consumer has its own worker queue by default
-
-    try {
-      while (this.isRunning) {
-        if (!this.messageHandler) {
-          await new Promise((resolve) => setTimeout(resolve, this.consumerIntervalMs));
-          continue;
-        }
-
-        try {
-          // Blocking pop from worker queue
-          const messageKey = await this.workerQueueManager!.blockingPop(
-            workerQueueId,
-            this.workerQueueBlockingTimeoutSeconds,
-            this.abortController.signal
-          );
-
-          if (!messageKey) {
-            continue; // Timeout, loop again
-          }
-
-          // Parse message key
-          const colonIndex = messageKey.indexOf(":");
-          if (colonIndex === -1) {
-            this.logger.error("Invalid message key format", { messageKey });
-            continue;
-          }
-
-          const messageId = messageKey.substring(0, colonIndex);
-          const queueId = messageKey.substring(colonIndex + 1);
-
-          await this.#processMessageFromWorkerQueue(loopId, messageId, queueId);
-        } catch (error) {
-          if (this.abortController.signal.aborted) {
-            break;
-          }
-          this.logger.error("Worker queue consumer error", {
-            loopId,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        this.logger.debug("Worker queue consumer aborted", { loopId });
-        return;
-      }
-      throw error;
-    }
-  }
-
-  async #processMessageFromWorkerQueue(
-    loopId: string,
+  /**
+   * Get message data from in-flight storage.
+   * External consumers use this to retrieve the stored message after popping from worker queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @returns The stored message or null if not found
+   */
+  async getMessageData(
     messageId: string,
     queueId: string
-  ): Promise<void> {
-    // Get message data from in-flight
+  ): Promise<StoredMessage<z.infer<TPayloadSchema>> | null> {
     const shardId = this.masterQueue.getShardForQueue(queueId);
     const inflightDataKey = this.keys.inflightDataKey(shardId);
     const dataJson = await this.redis.hget(inflightDataKey, messageId);
 
     if (!dataJson) {
-      this.logger.error("Message not found in in-flight data", { messageId, queueId });
-      return;
+      return null;
     }
 
-    let storedMessage: StoredMessage<z.infer<TPayloadSchema>>;
     try {
-      storedMessage = JSON.parse(dataJson);
+      return JSON.parse(dataJson) as StoredMessage<z.infer<TPayloadSchema>>;
     } catch {
       this.logger.error("Failed to parse message data", { messageId, queueId });
-      return;
+      return null;
     }
-
-    await this.#processMessage(loopId, storedMessage, queueId);
   }
 
-  // ============================================================================
-  // Private - Direct Consumer Loop (No Worker Queue)
-  // ============================================================================
-
-  async #runDirectConsumerLoop(consumerId: number, shardId: number): Promise<void> {
-    const loopId = `consumer-${consumerId}-shard-${shardId}`;
+  /**
+   * Extend the visibility timeout for a message.
+   * External consumers should call this periodically during long-running processing.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @returns true if heartbeat was successful
+   */
+  async heartbeatMessage(messageId: string, queueId: string): Promise<boolean> {
+    return this.visibilityManager.heartbeat(messageId, queueId, this.heartbeatIntervalMs);
+  }
 
-    try {
-      for await (const _ of setInterval(this.consumerIntervalMs, null, {
-        signal: this.abortController.signal,
-      })) {
-        if (!this.messageHandler) {
-          continue;
-        }
+  /**
+   * Mark a message as successfully processed.
+   * This removes the message from in-flight and releases concurrency.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   */
+  async completeMessage(messageId: string, queueId: string): Promise<void> {
+    const shardId = this.masterQueue.getShardForQueue(queueId);
+    const inflightDataKey = this.keys.inflightDataKey(shardId);
 
-        try {
-          await this.#processDirectIteration(loopId, shardId);
-        } catch (error) {
-          this.logger.error("Direct consumer iteration error", {
-            loopId,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        this.logger.debug("Direct consumer loop aborted", { loopId });
-        return;
+    // Get stored message for concurrency release
+    const dataJson = await this.redis.hget(inflightDataKey, messageId);
+    let storedMessage: StoredMessage<z.infer<TPayloadSchema>> | null = null;
+    if (dataJson) {
+      try {
+        storedMessage = JSON.parse(dataJson);
+      } catch {
+        // Ignore parse error, proceed with completion
       }
-      throw error;
     }
-  }
 
-  async #processDirectIteration(loopId: string, shardId: number): Promise<void> {
-    const masterQueueKey = this.keys.masterQueueKey(shardId);
+    const descriptor: QueueDescriptor = storedMessage
+      ? this.queueDescriptorCache.get(queueId) ?? {
+          id: queueId,
+          tenantId: storedMessage.tenantId,
+          metadata: storedMessage.metadata ?? {},
+        }
+      : { id: queueId, tenantId: this.keys.extractTenantId(queueId), metadata: {} };
 
-    // Create scheduler context
-    const context = this.#createSchedulerContext();
-
-    // Get queues to process from scheduler
-    const tenantQueues = await this.scheduler.selectQueues(masterQueueKey, loopId, context);
+    // Complete in visibility manager
+    await this.visibilityManager.complete(messageId, queueId);
 
-    if (tenantQueues.length === 0) {
-      return;
+    // Release concurrency
+    if (this.concurrencyManager && storedMessage) {
+      await this.concurrencyManager.release(descriptor, messageId);
     }
 
-    // Process messages from each selected tenant
-    // For fairness, process up to available concurrency slots per tenant
-    for (const { tenantId, queues } of tenantQueues) {
-      // Get available concurrency for this tenant
-      let availableSlots = 1; // Default to 1 for backwards compatibility
-      if (this.concurrencyManager) {
-        const [current, limit] = await Promise.all([
-          this.concurrencyManager.getCurrentConcurrency("tenant", tenantId),
-          this.concurrencyManager.getConcurrencyLimit("tenant", tenantId),
-        ]);
-        availableSlots = Math.max(1, limit - current);
-      }
-
-      // Process up to availableSlots messages from this tenant's queues
-      let slotsUsed = 0;
-      queueLoop: for (const queueId of queues) {
-        while (slotsUsed < availableSlots) {
-          // Check cooloff
-          if (this.cooloffEnabled && this.#isInCooloff(queueId)) {
-            break; // Try next queue
-          }
+    // Update both old and new indexes, clean up caches if queue is empty
+    const { queueEmpty } = await this.#updateAllIndexesAfterDequeue(
+      queueId,
+      descriptor.tenantId
+    );
+    if (queueEmpty) {
+      this.queueDescriptorCache.delete(queueId);
+      this.queueCooloffStates.delete(queueId);
+    }
 
-          const processed = await this.#processOneMessage(loopId, queueId, tenantId, shardId);
+    this.telemetry.recordComplete();
 
-          if (processed) {
-            await this.scheduler.recordProcessed?.(tenantId, queueId);
-            this.#resetCooloff(queueId);
-            slotsUsed++;
-          } else {
-            this.#incrementCooloff(queueId);
-            break; // Queue empty or blocked, try next queue
-          }
-        }
-        if (slotsUsed >= availableSlots) {
-          break queueLoop;
-        }
-      }
-    }
+    this.logger.debug("Message completed", {
+      messageId,
+      queueId,
+    });
   }
 
-  async #processOneMessage(
-    loopId: string,
-    queueId: string,
-    tenantId: string,
-    shardId: number
-  ): Promise<boolean> {
+  /**
+   * Release a message back to the queue for processing by another consumer.
+   * The message is placed at the back of the queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   */
+  async releaseMessage(messageId: string, queueId: string): Promise<void> {
+    const shardId = this.masterQueue.getShardForQueue(queueId);
     const queueKey = this.keys.queueKey(queueId);
     const queueItemsKey = this.keys.queueItemsKey(queueId);
-    const masterQueueKey = this.keys.masterQueueKey(shardId);
-    const descriptor = this.queueDescriptorCache.get(queueId) ?? {
-      id: queueId,
-      tenantId,
-      metadata: {},
-    };
+    const inflightDataKey = this.keys.inflightDataKey(shardId);
 
-    // Check concurrency before claiming
-    if (this.concurrencyManager) {
-      const check = await this.concurrencyManager.canProcess(descriptor);
-      if (!check.allowed) {
-        return false;
+    // Get stored message for concurrency release
+    const dataJson = await this.redis.hget(inflightDataKey, messageId);
+    let storedMessage: StoredMessage<z.infer<TPayloadSchema>> | null = null;
+    if (dataJson) {
+      try {
+        storedMessage = JSON.parse(dataJson);
+      } catch {
+        // Ignore parse error
       }
     }
 
-    // Check global rate limit - wait if rate limited
-    if (this.globalRateLimiter) {
-      const result = await this.globalRateLimiter.limit();
-      if (!result.allowed && result.resetAt) {
-        const waitMs = Math.max(0, result.resetAt - Date.now());
-        if (waitMs > 0) {
-          this.logger.debug("Global rate limit reached, waiting", { waitMs, loopId });
-          await new Promise((resolve) => setTimeout(resolve, waitMs));
+    const descriptor: QueueDescriptor = storedMessage
+      ? this.queueDescriptorCache.get(queueId) ?? {
+          id: queueId,
+          tenantId: storedMessage.tenantId,
+          metadata: storedMessage.metadata ?? {},
         }
-      }
-    }
+      : { id: queueId, tenantId: this.keys.extractTenantId(queueId), metadata: {} };
 
-    // Claim message with visibility timeout
-    const claimResult = await this.visibilityManager.claim<StoredMessage<z.infer<TPayloadSchema>>>(
+    // Release back to queue (visibility manager updates dispatch indexes atomically)
+    // Dispatch shard is tenant-based, not queue-based
+    const dispatchShardId = this.tenantDispatch.getShardForTenant(descriptor.tenantId);
+    const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(descriptor.tenantId);
+    const dispatchKey = this.keys.dispatchKey(dispatchShardId);
+    await this.visibilityManager.release(
+      messageId,
       queueId,
       queueKey,
       queueItemsKey,
-      loopId,
-      this.visibilityTimeoutMs
+      tenantQueueIndexKey,
+      dispatchKey,
+      descriptor.tenantId,
+      Date.now() // Put at back of queue
     );
 
-    if (!claimResult.claimed || !claimResult.message) {
-      // Queue is empty, update master queue
-      await this.redis.updateMasterQueueIfEmpty(masterQueueKey, queueKey, queueId);
-      return false;
-    }
-
-    const { message } = claimResult;
-
-    // Reserve concurrency slot
-    if (this.concurrencyManager) {
-      const reserved = await this.concurrencyManager.reserve(descriptor, message.messageId);
-      if (!reserved) {
-        // Release message back to queue
-        await this.visibilityManager.release(message.messageId, queueId, queueKey, queueItemsKey);
-        return false;
-      }
+    // Release concurrency
+    if (this.concurrencyManager && storedMessage) {
+      await this.concurrencyManager.release(descriptor, messageId);
     }
 
-    await this.#processMessage(loopId, message.payload, queueId);
-    return true;
+    this.logger.debug("Message released", {
+      messageId,
+      queueId,
+    });
   }
 
-  // ============================================================================
-  // Private - Message Processing
-  // ============================================================================
-
-  async #processMessage(
-    loopId: string,
-    storedMessage: StoredMessage<z.infer<TPayloadSchema>>,
-    queueId: string
-  ): Promise<void> {
-    const startTime = Date.now();
+  /**
+   * Mark a message as failed. This will trigger retry logic if configured,
+   * or move the message to the dead letter queue.
+   *
+   * @param messageId - The ID of the message
+   * @param queueId - The queue ID the message belongs to
+   * @param error - Optional error that caused the failure
+   */
+  async failMessage(messageId: string, queueId: string, error?: Error): Promise<void> {
+    const shardId = this.masterQueue.getShardForQueue(queueId);
     const queueKey = this.keys.queueKey(queueId);
     const queueItemsKey = this.keys.queueItemsKey(queueId);
-    const shardId = this.masterQueue.getShardForQueue(queueId);
-    const masterQueueKey = this.keys.masterQueueKey(shardId);
-
-    const descriptor = this.queueDescriptorCache.get(queueId) ?? {
-      id: queueId,
-      tenantId: storedMessage.tenantId,
-      metadata: storedMessage.metadata ?? {},
-    };
-
-    // Parse payload with schema if provided
-    let payload: z.infer<TPayloadSchema>;
-    if (this.payloadSchema) {
-      const result = this.payloadSchema.safeParse(storedMessage.payload);
-      if (!result.success) {
-        this.logger.error("Payload validation failed on dequeue", {
-          messageId: storedMessage.id,
-          queueId,
-          error: result.error.message,
-        });
-        // Move to DLQ
-        await this.#moveToDeadLetterQueue(storedMessage, "Payload validation failed");
-
-        // Release reserved concurrency slot
-        if (this.concurrencyManager) {
-          try {
-            await this.concurrencyManager.release(descriptor, storedMessage.id);
-          } catch (releaseError) {
-            this.logger.error("Failed to release concurrency slot after payload validation failure", {
-              messageId: storedMessage.id,
-              queueId,
-              error: releaseError instanceof Error ? releaseError.message : String(releaseError),
-            });
-          }
-        }
+    const inflightDataKey = this.keys.inflightDataKey(shardId);
 
-        return;
-      }
-      payload = result.data;
-    } else {
-      payload = storedMessage.payload;
+    // Get stored message
+    const dataJson = await this.redis.hget(inflightDataKey, messageId);
+    if (!dataJson) {
+      this.logger.error("Cannot fail message: not found in in-flight data", { messageId, queueId });
+      return;
     }
 
-    // Build queue message
-    const queueMessage: QueueMessage<z.infer<TPayloadSchema>> = {
-      id: storedMessage.id,
-      queueId,
-      payload,
-      timestamp: storedMessage.timestamp,
-      attempt: storedMessage.attempt,
-      metadata: storedMessage.metadata,
-    };
-
-    // Record queue time
-    const queueTime = startTime - storedMessage.timestamp;
-    this.telemetry.recordQueueTime(
-      queueTime,
-      this.telemetry.messageAttributes({
-        queueId,
-        tenantId: storedMessage.tenantId,
-        messageId: storedMessage.id,
-      })
-    );
-
-    // Build handler context
-    const handlerContext: MessageHandlerContext<z.infer<TPayloadSchema>> = {
-      message: queueMessage,
-      queue: descriptor,
-      consumerId: loopId,
-      heartbeat: async () => {
-        return this.visibilityManager.heartbeat(
-          storedMessage.id,
-          queueId,
-          this.heartbeatIntervalMs
-        );
-      },
-      complete: async () => {
-        await this.#completeMessage(storedMessage, queueId, queueKey, masterQueueKey, descriptor);
-        this.telemetry.recordComplete(
-          this.telemetry.messageAttributes({
-            queueId,
-            tenantId: storedMessage.tenantId,
-            messageId: storedMessage.id,
-          })
-        );
-        this.telemetry.recordProcessingTime(
-          Date.now() - startTime,
-          this.telemetry.messageAttributes({
-            queueId,
-            tenantId: storedMessage.tenantId,
-            messageId: storedMessage.id,
-          })
-        );
-      },
-      release: async () => {
-        await this.#releaseMessage(storedMessage, queueId, queueKey, queueItemsKey, descriptor);
-      },
-      fail: async (error?: Error) => {
-        await this.#handleMessageFailure(
-          storedMessage,
-          queueId,
-          queueKey,
-          queueItemsKey,
-          masterQueueKey,
-          descriptor,
-          error
-        );
-      },
-    };
-
-    // Call message handler
+    let storedMessage: StoredMessage<z.infer<TPayloadSchema>>;
     try {
-      await this.telemetry.trace(
-        "processMessage",
-        async (span) => {
-          span.setAttributes({
-            [FairQueueAttributes.QUEUE_ID]: queueId,
-            [FairQueueAttributes.TENANT_ID]: storedMessage.tenantId,
-            [FairQueueAttributes.MESSAGE_ID]: storedMessage.id,
-            [FairQueueAttributes.ATTEMPT]: storedMessage.attempt,
-            [FairQueueAttributes.CONSUMER_ID]: loopId,
-          });
-
-          await this.messageHandler!(handlerContext);
-        },
-        {
-          kind: SpanKind.CONSUMER,
-          attributes: {
-            [MessagingAttributes.OPERATION]: "process",
-          },
-        }
-      );
-    } catch (error) {
-      this.logger.error("Message handler error", {
-        messageId: storedMessage.id,
+      storedMessage = JSON.parse(dataJson);
+    } catch {
+      this.logger.error("Cannot fail message: failed to parse stored message", {
+        messageId,
         queueId,
-        error: error instanceof Error ? error.message : String(error),
       });
-      // Trigger failure handling
-      await handlerContext.fail(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  async #completeMessage(
-    storedMessage: StoredMessage<z.infer<TPayloadSchema>>,
-    queueId: string,
-    queueKey: string,
-    masterQueueKey: string,
-    descriptor: QueueDescriptor
-  ): Promise<void> {
-    const shardId = this.masterQueue.getShardForQueue(queueId);
-
-    // Complete in visibility manager
-    await this.visibilityManager.complete(storedMessage.id, queueId);
-
-    // Release concurrency
-    if (this.concurrencyManager) {
-      await this.concurrencyManager.release(descriptor, storedMessage.id);
+      return;
     }
 
-    // Update master queue if queue is now empty
-    await this.redis.updateMasterQueueIfEmpty(masterQueueKey, queueKey, queueId);
-
-    this.logger.debug("Message completed", {
-      messageId: storedMessage.id,
-      queueId,
-    });
-  }
+    const descriptor = this.queueDescriptorCache.get(queueId) ?? {
+      id: queueId,
+      tenantId: storedMessage.tenantId,
+      metadata: storedMessage.metadata ?? {},
+    };
 
-  async #releaseMessage(
-    storedMessage: StoredMessage<z.infer<TPayloadSchema>>,
-    queueId: string,
-    queueKey: string,
-    queueItemsKey: string,
-    descriptor: QueueDescriptor
-  ): Promise<void> {
-    // Release back to queue
-    await this.visibilityManager.release(
-      storedMessage.id,
+    const dispatchShardId = this.tenantDispatch.getShardForTenant(descriptor.tenantId);
+    await this.#handleMessageFailure(
+      storedMessage,
       queueId,
       queueKey,
       queueItemsKey,
-      Date.now() // Put at back of queue
+      dispatchShardId,
+      descriptor,
+      error
     );
-
-    // Release concurrency
-    if (this.concurrencyManager) {
-      await this.concurrencyManager.release(descriptor, storedMessage.id);
-    }
-
-    this.logger.debug("Message released", {
-      messageId: storedMessage.id,
-      queueId,
-    });
   }
 
+  // ============================================================================
+  // Private - Message Processing Helpers
+  // ============================================================================
+
   async #handleMessageFailure(
     storedMessage: StoredMessage<z.infer<TPayloadSchema>>,
     queueId: string,
     queueKey: string,
     queueItemsKey: string,
-    masterQueueKey: string,
+    dispatchShardId: number,
     descriptor: QueueDescriptor,
     error?: Error
   ): Promise<void> {
-    this.telemetry.recordFailure(
-      this.telemetry.messageAttributes({
-        queueId,
-        tenantId: storedMessage.tenantId,
-        messageId: storedMessage.id,
-        attempt: storedMessage.attempt,
-      })
-    );
+    this.telemetry.recordFailure();
 
     // Check retry strategy
     if (this.retryStrategy) {
@@ -1302,31 +1416,28 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
           attempt: storedMessage.attempt + 1,
         };
 
-        // Release with delay
+        // Release with delay, passing the updated message data so the Lua script
+        // atomically writes the incremented attempt count when re-queuing.
+        const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(descriptor.tenantId);
+        const dispatchKey = this.keys.dispatchKey(dispatchShardId);
         await this.visibilityManager.release(
           storedMessage.id,
           queueId,
           queueKey,
           queueItemsKey,
-          Date.now() + nextDelay
+          tenantQueueIndexKey,
+          dispatchKey,
+          descriptor.tenantId,
+          Date.now() + nextDelay,
+          JSON.stringify(updatedMessage)
         );
 
-        // Update message in items hash with new attempt count
-        await this.redis.hset(queueItemsKey, storedMessage.id, JSON.stringify(updatedMessage));
-
         // Release concurrency
         if (this.concurrencyManager) {
           await this.concurrencyManager.release(descriptor, storedMessage.id);
         }
 
-        this.telemetry.recordRetry(
-          this.telemetry.messageAttributes({
-            queueId,
-            tenantId: storedMessage.tenantId,
-            messageId: storedMessage.id,
-            attempt: storedMessage.attempt + 1,
-          })
-        );
+        this.telemetry.recordRetry();
 
         this.logger.debug("Message scheduled for retry", {
           messageId: storedMessage.id,
@@ -1382,14 +1493,7 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     pipeline.hset(dlqDataKey, storedMessage.id, JSON.stringify(dlqMessage));
     await pipeline.exec();
 
-    this.telemetry.recordDLQ(
-      this.telemetry.messageAttributes({
-        queueId: storedMessage.queueId,
-        tenantId: storedMessage.tenantId,
-        messageId: storedMessage.id,
-        attempt: storedMessage.attempt,
-      })
-    );
+    this.telemetry.recordDLQ();
 
     this.logger.info("Message moved to DLQ", {
       messageId: storedMessage.id,
@@ -1418,7 +1522,7 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
         }
       }
     } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
+      if (isAbortError(error)) {
         this.logger.debug("Reclaim loop aborted");
         return;
       }
@@ -1430,12 +1534,47 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
     let totalReclaimed = 0;
 
     for (let shardId = 0; shardId < this.shardCount; shardId++) {
-      const reclaimed = await this.visibilityManager.reclaimTimedOut(shardId, (queueId) => ({
-        queueKey: this.keys.queueKey(queueId),
-        queueItemsKey: this.keys.queueItemsKey(queueId),
-      }));
+      const reclaimedMessages = await this.visibilityManager.reclaimTimedOut(shardId, (queueId) => {
+        const tenantId = this.keys.extractTenantId(queueId);
+        const dispatchShardId = this.tenantDispatch.getShardForTenant(tenantId);
+        return {
+          queueKey: this.keys.queueKey(queueId),
+          queueItemsKey: this.keys.queueItemsKey(queueId),
+          tenantQueueIndexKey: this.keys.tenantQueueIndexKey(tenantId),
+          dispatchKey: this.keys.dispatchKey(dispatchShardId),
+          tenantId,
+        };
+      });
+
+      if (reclaimedMessages.length > 0) {
+        // Release concurrency for all reclaimed messages in a single batch
+        // This is critical: when a message times out, its concurrency slot must be freed
+        // so the message can be processed again when it's re-claimed from the queue
+        if (this.concurrencyManager) {
+          try {
+            await this.concurrencyManager.releaseBatch(
+              reclaimedMessages.map((msg) => ({
+                queue: {
+                  id: msg.queueId,
+                  tenantId: msg.tenantId,
+                  metadata: msg.metadata ?? {},
+                },
+                messageId: msg.messageId,
+              }))
+            );
+          } catch (error) {
+            this.logger.error("Failed to release concurrency for reclaimed messages", {
+              count: reclaimedMessages.length,
+              error: error instanceof Error ? error.message : String(error),
+            });
+          }
+        }
 
-      totalReclaimed += reclaimed;
+        // Dispatch indexes are updated atomically by the releaseMessage Lua script
+        // inside reclaimTimedOut, so no separate index update needed here.
+      }
+
+      totalReclaimed += reclaimedMessages.length;
     }
 
     if (totalReclaimed > 0) {
@@ -1463,6 +1602,15 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   }
 
   #incrementCooloff(queueId: string): void {
+    // Safety check: if the cache is too large, just clear it
+    if (this.queueCooloffStates.size >= this.maxCooloffStatesSize) {
+      this.logger.warn("Cooloff states cache hit size cap, clearing all entries", {
+        size: this.queueCooloffStates.size,
+        cap: this.maxCooloffStatesSize,
+      });
+      this.queueCooloffStates.clear();
+    }
+
     const state = this.queueCooloffStates.get(queueId) ?? {
       tag: "normal" as const,
       consecutiveFailures: 0,
@@ -1497,6 +1645,41 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   // Private - Helpers
   // ============================================================================
 
+  /**
+   * Update both old master queue and new dispatch indexes after a dequeue/complete.
+   * Both calls are idempotent - ZREM on a non-existent member is a no-op.
+   * This handles the transition period where queues may exist in either or both indexes.
+   */
+  async #updateAllIndexesAfterDequeue(
+    queueId: string,
+    tenantId: string
+  ): Promise<{ queueEmpty: boolean }> {
+    const queueShardId = this.masterQueue.getShardForQueue(queueId);
+    const dispatchShardId = this.tenantDispatch.getShardForTenant(tenantId);
+    const queueKey = this.keys.queueKey(queueId);
+    const masterQueueKey = this.keys.masterQueueKey(queueShardId);
+    const tenantQueueIndexKey = this.keys.tenantQueueIndexKey(tenantId);
+    const dispatchKey = this.keys.dispatchKey(dispatchShardId);
+
+    // Update legacy master queue (drain path, no-op if queue not there)
+    const removedFromMaster = await this.redis.updateMasterQueueIfEmpty(
+      masterQueueKey,
+      queueKey,
+      queueId
+    );
+
+    // Update new dispatch indexes
+    const removedFromDispatch = await this.redis.updateDispatchIndexes(
+      queueKey,
+      tenantQueueIndexKey,
+      dispatchKey,
+      queueId,
+      tenantId
+    );
+
+    return { queueEmpty: removedFromMaster === 1 || removedFromDispatch === 1 };
+  }
+
   #createSchedulerContext(): SchedulerContext {
     return {
       getCurrentConcurrency: async (groupName, groupId) => {
@@ -1528,7 +1711,9 @@ export class FairQueue<TPayloadSchema extends z.ZodTypeAny = z.ZodUnknown> {
   // ============================================================================
 
   #registerCommands(): void {
-    // Atomic single message enqueue with master queue update
+    // ---- Legacy Lua scripts (kept for drain of old master queue) ----
+
+    // Atomic single message enqueue with master queue update (legacy, used for drain only)
     this.redis.defineCommand("enqueueMessageAtomic", {
       numberOfKeys: 3,
       lua: `
@@ -1541,13 +1726,9 @@ local messageId = ARGV[2]
 local timestamp = tonumber(ARGV[3])
 local payload = ARGV[4]
 
--- Add to sorted set (score = timestamp)
 redis.call('ZADD', queueKey, timestamp, messageId)
-
--- Store payload in hash
 redis.call('HSET', queueItemsKey, messageId, payload)
 
--- Update master queue with oldest message timestamp
 local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
 if #oldest >= 2 then
   redis.call('ZADD', masterQueueKey, oldest[2], queueId)
@@ -1557,7 +1738,7 @@ return 1
       `,
     });
 
-    // Atomic batch message enqueue with master queue update
+    // Atomic batch message enqueue with master queue update (legacy, used for drain only)
     this.redis.defineCommand("enqueueBatchAtomic", {
       numberOfKeys: 3,
       lua: `
@@ -1567,20 +1748,14 @@ local masterQueueKey = KEYS[3]
 
 local queueId = ARGV[1]
 
--- Args after queueId are triples: [messageId, timestamp, payload, ...]
 for i = 2, #ARGV, 3 do
   local messageId = ARGV[i]
   local timestamp = tonumber(ARGV[i + 1])
   local payload = ARGV[i + 2]
-  
-  -- Add to sorted set
   redis.call('ZADD', queueKey, timestamp, messageId)
-  
-  -- Store payload in hash
   redis.call('HSET', queueItemsKey, messageId, payload)
 end
 
--- Update master queue with oldest message timestamp
 local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
 if #oldest >= 2 then
   redis.call('ZADD', masterQueueKey, oldest[2], queueId)
@@ -1590,7 +1765,7 @@ return (#ARGV - 1) / 3
       `,
     });
 
-    // Update master queue if queue is empty
+    // Remove queue from legacy master queue if empty (drain-only, never re-adds)
     this.redis.defineCommand("updateMasterQueueIfEmpty", {
       numberOfKeys: 2,
       lua: `
@@ -1602,11 +1777,128 @@ local count = redis.call('ZCARD', queueKey)
 if count == 0 then
   redis.call('ZREM', masterQueueKey, queueId)
   return 1
+end
+
+-- Queue still has messages but don't re-add to legacy master queue.
+-- New enqueues go through the V2 dispatch path, so we only drain here.
+-- Just remove it so it doesn't linger.
+redis.call('ZREM', masterQueueKey, queueId)
+return 0
+      `,
+    });
+
+    // ---- New V2 Lua scripts (two-level tenant dispatch) ----
+
+    // Atomic single message enqueue with tenant dispatch index update
+    this.redis.defineCommand("enqueueMessageAtomicV2", {
+      numberOfKeys: 4,
+      lua: `
+local queueKey = KEYS[1]
+local queueItemsKey = KEYS[2]
+local tenantQueueIndexKey = KEYS[3]
+local dispatchKey = KEYS[4]
+
+local queueId = ARGV[1]
+local messageId = ARGV[2]
+local timestamp = tonumber(ARGV[3])
+local payload = ARGV[4]
+local tenantId = ARGV[5]
+
+-- Add to per-queue storage (same as before)
+redis.call('ZADD', queueKey, timestamp, messageId)
+redis.call('HSET', queueItemsKey, messageId, payload)
+
+-- Update tenant queue index (Level 2) with queue's oldest message
+local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+if #oldest >= 2 then
+  redis.call('ZADD', tenantQueueIndexKey, oldest[2], queueId)
+end
+
+-- Update dispatch index (Level 1) with tenant's oldest across all queues
+local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+if #tenantOldest >= 2 then
+  redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
+end
+
+return 1
+      `,
+    });
+
+    // Atomic batch message enqueue with tenant dispatch index update
+    this.redis.defineCommand("enqueueBatchAtomicV2", {
+      numberOfKeys: 4,
+      lua: `
+local queueKey = KEYS[1]
+local queueItemsKey = KEYS[2]
+local tenantQueueIndexKey = KEYS[3]
+local dispatchKey = KEYS[4]
+
+local queueId = ARGV[1]
+local tenantId = ARGV[2]
+
+-- Args after queueId and tenantId are triples: [messageId, timestamp, payload, ...]
+for i = 3, #ARGV, 3 do
+  local messageId = ARGV[i]
+  local timestamp = tonumber(ARGV[i + 1])
+  local payload = ARGV[i + 2]
+  redis.call('ZADD', queueKey, timestamp, messageId)
+  redis.call('HSET', queueItemsKey, messageId, payload)
+end
+
+-- Update tenant queue index (Level 2)
+local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+if #oldest >= 2 then
+  redis.call('ZADD', tenantQueueIndexKey, oldest[2], queueId)
+end
+
+-- Update dispatch index (Level 1)
+local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+if #tenantOldest >= 2 then
+  redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
+end
+
+return (#ARGV - 2) / 3
+      `,
+    });
+
+    // Update tenant dispatch indexes after dequeue/complete
+    // Handles both queue-empty (remove from indexes) and queue-has-messages (update scores)
+    this.redis.defineCommand("updateDispatchIndexes", {
+      numberOfKeys: 3,
+      lua: `
+local queueKey = KEYS[1]
+local tenantQueueIndexKey = KEYS[2]
+local dispatchKey = KEYS[3]
+local queueId = ARGV[1]
+local tenantId = ARGV[2]
+
+local count = redis.call('ZCARD', queueKey)
+if count == 0 then
+  -- Queue is empty: remove from tenant queue index
+  redis.call('ZREM', tenantQueueIndexKey, queueId)
+
+  -- Check if tenant has any queues left
+  local tenantQueueCount = redis.call('ZCARD', tenantQueueIndexKey)
+  if tenantQueueCount == 0 then
+    -- No more queues: remove tenant from dispatch
+    redis.call('ZREM', dispatchKey, tenantId)
+  else
+    -- Update dispatch score to tenant's new oldest
+    local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+    if #tenantOldest >= 2 then
+      redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
+    end
+  end
+  return 1
 else
-  -- Update with oldest message timestamp
+  -- Queue still has messages: update scores
   local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
   if #oldest >= 2 then
-    redis.call('ZADD', masterQueueKey, oldest[2], queueId)
+    redis.call('ZADD', tenantQueueIndexKey, oldest[2], queueId)
+  end
+  local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+  if #tenantOldest >= 2 then
+    redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
   end
   return 0
 end
@@ -1623,6 +1915,7 @@ end
 // Extend Redis interface for custom commands
 declare module "@internal/redis" {
   interface RedisCommander<Context> {
+    // Legacy commands (kept for drain of old master queue)
     enqueueMessageAtomic(
       queueKey: string,
       queueItemsKey: string,
@@ -1646,5 +1939,36 @@ declare module "@internal/redis" {
       queueKey: string,
       queueId: string
     ): Promise<number>;
+
+    // V2 commands (two-level tenant dispatch)
+    enqueueMessageAtomicV2(
+      queueKey: string,
+      queueItemsKey: string,
+      tenantQueueIndexKey: string,
+      dispatchKey: string,
+      queueId: string,
+      messageId: string,
+      timestamp: string,
+      payload: string,
+      tenantId: string
+    ): Promise<number>;
+
+    enqueueBatchAtomicV2(
+      queueKey: string,
+      queueItemsKey: string,
+      tenantQueueIndexKey: string,
+      dispatchKey: string,
+      queueId: string,
+      tenantId: string,
+      ...args: string[]
+    ): Promise<number>;
+
+    updateDispatchIndexes(
+      queueKey: string,
+      tenantQueueIndexKey: string,
+      dispatchKey: string,
+      queueId: string,
+      tenantId: string
+    ): Promise<number>;
   }
 }
diff --git a/packages/redis-worker/src/fair-queue/keyProducer.ts b/packages/redis-worker/src/fair-queue/keyProducer.ts
index f63cdbed03e..1e1b2b42631 100644
--- a/packages/redis-worker/src/fair-queue/keyProducer.ts
+++ b/packages/redis-worker/src/fair-queue/keyProducer.ts
@@ -5,7 +5,9 @@ import type { FairQueueKeyProducer } from "./types.js";
  * Uses a configurable prefix and standard key structure.
  *
  * Key structure:
- * - Master queue: {prefix}:master:{shardId}
+ * - Master queue: {prefix}:master:{shardId} (legacy, drain-only)
+ * - Dispatch index: {prefix}:dispatch:{shardId} (Level 1: tenantIds)
+ * - Tenant queue index: {prefix}:tenantq:{tenantId} (Level 2: queueIds)
  * - Queue: {prefix}:queue:{queueId}
  * - Queue items: {prefix}:queue:{queueId}:items
  * - Concurrency: {prefix}:concurrency:{groupName}:{groupId}
@@ -70,6 +72,18 @@ export class DefaultFairQueueKeyProducer implements FairQueueKeyProducer {
     return this.#buildKey("worker", consumerId);
   }
 
+  // ============================================================================
+  // Tenant Dispatch Keys (Two-Level Index)
+  // ============================================================================
+
+  dispatchKey(shardId: number): string {
+    return this.#buildKey("dispatch", shardId.toString());
+  }
+
+  tenantQueueIndexKey(tenantId: string): string {
+    return this.#buildKey("tenantq", tenantId);
+  }
+
   // ============================================================================
   // Dead Letter Queue Keys
   // ============================================================================
diff --git a/packages/redis-worker/src/fair-queue/scheduler.ts b/packages/redis-worker/src/fair-queue/scheduler.ts
index 8acc641e3e2..00a22bb97a8 100644
--- a/packages/redis-worker/src/fair-queue/scheduler.ts
+++ b/packages/redis-worker/src/fair-queue/scheduler.ts
@@ -28,6 +28,15 @@ export abstract class BaseScheduler implements FairScheduler {
     // Default: no state tracking
   }
 
+  /**
+   * Called after processing multiple messages to update scheduler state.
+   * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
+   * Default implementation does nothing.
+   */
+  async recordProcessedBatch(_tenantId: string, _queueId: string, _count: number): Promise<void> {
+    // Default: no state tracking
+  }
+
   /**
    * Initialize the scheduler.
    * Default implementation does nothing.
diff --git a/packages/redis-worker/src/fair-queue/schedulers/drr.ts b/packages/redis-worker/src/fair-queue/schedulers/drr.ts
index fbb7f704a40..3e05ae8a34f 100644
--- a/packages/redis-worker/src/fair-queue/schedulers/drr.ts
+++ b/packages/redis-worker/src/fair-queue/schedulers/drr.ts
@@ -2,6 +2,7 @@ import { createRedisClient, type Redis, type RedisOptions } from "@internal/redi
 import { BaseScheduler } from "../scheduler.js";
 import type {
   DRRSchedulerConfig,
+  DispatchSchedulerContext,
   FairQueueKeyProducer,
   SchedulerContext,
   TenantQueues,
@@ -27,6 +28,7 @@ export class DRRScheduler extends BaseScheduler {
   private keys: FairQueueKeyProducer;
   private quantum: number;
   private maxDeficit: number;
+  private masterQueueLimit: number;
   private logger: NonNullable<DRRSchedulerConfig["logger"]>;
 
   constructor(private config: DRRSchedulerConfig) {
@@ -35,6 +37,7 @@ export class DRRScheduler extends BaseScheduler {
     this.keys = config.keys;
     this.quantum = config.quantum;
     this.maxDeficit = config.maxDeficit;
+    this.masterQueueLimit = config.masterQueueLimit ?? 1000;
     this.logger = config.logger ?? {
       debug: () => {},
       error: () => {},
@@ -130,6 +133,70 @@ export class DRRScheduler extends BaseScheduler {
     }));
   }
 
+  /**
+   * Select queues using the two-level tenant dispatch index.
+   *
+   * Algorithm:
+   * 1. ZRANGEBYSCORE on dispatch index (gets only tenants with queues - much smaller)
+   * 2. Add quantum to each tenant's deficit (atomically)
+   * 3. Check capacity as safety net (dispatch should only have tenants with capacity)
+   * 4. Select tenants with deficit >= 1, sorted by deficit (highest first)
+   * 5. For each tenant, fetch their queues from Level 2 index
+   */
+  async selectQueuesFromDispatch(
+    dispatchShardKey: string,
+    consumerId: string,
+    context: DispatchSchedulerContext
+  ): Promise<TenantQueues[]> {
+    // Level 1: Get tenants from dispatch index
+    const tenants = await this.#getTenantsFromDispatch(dispatchShardKey);
+
+    if (tenants.length === 0) {
+      return [];
+    }
+
+    const tenantIds = tenants.map((t) => t.tenantId);
+
+    // Add quantum to all active tenants atomically (1 Lua call)
+    const deficits = await this.#addQuantumToTenants(tenantIds);
+
+    // Build candidates sorted by deficit (highest first)
+    const candidates = tenantIds
+      .map((tenantId, index) => ({ tenantId, deficit: deficits[index] ?? 0 }))
+      .filter((t) => t.deficit >= 1);
+
+    candidates.sort((a, b) => b.deficit - a.deficit);
+
+    // Pick the first tenant with available capacity and fetch their queues.
+    // This keeps the scheduler cheap: O(1) in the common case where the
+    // highest-deficit tenant has capacity. The consumer loop iterates fast
+    // (1ms yield between rounds) so we cycle through tenants quickly.
+    for (const { tenantId, deficit } of candidates) {
+      const isAtCapacity = await context.isAtCapacity("tenant", tenantId);
+      if (isAtCapacity) continue;
+
+      // Limit queues fetched to what the tenant can actually process this round.
+      // deficit = max messages this tenant should process, so no point fetching
+      // more queues than that (each queue yields at least 1 message).
+      const queueLimit = Math.ceil(deficit);
+      const queues = await context.getQueuesForTenant(tenantId, queueLimit);
+      if (queues.length > 0) {
+        this.logger.debug("DRR dispatch: selected tenant", {
+          dispatchTenants: tenants.length,
+          candidates: candidates.length,
+          selectedTenant: tenantId,
+          deficit,
+          queueLimit,
+          queuesReturned: queues.length,
+        });
+
+        return [{ tenantId, queues: queues.map((q) => q.queueId) }];
+      }
+    }
+
+    return [];
+  }
+
   /**
    * Record that a message was processed from a tenant.
    * Decrements the tenant's deficit.
@@ -138,6 +205,18 @@ export class DRRScheduler extends BaseScheduler {
     await this.#decrementDeficit(tenantId);
   }
 
+  /**
+   * Record that multiple messages were processed from a tenant.
+   * Decrements the tenant's deficit by count atomically.
+   */
+  override async recordProcessedBatch(
+    tenantId: string,
+    _queueId: string,
+    count: number
+  ): Promise<void> {
+    await this.#decrementDeficitBatch(tenantId, count);
+  }
+
   override async close(): Promise<void> {
     await this.redis.quit();
   }
@@ -186,6 +265,35 @@ export class DRRScheduler extends BaseScheduler {
     return `${this.keys.masterQueueKey(0).split(":")[0]}:drr:deficit`;
   }
 
+  async #getTenantsFromDispatch(
+    dispatchKey: string
+  ): Promise<Array<{ tenantId: string; score: number }>> {
+    const now = Date.now();
+    const results = await this.redis.zrangebyscore(
+      dispatchKey,
+      "-inf",
+      now,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      this.masterQueueLimit
+    );
+
+    const tenants: Array<{ tenantId: string; score: number }> = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const tenantId = results[i];
+      const scoreStr = results[i + 1];
+      if (tenantId && scoreStr) {
+        tenants.push({
+          tenantId,
+          score: parseFloat(scoreStr),
+        });
+      }
+    }
+
+    return tenants;
+  }
+
   async #getQueuesFromShard(shardKey: string): Promise<QueueWithScore[]> {
     const now = Date.now();
     const results = await this.redis.zrangebyscore(
@@ -195,7 +303,7 @@ export class DRRScheduler extends BaseScheduler {
       "WITHSCORES",
       "LIMIT",
       0,
-      1000 // Limit for performance
+      this.masterQueueLimit
     );
 
     const queues: QueueWithScore[] = [];
@@ -247,6 +355,17 @@ export class DRRScheduler extends BaseScheduler {
     return parseFloat(result);
   }
 
+  /**
+   * Decrement deficit for a tenant by a count atomically.
+   */
+  async #decrementDeficitBatch(tenantId: string, count: number): Promise<number> {
+    const key = this.#deficitKey();
+
+    // Use Lua script to decrement by count and ensure non-negative
+    const result = await this.redis.drrDecrementDeficitBatch(key, tenantId, count.toString());
+    return parseFloat(result);
+  }
+
   #registerCommands(): void {
     // Atomic quantum addition with capping for multiple tenants
     this.redis.defineCommand("drrAddQuantum", {
@@ -293,6 +412,27 @@ if newDeficit < 0 then
   newDeficit = 0
 end
 
+return tostring(newDeficit)
+      `,
+    });
+
+    // Atomic deficit decrement by count with floor at 0
+    this.redis.defineCommand("drrDecrementDeficitBatch", {
+      numberOfKeys: 1,
+      lua: `
+local deficitKey = KEYS[1]
+local tenantId = ARGV[1]
+local count = tonumber(ARGV[2])
+
+local newDeficit = redis.call('HINCRBYFLOAT', deficitKey, tenantId, -count)
+newDeficit = tonumber(newDeficit)
+
+-- Floor at 0
+if newDeficit < 0 then
+  redis.call('HSET', deficitKey, tenantId, 0)
+  newDeficit = 0
+end
+
 return tostring(newDeficit)
       `,
     });
@@ -310,6 +450,12 @@ declare module "@internal/redis" {
     ): Promise<string[]>;
 
     drrDecrementDeficit(deficitKey: string, tenantId: string): Promise<string>;
+
+    drrDecrementDeficitBatch(
+      deficitKey: string,
+      tenantId: string,
+      count: string
+    ): Promise<string>;
   }
 }
 
diff --git a/packages/redis-worker/src/fair-queue/telemetry.ts b/packages/redis-worker/src/fair-queue/telemetry.ts
index abf4f78a0e3..e9531fc812a 100644
--- a/packages/redis-worker/src/fair-queue/telemetry.ts
+++ b/packages/redis-worker/src/fair-queue/telemetry.ts
@@ -8,7 +8,9 @@ import type {
   SpanKind,
   SpanOptions,
   Tracer,
+  Context,
 } from "@internal/tracing";
+import { context, trace, SpanStatusCode, ROOT_CONTEXT } from "@internal/tracing";
 
 /**
  * Semantic attributes for fair queue messaging operations.
@@ -54,6 +56,7 @@ export interface FairQueueMetrics {
   // Observable gauges (registered with callbacks)
   queueLength: ObservableGauge;
   masterQueueLength: ObservableGauge;
+  dispatchLength: ObservableGauge;
   inflightCount: ObservableGauge;
   dlqLength: ObservableGauge;
 }
@@ -248,6 +251,7 @@ export class FairQueueTelemetry {
   registerGaugeCallbacks(callbacks: {
     getQueueLength?: (queueId: string) => Promise<number>;
     getMasterQueueLength?: (shardId: number) => Promise<number>;
+    getDispatchLength?: (shardId: number) => Promise<number>;
     getInflightCount?: (shardId: number) => Promise<number>;
     getDLQLength?: (tenantId: string) => Promise<number>;
     shardCount?: number;
@@ -271,7 +275,7 @@ export class FairQueueTelemetry {
       });
     }
 
-    // Master queue length gauge
+    // Legacy master queue length gauge (draining, should trend to 0)
     if (callbacks.getMasterQueueLength && callbacks.shardCount) {
       const getMasterQueueLength = callbacks.getMasterQueueLength;
       const shardCount = callbacks.shardCount;
@@ -286,6 +290,21 @@ export class FairQueueTelemetry {
       });
     }
 
+    // Dispatch index length gauge (new two-level dispatch, tenant count per shard)
+    if (callbacks.getDispatchLength && callbacks.shardCount) {
+      const getDispatchLength = callbacks.getDispatchLength;
+      const shardCount = callbacks.shardCount;
+
+      this.metrics.dispatchLength.addCallback(async (observableResult) => {
+        for (let shardId = 0; shardId < shardCount; shardId++) {
+          const length = await getDispatchLength(shardId);
+          observableResult.observe(length, {
+            [FairQueueAttributes.SHARD_ID]: shardId.toString(),
+          });
+        }
+      });
+    }
+
     // Inflight count gauge
     if (callbacks.getInflightCount && callbacks.shardCount) {
       const getInflightCount = callbacks.getInflightCount;
@@ -315,6 +334,7 @@ export class FairQueueTelemetry {
         }
       });
     }
+
   }
 
   // ============================================================================
@@ -322,7 +342,8 @@ export class FairQueueTelemetry {
   // ============================================================================
 
   /**
-   * Create standard attributes for a message operation.
+   * Create standard attributes for a message operation (for spans/traces).
+   * Use this for span attributes where high cardinality is acceptable.
    */
   messageAttributes(params: {
     queueId?: string;
@@ -411,9 +432,13 @@ export class FairQueueTelemetry {
         unit: "messages",
       }),
       masterQueueLength: this.meter.createObservableGauge(`${this.name}.master_queue.length`, {
-        description: "Number of queues in master queue shard",
+        description: "Number of queues in legacy master queue shard (draining)",
         unit: "queues",
       }),
+      dispatchLength: this.meter.createObservableGauge(`${this.name}.dispatch.length`, {
+        description: "Number of tenants in dispatch index shard",
+        unit: "tenants",
+      }),
       inflightCount: this.meter.createObservableGauge(`${this.name}.inflight.count`, {
         description: "Number of messages currently being processed",
         unit: "messages",
@@ -426,6 +451,294 @@ export class FairQueueTelemetry {
   }
 }
 
+// ============================================================================
+// Batched Span Manager
+// ============================================================================
+
+/**
+ * State for tracking a consumer loop's batched span.
+ */
+export interface ConsumerLoopState {
+  /** Countdown of iterations before starting a new span */
+  perTraceCountdown: number;
+  /** When the current trace started */
+  traceStartedAt: Date;
+  /** The current batched span */
+  currentSpan?: Span;
+  /** The context for the current batched span */
+  currentSpanContext?: Context;
+  /** Number of iterations in the current span */
+  iterationsCount: number;
+  /** Total iterations across all spans */
+  totalIterationsCount: number;
+  /** Running duration in milliseconds for the current span */
+  runningDurationInMs: number;
+  /** Stats counters for the current span */
+  stats: Record<string, number>;
+  /** Flag to force span end on next iteration */
+  endSpanInNextIteration: boolean;
+}
+
+/**
+ * Configuration for the BatchedSpanManager.
+ */
+export interface BatchedSpanManagerOptions {
+  /** The tracer to use for creating spans */
+  tracer?: Tracer;
+  /** Name prefix for spans */
+  name: string;
+  /** Maximum iterations before rotating the span */
+  maxIterations: number;
+  /** Maximum seconds before rotating the span */
+  timeoutSeconds: number;
+  /** Optional callback to get dynamic attributes when starting a new batched span */
+  getDynamicAttributes?: () => Attributes;
+}
+
+/**
+ * Manages batched spans for consumer loops.
+ *
+ * This allows multiple iterations to be grouped into a single parent span,
+ * reducing the volume of spans while maintaining observability.
+ */
+export class BatchedSpanManager {
+  private tracer?: Tracer;
+  private name: string;
+  private maxIterations: number;
+  private timeoutSeconds: number;
+  private loopStates = new Map<string, ConsumerLoopState>();
+  private getDynamicAttributes?: () => Attributes;
+
+  constructor(options: BatchedSpanManagerOptions) {
+    this.tracer = options.tracer;
+    this.name = options.name;
+    this.maxIterations = options.maxIterations;
+    this.timeoutSeconds = options.timeoutSeconds;
+    this.getDynamicAttributes = options.getDynamicAttributes;
+  }
+
+  /**
+   * Initialize state for a consumer loop.
+   */
+  initializeLoop(loopId: string): void {
+    this.loopStates.set(loopId, {
+      perTraceCountdown: this.maxIterations,
+      traceStartedAt: new Date(),
+      iterationsCount: 0,
+      totalIterationsCount: 0,
+      runningDurationInMs: 0,
+      stats: {},
+      endSpanInNextIteration: false,
+    });
+  }
+
+  /**
+   * Get the state for a consumer loop.
+   */
+  getState(loopId: string): ConsumerLoopState | undefined {
+    return this.loopStates.get(loopId);
+  }
+
+  /**
+   * Increment a stat counter for a loop.
+   */
+  incrementStat(loopId: string, statName: string, value: number = 1): void {
+    const state = this.loopStates.get(loopId);
+    if (state) {
+      state.stats[statName] = (state.stats[statName] ?? 0) + value;
+    }
+  }
+
+  /**
+   * Mark that the span should end on the next iteration.
+   */
+  markForRotation(loopId: string): void {
+    const state = this.loopStates.get(loopId);
+    if (state) {
+      state.endSpanInNextIteration = true;
+    }
+  }
+
+  /**
+   * Check if the span should be rotated (ended and a new one started).
+   */
+  shouldRotate(loopId: string): boolean {
+    const state = this.loopStates.get(loopId);
+    if (!state) return true;
+
+    return (
+      state.perTraceCountdown <= 0 ||
+      Date.now() - state.traceStartedAt.getTime() > this.timeoutSeconds * 1000 ||
+      state.currentSpanContext === undefined ||
+      state.endSpanInNextIteration
+    );
+  }
+
+  /**
+   * End the current span for a loop and record stats.
+   */
+  endCurrentSpan(loopId: string): void {
+    const state = this.loopStates.get(loopId);
+    if (!state?.currentSpan) return;
+
+    // Record stats as span attributes
+    for (const [statName, count] of Object.entries(state.stats)) {
+      state.currentSpan.setAttribute(`stats.${statName}`, count);
+    }
+
+    state.currentSpan.end();
+    state.currentSpan = undefined;
+    state.currentSpanContext = undefined;
+  }
+
+  /**
+   * Start a new batched span for a loop.
+   */
+  startNewSpan(loopId: string, attributes?: Attributes): void {
+    if (!this.tracer) return;
+
+    const state = this.loopStates.get(loopId);
+    if (!state) return;
+
+    // End any existing span first
+    this.endCurrentSpan(loopId);
+
+    // Calculate metrics from previous span period
+    const traceDurationInMs = state.traceStartedAt
+      ? Date.now() - state.traceStartedAt.getTime()
+      : undefined;
+    const iterationsPerSecond =
+      traceDurationInMs && traceDurationInMs > 0
+        ? state.iterationsCount / (traceDurationInMs / 1000)
+        : undefined;
+
+    // Get dynamic attributes if callback is provided
+    const dynamicAttributes = this.getDynamicAttributes?.() ?? {};
+
+    // Start new span
+    state.currentSpan = this.tracer.startSpan(
+      `${this.name}.consumerLoop`,
+      {
+        kind: 1, // SpanKind.CONSUMER
+        attributes: {
+          loop_id: loopId,
+          max_iterations: this.maxIterations,
+          timeout_seconds: this.timeoutSeconds,
+          previous_iterations: state.iterationsCount,
+          previous_duration_ms: traceDurationInMs,
+          previous_iterations_per_second: iterationsPerSecond,
+          total_iterations: state.totalIterationsCount,
+          ...dynamicAttributes,
+          ...attributes,
+        },
+      },
+      ROOT_CONTEXT
+    );
+
+    // Set up context for child spans
+    state.currentSpanContext = trace.setSpan(ROOT_CONTEXT, state.currentSpan);
+
+    // Reset counters
+    state.perTraceCountdown = this.maxIterations;
+    state.traceStartedAt = new Date();
+    state.iterationsCount = 0;
+    state.runningDurationInMs = 0;
+    state.stats = {};
+    state.endSpanInNextIteration = false;
+  }
+
+  /**
+   * Execute a function within the batched span context.
+   * Automatically handles span rotation and iteration tracking.
+   */
+  async withBatchedSpan<T>(
+    loopId: string,
+    fn: (span: Span) => Promise<T>,
+    options?: {
+      iterationSpanName?: string;
+      attributes?: Attributes;
+    }
+  ): Promise<T> {
+    let state = this.loopStates.get(loopId);
+
+    // Initialize state if not present
+    if (!state) {
+      this.initializeLoop(loopId);
+      state = this.loopStates.get(loopId)!;
+    }
+
+    // Check if we need to rotate the span
+    if (this.shouldRotate(loopId)) {
+      this.startNewSpan(loopId);
+    }
+
+    const startTime = performance.now();
+
+    try {
+      // If no tracer, just execute the function
+      if (!this.tracer || !state.currentSpanContext) {
+        return await fn(noopSpan);
+      }
+
+      // Execute within the batched span context
+      return await context.with(state.currentSpanContext, async () => {
+        // Create an iteration span within the batched span
+        const iterationSpanName = options?.iterationSpanName ?? "iteration";
+
+        return await this.tracer!.startActiveSpan(
+          `${this.name}.${iterationSpanName}`,
+          {
+            attributes: {
+              loop_id: loopId,
+              iteration: state.iterationsCount,
+              ...options?.attributes,
+            },
+          },
+          async (iterationSpan) => {
+            try {
+              return await fn(iterationSpan);
+            } catch (error) {
+              if (error instanceof Error) {
+                iterationSpan.recordException(error);
+                state.currentSpan?.recordException(error);
+              }
+              iterationSpan.setStatus({ code: SpanStatusCode.ERROR });
+              state.endSpanInNextIteration = true;
+              throw error;
+            } finally {
+              iterationSpan.end();
+            }
+          }
+        );
+      });
+    } finally {
+      // Update iteration tracking
+      const duration = performance.now() - startTime;
+      state.runningDurationInMs += duration;
+      state.iterationsCount++;
+      state.totalIterationsCount++;
+      state.perTraceCountdown--;
+    }
+  }
+
+  /**
+   * Clean up state for a loop when it's stopped.
+   */
+  cleanup(loopId: string): void {
+    this.endCurrentSpan(loopId);
+    this.loopStates.delete(loopId);
+  }
+
+  /**
+   * Clean up all loop states.
+   */
+  cleanupAll(): void {
+    for (const loopId of this.loopStates.keys()) {
+      this.cleanup(loopId);
+    }
+  }
+}
+
 /**
  * No-op span implementation for when telemetry is disabled.
  */
diff --git a/packages/redis-worker/src/fair-queue/tenantDispatch.ts b/packages/redis-worker/src/fair-queue/tenantDispatch.ts
new file mode 100644
index 00000000000..82663646f5a
--- /dev/null
+++ b/packages/redis-worker/src/fair-queue/tenantDispatch.ts
@@ -0,0 +1,183 @@
+import { createRedisClient, type Redis, type RedisOptions } from "@internal/redis";
+import { jumpHash } from "@trigger.dev/core/v3/serverOnly";
+import type { FairQueueKeyProducer, QueueWithScore } from "./types.js";
+
+export interface TenantDispatchOptions {
+  redis: RedisOptions;
+  keys: FairQueueKeyProducer;
+  shardCount: number;
+}
+
+export interface TenantWithScore {
+  tenantId: string;
+  score: number;
+}
+
+/**
+ * TenantDispatch manages the two-level tenant dispatch index.
+ *
+ * Level 1 - Dispatch Index (per shard):
+ *   Key: {prefix}:dispatch:{shardId}
+ *   ZSET of tenantIds scored by oldest message timestamp across their queues.
+ *   Only tenants with queues containing messages appear here.
+ *
+ * Level 2 - Per-Tenant Queue Index:
+ *   Key: {prefix}:tenantq:{tenantId}
+ *   ZSET of queueIds scored by oldest message timestamp in that queue.
+ *
+ * This replaces the flat master queue for new enqueues, isolating each tenant's
+ * queue backlog so the scheduler iterates tenants (not queues) at Level 1.
+ */
+export class TenantDispatch {
+  private redis: Redis;
+  private keys: FairQueueKeyProducer;
+  private shardCount: number;
+
+  constructor(private options: TenantDispatchOptions) {
+    this.redis = createRedisClient(options.redis);
+    this.keys = options.keys;
+    this.shardCount = Math.max(1, options.shardCount);
+  }
+
+  /**
+   * Get the dispatch shard ID for a tenant.
+   * Uses jump consistent hash on the tenant ID so each tenant
+   * always maps to exactly one dispatch shard.
+   */
+  getShardForTenant(tenantId: string): number {
+    return jumpHash(tenantId, this.shardCount);
+  }
+
+  /**
+   * Get eligible tenants from a dispatch shard (Level 1).
+   * Returns tenants ordered by oldest message (lowest score first).
+   */
+  async getTenantsFromShard(
+    shardId: number,
+    limit: number = 1000,
+    maxScore?: number
+  ): Promise<TenantWithScore[]> {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    const score = maxScore ?? Date.now();
+
+    const results = await this.redis.zrangebyscore(
+      dispatchKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+
+    const tenants: TenantWithScore[] = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const tenantId = results[i];
+      const scoreStr = results[i + 1];
+      if (tenantId && scoreStr) {
+        tenants.push({
+          tenantId,
+          score: parseFloat(scoreStr),
+        });
+      }
+    }
+
+    return tenants;
+  }
+
+  /**
+   * Get queues for a specific tenant (Level 2).
+   * Returns queues ordered by oldest message (lowest score first).
+   */
+  async getQueuesForTenant(
+    tenantId: string,
+    limit: number = 1000,
+    maxScore?: number
+  ): Promise<QueueWithScore[]> {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    const score = maxScore ?? Date.now();
+
+    const results = await this.redis.zrangebyscore(
+      tenantQueueKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+
+    const queues: QueueWithScore[] = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const queueId = results[i];
+      const scoreStr = results[i + 1];
+      if (queueId && scoreStr) {
+        queues.push({
+          queueId,
+          score: parseFloat(scoreStr),
+          tenantId,
+        });
+      }
+    }
+
+    return queues;
+  }
+
+  /**
+   * Get the number of tenants in a dispatch shard.
+   */
+  async getShardTenantCount(shardId: number): Promise<number> {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    return await this.redis.zcard(dispatchKey);
+  }
+
+  /**
+   * Get total tenant count across all dispatch shards.
+   * Note: tenants may appear in multiple shards, so this may overcount.
+   */
+  async getTotalTenantCount(): Promise<number> {
+    const counts = await Promise.all(
+      Array.from({ length: this.shardCount }, (_, i) => this.getShardTenantCount(i))
+    );
+    return counts.reduce((sum, count) => sum + count, 0);
+  }
+
+  /**
+   * Get the number of queues for a tenant.
+   */
+  async getTenantQueueCount(tenantId: string): Promise<number> {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    return await this.redis.zcard(tenantQueueKey);
+  }
+
+  /**
+   * Remove a tenant from a specific dispatch shard.
+   */
+  async removeTenantFromShard(shardId: number, tenantId: string): Promise<void> {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zrem(dispatchKey, tenantId);
+  }
+
+  /**
+   * Add a tenant to a dispatch shard with the given score.
+   */
+  async addTenantToShard(shardId: number, tenantId: string, score: number): Promise<void> {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zadd(dispatchKey, score, tenantId);
+  }
+
+  /**
+   * Remove a queue from a tenant's queue index.
+   */
+  async removeQueueFromTenant(tenantId: string, queueId: string): Promise<void> {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    await this.redis.zrem(tenantQueueKey, queueId);
+  }
+
+  /**
+   * Close the Redis connection.
+   */
+  async close(): Promise<void> {
+    await this.redis.quit();
+  }
+}
diff --git a/packages/redis-worker/src/fair-queue/tests/concurrency.test.ts b/packages/redis-worker/src/fair-queue/tests/concurrency.test.ts
index 4f6035f21e8..7137ea8ac8b 100644
--- a/packages/redis-worker/src/fair-queue/tests/concurrency.test.ts
+++ b/packages/redis-worker/src/fair-queue/tests/concurrency.test.ts
@@ -222,6 +222,167 @@ describe("ConcurrencyManager", () => {
     );
   });
 
+  describe("getAvailableCapacity", () => {
+    redisTest(
+      "should return available capacity for single group",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new ConcurrencyManager({
+          redis: redisOptions,
+          keys,
+          groups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 10,
+              defaultLimit: 10,
+            },
+          ],
+        });
+
+        const queue: QueueDescriptor = {
+          id: "queue-1",
+          tenantId: "t1",
+          metadata: {},
+        };
+
+        // Initial capacity should be full
+        let capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(10);
+
+        // Reserve 3 slots
+        await manager.reserve(queue, "msg-1");
+        await manager.reserve(queue, "msg-2");
+        await manager.reserve(queue, "msg-3");
+
+        // Capacity should be reduced
+        capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(7);
+
+        await manager.close();
+      }
+    );
+
+    redisTest(
+      "should return minimum capacity across multiple groups",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new ConcurrencyManager({
+          redis: redisOptions,
+          keys,
+          groups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 5,
+              defaultLimit: 5,
+            },
+            {
+              name: "organization",
+              extractGroupId: (q) => (q.metadata.orgId as string) ?? "default",
+              getLimit: async () => 20,
+              defaultLimit: 20,
+            },
+          ],
+        });
+
+        const queue: QueueDescriptor = {
+          id: "queue-1",
+          tenantId: "t1",
+          metadata: { orgId: "org1" },
+        };
+
+        // Initial capacity should be minimum (5 for tenant, 20 for org)
+        let capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(5);
+
+        // Reserve 3 slots
+        await manager.reserve(queue, "msg-1");
+        await manager.reserve(queue, "msg-2");
+        await manager.reserve(queue, "msg-3");
+
+        // Now tenant has 2 left, org has 17 left - minimum is 2
+        capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(2);
+
+        await manager.close();
+      }
+    );
+
+    redisTest(
+      "should return 0 when any group is at capacity",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new ConcurrencyManager({
+          redis: redisOptions,
+          keys,
+          groups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 3,
+              defaultLimit: 3,
+            },
+            {
+              name: "organization",
+              extractGroupId: (q) => (q.metadata.orgId as string) ?? "default",
+              getLimit: async () => 10,
+              defaultLimit: 10,
+            },
+          ],
+        });
+
+        const queue: QueueDescriptor = {
+          id: "queue-1",
+          tenantId: "t1",
+          metadata: { orgId: "org1" },
+        };
+
+        // Fill up tenant capacity
+        await manager.reserve(queue, "msg-1");
+        await manager.reserve(queue, "msg-2");
+        await manager.reserve(queue, "msg-3");
+
+        // Tenant is at 3/3, org is at 3/10
+        const capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(0);
+
+        await manager.close();
+      }
+    );
+
+    redisTest(
+      "should return 0 when no groups are configured",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new ConcurrencyManager({
+          redis: redisOptions,
+          keys,
+          groups: [],
+        });
+
+        const queue: QueueDescriptor = {
+          id: "queue-1",
+          tenantId: "t1",
+          metadata: {},
+        };
+
+        const capacity = await manager.getAvailableCapacity(queue);
+        expect(capacity).toBe(0);
+
+        await manager.close();
+      }
+    );
+  });
+
   describe("atomic reservation", () => {
     redisTest(
       "should atomically reserve across groups",
diff --git a/packages/redis-worker/src/fair-queue/tests/drr.test.ts b/packages/redis-worker/src/fair-queue/tests/drr.test.ts
index eb7e3e83374..66575d6486f 100644
--- a/packages/redis-worker/src/fair-queue/tests/drr.test.ts
+++ b/packages/redis-worker/src/fair-queue/tests/drr.test.ts
@@ -115,6 +115,64 @@ describe("DRRScheduler", () => {
       await redis.quit();
     });
 
+    redisTest(
+      "should decrement deficit by count when using recordProcessedBatch",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 5,
+          maxDeficit: 50,
+        });
+
+        // Manually set deficit
+        const deficitKey = `test:drr:deficit`;
+        await redis.hset(deficitKey, "t1", "15");
+
+        // Record batch processing of 7 messages
+        await scheduler.recordProcessedBatch("t1", "queue:q1", 7);
+
+        const deficit = await scheduler.getDeficit("t1");
+        expect(deficit).toBe(8);
+
+        await scheduler.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should not go below 0 when recordProcessedBatch decrements more than available",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 5,
+          maxDeficit: 50,
+        });
+
+        // Manually set deficit to 3
+        const deficitKey = `test:drr:deficit`;
+        await redis.hset(deficitKey, "t1", "3");
+
+        // Record batch processing of 10 messages (more than deficit)
+        await scheduler.recordProcessedBatch("t1", "queue:q1", 10);
+
+        const deficit = await scheduler.getDeficit("t1");
+        expect(deficit).toBe(0);
+
+        await scheduler.close();
+        await redis.quit();
+      }
+    );
+
     redisTest("should reset deficit for tenant", { timeout: 10000 }, async ({ redisOptions }) => {
       keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
       const redis = createRedisClient(redisOptions);
diff --git a/packages/redis-worker/src/fair-queue/tests/fairQueue.test.ts b/packages/redis-worker/src/fair-queue/tests/fairQueue.test.ts
index fcd83b6bab8..f1634ad2fe0 100644
--- a/packages/redis-worker/src/fair-queue/tests/fairQueue.test.ts
+++ b/packages/redis-worker/src/fair-queue/tests/fairQueue.test.ts
@@ -7,20 +7,215 @@ import {
   DRRScheduler,
   FixedDelayRetry,
   NoRetry,
+  WorkerQueueManager,
 } from "../index.js";
-import type { FairQueueKeyProducer } from "../types.js";
+import type { FairQueueKeyProducer, FairQueueOptions, StoredMessage } from "../types.js";
+import type { RedisOptions } from "@internal/redis";
 
 // Define a common payload schema for tests
 const TestPayloadSchema = z.object({ value: z.string() });
 type TestPayload = z.infer<typeof TestPayloadSchema>;
 
+// Constant for test worker queue ID
+const TEST_WORKER_QUEUE_ID = "test-worker-queue";
+
+/**
+ * TestFairQueueHelper wraps FairQueue for easier testing.
+ * It manages the worker queue consumer loop and provides a simple onMessage interface.
+ */
+class TestFairQueueHelper {
+  public fairQueue: FairQueue<typeof TestPayloadSchema>;
+  private workerQueueManager: WorkerQueueManager;
+  private isRunning = false;
+  private abortController: AbortController;
+  private consumerLoops: Promise<void>[] = [];
+  private messageHandler?: (ctx: {
+    message: {
+      id: string;
+      queueId: string;
+      payload: TestPayload;
+      timestamp: number;
+      attempt: number;
+    };
+    queue: { id: string; tenantId: string };
+    consumerId: string;
+    heartbeat: () => Promise<boolean>;
+    complete: () => Promise<void>;
+    release: () => Promise<void>;
+    fail: (error?: Error) => Promise<void>;
+  }) => Promise<void>;
+
+  constructor(
+    private redisOptions: RedisOptions,
+    private keys: FairQueueKeyProducer,
+    options: Omit<FairQueueOptions<typeof TestPayloadSchema>, "redis" | "keys" | "workerQueue">
+  ) {
+    this.abortController = new AbortController();
+
+    // Create FairQueue with worker queue resolver
+    this.fairQueue = new FairQueue({
+      ...options,
+      redis: redisOptions,
+      keys,
+      workerQueue: {
+        resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+      },
+    });
+
+    // Create worker queue manager for consuming
+    this.workerQueueManager = new WorkerQueueManager({
+      redis: redisOptions,
+      keys,
+    });
+  }
+
+  onMessage(
+    handler: (ctx: {
+      message: {
+        id: string;
+        queueId: string;
+        payload: TestPayload;
+        timestamp: number;
+        attempt: number;
+      };
+      queue: { id: string; tenantId: string };
+      consumerId: string;
+      heartbeat: () => Promise<boolean>;
+      complete: () => Promise<void>;
+      release: () => Promise<void>;
+      fail: (error?: Error) => Promise<void>;
+    }) => Promise<void>
+  ): void {
+    this.messageHandler = handler;
+  }
+
+  start(): void {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.abortController = new AbortController();
+
+    // Start FairQueue's master queue consumers
+    this.fairQueue.start();
+
+    // Start worker queue consumer loop
+    const loop = this.#runConsumerLoop();
+    this.consumerLoops.push(loop);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    this.abortController.abort();
+    await this.fairQueue.stop();
+    await Promise.allSettled(this.consumerLoops);
+    this.consumerLoops = [];
+  }
+
+  async close(): Promise<void> {
+    await this.stop();
+    await this.fairQueue.close();
+    await this.workerQueueManager.close();
+  }
+
+  // Delegate methods to fairQueue
+  async enqueue(options: Parameters<typeof this.fairQueue.enqueue>[0]) {
+    return this.fairQueue.enqueue(options);
+  }
+
+  async enqueueBatch(options: Parameters<typeof this.fairQueue.enqueueBatch>[0]) {
+    return this.fairQueue.enqueueBatch(options);
+  }
+
+  async getQueueLength(queueId: string) {
+    return this.fairQueue.getQueueLength(queueId);
+  }
+
+  async getTotalInflightCount() {
+    return this.fairQueue.getTotalInflightCount();
+  }
+
+
+  registerTelemetryGauges(options?: { observedTenants?: string[] }) {
+    return this.fairQueue.registerTelemetryGauges(options);
+  }
+
+  async getDeadLetterQueueLength(tenantId: string) {
+    return this.fairQueue.getDeadLetterQueueLength(tenantId);
+  }
+
+  async getDeadLetterMessages(tenantId: string) {
+    return this.fairQueue.getDeadLetterMessages(tenantId);
+  }
+
+  async redriveMessage(tenantId: string, messageId: string) {
+    return this.fairQueue.redriveMessage(tenantId, messageId);
+  }
+
+  async #runConsumerLoop(): Promise<void> {
+    const loopId = "test-consumer-0";
+
+    try {
+      while (this.isRunning) {
+        if (!this.messageHandler) {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          continue;
+        }
+
+        try {
+          const messageKey = await this.workerQueueManager.blockingPop(
+            TEST_WORKER_QUEUE_ID,
+            1,
+            this.abortController.signal
+          );
+
+          if (!messageKey) continue;
+
+          const colonIndex = messageKey.indexOf(":");
+          if (colonIndex === -1) continue;
+
+          const messageId = messageKey.substring(0, colonIndex);
+          const queueId = messageKey.substring(colonIndex + 1);
+
+          const storedMessage = await this.fairQueue.getMessageData(messageId, queueId);
+          if (!storedMessage) continue;
+
+          const ctx = {
+            message: {
+              id: storedMessage.id,
+              queueId: storedMessage.queueId,
+              payload: storedMessage.payload,
+              timestamp: storedMessage.timestamp,
+              attempt: storedMessage.attempt,
+            },
+            queue: {
+              id: queueId,
+              tenantId: storedMessage.tenantId,
+            },
+            consumerId: loopId,
+            heartbeat: () => this.fairQueue.heartbeatMessage(messageId, queueId),
+            complete: () => this.fairQueue.completeMessage(messageId, queueId),
+            release: () => this.fairQueue.releaseMessage(messageId, queueId),
+            fail: (error?: Error) => this.fairQueue.failMessage(messageId, queueId, error),
+          };
+
+          await this.messageHandler(ctx);
+        } catch (error) {
+          if (this.abortController.signal.aborted) break;
+        }
+      }
+    } catch {
+      // Ignore abort errors
+    }
+  }
+}
+
 describe("FairQueue", () => {
   let keys: FairQueueKeyProducer;
 
   describe("basic enqueue and process", () => {
     redisTest(
       "should enqueue and process a single message",
-      { timeout: 15000 },
+      { timeout: 30000 },
       async ({ redisOptions }) => {
         const processed: string[] = [];
         keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
@@ -32,9 +227,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -87,9 +280,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -152,9 +343,7 @@ describe("FairQueue", () => {
           maxDeficit: 5,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -197,14 +386,25 @@ describe("FairQueue", () => {
           { timeout: 15000 }
         );
 
-        // Check that messages were interleaved (not all t1 before t2)
-        const firstFive = processed.slice(0, 5);
-        const t1InFirstFive = firstFive.filter((p) => p.tenant === "t1").length;
-        const t2InFirstFive = firstFive.filter((p) => p.tenant === "t2").length;
-
-        // DRR should ensure some interleaving
-        expect(t1InFirstFive).toBeGreaterThan(0);
-        expect(t2InFirstFive).toBeGreaterThan(0);
+        // With two-stage architecture, fairness is at the claiming level, not processing order.
+        // Both tenants' queues are serviced in the same scheduler round, but messages are
+        // pushed to a shared worker queue and processed in FIFO order.
+        // The fairness guarantee is that both tenants' messages ARE processed, not that
+        // they're interleaved in the processing order.
+        const t1Count = processed.filter((p) => p.tenant === "t1").length;
+        const t2Count = processed.filter((p) => p.tenant === "t2").length;
+
+        // DRR ensures both tenants get their messages claimed and processed
+        expect(t1Count).toBe(5);
+        expect(t2Count).toBe(5);
+
+        // Verify all messages were processed
+        expect(processed.filter((p) => p.tenant === "t1").map((p) => p.value)).toEqual(
+          expect.arrayContaining(["t1-0", "t1-1", "t1-2", "t1-3", "t1-4"])
+        );
+        expect(processed.filter((p) => p.tenant === "t2").map((p) => p.value)).toEqual(
+          expect.arrayContaining(["t2-0", "t2-1", "t2-2", "t2-3", "t2-4"])
+        );
 
         await queue.close();
       }
@@ -226,9 +426,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -289,9 +487,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -364,9 +560,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -429,9 +623,7 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -495,9 +687,7 @@ describe("FairQueue", () => {
         maxDeficit: 100,
       });
 
-      const queue = new FairQueue({
-        redis: redisOptions,
-        keys,
+      const queue = new TestFairQueueHelper(redisOptions, keys, {
         scheduler,
         payloadSchema: TestPayloadSchema,
         shardCount: 1,
@@ -589,6 +779,9 @@ describe("FairQueue", () => {
           payloadSchema: PayloadSchema,
           validateOnEnqueue: true,
           startConsumers: false,
+          workerQueue: {
+            resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+          },
         });
 
         // Valid payload should work
@@ -626,6 +819,12 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
+        // Create worker queue manager for consuming
+        const workerQueueManager = new WorkerQueueManager({
+          redis: redisOptions,
+          keys,
+        });
+
         const queue = new FairQueue({
           redis: redisOptions,
           keys,
@@ -636,13 +835,13 @@ describe("FairQueue", () => {
           consumerIntervalMs: 50,
           visibilityTimeoutMs: 5000,
           startConsumers: false,
+          workerQueue: {
+            resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+          },
         });
 
-        queue.onMessage(async (ctx) => {
-          // TypeScript should infer ctx.message.payload as { name: string; count: number }
-          processed.push(ctx.message.payload);
-          await ctx.complete();
-        });
+        // Start the queue (which routes messages to worker queue)
+        queue.start();
 
         await queue.enqueue({
           queueId: "tenant:t1:queue:q1",
@@ -650,18 +849,29 @@ describe("FairQueue", () => {
           payload: { name: "typed", count: 42 },
         });
 
-        queue.start();
-
-        await vi.waitFor(
-          () => {
-            expect(processed).toHaveLength(1);
-          },
-          { timeout: 5000 }
-        );
+        // Consume from worker queue
+        let attempts = 0;
+        while (processed.length === 0 && attempts < 50) {
+          const messageKey = await workerQueueManager.blockingPop(TEST_WORKER_QUEUE_ID, 1);
+          if (messageKey) {
+            const colonIndex = messageKey.indexOf(":");
+            const messageId = messageKey.substring(0, colonIndex);
+            const queueId = messageKey.substring(colonIndex + 1);
+            const storedMessage = await queue.getMessageData(messageId, queueId);
+            if (storedMessage) {
+              // TypeScript should infer storedMessage.payload as { name: string; count: number }
+              processed.push(storedMessage.payload);
+              await queue.completeMessage(messageId, queueId);
+            }
+          }
+          attempts++;
+        }
 
+        expect(processed).toHaveLength(1);
         expect(processed[0]).toEqual({ name: "typed", count: 42 });
 
         await queue.close();
+        await workerQueueManager.close();
       }
     );
   });
@@ -680,9 +890,8 @@ describe("FairQueue", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const processed: string[] = [];
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -697,6 +906,11 @@ describe("FairQueue", () => {
           startConsumers: false,
         });
 
+        queue.onMessage(async (ctx) => {
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+
         // Start without any messages (will trigger empty dequeues)
         queue.start();
 
@@ -711,20 +925,78 @@ describe("FairQueue", () => {
           payload: { value: "after-cooloff" },
         });
 
+        // Message should still be processed (cooloff is per-queue, not global)
+        await vi.waitFor(
+          () => {
+            expect(processed).toContain("after-cooloff");
+          },
+          { timeout: 10000 }
+        );
+
+        await queue.close();
+      }
+    );
+
+    redisTest(
+      "should clear cooloff states when size cap is exceeded",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 10,
+          maxDeficit: 100,
+        });
+
         const processed: string[] = [];
+
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerCount: 1,
+          consumerIntervalMs: 20,
+          visibilityTimeoutMs: 5000,
+          cooloff: {
+            enabled: true,
+            threshold: 1, // Enter cooloff after 1 failure
+            periodMs: 100, // Short cooloff for testing
+            maxStatesSize: 5, // Very small cap for testing
+          },
+          startConsumers: false,
+        });
+
+        // Handler that always fails to trigger cooloff
         queue.onMessage(async (ctx) => {
           processed.push(ctx.message.payload.value);
-          await ctx.complete();
+          await ctx.fail(new Error("Forced failure"));
         });
 
-        // Message should still be processed (cooloff is per-queue, not global)
+        // Enqueue messages to multiple queues
+        for (let i = 0; i < 10; i++) {
+          await queue.enqueue({
+            queueId: `tenant:t${i}:queue:q1`,
+            tenantId: `t${i}`,
+            payload: { value: `msg-${i}` },
+          });
+        }
+
+        queue.start();
+
+        // Wait for some messages to be processed and fail
         await vi.waitFor(
           () => {
-            expect(processed).toContain("after-cooloff");
+            expect(processed.length).toBeGreaterThanOrEqual(5);
           },
           { timeout: 10000 }
         );
 
+        // The cooloff states size should be capped (test that it doesn't grow unbounded)
+        const cacheSizes = queue.fairQueue.getCacheSizes();
+        expect(cacheSizes.cooloffStatesSize).toBeLessThanOrEqual(10); // Some buffer for race conditions
+
         await queue.close();
       }
     );
@@ -746,6 +1018,9 @@ describe("FairQueue", () => {
         keys,
         scheduler,
         startConsumers: false,
+        workerQueue: {
+          resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+        },
       });
 
       // Initially empty
@@ -786,6 +1061,9 @@ describe("FairQueue", () => {
         scheduler,
         shardCount: 2,
         startConsumers: false,
+        workerQueue: {
+          resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+        },
       });
 
       // Initially empty
@@ -810,4 +1088,288 @@ describe("FairQueue", () => {
       await queue.close();
     });
   });
+
+  describe("two-stage processing with concurrency limits", () => {
+    redisTest(
+      "should release remaining claimed messages when concurrency reservation fails",
+      { timeout: 30000 },
+      async ({ redisOptions }) => {
+        const processed: string[] = [];
+        const processingMessages = new Set<string>();
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 10,
+          maxDeficit: 100,
+        });
+
+        // Create queue with:
+        // - Worker queue enabled (two-stage processing)
+        // - Concurrency limit of 2 per tenant
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerCount: 1,
+          consumerIntervalMs: 50,
+          visibilityTimeoutMs: 10000,
+          concurrencyGroups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 2, // Limit to 2 concurrent per tenant
+              defaultLimit: 2,
+            },
+          ],
+          startConsumers: false,
+        });
+
+        // Message handler that tracks what's being processed
+        queue.onMessage(async (ctx) => {
+          const value = ctx.message.payload.value;
+          processingMessages.add(value);
+
+          // Simulate some work
+          await new Promise((resolve) => setTimeout(resolve, 100));
+
+          processed.push(value);
+          processingMessages.delete(value);
+          await ctx.complete();
+        });
+
+        // Enqueue 5 messages to the same tenant queue
+        await queue.enqueueBatch({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          messages: [
+            { payload: { value: "msg-1" } },
+            { payload: { value: "msg-2" } },
+            { payload: { value: "msg-3" } },
+            { payload: { value: "msg-4" } },
+            { payload: { value: "msg-5" } },
+          ],
+        });
+
+        // Start processing
+        queue.start();
+
+        // Wait for all messages to be processed
+        // With concurrency limit of 2, it should process in batches
+        await vi.waitFor(
+          () => {
+            expect(processed.length).toBe(5);
+          },
+          { timeout: 20000 }
+        );
+
+        // All messages should have been processed
+        expect(processed).toContain("msg-1");
+        expect(processed).toContain("msg-2");
+        expect(processed).toContain("msg-3");
+        expect(processed).toContain("msg-4");
+        expect(processed).toContain("msg-5");
+
+        // Wait a bit for any cleanup to complete
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        // No messages should be stuck in-flight
+        const inflightCount = await queue.getTotalInflightCount();
+        expect(inflightCount).toBe(0);
+
+        await queue.close();
+      }
+    );
+  });
+
+  describe("concurrency block should not trigger cooloff", () => {
+    redisTest(
+      "should not enter cooloff when queue hits concurrency limit",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const processed: string[] = [];
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 10,
+          maxDeficit: 100,
+        });
+
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerCount: 1,
+          consumerIntervalMs: 20,
+          visibilityTimeoutMs: 5000,
+          cooloff: {
+            periodMs: 5000, // Long cooloff - if triggered, messages would stall
+            threshold: 1, // Enter cooloff after just 1 increment
+          },
+          concurrencyGroups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 1, // Only 1 concurrent per tenant
+              defaultLimit: 1,
+            },
+          ],
+          startConsumers: false,
+        });
+
+        // Hold first message to keep concurrency slot occupied
+        let releaseFirst: (() => void) | undefined;
+        const firstBlocking = new Promise<void>((resolve) => {
+          releaseFirst = resolve;
+        });
+        let firstStarted = false;
+
+        queue.onMessage(async (ctx) => {
+          if (ctx.message.payload.value === "msg-0") {
+            firstStarted = true;
+            // Block this message to saturate concurrency
+            await firstBlocking;
+          }
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+
+        // Enqueue 3 messages to same tenant
+        for (let i = 0; i < 3; i++) {
+          await queue.enqueue({
+            queueId: "tenant:t1:queue:q1",
+            tenantId: "t1",
+            payload: { value: `msg-${i}` },
+          });
+        }
+
+        queue.start();
+
+        // Wait for first message to start processing (blocking the concurrency slot)
+        await vi.waitFor(
+          () => {
+            expect(firstStarted).toBe(true);
+          },
+          { timeout: 5000 }
+        );
+
+        // Release the first message so others can proceed
+        releaseFirst!();
+
+        // All 3 messages should process within a reasonable time.
+        // If cooloff was incorrectly triggered, this would take 5+ seconds.
+        const startTime = Date.now();
+        await vi.waitFor(
+          () => {
+            expect(processed).toHaveLength(3);
+          },
+          { timeout: 5000 }
+        );
+        const elapsed = Date.now() - startTime;
+
+        // Should complete well under the 5s cooloff period
+        expect(elapsed).toBeLessThan(3000);
+
+        // Cooloff states should be empty (no spurious cooloffs)
+        const cacheSizes = queue.fairQueue.getCacheSizes();
+        expect(cacheSizes.cooloffStatesSize).toBe(0);
+
+        await queue.close();
+      }
+    );
+  });
+
+  describe("worker queue depth cap", () => {
+    redisTest(
+      "should respect worker queue max depth and resume after draining",
+      { timeout: 30000 },
+      async ({ redisOptions }) => {
+        const processed: string[] = [];
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 100,
+          maxDeficit: 1000,
+        });
+
+        const workerQueueManager = new WorkerQueueManager({
+          redis: redisOptions,
+          keys,
+        });
+
+        // Create FairQueue with a small depth cap
+        const maxDepth = 3;
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerCount: 1,
+          consumerIntervalMs: 50,
+          visibilityTimeoutMs: 30000,
+          workerQueueMaxDepth: maxDepth,
+          workerQueueDepthCheckId: TEST_WORKER_QUEUE_ID,
+          startConsumers: false,
+        });
+
+        // Use a slow handler to let the worker queue build up
+        queue.onMessage(async (ctx) => {
+          await new Promise((resolve) => setTimeout(resolve, 200));
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+
+        // Enqueue 10 messages
+        const totalMessages = 10;
+        for (let i = 0; i < totalMessages; i++) {
+          await queue.enqueue({
+            queueId: "tenant:t1:queue:q1",
+            tenantId: "t1",
+            payload: { value: `msg-${i}` },
+          });
+        }
+
+        // Start processing and track peak worker queue depth
+        let peakDepth = 0;
+        let polling = true;
+        const depthPoller = (async () => {
+          while (polling) {
+            const depth = await workerQueueManager.getLength(TEST_WORKER_QUEUE_ID);
+            if (depth > peakDepth) {
+              peakDepth = depth;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+          }
+        })();
+
+        queue.start();
+
+        // Verify all messages eventually get processed (depth cap doesn't permanently block)
+        await vi.waitFor(
+          () => {
+            expect(processed.length).toBe(totalMessages);
+          },
+          { timeout: 25000 }
+        );
+
+        polling = false;
+        await depthPoller;
+
+        // Verify the depth cap was respected during processing
+        expect(peakDepth).toBeLessThanOrEqual(maxDepth);
+
+        // Verify the worker queue is drained
+        const finalDepth = await workerQueueManager.getLength(TEST_WORKER_QUEUE_ID);
+        expect(finalDepth).toBe(0);
+
+        await workerQueueManager.close();
+        await queue.close();
+      }
+    );
+  });
+
 });
diff --git a/packages/redis-worker/src/fair-queue/tests/raceConditions.test.ts b/packages/redis-worker/src/fair-queue/tests/raceConditions.test.ts
index 3700ef55866..4d85603b984 100644
--- a/packages/redis-worker/src/fair-queue/tests/raceConditions.test.ts
+++ b/packages/redis-worker/src/fair-queue/tests/raceConditions.test.ts
@@ -8,12 +8,191 @@ import {
   ConcurrencyManager,
   VisibilityManager,
   MasterQueue,
+  WorkerQueueManager,
   FixedDelayRetry,
 } from "../index.js";
-import type { FairQueueKeyProducer, QueueDescriptor } from "../types.js";
-import { createRedisClient } from "@internal/redis";
+import type { FairQueueKeyProducer, FairQueueOptions, QueueDescriptor, StoredMessage } from "../types.js";
+import { createRedisClient, type RedisOptions } from "@internal/redis";
 
 const TestPayloadSchema = z.object({ id: z.number(), value: z.string() });
+type TestPayload = z.infer<typeof TestPayloadSchema>;
+
+// Constant for test worker queue ID
+const TEST_WORKER_QUEUE_ID = "test-worker-queue";
+
+/**
+ * TestFairQueueHelper wraps FairQueue for easier testing in race condition tests.
+ */
+class TestFairQueueHelper {
+  public fairQueue: FairQueue<typeof TestPayloadSchema>;
+  private workerQueueManager: WorkerQueueManager;
+  private isRunning = false;
+  private abortController: AbortController;
+  private consumerLoops: Promise<void>[] = [];
+  private messageHandler?: (ctx: {
+    message: {
+      id: string;
+      queueId: string;
+      payload: TestPayload;
+      timestamp: number;
+      attempt: number;
+    };
+    queue: { id: string; tenantId: string };
+    consumerId: string;
+    heartbeat: () => Promise<boolean>;
+    complete: () => Promise<void>;
+    release: () => Promise<void>;
+    fail: (error?: Error) => Promise<void>;
+  }) => Promise<void>;
+
+  constructor(
+    private redisOptions: RedisOptions,
+    private keys: FairQueueKeyProducer,
+    options: Omit<FairQueueOptions<typeof TestPayloadSchema>, "redis" | "keys" | "workerQueue">
+  ) {
+    this.abortController = new AbortController();
+
+    this.fairQueue = new FairQueue({
+      ...options,
+      redis: redisOptions,
+      keys,
+      workerQueue: {
+        resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+      },
+    });
+
+    this.workerQueueManager = new WorkerQueueManager({
+      redis: redisOptions,
+      keys,
+    });
+  }
+
+  onMessage(
+    handler: (ctx: {
+      message: {
+        id: string;
+        queueId: string;
+        payload: TestPayload;
+        timestamp: number;
+        attempt: number;
+      };
+      queue: { id: string; tenantId: string };
+      consumerId: string;
+      heartbeat: () => Promise<boolean>;
+      complete: () => Promise<void>;
+      release: () => Promise<void>;
+      fail: (error?: Error) => Promise<void>;
+    }) => Promise<void>
+  ): void {
+    this.messageHandler = handler;
+  }
+
+  start(): void {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.abortController = new AbortController();
+    this.fairQueue.start();
+    const loop = this.#runConsumerLoop();
+    this.consumerLoops.push(loop);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    this.abortController.abort();
+    await this.fairQueue.stop();
+    await Promise.allSettled(this.consumerLoops);
+    this.consumerLoops = [];
+  }
+
+  async close(): Promise<void> {
+    await this.stop();
+    await this.fairQueue.close();
+    await this.workerQueueManager.close();
+  }
+
+  async enqueue(options: Parameters<typeof this.fairQueue.enqueue>[0]) {
+    return this.fairQueue.enqueue(options);
+  }
+
+  async enqueueBatch(options: Parameters<typeof this.fairQueue.enqueueBatch>[0]) {
+    return this.fairQueue.enqueueBatch(options);
+  }
+
+  async getQueueLength(queueId: string) {
+    return this.fairQueue.getQueueLength(queueId);
+  }
+
+  async getTotalInflightCount() {
+    return this.fairQueue.getTotalInflightCount();
+  }
+
+  async getDeadLetterQueueLength(tenantId: string) {
+    return this.fairQueue.getDeadLetterQueueLength(tenantId);
+  }
+
+  async getDeadLetterMessages(tenantId: string, limit?: number) {
+    return this.fairQueue.getDeadLetterMessages(tenantId, limit);
+  }
+
+  async getTotalQueueCount() {
+    return this.fairQueue.getTotalQueueCount();
+  }
+
+  async #runConsumerLoop(): Promise<void> {
+    const loopId = "test-consumer-0";
+    try {
+      while (this.isRunning) {
+        if (!this.messageHandler) {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          continue;
+        }
+        try {
+          const messageKey = await this.workerQueueManager.blockingPop(
+            TEST_WORKER_QUEUE_ID,
+            1,
+            this.abortController.signal
+          );
+          if (!messageKey) continue;
+
+          const colonIndex = messageKey.indexOf(":");
+          if (colonIndex === -1) continue;
+
+          const messageId = messageKey.substring(0, colonIndex);
+          const queueId = messageKey.substring(colonIndex + 1);
+
+          const storedMessage = await this.fairQueue.getMessageData(messageId, queueId);
+          if (!storedMessage) continue;
+
+          const ctx = {
+            message: {
+              id: storedMessage.id,
+              queueId: storedMessage.queueId,
+              payload: storedMessage.payload,
+              timestamp: storedMessage.timestamp,
+              attempt: storedMessage.attempt,
+            },
+            queue: {
+              id: queueId,
+              tenantId: storedMessage.tenantId,
+            },
+            consumerId: loopId,
+            heartbeat: () => this.fairQueue.heartbeatMessage(messageId, queueId),
+            complete: () => this.fairQueue.completeMessage(messageId, queueId),
+            release: () => this.fairQueue.releaseMessage(messageId, queueId),
+            fail: (error?: Error) => this.fairQueue.failMessage(messageId, queueId, error),
+          };
+
+          await this.messageHandler(ctx);
+        } catch (error) {
+          if (this.abortController.signal.aborted) break;
+        }
+      }
+    } catch {
+      // Ignore abort errors
+    }
+  }
+}
 
 describe("Race Condition Tests", () => {
   let keys: FairQueueKeyProducer;
@@ -39,6 +218,9 @@ describe("Race Condition Tests", () => {
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
           startConsumers: false,
+          workerQueue: {
+            resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+          },
         });
 
         const CONCURRENT_ENQUEUES = 100;
@@ -87,6 +269,9 @@ describe("Race Condition Tests", () => {
           payloadSchema: TestPayloadSchema,
           shardCount: 4, // Multiple shards
           startConsumers: false,
+          workerQueue: {
+            resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID,
+          },
         });
 
         const QUEUES = 10;
@@ -144,9 +329,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -225,9 +408,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -443,11 +624,14 @@ describe("Race Condition Tests", () => {
           await new Promise((resolve) => setTimeout(resolve, 300));
 
           // Try to reclaim (should find nothing because heartbeat extended the deadline)
-          const reclaimed = await manager.reclaimTimedOut(0, (queueId) => ({
+          const reclaimedMessages = await manager.reclaimTimedOut(0, (queueId) => ({
             queueKey: keys.queueKey(queueId),
             queueItemsKey: keys.queueItemsKey(queueId),
+            tenantQueueIndexKey: keys.tenantQueueIndexKey(keys.extractTenantId(queueId)),
+            dispatchKey: keys.dispatchKey(0),
+            tenantId: keys.extractTenantId(queueId),
           }));
-          reclaimResults.push(reclaimed);
+          reclaimResults.push(reclaimedMessages.length);
         }
 
         // Heartbeats should have kept the message alive
@@ -623,9 +807,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -710,9 +892,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -792,9 +972,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -862,9 +1040,7 @@ describe("Race Condition Tests", () => {
         // Track concurrency over time
         let maxConcurrency = 0;
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -952,9 +1128,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 1,
@@ -1023,9 +1197,7 @@ describe("Race Condition Tests", () => {
           maxDeficit: 100,
         });
 
-        const queue = new FairQueue({
-          redis: redisOptions,
-          keys,
+        const queue = new TestFairQueueHelper(redisOptions, keys, {
           scheduler,
           payloadSchema: TestPayloadSchema,
           shardCount: 2, // Multiple shards to test
diff --git a/packages/redis-worker/src/fair-queue/tests/tenantDispatch.test.ts b/packages/redis-worker/src/fair-queue/tests/tenantDispatch.test.ts
new file mode 100644
index 00000000000..b26fb981193
--- /dev/null
+++ b/packages/redis-worker/src/fair-queue/tests/tenantDispatch.test.ts
@@ -0,0 +1,1144 @@
+import { describe, expect } from "vitest";
+import { redisTest } from "@internal/testcontainers";
+import { createRedisClient } from "@internal/redis";
+import { z } from "zod";
+import {
+  FairQueue,
+  DefaultFairQueueKeyProducer,
+  DRRScheduler,
+  ExponentialBackoffRetry,
+  WorkerQueueManager,
+} from "../index.js";
+import type { FairQueueKeyProducer, StoredMessage } from "../types.js";
+import type { RedisOptions } from "@internal/redis";
+
+const TestPayloadSchema = z.object({ value: z.string() });
+type TestPayload = z.infer<typeof TestPayloadSchema>;
+const TEST_WORKER_QUEUE_ID = "test-worker-queue";
+
+/**
+ * Minimal test helper for tenant dispatch tests.
+ */
+class TestHelper {
+  public fairQueue: FairQueue<typeof TestPayloadSchema>;
+  private workerQueueManager: WorkerQueueManager;
+  private isRunning = false;
+  private abortController = new AbortController();
+  private consumerLoops: Promise<void>[] = [];
+  private messageHandler?: (ctx: {
+    message: { id: string; queueId: string; payload: TestPayload; attempt: number };
+    complete: () => Promise<void>;
+    release: () => Promise<void>;
+    fail: (error?: Error) => Promise<void>;
+  }) => Promise<void>;
+
+  constructor(
+    private redisOptions: RedisOptions,
+    private keys: FairQueueKeyProducer,
+    options: {
+      shardCount?: number;
+      consumerIntervalMs?: number;
+      concurrencyLimit?: number;
+      visibilityTimeoutMs?: number;
+      reclaimIntervalMs?: number;
+      retry?: { maxAttempts: number; delayMs: number };
+    } = {}
+  ) {
+    const scheduler = new DRRScheduler({
+      redis: redisOptions,
+      keys,
+      quantum: 10,
+      maxDeficit: 100,
+    });
+
+    this.fairQueue = new FairQueue({
+      redis: redisOptions,
+      keys,
+      scheduler,
+      payloadSchema: TestPayloadSchema,
+      shardCount: options.shardCount ?? 1,
+      consumerIntervalMs: options.consumerIntervalMs ?? 20,
+      visibilityTimeoutMs: options.visibilityTimeoutMs,
+      reclaimIntervalMs: options.reclaimIntervalMs,
+      startConsumers: false,
+      workerQueue: { resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID },
+      retry: options.retry
+        ? {
+            strategy: new ExponentialBackoffRetry({
+              maxAttempts: options.retry.maxAttempts,
+              minTimeoutInMs: options.retry.delayMs,
+              maxTimeoutInMs: options.retry.delayMs,
+              factor: 1,
+              randomize: false,
+            }),
+          }
+        : undefined,
+      concurrencyGroups: options.concurrencyLimit
+        ? [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => options.concurrencyLimit!,
+              defaultLimit: options.concurrencyLimit!,
+            },
+          ]
+        : undefined,
+    });
+
+    this.workerQueueManager = new WorkerQueueManager({
+      redis: redisOptions,
+      keys,
+    });
+  }
+
+  onMessage(
+    handler: (ctx: {
+      message: { id: string; queueId: string; payload: TestPayload; attempt: number };
+      complete: () => Promise<void>;
+      release: () => Promise<void>;
+      fail: (error?: Error) => Promise<void>;
+    }) => Promise<void>
+  ): void {
+    this.messageHandler = handler;
+  }
+
+  start(): void {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.abortController = new AbortController();
+    this.fairQueue.start();
+    this.consumerLoops.push(this.#runConsumerLoop());
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    this.abortController.abort();
+    await this.fairQueue.stop();
+    await Promise.allSettled(this.consumerLoops);
+    this.consumerLoops = [];
+  }
+
+  async close(): Promise<void> {
+    await this.stop();
+    await this.fairQueue.close();
+    await this.workerQueueManager.close();
+  }
+
+  async #runConsumerLoop(): Promise<void> {
+    try {
+      while (this.isRunning) {
+        if (!this.messageHandler) {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          continue;
+        }
+        try {
+          const messageKey = await this.workerQueueManager.blockingPop(
+            TEST_WORKER_QUEUE_ID,
+            1,
+            this.abortController.signal
+          );
+          if (!messageKey) continue;
+
+          const colonIndex = messageKey.indexOf(":");
+          if (colonIndex === -1) continue;
+
+          const messageId = messageKey.substring(0, colonIndex);
+          const queueId = messageKey.substring(colonIndex + 1);
+          const storedMessage = await this.fairQueue.getMessageData(messageId, queueId);
+          if (!storedMessage) continue;
+
+          await this.messageHandler({
+            message: {
+              id: storedMessage.id,
+              queueId: storedMessage.queueId,
+              payload: storedMessage.payload,
+              attempt: storedMessage.attempt,
+            },
+            complete: () => this.fairQueue.completeMessage(messageId, queueId),
+            release: () => this.fairQueue.releaseMessage(messageId, queueId),
+            fail: (error?: Error) => this.fairQueue.failMessage(messageId, queueId, error),
+          });
+        } catch {
+          if (!this.isRunning) break;
+        }
+      }
+    } catch {
+      // Consumer loop stopped
+    }
+  }
+}
+
+describe("Two-Level Tenant Dispatch", () => {
+  describe("enqueue writes to new index only", () => {
+    redisTest(
+      "should populate dispatch and tenant queue indexes, not old master queue",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        const helper = new TestHelper(redisOptions, keys);
+
+        // Enqueue messages to two different queues for two tenants
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "msg1" },
+        });
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t2:queue:q1",
+          tenantId: "t2",
+          payload: { value: "msg2" },
+        });
+
+        // Check new dispatch index (Level 1): should have both tenants
+        const dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1, "WITHSCORES");
+        expect(dispatchMembers.length).toBeGreaterThanOrEqual(2); // at least 1 tenant per shard
+
+        // Check tenant queue indexes (Level 2)
+        const t1Queues = await redis.zrange(keys.tenantQueueIndexKey("t1"), 0, -1);
+        expect(t1Queues).toContain("tenant:t1:queue:q1");
+
+        const t2Queues = await redis.zrange(keys.tenantQueueIndexKey("t2"), 0, -1);
+        expect(t2Queues).toContain("tenant:t2:queue:q1");
+
+        // Check old master queue: should be EMPTY (new enqueues don't write there)
+        const masterMembers = await redis.zrange(keys.masterQueueKey(0), 0, -1);
+        expect(masterMembers.length).toBe(0);
+
+        // Per-queue storage should still work as before
+        const queueLength = await helper.fairQueue.getQueueLength("tenant:t1:queue:q1");
+        expect(queueLength).toBe(1);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should populate dispatch index correctly for batch enqueue",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        const helper = new TestHelper(redisOptions, keys);
+
+        await helper.fairQueue.enqueueBatch({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          messages: [
+            { payload: { value: "msg1" } },
+            { payload: { value: "msg2" } },
+            { payload: { value: "msg3" } },
+          ],
+        });
+
+        // Tenant queue index should have the queue
+        const t1Queues = await redis.zrange(keys.tenantQueueIndexKey("t1"), 0, -1);
+        expect(t1Queues).toContain("tenant:t1:queue:q1");
+
+        // Dispatch should have the tenant
+        const dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1);
+        expect(dispatchMembers).toContain("t1");
+
+        // Per-queue storage should have all 3 messages
+        const queueLength = await helper.fairQueue.getQueueLength("tenant:t1:queue:q1");
+        expect(queueLength).toBe(3);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("dispatch consumer processes messages", () => {
+    redisTest(
+      "should process messages via tenant dispatch path",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const processed: string[] = [];
+
+        const helper = new TestHelper(redisOptions, keys);
+
+        // Enqueue messages
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "first" },
+        });
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t2:queue:q1",
+          tenantId: "t2",
+          payload: { value: "second" },
+        });
+
+        // Set up consumer
+        helper.onMessage(async (ctx) => {
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+
+        helper.start();
+
+        // Wait for messages to be processed
+        await waitFor(() => processed.length === 2, 5000);
+        expect(processed).toContain("first");
+        expect(processed).toContain("second");
+
+        await helper.close();
+      }
+    );
+  });
+
+  describe("complete updates dispatch indexes", () => {
+    redisTest(
+      "should remove empty queue from tenant index and tenant from dispatch",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        const helper = new TestHelper(redisOptions, keys);
+
+        // Enqueue one message
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "only" },
+        });
+
+        // Verify indexes populated
+        let t1Queues = await redis.zrange(keys.tenantQueueIndexKey("t1"), 0, -1);
+        expect(t1Queues.length).toBe(1);
+        let dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1);
+        expect(dispatchMembers).toContain("t1");
+
+        // Process and complete the message
+        helper.onMessage(async (ctx) => {
+          await ctx.complete();
+        });
+        helper.start();
+
+        // Wait for processing
+        await waitFor(
+          async () => (await helper.fairQueue.getQueueLength("tenant:t1:queue:q1")) === 0,
+          5000
+        );
+
+        // Allow index updates to propagate
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        // Verify indexes cleaned up
+        t1Queues = await redis.zrange(keys.tenantQueueIndexKey("t1"), 0, -1);
+        expect(t1Queues.length).toBe(0);
+        dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1);
+        expect(dispatchMembers).not.toContain("t1");
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should keep tenant in dispatch when other queues remain",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const processed: string[] = [];
+
+        const helper = new TestHelper(redisOptions, keys, { concurrencyLimit: 1 });
+
+        // Enqueue to two queues for the same tenant
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "queue1" },
+        });
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q2",
+          tenantId: "t1",
+          payload: { value: "queue2" },
+        });
+
+        // Process messages one at a time (concurrency limit 1)
+        helper.onMessage(async (ctx) => {
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+        helper.start();
+
+        // Wait for first message
+        await waitFor(() => processed.length >= 1, 5000);
+
+        // Tenant should still be in dispatch (has remaining queue)
+        const dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1);
+        // After first complete, tenant may still be in dispatch due to second queue
+        // (exact timing depends on consumer loop)
+
+        // Wait for both messages
+        await waitFor(() => processed.length === 2, 5000);
+        expect(processed).toContain("queue1");
+        expect(processed).toContain("queue2");
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("legacy drain", () => {
+    redisTest(
+      "should drain pre-populated master queue alongside new dispatch",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const processed: string[] = [];
+
+        // Simulate pre-deploy state: write directly to old master queue + queue storage
+        const queueId = "tenant:t1:queue:legacy";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const masterQueueKey = keys.masterQueueKey(0);
+
+        const timestamp = Date.now();
+        const storedMessage: StoredMessage<TestPayload> = {
+          id: "legacy-msg-1",
+          queueId,
+          tenantId: "t1",
+          payload: { value: "legacy" },
+          timestamp,
+          attempt: 1,
+        };
+
+        // Write to per-queue storage and old master queue (simulating pre-deploy)
+        await redis.zadd(queueKey, timestamp, "legacy-msg-1");
+        await redis.hset(queueItemsKey, "legacy-msg-1", JSON.stringify(storedMessage));
+        await redis.zadd(masterQueueKey, timestamp, queueId);
+
+        // Now create FairQueue (post-deploy)
+        const helper = new TestHelper(redisOptions, keys);
+
+        // Also enqueue a new message (goes to dispatch only)
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t2:queue:new",
+          tenantId: "t2",
+          payload: { value: "new" },
+        });
+
+        // Verify: old message in master queue, new message in dispatch
+        const masterMembers = await redis.zrange(masterQueueKey, 0, -1);
+        expect(masterMembers).toContain(queueId);
+        const dispatchMembers = await redis.zrange(keys.dispatchKey(0), 0, -1);
+        expect(dispatchMembers).toContain("t2");
+
+        // Process both messages
+        helper.onMessage(async (ctx) => {
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+        });
+        helper.start();
+
+        // Both messages should be processed (legacy from drain + new from dispatch)
+        await waitFor(() => processed.length === 2, 10000);
+        expect(processed).toContain("legacy");
+        expect(processed).toContain("new");
+
+        // Old master queue should be empty after drain
+        const masterAfter = await redis.zcard(masterQueueKey);
+        expect(masterAfter).toBe(0);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should not re-populate legacy master queue when completing messages",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+
+        // Simulate pre-deploy state: queue with 2 messages in old master queue
+        const queueId = "tenant:t1:queue:legacy-noreinsert";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const masterQueueKey = keys.masterQueueKey(0);
+        const timestamp = Date.now();
+
+        for (let i = 0; i < 2; i++) {
+          const msg: StoredMessage<TestPayload> = {
+            id: `legacy-msg-${i}`,
+            queueId,
+            tenantId: "t1",
+            payload: { value: `msg-${i}` },
+            timestamp: timestamp + i,
+            attempt: 1,
+          };
+          await redis.zadd(queueKey, timestamp + i, `legacy-msg-${i}`);
+          await redis.hset(queueItemsKey, `legacy-msg-${i}`, JSON.stringify(msg));
+        }
+        await redis.zadd(masterQueueKey, timestamp, queueId);
+
+        const processed: string[] = [];
+        const helper = new TestHelper(redisOptions, keys);
+
+        helper.onMessage(async (ctx) => {
+          processed.push(ctx.message.payload.value);
+          await ctx.complete();
+
+          // After completing the first message, the queue still has 1 message
+          // The legacy master queue should NOT be re-populated
+          if (processed.length === 1) {
+            const masterCount = await redis.zcard(masterQueueKey);
+            // Should be 0 (drained) not 1 (re-added)
+            expect(masterCount).toBe(0);
+          }
+        });
+        helper.start();
+
+        await waitFor(() => processed.length === 2, 10000);
+        expect(processed).toHaveLength(2);
+
+        // Final check: master queue should be completely empty
+        const masterFinal = await redis.zcard(masterQueueKey);
+        expect(masterFinal).toBe(0);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("DRR selectQueuesFromDispatch", () => {
+    redisTest(
+      "should select tenants from dispatch with DRR fairness",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const processed: Array<{ tenantId: string; value: string }> = [];
+
+        const helper = new TestHelper(redisOptions, keys, { concurrencyLimit: 100 });
+
+        // Enqueue messages for multiple tenants
+        for (let i = 0; i < 5; i++) {
+          await helper.fairQueue.enqueue({
+            queueId: `tenant:t1:queue:q${i}`,
+            tenantId: "t1",
+            payload: { value: `t1-${i}` },
+          });
+        }
+        for (let i = 0; i < 5; i++) {
+          await helper.fairQueue.enqueue({
+            queueId: `tenant:t2:queue:q${i}`,
+            tenantId: "t2",
+            payload: { value: `t2-${i}` },
+          });
+        }
+
+        // Process all messages
+        helper.onMessage(async (ctx) => {
+          const tenantId = ctx.message.queueId.split(":")[1]!;
+          processed.push({ tenantId, value: ctx.message.payload.value });
+          await ctx.complete();
+        });
+        helper.start();
+
+        await waitFor(() => processed.length === 10, 10000);
+
+        // Both tenants should have been processed
+        const t1Count = processed.filter((p) => p.tenantId === "t1").length;
+        const t2Count = processed.filter((p) => p.tenantId === "t2").length;
+        expect(t1Count).toBe(5);
+        expect(t2Count).toBe(5);
+
+        await helper.close();
+      }
+    );
+  });
+
+  describe("DRR fairness across iterations", () => {
+    redisTest(
+      "should distribute processing fairly and not starve any tenant",
+      { timeout: 30000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const processed: Array<{ tenantId: string; order: number }> = [];
+        let processOrder = 0;
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 5,
+          maxDeficit: 20,
+        });
+
+        const fairQueue = new FairQueue({
+          redis: redisOptions,
+          keys,
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerIntervalMs: 10,
+          startConsumers: false,
+          workerQueue: { resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID },
+          concurrencyGroups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async () => 100, // High limit so concurrency doesn't interfere
+              defaultLimit: 100,
+            },
+          ],
+        });
+
+        const workerQueueManager = new WorkerQueueManager({
+          redis: redisOptions,
+          keys,
+        });
+
+        // Scenario: 3 tenants with very different queue counts
+        // t1: 50 queues (heavy hitter)
+        // t2: 5 queues (medium)
+        // t3: 1 queue with 5 messages (small)
+        // All should get fair service - no tenant should be starved.
+
+        for (let i = 0; i < 50; i++) {
+          await fairQueue.enqueue({
+            queueId: `tenant:t1:queue:q${i}`,
+            tenantId: "t1",
+            payload: { value: `t1-${i}` },
+          });
+        }
+
+        for (let i = 0; i < 5; i++) {
+          await fairQueue.enqueue({
+            queueId: `tenant:t2:queue:q${i}`,
+            tenantId: "t2",
+            payload: { value: `t2-${i}` },
+          });
+        }
+
+        for (let i = 0; i < 5; i++) {
+          await fairQueue.enqueue({
+            queueId: "tenant:t3:queue:q0",
+            tenantId: "t3",
+            payload: { value: `t3-${i}` },
+          });
+        }
+
+        // Start processing
+        fairQueue.start();
+        const abortController = new AbortController();
+
+        const consumerLoop = (async () => {
+          while (!abortController.signal.aborted) {
+            try {
+              const messageKey = await workerQueueManager.blockingPop(
+                TEST_WORKER_QUEUE_ID,
+                1,
+                abortController.signal
+              );
+              if (!messageKey) continue;
+
+              const colonIndex = messageKey.indexOf(":");
+              if (colonIndex === -1) continue;
+
+              const messageId = messageKey.substring(0, colonIndex);
+              const queueId = messageKey.substring(colonIndex + 1);
+              const storedMessage = await fairQueue.getMessageData(messageId, queueId);
+              if (!storedMessage) continue;
+
+              processed.push({ tenantId: storedMessage.tenantId, order: processOrder++ });
+              await fairQueue.completeMessage(messageId, queueId);
+            } catch {
+              if (abortController.signal.aborted) break;
+            }
+          }
+        })();
+
+        // Wait for all 60 messages to be processed
+        await waitFor(() => processed.length === 60, 20000);
+
+        // === Fairness assertions ===
+
+        const t1 = processed.filter((p) => p.tenantId === "t1");
+        const t2 = processed.filter((p) => p.tenantId === "t2");
+        const t3 = processed.filter((p) => p.tenantId === "t3");
+
+        // All messages processed
+        expect(t1.length).toBe(50);
+        expect(t2.length).toBe(5);
+        expect(t3.length).toBe(5);
+
+        // No tenant should be starved: every tenant should have at least one
+        // message processed in the first 20 messages. With quantum=5 and 3 tenants,
+        // each should get a turn within the first few iterations.
+        const first20 = processed.slice(0, 20);
+        const tenantsInFirst20 = new Set(first20.map((p) => p.tenantId));
+        expect(tenantsInFirst20.size).toBe(3);
+
+        // t2 and t3 should finish well before t1 (they have fewer messages).
+        // Check that t2's last message is processed before t1's last message.
+        const t2LastOrder = Math.max(...t2.map((p) => p.order));
+        const t1LastOrder = Math.max(...t1.map((p) => p.order));
+        expect(t2LastOrder).toBeLessThan(t1LastOrder);
+
+        // t3 should also finish before t1
+        const t3LastOrder = Math.max(...t3.map((p) => p.order));
+        expect(t3LastOrder).toBeLessThan(t1LastOrder);
+
+        // Check that t1 doesn't monopolize early processing.
+        // In the first 15 messages, t1 should have at most 10 (with quantum=5,
+        // t1 gets ~5 per round, and there are 3 tenants taking turns).
+        const t1InFirst15 = processed.slice(0, 15).filter((p) => p.tenantId === "t1").length;
+        expect(t1InFirst15).toBeLessThanOrEqual(10);
+
+        // Clean up
+        abortController.abort();
+        await Promise.allSettled([consumerLoop]);
+        await fairQueue.close();
+        await workerQueueManager.close();
+      }
+    );
+  });
+
+  describe("noisy neighbor isolation", () => {
+    redisTest(
+      "should not block other tenants when one tenant is at capacity",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const processed: Array<{ tenantId: string; value: string }> = [];
+        let blockT1 = true;
+
+        const scheduler = new DRRScheduler({
+          redis: redisOptions,
+          keys,
+          quantum: 10,
+          maxDeficit: 100,
+        });
+
+        const fairQueue = new FairQueue({
+          redis: redisOptions,
+          keys,
+          scheduler,
+          payloadSchema: TestPayloadSchema,
+          shardCount: 1,
+          consumerIntervalMs: 20,
+          startConsumers: false,
+          workerQueue: { resolveWorkerQueue: () => TEST_WORKER_QUEUE_ID },
+          concurrencyGroups: [
+            {
+              name: "tenant",
+              extractGroupId: (q) => q.tenantId,
+              getLimit: async (tenantId) => {
+                // t1 has very low concurrency, t2 has high
+                return tenantId === "t1" ? 1 : 100;
+              },
+              defaultLimit: 10,
+            },
+          ],
+        });
+
+        const workerQueueManager = new WorkerQueueManager({
+          redis: redisOptions,
+          keys,
+        });
+
+        // Enqueue 20 messages for t1 (noisy neighbor with concurrency 1)
+        for (let i = 0; i < 20; i++) {
+          await fairQueue.enqueue({
+            queueId: `tenant:t1:queue:q${i}`,
+            tenantId: "t1",
+            payload: { value: `t1-${i}` },
+          });
+        }
+
+        // Enqueue 3 messages for t2 (quiet tenant with high concurrency)
+        for (let i = 0; i < 3; i++) {
+          await fairQueue.enqueue({
+            queueId: `tenant:t2:queue:q${i}`,
+            tenantId: "t2",
+            payload: { value: `t2-${i}` },
+          });
+        }
+
+        // Start processing
+        fairQueue.start();
+        const abortController = new AbortController();
+
+        const consumerLoop = (async () => {
+          while (!abortController.signal.aborted) {
+            try {
+              const messageKey = await workerQueueManager.blockingPop(
+                TEST_WORKER_QUEUE_ID,
+                1,
+                abortController.signal
+              );
+              if (!messageKey) continue;
+
+              const colonIndex = messageKey.indexOf(":");
+              if (colonIndex === -1) continue;
+
+              const messageId = messageKey.substring(0, colonIndex);
+              const queueId = messageKey.substring(colonIndex + 1);
+              const storedMessage = await fairQueue.getMessageData(messageId, queueId);
+              if (!storedMessage) continue;
+
+              const tenantId = storedMessage.tenantId;
+              processed.push({ tenantId, value: storedMessage.payload.value });
+              await fairQueue.completeMessage(messageId, queueId);
+            } catch {
+              if (abortController.signal.aborted) break;
+            }
+          }
+        })();
+
+        // Wait for t2's messages to be processed (they shouldn't be blocked by t1)
+        await waitFor(
+          () => processed.filter((p) => p.tenantId === "t2").length === 3,
+          10000
+        );
+
+        const t2ProcessedCount = processed.filter((p) => p.tenantId === "t2").length;
+        expect(t2ProcessedCount).toBe(3);
+
+        // Clean up
+        abortController.abort();
+        await Promise.allSettled([consumerLoop]);
+        await fairQueue.close();
+        await workerQueueManager.close();
+      }
+    );
+  });
+  describe("release updates dispatch indexes", () => {
+    redisTest(
+      "should update dispatch indexes when message is released for retry",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const attempts: number[] = [];
+
+        const helper = new TestHelper(redisOptions, keys, {
+          retry: { maxAttempts: 3, delayMs: 100 },
+        });
+
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "retry-me" },
+        });
+
+        helper.onMessage(async (ctx) => {
+          attempts.push(ctx.message.attempt);
+          if (ctx.message.attempt < 2) {
+            // Fail on first attempt to trigger retry
+            await ctx.fail(new Error("transient error"));
+          } else {
+            await ctx.complete();
+          }
+        });
+        helper.start();
+
+        // Wait for successful processing on second attempt
+        await waitFor(() => attempts.length >= 2 && attempts.includes(2), 10000);
+
+        // After retry, the message went back into the queue via releaseMessage Lua.
+        // Verify it was picked up again (attempt 2 processed).
+        expect(attempts).toContain(1);
+        expect(attempts).toContain(2);
+
+        // After completion, dispatch indexes should be cleaned up
+        await waitFor(async () => {
+          const t1Queues = await redis.zcard(keys.tenantQueueIndexKey("t1"));
+          return t1Queues === 0;
+        }, 5000);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("reclaim updates dispatch indexes", () => {
+    redisTest(
+      "should update dispatch indexes when timed-out message is reclaimed",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const processCount = { count: 0 };
+
+        const helper = new TestHelper(redisOptions, keys, {
+          visibilityTimeoutMs: 500,
+          reclaimIntervalMs: 200,
+        });
+
+        await helper.fairQueue.enqueue({
+          queueId: "tenant:t1:queue:q1",
+          tenantId: "t1",
+          payload: { value: "reclaim-me" },
+        });
+
+        helper.onMessage(async (ctx) => {
+          processCount.count++;
+          if (processCount.count === 1) {
+            // First attempt: don't complete, let it timeout and get reclaimed
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+          } else {
+            // Second attempt after reclaim: complete normally
+            await ctx.complete();
+          }
+        });
+        helper.start();
+
+        // Wait for message to be processed twice (once timeout, once success)
+        await waitFor(() => processCount.count >= 2, 10000);
+
+        // After reclaim + re-processing + completion, indexes should be clean
+        await waitFor(async () => {
+          const t1Queues = await redis.zcard(keys.tenantQueueIndexKey("t1"));
+          return t1Queues === 0;
+        }, 5000);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("legacy message migration via reclaim", () => {
+    redisTest(
+      "should migrate legacy master queue message to dispatch index on reclaim",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const processed: string[] = [];
+
+        // Simulate pre-deploy: write message to old master queue + queue storage
+        const queueId = "tenant:t1:queue:legacy";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const masterQueueKey = keys.masterQueueKey(0);
+
+        const timestamp = Date.now();
+        const storedMessage: StoredMessage<TestPayload> = {
+          id: "legacy-reclaim-1",
+          queueId,
+          tenantId: "t1",
+          payload: { value: "legacy-reclaim" },
+          timestamp,
+          attempt: 1,
+        };
+
+        await redis.zadd(queueKey, timestamp, "legacy-reclaim-1");
+        await redis.hset(queueItemsKey, "legacy-reclaim-1", JSON.stringify(storedMessage));
+        await redis.zadd(masterQueueKey, timestamp, queueId);
+
+        // Verify: message only in old master queue, not in dispatch
+        expect(await redis.zcard(keys.dispatchKey(0))).toBe(0);
+        expect(await redis.zcard(keys.tenantQueueIndexKey("t1"))).toBe(0);
+
+        // Create FairQueue with short visibility timeout
+        const helper = new TestHelper(redisOptions, keys, {
+          visibilityTimeoutMs: 500,
+          reclaimIntervalMs: 200,
+        });
+
+        const processCount = { count: 0 };
+        helper.onMessage(async (ctx) => {
+          processCount.count++;
+          if (processCount.count === 1) {
+            // First attempt: don't complete, let it timeout
+            // The reclaim will put it back in queue and update dispatch indexes
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+          } else {
+            // Second attempt: complete
+            processed.push(ctx.message.payload.value);
+            await ctx.complete();
+          }
+        });
+        helper.start();
+
+        // Wait for the message to be processed (first via drain, then reclaimed into dispatch)
+        await waitFor(() => processed.length === 1, 15000);
+        expect(processed[0]).toBe("legacy-reclaim");
+
+        // After completion, both old and new indexes should be clean
+        const masterAfter = await redis.zcard(masterQueueKey);
+        const dispatchAfter = await redis.zcard(keys.dispatchKey(0));
+        const tenantQueuesAfter = await redis.zcard(keys.tenantQueueIndexKey("t1"));
+
+        // Old master queue should still be empty (drain removed it)
+        // or at least the queue itself should be gone
+        expect(tenantQueuesAfter).toBe(0);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should migrate legacy message to dispatch index on retry failure",
+      { timeout: 20000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const attempts: number[] = [];
+
+        // Simulate pre-deploy: write message to old master queue
+        const queueId = "tenant:t1:queue:legacy";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const masterQueueKey = keys.masterQueueKey(0);
+
+        const timestamp = Date.now();
+        const storedMessage: StoredMessage<TestPayload> = {
+          id: "legacy-retry-1",
+          queueId,
+          tenantId: "t1",
+          payload: { value: "legacy-retry" },
+          timestamp,
+          attempt: 1,
+        };
+
+        await redis.zadd(queueKey, timestamp, "legacy-retry-1");
+        await redis.hset(queueItemsKey, "legacy-retry-1", JSON.stringify(storedMessage));
+        await redis.zadd(masterQueueKey, timestamp, queueId);
+
+        // Create FairQueue with retry enabled
+        const helper = new TestHelper(redisOptions, keys, {
+          retry: { maxAttempts: 3, delayMs: 100 },
+        });
+
+        helper.onMessage(async (ctx) => {
+          attempts.push(ctx.message.attempt);
+          if (ctx.message.attempt < 2) {
+            // Fail first attempt — triggers retry which writes to dispatch index
+            await ctx.fail(new Error("transient"));
+          } else {
+            await ctx.complete();
+          }
+        });
+        helper.start();
+
+        // Wait for retry to complete
+        await waitFor(() => attempts.includes(2), 10000);
+
+        // The retry release should have written to dispatch indexes.
+        // After completion, indexes should be clean.
+        await waitFor(async () => {
+          const t1Queues = await redis.zcard(keys.tenantQueueIndexKey("t1"));
+          return t1Queues === 0;
+        }, 5000);
+
+        expect(attempts).toContain(1);
+        expect(attempts).toContain(2);
+
+        await helper.close();
+        await redis.quit();
+      }
+    );
+  });
+  describe("dispatch shard is tenant-based, not queue-based", () => {
+    redisTest(
+      "tenant with queues in different queue shards should appear in only one dispatch shard",
+      { timeout: 15000 },
+      async ({ redisOptions }) => {
+        const keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+        const redis = createRedisClient(redisOptions);
+        const shardCount = 2;
+
+        const helper = new TestHelper(redisOptions, keys, { shardCount });
+
+        try {
+          const tenantId = "tenant-shard-test";
+
+          // Find two queue IDs for the same tenant that hash to different queue shards
+          // by trying different queue names
+          const { MasterQueue: MQ } = await import("../masterQueue.js");
+          const mq = new MQ({ redis: redisOptions, keys, shardCount });
+          const { TenantDispatch: TD } = await import("../tenantDispatch.js");
+          const td = new TD({ redis: redisOptions, keys, shardCount });
+
+          let queueShard0: string | null = null;
+          let queueShard1: string | null = null;
+
+          for (let i = 0; i < 100; i++) {
+            const qId = `tenant:${tenantId}:queue:q${i}`;
+            const shard = mq.getShardForQueue(qId);
+            if (shard === 0 && !queueShard0) queueShard0 = qId;
+            if (shard === 1 && !queueShard1) queueShard1 = qId;
+            if (queueShard0 && queueShard1) break;
+          }
+
+          expect(queueShard0).not.toBeNull();
+          expect(queueShard1).not.toBeNull();
+
+          // Both queues belong to the same tenant, so dispatch shard should be the same
+          const expectedDispatchShard = td.getShardForTenant(tenantId);
+
+          // Enqueue to both queues
+          await helper.fairQueue.enqueue({
+            queueId: queueShard0!,
+            tenantId,
+            payload: { value: "msg-shard0" },
+          });
+          await helper.fairQueue.enqueue({
+            queueId: queueShard1!,
+            tenantId,
+            payload: { value: "msg-shard1" },
+          });
+
+          // Verify: tenant should only appear in one dispatch shard
+          const dispatch0 = await redis.zrange(keys.dispatchKey(0), 0, -1);
+          const dispatch1 = await redis.zrange(keys.dispatchKey(1), 0, -1);
+
+          const inShard0 = dispatch0.includes(tenantId);
+          const inShard1 = dispatch1.includes(tenantId);
+
+          // Tenant should appear in exactly one shard
+          expect(inShard0 !== inShard1).toBe(true);
+
+          // And it should be the expected one
+          if (expectedDispatchShard === 0) {
+            expect(inShard0).toBe(true);
+            expect(inShard1).toBe(false);
+          } else {
+            expect(inShard0).toBe(false);
+            expect(inShard1).toBe(true);
+          }
+
+          await mq.close();
+          await td.close();
+        } finally {
+          await helper.close();
+          await redis.quit();
+        }
+      }
+    );
+  });
+});
+
+// Helper to wait for a condition
+async function waitFor(
+  condition: () => boolean | Promise<boolean>,
+  timeoutMs: number = 5000,
+  intervalMs: number = 50
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const result = await condition();
+    if (result) return;
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error(`waitFor timed out after ${timeoutMs}ms`);
+}
diff --git a/packages/redis-worker/src/fair-queue/tests/visibility.test.ts b/packages/redis-worker/src/fair-queue/tests/visibility.test.ts
index 42cb8f2a155..2ecdeb41e90 100644
--- a/packages/redis-worker/src/fair-queue/tests/visibility.test.ts
+++ b/packages/redis-worker/src/fair-queue/tests/visibility.test.ts
@@ -2,7 +2,7 @@ import { describe, expect } from "vitest";
 import { redisTest } from "@internal/testcontainers";
 import { createRedisClient } from "@internal/redis";
 import { VisibilityManager, DefaultFairQueueKeyProducer } from "../index.js";
-import type { FairQueueKeyProducer } from "../types.js";
+import type { FairQueueKeyProducer, ReclaimedMessageInfo } from "../types.js";
 
 describe("VisibilityManager", () => {
   let keys: FairQueueKeyProducer;
@@ -244,5 +244,628 @@ describe("VisibilityManager", () => {
       }
     );
   });
+
+  describe("claimBatch", () => {
+    redisTest(
+      "should claim multiple messages atomically",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:claim-batch";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+
+        // Add multiple messages to the queue
+        for (let i = 1; i <= 5; i++) {
+          const messageId = `msg-${i}`;
+          const storedMessage = {
+            id: messageId,
+            queueId,
+            tenantId: "t1",
+            payload: { value: `test-${i}` },
+            timestamp: Date.now() - (6 - i) * 1000,
+            attempt: 1,
+          };
+          await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+          await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+        }
+
+        // Claim batch of 3 messages
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 3);
+
+        expect(claimed).toHaveLength(3);
+        expect(claimed[0]!.messageId).toBe("msg-1");
+        expect(claimed[1]!.messageId).toBe("msg-2");
+        expect(claimed[2]!.messageId).toBe("msg-3");
+
+        // Verify messages are in in-flight set
+        const inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(3);
+
+        // Verify messages are removed from queue
+        const remainingCount = await redis.zcard(queueKey);
+        expect(remainingCount).toBe(2);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should return empty array when queue is empty",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const queueId = "tenant:t1:queue:empty";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 5);
+        expect(claimed).toHaveLength(0);
+
+        await manager.close();
+      }
+    );
+
+    redisTest(
+      "should claim all available messages when queue has fewer than maxCount",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:partial-batch";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+
+        // Add only 3 messages to the queue
+        for (let i = 1; i <= 3; i++) {
+          const messageId = `msg-${i}`;
+          const storedMessage = {
+            id: messageId,
+            queueId,
+            tenantId: "t1",
+            payload: { value: `test-${i}` },
+            timestamp: Date.now() - (4 - i) * 1000,
+            attempt: 1,
+          };
+          await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+          await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+        }
+
+        // Request 10 messages but only 3 exist
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 10);
+
+        expect(claimed).toHaveLength(3);
+        expect(claimed[0]!.messageId).toBe("msg-1");
+        expect(claimed[1]!.messageId).toBe("msg-2");
+        expect(claimed[2]!.messageId).toBe("msg-3");
+
+        // Verify all messages are in in-flight set
+        const inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(3);
+
+        // Verify queue is empty
+        const remainingCount = await redis.zcard(queueKey);
+        expect(remainingCount).toBe(0);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should skip corrupted messages and continue claiming valid ones",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:corrupted-batch";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+
+        // Add valid message 1
+        const storedMessage1 = {
+          id: "msg-1",
+          queueId,
+          tenantId: "t1",
+          payload: { value: "test-1" },
+          timestamp: Date.now() - 3000,
+          attempt: 1,
+        };
+        await redis.zadd(queueKey, storedMessage1.timestamp, "msg-1");
+        await redis.hset(queueItemsKey, "msg-1", JSON.stringify(storedMessage1));
+
+        // Add corrupted message 2 (invalid JSON)
+        await redis.zadd(queueKey, Date.now() - 2000, "msg-2");
+        await redis.hset(queueItemsKey, "msg-2", "not-valid-json{{{");
+
+        // Add valid message 3
+        const storedMessage3 = {
+          id: "msg-3",
+          queueId,
+          tenantId: "t1",
+          payload: { value: "test-3" },
+          timestamp: Date.now() - 1000,
+          attempt: 1,
+        };
+        await redis.zadd(queueKey, storedMessage3.timestamp, "msg-3");
+        await redis.hset(queueItemsKey, "msg-3", JSON.stringify(storedMessage3));
+
+        // Claim all 3 messages
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 5);
+
+        // Should only return the 2 valid messages
+        expect(claimed).toHaveLength(2);
+        expect(claimed[0]!.messageId).toBe("msg-1");
+        expect(claimed[1]!.messageId).toBe("msg-3");
+
+        // Corrupted message should have been removed from in-flight
+        // Valid messages should be in in-flight
+        const inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(2);
+
+        // Queue should be empty (all messages processed or removed)
+        const remainingCount = await redis.zcard(queueKey);
+        expect(remainingCount).toBe(0);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("releaseBatch", () => {
+    redisTest(
+      "should release multiple messages back to queue atomically",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:release-batch";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Add messages to queue and claim them
+        for (let i = 1; i <= 5; i++) {
+          const messageId = `msg-${i}`;
+          const storedMessage = {
+            id: messageId,
+            queueId,
+            tenantId: "t1",
+            payload: { value: `test-${i}` },
+            timestamp: Date.now() - (6 - i) * 1000,
+            attempt: 1,
+          };
+          await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+          await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+        }
+
+        // Claim all 5 messages
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 5);
+        expect(claimed).toHaveLength(5);
+
+        // Verify all messages are in-flight
+        let inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(5);
+
+        // Queue should be empty
+        let queueCount = await redis.zcard(queueKey);
+        expect(queueCount).toBe(0);
+
+        // Release messages 3, 4, 5 back to queue (batch release)
+        const messagesToRelease = claimed.slice(2);
+        await manager.releaseBatch(
+          messagesToRelease,
+          queueId,
+          queueKey,
+          queueItemsKey,
+          tenantQueueIndexKey,
+          dispatchKey,
+          "t1"
+        );
+
+        // Verify 2 messages still in-flight
+        inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(2);
+
+        // Verify 3 messages back in queue
+        queueCount = await redis.zcard(queueKey);
+        expect(queueCount).toBe(3);
+
+        // Verify the correct messages are back in queue
+        const queueMembers = await redis.zrange(queueKey, 0, -1);
+        expect(queueMembers).toContain("msg-3");
+        expect(queueMembers).toContain("msg-4");
+        expect(queueMembers).toContain("msg-5");
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should handle empty messages array",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const queueId = "tenant:t1:queue:empty-release";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Should not throw when releasing empty array
+        await manager.releaseBatch([], queueId, queueKey, queueItemsKey, tenantQueueIndexKey, dispatchKey, "t1");
+
+        await manager.close();
+      }
+    );
+
+    redisTest(
+      "should update dispatch indexes with oldest message timestamp",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 5000,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:dispatch-update";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Add and claim messages
+        const baseTime = Date.now();
+        for (let i = 1; i <= 3; i++) {
+          const messageId = `msg-${i}`;
+          const storedMessage = {
+            id: messageId,
+            queueId,
+            tenantId: "t1",
+            payload: { value: `test-${i}` },
+            timestamp: baseTime + i * 1000, // Different timestamps
+            attempt: 1,
+          };
+          await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+          await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+        }
+
+        const claimed = await manager.claimBatch(queueId, queueKey, queueItemsKey, "consumer-1", 3);
+
+        // Release all messages back
+        await manager.releaseBatch(claimed, queueId, queueKey, queueItemsKey, tenantQueueIndexKey, dispatchKey, "t1");
+
+        // Tenant queue index should have the queue with correct score
+        const tenantQueueScore = await redis.zscore(tenantQueueIndexKey, queueId);
+        expect(tenantQueueScore).not.toBeNull();
+
+        // Dispatch index should have the tenant
+        const dispatchScore = await redis.zscore(dispatchKey, "t1");
+        expect(dispatchScore).not.toBeNull();
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+  });
+
+  describe("reclaimTimedOut", () => {
+    redisTest(
+      "should return reclaimed message info with tenantId for concurrency release",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 100, // Very short timeout
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:reclaim-test";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Add and claim a message
+        const messageId = "reclaim-msg";
+        const storedMessage = {
+          id: messageId,
+          queueId,
+          tenantId: "t1",
+          payload: { id: 1, value: "test" },
+          timestamp: Date.now() - 1000,
+          attempt: 1,
+          metadata: { orgId: "org-123" },
+        };
+
+        await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+        await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+
+        // Claim with very short timeout
+        const claimResult = await manager.claim(queueId, queueKey, queueItemsKey, "consumer-1", 100);
+        expect(claimResult.claimed).toBe(true);
+
+        // Wait for timeout to expire
+        await new Promise((resolve) => setTimeout(resolve, 150));
+
+        // Reclaim should return the message info
+        const reclaimedMessages = await manager.reclaimTimedOut(0, (qId) => ({
+          queueKey: keys.queueKey(qId),
+          queueItemsKey: keys.queueItemsKey(qId),
+          tenantQueueIndexKey: keys.tenantQueueIndexKey(keys.extractTenantId(qId)),
+          dispatchKey,
+          tenantId: keys.extractTenantId(qId),
+        }));
+
+        expect(reclaimedMessages).toHaveLength(1);
+        expect(reclaimedMessages[0]).toEqual({
+          messageId,
+          queueId,
+          tenantId: "t1",
+          metadata: { orgId: "org-123" },
+        });
+
+        // Verify message is back in queue
+        const queueCount = await redis.zcard(queueKey);
+        expect(queueCount).toBe(1);
+
+        // Verify message is back in queue with its original timestamp (not the deadline)
+        const queueMessages = await redis.zrange(queueKey, 0, -1, "WITHSCORES");
+        expect(queueMessages[0]).toBe(messageId);
+        expect(parseInt(queueMessages[1]!)).toBe(storedMessage.timestamp);
+
+        // Verify message is no longer in-flight
+        const inflightCount = await manager.getTotalInflightCount();
+        expect(inflightCount).toBe(0);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should return empty array when no messages have timed out",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 60000, // Long timeout
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:no-timeout";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Add and claim a message with long timeout
+        const messageId = "long-timeout-msg";
+        const storedMessage = {
+          id: messageId,
+          queueId,
+          tenantId: "t1",
+          payload: { id: 1 },
+          timestamp: Date.now() - 1000,
+          attempt: 1,
+        };
+
+        await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+        await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+
+        await manager.claim(queueId, queueKey, queueItemsKey, "consumer-1");
+
+        // Reclaim should return empty array (message hasn't timed out)
+        const reclaimedMessages = await manager.reclaimTimedOut(0, (qId) => ({
+          queueKey: keys.queueKey(qId),
+          queueItemsKey: keys.queueItemsKey(qId),
+          tenantQueueIndexKey: keys.tenantQueueIndexKey(keys.extractTenantId(qId)),
+          dispatchKey,
+          tenantId: keys.extractTenantId(qId),
+        }));
+
+        expect(reclaimedMessages).toHaveLength(0);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should reclaim multiple timed-out messages and return all their info",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 100,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+
+        // Add and claim messages for two different tenants
+        for (const tenant of ["t1", "t2"]) {
+          const queueId = `tenant:${tenant}:queue:multi-reclaim`;
+          const queueKey = keys.queueKey(queueId);
+          const queueItemsKey = keys.queueItemsKey(queueId);
+
+          const messageId = `msg-${tenant}`;
+          const storedMessage = {
+            id: messageId,
+            queueId,
+            tenantId: tenant,
+            payload: { id: 1 },
+            timestamp: Date.now() - 1000,
+            attempt: 1,
+          };
+
+          await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+          await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+
+          await manager.claim(queueId, queueKey, queueItemsKey, "consumer-1", 100);
+        }
+
+        // Wait for timeout
+        await new Promise((resolve) => setTimeout(resolve, 150));
+
+        // Reclaim should return both messages
+        const reclaimedMessages = await manager.reclaimTimedOut(0, (qId) => ({
+          queueKey: keys.queueKey(qId),
+          queueItemsKey: keys.queueItemsKey(qId),
+          tenantQueueIndexKey: keys.tenantQueueIndexKey(keys.extractTenantId(qId)),
+          dispatchKey,
+          tenantId: keys.extractTenantId(qId),
+        }));
+
+        expect(reclaimedMessages).toHaveLength(2);
+
+        // Verify both tenants are represented
+        const tenantIds = reclaimedMessages.map((m: ReclaimedMessageInfo) => m.tenantId).sort();
+        expect(tenantIds).toEqual(["t1", "t2"]);
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+
+    redisTest(
+      "should use fallback tenantId extraction when message data is missing or corrupted",
+      { timeout: 10000 },
+      async ({ redisOptions }) => {
+        keys = new DefaultFairQueueKeyProducer({ prefix: "test" });
+
+        const manager = new VisibilityManager({
+          redis: redisOptions,
+          keys,
+          shardCount: 1,
+          defaultTimeoutMs: 100,
+        });
+
+        const redis = createRedisClient(redisOptions);
+        const queueId = "tenant:t1:queue:fallback-test";
+        const queueKey = keys.queueKey(queueId);
+        const queueItemsKey = keys.queueItemsKey(queueId);
+        const tenantQueueIndexKey = keys.tenantQueueIndexKey("t1");
+        const dispatchKey = keys.dispatchKey(0);
+        const inflightDataKey = keys.inflightDataKey(0);
+
+        // Add and claim a message
+        const messageId = "fallback-msg";
+        const storedMessage = {
+          id: messageId,
+          queueId,
+          tenantId: "t1",
+          payload: { id: 1 },
+          timestamp: Date.now() - 1000,
+          attempt: 1,
+          metadata: { orgId: "org-123" },
+        };
+
+        await redis.zadd(queueKey, storedMessage.timestamp, messageId);
+        await redis.hset(queueItemsKey, messageId, JSON.stringify(storedMessage));
+
+        // Claim the message
+        const claimResult = await manager.claim(queueId, queueKey, queueItemsKey, "consumer-1", 100);
+        expect(claimResult.claimed).toBe(true);
+
+        // Corrupt the in-flight data by setting invalid JSON
+        await redis.hset(inflightDataKey, messageId, "not-valid-json{{{");
+
+        // Wait for timeout
+        await new Promise((resolve) => setTimeout(resolve, 150));
+
+        // Reclaim should still work using fallback extraction
+        const reclaimedMessages = await manager.reclaimTimedOut(0, (qId) => ({
+          queueKey: keys.queueKey(qId),
+          queueItemsKey: keys.queueItemsKey(qId),
+          tenantQueueIndexKey: keys.tenantQueueIndexKey(keys.extractTenantId(qId)),
+          dispatchKey,
+          tenantId: keys.extractTenantId(qId),
+        }));
+
+        expect(reclaimedMessages).toHaveLength(1);
+        expect(reclaimedMessages[0]).toEqual({
+          messageId,
+          queueId,
+          tenantId: "t1", // Extracted from queueId via fallback
+          metadata: {}, // Empty metadata since we couldn't parse the stored message
+        });
+
+        await manager.close();
+        await redis.quit();
+      }
+    );
+  });
 });
 
diff --git a/packages/redis-worker/src/fair-queue/types.ts b/packages/redis-worker/src/fair-queue/types.ts
index 107d82dbcb6..3bc56b599fa 100644
--- a/packages/redis-worker/src/fair-queue/types.ts
+++ b/packages/redis-worker/src/fair-queue/types.ts
@@ -133,6 +133,25 @@ export interface ConcurrencyCheckResult {
   blockedBy?: ConcurrencyState;
 }
 
+// ============================================================================
+// Visibility Types
+// ============================================================================
+
+/**
+ * Information about a reclaimed message from visibility timeout.
+ * Used to release concurrency after a message is returned to the queue.
+ */
+export interface ReclaimedMessageInfo {
+  /** Message ID */
+  messageId: string;
+  /** Queue ID */
+  queueId: string;
+  /** Tenant ID for concurrency release */
+  tenantId: string;
+  /** Additional metadata for concurrency group extraction */
+  metadata?: Record<string, unknown>;
+}
+
 // ============================================================================
 // Scheduler Types
 // ============================================================================
@@ -161,6 +180,14 @@ export interface SchedulerContext {
   getQueueDescriptor(queueId: string): QueueDescriptor;
 }
 
+/**
+ * Extended context for two-level dispatch scheduling.
+ */
+export interface DispatchSchedulerContext extends SchedulerContext {
+  /** Get queues for a specific tenant from the per-tenant queue index (Level 2) */
+  getQueuesForTenant(tenantId: string, limit?: number): Promise<QueueWithScore[]>;
+}
+
 /**
  * Pluggable scheduler interface for fair queue selection.
  */
@@ -180,12 +207,31 @@ export interface FairScheduler {
     context: SchedulerContext
   ): Promise<TenantQueues[]>;
 
+  /**
+   * Select queues using the two-level tenant dispatch index.
+   * Level 1: reads tenantIds from dispatch shard.
+   * Level 2: reads queueIds from per-tenant index.
+   * Optional - falls back to selectQueues with flat queue list if not implemented.
+   */
+  selectQueuesFromDispatch?(
+    dispatchShardKey: string,
+    consumerId: string,
+    context: DispatchSchedulerContext
+  ): Promise<TenantQueues[]>;
+
   /**
    * Called after processing a message to update scheduler state.
    * Optional - not all schedulers need to track state.
    */
   recordProcessed?(tenantId: string, queueId: string): Promise<void>;
 
+  /**
+   * Called after processing multiple messages to update scheduler state.
+   * Batch variant for efficiency - reduces Redis calls when processing multiple messages.
+   * Optional - falls back to calling recordProcessed multiple times if not implemented.
+   */
+  recordProcessedBatch?(tenantId: string, queueId: string, count: number): Promise<void>;
+
   /**
    * Initialize the scheduler (called once on startup).
    */
@@ -266,6 +312,12 @@ export interface FairQueueKeyProducer {
   /** Get the dead letter queue data hash key for a tenant */
   deadLetterQueueDataKey(tenantId: string): string;
 
+  // Tenant dispatch keys (two-level index)
+  /** Get the dispatch index key for a shard (Level 1: tenantIds with capacity) */
+  dispatchKey(shardId: number): string;
+  /** Get the per-tenant queue index key (Level 2: queueIds for a tenant) */
+  tenantQueueIndexKey(tenantId: string): string;
+
   // Extraction methods
   /** Extract tenant ID from a queue ID */
   extractTenantId(queueId: string): string;
@@ -279,14 +331,15 @@ export interface FairQueueKeyProducer {
 
 /**
  * Worker queue configuration options.
+ * Worker queues are always enabled - FairQueue routes messages to worker queues,
+ * and external consumers are responsible for consuming from those queues.
  */
 export interface WorkerQueueOptions<TPayload = unknown> {
-  /** Whether to enable worker queues (default: false for backwards compatibility) */
-  enabled: boolean;
-  /** Blocking pop timeout in seconds (default: 10) */
-  blockingTimeoutSeconds?: number;
-  /** Function to resolve which worker queue a message should go to */
-  resolveWorkerQueue?: (message: StoredMessage<TPayload>) => string;
+  /**
+   * Function to resolve which worker queue a message should go to.
+   * This is called during the claim-and-push phase to determine the target queue.
+   */
+  resolveWorkerQueue: (message: StoredMessage<TPayload>) => string;
 }
 
 /**
@@ -309,6 +362,8 @@ export interface CooloffOptions {
   threshold?: number;
   /** Duration of cooloff period in milliseconds (default: 10000) */
   periodMs?: number;
+  /** Maximum number of cooloff state entries before triggering cleanup (default: 1000) */
+  maxStatesSize?: number;
 }
 
 /**
@@ -340,9 +395,12 @@ export interface FairQueueOptions<TPayloadSchema extends z.ZodTypeAny = z.ZodUnk
   /** Concurrency group configurations */
   concurrencyGroups?: ConcurrencyGroupConfig[];
 
-  // Worker queue
-  /** Worker queue configuration */
-  workerQueue?: WorkerQueueOptions<z.infer<TPayloadSchema>>;
+  // Worker queue (required)
+  /**
+   * Worker queue configuration.
+   * FairQueue routes messages to worker queues; external consumers handle consumption.
+   */
+  workerQueue: WorkerQueueOptions<z.infer<TPayloadSchema>>;
 
   // Retry and DLQ
   /** Retry and dead letter queue configuration */
@@ -364,6 +422,16 @@ export interface FairQueueOptions<TPayloadSchema extends z.ZodTypeAny = z.ZodUnk
   /** Whether to start consumers on initialization (default: true) */
   startConsumers?: boolean;
 
+  // Batch claiming
+  /** Maximum number of messages to claim in a single batch operation (default: 10) */
+  batchClaimSize?: number;
+
+  // Consumer tracing
+  /** Maximum iterations before starting a new trace span (default: 500) */
+  consumerTraceMaxIterations?: number;
+  /** Maximum seconds before starting a new trace span (default: 60) */
+  consumerTraceTimeoutSeconds?: number;
+
   // Cooloff
   /** Queue cooloff configuration */
   cooloff?: CooloffOptions;
@@ -378,9 +446,23 @@ export interface FairQueueOptions<TPayloadSchema extends z.ZodTypeAny = z.ZodUnk
   /** Name for metrics/tracing (default: "fairqueue") */
   name?: string;
 
-  // Global rate limiting
-  /** Optional global rate limiter to limit processing across all consumers */
-  globalRateLimiter?: GlobalRateLimiter;
+  // Worker queue backpressure
+  /**
+   * Maximum number of items allowed in a worker queue before claiming pauses.
+   * When set, the claim phase checks worker queue depth and skips claiming if
+   * the queue is at or above this limit. This prevents unbounded worker queue
+   * growth which could cause visibility timeouts (claimed messages have a
+   * visibility timeout that ticks while they sit in the worker queue).
+   * Requires `workerQueueDepthCheckId` to know which queue to check.
+   * Disabled by default (0 = no limit).
+   */
+  workerQueueMaxDepth?: number;
+  /**
+   * The worker queue ID to check depth against when workerQueueMaxDepth is set.
+   * Required when workerQueueMaxDepth > 0 and the system uses a single shared worker queue.
+   * If not set, depth checking is disabled even if workerQueueMaxDepth is set.
+   */
+  workerQueueDepthCheckId?: string;
 }
 
 // ============================================================================
@@ -503,6 +585,8 @@ export interface DRRSchedulerConfig {
   quantum: number;
   /** Maximum accumulated deficit (prevents starvation) */
   maxDeficit: number;
+  /** Maximum queues to fetch from master queue (default: 1000) */
+  masterQueueLimit?: number;
   /** Redis options for state storage */
   redis: RedisOptions;
   /** Key producer */
diff --git a/packages/redis-worker/src/fair-queue/visibility.ts b/packages/redis-worker/src/fair-queue/visibility.ts
index fb0f995db75..a182a4e790d 100644
--- a/packages/redis-worker/src/fair-queue/visibility.ts
+++ b/packages/redis-worker/src/fair-queue/visibility.ts
@@ -1,6 +1,12 @@
 import { createRedisClient, type Redis, type RedisOptions } from "@internal/redis";
 import { jumpHash } from "@trigger.dev/core/v3/serverOnly";
-import type { ClaimResult, FairQueueKeyProducer, InFlightMessage } from "./types.js";
+import type {
+  ClaimResult,
+  FairQueueKeyProducer,
+  InFlightMessage,
+  ReclaimedMessageInfo,
+  StoredMessage,
+} from "./types.js";
 
 export interface VisibilityManagerOptions {
   redis: RedisOptions;
@@ -39,8 +45,8 @@ export class VisibilityManager {
     this.shardCount = options.shardCount;
     this.defaultTimeoutMs = options.defaultTimeoutMs;
     this.logger = options.logger ?? {
-      debug: () => {},
-      error: () => {},
+      debug: () => { },
+      error: () => { },
     };
 
     this.#registerCommands();
@@ -127,6 +133,92 @@ export class VisibilityManager {
     }
   }
 
+  /**
+   * Claim multiple messages for processing (batch claim).
+   * Moves up to maxCount messages from the queue to the in-flight set.
+   *
+   * @param queueId - The queue to claim from
+   * @param queueKey - The Redis key for the queue sorted set
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param consumerId - ID of the consumer claiming the messages
+   * @param maxCount - Maximum number of messages to claim
+   * @param timeoutMs - Visibility timeout in milliseconds
+   * @returns Array of claimed messages
+   */
+  async claimBatch<TPayload = unknown>(
+    queueId: string,
+    queueKey: string,
+    queueItemsKey: string,
+    consumerId: string,
+    maxCount: number,
+    timeoutMs?: number
+  ): Promise<Array<InFlightMessage<TPayload>>> {
+    const timeout = timeoutMs ?? this.defaultTimeoutMs;
+    const deadline = Date.now() + timeout;
+    const shardId = this.#getShardForQueue(queueId);
+    const inflightKey = this.keys.inflightKey(shardId);
+    const inflightDataKey = this.keys.inflightDataKey(shardId);
+
+    // Use Lua script to atomically claim up to maxCount messages
+    const result = await this.redis.claimMessageBatch(
+      queueKey,
+      queueItemsKey,
+      inflightKey,
+      inflightDataKey,
+      queueId,
+      deadline.toString(),
+      maxCount.toString()
+    );
+
+    if (!result || result.length === 0) {
+      return [];
+    }
+
+    const messages: Array<InFlightMessage<TPayload>> = [];
+
+    // Results come in pairs: [messageId1, payload1, messageId2, payload2, ...]
+    for (let i = 0; i < result.length; i += 2) {
+      const messageId = result[i];
+      const payloadJson = result[i + 1];
+
+      // Skip if either value is missing
+      if (!messageId || !payloadJson) {
+        continue;
+      }
+
+      try {
+        const payload = JSON.parse(payloadJson) as TPayload;
+        messages.push({
+          messageId,
+          queueId,
+          payload,
+          deadline,
+          consumerId,
+        });
+      } catch (error) {
+        // JSON parse error - skip this message
+        this.logger.error("Failed to parse claimed message in batch", {
+          messageId,
+          queueId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        // Remove the corrupted message from in-flight
+        await this.#removeFromInflight(shardId, messageId, queueId);
+      }
+    }
+
+    if (messages.length > 0) {
+      this.logger.debug("Batch claimed messages", {
+        queueId,
+        consumerId,
+        count: messages.length,
+        deadline,
+      });
+    }
+
+    return messages;
+  }
+
   /**
    * Extend the visibility timeout for a message (heartbeat).
    *
@@ -143,11 +235,7 @@ export class VisibilityManager {
 
     // Use Lua script to atomically check existence and update score
     // ZADD XX returns 0 even on successful updates, so we use a custom command
-    const result = await this.redis.heartbeatMessage(
-      inflightKey,
-      member,
-      newDeadline.toString()
-    );
+    const result = await this.redis.heartbeatMessage(inflightKey, member, newDeadline.toString());
 
     const success = result === 1;
 
@@ -187,6 +275,9 @@ export class VisibilityManager {
    * @param queueId - The queue ID
    * @param queueKey - The Redis key for the queue
    * @param queueItemsKey - The Redis key for the queue items hash
+   * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
+   * @param dispatchKey - The Redis key for the dispatch index (Level 1)
+   * @param tenantId - The tenant ID
    * @param score - Optional score for the message (defaults to now)
    */
   async release<TPayload = unknown>(
@@ -194,7 +285,11 @@ export class VisibilityManager {
     queueId: string,
     queueKey: string,
     queueItemsKey: string,
-    score?: number
+    tenantQueueIndexKey: string,
+    dispatchKey: string,
+    tenantId: string,
+    score?: number,
+    updatedData?: string
   ): Promise<void> {
     const shardId = this.#getShardForQueue(queueId);
     const inflightKey = this.keys.inflightKey(shardId);
@@ -203,17 +298,23 @@ export class VisibilityManager {
     const messageScore = score ?? Date.now();
 
     // Use Lua script to atomically:
-    // 1. Get message data from in-flight
+    // 1. Get message data from in-flight (or use updatedData if provided)
     // 2. Remove from in-flight
     // 3. Add back to queue
+    // 4. Update dispatch indexes to ensure queue is picked up
     await this.redis.releaseMessage(
       inflightKey,
       inflightDataKey,
       queueKey,
       queueItemsKey,
+      tenantQueueIndexKey,
+      dispatchKey,
       member,
       messageId,
-      messageScore.toString()
+      messageScore.toString(),
+      queueId,
+      updatedData ?? "",
+      tenantId
     );
 
     this.logger.debug("Message released", {
@@ -223,18 +324,82 @@ export class VisibilityManager {
     });
   }
 
+  /**
+   * Release multiple messages back to their queue in a single operation.
+   * Used when processing fails or consumer wants to retry later.
+   * All messages must belong to the same queue.
+   *
+   * @param messages - Array of messages to release (must all have same queueId)
+   * @param queueId - The queue ID
+   * @param queueKey - The Redis key for the queue
+   * @param queueItemsKey - The Redis key for the queue items hash
+   * @param tenantQueueIndexKey - The Redis key for the tenant queue index (Level 2)
+   * @param dispatchKey - The Redis key for the dispatch index (Level 1)
+   * @param tenantId - The tenant ID
+   * @param score - Optional score for the messages (defaults to now)
+   */
+  async releaseBatch(
+    messages: Array<{ messageId: string }>,
+    queueId: string,
+    queueKey: string,
+    queueItemsKey: string,
+    tenantQueueIndexKey: string,
+    dispatchKey: string,
+    tenantId: string,
+    score?: number
+  ): Promise<void> {
+    if (messages.length === 0) {
+      return;
+    }
+
+    const shardId = this.#getShardForQueue(queueId);
+    const inflightKey = this.keys.inflightKey(shardId);
+    const inflightDataKey = this.keys.inflightDataKey(shardId);
+    const messageScore = score ?? Date.now();
+
+    // Build arrays of members and messageIds for the Lua script
+    const messageIds = messages.map((m) => m.messageId);
+    const members = messages.map((m) => this.#makeMember(m.messageId, queueId));
+
+    await this.redis.releaseMessageBatch(
+      inflightKey,
+      inflightDataKey,
+      queueKey,
+      queueItemsKey,
+      tenantQueueIndexKey,
+      dispatchKey,
+      messageScore.toString(),
+      queueId,
+      tenantId,
+      ...members,
+      ...messageIds
+    );
+
+    this.logger.debug("Batch messages released", {
+      queueId,
+      count: messages.length,
+      score: messageScore,
+    });
+  }
+
   /**
    * Reclaim timed-out messages from a shard.
    * Returns messages to their original queues.
    *
    * @param shardId - The shard to check
    * @param getQueueKeys - Function to get queue keys for a queue ID
-   * @returns Number of messages reclaimed
+   * @returns Array of reclaimed message info for concurrency release
    */
   async reclaimTimedOut(
     shardId: number,
-    getQueueKeys: (queueId: string) => { queueKey: string; queueItemsKey: string }
-  ): Promise<number> {
+    getQueueKeys: (queueId: string) => {
+      queueKey: string;
+      queueItemsKey: string;
+      tenantQueueIndexKey: string;
+      dispatchKey: string;
+      tenantId: string;
+    }
+  ): Promise<ReclaimedMessageInfo[]> {
     const inflightKey = this.keys.inflightKey(shardId);
     const inflightDataKey = this.keys.inflightDataKey(shardId);
     const now = Date.now();
@@ -250,36 +415,76 @@ export class VisibilityManager {
       100 // Process in batches
     );
 
-    let reclaimed = 0;
+    const reclaimedMessages: ReclaimedMessageInfo[] = [];
 
     for (let i = 0; i < timedOut.length; i += 2) {
       const member = timedOut[i];
-      const originalScore = timedOut[i + 1];
-      if (!member || !originalScore) {
+      const _deadlineScore = timedOut[i + 1]; // This is the visibility deadline, not the original timestamp
+      if (!member || !_deadlineScore) {
         continue;
       }
       const { messageId, queueId } = this.#parseMember(member);
-      const { queueKey, queueItemsKey } = getQueueKeys(queueId);
+      const { queueKey, queueItemsKey, tenantQueueIndexKey, dispatchKey, tenantId } =
+        getQueueKeys(queueId);
 
       try {
-        // Re-add to queue with original score (or now if not available)
-        const score = parseFloat(originalScore) || now;
+        // Get message data BEFORE releasing so we can extract tenantId for concurrency release
+        const dataJson = await this.redis.hget(inflightDataKey, messageId);
+        let storedMessage: StoredMessage | null = null;
+        if (dataJson) {
+          try {
+            storedMessage = JSON.parse(dataJson);
+          } catch {
+            // Ignore parse error, proceed with reclaim
+          }
+        }
+
+        // Re-add to queue with original timestamp to preserve priority
+        // Fall back to now if we can't get the original timestamp
+        const score = storedMessage?.timestamp ?? now;
         await this.redis.releaseMessage(
           inflightKey,
           inflightDataKey,
           queueKey,
           queueItemsKey,
+          tenantQueueIndexKey,
+          dispatchKey,
           member,
           messageId,
-          score.toString()
+          score.toString(),
+          queueId,
+          "",
+          tenantId
         );
 
-        reclaimed++;
+        // Track reclaimed message for concurrency release
+        // Always add to reclaimedMessages to avoid concurrency leaks
+        if (storedMessage) {
+          reclaimedMessages.push({
+            messageId,
+            queueId,
+            tenantId: storedMessage.tenantId,
+            metadata: storedMessage.metadata,
+          });
+        } else {
+          // Fallback: extract tenantId from queueId when message data is missing or corrupted
+          // This ensures concurrency is released even if we can't get the full metadata
+          this.logger.error("Missing or corrupted message data during reclaim, using fallback", {
+            messageId,
+            queueId,
+          });
+          reclaimedMessages.push({
+            messageId,
+            queueId,
+            tenantId: this.keys.extractTenantId(queueId),
+            metadata: {},
+          });
+        }
 
         this.logger.debug("Reclaimed timed-out message", {
           messageId,
           queueId,
-          originalScore,
+          deadline: _deadlineScore,
         });
       } catch (error) {
         this.logger.error("Failed to reclaim message", {
@@ -290,7 +495,7 @@ export class VisibilityManager {
       }
     }
 
-    return reclaimed;
+    return reclaimedMessages;
   }
 
   /**
@@ -431,18 +636,73 @@ return {messageId, payload}
       `,
     });
 
-    // Atomic release: remove from in-flight, add back to queue
-    this.redis.defineCommand("releaseMessage", {
+    // Atomic batch claim: pop up to N messages from queue, add to in-flight
+    this.redis.defineCommand("claimMessageBatch", {
       numberOfKeys: 4,
       lua: `
+local queueKey = KEYS[1]
+local queueItemsKey = KEYS[2]
+local inflightKey = KEYS[3]
+local inflightDataKey = KEYS[4]
+
+local queueId = ARGV[1]
+local deadline = tonumber(ARGV[2])
+local maxCount = tonumber(ARGV[3])
+
+-- Get up to maxCount oldest messages from queue
+local items = redis.call('ZRANGE', queueKey, 0, maxCount - 1)
+if #items == 0 then
+  return {}
+end
+
+local results = {}
+
+for i, messageId in ipairs(items) do
+  -- Get message data
+  local payload = redis.call('HGET', queueItemsKey, messageId)
+  
+  if payload then
+    -- Remove from queue
+    redis.call('ZREM', queueKey, messageId)
+    redis.call('HDEL', queueItemsKey, messageId)
+    
+    -- Add to in-flight set with deadline
+    local member = messageId .. ':' .. queueId
+    redis.call('ZADD', inflightKey, deadline, member)
+    
+    -- Store message data for potential release
+    redis.call('HSET', inflightDataKey, messageId, payload)
+    
+    -- Add to results
+    table.insert(results, messageId)
+    table.insert(results, payload)
+  else
+    -- Message data missing, remove from queue
+    redis.call('ZREM', queueKey, messageId)
+  end
+end
+
+return results
+      `,
+    });
+
+    // Atomic release: remove from in-flight, add back to queue, update dispatch indexes
+    this.redis.defineCommand("releaseMessage", {
+      numberOfKeys: 6,
+      lua: `
 local inflightKey = KEYS[1]
 local inflightDataKey = KEYS[2]
 local queueKey = KEYS[3]
 local queueItemsKey = KEYS[4]
+local tenantQueueIndexKey = KEYS[5]
+local dispatchKey = KEYS[6]
 
 local member = ARGV[1]
 local messageId = ARGV[2]
 local score = tonumber(ARGV[3])
+local queueId = ARGV[4]
+local updatedData = ARGV[5]
+local tenantId = ARGV[6]
 
 -- Get message data from in-flight
 local payload = redis.call('HGET', inflightDataKey, messageId)
@@ -451,6 +711,12 @@ if not payload then
   return 0
 end
 
+-- Use updatedData if provided (e.g. incremented attempt count for retries),
+-- otherwise use the original in-flight data
+if updatedData and updatedData ~= "" then
+  payload = updatedData
+end
+
 -- Remove from in-flight
 redis.call('ZREM', inflightKey, member)
 redis.call('HDEL', inflightDataKey, messageId)
@@ -459,10 +725,82 @@ redis.call('HDEL', inflightDataKey, messageId)
 redis.call('ZADD', queueKey, score, messageId)
 redis.call('HSET', queueItemsKey, messageId, payload)
 
+-- Update tenant queue index (Level 2) with queue's oldest message
+local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+if #oldest >= 2 then
+  redis.call('ZADD', tenantQueueIndexKey, oldest[2], queueId)
+end
+
+-- Update dispatch index (Level 1) with tenant's oldest across all queues
+local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+if #tenantOldest >= 2 then
+  redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
+end
+
 return 1
       `,
     });
 
+    // Atomic batch release: release multiple messages back to queue
+    this.redis.defineCommand("releaseMessageBatch", {
+      numberOfKeys: 6,
+      lua: `
+local inflightKey = KEYS[1]
+local inflightDataKey = KEYS[2]
+local queueKey = KEYS[3]
+local queueItemsKey = KEYS[4]
+local tenantQueueIndexKey = KEYS[5]
+local dispatchKey = KEYS[6]
+
+local score = tonumber(ARGV[1])
+local queueId = ARGV[2]
+local tenantId = ARGV[3]
+
+-- Remaining args are: members..., messageIds...
+-- Calculate how many messages we have
+local numMessages = (table.getn(ARGV) - 3) / 2
+local membersStart = 4
+local messageIdsStart = membersStart + numMessages
+
+local releasedCount = 0
+
+for i = 0, numMessages - 1 do
+  local member = ARGV[membersStart + i]
+  local messageId = ARGV[messageIdsStart + i]
+
+  -- Get message data from in-flight
+  local payload = redis.call('HGET', inflightDataKey, messageId)
+  if payload then
+    -- Remove from in-flight
+    redis.call('ZREM', inflightKey, member)
+    redis.call('HDEL', inflightDataKey, messageId)
+
+    -- Add back to queue
+    redis.call('ZADD', queueKey, score, messageId)
+    redis.call('HSET', queueItemsKey, messageId, payload)
+
+    releasedCount = releasedCount + 1
+  end
+end
+
+-- Update dispatch indexes (only once at the end)
+if releasedCount > 0 then
+  -- Update tenant queue index (Level 2)
+  local oldest = redis.call('ZRANGE', queueKey, 0, 0, 'WITHSCORES')
+  if #oldest >= 2 then
+    redis.call('ZADD', tenantQueueIndexKey, oldest[2], queueId)
+  end
+  -- Update dispatch index (Level 1)
+  local tenantOldest = redis.call('ZRANGE', tenantQueueIndexKey, 0, 0, 'WITHSCORES')
+  if #tenantOldest >= 2 then
+    redis.call('ZADD', dispatchKey, tenantOldest[2], tenantId)
+  end
+end
+
+return releasedCount
+      `,
+    });
+
     // Atomic heartbeat: check if member exists and update score
     // ZADD XX returns 0 even on successful updates (it counts new additions only)
     // So we need to check existence first with ZSCORE
@@ -500,14 +838,42 @@ declare module "@internal/redis" {
       deadline: string
     ): Promise<[string, string] | null>;
 
+    claimMessageBatch(
+      queueKey: string,
+      queueItemsKey: string,
+      inflightKey: string,
+      inflightDataKey: string,
+      queueId: string,
+      deadline: string,
+      maxCount: string
+    ): Promise<string[]>;
+
     releaseMessage(
       inflightKey: string,
       inflightDataKey: string,
       queueKey: string,
       queueItemsKey: string,
+      tenantQueueIndexKey: string,
+      dispatchKey: string,
       member: string,
       messageId: string,
-      score: string
+      score: string,
+      queueId: string,
+      updatedData: string,
+      tenantId: string
+    ): Promise<number>;
+
+    releaseMessageBatch(
+      inflightKey: string,
+      inflightDataKey: string,
+      queueKey: string,
+      queueItemsKey: string,
+      tenantQueueIndexKey: string,
+      dispatchKey: string,
+      score: string,
+      queueId: string,
+      tenantId: string,
+      ...membersAndMessageIds: string[]
     ): Promise<number>;
 
     heartbeatMessage(inflightKey: string, member: string, newDeadline: string): Promise<number>;
diff --git a/packages/redis-worker/src/fair-queue/workerQueue.ts b/packages/redis-worker/src/fair-queue/workerQueue.ts
index b60201c90af..b3b75e9db35 100644
--- a/packages/redis-worker/src/fair-queue/workerQueue.ts
+++ b/packages/redis-worker/src/fair-queue/workerQueue.ts
@@ -101,12 +101,17 @@ export class WorkerQueueManager {
     // This is required because BLPOP blocks the connection
     const blockingClient = this.redis.duplicate();
 
+    // Define cleanup outside try so it's accessible in finally
+    // This prevents listener accumulation on the AbortSignal
+    const cleanup = signal
+      ? () => {
+          blockingClient.disconnect();
+        }
+      : null;
+
     try {
       // Set up abort handler
-      if (signal) {
-        const cleanup = () => {
-          blockingClient.disconnect();
-        };
+      if (signal && cleanup) {
         signal.addEventListener("abort", cleanup, { once: true });
 
         if (signal.aborted) {
@@ -143,6 +148,11 @@ export class WorkerQueueManager {
 
       throw error;
     } finally {
+      // Always remove the listener to prevent accumulation on the AbortSignal
+      // (once: true only removes if abort fires, not on normal completion)
+      if (cleanup && signal) {
+        signal.removeEventListener("abort", cleanup);
+      }
       await blockingClient.quit().catch(() => {
         // Ignore quit errors (may already be disconnected)
       });
diff --git a/packages/redis-worker/src/index.ts b/packages/redis-worker/src/index.ts
index 6163c8faa6b..1c5147ea48d 100644
--- a/packages/redis-worker/src/index.ts
+++ b/packages/redis-worker/src/index.ts
@@ -1,5 +1,6 @@
 export * from "./queue.js";
 export * from "./worker.js";
+export * from "./utils.js";
 
 // Fair Queue System
 export * from "./fair-queue/index.js";
diff --git a/packages/redis-worker/src/utils.ts b/packages/redis-worker/src/utils.ts
new file mode 100644
index 00000000000..a577de3b0ed
--- /dev/null
+++ b/packages/redis-worker/src/utils.ts
@@ -0,0 +1,12 @@
+/**
+ * Check if an error is an AbortError.
+ *
+ * This handles both:
+ * - Custom abort errors created with `new Error("AbortError")` (sets .message)
+ * - Native Node.js AbortError from timers/promises (sets .name)
+ */
+export function isAbortError(error: unknown): boolean {
+  return (
+    error instanceof Error && (error.name === "AbortError" || error.message === "AbortError")
+  );
+}
diff --git a/packages/redis-worker/src/worker.ts b/packages/redis-worker/src/worker.ts
index 92880d1f07c..51812e575ea 100644
--- a/packages/redis-worker/src/worker.ts
+++ b/packages/redis-worker/src/worker.ts
@@ -29,6 +29,11 @@ export const CronSchema = z.object({
 
 export type CronSchema = z.infer<typeof CronSchema>;
 
+export type BatchConfig = {
+  maxSize: number;
+  maxWaitMs: number;
+};
+
 export type WorkerCatalog = {
   [key: string]: {
     schema: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion<any, any>;
@@ -38,6 +43,8 @@ export type WorkerCatalog = {
     jitterInMs?: number;
     /** Defaults to true. If false, errors will not be logged. */
     logErrors?: boolean;
+    /** When set, items are accumulated and delivered in batches to the handler. */
+    batch?: BatchConfig;
   };
 };
 
@@ -59,6 +66,11 @@ export type JobHandler<Catalog extends WorkerCatalog, K extends keyof Catalog> =
   params: JobHandlerParams<Catalog, K>
 ) => Promise<void>;
 
+type JobHandlerFor<Catalog extends WorkerCatalog, K extends keyof Catalog> =
+  Catalog[K] extends { batch: BatchConfig }
+    ? (items: Array<JobHandlerParams<Catalog, K>>) => Promise<void>
+    : (params: JobHandlerParams<Catalog, K>) => Promise<void>;
+
 export type WorkerConcurrencyOptions = {
   workers?: number;
   tasksPerWorker?: number;
@@ -70,7 +82,7 @@ type WorkerOptions<TCatalog extends WorkerCatalog> = {
   redisOptions: RedisOptions;
   catalog: TCatalog;
   jobs: {
-    [K in keyof TCatalog]: JobHandler<TCatalog, K>;
+    [K in keyof TCatalog]: JobHandlerFor<TCatalog, K>;
   };
   concurrency?: WorkerConcurrencyOptions;
   pollIntervalMs?: number;
@@ -117,6 +129,15 @@ class Worker<TCatalog extends WorkerCatalog> {
   // The p-limit limiter to control overall concurrency.
   private limiters: Record<string, ReturnType<typeof pLimit>> = {};
 
+  // Batch accumulators: one per batch-enabled job type
+  private batchAccumulators: Map<
+    string,
+    {
+      items: AnyQueueItem[];
+      firstItemAt: number;
+    }
+  > = new Map();
+
   constructor(private options: WorkerOptions<TCatalog>) {
     this.logger = options.logger ?? new Logger("Worker", "debug");
     this.tracer = options.tracer ?? trace.getTracer(options.name);
@@ -426,6 +447,37 @@ class Worker<TCatalog extends WorkerCatalog> {
     return this.queue.getJob(id);
   }
 
+  /**
+   * Returns true if the given job type has batch config in the catalog.
+   */
+  private isBatchJob(jobType: string): boolean {
+    const catalogItem = this.options.catalog[jobType as any];
+    return !!catalogItem?.batch;
+  }
+
+  /**
+   * Returns the batch config for a job type, or undefined if not batch-enabled.
+   */
+  private getBatchConfig(jobType: string): BatchConfig | undefined {
+    const catalogItem = this.options.catalog[jobType as any];
+    return catalogItem?.batch;
+  }
+
+  /**
+   * The max dequeue count: the largest batch maxSize across catalog entries,
+   * falling back to tasksPerWorker for non-batch catalogs.
+   */
+  private get maxDequeueCount(): number {
+    const batchSizes = Object.values(this.options.catalog)
+      .filter((entry): entry is typeof entry & { batch: BatchConfig } => !!entry.batch)
+      .map((entry) => entry.batch.maxSize);
+
+    if (batchSizes.length > 0) {
+      return Math.max(...batchSizes);
+    }
+    return this.concurrency.tasksPerWorker;
+  }
+
   /**
    * The main loop that each worker runs. It repeatedly polls for items,
    * processes them, and then waits before the next iteration.
@@ -459,7 +511,10 @@ class Worker<TCatalog extends WorkerCatalog> {
     });
 
     while (!this.isShuttingDown) {
-      // Check overall load. If at capacity, wait a bit before trying to dequeue more.
+      // 1. Flush any timed-out batch accumulators
+      await this.flushTimedOutBatches(workerId, limiter);
+
+      // 2. Check overall load. If at capacity, wait a bit before trying to dequeue more.
       if (limiter.activeCount + limiter.pendingCount >= this.concurrency.limit) {
         this.logger.debug("Worker at capacity, waiting", {
           workerId,
@@ -473,13 +528,14 @@ class Worker<TCatalog extends WorkerCatalog> {
         continue;
       }
 
-      // If taskCount is 10, concurrency limit is 100, and there are 98 active workers, we should dequeue 2 items at most.
-      // If taskCount is 10, concurrency limit is 100, and there are 12 active workers, we should dequeue 10 items at most.
+      // 3. Calculate dequeue count - use max batch size if we have batch jobs
       const $taskCount = Math.min(
-        taskCount,
+        this.maxDequeueCount,
         this.concurrency.limit - limiter.activeCount - limiter.pendingCount
       );
 
+      let itemsFound = false;
+
       try {
         const items = await this.withHistogram(
           this.metrics.dequeueDuration,
@@ -490,7 +546,9 @@ class Worker<TCatalog extends WorkerCatalog> {
           }
         );
 
-        if (items.length === 0) {
+        itemsFound = items.length > 0;
+
+        if (items.length === 0 && this.batchAccumulators.size === 0) {
           this.logger.debug("No items to dequeue", {
             workerId,
             concurrencyOptions: this.concurrency,
@@ -502,21 +560,39 @@ class Worker<TCatalog extends WorkerCatalog> {
           continue;
         }
 
-        this.logger.debug("Dequeued items", {
-          workerId,
-          itemCount: items.length,
-          concurrencyOptions: this.concurrency,
-          activeCount: limiter.activeCount,
-          pendingCount: limiter.pendingCount,
-        });
+        if (items.length > 0) {
+          this.logger.debug("Dequeued items", {
+            workerId,
+            itemCount: items.length,
+            concurrencyOptions: this.concurrency,
+            activeCount: limiter.activeCount,
+            pendingCount: limiter.pendingCount,
+          });
+        }
 
-        // Schedule each item using the limiter.
+        // 4. Route items: batch-enabled go to accumulators, others processed immediately
         for (const item of items) {
-          limiter(() =>
-            this.processItem(item as AnyQueueItem, items.length, workerId, limiter)
-          ).catch((err) => {
-            this.logger.error("Unhandled error in processItem:", { error: err, workerId, item });
-          });
+          const queueItem = item as AnyQueueItem;
+
+          if (this.isBatchJob(queueItem.job)) {
+            this.addToAccumulator(queueItem);
+
+            const batchConfig = this.getBatchConfig(queueItem.job)!;
+            const accumulator = this.batchAccumulators.get(queueItem.job);
+            if (accumulator && accumulator.items.length >= batchConfig.maxSize) {
+              await this.flushBatch(queueItem.job, workerId, limiter);
+            }
+          } else {
+            limiter(() =>
+              this.processItem(queueItem, items.length, workerId, limiter)
+            ).catch((err) => {
+              this.logger.error("Unhandled error in processItem:", {
+                error: err,
+                workerId,
+                item,
+              });
+            });
+          }
         }
       } catch (error) {
         this.logger.error("Error dequeuing items:", { name: this.options.name, error });
@@ -524,13 +600,238 @@ class Worker<TCatalog extends WorkerCatalog> {
         continue;
       }
 
-      // Wait briefly before immediately polling again since we processed items
-      await Worker.delay(immediatePollIntervalMs);
+      // 5. If we found items or have pending batch items, poll quickly
+      if (itemsFound || this.batchAccumulators.size > 0) {
+        await Worker.delay(immediatePollIntervalMs);
+      } else {
+        await Worker.delay(pollIntervalMs);
+      }
     }
 
+    // On shutdown, flush all remaining batch accumulators
+    await this.flushAllBatches(workerId, limiter);
+
     this.logger.info("Worker loop finished", { workerId });
   }
 
+  /**
+   * Adds an item to the batch accumulator for its job type.
+   */
+  private addToAccumulator(item: AnyQueueItem): void {
+    let accumulator = this.batchAccumulators.get(item.job);
+    if (!accumulator) {
+      accumulator = { items: [], firstItemAt: Date.now() };
+      this.batchAccumulators.set(item.job, accumulator);
+    }
+    accumulator.items.push(item);
+  }
+
+  /**
+   * Flushes any batch accumulators that have exceeded their maxWaitMs.
+   */
+  private async flushTimedOutBatches(
+    workerId: string,
+    limiter: ReturnType<typeof pLimit>
+  ): Promise<void> {
+    const now = Date.now();
+    for (const [jobType, accumulator] of this.batchAccumulators) {
+      const batchConfig = this.getBatchConfig(jobType);
+      if (!batchConfig) continue;
+
+      if (now - accumulator.firstItemAt >= batchConfig.maxWaitMs) {
+        await this.flushBatch(jobType, workerId, limiter);
+      }
+    }
+  }
+
+  /**
+   * Flushes all batch accumulators (used during shutdown).
+   */
+  private async flushAllBatches(
+    workerId: string,
+    limiter: ReturnType<typeof pLimit>
+  ): Promise<void> {
+    for (const jobType of this.batchAccumulators.keys()) {
+      await this.flushBatch(jobType, workerId, limiter);
+    }
+  }
+
+  /**
+   * Flushes the batch accumulator for a specific job type.
+   * Removes items from the accumulator and submits them to the limiter as a single batch.
+   */
+  private async flushBatch(
+    jobType: string,
+    workerId: string,
+    limiter: ReturnType<typeof pLimit>
+  ): Promise<void> {
+    const accumulator = this.batchAccumulators.get(jobType);
+    if (!accumulator || accumulator.items.length === 0) return;
+
+    const items = accumulator.items;
+    this.batchAccumulators.delete(jobType);
+
+    this.logger.debug("Flushing batch", {
+      jobType,
+      batchSize: items.length,
+      workerId,
+      accumulatedMs: Date.now() - accumulator.firstItemAt,
+    });
+
+    limiter(() => this.processBatch(items, jobType, workerId, limiter)).catch((err) => {
+      this.logger.error("Unhandled error in processBatch:", {
+        error: err,
+        workerId,
+        jobType,
+        batchSize: items.length,
+      });
+    });
+  }
+
+  /**
+   * Processes a batch of items for a batch-enabled job type.
+   */
+  private async processBatch(
+    items: AnyQueueItem[],
+    jobType: string,
+    workerId: string,
+    limiter: ReturnType<typeof pLimit>
+  ): Promise<void> {
+    const catalogItem = this.options.catalog[jobType as any];
+    const handler = this.jobs[jobType as any] as
+      | ((items: Array<JobHandlerParams<TCatalog, any>>) => Promise<void>)
+      | undefined;
+
+    if (!handler) {
+      this.logger.error(`Worker no handler found for batch job type: ${jobType}`);
+      return;
+    }
+
+    if (!catalogItem) {
+      this.logger.error(`Worker no catalog item found for batch job type: ${jobType}`);
+      return;
+    }
+
+    const batchParams = items.map((item) => ({
+      id: item.id,
+      payload: item.item,
+      visibilityTimeoutMs: item.visibilityTimeoutMs,
+      attempt: item.attempt,
+      deduplicationKey: item.deduplicationKey,
+    }));
+
+    await startSpan(
+      this.tracer,
+      "processBatch",
+      async () => {
+        await this.withHistogram(this.metrics.jobDuration, handler(batchParams), {
+          worker_id: workerId,
+          batch_size: items.length,
+          job_type: jobType,
+        });
+
+        // On success, acknowledge all items individually.
+        await Promise.all(items.map((item) => this.queue.ack(item.id, item.deduplicationKey)));
+      },
+      {
+        kind: SpanKind.CONSUMER,
+        attributes: {
+          job_type: jobType,
+          batch_size: items.length,
+          worker_id: workerId,
+          worker_name: this.options.name,
+        },
+      }
+    ).catch(async (error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const shouldLogError = catalogItem.logErrors ?? true;
+      const errorLogLevel =
+        error && typeof error === "object" && "logLevel" in error ? error.logLevel : undefined;
+
+      const logAttributes = {
+        name: this.options.name,
+        jobType,
+        batchSize: items.length,
+        error,
+        errorMessage,
+      };
+
+      if (!shouldLogError) {
+        this.logger.info(`Worker failed to process batch`, logAttributes);
+      } else if (errorLogLevel === "warn") {
+        this.logger.warn(`Worker error processing batch`, logAttributes);
+      } else if (errorLogLevel === "info") {
+        this.logger.info(`Worker error processing batch`, logAttributes);
+      } else {
+        this.logger.error(`Worker error processing batch`, logAttributes);
+      }
+
+      // Re-enqueue each item individually with retry logic
+      for (const item of items) {
+        try {
+          const newAttempt = item.attempt + 1;
+          const retrySettings = {
+            ...defaultRetrySettings,
+            ...catalogItem?.retry,
+          };
+          const retryDelay = calculateNextRetryDelay(retrySettings, newAttempt);
+
+          if (!retryDelay) {
+            const dlqLogAttributes = {
+              name: this.options.name,
+              id: item.id,
+              jobType,
+              attempt: newAttempt,
+            };
+
+            if (!shouldLogError) {
+              this.logger.info(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+            } else if (errorLogLevel === "warn") {
+              this.logger.warn(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+            } else if (errorLogLevel === "info") {
+              this.logger.info(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+            } else {
+              this.logger.error(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+            }
+
+            await this.queue.moveToDeadLetterQueue(item.id, errorMessage);
+            continue;
+          }
+
+          const retryDate = new Date(Date.now() + retryDelay);
+          this.logger.info(`Worker requeuing failed batch item with delay`, {
+            name: this.options.name,
+            id: item.id,
+            jobType,
+            retryDate,
+            retryDelay,
+            attempt: newAttempt,
+          });
+
+          await this.queue.enqueue({
+            id: item.id,
+            job: item.job,
+            item: item.item,
+            availableAt: retryDate,
+            attempt: newAttempt,
+            visibilityTimeoutMs: item.visibilityTimeoutMs,
+          });
+        } catch (requeueError) {
+          this.logger.error(
+            `Worker failed to requeue batch item. It will be retried after the visibility timeout.`,
+            {
+              name: this.options.name,
+              id: item.id,
+              jobType,
+              visibilityTimeoutMs: item.visibilityTimeoutMs,
+              error: requeueError,
+            }
+          );
+        }
+      }
+    });
+  }
+
   /**
    * Processes a single item.
    */
@@ -541,7 +842,10 @@ class Worker<TCatalog extends WorkerCatalog> {
     limiter: ReturnType<typeof pLimit>
   ): Promise<void> {
     const catalogItem = this.options.catalog[job as any];
-    const handler = this.jobs[job as any];
+    // processItem is only called for non-batch jobs, so the handler takes a single param
+    const handler = this.jobs[job as any] as
+      | ((params: JobHandlerParams<TCatalog, any>) => Promise<void>)
+      | undefined;
     if (!handler) {
       this.logger.error(`Worker no handler found for job type: ${job}`);
       return;
@@ -594,6 +898,8 @@ class Worker<TCatalog extends WorkerCatalog> {
       const errorMessage = error instanceof Error ? error.message : String(error);
 
       const shouldLogError = catalogItem.logErrors ?? true;
+      const errorLogLevel =
+        error && typeof error === "object" && "logLevel" in error ? error.logLevel : undefined;
 
       const logAttributes = {
         name: this.options.name,
@@ -605,10 +911,14 @@ class Worker<TCatalog extends WorkerCatalog> {
         errorMessage,
       };
 
-      if (shouldLogError) {
-        this.logger.error(`Worker error processing item`, logAttributes);
-      } else {
+      if (!shouldLogError) {
         this.logger.info(`Worker failed to process item`, logAttributes);
+      } else if (errorLogLevel === "warn") {
+        this.logger.warn(`Worker error processing item`, logAttributes);
+      } else if (errorLogLevel === "info") {
+        this.logger.info(`Worker error processing item`, logAttributes);
+      } else {
+        this.logger.error(`Worker error processing item`, logAttributes);
       }
 
       // Attempt requeue logic.
@@ -621,13 +931,18 @@ class Worker<TCatalog extends WorkerCatalog> {
         const retryDelay = calculateNextRetryDelay(retrySettings, newAttempt);
 
         if (!retryDelay) {
-          if (shouldLogError) {
-            this.logger.error(`Worker item reached max attempts. Moving to DLQ.`, {
+          if (!shouldLogError || errorLogLevel === "info") {
+            this.logger.info(`Worker item reached max attempts. Moving to DLQ.`, {
+              ...logAttributes,
+              attempt: newAttempt,
+            });
+          } else if (errorLogLevel === "warn") {
+            this.logger.warn(`Worker item reached max attempts. Moving to DLQ.`, {
               ...logAttributes,
               attempt: newAttempt,
             });
           } else {
-            this.logger.info(`Worker item reached max attempts. Moving to DLQ.`, {
+            this.logger.error(`Worker item reached max attempts. Moving to DLQ.`, {
               ...logAttributes,
               attempt: newAttempt,
             });
@@ -723,7 +1038,7 @@ class Worker<TCatalog extends WorkerCatalog> {
     Promise.allSettled(enqueuePromises).then((results) => {
       results.forEach((result) => {
         if (result.status === "fulfilled") {
-          this.logger.info("Enqueued cron job", { result: result.value });
+          this.logger.debug("Enqueued cron job", { result: result.value });
         } else {
           this.logger.error("Failed to enqueue cron job", { reason: result.reason });
         }
@@ -749,7 +1064,7 @@ class Worker<TCatalog extends WorkerCatalog> {
       availableAt,
     });
 
-    this.logger.info("Enqueued cron job", {
+    this.logger.debug("Enqueued cron job", {
       identifier,
       cron,
       job,
diff --git a/packages/rsc/CHANGELOG.md b/packages/rsc/CHANGELOG.md
index 93037c8a0dd..fe01554636b 100644
--- a/packages/rsc/CHANGELOG.md
+++ b/packages/rsc/CHANGELOG.md
@@ -1,5 +1,54 @@
 # @trigger.dev/rsc
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/rsc/package.json b/packages/rsc/package.json
index 30f30802910..b887f695b21 100644
--- a/packages/rsc/package.json
+++ b/packages/rsc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/rsc",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "trigger.dev rsc",
   "license": "MIT",
   "publishConfig": {
@@ -37,14 +37,14 @@
     "check-exports": "attw --pack ."
   },
   "dependencies": {
-    "@trigger.dev/core": "workspace:^4.3.0",
+    "@trigger.dev/core": "workspace:^4.4.3",
     "mlly": "^1.7.1",
     "react": "19.0.0-rc.1",
     "react-dom": "19.0.0-rc.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.15.4",
-    "@trigger.dev/build": "workspace:^4.3.0",
+    "@trigger.dev/build": "workspace:^4.4.3",
     "@types/node": "^20.14.14",
     "@types/react": "*",
     "@types/react-dom": "*",
diff --git a/packages/schema-to-json/CHANGELOG.md b/packages/schema-to-json/CHANGELOG.md
index e17cd1a9f10..e24fa24b07d 100644
--- a/packages/schema-to-json/CHANGELOG.md
+++ b/packages/schema-to-json/CHANGELOG.md
@@ -1,5 +1,54 @@
 # @trigger.dev/schema-to-json
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/schema-to-json/package.json b/packages/schema-to-json/package.json
index 66c0feff7cd..e2963c1d70b 100644
--- a/packages/schema-to-json/package.json
+++ b/packages/schema-to-json/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/schema-to-json",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "Convert various schema validation libraries to JSON Schema",
   "license": "MIT",
   "publishConfig": {
diff --git a/packages/trigger-sdk/CHANGELOG.md b/packages/trigger-sdk/CHANGELOG.md
index 75231f0c5e0..dbccf319fa5 100644
--- a/packages/trigger-sdk/CHANGELOG.md
+++ b/packages/trigger-sdk/CHANGELOG.md
@@ -1,5 +1,119 @@
 # @trigger.dev/sdk
 
+## 4.4.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.3`
+
+## 4.4.2
+
+### Patch Changes
+
+- Add input streams for bidirectional communication with running tasks. Define typed input streams with `streams.input<T>({ id })`, then consume inside tasks via `.wait()` (suspends the process), `.once()` (waits for next message), or `.on()` (subscribes to a continuous stream). Send data from backends with `.send(runId, data)` or from frontends with the new `useInputStreamSend` React hook. ([#3146](https://github.com/triggerdotdev/trigger.dev/pull/3146))
+
+  Upgrade S2 SDK from 0.17 to 0.22 with support for custom endpoints (s2-lite) via the new `endpoints` configuration, `AppendRecord.string()` API, and `maxInflightBytes` session option.
+
+- fix(sdk): batch triggerAndWait variants now return correct run.taskIdentifier instead of unknown ([#3080](https://github.com/triggerdotdev/trigger.dev/pull/3080))
+- Add PAYLOAD_TOO_LARGE error to handle graceful recovery of sending batch trigger items with payloads that exceed the maximum payload size ([#3137](https://github.com/triggerdotdev/trigger.dev/pull/3137))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.2`
+
+## 4.4.1
+
+### Patch Changes
+
+- Add OTEL metrics pipeline for task workers. Workers collect process CPU/memory, Node.js runtime metrics (event loop utilization, event loop delay, heap usage), and user-defined custom metrics via `otel.metrics.getMeter()`. Metrics are exported to ClickHouse with 10-second aggregation buckets and 1m/5m rollups, and are queryable through the dashboard query engine with typed attribute columns, `prettyFormat()` for human-readable values, and AI query support. ([#3061](https://github.com/triggerdotdev/trigger.dev/pull/3061))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.1`
+
+## 4.4.0
+
+### Minor Changes
+
+- Added `query.execute()` which lets you query your Trigger.dev data using TRQL (Trigger Query Language) and returns results as typed JSON rows or CSV. It supports configurable scope (environment, project, or organization), time filtering via `period` or `from`/`to` ranges, and a `format` option for JSON or CSV output. ([#3060](https://github.com/triggerdotdev/trigger.dev/pull/3060))
+
+  ```typescript
+  import { query } from "@trigger.dev/sdk";
+  import type { QueryTable } from "@trigger.dev/sdk";
+
+  // Basic untyped query
+  const result = await query.execute("SELECT run_id, status FROM runs LIMIT 10");
+
+  // Type-safe query using QueryTable to pick specific columns
+  const typedResult = await query.execute<QueryTable<"runs", "run_id" | "status" | "triggered_at">>(
+    "SELECT run_id, status, triggered_at FROM runs LIMIT 10"
+  );
+  typedResult.results.forEach((row) => {
+    console.log(row.run_id, row.status); // Fully typed
+  });
+
+  // Aggregation query with inline types
+  const stats = await query.execute<{ status: string; count: number }>(
+    "SELECT status, COUNT(*) as count FROM runs GROUP BY status",
+    { scope: "project", period: "30d" }
+  );
+
+  // CSV export
+  const csv = await query.execute("SELECT run_id, status FROM runs", {
+    format: "csv",
+    period: "7d",
+  });
+  console.log(csv.results); // Raw CSV string
+  ```
+
+### Patch Changes
+
+- Add `maxDelay` option to debounce feature. This allows setting a maximum time limit for how long a debounced run can be delayed, ensuring execution happens within a specified window even with continuous triggers. ([#2984](https://github.com/triggerdotdev/trigger.dev/pull/2984))
+
+  ```typescript
+  await myTask.trigger(payload, {
+    debounce: {
+      key: "my-key",
+      delay: "5s",
+      maxDelay: "30m", // Execute within 30 minutes regardless of continuous triggers
+    },
+  });
+  ```
+
+- Aligned the SDK's `getRunIdForOptions` logic with the Core package to handle semantic targets (`root`, `parent`) in root tasks. ([#2874](https://github.com/triggerdotdev/trigger.dev/pull/2874))
+- Export `AnyOnStartAttemptHookFunction` type to allow defining `onStartAttempt` hooks for individual tasks. ([#2966](https://github.com/triggerdotdev/trigger.dev/pull/2966))
+- Fixed a minor issue in the deployment command on distinguishing between local builds for the cloud vs local builds for self-hosting setups. ([#3070](https://github.com/triggerdotdev/trigger.dev/pull/3070))
+- Updated dependencies:
+  - `@trigger.dev/core@4.4.0`
+
+## 4.3.3
+
+### Patch Changes
+
+- Add support for AI SDK v6 (Vercel AI SDK) ([#2919](https://github.com/triggerdotdev/trigger.dev/pull/2919))
+
+  - Updated peer dependency to allow `ai@^6.0.0` alongside v4 and v5
+  - Updated internal code to handle async validation from AI SDK v6's Schema type
+
+- Expose user-provided idempotency key and scope in task context. `ctx.run.idempotencyKey` now returns the original key passed to `idempotencyKeys.create()` instead of the hash, and `ctx.run.idempotencyKeyScope` shows the scope ("run", "attempt", or "global"). ([#2903](https://github.com/triggerdotdev/trigger.dev/pull/2903))
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.3`
+
+## 4.3.2
+
+### Patch Changes
+
+- Improve batch trigger error messages, especially when rate limited ([#2837](https://github.com/triggerdotdev/trigger.dev/pull/2837))
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.2`
+
+## 4.3.1
+
+### Patch Changes
+
+- feat: Support for new batch trigger system ([#2779](https://github.com/triggerdotdev/trigger.dev/pull/2779))
+- feat(sdk): Support debouncing runs when triggering with new debounce options ([#2794](https://github.com/triggerdotdev/trigger.dev/pull/2794))
+- Added support for idempotency reset ([#2777](https://github.com/triggerdotdev/trigger.dev/pull/2777))
+- Updated dependencies:
+  - `@trigger.dev/core@4.3.1`
+
 ## 4.3.0
 
 ### Patch Changes
diff --git a/packages/trigger-sdk/CLAUDE.md b/packages/trigger-sdk/CLAUDE.md
new file mode 100644
index 00000000000..8311956358c
--- /dev/null
+++ b/packages/trigger-sdk/CLAUDE.md
@@ -0,0 +1,27 @@
+# Trigger.dev SDK
+
+`@trigger.dev/sdk` - the main customer-facing SDK for writing background tasks.
+
+## Import Rules
+
+Always import from `@trigger.dev/sdk`. Never use `@trigger.dev/sdk/v3` (deprecated path alias).
+
+## Key Exports
+
+- `task` - Define a background task
+- `schedules.task` - Define a scheduled (cron) task
+- `batch` - Batch trigger operations
+- `runs` - Run management and polling
+- `wait` - Wait for events, delays, or other tasks
+- `retry` - Retry utilities
+- `queue` - Queue configuration
+- `metadata` - Run metadata access
+- `logger` - Structured logging
+
+## When Adding Features
+
+1. Implement the feature in the SDK
+2. Test with `references/hello-world` reference project
+3. Docs updates (`docs/`) are usually done in a separate PR
+
+Do NOT update `rules/` or `.claude/skills/trigger-dev-tasks/` unless explicitly asked. These are maintained in separate dedicated passes.
diff --git a/packages/trigger-sdk/package.json b/packages/trigger-sdk/package.json
index 1311344d506..e1ff05c4de9 100644
--- a/packages/trigger-sdk/package.json
+++ b/packages/trigger-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@trigger.dev/sdk",
-  "version": "4.3.0",
+  "version": "4.4.3",
   "description": "trigger.dev Node.JS SDK",
   "license": "MIT",
   "publishConfig": {
@@ -52,7 +52,7 @@
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/semantic-conventions": "1.36.0",
-    "@trigger.dev/core": "workspace:4.3.0",
+    "@trigger.dev/core": "workspace:4.4.3",
     "chalk": "^5.2.0",
     "cronstrue": "^2.21.0",
     "debug": "^4.3.4",
@@ -69,7 +69,7 @@
     "@types/slug": "^5.0.3",
     "@types/uuid": "^9.0.0",
     "@types/ws": "^8.5.3",
-    "ai": "^5.0.0",
+    "ai": "^6.0.0",
     "encoding": "^0.1.13",
     "rimraf": "^3.0.2",
     "tshy": "^3.0.2",
@@ -79,7 +79,7 @@
   },
   "peerDependencies": {
     "zod": "^3.0.0 || ^4.0.0",
-    "ai": "^4.2.0 || ^5.0.0"
+    "ai": "^4.2.0 || ^5.0.0 || ^6.0.0"
   },
   "peerDependenciesMeta": {
     "ai": {
diff --git a/packages/trigger-sdk/src/v3/auth.ts b/packages/trigger-sdk/src/v3/auth.ts
index ddcf92569af..1f2df463b6f 100644
--- a/packages/trigger-sdk/src/v3/auth.ts
+++ b/packages/trigger-sdk/src/v3/auth.ts
@@ -62,6 +62,11 @@ type PublicTokenPermissionProperties = {
    * Grant access to specific waitpoints
    */
   waitpoints?: string | string[];
+
+  /**
+   * Grant access to send data to input streams on specific runs
+   */
+  inputStreams?: string | string[];
 };
 
 export type PublicTokenPermissions = {
diff --git a/packages/trigger-sdk/src/v3/hooks.ts b/packages/trigger-sdk/src/v3/hooks.ts
index c6811ca6e9b..9c4bd8eb691 100644
--- a/packages/trigger-sdk/src/v3/hooks.ts
+++ b/packages/trigger-sdk/src/v3/hooks.ts
@@ -17,6 +17,7 @@ import {
 
 export type {
   AnyOnStartHookFunction,
+  AnyOnStartAttemptHookFunction,
   TaskStartHookParams,
   OnStartHookFunction,
   AnyOnFailureHookFunction,
diff --git a/packages/trigger-sdk/src/v3/index.ts b/packages/trigger-sdk/src/v3/index.ts
index dcc258455b2..21ffa142871 100644
--- a/packages/trigger-sdk/src/v3/index.ts
+++ b/packages/trigger-sdk/src/v3/index.ts
@@ -1,7 +1,7 @@
 export * from "./cache.js";
 export * from "./config.js";
 export { retry, type RetryOptions } from "./retry.js";
-export { queue } from "./shared.js";
+export { queue, BatchTriggerError } from "./shared.js";
 export * from "./tasks.js";
 export * from "./batch.js";
 export * from "./wait.js";
@@ -17,6 +17,7 @@ export * from "./otel.js";
 export * from "./schemas.js";
 export * from "./heartbeats.js";
 export * from "./streams.js";
+export * from "./query.js";
 export type { Context };
 
 import type { Context } from "./shared.js";
@@ -58,3 +59,4 @@ export * as queues from "./queues.js";
 export type { ImportEnvironmentVariablesParams } from "./envvars.js";
 
 export { configure, auth } from "./auth.js";
+export * as prompts from "./prompts.js";
diff --git a/packages/trigger-sdk/src/v3/otel.ts b/packages/trigger-sdk/src/v3/otel.ts
index e80c77562eb..d02220208e7 100644
--- a/packages/trigger-sdk/src/v3/otel.ts
+++ b/packages/trigger-sdk/src/v3/otel.ts
@@ -1,7 +1,9 @@
+import { metrics } from "@opentelemetry/api";
 import { traceContext } from "@trigger.dev/core/v3";
 
 export const otel = {
   withExternalTrace: <T>(fn: () => T): T => {
     return traceContext.withExternalTrace(fn);
   },
+  metrics,
 };
diff --git a/packages/trigger-sdk/src/v3/prompt.ts b/packages/trigger-sdk/src/v3/prompt.ts
new file mode 100644
index 00000000000..1c465b1ee46
--- /dev/null
+++ b/packages/trigger-sdk/src/v3/prompt.ts
@@ -0,0 +1,256 @@
+import {
+  accessoryAttributes,
+  apiClientManager,
+  resourceCatalog,
+  SemanticInternalAttributes,
+  type PromptMetadataWithFunctions,
+  type TaskSchema,
+  type inferSchemaIn,
+  getSchemaParseFn,
+} from "@trigger.dev/core/v3";
+import { tracer } from "./tracer.js";
+
+type PromptOptions<
+  TIdentifier extends string = string,
+  TVariables extends TaskSchema | undefined = undefined,
+> = {
+  id: TIdentifier;
+  description?: string;
+  model?: string;
+  config?: Record<string, unknown>;
+  variables?: TVariables;
+  content: string;
+};
+
+type ResolvedPrompt = {
+  promptId: string;
+  version: number;
+  labels: string[];
+  text: string;
+  model: string | undefined;
+  config: Record<string, unknown> | undefined;
+  /** Returns `experimental_telemetry` options for AI SDK calls (`generateText`, `streamText`, etc.) */
+  toAISDKTelemetry(additionalMetadata?: Record<string, string>): {
+    experimental_telemetry: {
+      isEnabled: true;
+      metadata: Record<string, string>;
+    };
+  };
+};
+
+export type { PromptOptions, ResolvedPrompt };
+
+export type PromptHandle<
+  TIdentifier extends string = string,
+  TVariables extends TaskSchema | undefined = undefined,
+> = {
+  id: TIdentifier;
+  resolve(
+    variables: inferSchemaIn<TVariables>,
+    options?: { label?: string; version?: number }
+  ): Promise<ResolvedPrompt>;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyPromptHandle = PromptHandle<string, any>;
+
+/** Extract the identifier (id literal type) from a PromptHandle */
+export type PromptIdentifier<T extends AnyPromptHandle> = T extends PromptHandle<infer TId, any>
+  ? TId
+  : string;
+
+/** Extract the variables input type from a PromptHandle */
+export type PromptVariables<T extends AnyPromptHandle> = T extends PromptHandle<any, infer TVariables>
+  ? inferSchemaIn<TVariables>
+  : Record<string, unknown>;
+
+/**
+ * Compile a Mustache-style template by substituting `{{variable}}` placeholders.
+ */
+function compileTemplate(
+  template: string,
+  variables: Record<string, unknown>
+): string {
+  // Handle conditional sections: {{#key}}...{{/key}}
+  let result = template.replace(
+    /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g,
+    (_match, key, content) => {
+      const value = variables[key];
+      return value
+        ? content.replace(/\{\{(\w+)\}\}/g, (_m: string, k: string) => {
+            return String(variables[k] ?? "");
+          })
+        : "";
+    }
+  );
+
+  // Handle simple substitutions: {{key}}
+  result = result.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
+    const value = variables[key];
+    return value !== undefined && value !== null ? String(value) : "";
+  });
+
+  return result;
+}
+
+function makeToAISDKTelemetry(
+  slug: string,
+  promptId: string,
+  version: number,
+  labels: string[],
+  model?: string,
+  input?: string
+) {
+  return function toAISDKTelemetry(additionalMetadata?: Record<string, string>) {
+    return {
+      experimental_telemetry: {
+        isEnabled: true as const,
+        metadata: {
+          "prompt.slug": slug,
+          "prompt.id": promptId,
+          "prompt.version": String(version),
+          "prompt.labels": labels.join(", "),
+          ...(model ? { "prompt.model": model } : {}),
+          ...(input ? { "prompt.input": input } : {}),
+          ...additionalMetadata,
+        },
+      },
+    };
+  };
+}
+
+function resolveLocally(
+  options: PromptOptions<any, any>,
+  variables: Record<string, unknown>
+): ResolvedPrompt {
+  const inputJson = Object.keys(variables).length > 0 ? JSON.stringify(variables) : undefined;
+  const telemetryFn = makeToAISDKTelemetry(options.id, options.id, 0, ["local"], options.model, inputJson);
+
+  return {
+    promptId: options.id,
+    version: 0,
+    labels: ["local"],
+    text: compileTemplate(options.content, variables),
+    model: options.model,
+    config: options.config,
+    toAISDKTelemetry: telemetryFn,
+  };
+}
+
+export function definePrompt<
+  TIdentifier extends string,
+  TVariables extends TaskSchema | undefined = undefined,
+>(
+  options: PromptOptions<TIdentifier, TVariables>
+): PromptHandle<TIdentifier, TVariables> {
+  const parseVariables = options.variables
+    ? getSchemaParseFn(options.variables)
+    : undefined;
+
+  // Register with resource catalog
+  const metadata: PromptMetadataWithFunctions = {
+    id: options.id,
+    description: options.description,
+    content: options.content,
+    model: options.model,
+    config: options.config,
+    variableSchema: undefined, // Set by CLI via schemaToJsonSchema
+    schema: options.variables,
+    fns: {
+      resolve: async (variables: Record<string, unknown>) => {
+        const validated = parseVariables ? await parseVariables(variables) : variables;
+        return resolveLocally(options, validated as Record<string, unknown>);
+      },
+    },
+  };
+
+  resourceCatalog.registerPromptMetadata(metadata);
+
+  return {
+    id: options.id,
+    resolve: async (variables, resolveOptions) => {
+      // Validate variables if schema provided
+      const validated = parseVariables
+        ? await parseVariables(variables)
+        : variables;
+      const vars = validated as Record<string, unknown>;
+
+      const apiClient = apiClientManager.client;
+
+      // Resolve via the API when a client is configured (inside tasks or via configure())
+      if (apiClient) {
+        const response = await apiClient.resolvePrompt(
+          options.id,
+          {
+            variables: vars,
+            label: resolveOptions?.label,
+            version: resolveOptions?.version,
+          },
+          {
+            tracer,
+            name: "prompt.resolve()",
+            icon: "tabler-file-text-ai",
+            attributes: {
+              [SemanticInternalAttributes.STYLE_ICON]: "tabler-file-text-ai",
+              [SemanticInternalAttributes.ENTITY_TYPE]: "prompt",
+              [SemanticInternalAttributes.ENTITY_ID]: options.id,
+              ...accessoryAttributes({
+                items: [
+                  {
+                    text: options.id,
+                    variant: "normal",
+                  },
+                ],
+                style: "codepath",
+              }),
+            },
+            onResponseBody: (body, span) => {
+              span.setAttribute("prompt.version", body.data.version);
+              span.setAttribute("prompt.slug", body.data.slug);
+              span.setAttribute("prompt.labels", body.data.labels.join(", "));
+              if (body.data.model) {
+                span.setAttribute("prompt.model", body.data.model);
+              }
+              if (body.data.template) {
+                span.setAttribute("prompt.template", body.data.template);
+              }
+              if (body.data.text) {
+                span.setAttribute("prompt.text", body.data.text);
+              }
+              if (body.data.config) {
+                span.setAttribute("prompt.config", JSON.stringify(body.data.config));
+              }
+              if (vars && Object.keys(vars).length > 0) {
+                span.setAttribute("prompt.input", JSON.stringify(vars));
+              }
+            },
+          }
+        );
+
+        const data = response.data;
+        const inputJson = vars && Object.keys(vars).length > 0 ? JSON.stringify(vars) : undefined;
+        const telemetryFn = makeToAISDKTelemetry(
+          data.slug,
+          data.promptId,
+          data.version,
+          data.labels,
+          data.model ?? undefined,
+          inputJson
+        );
+
+        return {
+          promptId: data.promptId,
+          version: data.version,
+          labels: data.labels,
+          text: data.text ?? "",
+          model: data.model ?? undefined,
+          config: (data.config as Record<string, unknown>) ?? undefined,
+          toAISDKTelemetry: telemetryFn,
+        };
+      }
+
+      // Fallback: resolve locally (outside platform or during dev)
+      return resolveLocally(options, vars);
+    },
+  };
+}
diff --git a/packages/trigger-sdk/src/v3/promptManagement.ts b/packages/trigger-sdk/src/v3/promptManagement.ts
new file mode 100644
index 00000000000..480676f445e
--- /dev/null
+++ b/packages/trigger-sdk/src/v3/promptManagement.ts
@@ -0,0 +1,237 @@
+import {
+  accessoryAttributes,
+  apiClientManager,
+  SemanticInternalAttributes,
+  type ApiRequestOptions,
+  type CreatePromptOverrideRequestBody,
+  type ListPromptsResponseBody,
+  type ListPromptVersionsResponseBody,
+  type PromptOkResponseBody,
+  type PromptOverrideCreatedResponseBody,
+  type UpdatePromptOverrideRequestBody,
+} from "@trigger.dev/core/v3";
+import type { AnyPromptHandle, PromptIdentifier, PromptVariables, ResolvedPrompt } from "./prompt.js";
+import { tracer } from "./tracer.js";
+
+function promptSpanOptions(name: string, slug: string) {
+  return {
+    tracer,
+    name,
+    icon: "tabler-file-text-ai",
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "tabler-file-text-ai",
+      ...accessoryAttributes({
+        items: [{ text: slug, variant: "normal" as const }],
+        style: "codepath",
+      }),
+    },
+  };
+}
+
+function makeToAISDKTelemetry(
+  slug: string,
+  promptId: string,
+  version: number,
+  labels: string[],
+  model?: string,
+  input?: string
+) {
+  return function toAISDKTelemetry(additionalMetadata?: Record<string, string>) {
+    return {
+      experimental_telemetry: {
+        isEnabled: true as const,
+        metadata: {
+          "prompt.slug": slug,
+          "prompt.id": promptId,
+          "prompt.version": String(version),
+          "prompt.labels": labels.join(", "),
+          ...(model ? { "prompt.model": model } : {}),
+          ...(input ? { "prompt.input": input } : {}),
+          ...additionalMetadata,
+        },
+      },
+    };
+  };
+}
+
+/**
+ * Resolve a prompt by slug, calling the API to get the current version's
+ * compiled text. Works both inside and outside of a task context — requires
+ * an API client to be configured (via `configure()` or task runtime).
+ */
+export async function resolvePrompt<TPromptHandle extends AnyPromptHandle = AnyPromptHandle>(
+  slug: PromptIdentifier<TPromptHandle>,
+  variables?: PromptVariables<TPromptHandle>,
+  options?: { label?: string; version?: number; requestOptions?: ApiRequestOptions }
+): Promise<ResolvedPrompt> {
+  const apiClient = apiClientManager.clientOrThrow();
+  const vars = variables ?? {};
+  const response = await apiClient.resolvePrompt(
+    slug,
+    {
+      variables: vars,
+      label: options?.label,
+      version: options?.version,
+    },
+    {
+      ...promptSpanOptions("prompts.resolve()", slug),
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "tabler-file-text-ai",
+        [SemanticInternalAttributes.ENTITY_TYPE]: "prompt",
+        [SemanticInternalAttributes.ENTITY_ID]: slug,
+        ...accessoryAttributes({
+          items: [{ text: slug, variant: "normal" as const }],
+          style: "codepath",
+        }),
+      },
+      onResponseBody: (body, span) => {
+        span.setAttribute("prompt.version", body.data.version);
+        span.setAttribute("prompt.slug", body.data.slug);
+        span.setAttribute("prompt.labels", body.data.labels.join(", "));
+        if (body.data.model) span.setAttribute("prompt.model", body.data.model);
+        if (body.data.text) span.setAttribute("prompt.text", body.data.text);
+        if (vars && Object.keys(vars).length > 0) {
+          span.setAttribute("prompt.input", JSON.stringify(vars));
+        }
+      },
+    }
+  );
+
+  const data = response.data;
+  const inputJson = Object.keys(vars).length > 0 ? JSON.stringify(vars) : undefined;
+
+  return {
+    promptId: data.promptId,
+    version: data.version,
+    labels: data.labels,
+    text: data.text ?? "",
+    model: data.model ?? undefined,
+    config: (data.config as Record<string, unknown>) ?? undefined,
+    toAISDKTelemetry: makeToAISDKTelemetry(
+      data.slug,
+      data.promptId,
+      data.version,
+      data.labels,
+      data.model ?? undefined,
+      inputJson
+    ),
+  };
+}
+
+/** List all prompts in the current environment. */
+export function listPrompts(
+  requestOptions?: ApiRequestOptions
+): Promise<ListPromptsResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.listPrompts({
+    tracer,
+    name: "prompts.list()",
+    icon: "tabler-file-text-ai",
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "tabler-file-text-ai",
+    },
+    onResponseBody: (body, span) => {
+      span.setAttribute("prompt.count", body.data.length);
+    },
+  });
+}
+
+/** List all versions for a prompt. */
+export function listPromptVersions(
+  slug: string,
+  requestOptions?: ApiRequestOptions
+): Promise<ListPromptVersionsResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.listPromptVersions(slug, {
+    ...promptSpanOptions("prompts.versions()", slug),
+    onResponseBody: (body, span) => {
+      span.setAttribute("prompt.slug", slug);
+      span.setAttribute("prompt.versions.count", body.data.length);
+    },
+  });
+}
+
+/** Promote a code-deployed version to be the current version. */
+export async function promotePromptVersion(
+  slug: string,
+  version: number,
+  requestOptions?: ApiRequestOptions
+): Promise<PromptOkResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.promotePromptVersion(slug, { version }, {
+    ...promptSpanOptions("prompts.promote()", slug),
+    attributes: {
+      ...promptSpanOptions("prompts.promote()", slug).attributes,
+      "prompt.slug": slug,
+      "prompt.version": version,
+    },
+  });
+}
+
+/** Create an override — a dashboard/API edit that takes priority over the deployed version. */
+export async function createPromptOverride(
+  slug: string,
+  body: CreatePromptOverrideRequestBody,
+  requestOptions?: ApiRequestOptions
+): Promise<PromptOverrideCreatedResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.createPromptOverride(slug, body, {
+    ...promptSpanOptions("prompts.createOverride()", slug),
+    attributes: {
+      ...promptSpanOptions("prompts.createOverride()", slug).attributes,
+      "prompt.slug": slug,
+      ...(body.model ? { "prompt.model": body.model } : {}),
+    },
+    onResponseBody: (body, span) => {
+      span.setAttribute("prompt.override.version", body.version);
+    },
+  });
+}
+
+/** Update the active override's content or model. */
+export async function updatePromptOverride(
+  slug: string,
+  body: UpdatePromptOverrideRequestBody,
+  requestOptions?: ApiRequestOptions
+): Promise<PromptOkResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.updatePromptOverride(slug, body, {
+    ...promptSpanOptions("prompts.updateOverride()", slug),
+    attributes: {
+      ...promptSpanOptions("prompts.updateOverride()", slug).attributes,
+      "prompt.slug": slug,
+    },
+  });
+}
+
+/** Remove the active override, reverting to the current deployed version. */
+export async function removePromptOverride(
+  slug: string,
+  requestOptions?: ApiRequestOptions
+): Promise<PromptOkResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.removePromptOverride(slug, {
+    ...promptSpanOptions("prompts.removeOverride()", slug),
+    attributes: {
+      ...promptSpanOptions("prompts.removeOverride()", slug).attributes,
+      "prompt.slug": slug,
+    },
+  });
+}
+
+/** Reactivate a previously removed override version. */
+export async function reactivatePromptOverride(
+  slug: string,
+  version: number,
+  requestOptions?: ApiRequestOptions
+): Promise<PromptOkResponseBody> {
+  const apiClient = apiClientManager.clientOrThrow();
+  return apiClient.reactivatePromptOverride(slug, { version }, {
+    ...promptSpanOptions("prompts.reactivateOverride()", slug),
+    attributes: {
+      ...promptSpanOptions("prompts.reactivateOverride()", slug).attributes,
+      "prompt.slug": slug,
+      "prompt.version": version,
+    },
+  });
+}
diff --git a/packages/trigger-sdk/src/v3/prompts.ts b/packages/trigger-sdk/src/v3/prompts.ts
new file mode 100644
index 00000000000..df41915793a
--- /dev/null
+++ b/packages/trigger-sdk/src/v3/prompts.ts
@@ -0,0 +1,20 @@
+export { definePrompt as define } from "./prompt.js";
+export type {
+  AnyPromptHandle,
+  PromptHandle,
+  PromptIdentifier,
+  PromptOptions,
+  PromptVariables,
+  ResolvedPrompt,
+} from "./prompt.js";
+
+export {
+  resolvePrompt as resolve,
+  listPrompts as list,
+  listPromptVersions as versions,
+  promotePromptVersion as promote,
+  createPromptOverride as createOverride,
+  updatePromptOverride as updateOverride,
+  removePromptOverride as removeOverride,
+  reactivatePromptOverride as reactivateOverride,
+} from "./promptManagement.js";
diff --git a/packages/trigger-sdk/src/v3/query.ts b/packages/trigger-sdk/src/v3/query.ts
new file mode 100644
index 00000000000..8d86416b271
--- /dev/null
+++ b/packages/trigger-sdk/src/v3/query.ts
@@ -0,0 +1,184 @@
+import type {
+  ApiRequestOptions,
+  Prettify,
+  QueryExecuteResponseBody,
+  QueryExecuteCSVResponseBody,
+} from "@trigger.dev/core/v3";
+import { apiClientManager, mergeRequestOptions } from "@trigger.dev/core/v3";
+import { tracer } from "./tracer.js";
+
+export type { QueryTable, RunsTableRow, RunFriendlyStatus } from "@trigger.dev/core/v3";
+
+export type QueryScope = "environment" | "project" | "organization";
+export type QueryFormat = "json" | "csv";
+
+/**
+ * Options for executing a TRQL query
+ */
+export type QueryOptions = {
+  /**
+   * The scope of the query - determines what data is accessible
+   * - "environment": Current environment only (default)
+   * - "project": All environments in the project
+   * - "organization": All projects in the organization
+   *
+   * @default "environment"
+   */
+  scope?: QueryScope;
+
+  /**
+   * Time period to query (e.g., "7d", "30d", "1h")
+   * Cannot be used with `from` or `to`
+   */
+  period?: string;
+
+  /**
+   * Start of time range as a Date object or Unix timestamp in milliseconds.
+   * Must be used with `to`.
+   */
+  from?: Date | number;
+
+  /**
+   * End of time range as a Date object or Unix timestamp in milliseconds.
+   * Must be used with `from`.
+   */
+  to?: Date | number;
+
+  /**
+   * Response format
+   * - "json": Returns structured data (default)
+   * - "csv": Returns CSV string
+   *
+   * @default "json"
+   */
+  format?: QueryFormat;
+};
+
+/**
+ * Execute a TRQL query and get the results as a CSV string.
+ *
+ * @param {string} query - The TRQL query string to execute
+ * @param {QueryOptions & { format: "csv" }} options - Query options with `format: "csv"`
+ * @param {ApiRequestOptions} [requestOptions] - Optional API request configuration
+ * @returns A promise resolving to `{ format: "csv", results: string }` where `results` is the raw CSV text
+ *
+ * @example
+ * ```typescript
+ * const csvResult = await query.execute(
+ *   "SELECT run_id, status, triggered_at FROM runs",
+ *   { format: "csv", period: "7d" }
+ * );
+ * const lines = csvResult.results.split('\n');
+ * ```
+ */
+function execute(
+  query: string,
+  options: QueryOptions & { format: "csv" },
+  requestOptions?: ApiRequestOptions
+): Promise<{ format: "csv"; results: string }>;
+
+/**
+ * Execute a TRQL query and return typed JSON rows.
+ *
+ * @template TRow - The shape of each row in the result set. Use {@link QueryTable} for type-safe column access (e.g. `QueryTable<"runs", "status" | "run_id">`)
+ * @param {string} query - The TRQL query string to execute
+ * @param {QueryOptions} [options] - Optional query configuration
+ * @param {ApiRequestOptions} [requestOptions] - Optional API request configuration
+ * @returns A promise resolving to `{ format: "json", results: Array<TRow> }`
+ *
+ * @example
+ * ```typescript
+ * // Basic query with defaults (environment scope, json format)
+ * const result = await query.execute("SELECT run_id, status FROM runs LIMIT 10");
+ * console.log(result.results); // Array<Record<string, any>>
+ *
+ * // Type-safe query using QueryTable with specific columns
+ * const typedResult = await query.execute<QueryTable<"runs", "run_id" | "status" | "triggered_at">>(
+ *   "SELECT run_id, status, triggered_at FROM runs LIMIT 10"
+ * );
+ * typedResult.results.forEach(row => {
+ *   console.log(row.run_id, row.status); // Fully typed!
+ * });
+ *
+ * // Inline type for aggregation queries
+ * const stats = await query.execute<{ status: string; count: number }>(
+ *   "SELECT status, COUNT(*) as count FROM runs GROUP BY status"
+ * );
+ * stats.results.forEach(row => {
+ *   console.log(row.status, row.count); // Fully type-safe
+ * });
+ *
+ * // Query with a custom time period
+ * const recent = await query.execute(
+ *   "SELECT COUNT(*) as count FROM runs",
+ *   { period: "3d" }
+ * );
+ * console.log(recent.results[0].count);
+ * ```
+ */
+function execute<TRow extends Record<string, any> = Record<string, any>>(
+  query: string,
+  options?: Omit<QueryOptions, "format"> | (QueryOptions & { format?: "json" }),
+  requestOptions?: ApiRequestOptions
+): Promise<{ format: "json"; results: Array<Prettify<TRow>> }>;
+
+// Implementation
+function execute<TRow extends Record<string, any> = Record<string, any>>(
+  query: string,
+  options?: QueryOptions,
+  requestOptions?: ApiRequestOptions
+): Promise<{ format: "json"; results: Array<TRow> } | { format: "csv"; results: string }> {
+  const apiClient = apiClientManager.clientOrThrow();
+
+  const from = dateToISOString(options?.from);
+  const to = dateToISOString(options?.to);
+
+  const $requestOptions = mergeRequestOptions(
+    {
+      tracer,
+      name: "query.execute()",
+      icon: "query",
+      attributes: {
+        scope: options?.scope ?? "environment",
+        format: options?.format ?? "json",
+        query,
+        period: options?.period,
+        from,
+        to,
+      },
+    },
+    requestOptions
+  );
+
+  return apiClient
+    .executeQuery(
+      query,
+      {
+        scope: options?.scope,
+        period: options?.period,
+        from,
+        to,
+        format: options?.format,
+      },
+      $requestOptions
+    )
+    .then((response) => {
+      return response;
+    }) as Promise<{ format: "json"; results: Array<TRow> } | { format: "csv"; results: string }>;
+}
+
+function dateToISOString(date: Date | number | undefined): string | undefined {
+  if (date === undefined) {
+    return undefined;
+  }
+
+  if (date instanceof Date) {
+    return date.toISOString();
+  }
+
+  return new Date(date).toISOString();
+}
+
+export const query = {
+  execute,
+};
diff --git a/packages/trigger-sdk/src/v3/shared.ts b/packages/trigger-sdk/src/v3/shared.ts
index 87025f08168..c69bceeb535 100644
--- a/packages/trigger-sdk/src/v3/shared.ts
+++ b/packages/trigger-sdk/src/v3/shared.ts
@@ -2,6 +2,7 @@ import { SpanKind } from "@opentelemetry/api";
 import { SerializableJson } from "@trigger.dev/core";
 import {
   accessoryAttributes,
+  ApiError,
   apiClientManager,
   ApiRequestOptions,
   conditionallyImportPacket,
@@ -10,6 +11,7 @@ import {
   defaultRetryOptions,
   flattenIdempotencyKey,
   getEnvVar,
+  getIdempotencyKeyOptions,
   getSchemaParseFn,
   InitOutput,
   lifecycleHooks,
@@ -17,6 +19,7 @@ import {
   parsePacket,
   Queue,
   QueueOptions,
+  RateLimitError,
   resourceCatalog,
   runtime,
   SemanticInternalAttributes,
@@ -125,9 +128,6 @@ export { SubtaskUnwrapError, TaskRunPromise };
 
 export type Context = TaskRunContext;
 
-// Re-export for external use (defined later in file)
-export { BatchTriggerError };
-
 export function queue(options: QueueOptions): Queue {
   resourceCatalog.registerQueueMetadata(options);
 
@@ -236,6 +236,7 @@ export function createTask<
     retry: params.retry ? { ...defaultRetryOptions, ...params.retry } : undefined,
     machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
     maxDuration: params.maxDuration,
+    ttl: params.ttl,
     payloadSchema: params.jsonSchema,
     fns: {
       run: params.run,
@@ -367,6 +368,7 @@ export function createSchemaTask<
     retry: params.retry ? { ...defaultRetryOptions, ...params.retry } : undefined,
     machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
     maxDuration: params.maxDuration,
+    ttl: params.ttl,
     fns: {
       run: params.run,
       parsePayload,
@@ -936,7 +938,7 @@ export async function batchTriggerByIdAndWait<TTask extends AnyTask>(
           ctx,
         });
 
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
 
         return {
           id: result.id,
@@ -980,7 +982,7 @@ export async function batchTriggerByIdAndWait<TTask extends AnyTask>(
           ctx,
         });
 
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
 
         return {
           id: result.id,
@@ -1457,7 +1459,7 @@ export async function batchTriggerAndWaitTasks<TTasks extends readonly AnyTask[]
           ctx,
         });
 
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
 
         return {
           id: result.id,
@@ -1504,7 +1506,7 @@ export async function batchTriggerAndWaitTasks<TTasks extends readonly AnyTask[]
           ctx,
         });
 
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
 
         return {
           id: result.id,
@@ -1541,10 +1543,11 @@ async function executeBatchTwoPhase(
     parentRunId?: string;
     resumeParentOnCompletion?: boolean;
     idempotencyKey?: string;
+    idempotencyKeyOptions?: { key: string; scope: "run" | "attempt" | "global" };
     spanParentAsLink?: boolean;
   },
   requestOptions?: TriggerApiRequestOptions
-): Promise<{ id: string; runCount: number; publicAccessToken: string }> {
+): Promise<{ id: string; runCount: number; publicAccessToken: string; taskIdentifiers: string[] }> {
   let batch: Awaited<ReturnType<typeof apiClient.createBatch>> | undefined;
 
   try {
@@ -1555,6 +1558,7 @@ async function executeBatchTwoPhase(
         parentRunId: options.parentRunId,
         resumeParentOnCompletion: options.resumeParentOnCompletion,
         idempotencyKey: options.idempotencyKey,
+        idempotencyKeyOptions: options.idempotencyKeyOptions,
       },
       { spanParentAsLink: options.spanParentAsLink },
       requestOptions
@@ -1586,18 +1590,35 @@ async function executeBatchTwoPhase(
     id: batch.id,
     runCount: batch.runCount,
     publicAccessToken: batch.publicAccessToken,
+    taskIdentifiers: items.map((item) => item.task),
   };
 }
 
 /**
  * Error thrown when batch trigger operations fail.
  * Includes context about which phase failed and the batch details.
+ *
+ * When the underlying error is a rate limit (429), additional properties are exposed:
+ * - `isRateLimited`: true
+ * - `retryAfterMs`: milliseconds until the rate limit resets
  */
-class BatchTriggerError extends Error {
+export class BatchTriggerError extends Error {
   readonly phase: "create" | "stream";
   readonly batchId?: string;
   readonly itemCount: number;
 
+  /** True if the error was caused by rate limiting (HTTP 429) */
+  readonly isRateLimited: boolean;
+
+  /** Milliseconds until the rate limit resets. Only set when `isRateLimited` is true. */
+  readonly retryAfterMs?: number;
+
+  /** The underlying API error, if the cause was an ApiError */
+  readonly apiError?: ApiError;
+
+  /** The underlying cause of the error */
+  override readonly cause?: unknown;
+
   constructor(
     message: string,
     options: {
@@ -1607,14 +1628,61 @@ class BatchTriggerError extends Error {
       itemCount: number;
     }
   ) {
-    super(message, { cause: options.cause });
+    // Build enhanced message that includes the cause's message
+    const fullMessage = buildBatchErrorMessage(message, options.cause);
+    super(fullMessage, { cause: options.cause });
+
     this.name = "BatchTriggerError";
+    this.cause = options.cause;
     this.phase = options.phase;
     this.batchId = options.batchId;
     this.itemCount = options.itemCount;
+
+    // Extract rate limit info from cause
+    if (options.cause instanceof RateLimitError) {
+      this.isRateLimited = true;
+      this.retryAfterMs = options.cause.millisecondsUntilReset;
+      this.apiError = options.cause;
+    } else if (options.cause instanceof ApiError) {
+      this.isRateLimited = options.cause.status === 429;
+      this.apiError = options.cause;
+    } else {
+      this.isRateLimited = false;
+    }
   }
 }
 
+/**
+ * Build an enhanced error message that includes context from the cause.
+ */
+function buildBatchErrorMessage(baseMessage: string, cause: unknown): string {
+  if (!cause) {
+    return baseMessage;
+  }
+
+  // Handle RateLimitError specifically for better messaging
+  if (cause instanceof RateLimitError) {
+    const retryMs = cause.millisecondsUntilReset;
+    if (retryMs !== undefined) {
+      const retrySeconds = Math.ceil(retryMs / 1000);
+      return `${baseMessage}: Rate limit exceeded - retry after ${retrySeconds}s`;
+    }
+    return `${baseMessage}: Rate limit exceeded`;
+  }
+
+  // Handle other ApiErrors
+  if (cause instanceof ApiError) {
+    return `${baseMessage}: ${cause.message}`;
+  }
+
+  // Handle generic errors
+  if (cause instanceof Error) {
+    return `${baseMessage}: ${cause.message}`;
+  }
+
+  return baseMessage;
+}
+
 /**
  * Execute a streaming 2-phase batch trigger where items are streamed from an AsyncIterable.
  * Unlike executeBatchTwoPhase, this doesn't know the count upfront.
@@ -1634,10 +1702,11 @@ async function executeBatchTwoPhaseStreaming(
     parentRunId?: string;
     resumeParentOnCompletion?: boolean;
     idempotencyKey?: string;
+    idempotencyKeyOptions?: { key: string; scope: "run" | "attempt" | "global" };
     spanParentAsLink?: boolean;
   },
   requestOptions?: TriggerApiRequestOptions
-): Promise<{ id: string; runCount: number; publicAccessToken: string }> {
+): Promise<{ id: string; runCount: number; publicAccessToken: string; taskIdentifiers: string[] }> {
   // For streaming, we need to buffer items to get the count first
   // This is because createBatch requires runCount upfront
   // In the future, we could add a streaming-first endpoint that doesn't require this
@@ -1996,6 +2065,13 @@ async function* transformSingleTaskBatchItemsStreamForWait<TPayload>(
       flattenIdempotencyKey([options?.idempotencyKey, `${index}`])
     );
 
+    // Process item-specific idempotency key and extract options
+    const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+    const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+    const idempotencyKeyOptions = itemIdempotencyKey
+      ? getIdempotencyKeyOptions(itemIdempotencyKey)
+      : undefined;
+
     yield {
       index: index++,
       task: taskIdentifier,
@@ -2016,9 +2092,9 @@ async function* transformSingleTaskBatchItemsStreamForWait<TPayload>(
         maxAttempts: item.options?.maxAttempts,
         metadata: item.options?.metadata,
         maxDuration: item.options?.maxDuration,
-        idempotencyKey:
-          (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+        idempotencyKey: finalIdempotencyKey?.toString(),
         idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+        idempotencyKeyOptions,
         machine: item.options?.machine,
         priority: item.options?.priority,
         region: item.options?.region,
@@ -2042,6 +2118,12 @@ async function trigger_internal<TRunTypes extends AnyRunTypes>(
 
   const payloadPacket = await stringifyIO(parsedPayload);
 
+  // Process idempotency key and extract options for storage
+  const processedIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+  const idempotencyKeyOptions = processedIdempotencyKey
+    ? getIdempotencyKeyOptions(processedIdempotencyKey)
+    : undefined;
+
   const handle = await apiClient.triggerTask(
     id,
     {
@@ -2051,8 +2133,9 @@ async function trigger_internal<TRunTypes extends AnyRunTypes>(
         concurrencyKey: options?.concurrencyKey,
         test: taskContext.ctx?.run.isTest,
         payloadType: payloadPacket.dataType,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+        idempotencyKey: processedIdempotencyKey?.toString(),
         idempotencyKeyTTL: options?.idempotencyKeyTTL,
+        idempotencyKeyOptions,
         delay: options?.delay,
         ttl: options?.ttl,
         tags: options?.tags,
@@ -2117,6 +2200,13 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
           flattenIdempotencyKey([options?.idempotencyKey, `${index}`])
         );
 
+        // Process item-specific idempotency key and extract options
+        const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+        const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+        const idempotencyKeyOptions = itemIdempotencyKey
+          ? getIdempotencyKeyOptions(itemIdempotencyKey)
+          : undefined;
+
         return {
           index,
           task: taskIdentifier,
@@ -2136,9 +2226,9 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
             maxAttempts: item.options?.maxAttempts,
             metadata: item.options?.metadata,
             maxDuration: item.options?.maxDuration,
-            idempotencyKey:
-              (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+            idempotencyKey: finalIdempotencyKey?.toString(),
             idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+            idempotencyKeyOptions,
             machine: item.options?.machine,
             priority: item.options?.priority,
             region: item.options?.region,
@@ -2149,6 +2239,12 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
     );
 
     // Execute 2-phase batch
+    // Process batch-level idempotency key
+    const batchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const batchIdempotencyKeyOptions = batchIdempotencyKey
+      ? getIdempotencyKeyOptions(batchIdempotencyKey)
+      : undefined;
+
     const response = await tracer.startActiveSpan(
       name,
       async (span) => {
@@ -2157,7 +2253,8 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
           ndJsonItems,
           {
             parentRunId: ctx?.run.id,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKey: batchIdempotencyKey?.toString(),
+            idempotencyKeyOptions: batchIdempotencyKeyOptions,
             spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
           },
           requestOptions
@@ -2204,6 +2301,12 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
     );
 
     // Execute streaming 2-phase batch
+    // Process batch-level idempotency key
+    const streamBatchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const streamBatchIdempotencyKeyOptions = streamBatchIdempotencyKey
+      ? getIdempotencyKeyOptions(streamBatchIdempotencyKey)
+      : undefined;
+
     const response = await tracer.startActiveSpan(
       name,
       async (span) => {
@@ -2212,7 +2315,8 @@ async function batchTrigger_internal<TRunTypes extends AnyRunTypes>(
           transformedItems,
           {
             parentRunId: ctx?.run.id,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKey: streamBatchIdempotencyKey?.toString(),
+            idempotencyKeyOptions: streamBatchIdempotencyKeyOptions,
             spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
           },
           requestOptions
@@ -2270,6 +2374,12 @@ async function triggerAndWait_internal<TIdentifier extends string, TPayload, TOu
 
   const payloadPacket = await stringifyIO(parsedPayload);
 
+  // Process idempotency key and extract options for storage
+  const processedIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+  const idempotencyKeyOptions = processedIdempotencyKey
+    ? getIdempotencyKeyOptions(processedIdempotencyKey)
+    : undefined;
+
   return await tracer.startActiveSpan(
     name,
     async (span) => {
@@ -2291,8 +2401,9 @@ async function triggerAndWait_internal<TIdentifier extends string, TPayload, TOu
             maxDuration: options?.maxDuration,
             resumeParentOnCompletion: true,
             parentRunId: ctx.run.id,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKey: processedIdempotencyKey?.toString(),
             idempotencyKeyTTL: options?.idempotencyKeyTTL,
+            idempotencyKeyOptions,
             machine: options?.machine,
             priority: options?.priority,
             region: options?.region,
@@ -2363,6 +2474,13 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
           flattenIdempotencyKey([options?.idempotencyKey, `${index}`])
         );
 
+        // Process item-specific idempotency key and extract options
+        const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+        const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+        const idempotencyKeyOptions = itemIdempotencyKey
+          ? getIdempotencyKeyOptions(itemIdempotencyKey)
+          : undefined;
+
         return {
           index,
           task: id,
@@ -2383,9 +2501,9 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
             maxAttempts: item.options?.maxAttempts,
             metadata: item.options?.metadata,
             maxDuration: item.options?.maxDuration,
-            idempotencyKey:
-              (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+            idempotencyKey: finalIdempotencyKey?.toString(),
             idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+            idempotencyKeyOptions,
             machine: item.options?.machine,
             priority: item.options?.priority,
             region: item.options?.region,
@@ -2394,6 +2512,12 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
       })
     );
 
+    // Process batch-level idempotency key
+    const batchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const batchIdempotencyKeyOptions = batchIdempotencyKey
+      ? getIdempotencyKeyOptions(batchIdempotencyKey)
+      : undefined;
+
     return await tracer.startActiveSpan(
       name,
       async (span) => {
@@ -2404,7 +2528,8 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
           {
             parentRunId: ctx.run.id,
             resumeParentOnCompletion: true,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKey: batchIdempotencyKey?.toString(),
+            idempotencyKeyOptions: batchIdempotencyKeyOptions,
             spanParentAsLink: false, // Waiting: child runs share parent's trace ID
           },
           requestOptions
@@ -2456,6 +2581,12 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
       queue
     );
 
+    // Process batch-level idempotency key for streaming path
+    const streamBatchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const streamBatchIdempotencyKeyOptions = streamBatchIdempotencyKey
+      ? getIdempotencyKeyOptions(streamBatchIdempotencyKey)
+      : undefined;
+
     return await tracer.startActiveSpan(
       name,
       async (span) => {
@@ -2466,7 +2597,8 @@ async function batchTriggerAndWait_internal<TIdentifier extends string, TPayload
           {
             parentRunId: ctx.run.id,
             resumeParentOnCompletion: true,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKey: streamBatchIdempotencyKey?.toString(),
+            idempotencyKeyOptions: streamBatchIdempotencyKeyOptions,
             spanParentAsLink: false, // Waiting: child runs share parent's trace ID
           },
           requestOptions
@@ -2547,7 +2679,8 @@ async function handleBatchTaskRunExecutionResult<TIdentifier extends string, TOu
 }
 
 async function handleBatchTaskRunExecutionResultV2(
-  items: Array<TaskRunExecutionResult>
+  items: Array<TaskRunExecutionResult>,
+  taskIdentifiers?: string[]
 ): Promise<Array<AnyTaskRunResult>> {
   const someObjectStoreOutputs = items.some(
     (item) => item.ok && item.outputType === "application/store"
@@ -2555,8 +2688,11 @@ async function handleBatchTaskRunExecutionResultV2(
 
   if (!someObjectStoreOutputs) {
     const results = await Promise.all(
-      items.map(async (item) => {
-        return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
+      items.map(async (item, index) => {
+        return await handleTaskRunExecutionResult(
+          item,
+          item.taskIdentifier ?? taskIdentifiers?.[index] ?? "unknown"
+        );
       })
     );
 
@@ -2567,8 +2703,11 @@ async function handleBatchTaskRunExecutionResultV2(
     "store.downloadPayloads",
     async (span) => {
       const results = await Promise.all(
-        items.map(async (item) => {
-          return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
+        items.map(async (item, index) => {
+          return await handleTaskRunExecutionResult(
+            item,
+            item.taskIdentifier ?? taskIdentifiers?.[index] ?? "unknown"
+          );
         })
       );
 
diff --git a/packages/trigger-sdk/src/v3/streams.test.ts b/packages/trigger-sdk/src/v3/streams.test.ts
new file mode 100644
index 00000000000..67ee00fd261
--- /dev/null
+++ b/packages/trigger-sdk/src/v3/streams.test.ts
@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { streams } from "./streams.js";
+import { taskContext, realtimeStreams } from "@trigger.dev/core/v3";
+
+vi.mock("@trigger.dev/core/v3", async (importOriginal) => {
+    const original = await importOriginal<typeof import("@trigger.dev/core/v3")>();
+    return {
+        ...original,
+        taskContext: {
+            ctx: {
+                run: {
+                    id: "run_123",
+                    // parentTaskRunId and rootTaskRunId are undefined for root tasks
+                },
+            },
+        },
+        realtimeStreams: {
+            pipe: vi.fn().mockReturnValue({
+                wait: () => Promise.resolve(),
+                stream: new ReadableStream(),
+            }),
+        },
+    };
+});
+
+describe("streams.pipe consistency", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should not throw and should use self runId when target is 'root' in a root task", async () => {
+        const mockStream = new ReadableStream();
+
+        // This should not throw anymore
+        const { waitUntilComplete } = streams.pipe("test-key", mockStream, {
+            target: "root",
+        });
+
+        expect(realtimeStreams.pipe).toHaveBeenCalledWith(
+            "test-key",
+            mockStream,
+            expect.objectContaining({
+                target: "run_123",
+            })
+        );
+    });
+
+    it("should not throw and should use self runId when target is 'parent' in a root task", async () => {
+        const mockStream = new ReadableStream();
+
+        // This should not throw anymore
+        const { waitUntilComplete } = streams.pipe("test-key", mockStream, {
+            target: "parent",
+        });
+
+        expect(realtimeStreams.pipe).toHaveBeenCalledWith(
+            "test-key",
+            mockStream,
+            expect.objectContaining({
+                target: "run_123",
+            })
+        );
+    });
+});
diff --git a/packages/trigger-sdk/src/v3/streams.ts b/packages/trigger-sdk/src/v3/streams.ts
index 78b70f299c8..68edc2a64ab 100644
--- a/packages/trigger-sdk/src/v3/streams.ts
+++ b/packages/trigger-sdk/src/v3/streams.ts
@@ -1,6 +1,7 @@
 import {
   type ApiRequestOptions,
   realtimeStreams,
+  inputStreams,
   taskContext,
   type RealtimeStreamOperationOptions,
   mergeRequestOptions,
@@ -15,7 +16,19 @@ import {
   AppendStreamOptions,
   RealtimeDefinedStream,
   InferStreamType,
+  ManualWaitpointPromise,
+  WaitpointTimeoutError,
+  runtime,
+  type RealtimeDefinedInputStream,
+  type InputStreamSubscription,
+  type InputStreamOnceOptions,
+  InputStreamOncePromise,
+  type InputStreamOnceResult,
+  type InputStreamWaitOptions,
+  type SendInputStreamOptions,
+  type InferInputStreamType,
 } from "@trigger.dev/core/v3";
+import { conditionallyImportAndParsePacket } from "@trigger.dev/core/v3/utils/ioSerialization";
 import { tracer } from "./tracer.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 
@@ -652,7 +665,191 @@ function define<TPart>(opts: RealtimeDefineStreamOptions): RealtimeDefinedStream
   };
 }
 
-export type { InferStreamType };
+export type { InferStreamType, InferInputStreamType };
+
+/**
+ * Define an input stream that can receive typed data from external callers.
+ *
+ * Inside a task, use `.on()`, `.once()`, or `.peek()` to receive data.
+ * Outside a task (e.g., from your backend), use `.send(runId, data)` to send data.
+ *
+ * @template TData - The type of data this input stream receives
+ * @param opts - Options including a unique `id` for this input stream
+ *
+ * @example
+ * ```ts
+ * import { streams, task } from "@trigger.dev/sdk";
+ *
+ * const approval = streams.input<{ approved: boolean; reviewer: string }>({ id: "approval" });
+ *
+ * export const myTask = task({
+ *   id: "my-task",
+ *   run: async (payload) => {
+ *     // Wait for the next approval
+ *     const data = await approval.once().unwrap();
+ *     console.log(data.approved, data.reviewer);
+ *   },
+ * });
+ *
+ * // From your backend:
+ * // await approval.send(runId, { approved: true, reviewer: "alice" });
+ * ```
+ */
+function input<TData>(opts: { id: string }): RealtimeDefinedInputStream<TData> {
+  return {
+    id: opts.id,
+    on(handler) {
+      return inputStreams.on(
+        opts.id,
+        handler as (data: unknown) => void | Promise<void>
+      );
+    },
+    once(options) {
+      const ctx = taskContext.ctx;
+      const runId = ctx?.run.id;
+
+      const innerPromise = inputStreams.once(opts.id, options);
+
+      return new InputStreamOncePromise<TData>((resolve, reject) => {
+        tracer
+          .startActiveSpan(
+            `inputStream.once()`,
+            async () => {
+              const result = await innerPromise;
+              resolve(result as InputStreamOnceResult<TData>);
+            },
+            {
+              attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "streams",
+                [SemanticInternalAttributes.ENTITY_TYPE]: "input-stream",
+                ...(runId
+                  ? { [SemanticInternalAttributes.ENTITY_ID]: `${runId}:${opts.id}` }
+                  : {}),
+                streamId: opts.id,
+                ...accessoryAttributes({
+                  items: [{ text: opts.id, variant: "normal" }],
+                  style: "codepath",
+                }),
+              },
+            }
+          )
+          .catch(reject);
+      });
+    },
+    peek() {
+      return inputStreams.peek(opts.id) as TData | undefined;
+    },
+    wait(options) {
+      return new ManualWaitpointPromise<TData>(async (resolve, reject) => {
+        try {
+          const ctx = taskContext.ctx;
+
+          if (!ctx) {
+            throw new Error("inputStream.wait() can only be used from inside a task.run()");
+          }
+
+          const apiClient = apiClientManager.clientOrThrow();
+
+          const result = await tracer.startActiveSpan(
+            `inputStream.wait()`,
+            async (span) => {
+              // 1. Create a waitpoint linked to this input stream
+              const response = await apiClient.createInputStreamWaitpoint(ctx.run.id, {
+                streamId: opts.id,
+                timeout: options?.timeout,
+                idempotencyKey: options?.idempotencyKey,
+                idempotencyKeyTTL: options?.idempotencyKeyTTL,
+                tags: options?.tags,
+                lastSeqNum: inputStreams.lastSeqNum(opts.id),
+              });
+
+              // Set the entity ID now that we have the waitpoint ID
+              span.setAttribute(SemanticInternalAttributes.ENTITY_ID, response.waitpointId);
+
+              // 2. Block the run on the waitpoint
+              const waitResponse = await apiClient.waitForWaitpointToken({
+                runFriendlyId: ctx.run.id,
+                waitpointFriendlyId: response.waitpointId,
+              });
+
+              if (!waitResponse.success) {
+                throw new Error("Failed to block on input stream waitpoint");
+              }
+
+              // 3. Suspend the task
+              const waitResult = await runtime.waitUntil(response.waitpointId);
+
+              // 4. Parse the output
+              const data =
+                waitResult.output !== undefined
+                  ? await conditionallyImportAndParsePacket(
+                    {
+                      data: waitResult.output,
+                      dataType: waitResult.outputType ?? "application/json",
+                    },
+                    apiClient
+                  )
+                  : undefined;
+
+              if (waitResult.ok) {
+                return { ok: true as const, output: data as TData };
+              } else {
+                const error = new WaitpointTimeoutError(data?.message ?? "Timed out");
+
+                span.recordException(error);
+                span.setStatus({ code: SpanStatusCode.ERROR });
+
+                return { ok: false as const, error };
+              }
+            },
+            {
+              attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "wait",
+                [SemanticInternalAttributes.ENTITY_TYPE]: "waitpoint",
+                streamId: opts.id,
+                ...accessoryAttributes({
+                  items: [
+                    {
+                      text: opts.id,
+                      variant: "normal",
+                    },
+                  ],
+                  style: "codepath",
+                }),
+              },
+            }
+          );
+
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    },
+    async send(runId, data, options) {
+      return tracer.startActiveSpan(
+        `inputStream.send()`,
+        async () => {
+          const apiClient = apiClientManager.clientOrThrow();
+          await apiClient.sendInputStream(runId, opts.id, data, options?.requestOptions);
+        },
+        {
+          attributes: {
+            [SemanticInternalAttributes.STYLE_ICON]: "streams",
+            [SemanticInternalAttributes.ENTITY_TYPE]: "input-stream",
+            [SemanticInternalAttributes.ENTITY_ID]: `${runId}:${opts.id}`,
+            streamId: opts.id,
+            runId,
+            ...accessoryAttributes({
+              items: [{ text: opts.id, variant: "normal" }],
+              style: "codepath",
+            }),
+          },
+        }
+      );
+    },
+  };
+}
 
 export const streams = {
   pipe,
@@ -660,16 +857,17 @@ export const streams = {
   append,
   writer,
   define,
+  input,
 };
 
 function getRunIdForOptions(options?: RealtimeStreamOperationOptions): string | undefined {
   if (options?.target) {
     if (options.target === "parent") {
-      return taskContext.ctx?.run?.parentTaskRunId;
+      return taskContext.ctx?.run?.parentTaskRunId ?? taskContext.ctx?.run?.id;
     }
 
     if (options.target === "root") {
-      return taskContext.ctx?.run?.rootTaskRunId;
+      return taskContext.ctx?.run?.rootTaskRunId ?? taskContext.ctx?.run?.id;
     }
 
     if (options.target === "self") {
diff --git a/packages/trigger-sdk/src/v3/wait.ts b/packages/trigger-sdk/src/v3/wait.ts
index 7ac85b03429..aab0797f4f3 100644
--- a/packages/trigger-sdk/src/v3/wait.ts
+++ b/packages/trigger-sdk/src/v3/wait.ts
@@ -11,6 +11,7 @@ import {
   CursorPagePromise,
   flattenAttributes,
   ListWaitpointTokensQueryParams,
+  ManualWaitpointPromise,
   mergeRequestOptions,
   runtime,
   SemanticInternalAttributes,
@@ -19,6 +20,7 @@ import {
   WaitpointRetrieveTokenResponse,
   WaitpointTokenStatus,
   WaitpointTokenTypedResult,
+  WaitpointTimeoutError,
 } from "@trigger.dev/core/v3";
 import { conditionallyImportAndParsePacket } from "@trigger.dev/core/v3/utils/ioSerialization";
 import { tracer } from "./tracer.js";
@@ -378,12 +380,7 @@ type WaitPeriod =
       years: number;
     };
 
-export class WaitpointTimeoutError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "WaitpointTimeoutError";
-  }
-}
+export { WaitpointTimeoutError, ManualWaitpointPromise } from "@trigger.dev/core/v3";
 
 const DURATION_WAIT_CHARGE_THRESHOLD_MS = 5000;
 
@@ -393,29 +390,6 @@ function printWaitBelowThreshold() {
   );
 }
 
-class ManualWaitpointPromise<TOutput> extends Promise<WaitpointTokenTypedResult<TOutput>> {
-  constructor(
-    executor: (
-      resolve: (
-        value: WaitpointTokenTypedResult<TOutput> | PromiseLike<WaitpointTokenTypedResult<TOutput>>
-      ) => void,
-      reject: (reason?: any) => void
-    ) => void
-  ) {
-    super(executor);
-  }
-
-  unwrap(): Promise<TOutput> {
-    return this.then((result) => {
-      if (result.ok) {
-        return result.output;
-      } else {
-        throw new WaitpointTimeoutError(result.error.message);
-      }
-    });
-  }
-}
-
 export const wait = {
   for: async (options: WaitForOptions) => {
     const ctx = taskContext.ctx;
diff --git a/patches/@upstash__ratelimit.patch b/patches/@upstash__ratelimit.patch
new file mode 100644
index 00000000000..840984fbaa8
--- /dev/null
+++ b/patches/@upstash__ratelimit.patch
@@ -0,0 +1,26 @@
+diff --git a/dist/index.js b/dist/index.js
+index 7d1502426320957017988aed0c29974acd70e8da..062769cda055302d737503e5d1ba5e62609c934f 100644
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -841,7 +841,7 @@ var tokenBucketLimitScript = `
+     refilledAt = refilledAt + numRefills * interval
+   end
+ 
+-  if tokens == 0 then
++  if tokens < incrementBy then
+     return {-1, refilledAt + interval}
+   end
+ 
+diff --git a/dist/index.mjs b/dist/index.mjs
+index 25a2c888be27b7c5aff41de63d5df189e0031145..53b4a4b2d2ef55f709f7404cc6a66058b7f3191a 100644
+--- a/dist/index.mjs
++++ b/dist/index.mjs
+@@ -813,7 +813,7 @@ var tokenBucketLimitScript = `
+     refilledAt = refilledAt + numRefills * interval
+   end
+ 
+-  if tokens == 0 then
++  if tokens < incrementBy then
+     return {-1, refilledAt + interval}
+   end
+ 
diff --git a/patches/@window-splitter__state@0.4.1.patch b/patches/@window-splitter__state@0.4.1.patch
new file mode 100644
index 00000000000..8d99b717ba8
--- /dev/null
+++ b/patches/@window-splitter__state@0.4.1.patch
@@ -0,0 +1,28 @@
+diff --git a/dist/commonjs/index.js b/dist/commonjs/index.js
+index acb542b1b71a7e808173d938d16f45a484334f94..dc9289461b761f8f0d5c72919f48f94e394addfd 100644
+--- a/dist/commonjs/index.js
++++ b/dist/commonjs/index.js
+@@ -107,6 +107,9 @@ function prepareSnapshot(snapshot) {
+             if (item.max && item.max !== "1fr") {
+                 item.max.value = new big_js_1.default(item.max.value);
+             }
++            if (item.default && typeof item.default === "object" && item.default.value !== undefined) {
++                item.default.value = new big_js_1.default(item.default.value);
++            }
+         }
+         else {
+             item.size.value = new big_js_1.default(item.size.value);
+diff --git a/dist/esm/index.js b/dist/esm/index.js
+index 8891ac0141135a3a885bd704d9d443458c7a01bf..34cd7251f2298e7f9bfedfe4cadb797aa790b59a 100644
+--- a/dist/esm/index.js
++++ b/dist/esm/index.js
+@@ -81,6 +81,9 @@ export function prepareSnapshot(snapshot) {
+             if (item.max && item.max !== "1fr") {
+                 item.max.value = new Big(item.max.value);
+             }
++            if (item.default && typeof item.default === "object" && item.default.value !== undefined) {
++                item.default.value = new Big(item.default.value);
++            }
+         }
+         else {
+             item.size.value = new Big(item.size.value);
diff --git a/patches/antlr4ts@0.5.0-alpha.4.patch b/patches/antlr4ts@0.5.0-alpha.4.patch
new file mode 100644
index 00000000000..388a1e03578
--- /dev/null
+++ b/patches/antlr4ts@0.5.0-alpha.4.patch
@@ -0,0 +1,470 @@
+diff --git a/ANTLRInputStream.js b/ANTLRInputStream.js
+index eaeb0800e83d2a4bd21699ff5fc8b0bb8920efbb..ed6c85c047d1ead64653e212d579967536dca664 100644
+--- a/ANTLRInputStream.js
++++ b/ANTLRInputStream.js
+@@ -43,7 +43,7 @@ class ANTLRInputStream {
+     }
+     consume() {
+         if (this.p >= this.n) {
+-            assert(this.LA(1) === IntStream_1.IntStream.EOF);
++            assert.ok(this.LA(1) === IntStream_1.IntStream.EOF);
+             throw new Error("cannot consume EOF");
+         }
+         //System.out.println("prev p="+p+", c="+(char)data[p]);
+diff --git a/BufferedTokenStream.js b/BufferedTokenStream.js
+index 9a3c6d19bf959819d96552d73267f93985a6fd67..11511d985b9b2b7dd0b140579032a0929d0a4342 100644
+--- a/BufferedTokenStream.js
++++ b/BufferedTokenStream.js
+@@ -126,7 +126,7 @@ let BufferedTokenStream = class BufferedTokenStream {
+      * @see #get(int i)
+      */
+     sync(i) {
+-        assert(i >= 0);
++        assert.ok(i >= 0);
+         let n = i - this.tokens.length + 1; // how many more elements we need?
+         //System.out.println("sync("+i+") needs "+n);
+         if (n > 0) {
+@@ -251,7 +251,7 @@ let BufferedTokenStream = class BufferedTokenStream {
+     getTokens(start, stop, types) {
+         this.lazyInit();
+         if (start === undefined) {
+-            assert(stop === undefined && types === undefined);
++            assert.ok(stop === undefined && types === undefined);
+             return this.tokens;
+         }
+         else if (stop === undefined) {
+diff --git a/CodePointBuffer.js b/CodePointBuffer.js
+index 7d50d372da9a1ccae48f55dd6e5ee388f583ace1..f6452956227847a4e2477c8eb1017e56ec9a58d1 100644
+--- a/CodePointBuffer.js
++++ b/CodePointBuffer.js
+@@ -109,7 +109,7 @@ exports.CodePointBuffer = CodePointBuffer;
+             }
+         }
+         appendArrayByte(utf16In) {
+-            assert(this.prevHighSurrogate === -1);
++            assert.ok(this.prevHighSurrogate === -1);
+             let input = utf16In;
+             let inOffset = 0;
+             let inLimit = utf16In.length;
+@@ -140,7 +140,7 @@ exports.CodePointBuffer = CodePointBuffer;
+             this.position = outOffset;
+         }
+         appendArrayChar(utf16In) {
+-            assert(this.prevHighSurrogate === -1);
++            assert.ok(this.prevHighSurrogate === -1);
+             let input = utf16In;
+             let inOffset = 0;
+             let inLimit = utf16In.length;
+diff --git a/CodePointCharStream.js b/CodePointCharStream.js
+index 4c5398f24afdd378b36053391611404018925f71..e507525f0976219da6eae78136625b8b5a42db67 100644
+--- a/CodePointCharStream.js
++++ b/CodePointCharStream.js
+@@ -28,7 +28,7 @@ class CodePointCharStream {
+     // construct instances of this type.
+     constructor(array, position, remaining, name) {
+         // TODO
+-        assert(position === 0);
++        assert.ok(position === 0);
+         this._array = array;
+         this._size = remaining;
+         this._name = name;
+@@ -55,7 +55,7 @@ class CodePointCharStream {
+     }
+     consume() {
+         if (this._size - this._position === 0) {
+-            assert(this.LA(1) === IntStream_1.IntStream.EOF);
++            assert.ok(this.LA(1) === IntStream_1.IntStream.EOF);
+             throw new RangeError("cannot consume EOF");
+         }
+         this._position++;
+diff --git a/atn/ATN.js b/atn/ATN.js
+index 0da2b8e836510546583685253ec828dbdaa0c1db..4d812a850b6b010576396e6e610f6df25cb585c9 100644
+--- a/atn/ATN.js
++++ b/atn/ATN.js
+@@ -63,7 +63,7 @@ let ATN = class ATN {
+         return PredictionContext_1.PredictionContext.getCachedContext(context, this.contextCache, new PredictionContext_1.PredictionContext.IdentityHashMap());
+     }
+     getDecisionToDFA() {
+-        assert(this.decisionToDFA != null && this.decisionToDFA.length === this.decisionToState.length);
++        assert.ok(this.decisionToDFA != null && this.decisionToDFA.length === this.decisionToState.length);
+         return this.decisionToDFA;
+     }
+     nextTokens(s, ctx) {
+diff --git a/atn/ATNConfig.js b/atn/ATNConfig.js
+index 480d569b667f29437aeef8f2b9e6b0d3187c565f..bcacbc91ea61488f4b8e2ef40960c4f25a168758 100644
+--- a/atn/ATNConfig.js
++++ b/atn/ATNConfig.js
+@@ -61,7 +61,7 @@ const SUPPRESS_PRECEDENCE_FILTER = 0x80000000;
+ let ATNConfig = class ATNConfig {
+     constructor(state, altOrConfig, context) {
+         if (typeof altOrConfig === "number") {
+-            assert((altOrConfig & 0xFFFFFF) === altOrConfig);
++            assert.ok((altOrConfig & 0xFFFFFF) === altOrConfig);
+             this._state = state;
+             this.altAndOuterContextDepth = altOrConfig;
+             this._context = context;
+@@ -120,7 +120,7 @@ let ATNConfig = class ATNConfig {
+         return (this.altAndOuterContextDepth >>> 24) & 0x7F;
+     }
+     set outerContextDepth(outerContextDepth) {
+-        assert(outerContextDepth >= 0);
++        assert.ok(outerContextDepth >= 0);
+         // saturate at 0x7F - everything but zero/positive is only used for debug information anyway
+         outerContextDepth = Math.min(outerContextDepth, 0x7F);
+         this.altAndOuterContextDepth = ((outerContextDepth << 24) | (this.altAndOuterContextDepth & ~0x7F000000) >>> 0);
+diff --git a/atn/ATNConfigSet.js b/atn/ATNConfigSet.js
+index 3ce0361c4ce7fef06b07a9a24c23251fd31dc0d1..f92be1dbeeed37a69b2aa3022ac5a7b7b29040f1 100644
+--- a/atn/ATNConfigSet.js
++++ b/atn/ATNConfigSet.js
+@@ -125,7 +125,7 @@ class ATNConfigSet {
+         if (this.outermostConfigSet && !outermostConfigSet) {
+             throw new Error("IllegalStateException");
+         }
+-        assert(!outermostConfigSet || !this._dipsIntoOuterContext);
++        assert.ok(!outermostConfigSet || !this._dipsIntoOuterContext);
+         this.outermostConfigSet = outermostConfigSet;
+     }
+     getStates() {
+@@ -193,7 +193,7 @@ class ATNConfigSet {
+         if (!this.mergedConfigs || !this.unmerged) {
+             throw new Error("Covered by ensureWritable but duplicated here for strict null check limitation");
+         }
+-        assert(!this.outermostConfigSet || !e.reachesIntoOuterContext);
++        assert.ok(!this.outermostConfigSet || !e.reachesIntoOuterContext);
+         if (contextCache == null) {
+             contextCache = PredictionContextCache_1.PredictionContextCache.UNCACHED;
+         }
+@@ -247,7 +247,7 @@ class ATNConfigSet {
+     updatePropertiesForMergedConfig(config) {
+         // merged configs can't change the alt or semantic context
+         this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;
+-        assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);
++        assert.ok(!this.outermostConfigSet || !this._dipsIntoOuterContext);
+     }
+     updatePropertiesForAddedConfig(config) {
+         if (this.configs.length === 1) {
+@@ -258,7 +258,7 @@ class ATNConfigSet {
+         }
+         this._hasSemanticContext = this._hasSemanticContext || !SemanticContext_1.SemanticContext.NONE.equals(config.semanticContext);
+         this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;
+-        assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);
++        assert.ok(!this.outermostConfigSet || !this._dipsIntoOuterContext);
+     }
+     canMerge(left, leftKey, right) {
+         if (left.state.stateNumber !== right.state.stateNumber) {
+diff --git a/atn/LexerATNSimulator.js b/atn/LexerATNSimulator.js
+index d461d2063dddc78bbb15e56e5ae2559aadd3320d..c92994d52e226965e47a7e1fb28e8100252b289b 100644
+--- a/atn/LexerATNSimulator.js
++++ b/atn/LexerATNSimulator.js
+@@ -258,7 +258,7 @@ let LexerATNSimulator = class LexerATNSimulator extends ATNSimulator_1.ATNSimula
+                         config = c.transform(target, true, lexerActionExecutor);
+                     }
+                     else {
+-                        assert(c.lexerActionExecutor == null);
++                        assert.ok(c.lexerActionExecutor == null);
+                         config = c.transform(target, true);
+                     }
+                     let treatEofAsEpsilon = t === IntStream_1.IntStream.EOF;
+@@ -543,7 +543,7 @@ let LexerATNSimulator = class LexerATNSimulator extends ATNSimulator_1.ATNSimula
+         /* the lexer evaluates predicates on-the-fly; by this point configs
+          * should not contain any configurations with unevaluated predicates.
+          */
+-        assert(!configs.hasSemanticContext);
++        assert.ok(!configs.hasSemanticContext);
+         let proposed = new DFAState_1.DFAState(configs);
+         let existing = this.atn.modeToDFA[this.mode].states.get(proposed);
+         if (existing != null) {
+diff --git a/atn/ParserATNSimulator.js b/atn/ParserATNSimulator.js
+index c36395116d11c431b9f9ea5fea8afbc458bd0b50..0093ac18c7e31fe15bc0596e4f0886b199f41596 100644
+--- a/atn/ParserATNSimulator.js
++++ b/atn/ParserATNSimulator.js
+@@ -307,7 +307,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+             useContext = false;
+         }
+         let dfa = this.atn.decisionToDFA[decision];
+-        assert(dfa != null);
++        assert.ok(dfa != null);
+         if (this.optimize_ll1 && !dfa.isPrecedenceDfa && !dfa.isEmpty) {
+             let ll_1 = input.LA(1);
+             if (ll_1 >= 0 && ll_1 <= 0xFFFF) {
+@@ -381,7 +381,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+             return undefined;
+         }
+         let remainingContext = outerContext;
+-        assert(outerContext != null);
++        assert.ok(outerContext != null);
+         let s0;
+         if (dfa.isPrecedenceDfa) {
+             s0 = dfa.getPrecedenceStartState(this._parser.precedence, true);
+@@ -393,7 +393,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+             remainingContext = this.skipTailCalls(remainingContext);
+             s0 = s0.getContextTarget(this.getReturnState(remainingContext));
+             if (remainingContext.isEmpty) {
+-                assert(s0 == null || !s0.isContextSensitive);
++                assert.ok(s0 == null || !s0.isContextSensitive);
+             }
+             else {
+                 remainingContext = remainingContext.parent;
+@@ -433,7 +433,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                         let initialState = new SimulatorState_1.SimulatorState(state.outerContext, s, state.useContext, remainingOuterContext);
+                         return this.execATN(dfa, input, startIndex, initialState);
+                     }
+-                    assert(remainingOuterContext != null);
++                    assert.ok(remainingOuterContext != null);
+                     remainingOuterContext = remainingOuterContext.parent;
+                     s = next;
+                 }
+@@ -456,7 +456,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                 break;
+             }
+             // t is not updated if one of these states is reached
+-            assert(!this.isAcceptState(s, state.useContext));
++            assert.ok(!this.isAcceptState(s, state.useContext));
+             // if no edge, pop over to ATN interpreter, update DFA and return
+             let target = this.getExistingTargetState(s, t);
+             if (target == null) {
+@@ -508,7 +508,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                     //}
+                 }
+                 else {
+-                    assert(!state.useContext);
++                    assert.ok(!state.useContext);
+                     // Before attempting full context prediction, check to see if there are
+                     // disambiguating or validating predicates to evaluate which allow an
+                     // immediate decision
+@@ -664,9 +664,9 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+             }
+             let D = nextState.s0;
+             // predicted alt => accept state
+-            assert(D.isAcceptState || D.prediction === ATN_1.ATN.INVALID_ALT_NUMBER);
++            assert.ok(D.isAcceptState || D.prediction === ATN_1.ATN.INVALID_ALT_NUMBER);
+             // conflicted => accept state
+-            assert(D.isAcceptState || D.configs.conflictInfo == null);
++            assert.ok(D.isAcceptState || D.configs.conflictInfo == null);
+             if (this.isAcceptState(D, useContext)) {
+                 let conflictingAlts = D.configs.conflictingAlts;
+                 let predictedAlt = conflictingAlts == null ? D.prediction : ATN_1.ATN.INVALID_ALT_NUMBER;
+@@ -731,8 +731,8 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                     return predictedAlt;
+                 }
+                 else {
+-                    assert(!useContext);
+-                    assert(this.isAcceptState(D, false));
++                    assert.ok(!useContext);
++                    assert.ok(this.isAcceptState(D, false));
+                     if (ParserATNSimulator.debug) {
+                         console.log("RETRY with outerContext=" + outerContext);
+                     }
+@@ -877,12 +877,12 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                 if (next == null) {
+                     break;
+                 }
+-                assert(remainingGlobalContext != null);
++                assert.ok(remainingGlobalContext != null);
+                 remainingGlobalContext = remainingGlobalContext.parent;
+                 s = next;
+             }
+         }
+-        assert(!this.isAcceptState(s, useContext));
++        assert.ok(!this.isAcceptState(s, useContext));
+         if (this.isAcceptState(s, useContext)) {
+             return new SimulatorState_1.SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext);
+         }
+@@ -896,7 +896,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+         if (target === ATNSimulator_1.ATNSimulator.ERROR) {
+             return undefined;
+         }
+-        assert(!useContext || !target.configs.dipsIntoOuterContext);
++        assert.ok(!useContext || !target.configs.dipsIntoOuterContext);
+         return new SimulatorState_1.SimulatorState(previous.outerContext, target, useContext, remainingGlobalContext);
+     }
+     /**
+@@ -955,7 +955,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                     console.log("testing " + this.getTokenName(t) + " at " + c.toString());
+                 }
+                 if (c.state instanceof RuleStopState_1.RuleStopState) {
+-                    assert(c.context.isEmpty);
++                    assert.ok(c.context.isEmpty);
+                     if (useContext && !c.reachesIntoOuterContext || t === IntStream_1.IntStream.EOF) {
+                         if (skippedStopStates == null) {
+                             skippedStopStates = [];
+@@ -1018,7 +1018,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+              * multiple alternatives are viable.
+              */
+             if (skippedStopStates != null && (!useContext || !PredictionMode_1.PredictionMode.hasConfigInRuleStopState(reach))) {
+-                assert(skippedStopStates.length > 0);
++                assert.ok(skippedStopStates.length > 0);
+                 for (let c of skippedStopStates) {
+                     reach.add(c, contextCache);
+                 }
+@@ -1382,7 +1382,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+         for (let i = 1; i < altToPred.length; i++) {
+             let pred = altToPred[i];
+             // unpredicated is indicated by SemanticContext.NONE
+-            assert(pred != null);
++            assert.ok(pred != null);
+             // find first unpredicated but ambig alternative, if any.
+             // Only ambiguous alternatives will have SemanticContext.NONE.
+             // Any unambig alts or ambig naked alts after first ambig naked are ignored
+@@ -1497,7 +1497,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                     // Make sure we track that we are now out of context.
+                     c.outerContextDepth = config.outerContextDepth;
+                     c.isPrecedenceFilterSuppressed = config.isPrecedenceFilterSuppressed;
+-                    assert(depth > MIN_INTEGER_VALUE);
++                    assert.ok(depth > MIN_INTEGER_VALUE);
+                     this.closureImpl(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts, contextCache, depth - 1, treatEofAsEpsilon);
+                 }
+                 if (!hasEmpty || !hasMoreContexts) {
+@@ -1587,7 +1587,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                         // avoid infinite recursion for right-recursive rules
+                         continue;
+                     }
+-                    assert(newDepth > MIN_INTEGER_VALUE);
++                    assert.ok(newDepth > MIN_INTEGER_VALUE);
+                     newDepth--;
+                     if (ParserATNSimulator.debug) {
+                         console.log("dips into outer ctx: " + c);
+@@ -1595,7 +1595,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                 }
+                 else if (t instanceof RuleTransition_1.RuleTransition) {
+                     if (this.optimize_tail_calls && t.optimizedTailCall && (!this.tail_call_preserves_sll || !PredictionContext_1.PredictionContext.isEmptyLocal(config.context))) {
+-                        assert(c.context === config.context);
++                        assert.ok(c.context === config.context);
+                         if (newDepth === 0) {
+                             // the pop/push of a tail call would keep the depth
+                             // constant, except we latch if it goes negative
+@@ -1926,7 +1926,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+         return false;
+     }
+     addDFAEdge(dfa, fromState, t, contextTransitions, toConfigs, contextCache) {
+-        assert(contextTransitions == null || contextTransitions.isEmpty || dfa.isContextSensitive);
++        assert.ok(contextTransitions == null || contextTransitions.isEmpty || dfa.isContextSensitive);
+         let from = fromState;
+         let to = this.addDFAState(dfa, toConfigs, contextCache);
+         if (contextTransitions != null) {
+@@ -1944,7 +1944,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+                     continue;
+                 }
+                 next = this.addDFAContextState(dfa, from.configs, context, contextCache);
+-                assert(context !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY || next.configs.isOutermostConfigSet);
++                assert.ok(context !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY || next.configs.isOutermostConfigSet);
+                 from.setContextTarget(context, next);
+                 from = next;
+             }
+@@ -1973,7 +1973,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+             return this.addDFAState(dfa, contextConfigs, contextCache);
+         }
+         else {
+-            assert(!configs.isOutermostConfigSet, "Shouldn't be adding a duplicate edge.");
++            assert.ok(!configs.isOutermostConfigSet, "Shouldn't be adding a duplicate edge.");
+             configs = configs.clone(true);
+             configs.isOutermostConfigSet = true;
+             return this.addDFAState(dfa, configs, contextCache);
+@@ -2081,7 +2081,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
+         }
+         while (!context.isEmpty) {
+             let state = this.atn.states[context.invokingState];
+-            assert(state.numberOfTransitions === 1 && state.transition(0).serializationType === 3 /* RULE */);
++            assert.ok(state.numberOfTransitions === 1 && state.transition(0).serializationType === 3 /* RULE */);
+             let transition = state.transition(0);
+             if (!transition.tailCall) {
+                 break;
+diff --git a/atn/PredictionContext.js b/atn/PredictionContext.js
+index 47d525fde0ca117193dd2b1cd2685420c23683d6..b269295802fc84b7cf7e1ce055cdba0a0c03ec53 100644
+--- a/atn/PredictionContext.js
++++ b/atn/PredictionContext.js
+@@ -118,7 +118,7 @@ class PredictionContext {
+                 leftIndex++;
+             }
+             else {
+-                assert(context1.getReturnState(rightIndex) < context0.getReturnState(leftIndex));
++                assert.ok(context1.getReturnState(rightIndex) < context0.getReturnState(leftIndex));
+                 parentsList[count] = context1.getParent(rightIndex);
+                 returnStatesList[count] = context1.getReturnState(rightIndex);
+                 canReturnLeft = false;
+@@ -374,8 +374,8 @@ __decorate([
+ let ArrayPredictionContext = class ArrayPredictionContext extends PredictionContext {
+     constructor(parents, returnStates, hashCode) {
+         super(hashCode || PredictionContext.calculateHashCode(parents, returnStates));
+-        assert(parents.length === returnStates.length);
+-        assert(returnStates.length > 1 || returnStates[0] !== PredictionContext.EMPTY_FULL_STATE_KEY, "Should be using PredictionContext.EMPTY instead.");
++        assert.ok(parents.length === returnStates.length);
++        assert.ok(returnStates.length > 1 || returnStates[0] !== PredictionContext.EMPTY_FULL_STATE_KEY, "Should be using PredictionContext.EMPTY instead.");
+         this.parents = parents;
+         this.returnStates = returnStates;
+     }
+@@ -458,7 +458,7 @@ let ArrayPredictionContext = class ArrayPredictionContext extends PredictionCont
+                     result = new SingletonPredictionContext(updatedParents[0], updatedReturnStates[0]);
+                 }
+                 else {
+-                    assert(updatedParents.length > 1);
++                    assert.ok(updatedParents.length > 1);
+                     result = new ArrayPredictionContext(updatedParents, updatedReturnStates);
+                 }
+                 if (context.hasEmpty) {
+@@ -569,16 +569,16 @@ ArrayPredictionContext = __decorate([
+ let SingletonPredictionContext = class SingletonPredictionContext extends PredictionContext {
+     constructor(parent, returnState) {
+         super(PredictionContext.calculateSingleHashCode(parent, returnState));
+-        // assert(returnState != PredictionContext.EMPTY_FULL_STATE_KEY && returnState != PredictionContext.EMPTY_LOCAL_STATE_KEY);
++        // assert.ok(returnState != PredictionContext.EMPTY_FULL_STATE_KEY && returnState != PredictionContext.EMPTY_LOCAL_STATE_KEY);
+         this.parent = parent;
+         this.returnState = returnState;
+     }
+     getParent(index) {
+-        // assert(index == 0);
++        // assert.ok(index == 0);
+         return this.parent;
+     }
+     getReturnState(index) {
+-        // assert(index == 0);
++        // assert.ok(index == 0);
+         return this.returnState;
+     }
+     findReturnState(returnState) {
+diff --git a/atn/PredictionContextCache.js b/atn/PredictionContextCache.js
+index d919815854f0519b2b602a316f93f702f06c9754..ecd697a2b7141ebf5c76198bb49088cff90c4d35 100644
+--- a/atn/PredictionContextCache.js
++++ b/atn/PredictionContextCache.js
+@@ -104,8 +104,8 @@ PredictionContextCache.UNCACHED = new PredictionContextCache(false);
+     PredictionContextCache.PredictionContextAndInt = PredictionContextAndInt;
+     class IdentityCommutativePredictionContextOperands {
+         constructor(x, y) {
+-            assert(x != null);
+-            assert(y != null);
++            assert.ok(x != null);
++            assert.ok(y != null);
+             this._x = x;
+             this._y = y;
+         }
+diff --git a/dfa/DFAState.js b/dfa/DFAState.js
+index dcdd796eef9a8046033b233d6cc2ca33b198cb9d..d7a095dcc5680d1af58e6e213ebaed98eae4c1b1 100644
+--- a/dfa/DFAState.js
++++ b/dfa/DFAState.js
+@@ -66,11 +66,11 @@ class DFAState {
+         return this.contextSymbols.get(symbol);
+     }
+     setContextSymbol(symbol) {
+-        assert(this.isContextSensitive);
++        assert.ok(this.isContextSensitive);
+         this.contextSymbols.set(symbol);
+     }
+     setContextSensitive(atn) {
+-        assert(!this.configs.isOutermostConfigSet);
++        assert.ok(!this.configs.isOutermostConfigSet);
+         if (this.isContextSensitive) {
+             return;
+         }
+diff --git a/misc/Array2DHashSet.js b/misc/Array2DHashSet.js
+index 5e9b5dca143df940562734ce158c532a48fed78d..3796235c05d771f985a3e6d5cd9f5f8116188a5f 100644
+--- a/misc/Array2DHashSet.js
++++ b/misc/Array2DHashSet.js
+@@ -153,7 +153,7 @@ class Array2DHashSet {
+                 newBucket.push(o);
+             }
+         }
+-        assert(this.n === oldSize);
++        assert.ok(this.n === oldSize);
+     }
+     add(t) {
+         let existing = this.getOrAdd(t);
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9d846a52b3c..766cb4940c4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -5,6 +5,8 @@ settings:
   excludeLinksFromLockfile: false
 
 overrides:
+  typescript: 5.5.4
+  '@types/node': 20.14.14
   express@^4>body-parser: 1.20.3
   '@remix-run/dev@2.1.0>tar-fs': 2.1.3
   testcontainers@10.28.0>tar-fs: 3.0.9
@@ -15,6 +17,9 @@ overrides:
   js-yaml@>=3.0.0 <3.14.2: 3.14.2
   js-yaml@>=4.0.0 <4.1.1: 4.1.1
   jws@<3.2.3: 3.2.3
+  qs@>=6.0.0 <6.14.1: 6.14.1
+  systeminformation@>=5.0.0 <5.27.14: 5.27.14
+  lodash@>=4.0.0 <4.17.23: 4.17.23
 
 patchedDependencies:
   '@changesets/assemble-release-plan@5.2.4':
@@ -26,6 +31,15 @@ patchedDependencies:
   '@sentry/remix@9.46.0':
     hash: 146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b
     path: patches/@sentry__remix@9.46.0.patch
+  '@upstash/ratelimit@1.1.3':
+    hash: e5922e50fbefb7b2b24950c4b1c5c9ddc4cd25464439c9548d2298c432debe74
+    path: patches/@upstash__ratelimit.patch
+  '@window-splitter/state@0.4.1':
+    hash: da01382a3c0d3f4f66db5b09d6f0833cc21eaf8db00f97e2c1738797673b57c0
+    path: patches/@window-splitter__state@0.4.1.patch
+  antlr4ts@0.5.0-alpha.4:
+    hash: b5d41129ddbf7c4cbb0288244b2c8d041ee0803c5102c1181c180408d3b579f4
+    path: patches/antlr4ts@0.5.0-alpha.4.patch
   engine.io-parser@5.2.2:
     hash: 9011e7e16547017450c9baec0fceff0e070310c20d9e62f8d1383bb1da77104f
     path: patches/engine.io-parser@5.2.2.patch
@@ -46,6 +60,9 @@ importers:
       '@remix-run/changelog-github':
         specifier: ^0.0.5
         version: 0.0.5(encoding@0.1.13)
+      agentcrumbs:
+        specifier: ^0.5.0
+        version: 0.5.0
       node-fetch:
         specifier: 2.6.x
         version: 2.6.7(encoding@0.1.13)
@@ -173,6 +190,9 @@ importers:
       '@aws-sdk/client-ecr':
         specifier: ^3.839.0
         version: 3.839.0
+      '@internal/compute':
+        specifier: workspace:*
+        version: link:../../internal-packages/compute
       '@kubernetes/client-node':
         specifier: ^1.0.0
         version: 1.0.0(patch_hash=ba1a06f46256cdb8d6faf7167246692c0de2e7cd846a9dc0f13be0137e1c3745)(bufferutil@4.0.9)(encoding@0.1.13)
@@ -182,6 +202,9 @@ importers:
       dockerode:
         specifier: ^4.0.6
         version: 4.0.6
+      p-limit:
+        specifier: ^6.2.0
+        version: 6.2.0
       prom-client:
         specifier: ^15.1.0
         version: 15.1.0
@@ -235,31 +258,34 @@ importers:
         specifier: ^0.2.6
         version: 0.2.6
       '@codemirror/autocomplete':
-        specifier: ^6.3.1
+        specifier: 6.4.0
         version: 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)
       '@codemirror/commands':
-        specifier: ^6.1.2
+        specifier: 6.1.3
         version: 6.1.3
       '@codemirror/lang-javascript':
-        specifier: ^6.1.1
+        specifier: 6.1.2
         version: 6.1.2
       '@codemirror/lang-json':
-        specifier: ^6.0.1
+        specifier: 6.0.1
         version: 6.0.1
+      '@codemirror/lang-sql':
+        specifier: 6.5.5
+        version: 6.5.5(@codemirror/view@6.7.2)
       '@codemirror/language':
-        specifier: ^6.3.1
+        specifier: 6.3.2
         version: 6.3.2
       '@codemirror/lint':
-        specifier: ^6.4.2
+        specifier: 6.4.2
         version: 6.4.2
       '@codemirror/search':
-        specifier: ^6.2.3
+        specifier: 6.2.3
         version: 6.2.3
       '@codemirror/state':
-        specifier: ^6.1.3
+        specifier: 6.2.0
         version: 6.2.0
       '@codemirror/view':
-        specifier: ^6.5.0
+        specifier: 6.7.2
         version: 6.7.2
       '@conform-to/react':
         specifier: 0.9.2
@@ -285,6 +311,12 @@ importers:
       '@internal/cache':
         specifier: workspace:*
         version: link:../../internal-packages/cache
+      '@internal/compute':
+        specifier: workspace:*
+        version: link:../../internal-packages/compute
+      '@internal/llm-model-catalog':
+        specifier: workspace:*
+        version: link:../../internal-packages/llm-model-catalog
       '@internal/redis':
         specifier: workspace:*
         version: link:../../internal-packages/redis
@@ -297,12 +329,18 @@ importers:
       '@internal/tracing':
         specifier: workspace:*
         version: link:../../internal-packages/tracing
+      '@internal/tsql':
+        specifier: workspace:*
+        version: link:../../internal-packages/tsql
       '@internal/zod-worker':
         specifier: workspace:*
         version: link:../../internal-packages/zod-worker
       '@internationalized/date':
         specifier: ^3.5.1
         version: 3.5.1
+      '@jsonhero/schema-infer':
+        specifier: ^0.1.5
+        version: 0.1.5
       '@kapaai/react-sdk':
         specifier: ^0.1.3
         version: 0.1.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
@@ -328,8 +366,8 @@ importers:
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)
       '@opentelemetry/host-metrics':
-        specifier: ^0.36.0
-        version: 0.36.0(@opentelemetry/api@1.9.0)
+        specifier: ^0.37.0
+        version: 0.37.0(@opentelemetry/api@1.9.0)
       '@opentelemetry/instrumentation':
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)(supports-color@10.0.0)
@@ -419,46 +457,49 @@ importers:
         version: 3.7.1(react@18.2.0)
       '@remix-run/express':
         specifier: 2.1.0
-        version: 2.1.0(express@4.20.0)(typescript@5.9.3)
+        version: 2.1.0(express@4.20.0)(typescript@5.5.4)
       '@remix-run/node':
         specifier: 2.1.0
-        version: 2.1.0(typescript@5.9.3)
+        version: 2.1.0(typescript@5.5.4)
       '@remix-run/react':
         specifier: 2.1.0
-        version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
+        version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
       '@remix-run/router':
         specifier: ^1.15.3
         version: 1.15.3
       '@remix-run/serve':
         specifier: 2.1.0
-        version: 2.1.0(typescript@5.9.3)
+        version: 2.1.0(typescript@5.5.4)
       '@remix-run/server-runtime':
         specifier: 2.1.0
-        version: 2.1.0(typescript@5.9.3)
+        version: 2.1.0(typescript@5.5.4)
       '@remix-run/v1-meta':
         specifier: ^0.1.3
-        version: 0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
+        version: 0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
       '@s2-dev/streamstore':
-        specifier: ^0.17.2
-        version: 0.17.3(typescript@5.9.3)
+        specifier: ^0.22.5
+        version: 0.22.5(supports-color@10.0.0)
       '@sentry/remix':
         specifier: 9.46.0
-        version: 9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(encoding@0.1.13)(react@18.2.0)
+        version: 9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(encoding@0.1.13)(react@18.2.0)
       '@slack/web-api':
         specifier: 7.9.1
         version: 7.9.1
       '@socket.io/redis-adapter':
         specifier: ^8.3.0
         version: 8.3.0(socket.io-adapter@2.5.4(bufferutil@4.0.9))
-      '@splinetool/react-spline':
-        specifier: ^2.2.6
-        version: 2.2.6(@splinetool/runtime@1.11.2)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       '@tabler/icons-react':
-        specifier: ^2.39.0
-        version: 2.47.0(react@18.2.0)
+        specifier: ^3.36.1
+        version: 3.36.1(react@18.2.0)
       '@tailwindcss/container-queries':
         specifier: ^0.1.1
         version: 0.1.1(tailwindcss@3.4.1)
+      '@tanstack/match-sorter-utils':
+        specifier: ^8.19.4
+        version: 8.19.4
+      '@tanstack/react-table':
+        specifier: ^8.21.3
+        version: 8.21.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       '@tanstack/react-virtual':
         specifier: ^3.0.4
         version: 3.0.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
@@ -478,8 +519,8 @@ importers:
         specifier: workspace:*
         version: link:../../internal-packages/otlp-importer
       '@trigger.dev/platform':
-        specifier: 1.0.21
-        version: 1.0.21
+        specifier: 1.0.27
+        version: 1.0.27
       '@trigger.dev/redis-worker':
         specifier: workspace:*
         version: link:../../packages/redis-worker
@@ -491,7 +532,7 @@ importers:
         version: 8.6.6
       '@uiw/react-codemirror':
         specifier: ^4.19.5
-        version: 4.19.5(@babel/runtime@7.28.4)(@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0))(@codemirror/language@6.3.2)(@codemirror/lint@6.4.2)(@codemirror/search@6.2.3)(@codemirror/state@6.2.0)(@codemirror/theme-one-dark@6.1.3)(@codemirror/view@6.7.2)(codemirror@6.0.2)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+        version: 4.19.5(@babel/runtime@7.28.4)(@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0))(@codemirror/language@6.3.2)(@codemirror/lint@6.4.2)(@codemirror/search@6.2.3)(@codemirror/state@6.2.0)(@codemirror/theme-one-dark@6.1.3)(@codemirror/view@6.7.2)(codemirror@6.0.2(@lezer/common@1.3.0))(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       '@unkey/cache':
         specifier: ^1.5.0
         version: 1.5.0
@@ -500,7 +541,10 @@ importers:
         version: 0.2.0
       '@upstash/ratelimit':
         specifier: ^1.1.3
-        version: 1.1.3
+        version: 1.1.3(patch_hash=e5922e50fbefb7b2b24950c4b1c5c9ddc4cd25464439c9548d2298c432debe74)
+      '@vercel/sdk':
+        specifier: ^1.19.1
+        version: 1.19.1
       '@whatwg-node/fetch':
         specifier: ^0.9.14
         version: 0.9.14
@@ -515,7 +559,7 @@ importers:
         version: 1.0.18
       class-variance-authority:
         specifier: ^0.5.2
-        version: 0.5.2(typescript@5.9.3)
+        version: 0.5.2(typescript@5.5.4)
       clsx:
         specifier: ^1.2.1
         version: 1.2.1
@@ -537,6 +581,9 @@ importers:
       cuid:
         specifier: ^2.1.8
         version: 2.1.8
+      date-fns:
+        specifier: ^4.1.0
+        version: 4.1.0
       dompurify:
         specifier: ^3.2.6
         version: 3.2.6
@@ -563,7 +610,7 @@ importers:
         version: 10.12.11(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       graphile-worker:
         specifier: 0.16.6
-        version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.9.3)
+        version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.5.4)
       humanize-duration:
         specifier: ^3.27.3
         version: 3.27.3
@@ -582,6 +629,9 @@ importers:
       jose:
         specifier: ^5.4.0
         version: 5.4.0
+      json-stable-stringify:
+        specifier: ^1.3.0
+        version: 1.3.0
       jsonpointer:
         specifier: ^5.0.1
         version: 5.0.1
@@ -660,15 +710,27 @@ importers:
       react-collapse:
         specifier: ^5.1.1
         version: 5.1.1(react@18.2.0)
+      react-day-picker:
+        specifier: ^9.13.0
+        version: 9.13.0(react@18.2.0)
       react-dom:
         specifier: ^18.2.0
         version: 18.2.0(react@18.2.0)
+      react-grid-layout:
+        specifier: ^2.2.2
+        version: 2.2.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react-hotkeys-hook:
         specifier: ^4.4.1
         version: 4.4.1(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      react-markdown:
+        specifier: ^10.1.0
+        version: 10.1.0(@types/react@18.2.69)(react@18.2.0)
       react-popper:
         specifier: ^2.3.0
         version: 2.3.0(@popperjs/core@2.11.8)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      react-resizable:
+        specifier: ^3.1.3
+        version: 3.1.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react-resizable-panels:
         specifier: ^2.0.9
         version: 2.0.9(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
@@ -682,29 +744,29 @@ importers:
         specifier: ^0.4.1
         version: 0.4.1(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       recharts:
-        specifier: ^2.12.6
-        version: 2.12.6(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+        specifier: ^2.15.2
+        version: 2.15.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       regression:
         specifier: ^2.0.1
         version: 2.0.1
       remix-auth:
         specifier: ^3.6.0
-        version: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
+        version: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
       remix-auth-email-link:
         specifier: 2.0.2
-        version: 2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)))
+        version: 2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)))
       remix-auth-github:
         specifier: ^1.6.0
-        version: 1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)))
+        version: 1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)))
       remix-auth-google:
         specifier: ^2.0.0
-        version: 2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)))
+        version: 2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)))
       remix-typedjson:
         specifier: 0.3.1
-        version: 0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(react@18.2.0)
+        version: 0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(react@18.2.0)
       remix-utils:
         specifier: ^7.7.0
-        version: 7.7.0(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76)
+        version: 7.7.0(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76)
       seedrandom:
         specifier: ^3.0.5
         version: 3.0.5
@@ -729,9 +791,15 @@ importers:
       sonner:
         specifier: ^1.0.3
         version: 1.0.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      sql-formatter:
+        specifier: ^15.4.10
+        version: 15.6.12
       sqs-consumer:
         specifier: ^7.4.0
         version: 7.5.0(@aws-sdk/client-sqs@3.454.0)
+      streamdown:
+        specifier: ^1.4.0
+        version: 1.4.0(@types/react@18.2.69)(react@18.2.0)
       superjson:
         specifier: ^2.2.1
         version: 2.2.1
@@ -783,13 +851,13 @@ importers:
         version: link:../../internal-packages/testcontainers
       '@remix-run/dev':
         specifier: 2.1.0
-        version: 2.1.0(@remix-run/serve@2.1.0(typescript@5.9.3))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.9.3)
+        version: 2.1.0(@remix-run/serve@2.1.0(typescript@5.5.4))(@types/node@20.14.14)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.5.4)
       '@remix-run/eslint-config':
         specifier: 2.1.0
-        version: 2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.9.3)
+        version: 2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.5.4)
       '@remix-run/testing':
         specifier: ^2.1.0
-        version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
+        version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
       '@sentry/cli':
         specifier: 2.50.2
         version: 2.50.2(encoding@0.1.13)
@@ -888,10 +956,10 @@ importers:
         version: 8.5.4
       '@typescript-eslint/eslint-plugin':
         specifier: ^5.59.6
-        version: 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)
+        version: 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)
       '@typescript-eslint/parser':
         specifier: ^5.59.6
-        version: 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+        version: 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       autoevals:
         specifier: ^0.0.130
         version: 0.0.130(encoding@0.1.13)(ws@8.12.0(bufferutil@4.0.9))
@@ -918,7 +986,7 @@ importers:
         version: 8.6.0(eslint@8.31.0)
       eslint-plugin-import:
         specifier: ^2.29.1
-        version: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
+        version: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
       eslint-plugin-react-hooks:
         specifier: ^4.6.2
         version: 4.6.2(eslint@8.31.0)
@@ -936,7 +1004,7 @@ importers:
         version: 16.0.1(postcss@8.5.6)
       postcss-loader:
         specifier: ^8.1.1
-        version: 8.1.1(postcss@8.5.6)(typescript@5.9.3)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18))
+        version: 8.1.1(postcss@8.5.6)(typescript@5.5.4)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18))
       prettier:
         specifier: ^2.8.8
         version: 2.8.8
@@ -969,7 +1037,7 @@ importers:
         version: 4.20.6
       vite-tsconfig-paths:
         specifier: ^4.0.5
-        version: 4.0.5(typescript@5.9.3)
+        version: 4.0.5(typescript@5.5.4)
 
   docs: {}
 
@@ -987,6 +1055,9 @@ importers:
       '@unkey/error':
         specifier: ^0.2.0
         version: 0.2.0
+      lru-cache:
+        specifier: ^11.2.4
+        version: 11.2.4
       superjson:
         specifier: ^2.2.1
         version: 2.2.1
@@ -999,6 +1070,9 @@ importers:
       '@internal/tracing':
         specifier: workspace:*
         version: link:../tracing
+      '@internal/tsql':
+        specifier: workspace:*
+        version: link:../tsql
       '@trigger.dev/core':
         specifier: workspace:*
         version: link:../../packages/core
@@ -1016,11 +1090,21 @@ importers:
         specifier: 6.0.1
         version: 6.0.1
 
+  internal-packages/compute:
+    dependencies:
+      zod:
+        specifier: 3.25.76
+        version: 3.25.76
+    devDependencies:
+      rimraf:
+        specifier: 6.0.1
+        version: 6.0.1
+
   internal-packages/database:
     dependencies:
       '@prisma/client':
         specifier: 6.14.0
-        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)
       decimal.js:
         specifier: ^10.6.0
         version: 10.6.0
@@ -1030,7 +1114,7 @@ importers:
         version: 7.4.3
       prisma:
         specifier: 6.14.0
-        version: 6.14.0(magicast@0.3.5)(typescript@5.9.3)
+        version: 6.14.0(magicast@0.3.5)(typescript@5.5.4)
       rimraf:
         specifier: 6.0.1
         version: 6.0.1
@@ -1072,6 +1156,22 @@ importers:
         specifier: 18.2.69
         version: 18.2.69
 
+  internal-packages/llm-model-catalog:
+    dependencies:
+      '@trigger.dev/core':
+        specifier: workspace:*
+        version: link:../../packages/core
+      '@trigger.dev/database':
+        specifier: workspace:*
+        version: link:../database
+    devDependencies:
+      '@internal/testcontainers':
+        specifier: workspace:*
+        version: link:../testcontainers
+      vitest:
+        specifier: 3.1.4
+        version: 3.1.4(@types/debug@4.1.12)(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
+
   internal-packages/otlp-importer:
     dependencies:
       long:
@@ -1082,7 +1182,7 @@ importers:
         version: 7.3.2
     devDependencies:
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       rimraf:
         specifier: ^3.0.2
@@ -1214,6 +1314,25 @@ importers:
         specifier: 6.0.1
         version: 6.0.1
 
+  internal-packages/sdk-compat-tests:
+    dependencies:
+      '@trigger.dev/sdk':
+        specifier: workspace:*
+        version: link:../../packages/trigger-sdk
+    devDependencies:
+      esbuild:
+        specifier: ^0.24.0
+        version: 0.24.2
+      execa:
+        specifier: ^9.3.0
+        version: 9.6.1
+      typescript:
+        specifier: 5.5.4
+        version: 5.5.4
+      vitest:
+        specifier: 3.1.4
+        version: 3.1.4(@types/debug@4.1.12)(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
+
   internal-packages/testcontainers:
     dependencies:
       '@clickhouse/client':
@@ -1263,6 +1382,22 @@ importers:
         specifier: workspace:*
         version: link:../../packages/core
 
+  internal-packages/tsql:
+    dependencies:
+      '@trigger.dev/core':
+        specifier: workspace:*
+        version: link:../../packages/core
+      antlr4ts:
+        specifier: 0.5.0-alpha.4
+        version: 0.5.0-alpha.4(patch_hash=b5d41129ddbf7c4cbb0288244b2c8d041ee0803c5102c1181c180408d3b579f4)
+      zod:
+        specifier: 3.25.76
+        version: 3.25.76
+    devDependencies:
+      antlr4ts-cli:
+        specifier: 0.5.0-alpha.4
+        version: 0.5.0-alpha.4
+
   internal-packages/zod-worker:
     dependencies:
       '@internal/tracing':
@@ -1276,7 +1411,7 @@ importers:
         version: link:../database
       graphile-worker:
         specifier: 0.16.6
-        version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.9.3)
+        version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.5.4)
       lodash.omit:
         specifier: ^4.5.0
         version: 4.5.0
@@ -1297,7 +1432,7 @@ importers:
         specifier: ^6.10.0
         version: 6.19.0(magicast@0.3.5)
       '@trigger.dev/core':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../core
       mlly:
         specifier: ^1.7.1
@@ -1313,7 +1448,7 @@ importers:
         version: 0.2.2
       tsconfck:
         specifier: 3.1.3
-        version: 3.1.3(typescript@5.9.3)
+        version: 3.1.3(typescript@5.5.4)
     devDependencies:
       '@arethetypeswrong/cli':
         specifier: ^0.15.4
@@ -1343,8 +1478,8 @@ importers:
         specifier: 0.0.1-cli.2.80.0
         version: 0.0.1-cli.2.80.0
       '@modelcontextprotocol/sdk':
-        specifier: ^1.24.0
-        version: 1.24.2(supports-color@10.0.0)(zod@3.25.76)
+        specifier: ^1.25.2
+        version: 1.25.2(hono@4.11.8)(supports-color@10.0.0)(zod@3.25.76)
       '@opentelemetry/api':
         specifier: 1.9.0
         version: 1.9.0
@@ -1370,16 +1505,16 @@ importers:
         specifier: 1.36.0
         version: 1.36.0
       '@s2-dev/streamstore':
-        specifier: ^0.17.6
-        version: 0.17.6
+        specifier: ^0.22.5
+        version: 0.22.5(supports-color@10.0.0)
       '@trigger.dev/build':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../build
       '@trigger.dev/core':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../core
       '@trigger.dev/schema-to-json':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../schema-to-json
       ansi-escapes:
         specifier: ^7.0.0
@@ -1508,8 +1643,8 @@ importers:
         specifier: ^10.0.0
         version: 10.0.0
       tar:
-        specifier: ^7.4.3
-        version: 7.4.3
+        specifier: ^7.5.4
+        version: 7.5.6
       tiny-invariant:
         specifier: ^1.2.0
         version: 1.3.1
@@ -1582,7 +1717,7 @@ importers:
         version: 5.0.7
       ts-essentials:
         specifier: 10.0.1
-        version: 10.0.1(typescript@5.9.3)
+        version: 10.0.1(typescript@5.5.4)
       tshy:
         specifier: ^3.0.2
         version: 3.0.2
@@ -1616,9 +1751,15 @@ importers:
       '@opentelemetry/exporter-logs-otlp-http':
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/exporter-metrics-otlp-http':
+        specifier: 0.203.0
+        version: 0.203.0(@opentelemetry/api@1.9.0)
       '@opentelemetry/exporter-trace-otlp-http':
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/host-metrics':
+        specifier: ^0.37.0
+        version: 0.37.0(@opentelemetry/api@1.9.0)
       '@opentelemetry/instrumentation':
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)(supports-color@10.0.0)
@@ -1628,6 +1769,9 @@ importers:
       '@opentelemetry/sdk-logs':
         specifier: 0.203.0
         version: 0.203.0(@opentelemetry/api@1.9.0)
+      '@opentelemetry/sdk-metrics':
+        specifier: 2.0.1
+        version: 2.0.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/sdk-trace-base':
         specifier: 2.0.1
         version: 2.0.1(@opentelemetry/api@1.9.0)
@@ -1638,8 +1782,8 @@ importers:
         specifier: 1.36.0
         version: 1.36.0
       '@s2-dev/streamstore':
-        specifier: 0.17.3
-        version: 0.17.3(typescript@5.9.3)
+        specifier: 0.22.5
+        version: 0.22.5(supports-color@10.0.0)
       dequal:
         specifier: ^2.0.3
         version: 2.0.3
@@ -1673,9 +1817,6 @@ importers:
       std-env:
         specifier: ^3.8.1
         version: 3.8.1
-      superjson:
-        specifier: ^2.2.1
-        version: 2.2.1
       tinyexec:
         specifier: ^0.3.2
         version: 0.3.2
@@ -1714,8 +1855,8 @@ importers:
         specifier: ^4.0.14
         version: 4.0.14
       ai:
-        specifier: ^3.4.33
-        version: 3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)
+        specifier: ^6.0.0
+        version: 6.0.3(zod@3.25.76)
       defu:
         specifier: ^6.1.4
         version: 6.1.4
@@ -1725,9 +1866,12 @@ importers:
       rimraf:
         specifier: ^3.0.2
         version: 3.0.2
+      superjson:
+        specifier: ^2.2.1
+        version: 2.2.1
       ts-essentials:
         specifier: 10.0.1
-        version: 10.0.1(typescript@5.9.3)
+        version: 10.0.1(typescript@5.5.4)
       tshy:
         specifier: ^3.0.2
         version: 3.0.2
@@ -1738,7 +1882,7 @@ importers:
   packages/python:
     dependencies:
       '@trigger.dev/core':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../core
       tinyexec:
         specifier: ^0.3.2
@@ -1748,10 +1892,10 @@ importers:
         specifier: ^0.15.4
         version: 0.15.4
       '@trigger.dev/build':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../build
       '@trigger.dev/sdk':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../trigger-sdk
       '@types/node':
         specifier: 20.14.14
@@ -1769,13 +1913,13 @@ importers:
         specifier: 4.17.0
         version: 4.17.0
       typescript:
-        specifier: ^5.5.4
+        specifier: 5.5.4
         version: 5.5.4
 
   packages/react-hooks:
     dependencies:
       '@trigger.dev/core':
-        specifier: workspace:^4.3.0
+        specifier: workspace:^4.4.3
         version: link:../core
       react:
         specifier: ^18.0 || ^19.0 || ^19.0.0-rc
@@ -1809,7 +1953,7 @@ importers:
   packages/redis-worker:
     dependencies:
       '@trigger.dev/core':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../core
       cron-parser:
         specifier: ^4.9.0
@@ -1850,7 +1994,7 @@ importers:
         version: 6.0.1
       tsup:
         specifier: ^8.4.0
-        version: 8.4.0(@swc/core@1.3.101(@swc/helpers@0.5.15))(jiti@2.4.2)(postcss@8.5.6)(tsx@4.17.0)(typescript@5.9.3)(yaml@2.7.1)
+        version: 8.4.0(@swc/core@1.3.101(@swc/helpers@0.5.15))(jiti@2.4.2)(postcss@8.5.6)(tsx@4.17.0)(typescript@5.5.4)(yaml@2.7.1)
       tsx:
         specifier: 4.17.0
         version: 4.17.0
@@ -1858,7 +2002,7 @@ importers:
   packages/rsc:
     dependencies:
       '@trigger.dev/core':
-        specifier: workspace:^4.3.0
+        specifier: workspace:^4.4.3
         version: link:../core
       mlly:
         specifier: ^1.7.1
@@ -1874,10 +2018,10 @@ importers:
         specifier: ^0.15.4
         version: 0.15.4
       '@trigger.dev/build':
-        specifier: workspace:^4.3.0
+        specifier: workspace:^4.4.3
         version: link:../build
       '@types/node':
-        specifier: ^20.14.14
+        specifier: 20.14.14
         version: 20.14.14
       '@types/react':
         specifier: '*'
@@ -1936,7 +2080,7 @@ importers:
         version: 3.0.2
       valibot:
         specifier: ^1.1.0
-        version: 1.1.0(typescript@5.9.3)
+        version: 1.1.0(typescript@5.5.4)
       yup:
         specifier: ^1.7.0
         version: 1.7.0
@@ -1950,7 +2094,7 @@ importers:
         specifier: 1.36.0
         version: 1.36.0
       '@trigger.dev/core':
-        specifier: workspace:4.3.0
+        specifier: workspace:4.4.3
         version: link:../core
       chalk:
         specifier: ^5.2.0
@@ -1996,8 +2140,8 @@ importers:
         specifier: ^8.5.3
         version: 8.5.4
       ai:
-        specifier: ^5.0.0
-        version: 5.0.14(zod@3.25.76)
+        specifier: ^6.0.0
+        version: 6.0.3(zod@3.25.76)
       encoding:
         specifier: ^0.1.13
         version: 0.1.13
@@ -2139,7 +2283,7 @@ importers:
         specifier: ^4.0.3
         version: 4.0.8
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       '@types/react':
         specifier: ^19
@@ -2154,7 +2298,7 @@ importers:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5
+        specifier: 5.5.4
         version: 5.5.4
 
   references/d3-openai-agents:
@@ -2221,7 +2365,7 @@ importers:
         specifier: workspace:*
         version: link:../../packages/build
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       '@types/react':
         specifier: ^19
@@ -2242,7 +2386,7 @@ importers:
         specifier: 4.19.3
         version: 4.19.3
       typescript:
-        specifier: ^5
+        specifier: 5.5.4
         version: 5.5.4
 
   references/effect:
@@ -2263,6 +2407,9 @@ importers:
 
   references/hello-world:
     dependencies:
+      '@ai-sdk/openai':
+        specifier: ^3.0.41
+        version: 3.0.41(zod@3.25.76)
       '@sinclair/typebox':
         specifier: ^0.34.3
         version: 0.34.38
@@ -2272,6 +2419,9 @@ importers:
       '@trigger.dev/sdk':
         specifier: workspace:*
         version: link:../../packages/trigger-sdk
+      ai:
+        specifier: ^6.0.116
+        version: 6.0.116(zod@3.25.76)
       arktype:
         specifier: ^2.0.0
         version: 2.1.20
@@ -2363,7 +2513,7 @@ importers:
         version: link:../../packages/trigger-sdk
       '@uploadthing/react':
         specifier: ^7.0.3
-        version: 7.0.3(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(react@18.3.1)(uploadthing@7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1))
+        version: 7.0.3(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(react@18.3.1)(uploadthing@7.1.0(express@5.2.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1))
       ai:
         specifier: ^4.0.0
         version: 4.0.0(react@18.3.1)(zod@3.25.76)
@@ -2402,7 +2552,7 @@ importers:
         version: 1.0.7(tailwindcss@3.4.1)
       uploadthing:
         specifier: ^7.1.0
-        version: 7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1)
+        version: 7.1.0(express@5.2.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1)
       zod:
         specifier: 3.25.76
         version: 3.25.76
@@ -2433,7 +2583,7 @@ importers:
     dependencies:
       '@prisma/client':
         specifier: 6.14.0
-        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2443,10 +2593,10 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.14.0
-        version: 6.14.0(magicast@0.3.5)(typescript@5.9.3)
+        version: 6.14.0(magicast@0.3.5)(typescript@5.5.4)
       prisma-generator-ts-enums:
         specifier: ^1.1.0
-        version: 1.1.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))
+        version: 1.1.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2458,7 +2608,7 @@ importers:
         version: 6.16.0
       '@prisma/client':
         specifier: 6.16.0
-        version: 6.16.0(prisma@6.16.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.16.0(prisma@6.16.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2468,7 +2618,7 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.16.0
-        version: 6.16.0(magicast@0.3.5)(typescript@5.9.3)
+        version: 6.16.0(magicast@0.3.5)(typescript@5.5.4)
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2477,7 +2627,7 @@ importers:
     dependencies:
       '@prisma/client':
         specifier: 6.19.0
-        version: 6.19.0(prisma@6.19.0(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.19.0(prisma@6.19.0(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2487,7 +2637,7 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.19.0
-        version: 6.19.0(typescript@5.9.3)
+        version: 6.19.0(typescript@5.5.4)
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2496,7 +2646,7 @@ importers:
     dependencies:
       '@prisma/client':
         specifier: 6.14.0
-        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2506,7 +2656,7 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.14.0
-        version: 6.14.0(magicast@0.3.5)(typescript@5.9.3)
+        version: 6.14.0(magicast@0.3.5)(typescript@5.5.4)
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2515,7 +2665,7 @@ importers:
     dependencies:
       '@prisma/client':
         specifier: 6.19.0
-        version: 6.19.0(prisma@6.19.0(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.19.0(prisma@6.19.0(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2525,7 +2675,7 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.19.0
-        version: 6.19.0(typescript@5.9.3)
+        version: 6.19.0(typescript@5.5.4)
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2537,7 +2687,7 @@ importers:
         version: 6.20.0-integration-next.8
       '@prisma/client':
         specifier: 6.20.0-integration-next.8
-        version: 6.20.0-integration-next.8(prisma@6.20.0-integration-next.8(@types/react@19.0.12)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.20.0-integration-next.8(prisma@6.20.0-integration-next.8(@types/react@19.2.14)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.5.4))(typescript@5.5.4)
       '@trigger.dev/build':
         specifier: workspace:*
         version: link:../../packages/build
@@ -2550,7 +2700,7 @@ importers:
     devDependencies:
       prisma:
         specifier: 6.20.0-integration-next.8
-        version: 6.20.0-integration-next.8(@types/react@19.0.12)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.9.3)
+        version: 6.20.0-integration-next.8(@types/react@19.2.14)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.5.4)
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
@@ -2574,7 +2724,7 @@ importers:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5.5.4
+        specifier: 5.5.4
         version: 5.5.4
 
   references/realtime-hooks-test:
@@ -2602,7 +2752,7 @@ importers:
         specifier: ^4
         version: 4.0.17
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       '@types/react':
         specifier: ^19
@@ -2617,7 +2767,7 @@ importers:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5
+        specifier: 5.5.4
         version: 5.5.4
 
   references/realtime-streams:
@@ -2657,7 +2807,7 @@ importers:
         specifier: ^4
         version: 4.0.17
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       '@types/react':
         specifier: ^19
@@ -2672,9 +2822,43 @@ importers:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5
+        specifier: 5.5.4
         version: 5.5.4
 
+  references/seed:
+    dependencies:
+      '@sinclair/typebox':
+        specifier: ^0.34.3
+        version: 0.34.38
+      '@trigger.dev/build':
+        specifier: workspace:*
+        version: link:../../packages/build
+      '@trigger.dev/sdk':
+        specifier: workspace:*
+        version: link:../../packages/trigger-sdk
+      arktype:
+        specifier: ^2.0.0
+        version: 2.1.20
+      openai:
+        specifier: ^4.97.0
+        version: 4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76)
+      puppeteer-core:
+        specifier: ^24.15.0
+        version: 24.15.0(bufferutil@4.0.9)
+      replicate:
+        specifier: ^1.0.1
+        version: 1.0.1
+      yup:
+        specifier: ^1.6.1
+        version: 1.7.0
+      zod:
+        specifier: 3.25.76
+        version: 3.25.76
+    devDependencies:
+      trigger.dev:
+        specifier: workspace:*
+        version: link:../../packages/cli-v3
+
   references/telemetry:
     dependencies:
       '@opentelemetry/resources':
@@ -2685,13 +2869,13 @@ importers:
         version: link:../../packages/trigger-sdk
     devDependencies:
       '@types/node':
-        specifier: ^20
+        specifier: 20.14.14
         version: 20.14.14
       trigger.dev:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5
+        specifier: 5.5.4
         version: 5.5.4
 
   references/test-tasks:
@@ -2710,7 +2894,7 @@ importers:
         specifier: workspace:*
         version: link:../../packages/cli-v3
       typescript:
-        specifier: ^5.5.4
+        specifier: 5.5.4
         version: 5.5.4
 
 packages:
@@ -2736,6 +2920,18 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
+  '@ai-sdk/gateway@3.0.2':
+    resolution: {integrity: sha512-giJEg9ob45htbu3iautK+2kvplY2JnTj7ir4wZzYSQWvqGatWfBBfDuNCU5wSJt9BCGjymM5ZS9ziD42JGCZBw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/gateway@3.0.66':
+    resolution: {integrity: sha512-SIQ0YY0iMuv+07HLsZ+bB990zUJ6S4ujORAh+Jv1V2KGNn73qQKnGO0JBk+w+Res8YqOFSycwDoWcFlQrVxS4A==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/openai@1.0.1':
     resolution: {integrity: sha512-snZge8457afWlosVNUn+BG60MrxAPOOm3zmIMxJZih8tneNSiRbTVCbSzAtq/9vsnOHDe5RR83PRl85juOYEnA==}
     engines: {node: '>=18'}
@@ -2766,6 +2962,12 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
+  '@ai-sdk/openai@3.0.41':
+    resolution: {integrity: sha512-IZ42A+FO+vuEQCVNqlnAPYQnnUpUfdJIwn1BEDOBywiEHa23fw7PahxVtlX9zm3/zMvTW4JKPzWyvAgDu+SQ2A==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/provider-utils@1.0.22':
     resolution: {integrity: sha512-YHK2rpj++wnLVc9vPGzGFP3Pjeld2MwhKinetA0zKXOoHAT/Jit5O8kZsxcSlJPu9wvcGT1UGZEjZrtO7PfFOQ==}
     engines: {node: '>=18'}
@@ -2808,6 +3010,18 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4
 
+  '@ai-sdk/provider-utils@4.0.1':
+    resolution: {integrity: sha512-de2v8gH9zj47tRI38oSxhQIewmNc+OZjYIOOaMoVWKL65ERSav2PYYZHPSPCrfOeLMkv+Dyh8Y0QGwkO29wMWQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  '@ai-sdk/provider-utils@4.0.19':
+    resolution: {integrity: sha512-3eG55CrSWCu2SXlqq2QCsFjo3+E7+Gmg7i/oRVoSZzIodTuDSfLb3MRje67xE9RFea73Zao7Lm4mADIfUETKGg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/provider@0.0.26':
     resolution: {integrity: sha512-dQkfBDs2lTYpKM8389oopPdQgIU007GQyCbuPPrV+K6MtSII3HBfE0stUIMXUb44L+LK1t6GXPP7wjSzjO6uKg==}
     engines: {node: '>=18'}
@@ -2828,17 +3042,13 @@ packages:
     resolution: {integrity: sha512-6o7Y2SeO9vFKB8lArHXehNuusnpddKPk7xqL7T2/b+OvXMRIXUO1rR4wcv1hAFUAT9avGZshty3Wlua/XA7TvA==}
     engines: {node: '>=18'}
 
-  '@ai-sdk/react@0.0.70':
-    resolution: {integrity: sha512-GnwbtjW4/4z7MleLiW+TOZC2M29eCg1tOUpuEiYFMmFNZK8mkrqM0PFZMo6UsYeUYMWqEOOcPOU9OQVJMJh7IQ==}
+  '@ai-sdk/provider@3.0.0':
+    resolution: {integrity: sha512-m9ka3ptkPQbaHHZHqDXDF9C9B5/Mav0KTdky1k2HZ3/nrW2t1AgObxIVPyGDWQNS9FXT/FS6PIoSjpcP/No8rQ==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/provider@3.0.8':
+    resolution: {integrity: sha512-oGMAgGoQdBXbZqNG0Ze56CHjDZ1IDYOwGYxYjO5KLSlz5HiNQ9udIXsPZ61VWaHGZ5XW/jyjmr6t2xz2jGVwbQ==}
     engines: {node: '>=18'}
-    peerDependencies:
-      react: ^18 || ^19 || ^19.0.0-rc
-      zod: ^3.0.0
-    peerDependenciesMeta:
-      react:
-        optional: true
-      zod:
-        optional: true
 
   '@ai-sdk/react@1.0.0':
     resolution: {integrity: sha512-BDrZqQA07Btg64JCuhFvBgYV+tt2B8cXINzEqWknGoxqcwgdE8wSLG2gkXoLzyC2Rnj7oj0HHpOhLUxDCmoKZg==}
@@ -2872,33 +3082,6 @@ packages:
       zod:
         optional: true
 
-  '@ai-sdk/solid@0.0.54':
-    resolution: {integrity: sha512-96KWTVK+opdFeRubqrgaJXoNiDP89gNxFRWUp0PJOotZW816AbhUf4EnDjBjXTLjXL1n0h8tGSE9sZsRkj9wQQ==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      solid-js: ^1.7.7
-    peerDependenciesMeta:
-      solid-js:
-        optional: true
-
-  '@ai-sdk/svelte@0.0.57':
-    resolution: {integrity: sha512-SyF9ItIR9ALP9yDNAD+2/5Vl1IT6kchgyDH8xkmhysfJI6WrvJbtO1wdQ0nylvPLcsPoYu+cAlz1krU4lFHcYw==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      svelte: ^3.0.0 || ^4.0.0 || ^5.0.0
-    peerDependenciesMeta:
-      svelte:
-        optional: true
-
-  '@ai-sdk/ui-utils@0.0.50':
-    resolution: {integrity: sha512-Z5QYJVW+5XpSaJ4jYCCAVG7zIAuKOOdikhgpksneNmKvx61ACFaf98pmOd+xnjahl0pIlc/QIe6O4yVaJ1sEaw==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      zod: ^3.0.0
-    peerDependenciesMeta:
-      zod:
-        optional: true
-
   '@ai-sdk/ui-utils@1.0.0':
     resolution: {integrity: sha512-oXBDIM/0niWeTWyw77RVl505dNxBUDLLple7bTsqo2d3i1UKwGlzBUX8XqZsh7GbY7I6V05nlG0Y8iGlWxv1Aw==}
     engines: {node: '>=18'}
@@ -2920,15 +3103,6 @@ packages:
     peerDependencies:
       zod: ^3.23.8
 
-  '@ai-sdk/vue@0.0.59':
-    resolution: {integrity: sha512-+ofYlnqdc8c4F6tM0IKF0+7NagZRAiqBJpGDJ+6EYhDW8FHLUP/JFBgu32SjxSxC6IKFZxEnl68ZoP/Z38EMlw==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      vue: ^3.3.4
-    peerDependenciesMeta:
-      vue:
-        optional: true
-
   '@alloc/quick-lru@5.2.0':
     resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
     engines: {node: '>=10'}
@@ -3681,10 +3855,6 @@ packages:
     resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.28.5':
-    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/helper-validator-option@7.22.15':
     resolution: {integrity: sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==}
     engines: {node: '>=6.9.0'}
@@ -3721,11 +3891,6 @@ packages:
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  '@babel/parser@7.28.5':
-    resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
   '@babel/plugin-syntax-decorators@7.22.10':
     resolution: {integrity: sha512-z1KTVemBjnz+kSEilAsI4lbkPOl5TvJH7YDSY1CTIzvLWJ+KHXp+mRe8VPmfnyvqOPqar1V2gid2PleKzRUstQ==}
     engines: {node: '>=6.9.0'}
@@ -3848,10 +4013,6 @@ packages:
     resolution: {integrity: sha512-Y1GkI4ktrtvmawoSq+4FCVHNryea6uR+qUQy0AGxLSsjCX0nVmkYQMBLHDkXZuo5hGx7eYdnIaslsdBFm7zbUw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.28.5':
-    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
-    engines: {node: '>=6.9.0'}
-
   '@balena/dockerignore@1.0.2':
     resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==}
 
@@ -3964,9 +4125,6 @@ packages:
     resolution: {integrity: sha512-7ORY85rphRazqHzImNXMrh4vsaPrpetFoTWpZYueCO2bbO6PXYDXp/GQ4DgxnGIqbWB/Di1Ai+Xuwq2o7DJ36A==}
     engines: {node: '>=16'}
 
-  '@codemirror/autocomplete@6.19.1':
-    resolution: {integrity: sha512-q6NenYkEy2fn9+JyjIxMWcNjzTL/IhwqfzOut1/G3PrIFkrbl4AL7Wkse5tLrQUUyqGoAKU5+Pi5jnnXxH5HGw==}
-
   '@codemirror/autocomplete@6.4.0':
     resolution: {integrity: sha512-HLF2PnZAm1s4kGs30EiqKMgD7XsYaQ0XJnMR0rofEWQ5t5D60SfqpDIkIh1ze5tiEbyUWm8+VJ6W1/erVvBMIA==}
     peerDependencies:
@@ -3978,17 +4136,14 @@ packages:
   '@codemirror/commands@6.1.3':
     resolution: {integrity: sha512-wUw1+vb34Ultv0Q9m/OVB7yizGXgtoDbkI5f5ErM8bebwLyUYjicdhJTKhTvPTpgkv8dq/BK0lQ3K5pRf2DAJw==}
 
-  '@codemirror/commands@6.10.0':
-    resolution: {integrity: sha512-2xUIc5mHXQzT16JnyOFkh8PvfeXuIut3pslWGfsGOhxP/lpgRm9HOl/mpzLErgt5mXDovqA0d11P21gofRLb9w==}
-
   '@codemirror/lang-javascript@6.1.2':
     resolution: {integrity: sha512-OcwLfZXdQ1OHrLiIcKCn7MqZ7nx205CMKlhe+vL88pe2ymhT9+2P+QhwkYGxMICj8TDHyp8HFKVwpiisUT7iEQ==}
 
   '@codemirror/lang-json@6.0.1':
     resolution: {integrity: sha512-+T1flHdgpqDDlJZ2Lkil/rLiRy684WMLc74xUnjJH48GQdfJo/pudlTRreZmKwzP8/tGdKf83wlbAdOCzlJOGQ==}
 
-  '@codemirror/language@6.11.3':
-    resolution: {integrity: sha512-9HBM2XnwDj7fnu0551HkGdrUrrqmYq/WC5iv6nbY2WdicXdGbhR/gfbZOH73Aqj4351alY1+aoG9rCNfiwS1RA==}
+  '@codemirror/lang-sql@6.5.5':
+    resolution: {integrity: sha512-DvOaP2RXLb2xlxJxxydTFfwyYw5YDqEFea6aAfgh9UH0kUD6J1KFZ0xPgPpw1eo/5s2w3L6uh5PVR7GM23GxkQ==}
 
   '@codemirror/language@6.3.2':
     resolution: {integrity: sha512-g42uHhOcEMAXjmozGG+rdom5UsbyfMxQFh7AbkeoaNImddL6Xt4cQDL0+JxmG7+as18rUAvZaqzP/TjsciVIrA==}
@@ -3996,27 +4151,15 @@ packages:
   '@codemirror/lint@6.4.2':
     resolution: {integrity: sha512-wzRkluWb1ptPKdzlsrbwwjYCPLgzU6N88YBAmlZi8WFyuiEduSd05MnJYNogzyc8rPK7pj6m95ptUApc8sHKVA==}
 
-  '@codemirror/lint@6.9.2':
-    resolution: {integrity: sha512-sv3DylBiIyi+xKwRCJAAsBZZZWo82shJ/RTMymLabAdtbkV5cSKwWDeCgtUq3v8flTaXS2y1kKkICuRYtUswyQ==}
-
   '@codemirror/search@6.2.3':
     resolution: {integrity: sha512-V9n9233lopQhB1dyjsBK2Wc1i+8hcCqxl1wQ46c5HWWLePoe4FluV3TGHoZ04rBRlGjNyz9DTmpJErig8UE4jw==}
 
-  '@codemirror/search@6.5.11':
-    resolution: {integrity: sha512-KmWepDE6jUdL6n8cAAqIpRmLPBZ5ZKnicE8oGU/s3QrAVID+0VhLFrzUucVKHG5035/BSykhExDL/Xm7dHthiA==}
-
   '@codemirror/state@6.2.0':
     resolution: {integrity: sha512-69QXtcrsc3RYtOtd+GsvczJ319udtBf1PTrr2KbLWM/e2CXUPnh0Nz9AUo8WfhSQ7GeL8dPVNUmhQVgpmuaNGA==}
 
-  '@codemirror/state@6.5.2':
-    resolution: {integrity: sha512-FVqsPqtPWKVVL3dPSxy8wEF/ymIEuVzF1PK3VbUgrxXpJUSHQWWZz4JMToquRxnkw+36LTamCZG2iua2Ptq0fA==}
-
   '@codemirror/theme-one-dark@6.1.3':
     resolution: {integrity: sha512-NzBdIvEJmx6fjeremiGp3t/okrLPYT0d9orIc7AFun8oZcRk58aejkqhv6spnz4MLAevrKNPMQYXEWMg4s+sKA==}
 
-  '@codemirror/view@6.38.7':
-    resolution: {integrity: sha512-+b0imJTgzehmMToqT9DWPBdeRj7/qDsJj7MzQ+1+do2KK2UkxKuLaHlUVeZk855wO6my6cfbF1c+Qozs8B3YqA==}
-
   '@codemirror/view@6.7.2':
     resolution: {integrity: sha512-HeK2GyycxceaQVyvYVYXmn1vUKYYBsHCcfGRSsFO+3fRRtwXx2STK0YiFBmiWx2vtU9gUAJgIUXUN8a0osI8Ng==}
 
@@ -4061,6 +4204,9 @@ packages:
     peerDependencies:
       '@bufbuild/protobuf': ^2.2.0
 
+  '@date-fns/tz@1.4.1':
+    resolution: {integrity: sha512-P5LUNhtbj6YfI3iJjw5EL9eUAG6OitD0W3fWQcpQjDRc/QIsL0tRNuO1PcDvPccWL1fSTXXdE1ds+l95DV/OFA==}
+
   '@depot/cli-darwin-arm64@0.0.1-cli.2.80.0':
     resolution: {integrity: sha512-H7tQ0zWXVmdYXGFvt3d/v5fmquMlMM1I9JC8C2yiBZ9En9a20hzSbKoiym92RtcfqjKQFvhXL0DT6vQmJ8bgQA==}
     engines: {node: '>=14'}
@@ -4203,6 +4349,12 @@ packages:
     cpu: [ppc64]
     os: [aix]
 
+  '@esbuild/aix-ppc64@0.24.2':
+    resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
   '@esbuild/aix-ppc64@0.25.1':
     resolution: {integrity: sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==}
     engines: {node: '>=18'}
@@ -4239,6 +4391,12 @@ packages:
     cpu: [arm64]
     os: [android]
 
+  '@esbuild/android-arm64@0.24.2':
+    resolution: {integrity: sha512-cNLgeqCqV8WxfcTIOeL4OAtSmL8JjcN6m09XIgro1Wi7cF4t/THaWEa7eL5CMoMBdjoHOTh/vwTO/o2TRXIyzg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
   '@esbuild/android-arm64@0.25.1':
     resolution: {integrity: sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==}
     engines: {node: '>=18'}
@@ -4281,6 +4439,12 @@ packages:
     cpu: [arm]
     os: [android]
 
+  '@esbuild/android-arm@0.24.2':
+    resolution: {integrity: sha512-tmwl4hJkCfNHwFB3nBa8z1Uy3ypZpxqxfTQOcHX+xRByyYgunVbZ9MzUUfb0RxaHIMnbHagwAxuTL+tnNM+1/Q==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
   '@esbuild/android-arm@0.25.1':
     resolution: {integrity: sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==}
     engines: {node: '>=18'}
@@ -4317,6 +4481,12 @@ packages:
     cpu: [x64]
     os: [android]
 
+  '@esbuild/android-x64@0.24.2':
+    resolution: {integrity: sha512-B6Q0YQDqMx9D7rvIcsXfmJfvUYLoP722bgfBlO5cGvNVb5V/+Y7nhBE3mHV9OpxBf4eAS2S68KZztiPaWq4XYw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
   '@esbuild/android-x64@0.25.1':
     resolution: {integrity: sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==}
     engines: {node: '>=18'}
@@ -4353,6 +4523,12 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
+  '@esbuild/darwin-arm64@0.24.2':
+    resolution: {integrity: sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@esbuild/darwin-arm64@0.25.1':
     resolution: {integrity: sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==}
     engines: {node: '>=18'}
@@ -4389,6 +4565,12 @@ packages:
     cpu: [x64]
     os: [darwin]
 
+  '@esbuild/darwin-x64@0.24.2':
+    resolution: {integrity: sha512-WeSrmwwHaPkNR5H3yYfowhZcbriGqooyu3zI/3GGpF8AyUdsrrP0X6KumITGA9WOyiJavnGZUwPGvxvwfWPHIA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
   '@esbuild/darwin-x64@0.25.1':
     resolution: {integrity: sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==}
     engines: {node: '>=18'}
@@ -4425,6 +4607,12 @@ packages:
     cpu: [arm64]
     os: [freebsd]
 
+  '@esbuild/freebsd-arm64@0.24.2':
+    resolution: {integrity: sha512-UN8HXjtJ0k/Mj6a9+5u6+2eZ2ERD7Edt1Q9IZiB5UZAIdPnVKDoG7mdTVGhHJIeEml60JteamR3qhsr1r8gXvg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
   '@esbuild/freebsd-arm64@0.25.1':
     resolution: {integrity: sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==}
     engines: {node: '>=18'}
@@ -4461,6 +4649,12 @@ packages:
     cpu: [x64]
     os: [freebsd]
 
+  '@esbuild/freebsd-x64@0.24.2':
+    resolution: {integrity: sha512-TvW7wE/89PYW+IevEJXZ5sF6gJRDY/14hyIGFXdIucxCsbRmLUcjseQu1SyTko+2idmCw94TgyaEZi9HUSOe3Q==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
   '@esbuild/freebsd-x64@0.25.1':
     resolution: {integrity: sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==}
     engines: {node: '>=18'}
@@ -4497,6 +4691,12 @@ packages:
     cpu: [arm64]
     os: [linux]
 
+  '@esbuild/linux-arm64@0.24.2':
+    resolution: {integrity: sha512-7HnAD6074BW43YvvUmE/35Id9/NB7BeX5EoNkK9obndmZBUk8xmJJeU7DwmUeN7tkysslb2eSl6CTrYz6oEMQg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
   '@esbuild/linux-arm64@0.25.1':
     resolution: {integrity: sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==}
     engines: {node: '>=18'}
@@ -4533,6 +4733,12 @@ packages:
     cpu: [arm]
     os: [linux]
 
+  '@esbuild/linux-arm@0.24.2':
+    resolution: {integrity: sha512-n0WRM/gWIdU29J57hJyUdIsk0WarGd6To0s+Y+LwvlC55wt+GT/OgkwoXCXvIue1i1sSNWblHEig00GBWiJgfA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
   '@esbuild/linux-arm@0.25.1':
     resolution: {integrity: sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==}
     engines: {node: '>=18'}
@@ -4569,6 +4775,12 @@ packages:
     cpu: [ia32]
     os: [linux]
 
+  '@esbuild/linux-ia32@0.24.2':
+    resolution: {integrity: sha512-sfv0tGPQhcZOgTKO3oBE9xpHuUqguHvSo4jl+wjnKwFpapx+vUDcawbwPNuBIAYdRAvIDBfZVvXprIj3HA+Ugw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
   '@esbuild/linux-ia32@0.25.1':
     resolution: {integrity: sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==}
     engines: {node: '>=18'}
@@ -4611,6 +4823,12 @@ packages:
     cpu: [loong64]
     os: [linux]
 
+  '@esbuild/linux-loong64@0.24.2':
+    resolution: {integrity: sha512-CN9AZr8kEndGooS35ntToZLTQLHEjtVB5n7dl8ZcTZMonJ7CCfStrYhrzF97eAecqVbVJ7APOEe18RPI4KLhwQ==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
   '@esbuild/linux-loong64@0.25.1':
     resolution: {integrity: sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==}
     engines: {node: '>=18'}
@@ -4647,6 +4865,12 @@ packages:
     cpu: [mips64el]
     os: [linux]
 
+  '@esbuild/linux-mips64el@0.24.2':
+    resolution: {integrity: sha512-iMkk7qr/wl3exJATwkISxI7kTcmHKE+BlymIAbHO8xanq/TjHaaVThFF6ipWzPHryoFsesNQJPE/3wFJw4+huw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
   '@esbuild/linux-mips64el@0.25.1':
     resolution: {integrity: sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==}
     engines: {node: '>=18'}
@@ -4683,6 +4907,12 @@ packages:
     cpu: [ppc64]
     os: [linux]
 
+  '@esbuild/linux-ppc64@0.24.2':
+    resolution: {integrity: sha512-shsVrgCZ57Vr2L8mm39kO5PPIb+843FStGt7sGGoqiiWYconSxwTiuswC1VJZLCjNiMLAMh34jg4VSEQb+iEbw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
   '@esbuild/linux-ppc64@0.25.1':
     resolution: {integrity: sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==}
     engines: {node: '>=18'}
@@ -4719,6 +4949,12 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
+  '@esbuild/linux-riscv64@0.24.2':
+    resolution: {integrity: sha512-4eSFWnU9Hhd68fW16GD0TINewo1L6dRrB+oLNNbYyMUAeOD2yCK5KXGK1GH4qD/kT+bTEXjsyTCiJGHPZ3eM9Q==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
   '@esbuild/linux-riscv64@0.25.1':
     resolution: {integrity: sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==}
     engines: {node: '>=18'}
@@ -4755,6 +4991,12 @@ packages:
     cpu: [s390x]
     os: [linux]
 
+  '@esbuild/linux-s390x@0.24.2':
+    resolution: {integrity: sha512-S0Bh0A53b0YHL2XEXC20bHLuGMOhFDO6GN4b3YjRLK//Ep3ql3erpNcPlEFed93hsQAjAQDNsvcK+hV90FubSw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
   '@esbuild/linux-s390x@0.25.1':
     resolution: {integrity: sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==}
     engines: {node: '>=18'}
@@ -4791,12 +5033,24 @@ packages:
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/linux-x64@0.24.2':
+    resolution: {integrity: sha512-8Qi4nQcCTbLnK9WoMjdC9NiTG6/E38RNICU6sUNqK0QFxCYgoARqVqxdFmWkdonVsvGqWhmm7MO0jyTqLqwj0Q==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
   '@esbuild/linux-x64@0.25.1':
     resolution: {integrity: sha512-xbfUhu/gnvSEg+EGovRc+kjBAkrvtk38RlerAzQxvMzlB4fXpCFCeUAYzJvrnhFtdeyVCDANSjJvOvGYoeKzFA==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/netbsd-arm64@0.24.2':
+    resolution: {integrity: sha512-wuLK/VztRRpMt9zyHSazyCVdCXlpHkKm34WUyinD2lzK07FAHTq0KQvZZlXikNWkDGoT6x3TD51jKQ7gMVpopw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
   '@esbuild/netbsd-arm64@0.25.1':
     resolution: {integrity: sha512-O96poM2XGhLtpTh+s4+nP7YCCAfb4tJNRVZHfIE7dgmax+yMP2WgMd2OecBuaATHKTHsLWHQeuaxMRnCsH8+5g==}
     engines: {node: '>=18'}
@@ -4833,6 +5087,12 @@ packages:
     cpu: [x64]
     os: [netbsd]
 
+  '@esbuild/netbsd-x64@0.24.2':
+    resolution: {integrity: sha512-VefFaQUc4FMmJuAxmIHgUmfNiLXY438XrL4GDNV1Y1H/RW3qow68xTwjZKfj/+Plp9NANmzbH5R40Meudu8mmw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
   '@esbuild/netbsd-x64@0.25.1':
     resolution: {integrity: sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==}
     engines: {node: '>=18'}
@@ -4845,6 +5105,12 @@ packages:
     cpu: [arm64]
     os: [openbsd]
 
+  '@esbuild/openbsd-arm64@0.24.2':
+    resolution: {integrity: sha512-YQbi46SBct6iKnszhSvdluqDmxCJA+Pu280Av9WICNwQmMxV7nLRHZfjQzwbPs3jeWnuAhE9Jy0NrnJ12Oz+0A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
   '@esbuild/openbsd-arm64@0.25.1':
     resolution: {integrity: sha512-Na9T3szbXezdzM/Kfs3GcRQNjHzM6GzFBeU1/6IV/npKP5ORtp9zbQjvkDJ47s6BCgaAZnnnu/cY1x342+MvZg==}
     engines: {node: '>=18'}
@@ -4881,6 +5147,12 @@ packages:
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openbsd-x64@0.24.2':
+    resolution: {integrity: sha512-+iDS6zpNM6EnJyWv0bMGLWSWeXGN/HTaF/LXHXHwejGsVi+ooqDfMCCTerNFxEkM3wYVcExkeGXNqshc9iMaOA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
   '@esbuild/openbsd-x64@0.25.1':
     resolution: {integrity: sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==}
     engines: {node: '>=18'}
@@ -4917,6 +5189,12 @@ packages:
     cpu: [x64]
     os: [sunos]
 
+  '@esbuild/sunos-x64@0.24.2':
+    resolution: {integrity: sha512-hTdsW27jcktEvpwNHJU4ZwWFGkz2zRJUz8pvddmXPtXDzVKTTINmlmga3ZzwcuMpUvLw7JkLy9QLKyGpD2Yxig==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
   '@esbuild/sunos-x64@0.25.1':
     resolution: {integrity: sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==}
     engines: {node: '>=18'}
@@ -4953,6 +5231,12 @@ packages:
     cpu: [arm64]
     os: [win32]
 
+  '@esbuild/win32-arm64@0.24.2':
+    resolution: {integrity: sha512-LihEQ2BBKVFLOC9ZItT9iFprsE9tqjDjnbulhHoFxYQtQfai7qfluVODIYxt1PgdoyQkz23+01rzwNwYfutxUQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
   '@esbuild/win32-arm64@0.25.1':
     resolution: {integrity: sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==}
     engines: {node: '>=18'}
@@ -4989,6 +5273,12 @@ packages:
     cpu: [ia32]
     os: [win32]
 
+  '@esbuild/win32-ia32@0.24.2':
+    resolution: {integrity: sha512-q+iGUwfs8tncmFC9pcnD5IvRHAzmbwQ3GPS5/ceCyHdjXubwQWI12MKWSNSMYLJMq23/IUCvJMS76PDqXe1fxA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
   '@esbuild/win32-ia32@0.25.1':
     resolution: {integrity: sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==}
     engines: {node: '>=18'}
@@ -5025,6 +5315,12 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@esbuild/win32-x64@0.24.2':
+    resolution: {integrity: sha512-7VTgWzgMGvup6aSqDPLiW5zHaxYJGTO4OokMjIlrCtf+VpEL+cXKtCvg723iguPYI5oaUNdS+/V7OU2gvXVWEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@esbuild/win32-x64@0.25.1':
     resolution: {integrity: sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==}
     engines: {node: '>=18'}
@@ -5048,6 +5344,7 @@ packages:
   '@fal-ai/serverless-client@0.15.0':
     resolution: {integrity: sha512-4Vuocu0342OijAN6xO/lwohDV7h90LbkTnOAEwH+pYvMFVC6RYmHS4GILc/wnOWBTw+iFlZFEKlljEVolkjVfg==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
 
   '@fast-csv/parse@5.0.2':
     resolution: {integrity: sha512-gMu1Btmm99TP+wc0tZnlH30E/F1Gw1Tah3oMDBHNPe9W8S68ixVHjt89Wg5lh7d9RuQMtwN+sGl5kxR891+fzw==}
@@ -5058,8 +5355,8 @@ packages:
   '@fastify/ajv-compiler@4.0.2':
     resolution: {integrity: sha512-Rkiu/8wIjpsf46Rr+Fitd3HRP+VsxUFDDeag0hs9L0ksfnwx2g7SPQQTFL0E8Qv+rfXzQOxBJnjUB9ITUDjfWQ==}
 
-  '@fastify/busboy@2.0.0':
-    resolution: {integrity: sha512-JUFJad5lv7jxj926GPgymrWQxxjPYuJNiNjNMzqT+HiuP6Vl3dk5xzG+8sTX96np0ZAluvaMzPsjhHZ5rNuNQQ==}
+  '@fastify/busboy@2.1.1':
+    resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==}
     engines: {node: '>=14'}
 
   '@fastify/error@4.2.0':
@@ -5209,6 +5506,12 @@ packages:
     peerDependencies:
       hono: ^4
 
+  '@hono/node-server@1.19.9':
+    resolution: {integrity: sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw==}
+    engines: {node: '>=18.14.1'}
+    peerDependencies:
+      hono: ^4
+
   '@hono/node-ws@1.0.4':
     resolution: {integrity: sha512-0j1TMp67U5ym0CIlvPKcKtD0f2ZjaS/EnhOxFLs3bVfV+/4WInBE7hVe2x/7PLEsNIUK9+jVL8lPd28rzTAcZg==}
     engines: {node: '>=18.14.1'}
@@ -5543,9 +5846,6 @@ packages:
     resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
     engines: {node: '>=8'}
 
-  '@jridgewell/gen-mapping@0.3.13':
-    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
-
   '@jridgewell/gen-mapping@0.3.2':
     resolution: {integrity: sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==}
     engines: {node: '>=6.0.0'}
@@ -5554,9 +5854,6 @@ packages:
     resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==}
     engines: {node: '>=6.0.0'}
 
-  '@jridgewell/remapping@2.3.5':
-    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
-
   '@jridgewell/resolve-uri@3.1.0':
     resolution: {integrity: sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==}
     engines: {node: '>=6.0.0'}
@@ -5569,9 +5866,6 @@ packages:
     resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
     engines: {node: '>=6.0.0'}
 
-  '@jridgewell/source-map@0.3.11':
-    resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==}
-
   '@jridgewell/source-map@0.3.3':
     resolution: {integrity: sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==}
 
@@ -5605,9 +5899,22 @@ packages:
     peerDependencies:
       jsep: ^0.4.0||^1.0.0
 
+  '@jsonhero/json-infer-types@1.2.11':
+    resolution: {integrity: sha512-Bg9FFi4AlqaR29a32GsPxYWehVjtuXJ8cilMrcQA1lqaNZdt0TW5od0T7JeUxkRvxzck+QaXz4EvTA6mP/PVaw==}
+    engines: {node: '16'}
+
+  '@jsonhero/json-schema-fns@0.0.1':
+    resolution: {integrity: sha512-9/ykTgok+9yAQpYwqFI7yvDDGfN36uZEEVzUgLFktT/lQcDERX0NsRZsb1PPurnU3NortUK4XhnYKMu4cRMH2Q==}
+    engines: {node: '16'}
+
   '@jsonhero/path@1.0.21':
     resolution: {integrity: sha512-gVUDj/92acpVoJwsVJ/RuWOaHyG4oFzn898WNGQItLCTQ+hOaVlEaImhwE1WqOTf+l3dGOUkbSiVKlb3q1hd1Q==}
 
+  '@jsonhero/schema-infer@0.1.5':
+    resolution: {integrity: sha512-iZjrlRJ3JiIYbK77OSYvnp/fj7b4/FtahxEF/lZO0+4DZWjwOMdH5Apd41Nc8lMgvhuB4hGIsLec0J+RAOy6Tg==}
+    engines: {node: '>=16'}
+    hasBin: true
+
   '@jspm/core@2.0.1':
     resolution: {integrity: sha512-Lg3PnLp0QXpxwLIAuuJboLeRaIhrgJjeuh797QADg3xz8wGLugQOS5DpsE8A6i6Adgzf+bacllkKZG3J0tGfDw==}
 
@@ -5641,9 +5948,6 @@ packages:
   '@lezer/json@1.0.0':
     resolution: {integrity: sha512-zbAuUY09RBzCoCA3lJ1+ypKw5WSNvLqGMtasdW6HvVOqZoCpPr8eWrsGnOVWGKGn8Rh21FnrKRVlJXrGAVUqRw==}
 
-  '@lezer/lr@1.3.0':
-    resolution: {integrity: sha512-rpvS+WPS/PlbJCiW+bzXPbIFIRXmzRiTEDzMvrvgpED05w5ZQO59AzH3BJen2AnHuJIlP3DcJRjsKLTrkknUNA==}
-
   '@lezer/lr@1.4.3':
     resolution: {integrity: sha512-yenN5SqAxAPv/qMnpWW0AT7l+SxVrgG+u0tNsRQWqbrz66HIl8DnEbBObvy21J5K7+I1v7gsAnlE2VQ5yYVSeA==}
 
@@ -5661,9 +5965,6 @@ packages:
   '@manypkg/get-packages@1.1.3':
     resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==}
 
-  '@marijn/find-cluster-break@1.0.2':
-    resolution: {integrity: sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==}
-
   '@mdx-js/mdx@2.3.0':
     resolution: {integrity: sha512-jLuwRlz8DQfQNiUCJR50Y09CGPq3fLtmtUQfVrj79E0JWu3dvsVcxVIcfhR5h0iXu+/z++zDrYeiJqifRynJkA==}
 
@@ -5673,8 +5974,18 @@ packages:
   '@microsoft/fetch-event-source@2.0.1':
     resolution: {integrity: sha512-W6CLUJ2eBMw3Rec70qrsEW0jOm/3twwJv21mrmj2yORiaVmVYGS4sSS5yUwvQc1ZlDLYGPnClVWmUUMagKNsfA==}
 
-  '@modelcontextprotocol/sdk@1.24.2':
-    resolution: {integrity: sha512-hS/kzSfchqzvUeJUsdiDHi84/kNhLIZaZ6coGQVwbYIelOBbcAwUohUfaQTLa1MvFOK/jbTnGFzraHSFwB7pjQ==}
+  '@modelcontextprotocol/sdk@1.25.2':
+    resolution: {integrity: sha512-LZFeo4F9M5qOhC/Uc1aQSrBHxMrvxett+9KLHt7OhcExtoiRN9DKgbZffMP/nxjutWDQpfMDfP3nkHI4X9ijww==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@cfworker/json-schema': ^4.1.1
+      zod: ^3.25 || ^4.0
+    peerDependenciesMeta:
+      '@cfworker/json-schema':
+        optional: true
+
+  '@modelcontextprotocol/sdk@1.26.0':
+    resolution: {integrity: sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg==}
     engines: {node: '>=18'}
     peerDependencies:
       '@cfworker/json-schema': ^4.1.1
@@ -6269,8 +6580,8 @@ packages:
     peerDependencies:
       '@opentelemetry/api': ^1.0.0
 
-  '@opentelemetry/host-metrics@0.36.0':
-    resolution: {integrity: sha512-14lNY57qa21V3ZOl6xrqLMHR0HGlnPIApR6hr3oCw/Dqs5IzxhTwt2X8Stn82vWJJis7j/ezn11oODsizHj2dQ==}
+  '@opentelemetry/host-metrics@0.37.0':
+    resolution: {integrity: sha512-gf6nRFci0PTni9R1QQKjZ2uZE4Y6olLKhlwdM0qqLbbn3SBVKyP2jyBMiosBTHtRNLjY7s8hzQ44eLdK5wkGNQ==}
     engines: {node: ^18.19.0 || >=20.6.0}
     peerDependencies:
       '@opentelemetry/api': ^1.3.0
@@ -6657,7 +6968,7 @@ packages:
     engines: {node: '>=18.18'}
     peerDependencies:
       prisma: '*'
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       prisma:
         optional: true
@@ -6669,7 +6980,7 @@ packages:
     engines: {node: '>=18.18'}
     peerDependencies:
       prisma: '*'
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       prisma:
         optional: true
@@ -6681,7 +6992,7 @@ packages:
     engines: {node: '>=18.18'}
     peerDependencies:
       prisma: '*'
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       prisma:
         optional: true
@@ -6693,7 +7004,7 @@ packages:
     engines: {node: ^20.19 || ^22.12 || ^24.0}
     peerDependencies:
       prisma: '*'
-      typescript: '>=5.4.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       prisma:
         optional: true
@@ -8973,7 +9284,7 @@ packages:
     hasBin: true
     peerDependencies:
       '@remix-run/serve': ^2.1.0
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       '@remix-run/serve':
         optional: true
@@ -8987,7 +9298,7 @@ packages:
     peerDependencies:
       eslint: ^8.0.0
       react: ^18.0.0
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -8997,7 +9308,7 @@ packages:
     engines: {node: '>=18.0.0'}
     peerDependencies:
       express: ^4.17.1
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -9006,7 +9317,7 @@ packages:
     resolution: {integrity: sha512-TeSgjXnZUUlmw5FVpBVnXY7MLpracjdnwFNwoJE5NQkiUEFnGD/Yhvk4F2fOCkszqc2Z25KRclc5noweyiFu6Q==}
     engines: {node: '>=18.0.0'}
     peerDependencies:
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -9017,7 +9328,7 @@ packages:
     peerDependencies:
       react: ^18.0.0
       react-dom: ^18.0.0
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -9039,7 +9350,7 @@ packages:
     resolution: {integrity: sha512-Uz69yF4Gu6F3VYQub3JgDo9godN8eDMeZclkadBTAWN7bYLonu0ChR/GlFxS35OLeF7BDgudxOSZob0nE1WHNg==}
     engines: {node: '>=18.0.0'}
     peerDependencies:
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -9049,7 +9360,7 @@ packages:
     engines: {node: '>=18.0.0'}
     peerDependencies:
       react: ^18.0.0
-      typescript: ^5.1.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -9195,13 +9506,8 @@ packages:
   '@rushstack/eslint-patch@1.2.0':
     resolution: {integrity: sha512-sXo/qW2/pAcmT43VoRKOJbDOfV3cYpq3szSVfIThQXNt+E4DfKj361vaAt3c88U5tPUxzEswam7GW48PJqtKAg==}
 
-  '@s2-dev/streamstore@0.17.3':
-    resolution: {integrity: sha512-UeXL5+MgZQfNkbhCgEDVm7PrV5B3bxh6Zp4C5pUzQQwaoA+iGh2QiiIptRZynWgayzRv4vh0PYfnKpTzJEXegQ==}
-    peerDependencies:
-      typescript: ^5.9.3
-
-  '@s2-dev/streamstore@0.17.6':
-    resolution: {integrity: sha512-ocjZfKaPKmo2yhudM58zVNHv3rBLSbTKkabVoLFn9nAxU6iLrR2CO3QmSo7/waohI3EZHAWxF/Pw8kA8d6QH2g==}
+  '@s2-dev/streamstore@0.22.5':
+    resolution: {integrity: sha512-GqdOKIbIoIxT+40fnKzHbrsHB6gBqKdECmFe7D3Ojk4FoN1Hu0LhFzZv6ZmVMjoHHU+55debS1xSWjZwQmbIyQ==}
 
   '@sec-ant/readable-stream@0.4.1':
     resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==}
@@ -9368,6 +9674,10 @@ packages:
     resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==}
     engines: {node: '>=10'}
 
+  '@sindresorhus/merge-streams@4.0.0':
+    resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==}
+    engines: {node: '>=18'}
+
   '@slack/logger@4.0.0':
     resolution: {integrity: sha512-Wz7QYfPAlG/DR+DfABddUZeNgoeY7d1J39OCR2jR+v7VBsB8ezulDK5szTnDDPDwLH5IWhLvXIHlCFZV7MSKgA==}
     engines: {node: '>= 18', npm: '>= 8.6.0'}
@@ -9939,19 +10249,12 @@ packages:
   '@sodaru/yup-to-json-schema@2.0.1':
     resolution: {integrity: sha512-lWb0Wiz8KZ9ip/dY1eUqt7fhTPmL24p6Hmv5Fd9pzlzAdw/YNcWZr+tiCT4oZ4Zyxzi9+1X4zv82o7jYvcFxYA==}
 
-  '@splinetool/react-spline@2.2.6':
-    resolution: {integrity: sha512-y9L2VEbnC6FNZZu8XMmWM9YTTTWal6kJVfP05Amf0QqDNzCSumKsJxZyGUODvuCmiAvy0PfIfEsiVKnSxvhsDw==}
-    peerDependencies:
-      '@splinetool/runtime': '*'
-      react: '>=17.0.0'
-      react-dom: '>=17.0.0'
-
-  '@splinetool/runtime@1.11.2':
-    resolution: {integrity: sha512-rFz3KOQQRHQGzWBvPKRZcI7fZe5qxNYX1FmmCqzsbJkAU/hJdifaxpyN4xESpbkdta6s7riSmoz5lmPGIpZRRQ==}
-
   '@standard-schema/spec@1.0.0':
     resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==}
 
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
   '@stricli/auto-complete@1.2.0':
     resolution: {integrity: sha512-r9/msiloVmTF95mdhe04Uzqei1B0ZofhYRLeiPqpJ1W1RMCC8p9iW7kqBZEbALl2aRL5ZK9OEW3Q1cIejH7KEQ==}
     hasBin: true
@@ -9959,11 +10262,6 @@ packages:
   '@stricli/core@1.2.0':
     resolution: {integrity: sha512-5b+npntDY0TAB7wAw0daGlh3/R2sf0TDLyrB1By2jCNH+C+lmcSqMtJXOMLVtEGSkIOvqAgIWpLMSs1PXqzt3w==}
 
-  '@sveltejs/acorn-typescript@1.0.6':
-    resolution: {integrity: sha512-4awhxtMh4cx9blePWl10HRHj8Iivtqj+2QdDCSMDzxG+XKa9+VCNupQuCuvzEhYPzZSrX+0gC+0lHA/0fFKKQQ==}
-    peerDependencies:
-      acorn: ^8.9.0
-
   '@swc/core-darwin-arm64@1.3.101':
     resolution: {integrity: sha512-mNFK+uHNPRXSnfTOG34zJOeMl2waM4hF4a2NY7dkMXrPqw9CoJn4MwTXJcyMiSz1/BnNjjTCHF3Yhj0jPxmkzQ==}
     engines: {node: '>=10'}
@@ -10127,13 +10425,13 @@ packages:
     resolution: {integrity: sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==}
     engines: {node: '>=6'}
 
-  '@tabler/icons-react@2.47.0':
-    resolution: {integrity: sha512-iqly2FvCF/qUbgmvS8E40rVeYY7laltc5GUjRxQj59DuX0x/6CpKHTXt86YlI2whg4czvd/c8Ce8YR08uEku0g==}
+  '@tabler/icons-react@3.36.1':
+    resolution: {integrity: sha512-/8nOXeNeMoze9xY/QyEKG65wuvRhkT3q9aytaur6Gj8bYU2A98YVJyLc9MRmc5nVvpy+bRlrrwK/Ykr8WGyUWg==}
     peerDependencies:
-      react: ^16.5.1 || ^17.0.0 || ^18.0.0
+      react: '>= 16'
 
-  '@tabler/icons@2.47.0':
-    resolution: {integrity: sha512-4w5evLh+7FUUiA1GucvGj2ReX2TvOjEr4ejXdwL/bsjoSkof6r1gQmzqI+VHrE2CpJpB3al7bCTulOkFa/RcyA==}
+  '@tabler/icons@3.36.1':
+    resolution: {integrity: sha512-f4Jg3Fof/Vru5ioix/UO4GX+sdDsF9wQo47FbtvG+utIYYVQ/QVAC0QYgcBbAjQGfbdOh2CCf0BgiFOF9Ixtjw==}
 
   '@tailwindcss/container-queries@0.1.1':
     resolution: {integrity: sha512-p18dswChx6WnTSaJCSGx6lTmrGzNNvm2FtXmiO6AuA1V4U5REyoqwmT6kgAsIMdjo07QdAfYXHJ4hnMtfHzWgA==}
@@ -10230,6 +10528,10 @@ packages:
     peerDependencies:
       tailwindcss: '>=3.0.0 || insiders'
 
+  '@tanstack/match-sorter-utils@8.19.4':
+    resolution: {integrity: sha512-Wo1iKt2b9OT7d+YGhvEPD3DXvPv2etTusIMhMUoG7fbhmxcXCtIjJDEygy91Y2JFlwGyjqiBPRozme7UD8hoqg==}
+    engines: {node: '>=12'}
+
   '@tanstack/query-core@5.76.0':
     resolution: {integrity: sha512-FN375hb8ctzfNAlex5gHI6+WDXTNpe0nbxp/d2YJtnP+IBM6OUm7zcaoCW6T63BawGOYZBbKC0iPvr41TteNVg==}
 
@@ -10238,12 +10540,23 @@ packages:
     peerDependencies:
       react: ^18 || ^19
 
+  '@tanstack/react-table@8.21.3':
+    resolution: {integrity: sha512-5nNMTSETP4ykGegmVkhjcS8tTLW6Vl4axfEGQN3v0zdHYbK4UfoqfPChclTrJ4EoK9QynqAu9oUf8VEmrpZ5Ww==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      react: '>=16.8'
+      react-dom: '>=16.8'
+
   '@tanstack/react-virtual@3.0.4':
     resolution: {integrity: sha512-tiqKW/e2MJVCr7/pRUXulpkyxllaOclkHNfhKTo4pmHjJIqnhMfwIjc1Q1R0Un3PI3kQywywu/791c8z9u0qeA==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0
       react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0
 
+  '@tanstack/table-core@8.21.3':
+    resolution: {integrity: sha512-ldZXEhOBb8Is7xLs01fR3YEc3DERiz5silj8tnGkFZytt1abEvl/GhUmCE0PMLaMPTa3Jk4HbKmRlHmu+gCftg==}
+    engines: {node: '>=12'}
+
   '@tanstack/virtual-core@3.0.0':
     resolution: {integrity: sha512-SYXOBTjJb05rXa2vl55TTwO40A6wKu0R5i1qQwhJYNDIqaIGF7D0HsLw+pJAyi2OvntlEIVusx3xtbbgSUi6zg==}
 
@@ -10279,8 +10592,8 @@ packages:
       react: ^18.2.0
       react-dom: 18.2.0
 
-  '@trigger.dev/platform@1.0.21':
-    resolution: {integrity: sha512-D1p+Y5pj21Un8hhN7oS/X7c+mhHKL58w1nwI9XYxbKUK1cNIIVhEMNZ0IyYmYuLelSARUXYePlKSl0v4hlusZg==}
+  '@trigger.dev/platform@1.0.27':
+    resolution: {integrity: sha512-gYfYDBnp2RJpgL4V2oOeqzV20flMZg+oGALhxHmmNJdJM01MW4aJSLsFFjoj+dikpL+4/3gocJcoyZk1G02UNg==}
 
   '@types/acorn@4.0.6':
     resolution: {integrity: sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==}
@@ -10470,9 +10783,6 @@ packages:
   '@types/estree@1.0.6':
     resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==}
 
-  '@types/estree@1.0.7':
-    resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
-
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
@@ -10590,24 +10900,9 @@ packages:
   '@types/node-fetch@2.6.4':
     resolution: {integrity: sha512-1ZX9fcN4Rvkvgv4E6PAY5WXUFWFcRWxZa3EW83UjycOB9ljJCedb2CupIP4RZMEwF/M3eTcCihbBRgwtGbg5Rg==}
 
-  '@types/node@12.20.55':
-    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
-
-  '@types/node@18.19.20':
-    resolution: {integrity: sha512-SKXZvI375jkpvAj8o+5U2518XQv76mAsixqfXiVyWyXZbVWQK25RurFovYpVIxVzul0rZoH58V/3SkEnm7s3qA==}
-
-  '@types/node@20.11.22':
-    resolution: {integrity: sha512-/G+IxWxma6V3E+pqK1tSl2Fo1kl41pK1yeCyDsgkF9WlVAme4j5ISYM2zR11bgLFJGLN5sVK40T4RJNuiZbEjA==}
-
-  '@types/node@20.12.14':
-    resolution: {integrity: sha512-scnD59RpYD91xngrQQLGkE+6UrHUPzeKZWhhjBSa3HSkwjbQc38+q3RoIVEwxQGRw3M+j5hpNAM+lgV3cVormg==}
-
   '@types/node@20.14.14':
     resolution: {integrity: sha512-d64f00982fS9YoOgJkAMolK7MN8Iq3TDdVjchbYHdEmjth/DHowx82GnoA+tVUAN+7vxfYUgAzi+JXbKNd2SDQ==}
 
-  '@types/node@22.13.9':
-    resolution: {integrity: sha512-acBjXdRJ3A6Pb3tqnw9HZmyR3Fiol3aGxRCK1x3d+6CDAMjl7I649wpSd+yNURCjbOUGu9tqtLKnTGxmK6CyGw==}
-
   '@types/nodemailer@7.0.4':
     resolution: {integrity: sha512-ee8fxWqOchH+Hv6MDDNNy028kwvVnLplrStm4Zf/3uHWw5zzo8FoYYeffpJtGs2wWysEumMH0ZIdMGMY1eMAow==}
 
@@ -10670,6 +10965,9 @@ packages:
   '@types/react@19.0.12':
     resolution: {integrity: sha512-V6Ar115dBDrjbtXSrS+/Oruobc+qVbbUxDFC1RSbRqLt5SYvxxyIDrSC85RWml54g+jfNeEMZhEj7wW07ONQhA==}
 
+  '@types/react@19.2.14':
+    resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
+
   '@types/readable-stream@4.0.14':
     resolution: {integrity: sha512-xZn/AuUbCMShGsqH/ehZtGDwQtbx00M9rZ2ENLe4tOjFZ/JFeWMhEZkk2fEe1jAUqqEAURIkFJ7Az/go8mM1/w==}
 
@@ -10916,6 +11214,14 @@ packages:
     resolution: {integrity: sha512-yNEQvPcVrK9sIe637+I0jD6leluPxzwJKx/Haw6F4H77CdDsszUn5V3o96LPziXkSNE2B83+Z3mjqGKBK/R6Gg==}
     engines: {node: '>= 20'}
 
+  '@vercel/oidc@3.0.5':
+    resolution: {integrity: sha512-fnYhv671l+eTTp48gB4zEsTW/YtRgRPnkI2nT7x6qw5rkI1Lq2hTmQIpHPgyThI0znLK+vX2n9XxKdXZ7BUbbw==}
+    engines: {node: '>= 20'}
+
+  '@vercel/oidc@3.1.0':
+    resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==}
+    engines: {node: '>= 20'}
+
   '@vercel/otel@1.13.0':
     resolution: {integrity: sha512-esRkt470Y2jRK1B1g7S1vkt4Csu44gp83Zpu8rIyPoqy2BKgk4z7ik1uSMswzi45UogLHFl6yR5TauDurBQi4Q==}
     engines: {node: '>=18'}
@@ -10931,6 +11237,11 @@ packages:
   '@vercel/postgres@0.10.0':
     resolution: {integrity: sha512-fSD23DxGND40IzSkXjcFcxr53t3Tiym59Is0jSYIFpG4/0f0KO9SGtcp1sXiebvPaGe7N/tU05cH4yt2S6/IPg==}
     engines: {node: '>=18.14'}
+    deprecated: '@vercel/postgres is deprecated. If you are setting up a new database, you can choose an alternate storage solution from the Vercel Marketplace. If you had an existing Vercel Postgres database, it should have been migrated to Neon as a native Vercel integration. You can find more details and the guide to migrate to Neon''s SDKs here: https://neon.com/docs/guides/vercel-postgres-transition-guide'
+
+  '@vercel/sdk@1.19.1':
+    resolution: {integrity: sha512-K4rmtUT6t1vX06tiY44ot8A7W1FKN7g/tMkE7yZghCgNQ8b30SzljBd4ni8RNp2pJzM/HrZmphRDeIArO7oZuw==}
+    hasBin: true
 
   '@vitest/coverage-v8@3.1.4':
     resolution: {integrity: sha512-G4p6OtioySL+hPV7Y6JHlhpsODbJzt1ndwHAFkyk6vVjpK03PFsKnauZIzcd0PrK4zAbc5lc+jeZ+eNGiMA+iw==}
@@ -10979,35 +11290,6 @@ packages:
   '@vitest/utils@3.1.4':
     resolution: {integrity: sha512-yriMuO1cfFhmiGc8ataN51+9ooHRuURdfAZfwFd3usWynjzpLslZdYnRegTv32qdgtJTsj15FoeZe2g15fY1gg==}
 
-  '@vue/compiler-core@3.5.24':
-    resolution: {integrity: sha512-eDl5H57AOpNakGNAkFDH+y7kTqrQpJkZFXhWZQGyx/5Wh7B1uQYvcWkvZi11BDhscPgj8N7XV3oRwiPnx1Vrig==}
-
-  '@vue/compiler-dom@3.5.24':
-    resolution: {integrity: sha512-1QHGAvs53gXkWdd3ZMGYuvQFXHW4ksKWPG8HP8/2BscrbZ0brw183q2oNWjMrSWImYLHxHrx1ItBQr50I/q2zw==}
-
-  '@vue/compiler-sfc@3.5.24':
-    resolution: {integrity: sha512-8EG5YPRgmTB+YxYBM3VXy8zHD9SWHUJLIGPhDovo3Z8VOgvP+O7UP5vl0J4BBPWYD9vxtBabzW1EuEZ+Cqs14g==}
-
-  '@vue/compiler-ssr@3.5.24':
-    resolution: {integrity: sha512-trOvMWNBMQ/odMRHW7Ae1CdfYx+7MuiQu62Jtu36gMLXcaoqKvAyh+P73sYG9ll+6jLB6QPovqoKGGZROzkFFg==}
-
-  '@vue/reactivity@3.5.24':
-    resolution: {integrity: sha512-BM8kBhtlkkbnyl4q+HiF5R5BL0ycDPfihowulm02q3WYp2vxgPcJuZO866qa/0u3idbMntKEtVNuAUp5bw4teg==}
-
-  '@vue/runtime-core@3.5.24':
-    resolution: {integrity: sha512-RYP/byyKDgNIqfX/gNb2PB55dJmM97jc9wyF3jK7QUInYKypK2exmZMNwnjueWwGceEkP6NChd3D2ZVEp9undQ==}
-
-  '@vue/runtime-dom@3.5.24':
-    resolution: {integrity: sha512-Z8ANhr/i0XIluonHVjbUkjvn+CyrxbXRIxR7wn7+X7xlcb7dJsfITZbkVOeJZdP8VZwfrWRsWdShH6pngMxRjw==}
-
-  '@vue/server-renderer@3.5.24':
-    resolution: {integrity: sha512-Yh2j2Y4G/0/4z/xJ1Bad4mxaAk++C2v4kaa8oSYTMJBJ00/ndPuxCnWeot0/7/qafQFLh5pr6xeV6SdMcE/G1w==}
-    peerDependencies:
-      vue: 3.5.24
-
-  '@vue/shared@3.5.24':
-    resolution: {integrity: sha512-9cwHL2EsJBdi8NY22pngYYWzkTDhld6fAD6jlaeloNGciNSJL6bLpbxVgXl96X00Jtc6YWQv96YA/0sxex/k1A==}
-
   '@web3-storage/multipart-parser@1.0.0':
     resolution: {integrity: sha512-BEO6al7BYqcnfX15W2cnGR+Q566ACXAT9UQykORCWW80lmkpWsnEob6zJS1ZVBKsSJC8+7vJkHwlp+lXG1UCdw==}
 
@@ -11222,6 +11504,11 @@ packages:
     resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
     engines: {node: '>= 14'}
 
+  agentcrumbs@0.5.0:
+    resolution: {integrity: sha512-+1J7w+x9/DP8oF+ZMVkeXilkd81ydygENEVwLJKwhA3uGQ947DFRwld9hGqAocOcuU4DaQKIdxTzKCsFhpV1Eg==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
   agentkeepalive@4.5.0:
     resolution: {integrity: sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==}
     engines: {node: '>= 8.0.0'}
@@ -11237,27 +11524,6 @@ packages:
   ahocorasick@1.0.2:
     resolution: {integrity: sha512-hCOfMzbFx5IDutmWLAt6MZwOUjIfSM9G9FyVxytmE4Rs/5YDPWQrD/+IR1w+FweD9H2oOZEnv36TmkjhNURBVA==}
 
-  ai@3.4.33:
-    resolution: {integrity: sha512-plBlrVZKwPoRTmM8+D1sJac9Bq8eaa2jiZlHLZIWekKWI1yMWYZvCCEezY9ASPwRhULYDJB2VhKOBUUeg3S5JQ==}
-    engines: {node: '>=18'}
-    peerDependencies:
-      openai: ^4.42.0
-      react: ^18 || ^19 || ^19.0.0-rc
-      sswr: ^2.1.0
-      svelte: ^3.0.0 || ^4.0.0 || ^5.0.0
-      zod: ^3.0.0
-    peerDependenciesMeta:
-      openai:
-        optional: true
-      react:
-        optional: true
-      sswr:
-        optional: true
-      svelte:
-        optional: true
-      zod:
-        optional: true
-
   ai@4.0.0:
     resolution: {integrity: sha512-cqf2GCaXnOPhUU+Ccq6i+5I0jDjnFkzfq7t6mc0SUSibSa1wDPn5J4p8+Joh2fDGDYZOJ44rpTW9hSs40rXNAw==}
     engines: {node: '>=18'}
@@ -11302,6 +11568,18 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
+  ai@6.0.116:
+    resolution: {integrity: sha512-7yM+cTmyRLeNIXwt4Vj+mrrJgVQ9RMIW5WO0ydoLoYkewIvsMcvUmqS4j2RJTUXaF1HphwmSKUMQ/HypNRGOmA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
+  ai@6.0.3:
+    resolution: {integrity: sha512-OOo+/C+sEyscoLnbY3w42vjQDICioVNyS+F+ogwq6O5RJL/vgWGuiLzFwuP7oHTeni/MkmX8tIge48GTdaV7QQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   ajv-formats@2.1.1:
     resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
     peerDependencies:
@@ -11366,6 +11644,13 @@ packages:
     resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
     engines: {node: '>=12'}
 
+  antlr4ts-cli@0.5.0-alpha.4:
+    resolution: {integrity: sha512-lVPVBTA2CVHRYILSKilL6Jd4hAumhSZZWA7UbQNQrmaSSj7dPmmYaN4bOmZG79cOy0lS00i4LY68JZZjZMWVrw==}
+    hasBin: true
+
+  antlr4ts@0.5.0-alpha.4:
+    resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==}
+
   any-promise@1.3.0:
     resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
 
@@ -11401,10 +11686,6 @@ packages:
   aria-query@5.3.0:
     resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
 
-  aria-query@5.3.2:
-    resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==}
-    engines: {node: '>= 0.4'}
-
   arktype@2.1.20:
     resolution: {integrity: sha512-IZCEEXaJ8g+Ijd59WtSYwtjnqXiwM8sWQ5EjGamcto7+HVN9eK0C4p0zDlCuAwWhpqr6fIBkxPuYDl4/Mcj/+Q==}
 
@@ -11528,10 +11809,6 @@ packages:
     resolution: {integrity: sha512-eM9d/swFopRt5gdJ7jrpCwgvEMIayITpojhkkSMRsFHYuH5bkSQ4p/9qTEHtmNudUZh22Tehu7I6CxAW0IXTKA==}
     hasBin: true
 
-  available-typed-arrays@1.0.5:
-    resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==}
-    engines: {node: '>= 0.4'}
-
   available-typed-arrays@1.0.7:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
@@ -11558,10 +11835,6 @@ packages:
   axobject-query@3.2.1:
     resolution: {integrity: sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==}
 
-  axobject-query@4.1.0:
-    resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
-    engines: {node: '>= 0.4'}
-
   b4a@1.6.6:
     resolution: {integrity: sha512-5Tk1HLk6b6ctmjIkAcU/Ujv/1WqiDl0F0JdRCR80VsOcUlHcu7pWeWRlOqQLHfDEsVx9YH/aif5AG4ehoCtTmg==}
 
@@ -11575,9 +11848,6 @@ packages:
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
-  bare-events@2.5.4:
-    resolution: {integrity: sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==}
-
   bare-events@2.8.2:
     resolution: {integrity: sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==}
     peerDependencies:
@@ -11634,6 +11904,7 @@ packages:
   basic-ftp@5.0.3:
     resolution: {integrity: sha512-QHX8HLlncOLpy54mh+k/sWIFd0ThmRqwe9ZjELybGZK+tZ8rUb9VO0saKJUROTbE+KhzDUT7xziGpGrW8Kmd+g==}
     engines: {node: '>=10.0.0'}
+    deprecated: Security vulnerability fixed in 5.2.0, please upgrade
 
   bcrypt-pbkdf@1.0.2:
     resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==}
@@ -11675,6 +11946,10 @@ packages:
     resolution: {integrity: sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==}
     engines: {node: '>=18'}
 
+  body-parser@2.2.2:
+    resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==}
+    engines: {node: '>=18'}
+
   bottleneck@2.19.5:
     resolution: {integrity: sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw==}
 
@@ -11969,7 +12244,7 @@ packages:
   class-variance-authority@0.5.2:
     resolution: {integrity: sha512-j7Qqw3NPbs4IpO80gvdACWmVvHiLLo5MECacUBLnJG17CrLpWaQ7/4OaWX6P0IO1j2nvZ7AuSfBS/ImtEUZJGA==}
     peerDependencies:
-      typescript: '>= 4.5.5 < 6'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -12228,7 +12503,7 @@ packages:
     resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==}
     engines: {node: '>=14'}
     peerDependencies:
-      typescript: '>=4.9.5'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -12237,7 +12512,7 @@ packages:
     resolution: {integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==}
     engines: {node: '>=14'}
     peerDependencies:
-      typescript: '>=4.9.5'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -12268,9 +12543,6 @@ packages:
     resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==}
     engines: {node: '>= 14'}
 
-  crelt@1.0.5:
-    resolution: {integrity: sha512-+BO9wPPi+DWTDcNYhr/W90myha8ptzftZT+LwcmUbbok0rcP/fequmFYCw8NMoH7pkAZQzU78b3kYrlua5a9eA==}
-
   crelt@1.0.6:
     resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==}
 
@@ -12356,6 +12628,9 @@ packages:
   csstype@3.2.0:
     resolution: {integrity: sha512-si++xzRAY9iPp60roQiFta7OFbhrgvcthrhlNAGeQptSY25uJjkfUV8OArC3KLocB8JT8ohz+qgxWCmz8RhjIg==}
 
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
   csv-generate@3.4.3:
     resolution: {integrity: sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw==}
 
@@ -12559,6 +12834,9 @@ packages:
   dataloader@1.4.0:
     resolution: {integrity: sha512-68s5jYdlvasItOJnCuI2Q9s4q98g0pCyL3HrcKJu8KNugUl8ahgmZYg38ysLTgQjjXX3H8CJLkAvWrclWfcalw==}
 
+  date-fns-jalali@4.1.0-0:
+    resolution: {integrity: sha512-hTIP/z+t+qKwBDcmmsnmjWTduxCg+5KfdqWQvb2X/8C9+knYY6epN/pfxdDuyVlSVeFz0sM5eEfwIUQ70U4ckg==}
+
   date-fns@4.1.0:
     resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==}
 
@@ -12633,6 +12911,15 @@ packages:
       supports-color:
         optional: true
 
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
   decamelize-keys@1.1.1:
     resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==}
     engines: {node: '>=0.10.0'}
@@ -12797,6 +13084,9 @@ packages:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
 
+  discontinuous-range@1.0.0:
+    resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==}
+
   dlv@1.1.3:
     resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==}
 
@@ -13217,6 +13507,11 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
+  esbuild@0.24.2:
+    resolution: {integrity: sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   esbuild@0.25.1:
     resolution: {integrity: sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==}
     engines: {node: '>=18'}
@@ -13433,9 +13728,6 @@ packages:
     deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
 
-  esm-env@1.2.2:
-    resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
-
   espree@9.4.1:
     resolution: {integrity: sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -13453,9 +13745,6 @@ packages:
     resolution: {integrity: sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==}
     engines: {node: '>=0.10'}
 
-  esrap@2.1.2:
-    resolution: {integrity: sha512-DgvlIQeowRNyvLPWW4PT7Gu13WznY288Du086E751mwwbsgr29ytBiYeLzAGIo0qk3Ujob0SDk8TiSaM5WQzNg==}
-
   esrecurse@4.3.0:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
     engines: {node: '>=4.0'}
@@ -13493,9 +13782,6 @@ packages:
   estree-util-visit@1.2.0:
     resolution: {integrity: sha512-wdsoqhWueuJKsh5hqLw3j8lwFqNStm92VcwtAOAny8g/KS/l5Y8RISjR4k5W6skCj3Nirag/WUCMS0Nfy3sgsg==}
 
-  estree-walker@2.0.2:
-    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
-
   estree-walker@3.0.3:
     resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
 
@@ -13568,6 +13854,10 @@ packages:
     resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
     engines: {node: '>=16.17'}
 
+  execa@9.6.1:
+    resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==}
+    engines: {node: ^18.19.0 || >=20.5.0}
+
   exit-hook@2.2.1:
     resolution: {integrity: sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==}
     engines: {node: '>=6'}
@@ -13586,6 +13876,12 @@ packages:
     peerDependencies:
       express: ^4.11 || 5 || ^5.0.0-beta.1
 
+  express-rate-limit@8.2.1:
+    resolution: {integrity: sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      express: '>= 4.11'
+
   express@4.20.0:
     resolution: {integrity: sha512-pLdae7I6QqShF5PnNTCVn4hI91Dx0Grkn2+IAsMTgMIKuQVte2dN9PeGSSAME2FR8anOhVA62QDIUaWVfEXVLw==}
     engines: {node: '>= 0.10.0'}
@@ -13594,6 +13890,10 @@ packages:
     resolution: {integrity: sha512-ORF7g6qGnD+YtUG9yx4DFoqCShNMmUKiXuT5oWMHiOvt/4WFbHC6yCwQMTSBMno7AqntNCAzzcnnjowRkTL9eQ==}
     engines: {node: '>= 18'}
 
+  express@5.2.1:
+    resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
+    engines: {node: '>= 18'}
+
   exsolve@1.0.7:
     resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==}
 
@@ -13630,6 +13930,9 @@ packages:
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
+  fast-equals@4.0.3:
+    resolution: {integrity: sha512-G3BSX9cfKttjr+2o1O22tYMLq0DPluZnYtq1rXumE1SpL/F/SLIfHx08WYQoWSIpeMYf8sRbJ8++71+v6Pnxfg==}
+
   fast-equals@5.0.1:
     resolution: {integrity: sha512-WF1Wi8PwwSY7/6Kx0vKXtw8RwuSGoM1bvDaJbu7MxDlR1vovZjIAKrnzyrThgAjm6JDTu0fVgWXDlMGspodfoQ==}
     engines: {node: '>=6.0.0'}
@@ -13738,6 +14041,10 @@ packages:
   fft.js@4.0.4:
     resolution: {integrity: sha512-f9c00hphOgeQTlDyavwTtu6RiK8AIFjD6+jvXkNkpeQ7rirK3uFWVpalkoS4LAwbdX7mfZ8aoBfFVQX1Re/8aw==}
 
+  figures@6.1.0:
+    resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==}
+    engines: {node: '>=18'}
+
   file-entry-cache@6.0.1:
     resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==}
     engines: {node: ^10.12.0 || >=12.0.0}
@@ -14037,29 +14344,34 @@ packages:
   glob@10.3.10:
     resolution: {integrity: sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==}
     engines: {node: '>=16 || 14 >=14.17'}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@10.3.4:
     resolution: {integrity: sha512-6LFElP3A+i/Q8XQKEvZjkEWEOTgAIALR9AO2rwT8bgPhDd1anmqDJDZ6lLddI4ehxxxR1S5RIqKe1uapMQfYaQ==}
     engines: {node: '>=16 || 14 >=14.17'}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@10.4.5:
     resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@11.0.0:
     resolution: {integrity: sha512-9UiX/Bl6J2yaBbxKoEBRm4Cipxgok8kQYcOPEhScPwebu2I0HoQOuYdIO6S3hLuWoZgpDpwQZMzTFxgpkyT76g==}
     engines: {node: 20 || >=22}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   glob@9.3.5:
     resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==}
     engines: {node: '>=16 || 14 >=14.17'}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   globals@11.12.0:
     resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
@@ -14176,10 +14488,6 @@ packages:
     resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
     engines: {node: '>= 0.4'}
 
-  has-tostringtag@1.0.0:
-    resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==}
-    engines: {node: '>= 0.4'}
-
   has-tostringtag@1.0.2:
     resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
@@ -14247,6 +14555,10 @@ packages:
   hoist-non-react-statics@3.3.2:
     resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}
 
+  hono@4.11.8:
+    resolution: {integrity: sha512-eVkB/CYCCei7K2WElZW9yYQFWssG0DhaDhVvr7wy5jJ22K+ck8fWW0EsLpB0sITUTvPnc97+rrbQqIr5iqiy9Q==}
+    engines: {node: '>=16.9.0'}
+
   hono@4.5.11:
     resolution: {integrity: sha512-62FcjLPtjAFwISVBUshryl+vbHOjg8rE4uIK/dxyR8GpLztunZpwFmfEvmJCUI7xoGh/Sr3CGCDPCmYxVw7wUQ==}
     engines: {node: '>=16.0.0'}
@@ -14285,6 +14597,10 @@ packages:
     resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
     engines: {node: '>= 0.8'}
 
+  http-errors@2.0.1:
+    resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+    engines: {node: '>= 0.8'}
+
   http-proxy-agent@7.0.2:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
     engines: {node: '>= 14'}
@@ -14312,6 +14628,10 @@ packages:
     resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}
     engines: {node: '>=16.17.0'}
 
+  human-signals@8.0.1:
+    resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==}
+    engines: {node: '>=18.18.0'}
+
   humanize-duration@3.27.3:
     resolution: {integrity: sha512-iimHkHPfIAQ8zCDQLgn08pRqSVioyWvnGfaQ8gond2wf7Jq2jJ+24ykmnRyiz3fIldcn4oUuQXpjqKLhSVR7lw==}
 
@@ -14329,6 +14649,10 @@ packages:
     resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
     engines: {node: '>=0.10.0'}
 
+  iconv-lite@0.7.2:
+    resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
+    engines: {node: '>=0.10.0'}
+
   icss-utils@5.1.0:
     resolution: {integrity: sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==}
     engines: {node: ^10 || ^12 || >= 14}
@@ -14441,6 +14765,14 @@ packages:
     resolution: {integrity: sha512-1DKMMzlIHM02eBBVOFQ1+AolGjs6+xEcM4PDL7NqOS6szq7H9jSaEkIUH6/a5Hl241LzW6JLSiAbNvTQjUupUA==}
     engines: {node: '>=12.22.0'}
 
+  ip-address@10.0.1:
+    resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==}
+    engines: {node: '>= 12'}
+
+  ip-address@8.1.0:
+    resolution: {integrity: sha512-Wz91gZKpNKoXtqvY8ScarKYwhXoK4r/b5QuT+uywe/azv0/nUCo7Bh0IRRI7F9DHR06kJNWtzMGLIbXavngbKA==}
+    engines: {node: '>= 12'}
+
   ip-address@9.0.5:
     resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
     engines: {node: '>= 12'}
@@ -14646,10 +14978,6 @@ packages:
     resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==}
     engines: {node: '>= 0.4'}
 
-  is-typed-array@1.1.10:
-    resolution: {integrity: sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==}
-    engines: {node: '>= 0.4'}
-
   is-typed-array@1.1.13:
     resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==}
     engines: {node: '>= 0.4'}
@@ -14661,6 +14989,10 @@ packages:
     resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
     engines: {node: '>=10'}
 
+  is-unicode-supported@2.1.0:
+    resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==}
+    engines: {node: '>=18'}
+
   is-weakref@1.0.2:
     resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==}
 
@@ -14838,6 +15170,9 @@ packages:
   json-schema-traverse@1.0.0:
     resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
 
+  json-schema-typed@8.0.2:
+    resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
+
   json-schema@0.4.0:
     resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
 
@@ -14912,6 +15247,9 @@ packages:
   jws@3.2.3:
     resolution: {integrity: sha512-byiJ0FLRdLdSVSReO/U4E7RoEyOCKnEnEPMjq3HxWtvzLsV08/i5RQKsFVNkCldrCaPr2vDNAOMsfs8T/Hze7g==}
 
+  jwt-decode@3.1.2:
+    resolution: {integrity: sha512-UfpWE/VZn0iP50d8cz9NrZLM9lSWhcJ+0Gt/nm4by88UL+J1SiKN8/5dkjMmbEzwL2CAe+67GsegCbIKtbp75A==}
+
   katex@0.16.25:
     resolution: {integrity: sha512-woHRUZ/iF23GBP1dkDQMh1QBad9dmr8/PAwNA54VrSOVYgI12MAcE14TqnDdQOdzyEonGzMepYnqBMYdsoAr8Q==}
     hasBin: true
@@ -15142,9 +15480,6 @@ packages:
     resolution: {integrity: sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==}
     engines: {node: '>=14'}
 
-  locate-character@3.0.0:
-    resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==}
-
   locate-path@5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
@@ -15230,8 +15565,8 @@ packages:
   lodash.uniq@4.5.0:
     resolution: {integrity: sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==}
 
-  lodash@4.17.21:
-    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+  lodash@4.17.23:
+    resolution: {integrity: sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==}
 
   log-symbols@4.1.0:
     resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
@@ -15261,8 +15596,8 @@ packages:
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.0.0:
-    resolution: {integrity: sha512-Qv32eSV1RSCfhY3fpPE2GNZ8jgM9X7rdAfemLWqTUxwiyIC4jJ6Sy0fZ8H+oLWevO6i4/bizg7c8d8i6bxrzbA==}
+  lru-cache@11.2.4:
+    resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
     engines: {node: 20 || >=22}
 
   lru-cache@4.1.5:
@@ -15699,6 +16034,10 @@ packages:
     resolution: {integrity: sha512-oHlN/w+3MQ3rba9rqFr6V/ypF10LSkdwUysQL7GkXoTgIWeV+tcXGA852TBxH+gsh8UWoyhR1hKcoMJTuWflpg==}
     engines: {node: '>= 0.6'}
 
+  mime-db@1.54.0:
+    resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+    engines: {node: '>= 0.6'}
+
   mime-types@2.1.35:
     resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
     engines: {node: '>= 0.6'}
@@ -15707,6 +16046,10 @@ packages:
     resolution: {integrity: sha512-XqoSHeCGjVClAmoGFG3lVFqQFRIrTVw2OH3axRqAcfaw+gHWIfnASS92AV+Rl/mk0MupgZTRHQOjxY6YVnzK5w==}
     engines: {node: '>= 0.6'}
 
+  mime-types@3.0.2:
+    resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
+    engines: {node: '>=18'}
+
   mime@1.6.0:
     resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
     engines: {node: '>=4'}
@@ -15822,6 +16165,10 @@ packages:
     resolution: {integrity: sha512-umcy022ILvb5/3Djuu8LWeqUa8D68JaBzlttKeMWen48SjabqS3iY5w/vzeMzMUNhLDifyhbOwKDSznB1vvrwg==}
     engines: {node: '>= 18'}
 
+  minizlib@3.1.0:
+    resolution: {integrity: sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==}
+    engines: {node: '>= 18'}
+
   mitt@3.0.1:
     resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
 
@@ -15869,6 +16216,9 @@ packages:
   module-details-from-path@1.0.3:
     resolution: {integrity: sha512-ySViT69/76t8VhE1xXHK6Ch4NcDd26gx0MzKXLO+F7NOtnqH68d9zF94nT8ZWSxXh8ELOERsnJO/sWt1xZYw5A==}
 
+  moo@0.5.2:
+    resolution: {integrity: sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q==}
+
   morgan@1.10.0:
     resolution: {integrity: sha512-AbegBVI4sh6El+1gNwvD5YIck7nSA36weD7xvIxG4in80j/UoK8AEGaWnnz8v1GxonMCltmlNs5ZKbGvl9b1XQ==}
     engines: {node: '>= 0.8.0'}
@@ -15947,6 +16297,10 @@ packages:
   natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
+  nearley@2.20.1:
+    resolution: {integrity: sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==}
+    hasBin: true
+
   negotiator@0.6.3:
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
@@ -15972,6 +16326,7 @@ packages:
   next@14.1.0:
     resolution: {integrity: sha512-wlzrsbfeSU48YQBjZhDzOwhWhGsy+uQycR8bHAOt1LY1bn3zZEcDyHQOEoN3aWzQ8LHCAJ1nqrWCc9XF2+O45Q==}
     engines: {node: '>=18.17.0'}
+    deprecated: This version has a security vulnerability. Please upgrade to a patched version. See https://nextjs.org/blog/security-update-2025-12-11 for more details.
     hasBin: true
     peerDependencies:
       '@opentelemetry/api': ^1.1.0
@@ -15987,6 +16342,7 @@ packages:
   next@14.2.21:
     resolution: {integrity: sha512-rZmLwucLHr3/zfDMYbJXbw0ZeoBpirxkXuvsJbk7UPorvPYZhP7vq7aHbKnU7dQNCYIimRrbB2pp3xmf+wsYUg==}
     engines: {node: '>=18.17.0'}
+    deprecated: This version has a security vulnerability. Please upgrade to a patched version. See https://nextjs.org/blog/security-update-2025-12-11 for more details.
     hasBin: true
     peerDependencies:
       '@opentelemetry/api': ^1.1.0
@@ -16027,6 +16383,7 @@ packages:
   next@15.4.8:
     resolution: {integrity: sha512-jwOXTz/bo0Pvlf20FSb6VXVeWRssA2vbvq9SdrOPEg9x8E1B27C2rQtvriAn600o9hH61kjrVRexEffv3JybuA==}
     engines: {node: ^18.18.0 || ^19.8.0 || >= 20.0.0}
+    deprecated: This version has a security vulnerability. Please upgrade to a patched version. See https://nextjs.org/blog/security-update-2025-12-11 for more details.
     hasBin: true
     peerDependencies:
       '@opentelemetry/api': ^1.1.0
@@ -16189,6 +16546,10 @@ packages:
     resolution: {integrity: sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  npm-run-path@6.0.0:
+    resolution: {integrity: sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==}
+    engines: {node: '>=18'}
+
   num2fraction@1.2.2:
     resolution: {integrity: sha512-Y1wZESM7VUThYY+4W+X4ySH2maqcA+p7UR+w8VWNWVAd6lwuXXWz/w/Cz43J/dI2I+PS6wD5N+bJUF+gjWvIqg==}
 
@@ -16233,10 +16594,6 @@ packages:
     resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
     engines: {node: '>= 0.4'}
 
-  object.assign@4.1.4:
-    resolution: {integrity: sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==}
-    engines: {node: '>= 0.4'}
-
   object.assign@4.1.5:
     resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==}
     engines: {node: '>= 0.4'}
@@ -16285,10 +16642,6 @@ packages:
     resolution: {integrity: sha512-IF4PcGgzAr6XXSff26Sk/+P4KZFJVuHAJZj3wgO3vX2bMdNVp/QXTP3P7CEm9V1IdG8lDLY3HhiqpsE/nOwpPw==}
     engines: {node: ^10.13.0 || >=12.0.0}
 
-  on-change@4.0.2:
-    resolution: {integrity: sha512-cMtCyuJmTx/bg2HCpHo3ZLeF7FZnBOapLqZHr2AlLeJ5Ul0Zu2mUJJz051Fdwu/Et2YW04ZD+TtU+gVy0ACNCA==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-
   on-exit-leak-free@2.1.2:
     resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==}
     engines: {node: '>=14.0.0'}
@@ -16537,6 +16890,10 @@ packages:
     resolution: {integrity: sha512-kHt7kzLoS9VBZfUsiKjv43mr91ea+U05EyKkEtqp7vNbHxmaVuEqN7XxeEVnGrMtYOAxGrDElSi96K7EgO1zCA==}
     engines: {node: '>=6'}
 
+  parse-ms@4.0.0:
+    resolution: {integrity: sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==}
+    engines: {node: '>=18'}
+
   parse5-htmlparser2-tree-adapter@6.0.1:
     resolution: {integrity: sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==}
 
@@ -16650,9 +17007,6 @@ packages:
   pg-cloudflare@1.2.7:
     resolution: {integrity: sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==}
 
-  pg-connection-string@2.6.4:
-    resolution: {integrity: sha512-v+Z7W/0EO707aNMaAEfiGnGL9sxxumwLl2fJvCQtMn9Fxsg+lPpPkdcyBSv/KFgpGdYkMfn+EI1Or2EHjpgLCA==}
-
   pg-connection-string@2.8.5:
     resolution: {integrity: sha512-Ni8FuZ8yAF+sWZzojvtLE2b03cqjO5jNULcHFfM9ZZ0/JXrgom5pBREbtnAw7oxsxJqHw9Nz/XWORUEL3/IFow==}
 
@@ -16672,11 +17026,6 @@ packages:
     peerDependencies:
       pg: '>=8.0'
 
-  pg-pool@3.6.2:
-    resolution: {integrity: sha512-Htjbg8BlwXqSBQ9V8Vjtc+vzf/6fVUuak/3/XXKA9oxZprwW3IMDQTGHP+KDmVL7rtd+R1QjbnCFPuTHm3G4hg==}
-    peerDependencies:
-      pg: '>=8.0'
-
   pg-pool@3.9.6:
     resolution: {integrity: sha512-rFen0G7adh1YmgvrmE5IPIqbb+IgEzENUm+tzm6MLLDSlPRoZVhzU1WdML9PV2W5GOdRA9qBKURlbt1OsXOsPw==}
     peerDependencies:
@@ -16973,10 +17322,6 @@ packages:
     resolution: {integrity: sha512-Aweb9unOEpQ3ezu4Q00DPvvM2ZTUitJdNKeP/+uQgr1IBIqu574IaZoURId7BKtWMREwzKa9OgzPzezWGPWFQw==}
     engines: {node: ^10 || ^12 || >=14}
 
-  postcss@8.5.3:
-    resolution: {integrity: sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==}
-    engines: {node: ^10 || ^12 || >=14}
-
   postcss@8.5.4:
     resolution: {integrity: sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==}
     engines: {node: ^10 || ^12 || >=14}
@@ -17035,6 +17380,7 @@ packages:
   prebuild-install@7.1.3:
     resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
     engines: {node: '>=10'}
+    deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
     hasBin: true
 
   preferred-pm@3.0.3:
@@ -17123,6 +17469,10 @@ packages:
     resolution: {integrity: sha512-973driJZvxiGOQ5ONsFhOF/DtzPMOMtgC11kCpUrPGMTgqp2q/1gwzCquocrN33is0VZ5GFHXZYMM9l6h67v2Q==}
     engines: {node: '>=10'}
 
+  pretty-ms@9.3.0:
+    resolution: {integrity: sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==}
+    engines: {node: '>=18'}
+
   prism-react-renderer@2.1.0:
     resolution: {integrity: sha512-I5cvXHjA1PVGbGm1MsWCpvBCRrYyxEri0MC7/JbfIfYfcXAxHyO5PaUjs3A8H5GW6kJcLhTHxxMaOZZpRZD2iQ==}
     peerDependencies:
@@ -17141,7 +17491,7 @@ packages:
     engines: {node: '>=18.18'}
     hasBin: true
     peerDependencies:
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -17151,7 +17501,7 @@ packages:
     engines: {node: '>=18.18'}
     hasBin: true
     peerDependencies:
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -17161,7 +17511,7 @@ packages:
     engines: {node: '>=18.18'}
     hasBin: true
     peerDependencies:
-      typescript: '>=5.1.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -17171,7 +17521,7 @@ packages:
     engines: {node: ^20.19 || ^22.12 || ^24.0}
     hasBin: true
     peerDependencies:
-      typescript: '>=5.4.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -17267,9 +17617,6 @@ packages:
   pump@2.0.1:
     resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==}
 
-  pump@3.0.0:
-    resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==}
-
   pump@3.0.2:
     resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==}
 
@@ -17299,20 +17646,8 @@ packages:
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
-  qs@6.11.0:
-    resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==}
-    engines: {node: '>=0.6'}
-
-  qs@6.13.0:
-    resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==}
-    engines: {node: '>=0.6'}
-
-  qs@6.14.0:
-    resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
-    engines: {node: '>=0.6'}
-
-  qs@6.5.3:
-    resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==}
+  qs@6.14.1:
+    resolution: {integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==}
     engines: {node: '>=0.6'}
 
   quansync@0.2.11:
@@ -17328,6 +17663,13 @@ packages:
     resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
     engines: {node: '>=8'}
 
+  railroad-diagrams@1.0.0:
+    resolution: {integrity: sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==}
+
+  randexp@0.4.6:
+    resolution: {integrity: sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==}
+    engines: {node: '>=0.12'}
+
   random-words@2.0.0:
     resolution: {integrity: sha512-uqpnDqFnYrZajgmvgjmBrSZL2V1UA/9bNPGrilo12CmBeBszoff/avElutUlwWxG12gvmCk/8dUhvHefYxzYjw==}
 
@@ -17346,6 +17688,10 @@ packages:
     resolution: {integrity: sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==}
     engines: {node: '>= 0.8'}
 
+  raw-body@3.0.2:
+    resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
+    engines: {node: '>= 0.10'}
+
   rc9@2.1.2:
     resolution: {integrity: sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==}
 
@@ -17370,6 +17716,12 @@ packages:
     peerDependencies:
       react: '>=16.3.0'
 
+  react-day-picker@9.13.0:
+    resolution: {integrity: sha512-euzj5Hlq+lOHqI53NiuNhCP8HWgsPf/bBAVijR50hNaY1XwjKjShAnIe8jm8RD2W9IJUvihDIZ+KrmqfFzNhFQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: '>=16.8.0'
+
   react-dom@18.2.0:
     resolution: {integrity: sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==}
     peerDependencies:
@@ -17390,6 +17742,12 @@ packages:
     peerDependencies:
       react: ^19.1.0
 
+  react-draggable@4.5.0:
+    resolution: {integrity: sha512-VC+HBLEZ0XJxnOxVAZsdRi8rD04Iz3SiiKOoYzamjylUcju/hP9np/aZdLHf/7WOD268WMoNJMvYfB5yAK45cw==}
+    peerDependencies:
+      react: '>= 16.3.0'
+      react-dom: '>= 16.3.0'
+
   react-email@2.1.2:
     resolution: {integrity: sha512-HBHhpzEE5es9YUoo7VSj6qy1omjwndxf3/Sb44UJm/uJ2AjmqALo2yryux0CjW9QAVfitc9rxHkLvIb9H87QQw==}
     engines: {node: '>=18.0.0'}
@@ -17398,6 +17756,12 @@ packages:
   react-fast-compare@3.2.2:
     resolution: {integrity: sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==}
 
+  react-grid-layout@2.2.2:
+    resolution: {integrity: sha512-yNo9pxQWoxHWRAwHGSVT4DEGELYPyQ7+q9lFclb5jcqeFzva63/2F72CryS/jiTIr/SBIlTaDdyjqH+ODg8oBw==}
+    peerDependencies:
+      react: '>= 16.3.0'
+      react-dom: '>= 16.3.0'
+
   react-hotkeys-hook@4.4.1:
     resolution: {integrity: sha512-sClBMBioFEgFGYLTWWRKvhxcCx1DRznd+wkFHwQZspnRBkHTgruKIHptlK/U/2DPX8BhHoRGzpMVWUXMmdZlmw==}
     peerDependencies:
@@ -17410,15 +17774,15 @@ packages:
   react-is@17.0.2:
     resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
 
+  react-is@18.3.1:
+    resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
+
   react-markdown@10.1.0:
     resolution: {integrity: sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==}
     peerDependencies:
       '@types/react': '>=18'
       react: '>=18'
 
-  react-merge-refs@2.1.1:
-    resolution: {integrity: sha512-jLQXJ/URln51zskhgppGJ2ub7b2WFKGq3cl3NYKtlHoTG+dN2q7EzWrn3hN3EgPsTMvpR9tpq5ijdp7YwFZkag==}
-
   react-popper@2.3.0:
     resolution: {integrity: sha512-e1hj8lL3uM+sgSR4Lxzn5h1GxBlpa4CQz0XLF8kx4MDrDRWY0Ena4c97PUeSX9i5W3UAfDP0z0FXCTQkoXUl3Q==}
     peerDependencies:
@@ -17456,6 +17820,12 @@ packages:
       react: ^16.14.0 || ^17.0.0 || ^18.0.0
       react-dom: ^16.14.0 || ^17.0.0 || ^18.0.0
 
+  react-resizable@3.1.3:
+    resolution: {integrity: sha512-liJBNayhX7qA4tBJiBD321FDhJxgGTJ07uzH5zSORXoE8h7PyEZ8mLqmosST7ppf6C4zUsbd2gzDMmBCfFp9Lw==}
+    peerDependencies:
+      react: '>= 16.3'
+      react-dom: '>= 16.3'
+
   react-router-dom@6.17.0:
     resolution: {integrity: sha512-qWHkkbXQX+6li0COUUPKAUkxjNNqPJuiBd27dVwQGDNsuFBdMbrS6UZ0CLYc4CsbdLYTckn4oB4tGDuPZpPhaQ==}
     engines: {node: '>=14.0.0'}
@@ -17469,11 +17839,11 @@ packages:
     peerDependencies:
       react: '>=16.8'
 
-  react-smooth@4.0.1:
-    resolution: {integrity: sha512-OE4hm7XqR0jNOq3Qmk9mFLyd6p2+j6bvbPJ7qlB7+oo0eNcL2l7WQzG6MBnT3EXY6xzkLMUBec3AfewJdA0J8w==}
+  react-smooth@4.0.4:
+    resolution: {integrity: sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==}
     peerDependencies:
-      react: ^16.8.0 || ^17.0.0 || ^18.0.0
-      react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
   react-stately@3.29.1:
     resolution: {integrity: sha512-hc4ZHy/ahvMwr6z7XMjYJ7EgzNVrXhzM4l2Qj17rdRhERo7/ovWmQencf9pF7K8kD5TraEHxPHLrYzGN4fxfUQ==}
@@ -17588,12 +17958,12 @@ packages:
   recharts-scale@0.4.5:
     resolution: {integrity: sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==}
 
-  recharts@2.12.6:
-    resolution: {integrity: sha512-D+7j9WI+D0NHauah3fKHuNNcRK8bOypPW7os1DERinogGBGaHI7i6tQKJ0aUF3JXyBZ63dyfKIW2WTOPJDxJ8w==}
+  recharts@2.15.4:
+    resolution: {integrity: sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==}
     engines: {node: '>=14'}
     peerDependencies:
-      react: ^16.0.0 || ^17.0.0 || ^18.0.0
-      react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0
+      react: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+      react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
   rechoir@0.6.2:
     resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==}
@@ -17846,6 +18216,10 @@ packages:
     resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
     engines: {node: '>=8'}
 
+  ret@0.1.15:
+    resolution: {integrity: sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==}
+    engines: {node: '>=0.12'}
+
   ret@0.5.0:
     resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==}
     engines: {node: '>=10'}
@@ -17911,6 +18285,10 @@ packages:
     resolution: {integrity: sha512-/m/NSLxeYEgWNtyC+WtNHCF7jbGxOibVWKnn+1Psff4dJGOfoXP+MuC/f2CwSmyiHdOIzYnYFp4W6GxWfekaLA==}
     engines: {node: '>= 18'}
 
+  router@2.2.0:
+    resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+    engines: {node: '>= 18'}
+
   rtl-css-js@1.16.1:
     resolution: {integrity: sha512-lRQgou1mu19e+Ya0LsTvKrVJ5TYUbqCVPAiImX3UfLTenarvPUl1QFdvu5Z3PYmHT9RCcwIfbjRQBntExyj3Zg==}
 
@@ -18003,9 +18381,6 @@ packages:
   sembear@0.5.2:
     resolution: {integrity: sha512-Ij1vCAdFgWABd7zTg50Xw1/p0JgESNxuLlneEAsmBrKishA06ulTTL/SHGmNy2Zud7+rKrHTKNI6moJsn1ppAQ==}
 
-  semver-compare@1.0.0:
-    resolution: {integrity: sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==}
-
   semver@5.7.1:
     resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==}
     hasBin: true
@@ -18041,6 +18416,10 @@ packages:
     resolution: {integrity: sha512-v67WcEouB5GxbTWL/4NeToqcZiAWEq90N888fczVArY8A79J0L4FD7vj5hm3eUMua5EpoQ59wa/oovY6TLvRUA==}
     engines: {node: '>= 18'}
 
+  send@1.2.1:
+    resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
+    engines: {node: '>= 18'}
+
   serialize-javascript@6.0.1:
     resolution: {integrity: sha512-owoXEFjWRllis8/M1Q+Cw5k8ZH40e3zhp/ovX+Xr/vi1qj6QesbyXXViFbpNvWvPNAD62SutwEXavefrLJWj7w==}
 
@@ -18055,6 +18434,10 @@ packages:
     resolution: {integrity: sha512-A3We5UfEjG8Z7VkDv6uItWw6HY2bBSBJT1KtVESn6EOoOr2jAxNhxWCLY3jDE2WcuHXByWju74ck3ZgLwL8xmA==}
     engines: {node: '>= 18'}
 
+  serve-static@2.2.1:
+    resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
+    engines: {node: '>= 18'}
+
   set-blocking@2.0.0:
     resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
 
@@ -18296,12 +18679,19 @@ packages:
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
+  sprintf-js@1.1.2:
+    resolution: {integrity: sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==}
+
   sprintf-js@1.1.3:
     resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
 
   sqids@0.3.0:
     resolution: {integrity: sha512-lOQK1ucVg+W6n3FhRwwSeUijxe93b51Bfz5PMRMihVf1iVkl82ePQG7V5vwrhzB11v0NtsR25PSZRGiSomJaJw==}
 
+  sql-formatter@15.6.12:
+    resolution: {integrity: sha512-mkpF+RG402P66VMsnQkWewTRzDBWfu9iLbOfxaW/nAKOS/2A9MheQmcU5cmX0D0At9azrorZwpvcBRNNBozACQ==}
+    hasBin: true
+
   sqs-consumer@7.5.0:
     resolution: {integrity: sha512-aY3akgMjuK1aj4E7ZVAURUUnC8aNgUBES+b4SN+6ccMmJhi37MamWl7g1JbPow8sjIp1fBPz1bXCCDJmtjOTAg==}
     engines: {node: '>=18.0.0'}
@@ -18324,11 +18714,6 @@ packages:
     resolution: {integrity: sha512-bSf16tAFkGeRlUNDjXu8FzaMQt6g2HZJrun7mtMbIPOddxt3GLMSz5VWUWcqTJUPfLEaDIepGxv+bYQW49596A==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
-  sswr@2.1.0:
-    resolution: {integrity: sha512-Cqc355SYlTAaUt8iDPaC/4DPPXK925PePLMxyBKuWd5kKc5mwsG3nT9+Mq2tyguL5s7b4Jg+IRMpTRsNTAfpSQ==}
-    peerDependencies:
-      svelte: ^4.0.0 || ^5.0.0-next.0
-
   stack-generator@2.0.10:
     resolution: {integrity: sha512-mwnua/hkqM6pF4k8SnmZ2zfETsRUpWXREfA/goT8SLCV4iOFa4bzOX2nDipWAZFPTjLvQB82f5yaodMVhK0yJQ==}
 
@@ -18355,6 +18740,10 @@ packages:
     resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
     engines: {node: '>= 0.8'}
 
+  statuses@2.0.2:
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
+
   std-env@3.7.0:
     resolution: {integrity: sha512-JPbdCEQLj1w5GilpiHAx3qJvFndqybBysA3qUOnznweH4QbNYUsW/ea8QzSrnh0vNsezMMw5bcVool8lM0gwzg==}
 
@@ -18453,6 +18842,10 @@ packages:
     resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
     engines: {node: '>=12'}
 
+  strip-final-newline@4.0.0:
+    resolution: {integrity: sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==}
+    engines: {node: '>=18'}
+
   strip-indent@3.0.0:
     resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
     engines: {node: '>=8'}
@@ -18481,9 +18874,6 @@ packages:
     peerDependencies:
       webpack: ^5.0.0
 
-  style-mod@4.0.0:
-    resolution: {integrity: sha512-OPhtyEjyyN9x3nhPsu76f52yUGXiZcgvsrFVtvTkyGRQJ0XK+GPc6ov1z+lRpbeabka+MYEQxOYRnt5nF30aMw==}
-
   style-mod@4.1.3:
     resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
 
@@ -18579,23 +18969,11 @@ packages:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
-  svelte@5.43.6:
-    resolution: {integrity: sha512-RnyO9VXI85Bmsf4b8AuQFBKFYL3LKUl+ZrifOjvlrQoboAROj5IITVLK1yOXBjwUWUn2BI5cfmurktgCzuZ5QA==}
-    engines: {node: '>=18'}
-
   swr@2.2.5:
     resolution: {integrity: sha512-QtxqyclFeAsxEUeZIYmsaQ0UjimSq1RZ9Un7I68/0ClKK/U3LoyQunwkQfJZr2fc22DfIXLNDc2wFyTEikCUpg==}
     peerDependencies:
       react: ^16.11.0 || ^17.0.0 || ^18.0.0
 
-  swrev@4.0.0:
-    resolution: {integrity: sha512-LqVcOHSB4cPGgitD1riJ1Hh4vdmITOp+BkmfmXRh4hSF/t7EnS4iD+SOTmq7w5pPm/SiPeto4ADbKS6dHUDWFA==}
-
-  swrv@1.0.4:
-    resolution: {integrity: sha512-zjEkcP8Ywmj+xOJW3lIT65ciY/4AL4e/Or7Gj0MzU3zBJNMdJiT8geVZhINavnlHRMMCcJLHhraLTAiDOTmQ9g==}
-    peerDependencies:
-      vue: '>=3.2.26 < 4'
-
   sync-content@2.0.1:
     resolution: {integrity: sha512-NI1mo514yFhr8pV/5Etvgh+pSBUIpoAKoiBIUwALVlQQNAwb40bTw8hhPFaip/dvv0GhpHVOq0vq8iY02ppLTg==}
     engines: {node: 20 || >=22}
@@ -18605,8 +18983,8 @@ packages:
     resolution: {integrity: sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==}
     engines: {node: ^14.18.0 || >=16.0.0}
 
-  systeminformation@5.23.8:
-    resolution: {integrity: sha512-Osd24mNKe6jr/YoXLLK3k8TMdzaxDffhpCxgkfgBHcapykIkd50HXThM3TCEuHO2pPuCsSx2ms/SunqhU5MmsQ==}
+  systeminformation@5.27.14:
+    resolution: {integrity: sha512-3DoNDYSZBLxBwaJtQGWNpq0fonga/VZ47HY1+7/G3YoIPaPz93Df6egSzzTKbEMmlzUpy3eQ0nR9REuYIycXGg==}
     engines: {node: '>=8.0.0'}
     os: [darwin, linux, win32, freebsd, openbsd, netbsd, sunos, android]
     hasBin: true
@@ -18677,10 +19055,6 @@ packages:
     resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==}
     engines: {node: '>=6'}
 
-  tapable@2.2.2:
-    resolution: {integrity: sha512-Re10+NauLTMCudc7T5WLFLAwDhQ0JWdrMK+9B2M8zR5hRExKmsRDCBA7/aV/pNJFltmBFO5BAMlQFi/vq3nKOg==}
-    engines: {node: '>=6'}
-
   tapable@2.3.0:
     resolution: {integrity: sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==}
     engines: {node: '>=6'}
@@ -18704,14 +19078,22 @@ packages:
   tar@6.1.13:
     resolution: {integrity: sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==}
     engines: {node: '>=10'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   tar@6.2.1:
     resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
     engines: {node: '>=10'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   tar@7.4.3:
     resolution: {integrity: sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw==}
     engines: {node: '>=18'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+
+  tar@7.5.6:
+    resolution: {integrity: sha512-xqUeu2JAIJpXyvskvU3uvQW8PAmHrtXp2KDuMJwQqW8Sqq0CaZBAQ+dKS3RBXVhU4wC5NjAdKrmh84241gO9cA==}
+    engines: {node: '>=18'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   tdigest@0.1.2:
     resolution: {integrity: sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==}
@@ -18752,11 +19134,6 @@ packages:
       uglify-js:
         optional: true
 
-  terser@5.17.1:
-    resolution: {integrity: sha512-hVl35zClmpisy6oaoKALOpS0rDYLxRFLHhRuDlEGTKey9qHjS1w9GMORjuwIMt70Wan4lwsLYyWDVnWgF+KUEw==}
-    engines: {node: '>=10'}
-    hasBin: true
-
   terser@5.44.1:
     resolution: {integrity: sha512-t/R3R/n0MSwnnazuPpPNVO60LX0SKL45pyl9YlvxIdkH0Of7D5qM2EVe+yASRIlY5pZ73nclYJfNANGWPwFDZw==}
     engines: {node: '>=10'}
@@ -18951,7 +19328,7 @@ packages:
   ts-essentials@10.0.1:
     resolution: {integrity: sha512-HPH+H2bkkO8FkMDau+hFvv7KYozzned9Zr1Urn7rRPXMF4mZmCKOq+u4AI1AAW+2bofIOXTuSdKo9drQuni2dQ==}
     peerDependencies:
-      typescript: '>=4.5.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -18962,6 +19339,9 @@ packages:
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
 
+  ts-pattern@3.3.5:
+    resolution: {integrity: sha512-LD+wFR/RNckk1DrKV0LTH4KIT9wRqnnOjtEf77ovhKcVi8gf83Uf6U7OdywEua6KD9SbHadUdfolayfIUiPxzw==}
+
   ts-poet@6.6.0:
     resolution: {integrity: sha512-4vEH/wkhcjRPFOdBwIh9ItO6jOoumVLRF4aABDX5JSNEubSqwOulihxQPqai+OkuygJm3WYMInxXQX4QwVNMuw==}
 
@@ -18980,7 +19360,7 @@ packages:
     engines: {node: ^14.13.1 || ^16 || >=18}
     hasBin: true
     peerDependencies:
-      typescript: ^4.3.5 || ^5.0.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -18990,7 +19370,7 @@ packages:
     engines: {node: ^18 || >=20}
     hasBin: true
     peerDependencies:
-      typescript: ^5.0.0
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -19033,7 +19413,7 @@ packages:
       '@microsoft/api-extractor': ^7.36.0
       '@swc/core': ^1
       postcss: ^8.4.12
-      typescript: '>=4.5.0'
+      typescript: 5.5.4
     peerDependenciesMeta:
       '@microsoft/api-extractor':
         optional: true
@@ -19048,7 +19428,7 @@ packages:
     resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
     engines: {node: '>= 6'}
     peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
+      typescript: 5.5.4
 
   tsx@3.12.2:
     resolution: {integrity: sha512-ykAEkoBg30RXxeOMVeZwar+JH632dZn9EUJVyJwhfag62k6UO/dIyJEV58YuLF6e5BTdV/qmbQrpkWqjq9cUnQ==}
@@ -19162,6 +19542,10 @@ packages:
     resolution: {integrity: sha512-gd0sGezQYCbWSbkZr75mln4YBidWUN60+devscpLF5mtRDUpiaTvKpBNrdaCvel1NdR2k6vclXybU5fBd2i+nw==}
     engines: {node: '>= 0.6'}
 
+  type-is@2.0.1:
+    resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+    engines: {node: '>= 0.6'}
+
   typed-array-buffer@1.0.2:
     resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==}
     engines: {node: '>= 0.4'}
@@ -19187,26 +19571,11 @@ packages:
   typed-query-selector@2.12.0:
     resolution: {integrity: sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==}
 
-  typescript@5.1.6:
-    resolution: {integrity: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
-  typescript@5.3.3:
-    resolution: {integrity: sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
   typescript@5.5.4:
     resolution: {integrity: sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==}
     engines: {node: '>=14.17'}
     hasBin: true
 
-  typescript@5.9.3:
-    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
-
   ufo@1.5.4:
     resolution: {integrity: sha512-UsUk3byDzKd04EyoZ7U4DOlxQaD14JUKQl6/P7wiX4FNvUfm3XL246n9W5AmqwW5RSFJ27NAuM0iLscAOYUiGQ==}
 
@@ -19238,13 +19607,6 @@ packages:
   undici-types@5.26.5:
     resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
 
-  undici-types@6.20.0:
-    resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==}
-
-  undici@5.28.4:
-    resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==}
-    engines: {node: '>=14.0'}
-
   undici@5.29.0:
     resolution: {integrity: sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==}
     engines: {node: '>=14.0'}
@@ -19257,6 +19619,10 @@ packages:
     resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==}
     engines: {node: '>=18'}
 
+  unicorn-magic@0.3.0:
+    resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==}
+    engines: {node: '>=18'}
+
   unified@10.1.2:
     resolution: {integrity: sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==}
 
@@ -19463,7 +19829,7 @@ packages:
   valibot@1.1.0:
     resolution: {integrity: sha512-Nk8lX30Qhu+9txPYTwM0cFlWLdPFsFr6LblzqIySfbZph9+BFsAHsNvHOymEviUepeIW6KFHzpX8TKhbptBXXw==}
     peerDependencies:
-      typescript: '>=5'
+      typescript: 5.5.4
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -19531,7 +19897,7 @@ packages:
     engines: {node: ^14.18.0 || >=16.0.0}
     hasBin: true
     peerDependencies:
-      '@types/node': '>= 14'
+      '@types/node': 20.14.14
       less: '*'
       lightningcss: ^1.21.0
       sass: '*'
@@ -19559,7 +19925,7 @@ packages:
     engines: {node: ^18.0.0 || >=20.0.0}
     hasBin: true
     peerDependencies:
-      '@types/node': ^18.0.0 || >=20.0.0
+      '@types/node': 20.14.14
       less: '*'
       lightningcss: ^1.21.0
       sass: '*'
@@ -19592,7 +19958,7 @@ packages:
     peerDependencies:
       '@edge-runtime/vm': '*'
       '@types/debug': ^4.1.12
-      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      '@types/node': 20.14.14
       '@vitest/browser': 3.1.4
       '@vitest/ui': 3.1.4
       happy-dom: '*'
@@ -19633,17 +19999,6 @@ packages:
   vscode-uri@3.0.8:
     resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==}
 
-  vue@3.5.24:
-    resolution: {integrity: sha512-uTHDOpVQTMjcGgrqFPSb8iO2m1DUvo+WbGqoXQz8Y1CeBYQ0FXf2z1gLRaBtHjlRz7zZUBHxjVB5VTLzYkvftg==}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  w3c-keyname@2.2.6:
-    resolution: {integrity: sha512-f+fciywl1SJEniZHD6H+kUO8gOnwIr7f4ijKA6+ZvJFjeGi1r4PDLl53Ayud9O/rk64RqgoQine0feoeOU0kXg==}
-
   w3c-keyname@2.2.8:
     resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==}
 
@@ -19738,10 +20093,6 @@ packages:
     resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==}
     engines: {node: '>= 0.4'}
 
-  which-typed-array@1.1.9:
-    resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==}
-    engines: {node: '>= 0.4'}
-
   which@1.3.1:
     resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==}
     hasBin: true
@@ -19931,15 +20282,16 @@ packages:
     resolution: {integrity: sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==}
     engines: {node: '>=12.20'}
 
+  yoctocolors@2.1.2:
+    resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
+    engines: {node: '>=18'}
+
   yup@1.6.1:
     resolution: {integrity: sha512-JED8pB50qbA4FOkDol0bYF/p60qSEDQqBD0/qeIrUCG1KbPBIQ776fCUNb9ldbPcSTxA69g/47XTo4TqWiuXOA==}
 
   yup@1.7.0:
     resolution: {integrity: sha512-VJce62dBd+JQvoc+fCVq+KZfPHr+hXaxCcVgotfwWvlR0Ja3ffYKaJBT8rptPOSKOGJDCUnW2C2JWpud7aRP6Q==}
 
-  zimmerframe@1.1.4:
-    resolution: {integrity: sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==}
-
   zip-stream@6.0.1:
     resolution: {integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==}
     engines: {node: '>= 14'}
@@ -19947,11 +20299,6 @@ packages:
   zod-error@1.5.0:
     resolution: {integrity: sha512-zzopKZ/skI9iXpqCEPj+iLCKl9b88E43ehcU+sbRoHuwGd9F1IDVGQ70TyO6kmfiRL1g4IXkjsXK+g1gLYl4WQ==}
 
-  zod-to-json-schema@3.24.3:
-    resolution: {integrity: sha512-HIAfWdYIt1sssHfYZFCXp4rU1w2r8hVVXYIlmoa0r0gABLs5di3RCqPU5DDROogVz1pAdYBaz7HK5n9pSUNs3A==}
-    peerDependencies:
-      zod: ^3.24.1
-
   zod-to-json-schema@3.24.5:
     resolution: {integrity: sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==}
     peerDependencies:
@@ -19967,6 +20314,11 @@ packages:
     peerDependencies:
       zod: ^3.25 || ^4
 
+  zod-to-json-schema@3.25.1:
+    resolution: {integrity: sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==}
+    peerDependencies:
+      zod: ^3.25 || ^4
+
   zod-validation-error@1.5.0:
     resolution: {integrity: sha512-/7eFkAI4qV0tcxMBB/3+d2c1P6jzzZYdYSlBuAklzMuCrJu5bzJfHS0yVAS87dRHVlhftd6RFJDIvv03JgkSbw==}
     engines: {node: '>=16.0.0'}
@@ -20020,6 +20372,20 @@ snapshots:
       '@vercel/oidc': 3.0.3
       zod: 3.25.76
 
+  '@ai-sdk/gateway@3.0.2(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.0
+      '@ai-sdk/provider-utils': 4.0.1(zod@3.25.76)
+      '@vercel/oidc': 3.0.5
+      zod: 3.25.76
+
+  '@ai-sdk/gateway@3.0.66(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.19(zod@3.25.76)
+      '@vercel/oidc': 3.1.0
+      zod: 3.25.76
+
   '@ai-sdk/openai@1.0.1(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 1.0.0
@@ -20050,6 +20416,12 @@ snapshots:
       '@ai-sdk/provider-utils': 3.0.12(zod@3.25.76)
       zod: 3.25.76
 
+  '@ai-sdk/openai@3.0.41(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.19(zod@3.25.76)
+      zod: 3.25.76
+
   '@ai-sdk/provider-utils@1.0.22(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 0.0.26
@@ -20062,7 +20434,7 @@ snapshots:
   '@ai-sdk/provider-utils@2.0.0(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 1.0.0
-      eventsource-parser: 3.0.3
+      eventsource-parser: 3.0.6
       nanoid: 5.1.5
       secure-json-parse: 2.7.0
     optionalDependencies:
@@ -20085,18 +20457,32 @@ snapshots:
   '@ai-sdk/provider-utils@3.0.12(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 2.0.0
-      '@standard-schema/spec': 1.0.0
+      '@standard-schema/spec': 1.1.0
       eventsource-parser: 3.0.6
       zod: 3.25.76
 
   '@ai-sdk/provider-utils@3.0.3(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 2.0.0
-      '@standard-schema/spec': 1.0.0
-      eventsource-parser: 3.0.3
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
       zod: 3.25.76
       zod-to-json-schema: 3.24.6(zod@3.25.76)
 
+  '@ai-sdk/provider-utils@4.0.1(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.0
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 3.25.76
+
+  '@ai-sdk/provider-utils@4.0.19(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 3.25.76
+
   '@ai-sdk/provider@0.0.26':
     dependencies:
       json-schema: 0.4.0
@@ -20117,15 +20503,13 @@ snapshots:
     dependencies:
       json-schema: 0.4.0
 
-  '@ai-sdk/react@0.0.70(react@19.1.0)(zod@3.25.76)':
+  '@ai-sdk/provider@3.0.0':
     dependencies:
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76)
-      swr: 2.2.5(react@19.1.0)
-      throttleit: 2.1.0
-    optionalDependencies:
-      react: 19.1.0
-      zod: 3.25.76
+      json-schema: 0.4.0
+
+  '@ai-sdk/provider@3.0.8':
+    dependencies:
+      json-schema: 0.4.0
 
   '@ai-sdk/react@1.0.0(react@18.3.1)(zod@3.25.76)':
     dependencies:
@@ -20157,33 +20541,6 @@ snapshots:
     optionalDependencies:
       zod: 3.25.76
 
-  '@ai-sdk/solid@0.0.54(zod@3.25.76)':
-    dependencies:
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76)
-    transitivePeerDependencies:
-      - zod
-
-  '@ai-sdk/svelte@0.0.57(svelte@5.43.6)(zod@3.25.76)':
-    dependencies:
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76)
-      sswr: 2.1.0(svelte@5.43.6)
-    optionalDependencies:
-      svelte: 5.43.6
-    transitivePeerDependencies:
-      - zod
-
-  '@ai-sdk/ui-utils@0.0.50(zod@3.25.76)':
-    dependencies:
-      '@ai-sdk/provider': 0.0.26
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      json-schema: 0.4.0
-      secure-json-parse: 2.7.0
-      zod-to-json-schema: 3.24.6(zod@3.25.76)
-    optionalDependencies:
-      zod: 3.25.76
-
   '@ai-sdk/ui-utils@1.0.0(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 1.0.0
@@ -20206,16 +20563,6 @@ snapshots:
       zod: 3.25.76
       zod-to-json-schema: 3.24.6(zod@3.25.76)
 
-  '@ai-sdk/vue@0.0.59(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)':
-    dependencies:
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76)
-      swrv: 1.0.4(vue@3.5.24(typescript@5.9.3))
-    optionalDependencies:
-      vue: 3.5.24(typescript@5.9.3)
-    transitivePeerDependencies:
-      - zod
-
   '@alloc/quick-lru@5.2.0': {}
 
   '@ampproject/remapping@2.3.0':
@@ -20240,7 +20587,7 @@ snapshots:
       commander: 10.0.1
       marked: 9.1.6
       marked-terminal: 7.1.0(marked@9.1.6)
-      semver: 7.6.3
+      semver: 7.7.3
 
   '@arethetypeswrong/core@0.15.1':
     dependencies:
@@ -20248,7 +20595,7 @@ snapshots:
       fflate: 0.8.2
       semver: 7.7.3
       ts-expose-internals-conditionally: 1.0.0-empty.0
-      typescript: 5.3.3
+      typescript: 5.5.4
       validate-npm-package-name: 5.0.0
 
   '@ariakit/core@0.4.6': {}
@@ -22185,7 +22532,7 @@ snapshots:
       '@babel/traverse': 7.24.7
       '@babel/types': 7.24.0
       convert-source-map: 1.9.0
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -22314,8 +22661,6 @@ snapshots:
 
   '@babel/helper-validator-identifier@7.27.1': {}
 
-  '@babel/helper-validator-identifier@7.28.5': {}
-
   '@babel/helper-validator-option@7.22.15': {}
 
   '@babel/helpers@7.22.15':
@@ -22355,10 +22700,6 @@ snapshots:
     dependencies:
       '@babel/types': 7.27.3
 
-  '@babel/parser@7.28.5':
-    dependencies:
-      '@babel/types': 7.28.5
-
   '@babel/plugin-syntax-decorators@7.22.10(@babel/core@7.22.17)':
     dependencies:
       '@babel/core': 7.22.17
@@ -22479,7 +22820,7 @@ snapshots:
       '@babel/helper-split-export-declaration': 7.24.7
       '@babel/parser': 7.27.5
       '@babel/types': 7.27.3
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       globals: 11.12.0
     transitivePeerDependencies:
       - supports-color
@@ -22506,11 +22847,6 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.27.1
 
-  '@babel/types@7.28.5':
-    dependencies:
-      '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.28.5
-
   '@balena/dockerignore@1.0.2': {}
 
   '@bcoe/v8-coverage@1.0.2': {}
@@ -22723,20 +23059,6 @@ snapshots:
     dependencies:
       '@clickhouse/client-common': 1.12.1
 
-  '@codemirror/autocomplete@6.19.1':
-    dependencies:
-      '@codemirror/language': 6.11.3
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
-      '@lezer/common': 1.3.0
-
-  '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.0.2)':
-    dependencies:
-      '@codemirror/language': 6.3.2
-      '@codemirror/state': 6.2.0
-      '@codemirror/view': 6.7.2
-      '@lezer/common': 1.0.2
-
   '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)':
     dependencies:
       '@codemirror/language': 6.3.2
@@ -22749,23 +23071,16 @@ snapshots:
       '@codemirror/language': 6.3.2
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
-      '@lezer/common': 1.0.2
-
-  '@codemirror/commands@6.10.0':
-    dependencies:
-      '@codemirror/language': 6.11.3
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
       '@lezer/common': 1.3.0
 
   '@codemirror/lang-javascript@6.1.2':
     dependencies:
-      '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.0.2)
+      '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)
       '@codemirror/language': 6.3.2
       '@codemirror/lint': 6.4.2
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
-      '@lezer/common': 1.0.2
+      '@lezer/common': 1.3.0
       '@lezer/javascript': 1.4.1
 
   '@codemirror/lang-json@6.0.1':
@@ -22773,73 +23088,52 @@ snapshots:
       '@codemirror/language': 6.3.2
       '@lezer/json': 1.0.0
 
-  '@codemirror/language@6.11.3':
+  '@codemirror/lang-sql@6.5.5(@codemirror/view@6.7.2)':
     dependencies:
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
+      '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)
+      '@codemirror/language': 6.3.2
+      '@codemirror/state': 6.2.0
       '@lezer/common': 1.3.0
       '@lezer/highlight': 1.2.3
       '@lezer/lr': 1.4.3
-      style-mod: 4.1.3
+    transitivePeerDependencies:
+      - '@codemirror/view'
 
   '@codemirror/language@6.3.2':
     dependencies:
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
-      '@lezer/common': 1.0.2
-      '@lezer/highlight': 1.1.6
-      '@lezer/lr': 1.3.0
-      style-mod: 4.0.0
+      '@lezer/common': 1.3.0
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.3
+      style-mod: 4.1.3
 
   '@codemirror/lint@6.4.2':
     dependencies:
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
-      crelt: 1.0.5
-
-  '@codemirror/lint@6.9.2':
-    dependencies:
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
       crelt: 1.0.6
 
   '@codemirror/search@6.2.3':
     dependencies:
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
-      crelt: 1.0.5
-
-  '@codemirror/search@6.5.11':
-    dependencies:
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
       crelt: 1.0.6
 
   '@codemirror/state@6.2.0': {}
 
-  '@codemirror/state@6.5.2':
-    dependencies:
-      '@marijn/find-cluster-break': 1.0.2
-
   '@codemirror/theme-one-dark@6.1.3':
     dependencies:
-      '@codemirror/language': 6.11.3
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
+      '@codemirror/language': 6.3.2
+      '@codemirror/state': 6.2.0
+      '@codemirror/view': 6.7.2
       '@lezer/highlight': 1.2.3
 
-  '@codemirror/view@6.38.7':
-    dependencies:
-      '@codemirror/state': 6.5.2
-      crelt: 1.0.6
-      style-mod: 4.1.3
-      w3c-keyname: 2.2.8
-
   '@codemirror/view@6.7.2':
     dependencies:
       '@codemirror/state': 6.2.0
-      style-mod: 4.0.0
-      w3c-keyname: 2.2.6
+      style-mod: 4.1.3
+      w3c-keyname: 2.2.8
 
   '@colors/colors@1.5.0':
     optional: true
@@ -22860,7 +23154,7 @@ snapshots:
     dependencies:
       '@bufbuild/protobuf': 1.10.0
       '@connectrpc/connect': 1.4.0(@bufbuild/protobuf@1.10.0)
-      undici: 5.28.4
+      undici: 5.29.0
 
   '@connectrpc/connect-web@2.0.0-rc.3(@bufbuild/protobuf@2.2.5)(@connectrpc/connect@2.0.0-rc.3(@bufbuild/protobuf@2.2.5))':
     dependencies:
@@ -22875,6 +23169,8 @@ snapshots:
     dependencies:
       '@bufbuild/protobuf': 2.2.5
 
+  '@date-fns/tz@1.4.1': {}
+
   '@depot/cli-darwin-arm64@0.0.1-cli.2.80.0':
     optional: true
 
@@ -22973,7 +23269,7 @@ snapshots:
   '@epic-web/test-server@0.1.0(bufferutil@4.0.9)':
     dependencies:
       '@hono/node-server': 1.12.2(hono@4.5.11)
-      '@hono/node-ws': 1.0.4(@hono/node-server@1.12.2(hono@4.5.11))(bufferutil@4.0.9)
+      '@hono/node-ws': 1.0.4(@hono/node-server@1.12.2(hono@4.11.8))(bufferutil@4.0.9)
       '@open-draft/deferred-promise': 2.2.0
       '@types/ws': 8.5.12
       hono: 4.5.11
@@ -23006,6 +23302,9 @@ snapshots:
   '@esbuild/aix-ppc64@0.23.0':
     optional: true
 
+  '@esbuild/aix-ppc64@0.24.2':
+    optional: true
+
   '@esbuild/aix-ppc64@0.25.1':
     optional: true
 
@@ -23024,6 +23323,9 @@ snapshots:
   '@esbuild/android-arm64@0.23.0':
     optional: true
 
+  '@esbuild/android-arm64@0.24.2':
+    optional: true
+
   '@esbuild/android-arm64@0.25.1':
     optional: true
 
@@ -23045,6 +23347,9 @@ snapshots:
   '@esbuild/android-arm@0.23.0':
     optional: true
 
+  '@esbuild/android-arm@0.24.2':
+    optional: true
+
   '@esbuild/android-arm@0.25.1':
     optional: true
 
@@ -23063,6 +23368,9 @@ snapshots:
   '@esbuild/android-x64@0.23.0':
     optional: true
 
+  '@esbuild/android-x64@0.24.2':
+    optional: true
+
   '@esbuild/android-x64@0.25.1':
     optional: true
 
@@ -23081,6 +23389,9 @@ snapshots:
   '@esbuild/darwin-arm64@0.23.0':
     optional: true
 
+  '@esbuild/darwin-arm64@0.24.2':
+    optional: true
+
   '@esbuild/darwin-arm64@0.25.1':
     optional: true
 
@@ -23099,6 +23410,9 @@ snapshots:
   '@esbuild/darwin-x64@0.23.0':
     optional: true
 
+  '@esbuild/darwin-x64@0.24.2':
+    optional: true
+
   '@esbuild/darwin-x64@0.25.1':
     optional: true
 
@@ -23117,6 +23431,9 @@ snapshots:
   '@esbuild/freebsd-arm64@0.23.0':
     optional: true
 
+  '@esbuild/freebsd-arm64@0.24.2':
+    optional: true
+
   '@esbuild/freebsd-arm64@0.25.1':
     optional: true
 
@@ -23135,6 +23452,9 @@ snapshots:
   '@esbuild/freebsd-x64@0.23.0':
     optional: true
 
+  '@esbuild/freebsd-x64@0.24.2':
+    optional: true
+
   '@esbuild/freebsd-x64@0.25.1':
     optional: true
 
@@ -23153,6 +23473,9 @@ snapshots:
   '@esbuild/linux-arm64@0.23.0':
     optional: true
 
+  '@esbuild/linux-arm64@0.24.2':
+    optional: true
+
   '@esbuild/linux-arm64@0.25.1':
     optional: true
 
@@ -23171,6 +23494,9 @@ snapshots:
   '@esbuild/linux-arm@0.23.0':
     optional: true
 
+  '@esbuild/linux-arm@0.24.2':
+    optional: true
+
   '@esbuild/linux-arm@0.25.1':
     optional: true
 
@@ -23189,6 +23515,9 @@ snapshots:
   '@esbuild/linux-ia32@0.23.0':
     optional: true
 
+  '@esbuild/linux-ia32@0.24.2':
+    optional: true
+
   '@esbuild/linux-ia32@0.25.1':
     optional: true
 
@@ -23210,6 +23539,9 @@ snapshots:
   '@esbuild/linux-loong64@0.23.0':
     optional: true
 
+  '@esbuild/linux-loong64@0.24.2':
+    optional: true
+
   '@esbuild/linux-loong64@0.25.1':
     optional: true
 
@@ -23228,6 +23560,9 @@ snapshots:
   '@esbuild/linux-mips64el@0.23.0':
     optional: true
 
+  '@esbuild/linux-mips64el@0.24.2':
+    optional: true
+
   '@esbuild/linux-mips64el@0.25.1':
     optional: true
 
@@ -23246,6 +23581,9 @@ snapshots:
   '@esbuild/linux-ppc64@0.23.0':
     optional: true
 
+  '@esbuild/linux-ppc64@0.24.2':
+    optional: true
+
   '@esbuild/linux-ppc64@0.25.1':
     optional: true
 
@@ -23264,6 +23602,9 @@ snapshots:
   '@esbuild/linux-riscv64@0.23.0':
     optional: true
 
+  '@esbuild/linux-riscv64@0.24.2':
+    optional: true
+
   '@esbuild/linux-riscv64@0.25.1':
     optional: true
 
@@ -23282,6 +23623,9 @@ snapshots:
   '@esbuild/linux-s390x@0.23.0':
     optional: true
 
+  '@esbuild/linux-s390x@0.24.2':
+    optional: true
+
   '@esbuild/linux-s390x@0.25.1':
     optional: true
 
@@ -23300,9 +23644,15 @@ snapshots:
   '@esbuild/linux-x64@0.23.0':
     optional: true
 
+  '@esbuild/linux-x64@0.24.2':
+    optional: true
+
   '@esbuild/linux-x64@0.25.1':
     optional: true
 
+  '@esbuild/netbsd-arm64@0.24.2':
+    optional: true
+
   '@esbuild/netbsd-arm64@0.25.1':
     optional: true
 
@@ -23321,12 +23671,18 @@ snapshots:
   '@esbuild/netbsd-x64@0.23.0':
     optional: true
 
+  '@esbuild/netbsd-x64@0.24.2':
+    optional: true
+
   '@esbuild/netbsd-x64@0.25.1':
     optional: true
 
   '@esbuild/openbsd-arm64@0.23.0':
     optional: true
 
+  '@esbuild/openbsd-arm64@0.24.2':
+    optional: true
+
   '@esbuild/openbsd-arm64@0.25.1':
     optional: true
 
@@ -23345,6 +23701,9 @@ snapshots:
   '@esbuild/openbsd-x64@0.23.0':
     optional: true
 
+  '@esbuild/openbsd-x64@0.24.2':
+    optional: true
+
   '@esbuild/openbsd-x64@0.25.1':
     optional: true
 
@@ -23363,6 +23722,9 @@ snapshots:
   '@esbuild/sunos-x64@0.23.0':
     optional: true
 
+  '@esbuild/sunos-x64@0.24.2':
+    optional: true
+
   '@esbuild/sunos-x64@0.25.1':
     optional: true
 
@@ -23381,6 +23743,9 @@ snapshots:
   '@esbuild/win32-arm64@0.23.0':
     optional: true
 
+  '@esbuild/win32-arm64@0.24.2':
+    optional: true
+
   '@esbuild/win32-arm64@0.25.1':
     optional: true
 
@@ -23399,6 +23764,9 @@ snapshots:
   '@esbuild/win32-ia32@0.23.0':
     optional: true
 
+  '@esbuild/win32-ia32@0.24.2':
+    optional: true
+
   '@esbuild/win32-ia32@0.25.1':
     optional: true
 
@@ -23417,6 +23785,9 @@ snapshots:
   '@esbuild/win32-x64@0.23.0':
     optional: true
 
+  '@esbuild/win32-x64@0.24.2':
+    optional: true
+
   '@esbuild/win32-x64@0.25.1':
     optional: true
 
@@ -23430,7 +23801,7 @@ snapshots:
   '@eslint/eslintrc@1.4.1':
     dependencies:
       ajv: 6.12.6
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       espree: 9.6.0
       globals: 13.19.0
       ignore: 5.2.4
@@ -23464,7 +23835,7 @@ snapshots:
       ajv-formats: 3.0.1(ajv@8.17.1)
       fast-uri: 3.0.6
 
-  '@fastify/busboy@2.0.0': {}
+  '@fastify/busboy@2.1.1': {}
 
   '@fastify/error@4.2.0': {}
 
@@ -23649,10 +24020,14 @@ snapshots:
     dependencies:
       hono: 4.5.11
 
-  '@hono/node-ws@1.0.4(@hono/node-server@1.12.2(hono@4.5.11))(bufferutil@4.0.9)':
+  '@hono/node-server@1.19.9(hono@4.11.8)':
+    dependencies:
+      hono: 4.11.8
+
+  '@hono/node-ws@1.0.4(@hono/node-server@1.12.2(hono@4.11.8))(bufferutil@4.0.9)':
     dependencies:
       '@hono/node-server': 1.12.2(hono@4.5.11)
-      ws: 8.18.0(bufferutil@4.0.9)
+      ws: 8.18.3(bufferutil@4.0.9)
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -23660,7 +24035,7 @@ snapshots:
   '@humanwhocodes/config-array@0.11.8':
     dependencies:
       '@humanwhocodes/object-schema': 1.2.1
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
@@ -23676,7 +24051,7 @@ snapshots:
       '@antfu/install-pkg': 1.1.0
       '@antfu/utils': 9.3.0
       '@iconify/types': 2.0.0
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       globals: 15.15.0
       kolorist: 1.8.0
       local-pkg: 1.1.2
@@ -23907,11 +24282,6 @@ snapshots:
 
   '@istanbuljs/schema@0.1.3': {}
 
-  '@jridgewell/gen-mapping@0.3.13':
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@jridgewell/trace-mapping': 0.3.31
-
   '@jridgewell/gen-mapping@0.3.2':
     dependencies:
       '@jridgewell/set-array': 1.2.1
@@ -23924,26 +24294,16 @@ snapshots:
       '@jridgewell/sourcemap-codec': 1.5.5
       '@jridgewell/trace-mapping': 0.3.25
 
-  '@jridgewell/remapping@2.3.5':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-
   '@jridgewell/resolve-uri@3.1.0': {}
 
   '@jridgewell/resolve-uri@3.1.2': {}
 
   '@jridgewell/set-array@1.2.1': {}
 
-  '@jridgewell/source-map@0.3.11':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.13
-      '@jridgewell/trace-mapping': 0.3.31
-
   '@jridgewell/source-map@0.3.3':
     dependencies:
       '@jridgewell/gen-mapping': 0.3.8
-      '@jridgewell/trace-mapping': 0.3.25
+      '@jridgewell/trace-mapping': 0.3.31
 
   '@jridgewell/sourcemap-codec@1.5.0': {}
 
@@ -23974,8 +24334,28 @@ snapshots:
     dependencies:
       jsep: 1.4.0
 
+  '@jsonhero/json-infer-types@1.2.11':
+    dependencies:
+      ip-address: 8.1.0
+      json5: 2.2.3
+      jwt-decode: 3.1.2
+      uuid: 8.3.2
+
+  '@jsonhero/json-schema-fns@0.0.1':
+    dependencies:
+      deepmerge: 4.3.1
+      lodash.omit: 4.5.0
+      ts-pattern: 3.3.5
+
   '@jsonhero/path@1.0.21': {}
 
+  '@jsonhero/schema-infer@0.1.5':
+    dependencies:
+      '@jsonhero/json-infer-types': 1.2.11
+      '@jsonhero/json-schema-fns': 0.0.1
+      lodash.omit: 4.5.0
+      ts-pattern: 3.3.5
+
   '@jspm/core@2.0.1': {}
 
   '@kapaai/react-sdk@0.1.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -23991,7 +24371,7 @@ snapshots:
   '@kubernetes/client-node@0.20.0(bufferutil@4.0.9)':
     dependencies:
       '@types/js-yaml': 4.0.9
-      '@types/node': 20.11.22
+      '@types/node': 20.14.14
       '@types/request': 2.48.12
       '@types/ws': 8.5.10
       byline: 5.0.0
@@ -24013,7 +24393,7 @@ snapshots:
   '@kubernetes/client-node@1.0.0(patch_hash=ba1a06f46256cdb8d6faf7167246692c0de2e7cd846a9dc0f13be0137e1c3745)(bufferutil@4.0.9)(encoding@0.1.13)':
     dependencies:
       '@types/js-yaml': 4.0.9
-      '@types/node': 22.13.9
+      '@types/node': 20.14.14
       '@types/node-fetch': 2.6.12
       '@types/stream-buffers': 3.0.7
       '@types/tar': 6.1.4
@@ -24049,17 +24429,13 @@ snapshots:
 
   '@lezer/javascript@1.4.1':
     dependencies:
-      '@lezer/highlight': 1.1.6
-      '@lezer/lr': 1.3.0
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.3
 
   '@lezer/json@1.0.0':
     dependencies:
-      '@lezer/highlight': 1.1.6
-      '@lezer/lr': 1.3.0
-
-  '@lezer/lr@1.3.0':
-    dependencies:
-      '@lezer/common': 1.0.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.3
 
   '@lezer/lr@1.4.3':
     dependencies:
@@ -24086,8 +24462,8 @@ snapshots:
 
   '@manypkg/find-root@1.1.0':
     dependencies:
-      '@babel/runtime': 7.27.4
-      '@types/node': 12.20.55
+      '@babel/runtime': 7.28.4
+      '@types/node': 20.14.14
       find-up: 4.1.0
       fs-extra: 8.1.0
 
@@ -24100,8 +24476,6 @@ snapshots:
       globby: 11.1.0
       read-yaml-file: 1.1.0
 
-  '@marijn/find-cluster-break@1.0.2': {}
-
   '@mdx-js/mdx@2.3.0':
     dependencies:
       '@types/estree-jsx': 1.0.0
@@ -24130,8 +24504,9 @@ snapshots:
 
   '@microsoft/fetch-event-source@2.0.1': {}
 
-  '@modelcontextprotocol/sdk@1.24.2(supports-color@10.0.0)(zod@3.25.76)':
+  '@modelcontextprotocol/sdk@1.25.2(hono@4.11.8)(supports-color@10.0.0)(zod@3.25.76)':
     dependencies:
+      '@hono/node-server': 1.19.9(hono@4.11.8)
       ajv: 8.17.1
       ajv-formats: 3.0.1(ajv@8.17.1)
       content-type: 1.0.5
@@ -24142,10 +24517,34 @@ snapshots:
       express: 5.0.1(supports-color@10.0.0)
       express-rate-limit: 7.5.0(express@5.0.1(supports-color@10.0.0))
       jose: 6.1.3
+      json-schema-typed: 8.0.2
       pkce-challenge: 5.0.0
       raw-body: 3.0.0
       zod: 3.25.76
       zod-to-json-schema: 3.25.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - hono
+      - supports-color
+
+  '@modelcontextprotocol/sdk@1.26.0(zod@3.25.76)':
+    dependencies:
+      '@hono/node-server': 1.19.9(hono@4.11.8)
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      content-type: 1.0.5
+      cors: 2.8.5
+      cross-spawn: 7.0.6
+      eventsource: 3.0.5
+      eventsource-parser: 3.0.6
+      express: 5.2.1
+      express-rate-limit: 8.2.1(express@5.2.1)
+      hono: 4.11.8
+      jose: 6.1.3
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.0
+      raw-body: 3.0.0
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.1(zod@3.25.76)
     transitivePeerDependencies:
       - supports-color
 
@@ -24339,7 +24738,7 @@ snapshots:
       json-parse-even-better-errors: 3.0.0
       normalize-package-data: 5.0.0
       proc-log: 3.0.0
-      semver: 7.7.2
+      semver: 7.7.3
     transitivePeerDependencies:
       - bluebird
 
@@ -24678,10 +25077,10 @@ snapshots:
       '@opentelemetry/sdk-trace-base': 2.0.1(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions': 1.36.0
 
-  '@opentelemetry/host-metrics@0.36.0(@opentelemetry/api@1.9.0)':
+  '@opentelemetry/host-metrics@0.37.0(@opentelemetry/api@1.9.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
-      systeminformation: 5.23.8
+      systeminformation: 5.27.14
 
   '@opentelemetry/instrumentation-amqplib@0.46.1(@opentelemetry/api@1.9.0)':
     dependencies:
@@ -24937,7 +25336,7 @@ snapshots:
       '@types/shimmer': 1.2.0
       import-in-the-middle: 1.11.0
       require-in-the-middle: 7.1.1(supports-color@10.0.0)
-      semver: 7.7.2
+      semver: 7.7.3
       shimmer: 1.2.1
     transitivePeerDependencies:
       - supports-color
@@ -24949,7 +25348,7 @@ snapshots:
       '@types/shimmer': 1.2.0
       import-in-the-middle: 1.11.0
       require-in-the-middle: 7.1.1(supports-color@10.0.0)
-      semver: 7.7.2
+      semver: 7.7.3
       shimmer: 1.2.1
     transitivePeerDependencies:
       - supports-color
@@ -25168,7 +25567,7 @@ snapshots:
   '@prisma/adapter-pg@6.16.0':
     dependencies:
       '@prisma/driver-adapter-utils': 6.16.0
-      pg: 8.15.6
+      pg: 8.16.3
       postgres-array: 3.0.4
     transitivePeerDependencies:
       - pg-native
@@ -25183,33 +25582,33 @@ snapshots:
 
   '@prisma/client-runtime-utils@6.20.0-integration-next.8': {}
 
-  '@prisma/client@4.9.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))':
+  '@prisma/client@4.9.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))':
     dependencies:
       '@prisma/engines-version': 4.9.0-42.ceb5c99003b99c9ee2c1d2e618e359c14aef2ea5
     optionalDependencies:
-      prisma: 6.14.0(magicast@0.3.5)(typescript@5.9.3)
+      prisma: 6.14.0(magicast@0.3.5)(typescript@5.5.4)
 
-  '@prisma/client@6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)':
+  '@prisma/client@6.14.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)':
     optionalDependencies:
-      prisma: 6.14.0(magicast@0.3.5)(typescript@5.9.3)
-      typescript: 5.9.3
+      prisma: 6.14.0(magicast@0.3.5)(typescript@5.5.4)
+      typescript: 5.5.4
 
-  '@prisma/client@6.16.0(prisma@6.16.0(magicast@0.3.5)(typescript@5.9.3))(typescript@5.9.3)':
+  '@prisma/client@6.16.0(prisma@6.16.0(magicast@0.3.5)(typescript@5.5.4))(typescript@5.5.4)':
     optionalDependencies:
-      prisma: 6.16.0(magicast@0.3.5)(typescript@5.9.3)
-      typescript: 5.9.3
+      prisma: 6.16.0(magicast@0.3.5)(typescript@5.5.4)
+      typescript: 5.5.4
 
-  '@prisma/client@6.19.0(prisma@6.19.0(typescript@5.9.3))(typescript@5.9.3)':
+  '@prisma/client@6.19.0(prisma@6.19.0(typescript@5.5.4))(typescript@5.5.4)':
     optionalDependencies:
-      prisma: 6.19.0(typescript@5.9.3)
-      typescript: 5.9.3
+      prisma: 6.19.0(typescript@5.5.4)
+      typescript: 5.5.4
 
-  '@prisma/client@6.20.0-integration-next.8(prisma@6.20.0-integration-next.8(@types/react@19.0.12)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.9.3))(typescript@5.9.3)':
+  '@prisma/client@6.20.0-integration-next.8(prisma@6.20.0-integration-next.8(@types/react@19.2.14)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.5.4))(typescript@5.5.4)':
     dependencies:
       '@prisma/client-runtime-utils': 6.20.0-integration-next.8
     optionalDependencies:
-      prisma: 6.20.0-integration-next.8(@types/react@19.0.12)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.9.3)
-      typescript: 5.9.3
+      prisma: 6.20.0-integration-next.8(@types/react@19.2.14)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.5.4)
+      typescript: 5.5.4
 
   '@prisma/config@6.14.0(magicast@0.3.5)':
     dependencies:
@@ -25372,9 +25771,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@prisma/studio-core-licensed@0.6.0(@types/react@19.0.12)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)':
+  '@prisma/studio-core-licensed@0.6.0(@types/react@19.2.14)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)':
     dependencies:
-      '@types/react': 19.0.12
+      '@types/react': 19.2.14
       react: 19.1.0
       react-dom: 19.1.0(react@19.1.0)
 
@@ -25405,7 +25804,7 @@ snapshots:
 
   '@puppeteer/browsers@2.10.6':
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       extract-zip: 2.0.1
       progress: 2.0.3
       proxy-agent: 6.5.0
@@ -25475,19 +25874,19 @@ snapshots:
 
   '@radix-ui/react-arrow@1.0.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-primitive': 1.0.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
 
-  '@radix-ui/react-arrow@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-arrow@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-avatar@1.1.3(@types/react-dom@19.0.4(@types/react@19.0.12))(@types/react@19.0.12)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)':
@@ -25502,21 +25901,21 @@ snapshots:
       '@types/react': 19.0.12
       '@types/react-dom': 19.0.4(@types/react@19.0.12)
 
-  '@radix-ui/react-collapsible@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-collapsible@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-id': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-id': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-collapsible@1.1.11(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -25568,17 +25967,17 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-collection@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-collection@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-slot': 1.0.2(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-collection@1.1.7(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -25671,6 +26070,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-context@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.26.7
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-context@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
@@ -25781,12 +26187,12 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
-  '@radix-ui/react-direction@1.0.1(@types/react@18.3.1)(react@18.3.1)':
+  '@radix-ui/react-direction@1.0.1(@types/react@18.2.69)(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
       react: 18.3.1
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
 
   '@radix-ui/react-direction@1.1.0(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
@@ -25813,7 +26219,7 @@ snapshots:
 
   '@radix-ui/react-dismissable-layer@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
       '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.2.0)
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
@@ -25825,9 +26231,23 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
+  '@radix-ui/react-dismissable-layer@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@radix-ui/primitive': 1.0.1
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-escape-keydown': 1.0.3(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.2.0(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.2.69
+      '@types/react-dom': 18.2.7
+
   '@radix-ui/react-dismissable-layer@1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
       '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
@@ -25839,18 +26259,18 @@ snapshots:
       '@types/react': 18.3.1
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-dismissable-layer@1.0.5(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-dismissable-layer@1.0.5(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-escape-keydown': 1.0.3(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-escape-keydown': 1.0.3(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-focus-guards@1.0.0(react@18.2.0)':
@@ -25860,14 +26280,21 @@ snapshots:
 
   '@radix-ui/react-focus-guards@1.0.1(@types/react@18.2.69)(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       react: 18.2.0
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-focus-guards@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-focus-guards@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       react: 18.3.1
     optionalDependencies:
       '@types/react': 18.3.1
@@ -25883,7 +26310,7 @@ snapshots:
 
   '@radix-ui/react-focus-scope@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.2.0)
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.2.0)
@@ -25895,7 +26322,7 @@ snapshots:
 
   '@radix-ui/react-focus-scope@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
@@ -25905,16 +26332,16 @@ snapshots:
       '@types/react': 18.3.1
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-focus-scope@1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-focus-scope@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-icons@1.3.0(react@18.3.1)':
@@ -25935,15 +26362,23 @@ snapshots:
 
   '@radix-ui/react-id@1.0.1(@types/react@18.2.69)(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.2.0)
       react: 18.2.0
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-id@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-id@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
       react: 18.3.1
     optionalDependencies:
@@ -25986,28 +26421,28 @@ snapshots:
     transitivePeerDependencies:
       - '@types/react'
 
-  '@radix-ui/react-popover@1.0.7(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-popover@1.0.7(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-dismissable-layer': 1.0.5(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-focus-guards': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-focus-scope': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-id': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-popper': 1.1.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-portal': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-slot': 1.0.2(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-dismissable-layer': 1.0.5(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-focus-guards': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-focus-scope': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-id': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-popper': 1.1.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-portal': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       aria-hidden: 1.2.4
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
-      react-remove-scroll: 2.5.5(@types/react@18.3.1)(react@18.3.1)
+      react-remove-scroll: 2.5.5(@types/react@18.2.69)(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-popper@1.1.1(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -26028,42 +26463,42 @@ snapshots:
     transitivePeerDependencies:
       - '@types/react'
 
-  '@radix-ui/react-popper@1.1.2(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-popper@1.1.2(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@floating-ui/react-dom': 2.0.9(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-arrow': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-rect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-size': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-arrow': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-rect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-size': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       '@radix-ui/rect': 1.0.1
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-popper@1.1.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-popper@1.1.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@floating-ui/react-dom': 2.0.9(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-arrow': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-rect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-size': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-arrow': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-rect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-size': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       '@radix-ui/rect': 1.0.1
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-portal@1.0.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -26075,7 +26510,7 @@ snapshots:
 
   '@radix-ui/react-portal@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
@@ -26083,9 +26518,19 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
+  '@radix-ui/react-portal@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.2.0(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.2.69
+      '@types/react-dom': 18.2.7
+
   '@radix-ui/react-portal@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
@@ -26093,14 +26538,14 @@ snapshots:
       '@types/react': 18.3.1
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-portal@1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-portal@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-portal@1.1.9(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -26140,6 +26585,17 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
+  '@radix-ui/react-presence@1.0.1(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.26.7
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.2.0(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.2.69
+      '@types/react-dom': 18.2.7
+
   '@radix-ui/react-presence@1.0.1(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
@@ -26195,6 +26651,16 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
+  '@radix-ui/react-primitive@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.26.7
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.2.0(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.2.69
+      '@types/react-dom': 18.2.7
+
   '@radix-ui/react-primitive@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
@@ -26318,22 +26784,22 @@ snapshots:
       '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-roving-focus@1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-roving-focus@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-collection': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-direction': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-id': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-collection': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-direction': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-id': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-scroll-area@1.2.0(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
@@ -26510,32 +26976,32 @@ snapshots:
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
 
-  '@radix-ui/react-toggle-group@1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-toggle-group@1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-direction': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-roving-focus': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-toggle': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-direction': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-roving-focus': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-toggle': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
-  '@radix-ui/react-toggle@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-toggle@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-tooltip@1.0.5(@types/react@18.2.69)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
@@ -26558,25 +27024,25 @@ snapshots:
     transitivePeerDependencies:
       - '@types/react'
 
-  '@radix-ui/react-tooltip@1.0.6(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-tooltip@1.0.6(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/primitive': 1.0.1
-      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-context': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-dismissable-layer': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-id': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-popper': 1.1.2(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-portal': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-slot': 1.0.2(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-visually-hidden': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-context': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-dismissable-layer': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-id': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-popper': 1.1.2(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-portal': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-presence': 1.0.1(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-visually-hidden': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/react-use-callback-ref@1.0.0(react@18.2.0)':
@@ -26591,14 +27057,21 @@ snapshots:
 
   '@radix-ui/react-use-callback-ref@1.0.1(@types/react@18.2.69)(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       react: 18.2.0
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-use-callback-ref@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-use-callback-ref@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       react: 18.3.1
     optionalDependencies:
       '@types/react': 18.3.1
@@ -26635,6 +27108,14 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-use-controllable-state@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.27.4
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-use-controllable-state@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.27.4
@@ -26660,21 +27141,29 @@ snapshots:
 
   '@radix-ui/react-use-escape-keydown@1.0.2(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-callback-ref': 1.0.0(react@18.2.0)
       react: 18.2.0
 
   '@radix-ui/react-use-escape-keydown@1.0.3(@types/react@18.2.69)(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.2.0)
       react: 18.2.0
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-use-escape-keydown@1.0.3(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.2.69)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-use-escape-keydown@1.0.3(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-callback-ref': 1.0.1(@types/react@18.3.1)(react@18.3.1)
       react: 18.3.1
     optionalDependencies:
@@ -26697,6 +27186,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  '@radix-ui/react-use-layout-effect@1.0.1(@types/react@18.2.69)(react@18.3.1)':
+    dependencies:
+      '@babel/runtime': 7.27.4
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   '@radix-ui/react-use-layout-effect@1.0.1(@types/react@18.3.1)(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.27.4
@@ -26736,21 +27232,21 @@ snapshots:
 
   '@radix-ui/react-use-rect@1.0.0(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/rect': 1.0.0
       react: 18.2.0
 
-  '@radix-ui/react-use-rect@1.0.1(@types/react@18.3.1)(react@18.3.1)':
+  '@radix-ui/react-use-rect@1.0.1(@types/react@18.2.69)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/rect': 1.0.1
       react: 18.3.1
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
 
   '@radix-ui/react-use-size@1.0.0(react@18.2.0)':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       '@radix-ui/react-use-layout-effect': 1.0.0(react@18.2.0)
       react: 18.2.0
 
@@ -26762,13 +27258,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
-  '@radix-ui/react-use-size@1.0.1(@types/react@18.3.1)(react@18.3.1)':
+  '@radix-ui/react-use-size@1.0.1(@types/react@18.2.69)(react@18.3.1)':
     dependencies:
       '@babel/runtime': 7.26.7
-      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.0.1(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
 
   '@radix-ui/react-visually-hidden@1.0.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
@@ -26777,23 +27273,23 @@ snapshots:
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
 
-  '@radix-ui/react-visually-hidden@1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
+  '@radix-ui/react-visually-hidden@1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.27.4
-      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@babel/runtime': 7.28.4
+      '@radix-ui/react-primitive': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       react: 18.3.1
       react-dom: 18.2.0(react@18.3.1)
     optionalDependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
 
   '@radix-ui/rect@1.0.0':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   '@radix-ui/rect@1.0.1':
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   '@react-aria/breadcrumbs@3.5.16(react@18.2.0)':
     dependencies:
@@ -27854,7 +28350,7 @@ snapshots:
     transitivePeerDependencies:
       - '@types/react'
 
-  '@react-email/components@0.0.17(@types/react@18.3.1)(react@18.3.1)':
+  '@react-email/components@0.0.17(@types/react@18.2.69)(react@18.3.1)':
     dependencies:
       '@react-email/body': 0.0.8(react@18.3.1)
       '@react-email/button': 0.0.15(react@18.3.1)
@@ -27864,7 +28360,7 @@ snapshots:
       '@react-email/container': 0.0.12(react@18.3.1)
       '@react-email/font': 0.0.6(react@18.3.1)
       '@react-email/head': 0.0.8(react@18.3.1)
-      '@react-email/heading': 0.0.12(@types/react@18.3.1)(react@18.3.1)
+      '@react-email/heading': 0.0.12(@types/react@18.2.69)(react@18.3.1)
       '@react-email/hr': 0.0.8(react@18.3.1)
       '@react-email/html': 0.0.8(react@18.3.1)
       '@react-email/img': 0.0.8(react@18.3.1)
@@ -27911,9 +28407,9 @@ snapshots:
     transitivePeerDependencies:
       - '@types/react'
 
-  '@react-email/heading@0.0.12(@types/react@18.3.1)(react@18.3.1)':
+  '@react-email/heading@0.0.12(@types/react@18.2.69)(react@18.3.1)':
     dependencies:
-      '@radix-ui/react-slot': 1.0.2(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
       react: 18.3.1
     transitivePeerDependencies:
       - '@types/react'
@@ -28704,7 +29200,7 @@ snapshots:
     transitivePeerDependencies:
       - encoding
 
-  '@remix-run/dev@2.1.0(@remix-run/serve@2.1.0(typescript@5.9.3))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.9.3)':
+  '@remix-run/dev@2.1.0(@remix-run/serve@2.1.0(typescript@5.5.4))(@types/node@20.14.14)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.5.4)':
     dependencies:
       '@babel/core': 7.22.17
       '@babel/generator': 7.24.7
@@ -28715,9 +29211,9 @@ snapshots:
       '@babel/traverse': 7.24.7
       '@mdx-js/mdx': 2.3.0
       '@npmcli/package-json': 4.0.1
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       '@types/mdx': 2.0.5
-      '@vanilla-extract/integration': 6.2.1(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1)
+      '@vanilla-extract/integration': 6.2.1(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
       arg: 5.0.2
       cacache: 17.1.4
       chalk: 4.1.2
@@ -28733,7 +29229,7 @@ snapshots:
       gunzip-maybe: 1.4.2
       jsesc: 3.0.2
       json5: 2.2.3
-      lodash: 4.17.21
+      lodash: 4.17.23
       lodash.debounce: 4.0.8
       minimatch: 9.0.5
       node-fetch: 2.6.12(encoding@0.1.13)
@@ -28755,8 +29251,8 @@ snapshots:
       tsconfig-paths: 4.2.0
       ws: 7.5.9(bufferutil@4.0.9)
     optionalDependencies:
-      '@remix-run/serve': 2.1.0(typescript@5.9.3)
-      typescript: 5.9.3
+      '@remix-run/serve': 2.1.0(typescript@5.5.4)
+      typescript: 5.5.4
     transitivePeerDependencies:
       - '@types/node'
       - bluebird
@@ -28772,43 +29268,43 @@ snapshots:
       - ts-node
       - utf-8-validate
 
-  '@remix-run/eslint-config@2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.9.3)':
+  '@remix-run/eslint-config@2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.5.4)':
     dependencies:
       '@babel/core': 7.22.17
       '@babel/eslint-parser': 7.21.8(@babel/core@7.22.17)(eslint@8.31.0)
       '@babel/preset-react': 7.18.6(@babel/core@7.22.17)
       '@rushstack/eslint-patch': 1.2.0
-      '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)
-      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)
+      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       eslint: 8.31.0
       eslint-import-resolver-node: 0.3.7
-      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
-      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
-      eslint-plugin-jest: 26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)
+      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
+      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
+      eslint-plugin-jest: 26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)
       eslint-plugin-jest-dom: 4.0.3(eslint@8.31.0)
       eslint-plugin-jsx-a11y: 6.7.1(eslint@8.31.0)
       eslint-plugin-node: 11.1.0(eslint@8.31.0)
       eslint-plugin-react: 7.32.2(eslint@8.31.0)
       eslint-plugin-react-hooks: 4.6.2(eslint@8.31.0)
-      eslint-plugin-testing-library: 5.11.0(eslint@8.31.0)(typescript@5.9.3)
+      eslint-plugin-testing-library: 5.11.0(eslint@8.31.0)(typescript@5.5.4)
       react: 18.2.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - eslint-import-resolver-webpack
       - jest
       - supports-color
 
-  '@remix-run/express@2.1.0(express@4.20.0)(typescript@5.9.3)':
+  '@remix-run/express@2.1.0(express@4.20.0)(typescript@5.5.4)':
     dependencies:
-      '@remix-run/node': 2.1.0(typescript@5.9.3)
+      '@remix-run/node': 2.1.0(typescript@5.5.4)
       express: 4.20.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
-  '@remix-run/node@2.1.0(typescript@5.9.3)':
+  '@remix-run/node@2.1.0(typescript@5.5.4)':
     dependencies:
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       '@remix-run/web-fetch': 4.4.1
       '@remix-run/web-file': 3.1.0
       '@remix-run/web-stream': 1.1.0
@@ -28817,26 +29313,26 @@ snapshots:
       source-map-support: 0.5.21
       stream-slice: 0.1.2
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
-  '@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)':
+  '@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)':
     dependencies:
       '@remix-run/router': 1.10.0
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
       react-router-dom: 6.17.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   '@remix-run/router@1.10.0': {}
 
   '@remix-run/router@1.15.3': {}
 
-  '@remix-run/serve@2.1.0(typescript@5.9.3)':
+  '@remix-run/serve@2.1.0(typescript@5.5.4)':
     dependencies:
-      '@remix-run/express': 2.1.0(express@4.20.0)(typescript@5.9.3)
-      '@remix-run/node': 2.1.0(typescript@5.9.3)
+      '@remix-run/express': 2.1.0(express@4.20.0)(typescript@5.5.4)
+      '@remix-run/node': 2.1.0(typescript@5.5.4)
       chokidar: 3.6.0
       compression: 1.7.4
       express: 4.20.0
@@ -28847,7 +29343,7 @@ snapshots:
       - supports-color
       - typescript
 
-  '@remix-run/server-runtime@2.1.0(typescript@5.9.3)':
+  '@remix-run/server-runtime@2.1.0(typescript@5.5.4)':
     dependencies:
       '@remix-run/router': 1.10.0
       '@types/cookie': 0.4.1
@@ -28856,24 +29352,24 @@ snapshots:
       set-cookie-parser: 2.6.0
       source-map: 0.7.4
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
-  '@remix-run/testing@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)':
+  '@remix-run/testing@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)':
     dependencies:
-      '@remix-run/node': 2.1.0(typescript@5.9.3)
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
+      '@remix-run/node': 2.1.0(typescript@5.5.4)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
       '@remix-run/router': 1.10.0
       react: 18.2.0
       react-router-dom: 6.17.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - react-dom
 
-  '@remix-run/v1-meta@0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))':
+  '@remix-run/v1-meta@0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))':
     dependencies:
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
 
   '@remix-run/web-blob@3.1.0':
     dependencies:
@@ -28968,14 +29464,12 @@ snapshots:
 
   '@rushstack/eslint-patch@1.2.0': {}
 
-  '@s2-dev/streamstore@0.17.3(typescript@5.9.3)':
-    dependencies:
-      '@protobuf-ts/runtime': 2.11.1
-      typescript: 5.9.3
-
-  '@s2-dev/streamstore@0.17.6':
+  '@s2-dev/streamstore@0.22.5(supports-color@10.0.0)':
     dependencies:
       '@protobuf-ts/runtime': 2.11.1
+      debug: 4.4.3(supports-color@10.0.0)
+    transitivePeerDependencies:
+      - supports-color
 
   '@sec-ant/readable-stream@0.4.1': {}
 
@@ -29125,15 +29619,15 @@ snapshots:
       hoist-non-react-statics: 3.3.2
       react: 18.2.0
 
-  '@sentry/remix@9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(encoding@0.1.13)(react@18.2.0)':
+  '@sentry/remix@9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(encoding@0.1.13)(react@18.2.0)':
     dependencies:
       '@opentelemetry/api': 1.9.0
       '@opentelemetry/instrumentation': 0.57.2(@opentelemetry/api@1.9.0)
       '@opentelemetry/semantic-conventions': 1.36.0
-      '@remix-run/node': 2.1.0(typescript@5.9.3)
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
+      '@remix-run/node': 2.1.0(typescript@5.5.4)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
       '@remix-run/router': 1.15.3
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       '@sentry/cli': 2.50.2(encoding@0.1.13)
       '@sentry/core': 9.46.0
       '@sentry/node': 9.46.0
@@ -29192,6 +29686,8 @@ snapshots:
 
   '@sindresorhus/is@4.6.0': {}
 
+  '@sindresorhus/merge-streams@4.0.0': {}
+
   '@slack/logger@4.0.0':
     dependencies:
       '@types/node': 20.14.14
@@ -30133,31 +30629,16 @@ snapshots:
 
   '@sodaru/yup-to-json-schema@2.0.1': {}
 
-  '@splinetool/react-spline@2.2.6(@splinetool/runtime@1.11.2)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
-    dependencies:
-      '@splinetool/runtime': 1.11.2
-      lodash.debounce: 4.0.8
-      react: 18.2.0
-      react-dom: 18.2.0(react@18.2.0)
-      react-merge-refs: 2.1.1
-
-  '@splinetool/runtime@1.11.2':
-    dependencies:
-      on-change: 4.0.2
-      semver-compare: 1.0.0
-
   '@standard-schema/spec@1.0.0': {}
 
+  '@standard-schema/spec@1.1.0': {}
+
   '@stricli/auto-complete@1.2.0':
     dependencies:
       '@stricli/core': 1.2.0
 
   '@stricli/core@1.2.0': {}
 
-  '@sveltejs/acorn-typescript@1.0.6(acorn@8.15.0)':
-    dependencies:
-      acorn: 8.15.0
-
   '@swc/core-darwin-arm64@1.3.101':
     optional: true
 
@@ -30275,13 +30756,12 @@ snapshots:
     dependencies:
       defer-to-connect: 1.1.3
 
-  '@tabler/icons-react@2.47.0(react@18.2.0)':
+  '@tabler/icons-react@3.36.1(react@18.2.0)':
     dependencies:
-      '@tabler/icons': 2.47.0
-      prop-types: 15.8.1
+      '@tabler/icons': 3.36.1
       react: 18.2.0
 
-  '@tabler/icons@2.47.0': {}
+  '@tabler/icons@3.36.1': {}
 
   '@tailwindcss/container-queries@0.1.1(tailwindcss@3.4.1)':
     dependencies:
@@ -30351,7 +30831,7 @@ snapshots:
       '@tailwindcss/node': 4.0.17
       '@tailwindcss/oxide': 4.0.17
       lightningcss: 1.29.2
-      postcss: 8.5.3
+      postcss: 8.5.6
       tailwindcss: 4.0.17
 
   '@tailwindcss/typography@0.5.9(tailwindcss@3.4.1)':
@@ -30370,6 +30850,10 @@ snapshots:
       postcss-selector-parser: 6.0.10
       tailwindcss: 4.0.17
 
+  '@tanstack/match-sorter-utils@8.19.4':
+    dependencies:
+      remove-accents: 0.5.0
+
   '@tanstack/query-core@5.76.0': {}
 
   '@tanstack/react-query@5.76.1(react@18.2.0)':
@@ -30377,12 +30861,20 @@ snapshots:
       '@tanstack/query-core': 5.76.0
       react: 18.2.0
 
+  '@tanstack/react-table@8.21.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
+    dependencies:
+      '@tanstack/table-core': 8.21.3
+      react: 18.2.0
+      react-dom: 18.2.0(react@18.2.0)
+
   '@tanstack/react-virtual@3.0.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
       '@tanstack/virtual-core': 3.0.0
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
 
+  '@tanstack/table-core@8.21.3': {}
+
   '@tanstack/virtual-core@3.0.0': {}
 
   '@team-plain/typescript-sdk@3.5.0':
@@ -30410,7 +30902,7 @@ snapshots:
   '@testing-library/dom@8.19.1':
     dependencies:
       '@babel/code-frame': 7.22.13
-      '@babel/runtime': 7.27.0
+      '@babel/runtime': 7.28.4
       '@types/aria-query': 5.0.1
       aria-query: 5.3.0
       chalk: 4.1.2
@@ -30425,7 +30917,7 @@ snapshots:
       chalk: 3.0.0
       css.escape: 1.5.1
       dom-accessibility-api: 0.6.3
-      lodash: 4.17.21
+      lodash: 4.17.23
       redent: 3.0.0
 
   '@tokenizer/token@0.3.0': {}
@@ -30439,7 +30931,7 @@ snapshots:
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
 
-  '@trigger.dev/platform@1.0.21':
+  '@trigger.dev/platform@1.0.27':
     dependencies:
       zod: 3.23.8
 
@@ -30664,14 +31156,12 @@ snapshots:
 
   '@types/estree-jsx@1.0.0':
     dependencies:
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
 
   '@types/estree@1.0.0': {}
 
   '@types/estree@1.0.6': {}
 
-  '@types/estree@1.0.7': {}
-
   '@types/estree@1.0.8': {}
 
   '@types/eventsource@1.1.15': {}
@@ -30772,7 +31262,7 @@ snapshots:
 
   '@types/morgan@1.9.4':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
 
   '@types/ms@0.7.31': {}
 
@@ -30787,7 +31277,7 @@ snapshots:
 
   '@types/node-fetch@2.6.2':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       form-data: 3.0.4
 
   '@types/node-fetch@2.6.4':
@@ -30795,28 +31285,10 @@ snapshots:
       '@types/node': 20.14.14
       form-data: 3.0.4
 
-  '@types/node@12.20.55': {}
-
-  '@types/node@18.19.20':
-    dependencies:
-      undici-types: 5.26.5
-
-  '@types/node@20.11.22':
-    dependencies:
-      undici-types: 5.26.5
-
-  '@types/node@20.12.14':
-    dependencies:
-      undici-types: 5.26.5
-
   '@types/node@20.14.14':
     dependencies:
       undici-types: 5.26.5
 
-  '@types/node@22.13.9':
-    dependencies:
-      undici-types: 6.20.0
-
   '@types/nodemailer@7.0.4':
     dependencies:
       '@aws-sdk/client-sesv2': 3.940.0
@@ -30841,7 +31313,7 @@ snapshots:
   '@types/pg@8.11.6':
     dependencies:
       '@types/node': 20.14.14
-      pg-protocol: 1.6.1
+      pg-protocol: 1.10.3
       pg-types: 4.0.2
 
   '@types/pg@8.6.1':
@@ -30852,7 +31324,7 @@ snapshots:
 
   '@types/pg@8.6.6':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       pg-protocol: 1.6.1
       pg-types: 2.2.0
 
@@ -30877,7 +31349,7 @@ snapshots:
 
   '@types/react-dom@18.2.7':
     dependencies:
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
 
   '@types/react-dom@19.0.4(@types/react@19.0.12)':
     dependencies:
@@ -30902,11 +31374,15 @@ snapshots:
 
   '@types/react@19.0.12':
     dependencies:
-      csstype: 3.1.3
+      csstype: 3.2.0
+
+  '@types/react@19.2.14':
+    dependencies:
+      csstype: 3.2.3
 
   '@types/readable-stream@4.0.14':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       safe-buffer: 5.1.2
 
   '@types/regression@2.0.6': {}
@@ -30966,7 +31442,7 @@ snapshots:
 
   '@types/ssh2@1.15.1':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
 
   '@types/stream-buffers@3.0.7':
     dependencies:
@@ -30986,7 +31462,7 @@ snapshots:
 
   '@types/tar@6.1.4':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       minipass: 4.0.0
 
   '@types/tedious@4.0.14':
@@ -31031,41 +31507,41 @@ snapshots:
 
   '@types/ws@8.5.4':
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
 
   '@types/yauzl@2.10.3':
     dependencies:
       '@types/node': 20.14.14
     optional: true
 
-  '@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)':
     dependencies:
       '@eslint-community/regexpp': 4.5.1
-      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       '@typescript-eslint/scope-manager': 5.59.6
-      '@typescript-eslint/type-utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
-      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/type-utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
+      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       debug: 4.3.4
       eslint: 8.31.0
       grapheme-splitter: 1.0.4
       ignore: 5.2.4
       natural-compare-lite: 1.4.0
       semver: 7.6.3
-      tsutils: 3.21.0(typescript@5.9.3)
+      tsutils: 3.21.0(typescript@5.5.4)
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3)':
+  '@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4)':
     dependencies:
       '@typescript-eslint/scope-manager': 5.59.6
       '@typescript-eslint/types': 5.59.6
-      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4)
       debug: 4.4.0
       eslint: 8.31.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - supports-color
 
@@ -31074,45 +31550,45 @@ snapshots:
       '@typescript-eslint/types': 5.59.6
       '@typescript-eslint/visitor-keys': 5.59.6
 
-  '@typescript-eslint/type-utils@5.59.6(eslint@8.31.0)(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@5.59.6(eslint@8.31.0)(typescript@5.5.4)':
     dependencies:
-      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3)
-      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
-      debug: 4.4.1(supports-color@10.0.0)
+      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4)
+      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
+      debug: 4.4.3(supports-color@10.0.0)
       eslint: 8.31.0
-      tsutils: 3.21.0(typescript@5.9.3)
+      tsutils: 3.21.0(typescript@5.5.4)
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - supports-color
 
   '@typescript-eslint/types@5.59.6': {}
 
-  '@typescript-eslint/typescript-estree@5.59.6(typescript@5.9.3)':
+  '@typescript-eslint/typescript-estree@5.59.6(typescript@5.5.4)':
     dependencies:
       '@typescript-eslint/types': 5.59.6
       '@typescript-eslint/visitor-keys': 5.59.6
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       globby: 11.1.0
       is-glob: 4.0.3
-      semver: 7.7.2
-      tsutils: 3.21.0(typescript@5.9.3)
+      semver: 7.7.3
+      tsutils: 3.21.0(typescript@5.5.4)
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@5.59.6(eslint@8.31.0)(typescript@5.9.3)':
+  '@typescript-eslint/utils@5.59.6(eslint@8.31.0)(typescript@5.5.4)':
     dependencies:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.31.0)
       '@types/json-schema': 7.0.13
       '@types/semver': 7.5.1
       '@typescript-eslint/scope-manager': 5.59.6
       '@typescript-eslint/types': 5.59.6
-      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4)
       eslint: 8.31.0
       eslint-scope: 5.1.1
-      semver: 7.7.2
+      semver: 7.7.3
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -31132,7 +31608,7 @@ snapshots:
       '@codemirror/state': 6.2.0
       '@codemirror/view': 6.7.2
 
-  '@uiw/react-codemirror@4.19.5(@babel/runtime@7.28.4)(@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0))(@codemirror/language@6.3.2)(@codemirror/lint@6.4.2)(@codemirror/search@6.2.3)(@codemirror/state@6.2.0)(@codemirror/theme-one-dark@6.1.3)(@codemirror/view@6.7.2)(codemirror@6.0.2)(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
+  '@uiw/react-codemirror@4.19.5(@babel/runtime@7.28.4)(@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0))(@codemirror/language@6.3.2)(@codemirror/lint@6.4.2)(@codemirror/search@6.2.3)(@codemirror/state@6.2.0)(@codemirror/theme-one-dark@6.1.3)(@codemirror/view@6.7.2)(codemirror@6.0.2(@lezer/common@1.3.0))(react-dom@18.2.0(react@18.2.0))(react@18.2.0)':
     dependencies:
       '@babel/runtime': 7.28.4
       '@codemirror/commands': 6.1.3
@@ -31140,7 +31616,7 @@ snapshots:
       '@codemirror/theme-one-dark': 6.1.3
       '@codemirror/view': 6.7.2
       '@uiw/codemirror-extensions-basic-setup': 4.19.5(@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0))(@codemirror/commands@6.1.3)(@codemirror/language@6.3.2)(@codemirror/lint@6.4.2)(@codemirror/search@6.2.3)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)
-      codemirror: 6.0.2
+      codemirror: 6.0.2(@lezer/common@1.3.0)
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
     transitivePeerDependencies:
@@ -31163,12 +31639,12 @@ snapshots:
 
   '@uploadthing/mime-types@0.3.0': {}
 
-  '@uploadthing/react@7.0.3(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(react@18.3.1)(uploadthing@7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1))':
+  '@uploadthing/react@7.0.3(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(react@18.3.1)(uploadthing@7.1.0(express@5.2.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1))':
     dependencies:
       '@uploadthing/shared': 7.0.3
       file-selector: 0.6.0
       react: 18.3.1
-      uploadthing: 7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1)
+      uploadthing: 7.1.0(express@5.2.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1)
     optionalDependencies:
       next: 14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
 
@@ -31182,7 +31658,7 @@ snapshots:
     dependencies:
       '@upstash/redis': 1.29.0
 
-  '@upstash/ratelimit@1.1.3':
+  '@upstash/ratelimit@1.1.3(patch_hash=e5922e50fbefb7b2b24950c4b1c5c9ddc4cd25464439c9548d2298c432debe74)':
     dependencies:
       '@upstash/core-analytics': 0.0.8
 
@@ -31210,7 +31686,7 @@ snapshots:
       media-query-parser: 2.0.2
       outdent: 0.8.0
 
-  '@vanilla-extract/integration@6.2.1(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1)':
+  '@vanilla-extract/integration@6.2.1(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)':
     dependencies:
       '@babel/core': 7.22.17
       '@babel/plugin-syntax-typescript': 7.21.4(@babel/core@7.22.17)
@@ -31220,11 +31696,11 @@ snapshots:
       eval: 0.1.6
       find-up: 5.0.0
       javascript-stringify: 2.1.0
-      lodash: 4.17.21
+      lodash: 4.17.23
       mlly: 1.7.4
       outdent: 0.8.0
-      vite: 4.4.9(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1)
-      vite-node: 0.28.5(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1)
+      vite: 4.4.9(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
+      vite-node: 0.28.5(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
     transitivePeerDependencies:
       - '@types/node'
       - less
@@ -31239,6 +31715,10 @@ snapshots:
 
   '@vercel/oidc@3.0.3': {}
 
+  '@vercel/oidc@3.0.5': {}
+
+  '@vercel/oidc@3.1.0': {}
+
   '@vercel/otel@1.13.0(@opentelemetry/api-logs@0.203.0)(@opentelemetry/api@1.9.0)(@opentelemetry/instrumentation@0.203.0(@opentelemetry/api@1.9.0))(@opentelemetry/resources@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-logs@0.203.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-metrics@2.0.1(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@2.0.1(@opentelemetry/api@1.9.0))':
     dependencies:
       '@opentelemetry/api': 1.9.0
@@ -31257,6 +31737,14 @@ snapshots:
     transitivePeerDependencies:
       - utf-8-validate
 
+  '@vercel/sdk@1.19.1':
+    dependencies:
+      '@modelcontextprotocol/sdk': 1.26.0(zod@3.25.76)
+      zod: 3.25.76
+    transitivePeerDependencies:
+      - '@cfworker/json-schema'
+      - supports-color
+
   '@vitest/coverage-v8@3.1.4(vitest@3.1.4(@types/debug@4.1.12)(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1))':
     dependencies:
       '@ampproject/remapping': 2.3.0
@@ -31330,60 +31818,6 @@ snapshots:
       loupe: 3.1.3
       tinyrainbow: 2.0.0
 
-  '@vue/compiler-core@3.5.24':
-    dependencies:
-      '@babel/parser': 7.28.5
-      '@vue/shared': 3.5.24
-      entities: 4.5.0
-      estree-walker: 2.0.2
-      source-map-js: 1.2.1
-
-  '@vue/compiler-dom@3.5.24':
-    dependencies:
-      '@vue/compiler-core': 3.5.24
-      '@vue/shared': 3.5.24
-
-  '@vue/compiler-sfc@3.5.24':
-    dependencies:
-      '@babel/parser': 7.28.5
-      '@vue/compiler-core': 3.5.24
-      '@vue/compiler-dom': 3.5.24
-      '@vue/compiler-ssr': 3.5.24
-      '@vue/shared': 3.5.24
-      estree-walker: 2.0.2
-      magic-string: 0.30.21
-      postcss: 8.5.6
-      source-map-js: 1.2.1
-
-  '@vue/compiler-ssr@3.5.24':
-    dependencies:
-      '@vue/compiler-dom': 3.5.24
-      '@vue/shared': 3.5.24
-
-  '@vue/reactivity@3.5.24':
-    dependencies:
-      '@vue/shared': 3.5.24
-
-  '@vue/runtime-core@3.5.24':
-    dependencies:
-      '@vue/reactivity': 3.5.24
-      '@vue/shared': 3.5.24
-
-  '@vue/runtime-dom@3.5.24':
-    dependencies:
-      '@vue/reactivity': 3.5.24
-      '@vue/runtime-core': 3.5.24
-      '@vue/shared': 3.5.24
-      csstype: 3.2.0
-
-  '@vue/server-renderer@3.5.24(vue@3.5.24(typescript@5.9.3))':
-    dependencies:
-      '@vue/compiler-ssr': 3.5.24
-      '@vue/shared': 3.5.24
-      vue: 3.5.24(typescript@5.9.3)
-
-  '@vue/shared@3.5.24': {}
-
   '@web3-storage/multipart-parser@1.0.0': {}
 
   '@webassemblyjs/ast@1.11.5':
@@ -31553,7 +31987,7 @@ snapshots:
       fast-url-parser: 1.1.3
       tslib: 2.8.1
 
-  '@window-splitter/state@0.4.1':
+  '@window-splitter/state@0.4.1(patch_hash=da01382a3c0d3f4f66db5b09d6f0833cc21eaf8db00f97e2c1738797673b57c0)':
     dependencies:
       '@react-spring/rafz': 9.7.4
       '@types/invariant': 2.2.37
@@ -31601,17 +32035,17 @@ snapshots:
       mime-types: 3.0.0
       negotiator: 1.0.0
 
-  acorn-import-assertions@1.9.0(acorn@8.14.1):
+  acorn-import-assertions@1.9.0(acorn@8.15.0):
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
   acorn-import-attributes@1.9.5(acorn@8.12.1):
     dependencies:
       acorn: 8.12.1
 
-  acorn-import-attributes@1.9.5(acorn@8.14.1):
+  acorn-import-attributes@1.9.5(acorn@8.15.0):
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
   acorn-import-phases@1.0.4(acorn@8.15.0):
     dependencies:
@@ -31621,9 +32055,9 @@ snapshots:
     dependencies:
       acorn: 8.12.1
 
-  acorn-jsx@5.3.2(acorn@8.14.1):
+  acorn-jsx@5.3.2(acorn@8.15.0):
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
   acorn-node@1.8.2:
     dependencies:
@@ -31645,12 +32079,14 @@ snapshots:
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
     transitivePeerDependencies:
       - supports-color
 
   agent-base@7.1.4: {}
 
+  agentcrumbs@0.5.0: {}
+
   agentkeepalive@4.5.0:
     dependencies:
       humanize-ms: 1.2.1
@@ -31667,31 +32103,6 @@ snapshots:
 
   ahocorasick@1.0.2: {}
 
-  ai@3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.9.3))(zod@3.25.76):
-    dependencies:
-      '@ai-sdk/provider': 0.0.26
-      '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76)
-      '@ai-sdk/react': 0.0.70(react@19.1.0)(zod@3.25.76)
-      '@ai-sdk/solid': 0.0.54(zod@3.25.76)
-      '@ai-sdk/svelte': 0.0.57(svelte@5.43.6)(zod@3.25.76)
-      '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76)
-      '@ai-sdk/vue': 0.0.59(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)
-      '@opentelemetry/api': 1.9.0
-      eventsource-parser: 1.1.2
-      json-schema: 0.4.0
-      jsondiffpatch: 0.6.0
-      secure-json-parse: 2.7.0
-      zod-to-json-schema: 3.24.3(zod@3.25.76)
-    optionalDependencies:
-      openai: 4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76)
-      react: 19.1.0
-      sswr: 2.1.0(svelte@5.43.6)
-      svelte: 5.43.6
-      zod: 3.25.76
-    transitivePeerDependencies:
-      - solid-js
-      - vue
-
   ai@4.0.0(react@18.3.1)(zod@3.25.76):
     dependencies:
       '@ai-sdk/provider': 1.0.0
@@ -31745,6 +32156,22 @@ snapshots:
       '@opentelemetry/api': 1.9.0
       zod: 3.25.76
 
+  ai@6.0.116(zod@3.25.76):
+    dependencies:
+      '@ai-sdk/gateway': 3.0.66(zod@3.25.76)
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.19(zod@3.25.76)
+      '@opentelemetry/api': 1.9.0
+      zod: 3.25.76
+
+  ai@6.0.3(zod@3.25.76):
+    dependencies:
+      '@ai-sdk/gateway': 3.0.2(zod@3.25.76)
+      '@ai-sdk/provider': 3.0.0
+      '@ai-sdk/provider-utils': 4.0.1(zod@3.25.76)
+      '@opentelemetry/api': 1.9.0
+      zod: 3.25.76
+
   ajv-formats@2.1.1(ajv@8.17.1):
     optionalDependencies:
       ajv: 8.17.1
@@ -31798,6 +32225,10 @@ snapshots:
 
   ansi-styles@6.2.1: {}
 
+  antlr4ts-cli@0.5.0-alpha.4: {}
+
+  antlr4ts@0.5.0-alpha.4(patch_hash=b5d41129ddbf7c4cbb0288244b2c8d041ee0803c5102c1181c180408d3b579f4): {}
+
   any-promise@1.3.0: {}
 
   anymatch@3.1.3:
@@ -31811,7 +32242,7 @@ snapshots:
       graceful-fs: 4.2.11
       is-stream: 2.0.1
       lazystream: 1.0.1
-      lodash: 4.17.21
+      lodash: 4.17.23
       normalize-path: 3.0.0
       readable-stream: 4.7.0
 
@@ -31847,8 +32278,6 @@ snapshots:
     dependencies:
       dequal: 2.0.3
 
-  aria-query@5.3.2: {}
-
   arktype@2.1.20:
     dependencies:
       '@ark/schema': 0.46.0
@@ -31856,15 +32285,15 @@ snapshots:
 
   array-buffer-byte-length@1.0.1:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       is-array-buffer: 3.0.4
 
   array-flatten@1.1.1: {}
 
   array-includes@3.1.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       get-intrinsic: 1.3.0
       is-string: 1.0.7
@@ -31891,8 +32320,8 @@ snapshots:
 
   array.prototype.flat@1.3.1:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       es-shim-unscopables: 1.0.0
 
@@ -31905,8 +32334,8 @@ snapshots:
 
   array.prototype.flatmap@1.3.1:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       es-shim-unscopables: 1.0.0
 
@@ -31919,8 +32348,8 @@ snapshots:
 
   array.prototype.tosorted@1.1.1:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       es-shim-unscopables: 1.0.0
       get-intrinsic: 1.3.0
@@ -31928,7 +32357,7 @@ snapshots:
   arraybuffer.prototype.slice@1.0.3:
     dependencies:
       array-buffer-byte-length: 1.0.1
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-abstract: 1.23.3
       es-errors: 1.3.0
@@ -32015,8 +32444,6 @@ snapshots:
       postcss: 7.0.39
       postcss-value-parser: 4.2.0
 
-  available-typed-arrays@1.0.5: {}
-
   available-typed-arrays@1.0.7:
     dependencies:
       possible-typed-array-names: 1.0.0
@@ -32046,8 +32473,6 @@ snapshots:
     dependencies:
       dequal: 2.0.3
 
-  axobject-query@4.1.0: {}
-
   b4a@1.6.6: {}
 
   babel-walk@3.0.0:
@@ -32058,17 +32483,14 @@ snapshots:
 
   balanced-match@1.0.2: {}
 
-  bare-events@2.5.4:
-    optional: true
-
   bare-events@2.8.2:
     optional: true
 
   bare-fs@4.5.1:
     dependencies:
-      bare-events: 2.5.4
+      bare-events: 2.8.2
       bare-path: 3.0.0
-      bare-stream: 2.6.5(bare-events@2.5.4)
+      bare-stream: 2.6.5(bare-events@2.8.2)
       bare-url: 2.3.2
       fast-fifo: 1.3.2
     transitivePeerDependencies:
@@ -32083,11 +32505,11 @@ snapshots:
       bare-os: 3.6.1
     optional: true
 
-  bare-stream@2.6.5(bare-events@2.5.4):
+  bare-stream@2.6.5(bare-events@2.8.2):
     dependencies:
       streamx: 2.22.0
     optionalDependencies:
-      bare-events: 2.5.4
+      bare-events: 2.8.2
     transitivePeerDependencies:
       - bare-abort-controller
     optional: true
@@ -32140,7 +32562,7 @@ snapshots:
     dependencies:
       buffer: 5.7.1
       inherits: 2.0.4
-      readable-stream: 3.6.0
+      readable-stream: 3.6.2
 
   body-parser@1.20.3:
     dependencies:
@@ -32152,7 +32574,7 @@ snapshots:
       http-errors: 2.0.0
       iconv-lite: 0.4.24
       on-finished: 2.4.1
-      qs: 6.13.0
+      qs: 6.14.1
       raw-body: 2.5.2
       type-is: 1.6.18
       unpipe: 1.0.0
@@ -32163,16 +32585,30 @@ snapshots:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       http-errors: 2.0.0
       iconv-lite: 0.6.3
       on-finished: 2.4.1
-      qs: 6.14.0
+      qs: 6.14.1
       raw-body: 3.0.0
       type-is: 2.0.0
     transitivePeerDependencies:
       - supports-color
 
+  body-parser@2.2.2:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 4.4.3(supports-color@10.0.0)
+      http-errors: 2.0.0
+      iconv-lite: 0.7.2
+      on-finished: 2.4.1
+      qs: 6.14.1
+      raw-body: 3.0.2
+      type-is: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
   bottleneck@2.19.5: {}
 
   bowser@2.11.0: {}
@@ -32257,7 +32693,7 @@ snapshots:
 
   bun-types@1.1.17:
     dependencies:
-      '@types/node': 20.12.14
+      '@types/node': 20.14.14
       '@types/ws': 8.5.10
 
   bundle-name@4.1.0:
@@ -32501,9 +32937,9 @@ snapshots:
 
   cjs-module-lexer@1.2.3: {}
 
-  class-variance-authority@0.5.2(typescript@5.9.3):
+  class-variance-authority@0.5.2(typescript@5.5.4):
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   class-variance-authority@0.7.0:
     dependencies:
@@ -32582,15 +33018,17 @@ snapshots:
 
   cluster-key-slot@1.1.2: {}
 
-  codemirror@6.0.2:
+  codemirror@6.0.2(@lezer/common@1.3.0):
     dependencies:
-      '@codemirror/autocomplete': 6.19.1
-      '@codemirror/commands': 6.10.0
-      '@codemirror/language': 6.11.3
-      '@codemirror/lint': 6.9.2
-      '@codemirror/search': 6.5.11
-      '@codemirror/state': 6.5.2
-      '@codemirror/view': 6.38.7
+      '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)
+      '@codemirror/commands': 6.1.3
+      '@codemirror/language': 6.3.2
+      '@codemirror/lint': 6.4.2
+      '@codemirror/search': 6.2.3
+      '@codemirror/state': 6.2.0
+      '@codemirror/view': 6.7.2
+    transitivePeerDependencies:
+      - '@lezer/common'
 
   color-convert@1.9.3:
     dependencies:
@@ -32753,23 +33191,23 @@ snapshots:
     dependencies:
       layout-base: 2.0.1
 
-  cosmiconfig@8.3.6(typescript@5.9.3):
+  cosmiconfig@8.3.6(typescript@5.5.4):
     dependencies:
       import-fresh: 3.3.0
       js-yaml: 4.1.1
       parse-json: 5.2.0
       path-type: 4.0.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
-  cosmiconfig@9.0.0(typescript@5.9.3):
+  cosmiconfig@9.0.0(typescript@5.5.4):
     dependencies:
       env-paths: 2.2.1
       import-fresh: 3.3.0
       js-yaml: 4.1.1
       parse-json: 5.2.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   cp-file@10.0.0:
     dependencies:
@@ -32806,8 +33244,6 @@ snapshots:
       crc-32: 1.2.2
       readable-stream: 4.7.0
 
-  crelt@1.0.5: {}
-
   crelt@1.0.6: {}
 
   cron-parser@4.9.0:
@@ -32888,6 +33324,8 @@ snapshots:
 
   csstype@3.2.0: {}
 
+  csstype@3.2.3: {}
+
   csv-generate@3.4.3: {}
 
   csv-parse@4.16.3: {}
@@ -33099,24 +33537,26 @@ snapshots:
 
   data-view-buffer@1.0.1:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       is-data-view: 1.0.1
 
   data-view-byte-length@1.0.1:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       is-data-view: 1.0.1
 
   data-view-byte-offset@1.0.0:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       is-data-view: 1.0.1
 
   dataloader@1.4.0: {}
 
+  date-fns-jalali@4.1.0-0: {}
+
   date-fns@4.1.0: {}
 
   dayjs@1.11.18: {}
@@ -33153,7 +33593,11 @@ snapshots:
     dependencies:
       ms: 2.1.3
 
-  debug@4.4.1(supports-color@10.0.0):
+  debug@4.4.1:
+    dependencies:
+      ms: 2.1.3
+
+  debug@4.4.3(supports-color@10.0.0):
     dependencies:
       ms: 2.1.3
     optionalDependencies:
@@ -33291,6 +33735,8 @@ snapshots:
     dependencies:
       path-type: 4.0.0
 
+  discontinuous-range@1.0.0: {}
+
   dlv@1.1.3: {}
 
   docker-compose@0.24.8:
@@ -33299,7 +33745,7 @@ snapshots:
 
   docker-modem@5.0.6:
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       readable-stream: 3.6.0
       split-ca: 1.0.1
       ssh2: 1.16.0
@@ -33332,7 +33778,7 @@ snapshots:
 
   dom-helpers@5.2.1:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       csstype: 3.2.0
 
   dom-serializer@2.0.0:
@@ -33434,7 +33880,7 @@ snapshots:
 
   effect@3.16.12:
     dependencies:
-      '@standard-schema/spec': 1.0.0
+      '@standard-schema/spec': 1.1.0
       fast-check: 3.23.2
 
   effect@3.17.1:
@@ -33444,7 +33890,7 @@ snapshots:
 
   effect@3.18.4:
     dependencies:
-      '@standard-schema/spec': 1.0.0
+      '@standard-schema/spec': 1.1.0
       fast-check: 3.23.2
 
   effect@3.7.2: {}
@@ -33493,7 +33939,7 @@ snapshots:
     dependencies:
       '@types/cookie': 0.4.1
       '@types/cors': 2.8.17
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       accepts: 1.3.8
       base64id: 2.0.0
       cookie: 0.4.2
@@ -33509,12 +33955,12 @@ snapshots:
   enhanced-resolve@5.15.0:
     dependencies:
       graceful-fs: 4.2.11
-      tapable: 2.2.1
+      tapable: 2.3.0
 
   enhanced-resolve@5.18.3:
     dependencies:
       graceful-fs: 4.2.11
-      tapable: 2.2.2
+      tapable: 2.3.0
 
   enquirer@2.3.6:
     dependencies:
@@ -33540,8 +33986,8 @@ snapshots:
 
   es-abstract@1.21.1:
     dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.7
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
       es-set-tostringtag: 2.0.1
       es-to-primitive: 1.2.1
       function-bind: 1.1.2
@@ -33561,25 +34007,25 @@ snapshots:
       is-regex: 1.1.4
       is-shared-array-buffer: 1.0.2
       is-string: 1.0.7
-      is-typed-array: 1.1.10
+      is-typed-array: 1.1.13
       is-weakref: 1.0.2
       object-inspect: 1.13.4
       object-keys: 1.1.1
-      object.assign: 4.1.4
+      object.assign: 4.1.5
       regexp.prototype.flags: 1.4.3
       safe-regex-test: 1.0.0
       string.prototype.trimend: 1.0.6
       string.prototype.trimstart: 1.0.6
       typed-array-length: 1.0.4
       unbox-primitive: 1.0.2
-      which-typed-array: 1.1.9
+      which-typed-array: 1.1.15
 
   es-abstract@1.23.3:
     dependencies:
       array-buffer-byte-length: 1.0.1
       arraybuffer.prototype.slice: 1.0.3
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       data-view-buffer: 1.0.1
       data-view-byte-length: 1.0.1
       data-view-byte-offset: 1.0.0
@@ -33641,7 +34087,7 @@ snapshots:
     dependencies:
       get-intrinsic: 1.3.0
       has: 1.0.3
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   es-set-tostringtag@2.0.3:
     dependencies:
@@ -33891,6 +34337,34 @@ snapshots:
       '@esbuild/win32-ia32': 0.23.0
       '@esbuild/win32-x64': 0.23.0
 
+  esbuild@0.24.2:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.24.2
+      '@esbuild/android-arm': 0.24.2
+      '@esbuild/android-arm64': 0.24.2
+      '@esbuild/android-x64': 0.24.2
+      '@esbuild/darwin-arm64': 0.24.2
+      '@esbuild/darwin-x64': 0.24.2
+      '@esbuild/freebsd-arm64': 0.24.2
+      '@esbuild/freebsd-x64': 0.24.2
+      '@esbuild/linux-arm': 0.24.2
+      '@esbuild/linux-arm64': 0.24.2
+      '@esbuild/linux-ia32': 0.24.2
+      '@esbuild/linux-loong64': 0.24.2
+      '@esbuild/linux-mips64el': 0.24.2
+      '@esbuild/linux-ppc64': 0.24.2
+      '@esbuild/linux-riscv64': 0.24.2
+      '@esbuild/linux-s390x': 0.24.2
+      '@esbuild/linux-x64': 0.24.2
+      '@esbuild/netbsd-arm64': 0.24.2
+      '@esbuild/netbsd-x64': 0.24.2
+      '@esbuild/openbsd-arm64': 0.24.2
+      '@esbuild/openbsd-x64': 0.24.2
+      '@esbuild/sunos-x64': 0.24.2
+      '@esbuild/win32-arm64': 0.24.2
+      '@esbuild/win32-ia32': 0.24.2
+      '@esbuild/win32-x64': 0.24.2
+
   esbuild@0.25.1:
     optionalDependencies:
       '@esbuild/aix-ppc64': 0.25.1
@@ -33966,14 +34440,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0):
+  eslint-import-resolver-typescript@3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0):
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       enhanced-resolve: 5.15.0
       eslint: 8.31.0
-      eslint-module-utils: 2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
-      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
-      get-tsconfig: 4.7.2
+      eslint-module-utils: 2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
+      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
+      get-tsconfig: 4.7.6
       globby: 13.2.2
       is-core-module: 2.14.0
       is-glob: 4.0.3
@@ -33984,25 +34458,25 @@ snapshots:
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-module-utils@2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
+  eslint-module-utils@2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       eslint: 8.31.0
       eslint-import-resolver-node: 0.3.7
-      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
+      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
+  eslint-module-utils@2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       eslint: 8.31.0
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
+      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -34012,7 +34486,7 @@ snapshots:
       eslint-utils: 2.1.0
       regexpp: 3.2.0
 
-  eslint-plugin-import@2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
+  eslint-plugin-import@2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0):
     dependencies:
       array-includes: 3.1.8
       array.prototype.findlastindex: 1.2.5
@@ -34022,7 +34496,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.31.0
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
+      eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0)
       hasown: 2.0.2
       is-core-module: 2.14.0
       is-glob: 4.0.3
@@ -34033,7 +34507,7 @@ snapshots:
       semver: 6.3.1
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
@@ -34046,12 +34520,12 @@ snapshots:
       eslint: 8.31.0
       requireindex: 1.2.0
 
-  eslint-plugin-jest@26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3):
+  eslint-plugin-jest@26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4):
     dependencies:
-      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       eslint: 8.31.0
     optionalDependencies:
-      '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -34109,9 +34583,9 @@ snapshots:
       semver: 6.3.1
       string.prototype.matchall: 4.0.8
 
-  eslint-plugin-testing-library@5.11.0(eslint@8.31.0)(typescript@5.9.3):
+  eslint-plugin-testing-library@5.11.0(eslint@8.31.0)(typescript@5.5.4):
     dependencies:
-      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3)
+      '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4)
       eslint: 8.31.0
     transitivePeerDependencies:
       - supports-color
@@ -34198,8 +34672,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  esm-env@1.2.2: {}
-
   espree@9.4.1:
     dependencies:
       acorn: 8.12.1
@@ -34208,8 +34680,8 @@ snapshots:
 
   espree@9.6.0:
     dependencies:
-      acorn: 8.14.1
-      acorn-jsx: 5.3.2(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
       eslint-visitor-keys: 3.4.2
 
   esprima@4.0.1: {}
@@ -34218,10 +34690,6 @@ snapshots:
     dependencies:
       estraverse: 5.3.0
 
-  esrap@2.1.2:
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.5
-
   esrecurse@4.3.0:
     dependencies:
       estraverse: 5.3.0
@@ -34261,8 +34729,6 @@ snapshots:
       '@types/estree-jsx': 1.0.0
       '@types/unist': 2.0.6
 
-  estree-walker@2.0.2: {}
-
   estree-walker@3.0.3:
     dependencies:
       '@types/estree': 1.0.8
@@ -34347,6 +34813,21 @@ snapshots:
       signal-exit: 4.1.0
       strip-final-newline: 3.0.0
 
+  execa@9.6.1:
+    dependencies:
+      '@sindresorhus/merge-streams': 4.0.0
+      cross-spawn: 7.0.6
+      figures: 6.1.0
+      get-stream: 9.0.1
+      human-signals: 8.0.1
+      is-plain-obj: 4.1.0
+      is-stream: 4.0.1
+      npm-run-path: 6.0.0
+      pretty-ms: 9.3.0
+      signal-exit: 4.1.0
+      strip-final-newline: 4.0.0
+      yoctocolors: 2.1.2
+
   exit-hook@2.2.1: {}
 
   expand-template@2.0.3: {}
@@ -34357,6 +34838,11 @@ snapshots:
     dependencies:
       express: 5.0.1(supports-color@10.0.0)
 
+  express-rate-limit@8.2.1(express@5.2.1):
+    dependencies:
+      express: 5.2.1
+      ip-address: 10.0.1
+
   express@4.20.0:
     dependencies:
       accepts: 1.3.8
@@ -34380,7 +34866,7 @@ snapshots:
       parseurl: 1.3.3
       path-to-regexp: 0.1.10
       proxy-addr: 2.0.7
-      qs: 6.11.0
+      qs: 6.14.1
       range-parser: 1.2.1
       safe-buffer: 5.2.1
       send: 0.19.0
@@ -34416,7 +34902,7 @@ snapshots:
       once: 1.4.0
       parseurl: 1.3.3
       proxy-addr: 2.0.7
-      qs: 6.13.0
+      qs: 6.14.1
       range-parser: 1.2.1
       router: 2.1.0
       safe-buffer: 5.2.1
@@ -34430,6 +34916,39 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  express@5.2.1:
+    dependencies:
+      accepts: 2.0.0
+      body-parser: 2.2.2
+      content-disposition: 1.0.0
+      content-type: 1.0.5
+      cookie: 0.7.1
+      cookie-signature: 1.2.2
+      debug: 4.4.3(supports-color@10.0.0)
+      depd: 2.0.0
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 2.1.0(supports-color@10.0.0)
+      fresh: 2.0.0
+      http-errors: 2.0.0
+      merge-descriptors: 2.0.0
+      mime-types: 3.0.0
+      on-finished: 2.4.1
+      once: 1.4.0
+      parseurl: 1.3.3
+      proxy-addr: 2.0.7
+      qs: 6.14.1
+      range-parser: 1.2.1
+      router: 2.2.0
+      send: 1.1.0(supports-color@10.0.0)
+      serve-static: 2.2.1
+      statuses: 2.0.1
+      type-is: 2.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
   exsolve@1.0.7: {}
 
   extend@3.0.2: {}
@@ -34444,7 +34963,7 @@ snapshots:
 
   extract-zip@2.0.1:
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
@@ -34466,6 +34985,8 @@ snapshots:
 
   fast-deep-equal@3.1.3: {}
 
+  fast-equals@4.0.3: {}
+
   fast-equals@5.0.1: {}
 
   fast-fifo@1.3.2: {}
@@ -34540,7 +35061,7 @@ snapshots:
       process-warning: 5.0.0
       rfdc: 1.4.1
       secure-json-parse: 4.0.0
-      semver: 7.7.2
+      semver: 7.7.3
       toad-cache: 3.7.0
 
   fastq@1.15.0:
@@ -34577,6 +35098,10 @@ snapshots:
 
   fft.js@4.0.4: {}
 
+  figures@6.1.0:
+    dependencies:
+      is-unicode-supported: 2.1.0
+
   file-entry-cache@6.0.1:
     dependencies:
       flat-cache: 3.0.4
@@ -34612,7 +35137,7 @@ snapshots:
 
   finalhandler@2.1.0(supports-color@10.0.0):
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
@@ -34665,7 +35190,7 @@ snapshots:
 
   foreground-child@3.1.1:
     dependencies:
-      cross-spawn: 7.0.3
+      cross-spawn: 7.0.6
       signal-exit: 4.1.0
 
   forever-agent@0.6.1: {}
@@ -34778,14 +35303,14 @@ snapshots:
 
   function.prototype.name@1.1.5:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       functions-have-names: 1.2.3
 
   function.prototype.name@1.1.6:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-abstract: 1.23.3
       functions-have-names: 1.2.3
@@ -34851,12 +35376,12 @@ snapshots:
 
   get-symbol-description@1.0.0:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       get-intrinsic: 1.3.0
 
   get-symbol-description@1.0.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       get-intrinsic: 1.3.0
 
@@ -34872,7 +35397,7 @@ snapshots:
     dependencies:
       basic-ftp: 5.0.3
       data-uri-to-buffer: 5.0.1
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       fs-extra: 8.1.0
     transitivePeerDependencies:
       - supports-color
@@ -34975,7 +35500,7 @@ snapshots:
 
   globalthis@1.0.3:
     dependencies:
-      define-properties: 1.1.4
+      define-properties: 1.2.1
 
   globalyzer@0.1.0: {}
 
@@ -35031,20 +35556,20 @@ snapshots:
       '@types/node': 20.14.14
       '@types/semver': 7.5.1
       chalk: 4.1.2
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       interpret: 3.1.1
-      semver: 7.7.2
+      semver: 7.7.3
       tslib: 2.8.1
       yargs: 17.7.2
     transitivePeerDependencies:
       - supports-color
 
-  graphile-worker@0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.9.3):
+  graphile-worker@0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.5.4):
     dependencies:
       '@graphile/logger': 0.2.0
       '@types/debug': 4.1.12
       '@types/pg': 8.11.6
-      cosmiconfig: 8.3.6(typescript@5.9.3)
+      cosmiconfig: 8.3.6(typescript@5.5.4)
       graphile-config: 0.0.1-beta.8
       json5: 2.2.3
       pg: 8.11.5
@@ -35099,10 +35624,6 @@ snapshots:
 
   has-symbols@1.1.0: {}
 
-  has-tostringtag@1.0.0:
-    dependencies:
-      has-symbols: 1.1.0
-
   has-tostringtag@1.0.2:
     dependencies:
       has-symbols: 1.1.0
@@ -35174,7 +35695,7 @@ snapshots:
 
   hast-util-to-estree@2.1.0:
     dependencies:
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
       '@types/estree-jsx': 1.0.0
       '@types/hast': 2.3.4
       '@types/unist': 2.0.6
@@ -35208,7 +35729,7 @@ snapshots:
 
   hast-util-to-jsx-runtime@2.3.6:
     dependencies:
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
       '@types/hast': 3.0.4
       '@types/unist': 3.0.3
       comma-separated-tokens: 2.0.3
@@ -35265,6 +35786,8 @@ snapshots:
     dependencies:
       react-is: 16.13.1
 
+  hono@4.11.8: {}
+
   hono@4.5.11: {}
 
   hosted-git-info@2.8.9: {}
@@ -35306,10 +35829,18 @@ snapshots:
       statuses: 2.0.1
       toidentifier: 1.0.1
 
+  http-errors@2.0.1:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.2
+      toidentifier: 1.0.1
+
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -35322,14 +35853,14 @@ snapshots:
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
     transitivePeerDependencies:
       - supports-color
 
@@ -35339,6 +35870,8 @@ snapshots:
 
   human-signals@5.0.0: {}
 
+  human-signals@8.0.1: {}
+
   humanize-duration@3.27.3: {}
 
   humanize-ms@1.2.1:
@@ -35355,6 +35888,10 @@ snapshots:
     dependencies:
       safer-buffer: 2.1.2
 
+  iconv-lite@0.7.2:
+    dependencies:
+      safer-buffer: 2.1.2
+
   icss-utils@5.1.0(postcss@8.4.35):
     dependencies:
       postcss: 8.4.35
@@ -35383,8 +35920,8 @@ snapshots:
 
   import-in-the-middle@1.14.2:
     dependencies:
-      acorn: 8.14.1
-      acorn-import-attributes: 1.9.5(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-import-attributes: 1.9.5(acorn@8.15.0)
       cjs-module-lexer: 1.2.3
       module-details-from-path: 1.0.3
 
@@ -35469,6 +36006,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  ip-address@10.0.1: {}
+
+  ip-address@8.1.0:
+    dependencies:
+      jsbn: 1.1.0
+      sprintf-js: 1.1.2
+
   ip-address@9.0.5:
     dependencies:
       jsbn: 1.1.0
@@ -35489,18 +36033,18 @@ snapshots:
 
   is-arguments@1.1.1:
     dependencies:
-      call-bind: 1.0.7
-      has-tostringtag: 1.0.0
+      call-bind: 1.0.8
+      has-tostringtag: 1.0.2
 
   is-array-buffer@3.0.1:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       get-intrinsic: 1.3.0
-      is-typed-array: 1.1.10
+      is-typed-array: 1.1.13
 
   is-array-buffer@3.0.4:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       get-intrinsic: 1.3.0
 
   is-arrayish@0.2.1: {}
@@ -35517,8 +36061,8 @@ snapshots:
 
   is-boolean-object@1.1.2:
     dependencies:
-      call-bind: 1.0.7
-      has-tostringtag: 1.0.0
+      call-bind: 1.0.8
+      has-tostringtag: 1.0.2
 
   is-buffer@2.0.5: {}
 
@@ -35538,7 +36082,7 @@ snapshots:
 
   is-date-object@1.0.5:
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   is-decimal@2.0.1: {}
 
@@ -35556,7 +36100,7 @@ snapshots:
 
   is-generator-function@1.0.10:
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   is-glob@4.0.3:
     dependencies:
@@ -35580,7 +36124,7 @@ snapshots:
 
   is-number-object@1.0.7:
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   is-number@7.0.0: {}
 
@@ -35602,16 +36146,16 @@ snapshots:
 
   is-regex@1.1.4:
     dependencies:
-      call-bind: 1.0.7
-      has-tostringtag: 1.0.0
+      call-bind: 1.0.8
+      has-tostringtag: 1.0.2
 
   is-shared-array-buffer@1.0.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
 
   is-shared-array-buffer@1.0.3:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
 
   is-stream@2.0.1: {}
 
@@ -35621,7 +36165,7 @@ snapshots:
 
   is-string@1.0.7:
     dependencies:
-      has-tostringtag: 1.0.0
+      has-tostringtag: 1.0.2
 
   is-subdir@1.2.0:
     dependencies:
@@ -35631,14 +36175,6 @@ snapshots:
     dependencies:
       has-symbols: 1.1.0
 
-  is-typed-array@1.1.10:
-    dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.7
-      for-each: 0.3.3
-      gopd: 1.2.0
-      has-tostringtag: 1.0.0
-
   is-typed-array@1.1.13:
     dependencies:
       which-typed-array: 1.1.15
@@ -35647,9 +36183,11 @@ snapshots:
 
   is-unicode-supported@0.1.0: {}
 
+  is-unicode-supported@2.1.0: {}
+
   is-weakref@1.0.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
 
   is-what@4.1.16: {}
 
@@ -35692,7 +36230,7 @@ snapshots:
   istanbul-lib-source-maps@5.0.6:
     dependencies:
       '@jridgewell/trace-mapping': 0.3.25
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       istanbul-lib-coverage: 3.2.2
     transitivePeerDependencies:
       - supports-color
@@ -35806,6 +36344,8 @@ snapshots:
 
   json-schema-traverse@1.0.0: {}
 
+  json-schema-typed@8.0.2: {}
+
   json-schema@0.4.0: {}
 
   json-stable-stringify-without-jsonify@1.0.1: {}
@@ -35879,7 +36419,7 @@ snapshots:
   jsx-ast-utils@3.3.3:
     dependencies:
       array-includes: 3.1.6
-      object.assign: 4.1.4
+      object.assign: 4.1.5
 
   junk@4.0.1: {}
 
@@ -35894,6 +36434,8 @@ snapshots:
       jwa: 1.4.2
       safe-buffer: 5.2.1
 
+  jwt-decode@3.1.2: {}
+
   katex@0.16.25:
     dependencies:
       commander: 8.3.0
@@ -36089,8 +36631,6 @@ snapshots:
       pkg-types: 2.3.0
       quansync: 0.2.11
 
-  locate-character@3.0.0: {}
-
   locate-path@5.0.0:
     dependencies:
       p-locate: 4.1.0
@@ -36151,7 +36691,7 @@ snapshots:
 
   lodash.uniq@4.5.0: {}
 
-  lodash@4.17.21: {}
+  lodash@4.17.23: {}
 
   log-symbols@4.1.0:
     dependencies:
@@ -36174,7 +36714,7 @@ snapshots:
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.0.0: {}
+  lru-cache@11.2.4: {}
 
   lru-cache@4.1.5:
     dependencies:
@@ -36208,6 +36748,10 @@ snapshots:
     dependencies:
       react: 19.0.0
 
+  lucide-react@0.542.0(react@18.2.0):
+    dependencies:
+      react: 18.2.0
+
   lucide-react@0.542.0(react@19.1.0):
     dependencies:
       react: 19.1.0
@@ -36554,7 +37098,7 @@ snapshots:
 
   media-query-parser@2.0.2:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   media-typer@0.3.0: {}
 
@@ -36764,8 +37308,8 @@ snapshots:
 
   micromark-extension-mdxjs@1.0.0:
     dependencies:
-      acorn: 8.14.1
-      acorn-jsx: 5.3.2(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
       micromark-extension-mdx-expression: 1.0.3
       micromark-extension-mdx-jsx: 1.0.3
       micromark-extension-mdx-md: 1.0.0
@@ -36982,7 +37526,7 @@ snapshots:
   micromark@3.1.0:
     dependencies:
       '@types/debug': 4.1.12
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       decode-named-character-reference: 1.0.2
       micromark-core-commonmark: 1.0.6
       micromark-factory-space: 1.0.0
@@ -37004,7 +37548,7 @@ snapshots:
   micromark@4.0.2:
     dependencies:
       '@types/debug': 4.1.12
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       decode-named-character-reference: 1.0.2
       devlop: 1.1.0
       micromark-core-commonmark: 2.0.3
@@ -37032,6 +37576,8 @@ snapshots:
 
   mime-db@1.53.0: {}
 
+  mime-db@1.54.0: {}
+
   mime-types@2.1.35:
     dependencies:
       mime-db: 1.52.0
@@ -37040,6 +37586,10 @@ snapshots:
     dependencies:
       mime-db: 1.53.0
 
+  mime-types@3.0.2:
+    dependencies:
+      mime-db: 1.54.0
+
   mime@1.6.0: {}
 
   mime@2.6.0: {}
@@ -37130,6 +37680,10 @@ snapshots:
       minipass: 7.1.2
       rimraf: 5.0.7
 
+  minizlib@3.1.0:
+    dependencies:
+      minipass: 7.1.2
+
   mitt@3.0.1: {}
 
   mixme@0.5.4: {}
@@ -37186,6 +37740,8 @@ snapshots:
 
   module-details-from-path@1.0.3: {}
 
+  moo@0.5.2: {}
+
   morgan@1.10.0:
     dependencies:
       basic-auth: 2.0.1
@@ -37223,7 +37779,7 @@ snapshots:
 
   nano-css@5.6.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
       css-tree: 1.1.3
       csstype: 3.2.0
       fastest-stable-stringify: 2.0.2
@@ -37250,6 +37806,13 @@ snapshots:
 
   natural-compare@1.4.0: {}
 
+  nearley@2.20.1:
+    dependencies:
+      commander: 2.20.3
+      moo: 0.5.2
+      railroad-diagrams: 1.0.0
+      randexp: 0.4.6
+
   negotiator@0.6.3: {}
 
   negotiator@1.0.0: {}
@@ -37406,7 +37969,7 @@ snapshots:
 
   node-emoji@1.11.0:
     dependencies:
-      lodash: 4.17.21
+      lodash: 4.17.23
 
   node-emoji@2.1.3:
     dependencies:
@@ -37509,6 +38072,11 @@ snapshots:
     dependencies:
       path-key: 4.0.0
 
+  npm-run-path@6.0.0:
+    dependencies:
+      path-key: 4.0.0
+      unicorn-magic: 0.3.0
+
   num2fraction@1.2.2: {}
 
   nypm@0.3.9:
@@ -37551,30 +38119,23 @@ snapshots:
 
   object-keys@1.1.1: {}
 
-  object.assign@4.1.4:
-    dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
-      has-symbols: 1.1.0
-      object-keys: 1.1.1
-
   object.assign@4.1.5:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       has-symbols: 1.1.0
       object-keys: 1.1.1
 
   object.entries@1.1.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   object.fromentries@2.0.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   object.fromentries@2.0.8:
@@ -37592,13 +38153,13 @@ snapshots:
 
   object.hasown@1.1.2:
     dependencies:
-      define-properties: 1.1.4
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   object.values@1.1.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   object.values@1.2.0:
@@ -37630,8 +38191,6 @@ snapshots:
   oidc-token-hash@5.0.3:
     optional: true
 
-  on-change@4.0.2: {}
-
   on-exit-leak-free@2.1.2: {}
 
   on-finished@2.3.0:
@@ -37679,7 +38238,7 @@ snapshots:
 
   openai@4.33.1(encoding@0.1.13):
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       '@types/node-fetch': 2.6.4
       abort-controller: 3.0.0
       agentkeepalive: 4.5.0
@@ -37692,7 +38251,7 @@ snapshots:
 
   openai@4.68.4(encoding@0.1.13)(zod@3.25.76):
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       '@types/node-fetch': 2.6.4
       abort-controller: 3.0.0
       agentkeepalive: 4.5.0
@@ -37706,7 +38265,7 @@ snapshots:
 
   openai@4.97.0(encoding@0.1.13)(ws@8.12.0(bufferutil@4.0.9))(zod@3.25.76):
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       '@types/node-fetch': 2.6.12
       abort-controller: 3.0.0
       agentkeepalive: 4.5.0
@@ -37721,7 +38280,7 @@ snapshots:
 
   openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76):
     dependencies:
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       '@types/node-fetch': 2.6.12
       abort-controller: 3.0.0
       agentkeepalive: 4.5.0
@@ -37877,7 +38436,7 @@ snapshots:
     dependencies:
       '@tootallnate/quickjs-emscripten': 0.23.0
       agent-base: 7.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       get-uri: 6.0.1
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
@@ -37937,6 +38496,8 @@ snapshots:
 
   parse-ms@2.1.0: {}
 
+  parse-ms@4.0.0: {}
+
   parse5-htmlparser2-tree-adapter@6.0.1:
     dependencies:
       parse5: 6.0.1
@@ -37983,7 +38544,7 @@ snapshots:
 
   path-scurry@2.0.0:
     dependencies:
-      lru-cache: 11.0.0
+      lru-cache: 11.2.4
       minipass: 7.1.2
 
   path-to-regexp@0.1.10: {}
@@ -38022,15 +38583,13 @@ snapshots:
 
   periscopic@3.1.0:
     dependencies:
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
       estree-walker: 3.0.3
       is-reference: 3.0.3
 
   pg-cloudflare@1.2.7:
     optional: true
 
-  pg-connection-string@2.6.4: {}
-
   pg-connection-string@2.8.5: {}
 
   pg-connection-string@2.9.1: {}
@@ -38039,13 +38598,13 @@ snapshots:
 
   pg-numeric@1.0.2: {}
 
-  pg-pool@3.10.1(pg@8.16.3):
+  pg-pool@3.10.1(pg@8.11.5):
     dependencies:
-      pg: 8.16.3
+      pg: 8.11.5
 
-  pg-pool@3.6.2(pg@8.11.5):
+  pg-pool@3.10.1(pg@8.16.3):
     dependencies:
-      pg: 8.11.5
+      pg: 8.16.3
 
   pg-pool@3.9.6(pg@8.15.6):
     dependencies:
@@ -38077,9 +38636,9 @@ snapshots:
 
   pg@8.11.5:
     dependencies:
-      pg-connection-string: 2.6.4
-      pg-pool: 3.6.2(pg@8.11.5)
-      pg-protocol: 1.6.1
+      pg-connection-string: 2.9.1
+      pg-pool: 3.10.1(pg@8.11.5)
+      pg-protocol: 1.10.3
       pg-types: 2.2.0
       pgpass: 1.0.5
     optionalDependencies:
@@ -38265,9 +38824,9 @@ snapshots:
       tsx: 4.17.0
       yaml: 2.7.1
 
-  postcss-loader@8.1.1(postcss@8.5.6)(typescript@5.9.3)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)):
+  postcss-loader@8.1.1(postcss@8.5.6)(typescript@5.5.4)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)):
     dependencies:
-      cosmiconfig: 9.0.0(typescript@5.9.3)
+      cosmiconfig: 9.0.0(typescript@5.5.4)
       jiti: 1.21.0
       postcss: 8.5.6
       semver: 7.6.3
@@ -38394,12 +38953,6 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.0
 
-  postcss@8.5.3:
-    dependencies:
-      nanoid: 3.3.8
-      picocolors: 1.1.1
-      source-map-js: 1.2.1
-
   postcss@8.5.4:
     dependencies:
       nanoid: 3.3.11
@@ -38455,7 +39008,7 @@ snapshots:
       mkdirp-classic: 0.5.3
       napi-build-utils: 2.0.0
       node-abi: 3.75.0
-      pump: 3.0.0
+      pump: 3.0.2
       rc: 1.2.8
       simple-get: 4.0.1
       tar-fs: 2.1.3
@@ -38492,6 +39045,10 @@ snapshots:
     dependencies:
       parse-ms: 2.1.0
 
+  pretty-ms@9.3.0:
+    dependencies:
+      parse-ms: 4.0.0
+
   prism-react-renderer@2.1.0(react@18.3.1):
     dependencies:
       '@types/prismjs': 1.26.0
@@ -38504,9 +39061,9 @@ snapshots:
       clsx: 2.1.1
       react: 18.2.0
 
-  prisma-generator-ts-enums@1.1.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3)):
+  prisma-generator-ts-enums@1.1.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4)):
     dependencies:
-      '@prisma/client': 4.9.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3))
+      '@prisma/client': 4.9.0(prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4))
       '@prisma/generator-helper': 4.16.2
       prettier: 2.8.8
       rimraf: 4.4.1
@@ -38514,41 +39071,41 @@ snapshots:
       - prisma
       - supports-color
 
-  prisma@6.14.0(magicast@0.3.5)(typescript@5.9.3):
+  prisma@6.14.0(magicast@0.3.5)(typescript@5.5.4):
     dependencies:
       '@prisma/config': 6.14.0(magicast@0.3.5)
       '@prisma/engines': 6.14.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - magicast
 
-  prisma@6.16.0(magicast@0.3.5)(typescript@5.9.3):
+  prisma@6.16.0(magicast@0.3.5)(typescript@5.5.4):
     dependencies:
       '@prisma/config': 6.16.0(magicast@0.3.5)
       '@prisma/engines': 6.16.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - magicast
 
-  prisma@6.19.0(typescript@5.9.3):
+  prisma@6.19.0(typescript@5.5.4):
     dependencies:
       '@prisma/config': 6.19.0(magicast@0.3.5)
       '@prisma/engines': 6.19.0
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - magicast
 
-  prisma@6.20.0-integration-next.8(@types/react@19.0.12)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.9.3):
+  prisma@6.20.0-integration-next.8(@types/react@19.2.14)(magicast@0.3.5)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.5.4):
     dependencies:
       '@prisma/config': 6.20.0-integration-next.8(magicast@0.3.5)
       '@prisma/engines': 6.20.0-integration-next.8
-      '@prisma/studio-core-licensed': 0.6.0(@types/react@19.0.12)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+      '@prisma/studio-core-licensed': 0.6.0(@types/react@19.2.14)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       postgres: 3.4.7
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - '@types/react'
       - magicast
@@ -38619,7 +39176,7 @@ snapshots:
       '@protobufjs/path': 1.1.2
       '@protobufjs/pool': 1.1.0
       '@protobufjs/utf8': 1.1.0
-      '@types/node': 18.19.20
+      '@types/node': 20.14.14
       long: 5.2.3
 
   proxy-addr@2.0.7:
@@ -38630,7 +39187,7 @@ snapshots:
   proxy-agent@6.5.0:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       lru-cache: 7.18.3
@@ -38651,11 +39208,6 @@ snapshots:
       end-of-stream: 1.4.4
       once: 1.4.0
 
-  pump@3.0.0:
-    dependencies:
-      end-of-stream: 1.4.4
-      once: 1.4.0
-
   pump@3.0.2:
     dependencies:
       end-of-stream: 1.4.4
@@ -38675,7 +39227,7 @@ snapshots:
     dependencies:
       '@puppeteer/browsers': 2.10.6
       chromium-bidi: 7.2.0(devtools-protocol@0.0.1464554)
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.1
       devtools-protocol: 0.0.1464554
       typed-query-selector: 2.12.0
       ws: 8.18.3(bufferutil@4.0.9)
@@ -38699,20 +39251,10 @@ snapshots:
     dependencies:
       react: 18.2.0
 
-  qs@6.11.0:
-    dependencies:
-      side-channel: 1.1.0
-
-  qs@6.13.0:
+  qs@6.14.1:
     dependencies:
       side-channel: 1.1.0
 
-  qs@6.14.0:
-    dependencies:
-      side-channel: 1.1.0
-
-  qs@6.5.3: {}
-
   quansync@0.2.11: {}
 
   queue-microtask@1.2.3: {}
@@ -38721,6 +39263,13 @@ snapshots:
 
   quick-lru@4.0.1: {}
 
+  railroad-diagrams@1.0.0: {}
+
+  randexp@0.4.6:
+    dependencies:
+      discontinuous-range: 1.0.0
+      ret: 0.1.15
+
   random-words@2.0.0:
     dependencies:
       seedrandom: 3.0.5
@@ -38745,6 +39294,13 @@ snapshots:
       iconv-lite: 0.6.3
       unpipe: 1.0.0
 
+  raw-body@3.0.2:
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
+      unpipe: 1.0.0
+
   rc9@2.1.2:
     dependencies:
       defu: 6.1.4
@@ -38845,6 +39401,13 @@ snapshots:
     dependencies:
       react: 18.2.0
 
+  react-day-picker@9.13.0(react@18.2.0):
+    dependencies:
+      '@date-fns/tz': 1.4.1
+      date-fns: 4.1.0
+      date-fns-jalali: 4.1.0-0
+      react: 18.2.0
+
   react-dom@18.2.0(react@18.2.0):
     dependencies:
       loose-envify: 1.4.0
@@ -38872,19 +39435,26 @@ snapshots:
       react: 19.1.0
       scheduler: 0.26.0
 
+  react-draggable@4.5.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
+    dependencies:
+      clsx: 2.1.1
+      prop-types: 15.8.1
+      react: 18.2.0
+      react-dom: 18.2.0(react@18.2.0)
+
   react-email@2.1.2(@opentelemetry/api@1.9.0)(@swc/helpers@0.5.15)(eslint@8.31.0):
     dependencies:
       '@babel/parser': 7.24.1
       '@radix-ui/colors': 1.0.1
-      '@radix-ui/react-collapsible': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-popover': 1.0.7(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-slot': 1.0.2(@types/react@18.3.1)(react@18.3.1)
-      '@radix-ui/react-toggle-group': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@radix-ui/react-tooltip': 1.0.6(@types/react-dom@18.2.7)(@types/react@18.3.1)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
-      '@react-email/components': 0.0.17(@types/react@18.3.1)(react@18.3.1)
+      '@radix-ui/react-collapsible': 1.0.3(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-popover': 1.0.7(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-slot': 1.0.2(@types/react@18.2.69)(react@18.3.1)
+      '@radix-ui/react-toggle-group': 1.0.4(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-tooltip': 1.0.6(@types/react-dom@18.2.7)(@types/react@18.2.69)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
+      '@react-email/components': 0.0.17(@types/react@18.2.69)(react@18.3.1)
       '@react-email/render': 0.0.13
       '@swc/core': 1.3.101(@swc/helpers@0.5.15)
-      '@types/react': 18.3.1
+      '@types/react': 18.2.69
       '@types/react-dom': 18.2.7
       '@types/webpack': 5.28.5(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11)
       autoprefixer: 10.4.14(postcss@8.4.35)
@@ -38916,7 +39486,7 @@ snapshots:
       stacktrace-parser: 0.1.10
       tailwind-merge: 2.2.0
       tailwindcss: 3.4.0
-      typescript: 5.1.6
+      typescript: 5.5.4
     transitivePeerDependencies:
       - '@babel/core'
       - '@opentelemetry/api'
@@ -38933,6 +39503,17 @@ snapshots:
 
   react-fast-compare@3.2.2: {}
 
+  react-grid-layout@2.2.2(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
+    dependencies:
+      clsx: 2.1.1
+      fast-equals: 4.0.3
+      prop-types: 15.8.1
+      react: 18.2.0
+      react-dom: 18.2.0(react@18.2.0)
+      react-draggable: 4.5.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      react-resizable: 3.1.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      resize-observer-polyfill: 1.5.1
+
   react-hotkeys-hook@4.4.1(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
       react: 18.2.0
@@ -38942,6 +39523,26 @@ snapshots:
 
   react-is@17.0.2: {}
 
+  react-is@18.3.1: {}
+
+  react-markdown@10.1.0(@types/react@18.2.69)(react@18.2.0):
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/react': 18.2.69
+      devlop: 1.1.0
+      hast-util-to-jsx-runtime: 2.3.6
+      html-url-attributes: 3.0.1
+      mdast-util-to-hast: 13.2.0
+      react: 18.2.0
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.1
+      unified: 11.0.5
+      unist-util-visit: 5.0.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - supports-color
+
   react-markdown@10.1.0(@types/react@19.0.12)(react@19.0.0):
     dependencies:
       '@types/hast': 3.0.4
@@ -38978,8 +39579,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  react-merge-refs@2.1.1: {}
-
   react-popper@2.3.0(@popperjs/core@2.11.8)(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
       '@popperjs/core': 2.11.8
@@ -38998,6 +39597,14 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  react-remove-scroll-bar@2.3.8(@types/react@18.2.69)(react@18.3.1):
+    dependencies:
+      react: 18.3.1
+      react-style-singleton: 2.2.3(@types/react@18.2.69)(react@18.3.1)
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   react-remove-scroll-bar@2.3.8(@types/react@18.3.1)(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -39017,6 +39624,17 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  react-remove-scroll@2.5.5(@types/react@18.2.69)(react@18.3.1):
+    dependencies:
+      react: 18.3.1
+      react-remove-scroll-bar: 2.3.8(@types/react@18.2.69)(react@18.3.1)
+      react-style-singleton: 2.2.3(@types/react@18.2.69)(react@18.3.1)
+      tslib: 2.8.1
+      use-callback-ref: 1.3.3(@types/react@18.2.69)(react@18.3.1)
+      use-sidecar: 1.1.3(@types/react@18.2.69)(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   react-remove-scroll@2.5.5(@types/react@18.3.1)(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -39033,6 +39651,13 @@ snapshots:
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
 
+  react-resizable@3.1.3(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
+    dependencies:
+      prop-types: 15.8.1
+      react: 18.2.0
+      react-dom: 18.2.0(react@18.2.0)
+      react-draggable: 4.5.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+
   react-router-dom@6.17.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
       '@remix-run/router': 1.10.0
@@ -39045,7 +39670,7 @@ snapshots:
       '@remix-run/router': 1.10.0
       react: 18.2.0
 
-  react-smooth@4.0.1(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
+  react-smooth@4.0.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
       fast-equals: 5.0.1
       prop-types: 15.8.1
@@ -39088,6 +39713,14 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  react-style-singleton@2.2.3(@types/react@18.2.69)(react@18.3.1):
+    dependencies:
+      get-nonce: 1.0.1
+      react: 18.3.1
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   react-style-singleton@2.2.3(@types/react@18.3.1)(react@18.3.1):
     dependencies:
       get-nonce: 1.0.1
@@ -39098,7 +39731,7 @@ snapshots:
 
   react-transition-group@4.4.5(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       dom-helpers: 5.2.1
       loose-envify: 1.4.0
       prop-types: 15.8.1
@@ -39133,7 +39766,7 @@ snapshots:
     dependencies:
       '@radix-ui/react-compose-refs': 1.1.0(@types/react@18.2.69)(react@18.2.0)
       '@testing-library/jest-dom': 6.5.0
-      '@window-splitter/state': 0.4.1
+      '@window-splitter/state': 0.4.1(patch_hash=da01382a3c0d3f4f66db5b09d6f0833cc21eaf8db00f97e2c1738797673b57c0)
       '@xstate/react': 4.1.2(@types/react@18.2.69)(react@18.2.0)(xstate@5.18.1)
       invariant: 2.2.4
       react: 18.2.0
@@ -39235,15 +39868,15 @@ snapshots:
     dependencies:
       decimal.js-light: 2.5.1
 
-  recharts@2.12.6(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
+  recharts@2.15.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0):
     dependencies:
       clsx: 2.1.1
       eventemitter3: 4.0.7
-      lodash: 4.17.21
+      lodash: 4.17.23
       react: 18.2.0
       react-dom: 18.2.0(react@18.2.0)
-      react-is: 16.13.1
-      react-smooth: 4.0.1(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
+      react-is: 18.3.1
+      react-smooth: 4.0.4(react-dom@18.2.0(react@18.2.0))(react@18.2.0)
       recharts-scale: 0.4.5
       tiny-invariant: 1.3.1
       victory-vendor: 36.6.11
@@ -39297,13 +39930,13 @@ snapshots:
 
   regexp.prototype.flags@1.4.3:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       functions-have-names: 1.2.3
 
   regexp.prototype.flags@1.5.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-errors: 1.3.0
       set-function-name: 2.0.2
@@ -39417,54 +40050,54 @@ snapshots:
       mdast-util-to-markdown: 2.1.2
       unified: 11.0.5
 
-  remix-auth-email-link@2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))):
+  remix-auth-email-link@2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))):
     dependencies:
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       crypto-js: 4.1.1
-      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
+      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
 
-  remix-auth-github@1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))):
+  remix-auth-github@1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))):
     dependencies:
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
-      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
-      remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)))
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
+      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
+      remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)))
     transitivePeerDependencies:
       - supports-color
 
-  remix-auth-google@2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))):
+  remix-auth-google@2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))):
     dependencies:
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
-      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
-      remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)))
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
+      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
+      remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)))
     transitivePeerDependencies:
       - supports-color
 
-  remix-auth-oauth2@1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))):
+  remix-auth-oauth2@1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))):
     dependencies:
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
-      debug: 4.4.1(supports-color@10.0.0)
-      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
+      debug: 4.4.3(supports-color@10.0.0)
+      remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))
     transitivePeerDependencies:
       - supports-color
 
-  remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)):
+  remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)):
     dependencies:
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       uuid: 8.3.2
 
-  remix-typedjson@0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(react@18.2.0):
+  remix-typedjson@0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(react@18.2.0):
     dependencies:
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
-      '@remix-run/server-runtime': 2.1.0(typescript@5.9.3)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
+      '@remix-run/server-runtime': 2.1.0(typescript@5.5.4)
       react: 18.2.0
 
-  remix-utils@7.7.0(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76):
+  remix-utils@7.7.0(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76):
     dependencies:
       type-fest: 4.33.0
     optionalDependencies:
-      '@remix-run/node': 2.1.0(typescript@5.9.3)
-      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)
+      '@remix-run/node': 2.1.0(typescript@5.5.4)
+      '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)
       '@remix-run/router': 1.15.3
       crypto-js: 4.2.0
       intl-parse-accept-language: 1.0.0
@@ -39494,7 +40127,7 @@ snapshots:
       mime-types: 2.1.35
       oauth-sign: 0.9.0
       performance-now: 2.1.0
-      qs: 6.5.3
+      qs: 6.14.1
       safe-buffer: 5.2.1
       tough-cookie: 2.5.0
       tunnel-agent: 0.6.0
@@ -39506,7 +40139,7 @@ snapshots:
 
   require-in-the-middle@7.1.1(supports-color@10.0.0):
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       module-details-from-path: 1.0.3
       resolve: 1.22.8
     transitivePeerDependencies:
@@ -39558,6 +40191,8 @@ snapshots:
       onetime: 5.1.2
       signal-exit: 3.0.7
 
+  ret@0.1.15: {}
+
   ret@0.5.0: {}
 
   retry@0.12.0: {}
@@ -39633,9 +40268,19 @@ snapshots:
       parseurl: 1.3.3
       path-to-regexp: 8.2.0
 
+  router@2.2.0:
+    dependencies:
+      debug: 4.4.3(supports-color@10.0.0)
+      depd: 2.0.0
+      is-promise: 4.0.0
+      parseurl: 1.3.3
+      path-to-regexp: 8.2.0
+    transitivePeerDependencies:
+      - supports-color
+
   rtl-css-js@1.16.1:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   run-applescript@7.0.0: {}
 
@@ -39662,7 +40307,7 @@ snapshots:
 
   safe-array-concat@1.1.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       get-intrinsic: 1.3.0
       has-symbols: 1.1.0
       isarray: 2.0.5
@@ -39673,13 +40318,13 @@ snapshots:
 
   safe-regex-test@1.0.0:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       get-intrinsic: 1.3.0
       is-regex: 1.1.4
 
   safe-regex-test@1.0.3:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       is-regex: 1.1.4
 
@@ -39731,8 +40376,6 @@ snapshots:
       '@types/semver': 6.2.3
       semver: 6.3.1
 
-  semver-compare@1.0.0: {}
-
   semver@5.7.1: {}
 
   semver@6.3.1: {}
@@ -39781,7 +40424,7 @@ snapshots:
 
   send@1.1.0(supports-color@10.0.0):
     dependencies:
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       destroy: 1.2.0
       encodeurl: 2.0.0
       escape-html: 1.0.3
@@ -39796,6 +40439,22 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  send@1.2.1:
+    dependencies:
+      debug: 4.4.3(supports-color@10.0.0)
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 2.0.0
+      http-errors: 2.0.1
+      mime-types: 3.0.2
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
   serialize-javascript@6.0.1:
     dependencies:
       randombytes: 2.1.0
@@ -39822,6 +40481,15 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  serve-static@2.2.1:
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 1.2.1
+    transitivePeerDependencies:
+      - supports-color
+
   set-blocking@2.0.0: {}
 
   set-cookie-parser@2.6.0: {}
@@ -40099,7 +40767,7 @@ snapshots:
   socks-proxy-agent@8.0.5:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       socks: 2.8.3
     transitivePeerDependencies:
       - supports-color
@@ -40171,10 +40839,17 @@ snapshots:
 
   sprintf-js@1.0.3: {}
 
+  sprintf-js@1.1.2: {}
+
   sprintf-js@1.1.3: {}
 
   sqids@0.3.0: {}
 
+  sql-formatter@15.6.12:
+    dependencies:
+      argparse: 2.0.1
+      nearley: 2.20.1
+
   sqs-consumer@7.5.0(@aws-sdk/client-sqs@3.454.0):
     dependencies:
       '@aws-sdk/client-sqs': 3.454.0
@@ -40211,11 +40886,6 @@ snapshots:
     dependencies:
       minipass: 7.1.2
 
-  sswr@2.1.0(svelte@5.43.6):
-    dependencies:
-      svelte: 5.43.6
-      swrev: 4.0.0
-
   stack-generator@2.0.10:
     dependencies:
       stackframe: 1.3.4
@@ -40243,6 +40913,8 @@ snapshots:
 
   statuses@2.0.1: {}
 
+  statuses@2.0.2: {}
+
   std-env@3.7.0: {}
 
   std-env@3.8.1: {}
@@ -40259,6 +40931,26 @@ snapshots:
     dependencies:
       mixme: 0.5.4
 
+  streamdown@1.4.0(@types/react@18.2.69)(react@18.2.0):
+    dependencies:
+      clsx: 2.1.1
+      katex: 0.16.25
+      lucide-react: 0.542.0(react@18.2.0)
+      marked: 16.4.1
+      mermaid: 11.12.0
+      react: 18.2.0
+      react-markdown: 10.1.0(@types/react@18.2.69)(react@18.2.0)
+      rehype-harden: 1.1.5
+      rehype-katex: 7.0.1
+      rehype-raw: 7.0.0
+      remark-gfm: 4.0.1
+      remark-math: 6.0.0
+      shiki: 3.13.0
+      tailwind-merge: 3.3.1
+    transitivePeerDependencies:
+      - '@types/react'
+      - supports-color
+
   streamdown@1.4.0(@types/react@19.0.12)(react@19.1.0):
     dependencies:
       clsx: 2.1.1
@@ -40306,8 +40998,8 @@ snapshots:
 
   string.prototype.matchall@4.0.8:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
       get-intrinsic: 1.3.0
       has-symbols: 1.1.0
@@ -40323,32 +41015,32 @@ snapshots:
 
   string.prototype.trim@1.2.9:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-abstract: 1.23.3
       es-object-atoms: 1.1.1
 
   string.prototype.trimend@1.0.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   string.prototype.trimend@1.0.8:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-object-atoms: 1.1.1
 
   string.prototype.trimstart@1.0.6:
     dependencies:
-      call-bind: 1.0.7
-      define-properties: 1.1.4
+      call-bind: 1.0.8
+      define-properties: 1.2.1
       es-abstract: 1.21.1
 
   string.prototype.trimstart@1.0.8:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       define-properties: 1.2.1
       es-object-atoms: 1.1.1
 
@@ -40379,6 +41071,8 @@ snapshots:
 
   strip-final-newline@3.0.0: {}
 
+  strip-final-newline@4.0.0: {}
+
   strip-indent@3.0.0:
     dependencies:
       min-indent: 1.0.1
@@ -40400,8 +41094,6 @@ snapshots:
     dependencies:
       webpack: 5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)
 
-  style-mod@4.0.0: {}
-
   style-mod@4.1.3: {}
 
   style-to-js@1.1.16:
@@ -40449,13 +41141,13 @@ snapshots:
     dependencies:
       component-emitter: 1.3.1
       cookiejar: 2.1.4
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       fast-safe-stringify: 2.1.1
       form-data: 4.0.4
       formidable: 3.5.1
       methods: 1.1.2
       mime: 2.6.0
-      qs: 6.11.0
+      qs: 6.14.1
     transitivePeerDependencies:
       - supports-color
 
@@ -40497,23 +41189,6 @@ snapshots:
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
-  svelte@5.43.6:
-    dependencies:
-      '@jridgewell/remapping': 2.3.5
-      '@jridgewell/sourcemap-codec': 1.5.5
-      '@sveltejs/acorn-typescript': 1.0.6(acorn@8.15.0)
-      '@types/estree': 1.0.8
-      acorn: 8.15.0
-      aria-query: 5.3.2
-      axobject-query: 4.1.0
-      clsx: 2.1.1
-      esm-env: 1.2.2
-      esrap: 2.1.2
-      is-reference: 3.0.3
-      locate-character: 3.0.0
-      magic-string: 0.30.21
-      zimmerframe: 1.1.4
-
   swr@2.2.5(react@18.2.0):
     dependencies:
       client-only: 0.0.1
@@ -40532,18 +41207,6 @@ snapshots:
       react: 19.0.0
       use-sync-external-store: 1.2.2(react@19.0.0)
 
-  swr@2.2.5(react@19.1.0):
-    dependencies:
-      client-only: 0.0.1
-      react: 19.1.0
-      use-sync-external-store: 1.2.2(react@19.1.0)
-
-  swrev@4.0.0: {}
-
-  swrv@1.0.4(vue@3.5.24(typescript@5.9.3)):
-    dependencies:
-      vue: 3.5.24(typescript@5.9.3)
-
   sync-content@2.0.1:
     dependencies:
       glob: 11.0.0
@@ -40557,7 +41220,7 @@ snapshots:
       '@pkgr/utils': 2.3.1
       tslib: 2.8.1
 
-  systeminformation@5.23.8: {}
+  systeminformation@5.27.14: {}
 
   table@6.9.0:
     dependencies:
@@ -40571,7 +41234,7 @@ snapshots:
 
   tailwind-merge@2.2.0:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   tailwind-merge@2.5.3: {}
 
@@ -40610,7 +41273,7 @@ snapshots:
       detective: 5.2.1
       fs-extra: 8.1.0
       html-tags: 3.3.1
-      lodash: 4.17.21
+      lodash: 4.17.23
       node-emoji: 1.11.0
       normalize.css: 8.0.1
       object-hash: 2.2.0
@@ -40682,8 +41345,6 @@ snapshots:
 
   tapable@2.2.1: {}
 
-  tapable@2.2.2: {}
-
   tapable@2.3.0: {}
 
   tar-fs@2.1.3:
@@ -40721,7 +41382,7 @@ snapshots:
       end-of-stream: 1.4.4
       fs-constants: 1.0.0
       inherits: 2.0.4
-      readable-stream: 3.6.0
+      readable-stream: 3.6.2
 
   tar-stream@3.1.7:
     dependencies:
@@ -40758,6 +41419,14 @@ snapshots:
       mkdirp: 3.0.1
       yallist: 5.0.0
 
+  tar@7.5.6:
+    dependencies:
+      '@isaacs/fs-minipass': 4.0.1
+      chownr: 3.0.0
+      minipass: 7.1.2
+      minizlib: 3.1.0
+      yallist: 5.0.0
+
   tdigest@0.1.2:
     dependencies:
       bintrees: 1.0.2
@@ -40782,22 +41451,15 @@ snapshots:
       jest-worker: 27.5.1
       schema-utils: 3.3.0
       serialize-javascript: 6.0.1
-      terser: 5.17.1
+      terser: 5.44.1
       webpack: 5.88.2(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11)
     optionalDependencies:
       '@swc/core': 1.3.101(@swc/helpers@0.5.15)
       esbuild: 0.19.11
 
-  terser@5.17.1:
-    dependencies:
-      '@jridgewell/source-map': 0.3.3
-      acorn: 8.14.1
-      commander: 2.20.3
-      source-map-support: 0.5.21
-
   terser@5.44.1:
     dependencies:
-      '@jridgewell/source-map': 0.3.11
+      '@jridgewell/source-map': 0.3.3
       acorn: 8.15.0
       commander: 2.20.3
       source-map-support: 0.5.21
@@ -40979,14 +41641,16 @@ snapshots:
 
   ts-easing@0.2.0: {}
 
-  ts-essentials@10.0.1(typescript@5.9.3):
+  ts-essentials@10.0.1(typescript@5.5.4):
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   ts-expose-internals-conditionally@1.0.0-empty.0: {}
 
   ts-interface-checker@0.1.13: {}
 
+  ts-pattern@3.3.5: {}
+
   ts-poet@6.6.0:
     dependencies:
       dprint-node: 1.0.8
@@ -41009,13 +41673,9 @@ snapshots:
     optionalDependencies:
       typescript: 5.5.4
 
-  tsconfck@2.1.2(typescript@5.9.3):
+  tsconfck@3.1.3(typescript@5.5.4):
     optionalDependencies:
-      typescript: 5.9.3
-
-  tsconfck@3.1.3(typescript@5.9.3):
-    optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   tsconfig-paths@3.14.1:
     dependencies:
@@ -41061,7 +41721,7 @@ snapshots:
 
   tslib@2.8.1: {}
 
-  tsup@8.4.0(@swc/core@1.3.101(@swc/helpers@0.5.15))(jiti@2.4.2)(postcss@8.5.6)(tsx@4.17.0)(typescript@5.9.3)(yaml@2.7.1):
+  tsup@8.4.0(@swc/core@1.3.101(@swc/helpers@0.5.15))(jiti@2.4.2)(postcss@8.5.6)(tsx@4.17.0)(typescript@5.5.4)(yaml@2.7.1):
     dependencies:
       bundle-require: 5.1.0(esbuild@0.25.1)
       cac: 6.7.14
@@ -41082,17 +41742,17 @@ snapshots:
     optionalDependencies:
       '@swc/core': 1.3.101(@swc/helpers@0.5.15)
       postcss: 8.5.6
-      typescript: 5.9.3
+      typescript: 5.5.4
     transitivePeerDependencies:
       - jiti
       - supports-color
       - tsx
       - yaml
 
-  tsutils@3.21.0(typescript@5.9.3):
+  tsutils@3.21.0(typescript@5.5.4):
     dependencies:
       tslib: 1.14.1
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   tsx@3.12.2:
     dependencies:
@@ -41204,15 +41864,21 @@ snapshots:
       media-typer: 1.1.0
       mime-types: 3.0.0
 
+  type-is@2.0.1:
+    dependencies:
+      content-type: 1.0.5
+      media-typer: 1.1.0
+      mime-types: 3.0.0
+
   typed-array-buffer@1.0.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       es-errors: 1.3.0
       is-typed-array: 1.1.13
 
   typed-array-byte-length@1.0.1:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       for-each: 0.3.3
       gopd: 1.2.0
       has-proto: 1.0.3
@@ -41221,7 +41887,7 @@ snapshots:
   typed-array-byte-offset@1.0.2:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       for-each: 0.3.3
       gopd: 1.2.0
       has-proto: 1.0.3
@@ -41229,13 +41895,13 @@ snapshots:
 
   typed-array-length@1.0.4:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       for-each: 0.3.3
-      is-typed-array: 1.1.10
+      is-typed-array: 1.1.13
 
   typed-array-length@1.0.6:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       for-each: 0.3.3
       gopd: 1.2.0
       has-proto: 1.0.3
@@ -41248,14 +41914,8 @@ snapshots:
 
   typed-query-selector@2.12.0: {}
 
-  typescript@5.1.6: {}
-
-  typescript@5.3.3: {}
-
   typescript@5.5.4: {}
 
-  typescript@5.9.3: {}
-
   ufo@1.5.4: {}
 
   ufo@1.6.1: {}
@@ -41272,7 +41932,7 @@ snapshots:
 
   unbox-primitive@1.0.2:
     dependencies:
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       has-bigints: 1.0.2
       has-symbols: 1.1.0
       which-boxed-primitive: 1.0.2
@@ -41281,20 +41941,16 @@ snapshots:
 
   undici-types@5.26.5: {}
 
-  undici-types@6.20.0: {}
-
-  undici@5.28.4:
-    dependencies:
-      '@fastify/busboy': 2.0.0
-
   undici@5.29.0:
     dependencies:
-      '@fastify/busboy': 2.0.0
+      '@fastify/busboy': 2.1.1
 
   unicode-emoji-modifier-base@1.0.0: {}
 
   unicorn-magic@0.1.0: {}
 
+  unicorn-magic@0.3.0: {}
+
   unified@10.1.2:
     dependencies:
       '@types/unist': 2.0.6
@@ -41424,7 +42080,7 @@ snapshots:
       escalade: 3.2.0
       picocolors: 1.1.1
 
-  uploadthing@7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1):
+  uploadthing@7.1.0(express@5.2.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1):
     dependencies:
       '@effect/platform': 0.63.2(@effect/schema@0.72.2(effect@3.7.2))(effect@3.7.2)
       '@effect/schema': 0.72.2(effect@3.7.2)
@@ -41432,7 +42088,7 @@ snapshots:
       '@uploadthing/shared': 7.0.3
       effect: 3.7.2
     optionalDependencies:
-      express: 5.0.1(supports-color@10.0.0)
+      express: 5.2.1
       fastify: 5.4.0
       next: 14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1)
       tailwindcss: 3.4.1
@@ -41454,6 +42110,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  use-callback-ref@1.3.3(@types/react@18.2.69)(react@18.3.1):
+    dependencies:
+      react: 18.3.1
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   use-callback-ref@1.3.3(@types/react@18.3.1)(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -41475,6 +42138,14 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.2.69
 
+  use-sidecar@1.1.3(@types/react@18.2.69)(react@18.3.1):
+    dependencies:
+      detect-node-es: 1.1.0
+      react: 18.3.1
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 18.2.69
+
   use-sidecar@1.1.3(@types/react@18.3.1)(react@18.3.1):
     dependencies:
       detect-node-es: 1.1.0
@@ -41495,10 +42166,6 @@ snapshots:
     dependencies:
       react: 19.0.0
 
-  use-sync-external-store@1.2.2(react@19.1.0):
-    dependencies:
-      react: 19.1.0
-
   util-deprecate@1.0.2: {}
 
   util@0.12.5:
@@ -41506,8 +42173,8 @@ snapshots:
       inherits: 2.0.4
       is-arguments: 1.1.1
       is-generator-function: 1.0.10
-      is-typed-array: 1.1.10
-      which-typed-array: 1.1.9
+      is-typed-array: 1.1.13
+      which-typed-array: 1.1.15
 
   utils-merge@1.0.1: {}
 
@@ -41530,9 +42197,9 @@ snapshots:
       kleur: 4.1.5
       sade: 1.8.1
 
-  valibot@1.1.0(typescript@5.9.3):
+  valibot@1.1.0(typescript@5.5.4):
     optionalDependencies:
-      typescript: 5.9.3
+      typescript: 5.5.4
 
   validate-npm-package-license@3.0.4:
     dependencies:
@@ -41608,16 +42275,16 @@ snapshots:
       d3-time: 3.1.0
       d3-timer: 3.0.1
 
-  vite-node@0.28.5(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1):
+  vite-node@0.28.5(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       mlly: 1.7.4
       pathe: 1.1.2
       picocolors: 1.1.1
       source-map: 0.6.1
       source-map-support: 0.5.21
-      vite: 4.4.9(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1)
+      vite: 4.4.9(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
     transitivePeerDependencies:
       - '@types/node'
       - less
@@ -41631,7 +42298,7 @@ snapshots:
   vite-node@3.1.4(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.1(supports-color@10.0.0)
+      debug: 4.4.3(supports-color@10.0.0)
       es-module-lexer: 1.7.0
       pathe: 2.0.3
       vite: 5.4.21(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1)
@@ -41655,22 +42322,13 @@ snapshots:
       - supports-color
       - typescript
 
-  vite-tsconfig-paths@4.0.5(typescript@5.9.3):
-    dependencies:
-      debug: 4.3.7(supports-color@10.0.0)
-      globrex: 0.1.2
-      tsconfck: 2.1.2(typescript@5.9.3)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-
-  vite@4.4.9(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1):
+  vite@4.4.9(@types/node@20.14.14)(lightningcss@1.29.2)(terser@5.44.1):
     dependencies:
       esbuild: 0.18.11
       postcss: 8.5.6
       rollup: 3.29.1
     optionalDependencies:
-      '@types/node': 22.13.9
+      '@types/node': 20.14.14
       fsevents: 2.3.3
       lightningcss: 1.29.2
       terser: 5.44.1
@@ -41696,9 +42354,9 @@ snapshots:
       '@vitest/spy': 3.1.4
       '@vitest/utils': 3.1.4
       chai: 5.2.0
-      debug: 4.4.0
+      debug: 4.4.1
       expect-type: 1.2.1
-      magic-string: 0.30.17
+      magic-string: 0.30.21
       pathe: 2.0.3
       std-env: 3.9.0
       tinybench: 2.9.0
@@ -41740,18 +42398,6 @@ snapshots:
 
   vscode-uri@3.0.8: {}
 
-  vue@3.5.24(typescript@5.9.3):
-    dependencies:
-      '@vue/compiler-dom': 3.5.24
-      '@vue/compiler-sfc': 3.5.24
-      '@vue/runtime-dom': 3.5.24
-      '@vue/server-renderer': 3.5.24(vue@3.5.24(typescript@5.9.3))
-      '@vue/shared': 3.5.24
-    optionalDependencies:
-      typescript: 5.9.3
-
-  w3c-keyname@2.2.6: {}
-
   w3c-keyname@2.2.8: {}
 
   walk-up-path@4.0.0: {}
@@ -41793,7 +42439,7 @@ snapshots:
   webpack-bundle-analyzer@4.10.1(bufferutil@4.0.9):
     dependencies:
       '@discoveryjs/json-ext': 0.5.7
-      acorn: 8.14.1
+      acorn: 8.15.0
       acorn-walk: 8.3.2
       commander: 7.2.0
       debounce: 1.2.1
@@ -41848,12 +42494,12 @@ snapshots:
   webpack@5.88.2(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11):
     dependencies:
       '@types/eslint-scope': 3.7.4
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
       '@webassemblyjs/ast': 1.11.5
       '@webassemblyjs/wasm-edit': 1.11.5
       '@webassemblyjs/wasm-parser': 1.11.5
-      acorn: 8.14.1
-      acorn-import-assertions: 1.9.0(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-import-assertions: 1.9.0(acorn@8.15.0)
       browserslist: 4.24.4
       chrome-trace-event: 1.0.3
       enhanced-resolve: 5.18.3
@@ -41905,20 +42551,11 @@ snapshots:
   which-typed-array@1.1.15:
     dependencies:
       available-typed-arrays: 1.0.7
-      call-bind: 1.0.7
+      call-bind: 1.0.8
       for-each: 0.3.3
       gopd: 1.2.0
       has-tostringtag: 1.0.2
 
-  which-typed-array@1.1.9:
-    dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.7
-      for-each: 0.3.3
-      gopd: 1.2.0
-      has-tostringtag: 1.0.0
-      is-typed-array: 1.1.10
-
   which@1.3.1:
     dependencies:
       isexe: 2.0.0
@@ -42066,6 +42703,8 @@ snapshots:
 
   yocto-queue@1.1.1: {}
 
+  yoctocolors@2.1.2: {}
+
   yup@1.6.1:
     dependencies:
       property-expr: 2.0.6
@@ -42080,8 +42719,6 @@ snapshots:
       toposort: 2.0.2
       type-fest: 2.19.0
 
-  zimmerframe@1.1.4: {}
-
   zip-stream@6.0.1:
     dependencies:
       archiver-utils: 5.0.2
@@ -42092,10 +42729,6 @@ snapshots:
     dependencies:
       zod: 3.25.76
 
-  zod-to-json-schema@3.24.3(zod@3.25.76):
-    dependencies:
-      zod: 3.25.76
-
   zod-to-json-schema@3.24.5(zod@3.25.76):
     dependencies:
       zod: 3.25.76
@@ -42108,6 +42741,10 @@ snapshots:
     dependencies:
       zod: 3.25.76
 
+  zod-to-json-schema@3.25.1(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
   zod-validation-error@1.5.0(zod@3.25.76):
     dependencies:
       zod: 3.25.76
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index f5fecfce774..25f679f6bf0 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -11,6 +11,7 @@ minimumReleaseAgeExclude:
   - "@trigger.dev/platform"
   - "next"
   - "@next/*"
+  - "agentcrumbs"
 preferOffline: true
 
 linkWorkspacePackages: false
diff --git a/references/bun-catalog/src/trigger/bun.ts b/references/bun-catalog/src/trigger/bun.ts
index a5d14fa5b09..2f3e123c795 100644
--- a/references/bun-catalog/src/trigger/bun.ts
+++ b/references/bun-catalog/src/trigger/bun.ts
@@ -8,6 +8,8 @@ export const bunTask = task({
     const query = db.query("select 'Hello world' as message;");
     console.log(query.get()); // => { message: "Hello world" }
 
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
     return {
       message: "Query executed",
       bunVersion: Bun.version,
diff --git a/references/bun-catalog/trigger.config.ts b/references/bun-catalog/trigger.config.ts
index 67045bf8d50..fa791aa4558 100644
--- a/references/bun-catalog/trigger.config.ts
+++ b/references/bun-catalog/trigger.config.ts
@@ -2,7 +2,7 @@ import { defineConfig } from "@trigger.dev/sdk";
 
 export default defineConfig({
   runtime: "bun",
-  project: "proj_uxbxncnbsyamyxeqtucu",
+  project: process.env.TRIGGER_PROJECT_REF!,
   maxDuration: 3600,
   machine: "small-2x",
   retries: {
diff --git a/references/hello-world/package.json b/references/hello-world/package.json
index dea86c6b7af..dc9bff17310 100644
--- a/references/hello-world/package.json
+++ b/references/hello-world/package.json
@@ -6,8 +6,10 @@
     "trigger.dev": "workspace:*"
   },
   "dependencies": {
+    "@ai-sdk/openai": "^3.0.41",
     "@trigger.dev/build": "workspace:*",
     "@trigger.dev/sdk": "workspace:*",
+    "ai": "^6.0.116",
     "arktype": "^2.0.0",
     "openai": "^4.97.0",
     "puppeteer-core": "^24.15.0",
diff --git a/references/hello-world/src/trigger/agentRelay.ts b/references/hello-world/src/trigger/agentRelay.ts
new file mode 100644
index 00000000000..cead2408e66
--- /dev/null
+++ b/references/hello-world/src/trigger/agentRelay.ts
@@ -0,0 +1,252 @@
+import { logger, runs, streams, task, wait } from "@trigger.dev/sdk/v3";
+
+/**
+ * Multi-agent coordination via input streams.
+ *
+ * Demonstrates the pattern from the Agent Relay blog post: instead of a human
+ * copy-pasting context between agents, the agents talk to each other directly.
+ *
+ * Three "agents" (tasks) collaborate to write and review a document:
+ *   - Planner: breaks the work into steps and sends them to the worker
+ *   - Worker: executes each step, sends results to the reviewer
+ *   - Reviewer: checks each result, sends feedback back to the worker
+ *
+ * The coordinator task wires them together — no human in the loop.
+ */
+
+// -- Input streams for inter-agent communication --
+
+/** Coordinator → Agent: tells an agent who its peers are */
+const connect = streams.input<{ workerRunId: string }>({
+  id: "connect",
+});
+
+/** Planner → Worker: steps to execute */
+const planSteps = streams.input<{ step: number; instruction: string }>({
+  id: "plan-steps",
+});
+
+/** Planner → Worker: signal that all steps have been sent */
+const planComplete = streams.input<{ totalSteps: number }>({
+  id: "plan-complete",
+});
+
+/** Worker → Reviewer: completed work for review */
+const workResult = streams.input<{ step: number; output: string }>({
+  id: "work-result",
+});
+
+/** Reviewer → Worker: feedback on completed work */
+const reviewFeedback = streams.input<{
+  step: number;
+  approved: boolean;
+  comment: string;
+}>({
+  id: "review-feedback",
+});
+
+// -- Mock "AI" functions (replace with real LLM calls) --
+
+function mockPlan(topic: string) {
+  return [
+    { step: 1, instruction: `Research the topic: ${topic}` },
+    { step: 2, instruction: `Write an outline for: ${topic}` },
+    { step: 3, instruction: `Draft the introduction for: ${topic}` },
+  ];
+}
+
+function mockWork(instruction: string): string {
+  return `[Completed] ${instruction} — Lorem ipsum dolor sit amet.`;
+}
+
+function mockReview(output: string): { approved: boolean; comment: string } {
+  const approved = !output.includes("outline");
+  return {
+    approved,
+    comment: approved ? "Looks good." : "Needs more detail in the structure.",
+  };
+}
+
+// -- Agent tasks --
+
+/**
+ * Planner agent: receives a topic, breaks it into steps, sends them to the worker.
+ */
+export const plannerAgent = task({
+  id: "agent-planner",
+  run: async (payload: { topic: string; workerRunId: string }) => {
+    const steps = mockPlan(payload.topic);
+    logger.info("Planner: created plan", { stepCount: steps.length });
+
+    for (const step of steps) {
+      await planSteps.send(payload.workerRunId, step);
+      logger.info("Planner: sent step", { step: step.step });
+      await wait.for({ seconds: 1 });
+    }
+
+    await planComplete.send(payload.workerRunId, { totalSteps: steps.length });
+    logger.info("Planner: all steps sent");
+
+    return { steps: steps.length };
+  },
+});
+
+/**
+ * Worker agent: receives steps from the planner, executes them, sends results
+ * to the reviewer, and incorporates feedback.
+ */
+export const workerAgent = task({
+  id: "agent-worker",
+  run: async (payload: { reviewerRunId: string }) => {
+    const completedSteps: Array<{
+      step: number;
+      output: string;
+      feedback: string;
+    }> = [];
+
+    let totalSteps: number | null = null;
+    let stepsReceived = 0;
+
+    // Listen for plan completion signal
+    planComplete.on((data) => {
+      totalSteps = data.totalSteps;
+      logger.info("Worker: plan complete signal received", { totalSteps });
+    });
+
+    // Listen for review feedback
+    reviewFeedback.on((data) => {
+      logger.info("Worker: received feedback", { step: data.step, approved: data.approved });
+      const entry = completedSteps.find((s) => s.step === data.step);
+      if (entry) {
+        entry.feedback = data.comment;
+      }
+    });
+
+    // Process steps as they arrive
+    planSteps.on(async (data) => {
+      stepsReceived++;
+      logger.info("Worker: received step", { step: data.step, instruction: data.instruction });
+
+      const output = mockWork(data.instruction);
+      completedSteps.push({ step: data.step, output, feedback: "" });
+
+      // Send result to reviewer
+      await workResult.send(payload.reviewerRunId, { step: data.step, output });
+      logger.info("Worker: sent result to reviewer", { step: data.step });
+    });
+
+    // Wait until all steps are received and processed
+    while (totalSteps === null || stepsReceived < totalSteps) {
+      await wait.for({ seconds: 1 });
+    }
+
+    // Give reviewer time to send feedback
+    await wait.for({ seconds: 5 });
+
+    logger.info("Worker: all done", { completedSteps });
+    return { completedSteps };
+  },
+});
+
+/**
+ * Reviewer agent: receives work results, reviews them, sends feedback to the
+ * worker, and reports final results to the coordinator.
+ *
+ * The reviewer doesn't know the worker's run ID at spawn time — it receives
+ * it via the `connect` input stream once the coordinator has spawned both agents.
+ */
+export const reviewerAgent = task({
+  id: "agent-reviewer",
+  run: async (payload: { expectedSteps: number }) => {
+    // Wait for the coordinator to tell us who the worker is
+    const { workerRunId } = await connect.once({ timeoutMs: 30_000 }).unwrap();
+    logger.info("Reviewer: connected to worker", { workerRunId });
+
+    const reviews: Array<{ step: number; approved: boolean; comment: string }> = [];
+
+    // Review each piece of work as it arrives
+    workResult.on(async (data) => {
+      logger.info("Reviewer: checking step", { step: data.step });
+
+      const review = mockReview(data.output);
+      reviews.push({ step: data.step, ...review });
+
+      // Send feedback back to worker
+      await reviewFeedback.send(workerRunId, {
+        step: data.step,
+        ...review,
+      });
+      logger.info("Reviewer: sent feedback", { step: data.step, approved: review.approved });
+    });
+
+    // Wait until all steps are reviewed
+    while (reviews.length < payload.expectedSteps) {
+      await wait.for({ seconds: 1 });
+    }
+
+    const approved = reviews.filter((r) => r.approved).length;
+    const rejected = reviews.filter((r) => !r.approved).length;
+    const summary = `Reviewed ${reviews.length} steps. ${approved} approved, ${rejected} need revision.`;
+
+    logger.info("Reviewer: done", { summary });
+    return { reviews, summary };
+  },
+});
+
+/**
+ * Coordinator: wires the agents together and collects results.
+ *
+ * This is the orchestrator — it spawns the agents, connects them via input
+ * streams, and waits for everything to complete. No human in the loop.
+ */
+export const agentRelayCoordinator = task({
+  id: "agent-relay-coordinator",
+  run: async (payload: { topic?: string }) => {
+    const topic = payload.topic ?? "The future of multi-agent systems";
+    logger.info("Coordinator: starting multi-agent workflow", { topic });
+
+    // Spawn worker and reviewer (order doesn't matter — they wait for connections)
+    const reviewerHandle = await reviewerAgent.trigger({ expectedSteps: 3 });
+    const workerHandle = await workerAgent.trigger({
+      reviewerRunId: reviewerHandle.id,
+    });
+
+    logger.info("Coordinator: agents spawned", {
+      workerId: workerHandle.id,
+      reviewerId: reviewerHandle.id,
+    });
+
+    // Tell the reviewer who the worker is so it can send feedback
+    await connect.send(reviewerHandle.id, { workerRunId: workerHandle.id });
+
+    // Spawn the planner — it sends steps directly to the worker
+    const plannerHandle = await plannerAgent.trigger({
+      topic,
+      workerRunId: workerHandle.id,
+    });
+
+    logger.info("Coordinator: planner spawned, waiting for completion", {
+      plannerId: plannerHandle.id,
+    });
+
+    // Wait for all agents to complete
+    const [plannerRun, workerRun, reviewerRun] = await Promise.all([
+      runs.poll(plannerHandle, { pollIntervalMs: 2000 }),
+      runs.poll(workerHandle, { pollIntervalMs: 2000 }),
+      runs.poll(reviewerHandle, { pollIntervalMs: 2000 }),
+    ]);
+
+    logger.info("Coordinator: all agents complete", {
+      planner: plannerRun.output,
+      worker: workerRun.output,
+      reviewer: reviewerRun.output,
+    });
+
+    return {
+      topic,
+      planner: plannerRun.output,
+      worker: workerRun.output,
+      reviewer: reviewerRun.output,
+    };
+  },
+});
diff --git a/references/hello-world/src/trigger/batches.ts b/references/hello-world/src/trigger/batches.ts
index b48272962c9..b6a3f79e74e 100644
--- a/references/hello-world/src/trigger/batches.ts
+++ b/references/hello-world/src/trigger/batches.ts
@@ -1,4 +1,4 @@
-import { batch, logger, runs, task, tasks } from "@trigger.dev/sdk/v3";
+import { batch, BatchTriggerError, logger, runs, task, tasks } from "@trigger.dev/sdk/v3";
 import { setTimeout } from "timers/promises";
 
 // ============================================================================
@@ -344,6 +344,211 @@ export const batchTriggerAndWait = task({
   },
 });
 
+// ============================================================================
+// Rate Limit Error Testing
+// ============================================================================
+
+/**
+ * Test: Intentionally trigger a rate limit error to verify BatchTriggerError improvements
+ *
+ * This test triggers many batches in rapid succession to exceed the rate limit.
+ * When a rate limit is hit, it verifies that:
+ * 1. The error is a BatchTriggerError
+ * 2. The error has isRateLimited = true
+ * 3. The error message includes rate limit details
+ * 4. The retryAfterMs property is set
+ *
+ * Run this from backend code, not from inside a task (to avoid worker rate limits).
+ */
+export const rateLimitErrorTest = task({
+  id: "rate-limit-error-test",
+  maxDuration: 300,
+  run: async (payload: { batchesPerAttempt?: number; itemsPerBatch?: number }) => {
+    const batchesPerAttempt = payload.batchesPerAttempt || 50;
+    const itemsPerBatch = payload.itemsPerBatch || 100;
+
+    logger.info("Starting rate limit error test", {
+      batchesPerAttempt,
+      itemsPerBatch,
+      totalItems: batchesPerAttempt * itemsPerBatch,
+    });
+
+    const results: Array<{
+      batchIndex: number;
+      success: boolean;
+      batchId?: string;
+      error?: {
+        message: string;
+        name: string;
+        isRateLimited?: boolean;
+        retryAfterMs?: number;
+        phase?: string;
+      };
+    }> = [];
+
+    // Try to trigger many batches rapidly
+    const batchPromises = Array.from({ length: batchesPerAttempt }, async (_, batchIndex) => {
+      const items = Array.from({ length: itemsPerBatch }, (_, i) => ({
+        payload: { index: batchIndex * itemsPerBatch + i, testId: `rate-limit-test-${Date.now()}` },
+      }));
+
+      try {
+        const result = await retryTrackingTask.batchTrigger(items);
+        return {
+          batchIndex,
+          success: true as const,
+          batchId: result.batchId,
+        };
+      } catch (error) {
+        // Log the error details for inspection
+        if (error instanceof BatchTriggerError) {
+          logger.info(`BatchTriggerError caught for batch ${batchIndex}`, {
+            message: error.message,
+            name: error.name,
+            isRateLimited: error.isRateLimited,
+            retryAfterMs: error.retryAfterMs,
+            phase: error.phase,
+            batchId: error.batchId,
+            itemCount: error.itemCount,
+            cause: error.cause instanceof Error ? error.cause.message : String(error.cause),
+          });
+
+          return {
+            batchIndex,
+            success: false as const,
+            error: {
+              message: error.message,
+              name: error.name,
+              isRateLimited: error.isRateLimited,
+              retryAfterMs: error.retryAfterMs,
+              phase: error.phase,
+            },
+          };
+        }
+
+        // Non-BatchTriggerError
+        const err = error instanceof Error ? error : new Error(String(error));
+        logger.warn(`Non-BatchTriggerError caught for batch ${batchIndex}`, {
+          message: err.message,
+          name: err.name,
+        });
+
+        return {
+          batchIndex,
+          success: false as const,
+          error: {
+            message: err.message,
+            name: err.name,
+          },
+        };
+      }
+    });
+
+    // Wait for all attempts (use allSettled to capture all results)
+    const settled = await Promise.allSettled(batchPromises);
+
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        results.push({
+          batchIndex: -1,
+          success: false,
+          error: {
+            message: result.reason?.message || String(result.reason),
+            name: result.reason?.name || "Error",
+          },
+        });
+      }
+    }
+
+    // Analyze results
+    const successCount = results.filter((r) => r.success).length;
+    const rateLimitedCount = results.filter((r) => !r.success && r.error?.isRateLimited).length;
+    const otherErrorCount = results.filter((r) => !r.success && !r.error?.isRateLimited).length;
+
+    // Get a sample rate limit error for inspection
+    const sampleRateLimitError = results.find((r) => r.error?.isRateLimited)?.error;
+
+    return {
+      summary: {
+        totalBatches: batchesPerAttempt,
+        successCount,
+        rateLimitedCount,
+        otherErrorCount,
+      },
+      sampleRateLimitError: sampleRateLimitError || null,
+      allResults: results,
+      testPassed:
+        rateLimitedCount > 0 &&
+        sampleRateLimitError?.isRateLimited === true &&
+        typeof sampleRateLimitError?.retryAfterMs === "number",
+    };
+  },
+});
+
+/**
+ * Simpler test: Direct batch trigger that's likely to hit rate limits
+ *
+ * This test just tries to batch trigger a very large number of items in one call.
+ * If the organization has rate limits configured, this should trigger them.
+ */
+export const simpleBatchRateLimitTest = task({
+  id: "simple-batch-rate-limit-test",
+  maxDuration: 120,
+  run: async (payload: { itemCount?: number }) => {
+    const itemCount = payload.itemCount || 5000; // Large batch that might hit limits
+
+    logger.info("Starting simple batch rate limit test", { itemCount });
+
+    const items = Array.from({ length: itemCount }, (_, i) => ({
+      payload: { index: i, testId: `simple-rate-test-${Date.now()}` },
+    }));
+
+    try {
+      const result = await retryTrackingTask.batchTrigger(items);
+
+      logger.info("Batch succeeded (no rate limit hit)", {
+        batchId: result.batchId,
+        runCount: result.runCount,
+      });
+
+      return {
+        success: true,
+        batchId: result.batchId,
+        runCount: result.runCount,
+        rateLimitHit: false,
+      };
+    } catch (error) {
+      if (error instanceof BatchTriggerError) {
+        logger.info("BatchTriggerError caught", {
+          fullMessage: error.message,
+          isRateLimited: error.isRateLimited,
+          retryAfterMs: error.retryAfterMs,
+          phase: error.phase,
+          itemCount: error.itemCount,
+          apiErrorType: error.apiError?.constructor.name,
+        });
+
+        return {
+          success: false,
+          rateLimitHit: error.isRateLimited,
+          errorMessage: error.message,
+          errorDetails: {
+            phase: error.phase,
+            itemCount: error.itemCount,
+            isRateLimited: error.isRateLimited,
+            retryAfterMs: error.retryAfterMs,
+            hasApiError: !!error.apiError,
+          },
+        };
+      }
+
+      throw error; // Re-throw unexpected errors
+    }
+  },
+});
+
 // ============================================================================
 // Streaming Batch Examples
 // ============================================================================
@@ -484,6 +689,180 @@ export const simpleTask = task({
   },
 });
 
+// ============================================================================
+// Queue Option Tests
+// ============================================================================
+
+/**
+ * Task that runs in a specific queue for testing queue option handling.
+ */
+export const queuedTask = task({
+  id: "queued-task",
+  queue: {
+    name: "test-queue-for-batch",
+  },
+  run: async (payload: { index: number; testId: string }) => {
+    logger.info(`Processing queued task ${payload.index}`, { payload });
+    await setTimeout(100);
+    return {
+      index: payload.index,
+      testId: payload.testId,
+      processedAt: Date.now(),
+    };
+  },
+});
+
+/**
+ * Test: Batch trigger with queue option as object
+ *
+ * This test verifies that the queue option works correctly when passed
+ * through batch trigger. The SDK passes queue as { name: "queue-name" }
+ * which should be handled correctly by the server.
+ *
+ * This tests the fix for the double-wrapping bug where queue objects
+ * like { name: "queue-name", concurrencyLimit: 20 } could get wrapped
+ * into { name: { name: "queue-name", concurrencyLimit: 20 } }.
+ */
+export const batchTriggerWithQueueOption = task({
+  id: "batch-trigger-with-queue-option",
+  maxDuration: 120,
+  run: async (payload: { count: number; useObjectQueue?: boolean }) => {
+    const count = payload.count || 5;
+    const testId = `queue-test-${Date.now()}`;
+
+    // If useObjectQueue is true, we bypass the SDK types to send queue as an object
+    // This simulates what might happen if someone calls the API directly with wrong format
+    const queueValue = payload.useObjectQueue
+      ? ({ name: "test-queue-for-batch", concurrencyLimit: 20 } as unknown as string)
+      : "test-queue-for-batch";
+
+    // Generate batch items with queue option specified
+    const items = Array.from({ length: count }, (_, i) => ({
+      payload: { index: i, testId },
+      options: {
+        queue: queueValue,
+        // Also test with lockToVersion since the error showed workers.some.id
+        // which only appears in the lockedBackgroundWorker code path
+      },
+    }));
+
+    logger.info("Starting batch trigger with queue option", {
+      count,
+      testId,
+      useObjectQueue: payload.useObjectQueue,
+      queueValue,
+    });
+
+    // Trigger the batch with queue option
+    const result = await queuedTask.batchTrigger(items);
+
+    logger.info("Batch triggered successfully", {
+      batchId: result.batchId,
+      runCount: result.runCount,
+    });
+
+    // Wait for runs to complete
+    await setTimeout(5000);
+
+    // Retrieve batch to check results
+    const batchResult = await batch.retrieve(result.batchId);
+
+    return {
+      success: true,
+      batchId: result.batchId,
+      runCount: result.runCount,
+      batchStatus: batchResult.status,
+      testId,
+    };
+  },
+});
+
+/**
+ * Test: Batch triggerAndWait with queue option
+ *
+ * Similar to above but waits for all runs to complete.
+ */
+export const batchTriggerAndWaitWithQueueOption = task({
+  id: "batch-trigger-and-wait-with-queue-option",
+  maxDuration: 120,
+  run: async (payload: { count: number }) => {
+    const count = payload.count || 5;
+    const testId = `queue-wait-test-${Date.now()}`;
+
+    // Generate items with queue option
+    const items = Array.from({ length: count }, (_, i) => ({
+      payload: { index: i, testId },
+      options: {
+        queue: "test-queue-for-batch",
+      },
+    }));
+
+    logger.info("Starting batch triggerAndWait with queue option", { count, testId });
+
+    // Trigger and wait
+    const results = await queuedTask.batchTriggerAndWait(items);
+
+    const successCount = results.runs.filter((r) => r.ok).length;
+    const outputs = results.runs.filter((r) => r.ok).map((r) => (r.ok ? r.output : null));
+
+    return {
+      success: successCount === count,
+      successCount,
+      totalCount: count,
+      outputs,
+      testId,
+    };
+  },
+});
+
+/**
+ * Test: Streaming batch trigger with queue option
+ *
+ * Tests that streaming batches also work correctly with queue options.
+ */
+export const streamingBatchWithQueueOption = task({
+  id: "streaming-batch-with-queue-option",
+  maxDuration: 120,
+  run: async (payload: { count: number }) => {
+    const count = payload.count || 10;
+    const testId = `stream-queue-test-${Date.now()}`;
+
+    // Async generator that yields items with queue option
+    async function* generateItems() {
+      for (let i = 0; i < count; i++) {
+        yield {
+          payload: { index: i, testId },
+          options: {
+            queue: "test-queue-for-batch",
+          },
+        };
+      }
+    }
+
+    logger.info("Starting streaming batch with queue option", { count, testId });
+
+    // Trigger using the generator
+    const result = await queuedTask.batchTrigger(generateItems());
+
+    logger.info("Streaming batch triggered", {
+      batchId: result.batchId,
+      runCount: result.runCount,
+    });
+
+    // Wait and check results
+    await setTimeout(5000);
+    const batchResult = await batch.retrieve(result.batchId);
+
+    return {
+      success: true,
+      batchId: result.batchId,
+      runCount: result.runCount,
+      batchStatus: batchResult.status,
+      testId,
+    };
+  },
+});
+
 // ============================================================================
 // Large Payload Examples (R2 Offloading)
 // ============================================================================
@@ -620,6 +999,45 @@ export const largePayloadTask = task({
   },
 });
 
+// ============================================================================
+// Oversized Payload Graceful Handling
+// ============================================================================
+
+/**
+ * Test: Batch with oversized item should complete gracefully
+ *
+ * Sends 2 items: one normal, one oversized (~3.2MB).
+ * The oversized item should result in a pre-failed run (ok: false)
+ * while the normal item processes successfully (ok: true).
+ */
+export const batchSealFailureOversizedPayload = task({
+  id: "batch-seal-failure-oversized",
+  maxDuration: 60,
+  retry: {
+    maxAttempts: 1,
+  },
+  run: async () => {
+    const results = await fixedLengthTask.batchTriggerAndWait([
+      { payload: { waitSeconds: 1, output: "normal" } },
+      { payload: { waitSeconds: 1, output: "x".repeat(3_200_000) } }, // ~3.2MB oversized
+    ]);
+
+    const normal = results.runs[0];
+    const oversized = results.runs[1];
+
+    logger.info("Batch results", {
+      normalOk: normal?.ok,
+      oversizedOk: oversized?.ok,
+    });
+
+    return {
+      normalOk: normal?.ok === true,
+      oversizedOk: oversized?.ok === false,
+      oversizedError: !oversized?.ok ? oversized?.error : undefined,
+    };
+  },
+});
+
 type Payload = {
   waitSeconds: number;
   error?: string;
@@ -643,3 +1061,322 @@ export const fixedLengthTask = task({
     return output;
   },
 });
+
+// ============================================================================
+// Queue Size Limit Testing
+// ============================================================================
+// These tests verify that per-queue size limits are enforced correctly.
+//
+// To test:
+// 1. Set a low queue limit on the organization:
+//    UPDATE "Organization" SET "maximumDeployedQueueSize" = 5 WHERE slug = 'references-9dfd';
+// 2. Run these tasks to verify queue limits are enforced
+// 3. Reset the limit when done:
+//    UPDATE "Organization" SET "maximumDeployedQueueSize" = NULL WHERE slug = 'references-9dfd';
+// ============================================================================
+
+/**
+ * Simple task for queue limit testing.
+ * Has a dedicated queue so we can test per-queue limits independently.
+ */
+export const queueLimitTestTask = task({
+  id: "queue-limit-test-task",
+  queue: {
+    name: "queue-limit-test-queue",
+    concurrencyLimit: 1
+  },
+  run: async (payload: { index: number; testId: string }) => {
+    logger.info(`Processing queue limit test task ${payload.index}`, { payload });
+    // Sleep for a bit so runs stay in queue
+    await setTimeout(5000);
+    return {
+      index: payload.index,
+      testId: payload.testId,
+      processedAt: Date.now(),
+    };
+  },
+});
+
+/**
+ * Test: Single trigger that should fail when queue is at limit
+ *
+ * Steps to test:
+ * 1. Set maximumDeployedQueueSize = 5 on the organization
+ * 2. Run this task with count = 10
+ * 3. First 5 triggers should succeed
+ * 4. Remaining triggers should fail with queue limit error
+ */
+export const testSingleTriggerQueueLimit = task({
+  id: "test-single-trigger-queue-limit",
+  maxDuration: 120,
+  run: async (payload: { count: number }) => {
+    const count = payload.count || 10;
+    const testId = `single-trigger-limit-${Date.now()}`;
+
+    logger.info("Starting single trigger queue limit test", { count, testId });
+
+    const results: Array<{
+      index: number;
+      success: boolean;
+      runId?: string;
+      error?: string;
+    }> = [];
+
+    // Trigger tasks one by one
+    for (let i = 0; i < count; i++) {
+      try {
+        const handle = await queueLimitTestTask.trigger({
+          index: i,
+          testId,
+        });
+
+        results.push({
+          index: i,
+          success: true,
+          runId: handle.id,
+        });
+
+        logger.info(`Triggered task ${i} successfully`, { runId: handle.id });
+
+        await setTimeout(1000)
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({
+          index: i,
+          success: false,
+          error: errorMessage,
+        });
+
+        logger.warn(`Failed to trigger task ${i}`, { error: errorMessage });
+      }
+    }
+
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.filter((r) => !r.success).length;
+    const queueLimitErrors = results.filter(
+      (r) => !r.success && r.error?.includes("queue")
+    ).length;
+
+    return {
+      testId,
+      totalAttempts: count,
+      successCount,
+      failCount,
+      queueLimitErrors,
+      results,
+    };
+  },
+});
+
+/**
+ * Test: Batch trigger that should fail when queue limit would be exceeded
+ *
+ * Steps to test:
+ * 1. Set maximumDeployedQueueSize = 5 on the organization
+ * 2. Run this task with count = 10
+ * 3. The batch should be aborted because it would exceed the queue limit
+ */
+export const testBatchTriggerQueueLimit = task({
+  id: "test-batch-trigger-queue-limit",
+  maxDuration: 120,
+  run: async (payload: { count: number }) => {
+    const count = payload.count || 10;
+    const testId = `batch-trigger-limit-${Date.now()}`;
+
+    logger.info("Starting batch trigger queue limit test", { count, testId });
+
+    const items = Array.from({ length: count }, (_, i) => ({
+      payload: { index: i, testId },
+    }));
+
+    try {
+      const result = await queueLimitTestTask.batchTrigger(items);
+
+      logger.info("Batch triggered successfully (no limit hit)", {
+        batchId: result.batchId,
+        runCount: result.runCount,
+      });
+
+      // Wait a bit and check batch status
+      await setTimeout(2000);
+      const batchResult = await batch.retrieve(result.batchId);
+
+      return {
+        testId,
+        success: true,
+        batchId: result.batchId,
+        runCount: result.runCount,
+        batchStatus: batchResult.status,
+        queueLimitHit: false,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isQueueLimitError = errorMessage.toLowerCase().includes("queue");
+
+      logger.info("Batch trigger failed", {
+        error: errorMessage,
+        isQueueLimitError,
+      });
+
+      return {
+        testId,
+        success: false,
+        error: errorMessage,
+        queueLimitHit: isQueueLimitError,
+      };
+    }
+  },
+});
+
+/**
+ * Test: Batch triggerAndWait that should fail when queue limit would be exceeded
+ *
+ * Same as testBatchTriggerQueueLimit but uses batchTriggerAndWait.
+ * This tests the blocking batch path where the parent run is blocked
+ * until the batch completes.
+ *
+ * Steps to test:
+ * 1. Set maximumDevQueueSize = 5 on the organization
+ * 2. Run this task with count = 10
+ * 3. The batch should be aborted because it would exceed the queue limit
+ */
+export const testBatchTriggerAndWaitQueueLimit = task({
+  id: "test-batch-trigger-and-wait-queue-limit",
+  maxDuration: 120,
+  run: async (payload: { count: number }) => {
+    const count = payload.count || 10;
+    const testId = `batch-wait-limit-${Date.now()}`;
+
+    logger.info("Starting batch triggerAndWait queue limit test", { count, testId });
+
+    const items = Array.from({ length: count }, (_, i) => ({
+      payload: { index: i, testId },
+    }));
+
+    try {
+      const result = await queueLimitTestTask.batchTriggerAndWait(items);
+
+      logger.info("Batch triggerAndWait completed (no limit hit)", {
+        batchId: result.id,
+        runsCount: result.runs.length,
+      });
+
+      const successCount = result.runs.filter((r) => r.ok).length;
+      const failCount = result.runs.filter((r) => !r.ok).length;
+
+      return {
+        testId,
+        success: true,
+        batchId: result.id,
+        runsCount: result.runs.length,
+        successCount,
+        failCount,
+        queueLimitHit: false,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isQueueLimitError = errorMessage.toLowerCase().includes("queue");
+
+      logger.info("Batch triggerAndWait failed", {
+        error: errorMessage,
+        isQueueLimitError,
+      });
+
+      return {
+        testId,
+        success: false,
+        error: errorMessage,
+        queueLimitHit: isQueueLimitError,
+      };
+    }
+  },
+});
+
+/**
+ * Test: Batch trigger to multiple queues with different limits
+ *
+ * This tests that per-queue validation works correctly when batch items
+ * go to different queues. Some items may succeed while the queue that
+ * exceeds its limit causes the batch to abort.
+ */
+export const testMultiQueueBatchLimit = task({
+  id: "test-multi-queue-batch-limit",
+  maxDuration: 120,
+  run: async (payload: { countPerQueue: number }) => {
+    const countPerQueue = payload.countPerQueue || 5;
+    const testId = `multi-queue-limit-${Date.now()}`;
+
+    logger.info("Starting multi-queue batch limit test", { countPerQueue, testId });
+
+    // Create items that go to different queues
+    // queueLimitTestTask goes to "queue-limit-test-queue"
+    // simpleTask goes to its default queue "task/simple-task"
+    const items = [];
+
+    // Add items for the queue-limit-test-queue
+    for (let i = 0; i < countPerQueue; i++) {
+      items.push({
+        id: "queue-limit-test-task" as const,
+        payload: { index: i, testId },
+      });
+    }
+
+    // Add items for a different queue (simple-task uses default queue)
+    for (let i = 0; i < countPerQueue; i++) {
+      items.push({
+        id: "simple-task" as const,
+        payload: { message: `multi-queue-${i}` },
+      });
+    }
+
+    try {
+      const result = await batch.trigger<typeof queueLimitTestTask | typeof simpleTask>(items);
+
+      logger.info("Multi-queue batch triggered successfully", {
+        batchId: result.batchId,
+        runCount: result.runCount,
+      });
+
+      await setTimeout(2000);
+      const batchResult = await batch.retrieve(result.batchId);
+
+      return {
+        testId,
+        success: true,
+        batchId: result.batchId,
+        runCount: result.runCount,
+        batchStatus: batchResult.status,
+        queueLimitHit: false,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isQueueLimitError = errorMessage.toLowerCase().includes("queue");
+
+      logger.info("Multi-queue batch trigger failed", {
+        error: errorMessage,
+        isQueueLimitError,
+      });
+
+      return {
+        testId,
+        success: false,
+        error: errorMessage,
+        queueLimitHit: isQueueLimitError,
+      };
+    }
+  },
+});
+
+/**
+ * Helper task to check current queue size
+ */
+export const checkQueueSize = task({
+  id: "check-queue-size",
+  run: async () => {
+    // This task just reports - actual queue size check is done server-side
+    return {
+      note: "Check the webapp logs or database for queue size information",
+      hint: "Run: SELECT * FROM \"TaskRun\" WHERE queue = 'queue-limit-test-queue' AND status IN ('PENDING', 'EXECUTING');",
+    };
+  },
+});
diff --git a/references/hello-world/src/trigger/concurrencyKeys.ts b/references/hello-world/src/trigger/concurrencyKeys.ts
new file mode 100644
index 00000000000..7cdaf4847f9
--- /dev/null
+++ b/references/hello-world/src/trigger/concurrencyKeys.ts
@@ -0,0 +1,201 @@
+import { batch, logger, queue, task } from "@trigger.dev/sdk";
+import { setTimeout } from "node:timers/promises";
+
+// Queue with concurrency limit for CK tests
+const ckQueue = queue({
+  name: "ck-test-queue",
+  concurrencyLimit: 2,
+});
+
+// Worker task: simulates work with a concurrency key
+export const ckWorkerTask = task({
+  id: "ck-worker-task",
+  queue: ckQueue,
+  retry: { maxAttempts: 1 },
+  run: async (payload: { id: string; waitMs: number }) => {
+    const startedAt = Date.now();
+    logger.info(`CK worker ${payload.id} started`);
+    await setTimeout(payload.waitMs);
+    const completedAt = Date.now();
+    logger.info(`CK worker ${payload.id} completed`);
+    return { id: payload.id, startedAt, completedAt };
+  },
+});
+
+// Test 1: Multiple CKs should each get their own concurrency slot
+export const ckBasicTest = task({
+  id: "ck-basic-test",
+  retry: { maxAttempts: 1 },
+  maxDuration: 120,
+  run: async () => {
+    logger.info("Testing basic CK behavior: multiple CKs run concurrently");
+
+    // Trigger 3 runs with different CKs - all should be able to run
+    // because each CK gets its own concurrency tracking
+    const results = await batch.triggerAndWait([
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "user-1", waitMs: 3000 },
+        options: { concurrencyKey: "user-1" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "user-2", waitMs: 3000 },
+        options: { concurrencyKey: "user-2" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "user-3", waitMs: 3000 },
+        options: { concurrencyKey: "user-3" },
+      },
+    ]);
+
+    if (!results.runs.every((r) => r.ok)) {
+      throw new Error("Not all CK runs completed successfully");
+    }
+
+    const executions = results.runs
+      .map((r) => r.output)
+      .sort((a, b) => a.startedAt - b.startedAt);
+
+    logger.info("CK basic test executions", { executions });
+
+    return { executions };
+  },
+});
+
+// Test 2: Same CK should respect concurrency limit
+export const ckSameConcurrencyTest = task({
+  id: "ck-same-concurrency-test",
+  retry: { maxAttempts: 1 },
+  maxDuration: 120,
+  run: async () => {
+    logger.info("Testing same CK concurrency: runs with same CK respect queue limit");
+
+    // Trigger 4 runs all with the same CK
+    // Queue limit is 2, so at most 2 should run concurrently
+    const results = await batch.triggerAndWait([
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "same-1", waitMs: 4000 },
+        options: { concurrencyKey: "shared-key" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "same-2", waitMs: 4000 },
+        options: { concurrencyKey: "shared-key" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "same-3", waitMs: 4000 },
+        options: { concurrencyKey: "shared-key" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "same-4", waitMs: 4000 },
+        options: { concurrencyKey: "shared-key" },
+      },
+    ]);
+
+    if (!results.runs.every((r) => r.ok)) {
+      throw new Error("Not all same-CK runs completed successfully");
+    }
+
+    const executions = results.runs
+      .map((r) => r.output)
+      .sort((a, b) => a.startedAt - b.startedAt);
+
+    // Check max concurrent: with same CK and limit 2, should be <= 2
+    let maxConcurrent = 0;
+    for (const current of executions) {
+      const concurrent = executions.filter(
+        (e) =>
+          e.startedAt <= current.startedAt &&
+          e.completedAt > current.startedAt
+      ).length;
+      maxConcurrent = Math.max(maxConcurrent, concurrent);
+    }
+
+    logger.info("Same CK concurrency result", { maxConcurrent, executions });
+
+    if (maxConcurrent > 2) {
+      throw new Error(`Expected max 2 concurrent with same CK, got ${maxConcurrent}`);
+    }
+
+    return { executions, maxConcurrent };
+  },
+});
+
+// Test 3: Many CKs - the scenario that motivated the CK index
+export const ckManyKeysTest = task({
+  id: "ck-many-keys-test",
+  retry: { maxAttempts: 1 },
+  maxDuration: 180,
+  run: async () => {
+    logger.info("Testing many CKs: all should complete without starving");
+
+    // Trigger 20 runs each with a different CK
+    const items = Array.from({ length: 20 }, (_, i) => ({
+      id: ckWorkerTask.id,
+      payload: { id: `prospect-${i}`, waitMs: 2000 },
+      options: { concurrencyKey: `prospect-${i}` },
+    }));
+
+    const results = await batch.triggerAndWait(items);
+
+    const succeeded = results.runs.filter((r) => r.ok).length;
+    const failed = results.runs.filter((r) => !r.ok).length;
+
+    logger.info("Many CKs test result", { succeeded, failed, total: results.runs.length });
+
+    if (failed > 0) {
+      throw new Error(`${failed} of ${results.runs.length} runs failed`);
+    }
+
+    return { succeeded, total: results.runs.length };
+  },
+});
+
+// Test 4: Mixed CK and non-CK triggers on same queue
+export const ckMixedTest = task({
+  id: "ck-mixed-test",
+  retry: { maxAttempts: 1 },
+  maxDuration: 120,
+  run: async () => {
+    logger.info("Testing mixed CK and non-CK on same queue");
+
+    const results = await batch.triggerAndWait([
+      // Non-CK runs
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "no-ck-1", waitMs: 2000 },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "no-ck-2", waitMs: 2000 },
+      },
+      // CK runs
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "with-ck-1", waitMs: 2000 },
+        options: { concurrencyKey: "tenant-a" },
+      },
+      {
+        id: ckWorkerTask.id,
+        payload: { id: "with-ck-2", waitMs: 2000 },
+        options: { concurrencyKey: "tenant-b" },
+      },
+    ]);
+
+    const succeeded = results.runs.filter((r) => r.ok).length;
+    const failed = results.runs.filter((r) => !r.ok).length;
+
+    logger.info("Mixed test result", { succeeded, failed });
+
+    if (failed > 0) {
+      throw new Error(`${failed} runs failed in mixed CK/non-CK test`);
+    }
+
+    return { succeeded, total: results.runs.length };
+  },
+});
diff --git a/references/hello-world/src/trigger/debounce.ts b/references/hello-world/src/trigger/debounce.ts
index e396714eb8e..f0a7e8b6389 100644
--- a/references/hello-world/src/trigger/debounce.ts
+++ b/references/hello-world/src/trigger/debounce.ts
@@ -1056,3 +1056,159 @@ export const demonstrateTrailingWithMetadata = task({
     };
   },
 });
+
+/**
+ * Example 12: Debounce with maxDelay
+ *
+ * The maxDelay option limits how long a debounced run can be delayed.
+ * Even if triggers keep coming, the run will eventually execute after maxDelay
+ * from the first trigger. This is useful for scenarios where you want to
+ * debounce but also guarantee execution within a certain time window.
+ *
+ * Use case: Summarizing AI conversation threads that need to stay relatively
+ * up to date. You want to debounce as messages come in, but also guarantee
+ * the summary runs at least every 30 minutes.
+ */
+export const processConversationSummary = task({
+  id: "process-conversation-summary",
+  run: async (payload: { conversationId: string; messageCount: number }) => {
+    logger.info("Generating conversation summary", { payload });
+
+    // Simulate AI summarization work
+    await wait.for({ seconds: 2 });
+
+    logger.info("Conversation summary generated", {
+      conversationId: payload.conversationId,
+      messageCount: payload.messageCount,
+    });
+
+    return {
+      summarized: true,
+      conversationId: payload.conversationId,
+      messageCount: payload.messageCount,
+      summarizedAt: new Date().toISOString(),
+    };
+  },
+});
+
+/**
+ * Demonstrates maxDelay in action.
+ *
+ * This simulates a chat application where messages come in continuously.
+ * With just debounce, the summary task would keep getting delayed forever.
+ * With maxDelay: "30s", the summary will run at most 30 seconds after the first trigger,
+ * even if messages keep coming.
+ *
+ * Run this task and observe:
+ * - Messages trigger the summary task with debounce
+ * - Each trigger extends the delay by 5s
+ * - But maxDelay ensures execution happens within 30s of the first trigger
+ */
+export const simulateChatWithMaxWait = task({
+  id: "simulate-chat-with-max-wait",
+  run: async (payload: { conversationId?: string; simulateDelay?: number }) => {
+    const conversationId = payload.conversationId ?? "conv-123";
+    const delayBetweenMessages = payload.simulateDelay ?? 3000; // 3 seconds
+
+    logger.info("Starting chat simulation with maxDelay", {
+      conversationId,
+      delayBetweenMessages,
+    });
+
+    logger.info(
+      "Debounce delay is 5s, maxDelay is 30s. Messages arrive every 3s, so debounce would normally keep extending. But maxDelay ensures execution within 30s."
+    );
+
+    const handles: string[] = [];
+
+    // Simulate 15 messages over ~45 seconds
+    // Without maxDelay, the task would never run because each trigger resets the 5s delay
+    // With maxDelay: "30s", the task will run after 30 seconds from the first trigger
+    for (let i = 1; i <= 15; i++) {
+      logger.info(`Message ${i}/15 received`, { messageNumber: i });
+
+      const handle = await processConversationSummary.trigger(
+        {
+          conversationId,
+          messageCount: i,
+        },
+        {
+          debounce: {
+            key: `conversation-${conversationId}`,
+            delay: "5s",
+            mode: "trailing", // Use latest message count
+            maxDelay: "30s", // Ensure execution within 30s of first trigger
+          },
+        }
+      );
+
+      handles.push(handle.id);
+      logger.info(`Message ${i} triggered, run ID: ${handle.id}`, {
+        messageNumber: i,
+        runId: handle.id,
+      });
+
+      // Wait between messages (simulating real chat)
+      if (i < 15) {
+        await new Promise((resolve) => setTimeout(resolve, delayBetweenMessages));
+      }
+    }
+
+    const uniqueHandles = [...new Set(handles)];
+
+    logger.info("Chat simulation complete", {
+      totalMessages: 15,
+      uniqueRuns: uniqueHandles.length,
+      note:
+        "With maxDelay, runs should have been created periodically despite continuous triggering",
+    });
+
+    return {
+      conversationId,
+      totalMessages: 15,
+      uniqueRunsCreated: uniqueHandles.length,
+      runIds: uniqueHandles,
+      message:
+        "Due to maxDelay: '30s', the summary task runs periodically even with continuous triggers",
+    };
+  },
+});
+
+/**
+ * A simpler maxDelay example showing the basic usage pattern.
+ *
+ * This is the recommended pattern for using maxDelay:
+ * - delay: How long to wait after each trigger before executing
+ * - maxDelay: Maximum total wait time from the first trigger
+ */
+export const onNewMessage = task({
+  id: "on-new-message",
+  run: async (payload: { conversationId: string; message: string }) => {
+    logger.info("New message received", {
+      conversationId: payload.conversationId,
+      messagePreview: payload.message.substring(0, 50),
+    });
+
+    // Trigger summarization with debounce and maxDelay
+    const handle = await processConversationSummary.trigger(
+      {
+        conversationId: payload.conversationId,
+        messageCount: 1, // In real code, you'd track actual count
+      },
+      {
+        debounce: {
+          key: `summary-${payload.conversationId}`,
+          delay: "10s", // Wait 10s after last message before summarizing
+          mode: "trailing", // Use latest state
+          maxDelay: "5m", // But always summarize within 5 minutes
+        },
+      }
+    );
+
+    logger.info("Summary task triggered (debounced with maxDelay)", {
+      runId: handle.id,
+    });
+
+    return { summaryRunId: handle.id };
+  },
+});
diff --git a/references/hello-world/src/trigger/example.ts b/references/hello-world/src/trigger/example.ts
index 8ecfdb033ed..5e04f57144f 100644
--- a/references/hello-world/src/trigger/example.ts
+++ b/references/hello-world/src/trigger/example.ts
@@ -5,6 +5,7 @@ import { fixedLengthTask } from "./batches.js";
 
 export const helloWorldTask = task({
   id: "hello-world",
+  ttl: "10m",
   retry: {
     maxAttempts: 3,
     minTimeoutInMs: 500,
diff --git a/references/hello-world/src/trigger/idempotency.ts b/references/hello-world/src/trigger/idempotency.ts
index 55e3c0bc9cb..f45e6af14a2 100644
--- a/references/hello-world/src/trigger/idempotency.ts
+++ b/references/hello-world/src/trigger/idempotency.ts
@@ -1,4 +1,4 @@
-import { batch, idempotencyKeys, logger, task, timeout, usage, wait } from "@trigger.dev/sdk/v3";
+import { batch, idempotencyKeys, logger, runs, task, timeout, usage, wait } from "@trigger.dev/sdk/v3";
 import { setTimeout } from "timers/promises";
 import { childTask } from "./example.js";
 
@@ -301,3 +301,242 @@ export const idempotencyTriggerAndWaitWithInProgressRun = task({
     );
   },
 });
+
+// Test task for verifying idempotencyKeyOptions storage (TRI-4352)
+export const idempotencyKeyOptionsChild = task({
+  id: "idempotency-key-options-child",
+  run: async (payload: { message: string }, { ctx }) => {
+    // Log the idempotency key from context - should be the user-provided key, not the hash
+    logger.log("Child task context", {
+      idempotencyKey: ctx.run.idempotencyKey,
+      idempotencyKeyScope: ctx.run.idempotencyKeyScope,
+      runId: ctx.run.id,
+    });
+
+    return {
+      receivedIdempotencyKey: ctx.run.idempotencyKey,
+      receivedIdempotencyKeyScope: ctx.run.idempotencyKeyScope,
+      message: payload.message,
+    };
+  },
+});
+
+
+export const idempotencyKeyOptionsTest = task({
+  id: "idempotency-key-options-test",
+  maxDuration: 60,
+  run: async (payload: any, { ctx }) => {
+    logger.log("Testing idempotencyKeyOptions feature (TRI-4352)");
+
+    // Test 1: Create key with "run" scope (default)
+    const runScopedKey = await idempotencyKeys.create("my-run-scoped-key");
+    logger.log("Created run-scoped key", { key: runScopedKey.toString() });
+
+    const result1 = await idempotencyKeyOptionsChild.triggerAndWait(
+      { message: "Test with run scope" },
+      { idempotencyKey: runScopedKey, idempotencyKeyTTL: "60s" }
+    );
+    logger.log("Result 1 (run scope)", { result: result1 });
+
+    // Test 2: Create key with "global" scope
+    const globalScopedKey = await idempotencyKeys.create("my-global-scoped-key", {
+      scope: "global",
+    });
+    logger.log("Created global-scoped key", { key: globalScopedKey.toString() });
+
+    const result2 = await idempotencyKeyOptionsChild.triggerAndWait(
+      { message: "Test with global scope" },
+      { idempotencyKey: globalScopedKey, idempotencyKeyTTL: "60s" }
+    );
+    logger.log("Result 2 (global scope)", { result: result2 });
+
+    // Test 3: Create key with "attempt" scope
+    const attemptScopedKey = await idempotencyKeys.create("my-attempt-scoped-key", {
+      scope: "attempt",
+    });
+    logger.log("Created attempt-scoped key", { key: attemptScopedKey.toString() });
+
+    const result3 = await idempotencyKeyOptionsChild.triggerAndWait(
+      { message: "Test with attempt scope" },
+      { idempotencyKey: attemptScopedKey, idempotencyKeyTTL: "60s" }
+    );
+    logger.log("Result 3 (attempt scope)", { result: result3 });
+
+    // Test 4: Create key with array input
+    const arrayKey = await idempotencyKeys.create(["user", "123", "action"]);
+    logger.log("Created array key", { key: arrayKey.toString() });
+
+    const result4 = await idempotencyKeyOptionsChild.triggerAndWait(
+      { message: "Test with array key" },
+      { idempotencyKey: arrayKey, idempotencyKeyTTL: "60s" }
+    );
+    logger.log("Result 4 (array key)", { result: result4 });
+
+    return {
+      results: [
+        { scope: "run", idempotencyKey: result1.ok ? result1.output?.receivedIdempotencyKey : null },
+        {
+          scope: "global",
+          idempotencyKey: result2.ok ? result2.output?.receivedIdempotencyKey : null,
+        },
+        {
+          scope: "attempt",
+          idempotencyKey: result3.ok ? result3.output?.receivedIdempotencyKey : null,
+        },
+        { scope: "array", idempotencyKey: result4.ok ? result4.output?.receivedIdempotencyKey : null },
+      ],
+    };
+  },
+});
+
+// Test task for verifying idempotencyKeys.reset works with the new API (TRI-4352)
+export const idempotencyKeyResetTest = task({
+  id: "idempotency-key-reset-test",
+  maxDuration: 120,
+  run: async (payload: any, { ctx }) => {
+    logger.log("Testing idempotencyKeys.reset feature (TRI-4352)");
+
+    const testResults: Array<{
+      test: string;
+      success: boolean;
+      details: Record<string, unknown>;
+    }> = [];
+
+    // Test 1: Reset using IdempotencyKey object (options extracted automatically)
+    {
+      const key = await idempotencyKeys.create("reset-test-key-1", { scope: "global" });
+      logger.log("Test 1: Created global-scoped key", { key: key.toString() });
+
+      // First trigger - should create a new run
+      const result1 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "First trigger" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const firstRunId = result1.ok ? result1.id : null;
+      logger.log("Test 1: First trigger", { runId: firstRunId });
+
+      // Second trigger - should be deduplicated (same run ID)
+      const result2 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "Second trigger (should dedupe)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const secondRunId = result2.ok ? result2.id : null;
+      logger.log("Test 1: Second trigger (dedupe check)", { runId: secondRunId });
+
+      const wasDeduplicated = firstRunId === secondRunId;
+
+      // Reset the idempotency key using the IdempotencyKey object
+      logger.log("Test 1: Resetting idempotency key using IdempotencyKey object");
+      await idempotencyKeys.reset("idempotency-key-options-child", key);
+
+      // Third trigger - should create a NEW run after reset
+      const result3 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "Third trigger (after reset)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const thirdRunId = result3.ok ? result3.id : null;
+      logger.log("Test 1: Third trigger (after reset)", { runId: thirdRunId });
+
+      const wasResetSuccessful = thirdRunId !== firstRunId && thirdRunId !== null;
+
+      testResults.push({
+        test: "Reset with IdempotencyKey object (global scope)",
+        success: wasDeduplicated && wasResetSuccessful,
+        details: {
+          firstRunId,
+          secondRunId,
+          thirdRunId,
+          wasDeduplicated,
+          wasResetSuccessful,
+        },
+      });
+    }
+
+    // Test 2: Reset using raw string with scope option
+    {
+      const keyString = "reset-test-key-2";
+      const key = await idempotencyKeys.create(keyString, { scope: "global" });
+      logger.log("Test 2: Created global-scoped key from string", { key: key.toString() });
+
+      // First trigger
+      const result1 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "First trigger (raw string test)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const firstRunId = result1.ok ? result1.id : null;
+      logger.log("Test 2: First trigger", { runId: firstRunId });
+
+      // Reset using raw string + scope option
+      logger.log("Test 2: Resetting idempotency key using raw string + scope");
+      await idempotencyKeys.reset("idempotency-key-options-child", keyString, { scope: "global" });
+
+      // Second trigger - should create a NEW run after reset
+      const result2 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "Second trigger (after reset with raw string)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const secondRunId = result2.ok ? result2.id : null;
+      logger.log("Test 2: Second trigger (after reset)", { runId: secondRunId });
+
+      const wasResetSuccessful = secondRunId !== firstRunId && secondRunId !== null;
+
+      testResults.push({
+        test: "Reset with raw string + scope option (global scope)",
+        success: wasResetSuccessful,
+        details: {
+          firstRunId,
+          secondRunId,
+          wasResetSuccessful,
+        },
+      });
+    }
+
+    // Test 3: Reset with run scope (uses current run context)
+    {
+      const key = await idempotencyKeys.create("reset-test-key-3", { scope: "run" });
+      logger.log("Test 3: Created run-scoped key", { key: key.toString() });
+
+      // First trigger
+      const result1 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "First trigger (run scope)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const firstRunId = result1.ok ? result1.id : null;
+      logger.log("Test 3: First trigger", { runId: firstRunId });
+
+      // Reset using IdempotencyKey (run scope - should use current run context)
+      logger.log("Test 3: Resetting idempotency key with run scope");
+      await idempotencyKeys.reset("idempotency-key-options-child", key);
+
+      // Second trigger - should create a NEW run after reset
+      const result2 = await idempotencyKeyOptionsChild.triggerAndWait(
+        { message: "Second trigger (after reset, run scope)" },
+        { idempotencyKey: key, idempotencyKeyTTL: "300s" }
+      );
+      const secondRunId = result2.ok ? result2.id : null;
+      logger.log("Test 3: Second trigger (after reset)", { runId: secondRunId });
+
+      const wasResetSuccessful = secondRunId !== firstRunId && secondRunId !== null;
+
+      testResults.push({
+        test: "Reset with IdempotencyKey object (run scope)",
+        success: wasResetSuccessful,
+        details: {
+          firstRunId,
+          secondRunId,
+          wasResetSuccessful,
+          parentRunId: ctx.run.id,
+        },
+      });
+    }
+
+    // Summary
+    const allPassed = testResults.every((r) => r.success);
+    logger.log("Test summary", { allPassed, testResults });
+
+    return {
+      allPassed,
+      testResults,
+    };
+  },
+});
diff --git a/references/hello-world/src/trigger/inputStreams.ts b/references/hello-world/src/trigger/inputStreams.ts
new file mode 100644
index 00000000000..567c1738d7a
--- /dev/null
+++ b/references/hello-world/src/trigger/inputStreams.ts
@@ -0,0 +1,149 @@
+import { logger, runs, streams, task, wait } from "@trigger.dev/sdk/v3";
+
+// Define typed input streams
+const approvalStream = streams.input<{ approved: boolean; reviewer: string }>({
+  id: "approval",
+});
+
+const messageStream = streams.input<{ text: string }>({ id: "messages" });
+
+/**
+ * Coordinator task that exercises all input stream patterns end-to-end.
+ *
+ * 1a. .once().unwrap() — trigger a child, send data, verify unwrap returns TData
+ * 1b. .once() result  — trigger a child, send data, verify result object { ok, output }
+ * 2.  .on()            — trigger a child, send it multiple messages, poll until complete
+ * 3.  .wait()          — trigger a child, send it data (completes its waitpoint), poll until complete
+ * 4.  .wait() race     — send data before child calls .wait(), verify race handling
+ */
+export const inputStreamCoordinator = task({
+  id: "input-stream-coordinator",
+  run: async () => {
+    const results: Record<string, unknown> = {};
+
+    // --- Test 1a: .once() with .unwrap() ---
+    logger.info("Test 1a: .once().unwrap()");
+    const onceUnwrapHandle = await inputStreamOnceUnwrap.trigger({});
+    await wait.for({ seconds: 5 });
+    await approvalStream.send(onceUnwrapHandle.id, { approved: true, reviewer: "coordinator-unwrap" });
+    const onceUnwrapRun = await runs.poll(onceUnwrapHandle, { pollIntervalMs: 1000 });
+    results.onceUnwrap = onceUnwrapRun.output;
+    logger.info("Test 1a passed", { output: onceUnwrapRun.output });
+
+    // --- Test 1b: .once() with result object ---
+    logger.info("Test 1b: .once() result object");
+    const onceResultHandle = await inputStreamOnceResult.trigger({});
+    await wait.for({ seconds: 5 });
+    await approvalStream.send(onceResultHandle.id, { approved: true, reviewer: "coordinator-result" });
+    const onceResultRun = await runs.poll(onceResultHandle, { pollIntervalMs: 1000 });
+    results.onceResult = onceResultRun.output;
+    logger.info("Test 1b passed", { output: onceResultRun.output });
+
+    // --- Test 2: .on() with multiple messages ---
+    logger.info("Test 2: .on()");
+    const onHandle = await inputStreamOn.trigger({ messageCount: 3 });
+    await wait.for({ seconds: 5 });
+    for (let i = 0; i < 3; i++) {
+      await messageStream.send(onHandle.id, { text: `message-${i}` });
+      await wait.for({ seconds: 1 });
+    }
+    const onRun = await runs.poll(onHandle, { pollIntervalMs: 1000 });
+    results.on = onRun.output;
+    logger.info("Test 2 passed", { output: onRun.output });
+
+    // --- Test 3: .wait() (waitpoint-based) ---
+    logger.info("Test 3: .wait()");
+    const waitHandle = await inputStreamWait.trigger({ timeout: "1m" });
+    await wait.for({ seconds: 5 });
+    await approvalStream.send(waitHandle.id, { approved: true, reviewer: "coordinator-wait" });
+    const waitRun = await runs.poll(waitHandle, { pollIntervalMs: 1000 });
+    results.wait = waitRun.output;
+    logger.info("Test 3 passed", { output: waitRun.output });
+
+    // --- Test 4: .wait() race condition (send before child calls .wait()) ---
+    logger.info("Test 4: .wait() race");
+    const raceHandle = await inputStreamWait.trigger({ timeout: "1m" });
+    await approvalStream.send(raceHandle.id, { approved: false, reviewer: "race-test" });
+    const raceRun = await runs.poll(raceHandle, { pollIntervalMs: 1000 });
+    results.race = raceRun.output;
+    logger.info("Test 4 passed", { output: raceRun.output });
+
+    logger.info("All input stream tests passed", { results });
+    return results;
+  },
+});
+
+/**
+ * Uses .once().unwrap() — returns TData directly, throws InputStreamTimeoutError on timeout.
+ */
+export const inputStreamOnceUnwrap = task({
+  id: "input-stream-once-unwrap",
+  run: async (_payload: Record<string, never>) => {
+    logger.info("Waiting for approval via .once().unwrap()");
+
+    const approval = await approvalStream.once({ timeoutMs: 30_000 }).unwrap();
+
+    logger.info("Received approval", { approval });
+    return { approval };
+  },
+});
+
+/**
+ * Uses .once() with result object — check result.ok to handle timeout without try/catch.
+ */
+export const inputStreamOnceResult = task({
+  id: "input-stream-once-result",
+  run: async (_payload: Record<string, never>) => {
+    logger.info("Waiting for approval via .once() result object");
+
+    const result = await approvalStream.once({ timeoutMs: 30_000 });
+
+    if (!result.ok) {
+      logger.error("Timed out waiting for approval", { error: result.error.message });
+      return { approval: null, timedOut: true };
+    }
+
+    logger.info("Received approval", { approval: result.output });
+    return { approval: result.output };
+  },
+});
+
+/**
+ * Uses .on() to subscribe and collect multiple messages.
+ */
+export const inputStreamOn = task({
+  id: "input-stream-on",
+  run: async (payload: { messageCount?: number }) => {
+    const expected = payload.messageCount ?? 3;
+    const received: { text: string }[] = [];
+
+    logger.info("Subscribing to messages via .on()", { expected });
+
+    messageStream.on((data) => {
+      logger.info("Received message", { data });
+      received.push(data);
+    });
+
+    while (received.length < expected) {
+      await wait.for({ seconds: 1 });
+    }
+
+    logger.info("Done receiving messages", { count: received.length });
+    return { messages: received };
+  },
+});
+
+/**
+ * Uses .wait() to suspend the task via a waitpoint until data arrives.
+ */
+export const inputStreamWait = task({
+  id: "input-stream-wait",
+  run: async (payload: { timeout?: string }) => {
+    logger.info("Waiting for approval via .wait()");
+    const approval = await approvalStream.wait({
+      timeout: payload.timeout ?? "5m",
+    });
+    logger.info("Received approval via .wait()", { approval });
+    return { approval };
+  },
+});
diff --git a/references/hello-world/src/trigger/metrics.ts b/references/hello-world/src/trigger/metrics.ts
new file mode 100644
index 00000000000..fa398186b0b
--- /dev/null
+++ b/references/hello-world/src/trigger/metrics.ts
@@ -0,0 +1,326 @@
+import { batch, logger, otel, task } from "@trigger.dev/sdk";
+import { createHash } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+
+// Custom metrics — instruments are created once at module level
+const meter = otel.metrics.getMeter("hello-world");
+const itemsProcessedCounter = meter.createCounter("items.processed", {
+  description: "Total number of items processed",
+  unit: "items",
+});
+const itemDurationHistogram = meter.createHistogram("item.duration", {
+  description: "Time spent processing each item",
+  unit: "ms",
+});
+const queueDepthGauge = meter.createUpDownCounter("queue.depth", {
+  description: "Current simulated queue depth",
+  unit: "items",
+});
+
+/**
+ * Tight computational loop that produces sustained high CPU utilization.
+ * Uses repeated SHA-256 hashing to keep the CPU busy.
+ */
+export const cpuIntensive = task({
+  id: "cpu-intensive",
+  run: async (
+    {
+      durationSeconds = 60,
+    }: {
+      durationSeconds?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting CPU-intensive workload", { durationSeconds });
+
+    const deadline = Date.now() + durationSeconds * 1000;
+    let iterations = 0;
+    let data = Buffer.from("seed-data-for-hashing");
+
+    while (Date.now() < deadline) {
+      // Tight hashing loop — ~100ms chunks then yield to event loop
+      const chunkEnd = Date.now() + 100;
+      while (Date.now() < chunkEnd) {
+        data = createHash("sha256").update(data).digest();
+        iterations++;
+      }
+      // Yield to let metrics collection and heartbeats run
+      await setTimeout(1);
+    }
+
+    logger.info("CPU-intensive workload complete", { iterations });
+    return { iterations };
+  },
+});
+
+/**
+ * Progressively allocates memory in steps, holds it, then releases.
+ * Produces a staircase-shaped memory usage graph.
+ */
+export const memoryRamp = task({
+  id: "memory-ramp",
+  run: async (
+    {
+      steps = 6,
+      stepSizeMb = 50,
+      stepIntervalSeconds = 5,
+      holdSeconds = 15,
+    }: {
+      steps?: number;
+      stepSizeMb?: number;
+      stepIntervalSeconds?: number;
+      holdSeconds?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting memory ramp", { steps, stepSizeMb, stepIntervalSeconds, holdSeconds });
+
+    const allocations: Buffer[] = [];
+
+    // Ramp up — allocate in steps
+    for (let i = 0; i < steps; i++) {
+      const buf = Buffer.alloc(stepSizeMb * 1024 * 1024, 0xff);
+      allocations.push(buf);
+      logger.info(`Allocated step ${i + 1}/${steps}`, {
+        totalAllocatedMb: (i + 1) * stepSizeMb,
+      });
+      await setTimeout(stepIntervalSeconds * 1000);
+    }
+
+    // Hold at peak
+    logger.info("Holding at peak memory", { totalMb: steps * stepSizeMb });
+    await setTimeout(holdSeconds * 1000);
+
+    // Release
+    allocations.length = 0;
+    global.gc?.();
+    logger.info("Released all allocations");
+
+    // Let metrics capture the drop
+    await setTimeout(10_000);
+
+    logger.info("Memory ramp complete");
+    return { peakMb: steps * stepSizeMb };
+  },
+});
+
+/**
+ * Alternates between CPU-intensive bursts and idle sleep periods.
+ * Produces a sawtooth/square-wave CPU utilization pattern.
+ */
+export const burstyWorkload = task({
+  id: "bursty-workload",
+  run: async (
+    {
+      cycles = 5,
+      burstSeconds = 5,
+      idleSeconds = 5,
+    }: {
+      cycles?: number;
+      burstSeconds?: number;
+      idleSeconds?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting bursty workload", { cycles, burstSeconds, idleSeconds });
+
+    for (let cycle = 0; cycle < cycles; cycle++) {
+      // Burst phase — hash as fast as possible
+      logger.info(`Cycle ${cycle + 1}/${cycles}: burst phase`);
+      const burstDeadline = Date.now() + burstSeconds * 1000;
+      let data = Buffer.from(`burst-cycle-${cycle}`);
+      while (Date.now() < burstDeadline) {
+        const chunkEnd = Date.now() + 100;
+        while (Date.now() < chunkEnd) {
+          data = createHash("sha256").update(data).digest();
+        }
+        await setTimeout(1);
+      }
+
+      // Idle phase
+      logger.info(`Cycle ${cycle + 1}/${cycles}: idle phase`);
+      await setTimeout(idleSeconds * 1000);
+    }
+
+    logger.info("Bursty workload complete", { totalCycles: cycles });
+    return { cycles };
+  },
+});
+
+/**
+ * Simulates a data processing pipeline with distinct phases:
+ *   1. Read phase — light CPU, growing memory (buffering data)
+ *   2. Process phase — high CPU, stable memory (crunching data)
+ *   3. Write phase — low CPU, memory drops (streaming out results)
+ *
+ * Shows clear phase transitions in both CPU and memory graphs.
+ */
+export const sustainedWorkload = task({
+  id: "sustained-workload",
+  run: async (
+    {
+      readSeconds = 20,
+      processSeconds = 20,
+      writeSeconds = 20,
+      dataSizeMb = 100,
+    }: {
+      readSeconds?: number;
+      processSeconds?: number;
+      writeSeconds?: number;
+      dataSizeMb?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting sustained workload — read phase", { readSeconds, dataSizeMb });
+
+    // Phase 1: Read — gradually accumulate buffers (memory ramp, low CPU)
+    const chunks: Buffer[] = [];
+    const chunkCount = 10;
+    const chunkSize = Math.floor((dataSizeMb * 1024 * 1024) / chunkCount);
+    const readInterval = (readSeconds * 1000) / chunkCount;
+
+    for (let i = 0; i < chunkCount; i++) {
+      chunks.push(Buffer.alloc(chunkSize, i));
+      logger.info(`Read ${i + 1}/${chunkCount} chunks`);
+      await setTimeout(readInterval);
+    }
+
+    // Phase 2: Process — hash all chunks repeatedly (high CPU, stable memory)
+    logger.info("Entering process phase", { processSeconds });
+    const processDeadline = Date.now() + processSeconds * 1000;
+    let hashCount = 0;
+
+    while (Date.now() < processDeadline) {
+      const chunkEnd = Date.now() + 100;
+      while (Date.now() < chunkEnd) {
+        for (const chunk of chunks) {
+          createHash("sha256").update(chunk).digest();
+          hashCount++;
+        }
+      }
+      await setTimeout(1);
+    }
+
+    // Phase 3: Write — release memory gradually (low CPU, memory drops)
+    logger.info("Entering write phase", { writeSeconds });
+    const writeInterval = (writeSeconds * 1000) / chunkCount;
+
+    for (let i = chunkCount - 1; i >= 0; i--) {
+      chunks.pop();
+      logger.info(`Wrote and released chunk ${chunkCount - i}/${chunkCount}`);
+      await setTimeout(writeInterval);
+    }
+
+    global.gc?.();
+    await setTimeout(5000);
+
+    logger.info("Sustained workload complete", { hashCount });
+    return { hashCount };
+  },
+});
+
+/**
+ * Parent task that fans out multiple child tasks in parallel.
+ * Useful for seeing per-run breakdowns in metrics queries grouped by run_id.
+ */
+export const concurrentLoad = task({
+  id: "concurrent-load",
+  run: async (
+    {
+      concurrency = 3,
+      taskType = "bursty-workload" as "cpu-intensive" | "bursty-workload",
+      durationSeconds = 30,
+    }: {
+      concurrency?: number;
+      taskType?: "cpu-intensive" | "bursty-workload";
+      durationSeconds?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting concurrent load", { concurrency, taskType, durationSeconds });
+
+    const items = Array.from({ length: concurrency }, (_, i) => {
+      if (taskType === "cpu-intensive") {
+        return { id: cpuIntensive.id, payload: { durationSeconds } };
+      }
+      return {
+        id: burstyWorkload.id,
+        payload: { cycles: 3, burstSeconds: 5, idleSeconds: 5 },
+      };
+    });
+
+    const results = await batch.triggerAndWait<typeof cpuIntensive | typeof burstyWorkload>(items);
+
+    logger.info("All children completed", {
+      count: results.runs.length,
+    });
+
+    return { childRunIds: results.runs.map((r) => r.id) };
+  },
+});
+
+/**
+ * Demonstrates custom OTEL metrics: counter, histogram, and up-down counter.
+ * Simulates processing a queue of items with varying processing times.
+ */
+export const customMetrics = task({
+  id: "custom-metrics",
+  run: async (
+    {
+      itemCount = 20,
+      minProcessingMs = 50,
+      maxProcessingMs = 500,
+      batchSize = 5,
+    }: {
+      itemCount?: number;
+      minProcessingMs?: number;
+      maxProcessingMs?: number;
+      batchSize?: number;
+    },
+    { ctx }
+  ) => {
+    logger.info("Starting custom metrics demo", { itemCount, batchSize });
+
+    // Simulate items arriving in the queue
+    queueDepthGauge.add(itemCount);
+
+    let totalProcessed = 0;
+
+    for (let i = 0; i < itemCount; i += batchSize) {
+      const currentBatch = Math.min(batchSize, itemCount - i);
+
+      for (let j = 0; j < currentBatch; j++) {
+        const processingTime =
+          minProcessingMs + Math.random() * (maxProcessingMs - minProcessingMs);
+
+        // Simulate work
+        const start = performance.now();
+        let data = Buffer.from(`item-${i + j}`);
+        const deadline = Date.now() + processingTime;
+        while (Date.now() < deadline) {
+          data = createHash("sha256").update(data).digest();
+        }
+        const elapsed = performance.now() - start;
+
+        // Record metrics
+        itemsProcessedCounter.add(1, { "item.type": j % 2 === 0 ? "even" : "odd" });
+        itemDurationHistogram.record(elapsed, { "item.type": j % 2 === 0 ? "even" : "odd" });
+        queueDepthGauge.add(-1);
+
+        totalProcessed++;
+      }
+
+      logger.info(`Processed batch`, {
+        batchNumber: Math.floor(i / batchSize) + 1,
+        totalProcessed,
+        remaining: itemCount - totalProcessed,
+      });
+
+      // Brief pause between batches
+      await setTimeout(1000);
+    }
+
+    logger.info("Custom metrics demo complete", { totalProcessed });
+    return { totalProcessed };
+  },
+});
diff --git a/references/hello-world/src/trigger/prompts.ts b/references/hello-world/src/trigger/prompts.ts
new file mode 100644
index 00000000000..8d9c223317d
--- /dev/null
+++ b/references/hello-world/src/trigger/prompts.ts
@@ -0,0 +1,349 @@
+import { task, logger, prompts } from "@trigger.dev/sdk";
+import { generateText, generateObject, streamText, tool, stepCountIs } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { z } from "zod";
+
+// ─── Prompt definitions ──────────────────────────────────
+
+export const supportPrompt = prompts.define({
+  id: "customer-support",
+  description: "System prompt for great customer support interactions",
+  model: "gpt-4o",
+  config: { temperature: 0.7, maxTokens: 2000 },
+  variables: z.object({
+    customerName: z.string(),
+    plan: z.string(),
+    issue: z.string(),
+    previousMessages: z.string().optional(),
+  }),
+  content: `You are a senior customer support agent for Acme SaaS, a project management platform. You handle billing, account, and technical support inquiries with empathy and precision.
+
+## Customer context
+
+- **Name:** {{customerName}}
+- **Plan:** {{plan}}
+- **Reported issue:** {{issue}}
+
+## Your responsibilities
+
+1. **Diagnose the issue** — Ask clarifying questions if the problem is ambiguous. Do not guess.
+2. **Resolve when possible** — Use the tools provided (lookup_order, check_subscription, reset_password, issue_refund, update_billing) to take direct action.
+3. **Escalate when necessary** — If you cannot resolve the issue within your authority, use the escalate_to_human tool. Always include a summary of what you've already tried.
+
+## Guidelines
+
+### Tone and language
+- Address the customer by their first name.
+- Be concise but warm. Avoid corporate jargon.
+- Never blame the customer. Use phrases like "I can see that..." or "It looks like..." instead of "You did...".
+- If something is our fault, acknowledge it directly: "I'm sorry about that — this shouldn't have happened."
+
+### Billing and refunds
+- Customers on the **Free** plan are not eligible for refunds.
+- Customers on the **Pro** plan can receive refunds for charges within the last 30 days, up to $500, without manager approval.
+- Customers on the **Enterprise** plan: any refund over $200 requires escalation to the billing team.
+- If a customer was double-charged, issue a refund immediately and apologize.
+- Never share internal pricing tiers or discount structures.
+
+### Account and security
+- You can trigger a password reset email but cannot view or change passwords directly.
+- If a customer reports unauthorized access, immediately escalate to the security team using escalate_to_human with priority "urgent".
+- Do not share account details (email, billing info) without first verifying the customer's identity through their registered email.
+
+### Technical issues
+- For issues related to project creation, task boards, or integrations, check our known issues list first.
+- If the issue matches a known bug, share the workaround and let the customer know it's being tracked.
+- For API-related questions, link to the relevant docs page: https://docs.acme-saas.com/api
+- If the issue is not in the known issues list and you cannot diagnose it, escalate to engineering support.
+
+### What you must never do
+- Never make up information about product features, pricing, or policies.
+- Never promise a timeline for bug fixes or feature releases.
+- Never share internal Slack messages, Jira tickets, or employee names.
+- Never ask the customer to "try again later" without a concrete reason.
+
+{{#previousMessages}}
+## Conversation history
+
+{{previousMessages}}
+{{/previousMessages}}
+
+Respond to the customer's issue now. Start by acknowledging their problem, then either resolve it directly or ask the one most important clarifying question.`,
+});
+
+export const summarizerPrompt = prompts.define({
+  id: "summarizer",
+  description: "Summarizes text content",
+  model: "gpt-4o-mini",
+  config: { temperature: 0.3 },
+  variables: z.object({
+    text: z.string(),
+    maxSentences: z.string().optional(),
+  }),
+  content: `Summarize the following text{{#maxSentences}} in {{maxSentences}} sentences or fewer{{/maxSentences}}:
+
+{{text}}`,
+});
+
+// ─── Test task: resolve prompts locally ──────────────────
+
+export const testPromptsTask = task({
+  id: "test-prompts",
+  run: async () => {
+    const support = await supportPrompt.resolve({
+      customerName: "Alice Johnson",
+      plan: "Pro",
+      issue: "Cannot access billing dashboard",
+    });
+
+    logger.info("Support prompt resolved", {
+      version: support.version,
+      model: support.model,
+      text: support.text,
+    });
+
+    const summarizer = await summarizerPrompt.resolve({
+      text: "Trigger.dev is a platform for building and running background tasks. It provides a TypeScript SDK for defining tasks, and a dashboard for monitoring and managing them.",
+      maxSentences: "2",
+    });
+
+    logger.info("Summarizer prompt resolved", {
+      version: summarizer.version,
+      model: summarizer.model,
+      text: summarizer.text,
+    });
+
+    return {
+      supportPrompt: support.text,
+      summarizerText: summarizer.text,
+    };
+  },
+});
+
+// ─── AI SDK integration: generateText with prompt ────────
+
+export const generateWithPromptTask = task({
+  id: "generate-with-prompt",
+  run: async (payload: { customerName: string; plan: string; issue: string }) => {
+    const resolved = await supportPrompt.resolve({
+      customerName: payload.customerName,
+      plan: payload.plan,
+      issue: payload.issue,
+    });
+
+    // Use with generateText — spread toAISDKTelemetry to link the AI span to the prompt
+    const result = await generateText({
+      model: openai(resolved.model ?? "gpt-4o-mini"),
+      system: resolved.text,
+      prompt: `The customer says: "${payload.issue}". Please help them.`,
+      ...resolved.toAISDKTelemetry(),
+    });
+
+    logger.info("AI response generated", {
+      promptVersion: resolved.version,
+      promptLabels: resolved.labels,
+      responseLength: result.text.length,
+    });
+
+    return { response: result.text };
+  },
+});
+
+// ─── AI SDK integration: summarize with prompt ───────────
+
+export const summarizeTask = task({
+  id: "summarize-with-prompt",
+  run: async (payload: { text: string; maxSentences?: string }) => {
+    const resolved = await summarizerPrompt.resolve({
+      text: payload.text,
+      maxSentences: payload.maxSentences,
+    });
+
+    // Use the resolved prompt as the user prompt directly
+    const result = await generateText({
+      model: openai("gpt-4o-mini"),
+      prompt: resolved.text,
+      ...resolved.toAISDKTelemetry({ "task.type": "summarization" }),
+    });
+
+    logger.info("Summary generated", {
+      promptVersion: resolved.version,
+      inputLength: payload.text.length,
+      outputLength: result.text.length,
+    });
+
+    return { summary: result.text };
+  },
+});
+
+// ─── AI SDK integration: streamText with prompt ──────────
+
+export const streamWithPromptTask = task({
+  id: "stream-with-prompt",
+  run: async (payload: { customerName: string; plan: string; issue: string }) => {
+    const resolved = await supportPrompt.resolve({
+      customerName: payload.customerName,
+      plan: payload.plan,
+      issue: payload.issue,
+    });
+
+    const result = streamText({
+      model: openai(resolved.model ?? "gpt-4o-mini"),
+      system: resolved.text,
+      prompt: `The customer says: "${payload.issue}". Please help them.`,
+      tools: {
+        check_subscription: tool({
+          description: "Look up the customer's current subscription status and plan details",
+          inputSchema: z.object({
+            customerName: z.string().describe("The customer's name"),
+          }),
+          execute: async ({ customerName }) => ({
+            plan: payload.plan,
+            status: "active",
+            billingCycle: "monthly",
+            nextBillingDate: "2026-04-01",
+          }),
+        }),
+        escalate_to_human: tool({
+          description: "Escalate the issue to a human support agent",
+          inputSchema: z.object({
+            summary: z.string().describe("Summary of the issue and what has been tried"),
+            priority: z.enum(["low", "medium", "high", "urgent"]).describe("Urgency level"),
+          }),
+          execute: async ({ summary, priority }) => ({
+            ticketId: "ESC-1234",
+            status: "escalated",
+            priority,
+          }),
+        }),
+      },
+      stopWhen: stepCountIs(3),
+      ...resolved.toAISDKTelemetry(),
+    });
+
+    let fullText = "";
+    for await (const chunk of result.textStream) {
+      fullText += chunk;
+    }
+
+    logger.info("Streamed response complete", {
+      promptVersion: resolved.version,
+      responseLength: fullText.length,
+    });
+
+    return { response: fullText };
+  },
+});
+
+// ─── Prompt for structured extraction ────────────────────
+
+export const extractContactPrompt = prompts.define({
+  id: "extract-contact",
+  description: "Extracts structured contact info from freeform text",
+  model: "gpt-4o-mini",
+  config: { temperature: 0 },
+  variables: z.object({
+    text: z.string(),
+  }),
+  content: `Extract the contact information from the following text. If a field is not present, omit it.
+
+Text:
+{{text}}`,
+});
+
+// ─── AI SDK integration: generateObject with prompt ──────
+
+export const generateObjectWithPromptTask = task({
+  id: "generate-object-with-prompt",
+  run: async (payload: { text: string }) => {
+    const resolved = await extractContactPrompt.resolve({
+      text: payload.text,
+    });
+
+    const result = await generateObject({
+      model: openai(resolved.model ?? "gpt-4o-mini"),
+      system: resolved.text,
+      prompt: payload.text,
+      schema: z.object({
+        name: z.string().describe("Full name, or empty string if not found"),
+        email: z.string().describe("Email address, or empty string if not found"),
+        phone: z.string().describe("Phone number, or empty string if not found"),
+        company: z.string().describe("Company name, or empty string if not found"),
+        role: z.string().describe("Job title or role, or empty string if not found"),
+      }),
+      ...resolved.toAISDKTelemetry(),
+    });
+
+    logger.info("Contact extracted", {
+      promptVersion: resolved.version,
+      contact: result.object,
+    });
+
+    return { contact: result.object };
+  },
+});
+
+// ─── Prompt management SDK methods ───────────────────────
+
+export const testPromptManagement = task({
+  id: "test-prompt-management",
+  run: async () => {
+    // List all prompts
+    const allPrompts = await prompts.list();
+    logger.info("Listed prompts", { count: allPrompts.data.length, slugs: allPrompts.data.map((p) => p.slug) });
+
+    if (allPrompts.data.length === 0) {
+      return { success: false, reason: "No prompts found — deploy first" };
+    }
+
+    const slug = allPrompts.data[0].slug;
+
+    // List versions
+    const versions = await prompts.versions(slug);
+    logger.info("Listed versions", { slug, count: versions.data.length });
+
+    // Resolve the prompt (standalone, typesafe via generic)
+    const resolved = await prompts.resolve<typeof supportPrompt>("customer-support", {
+      customerName: "SDK Test",
+      plan: "Enterprise",
+      issue: "Testing management API",
+    });
+    logger.info("Resolved prompt standalone", { version: resolved.version, textLength: resolved.text.length });
+
+    // Create an override
+    const override = await prompts.createOverride(slug, {
+      textContent: "Override from SDK test: Hello {{customerName}} on {{plan}}!",
+      model: "gpt-4o-mini",
+      commitMessage: "SDK test override",
+    });
+    logger.info("Created override", { version: override.version });
+
+    // Resolve again — should get the override
+    const resolvedOverride = await prompts.resolve<typeof supportPrompt>("customer-support", {
+      customerName: "SDK Test",
+      plan: "Enterprise",
+      issue: "Testing override",
+    });
+    logger.info("Resolved with override", { version: resolvedOverride.version, text: resolvedOverride.text });
+
+    // Update the override
+    await prompts.updateOverride(slug, {
+      textContent: "Updated override: Hi {{customerName}} ({{plan}})!",
+      commitMessage: "SDK test update",
+    });
+    logger.info("Updated override");
+
+    // Remove the override
+    await prompts.removeOverride(slug);
+    logger.info("Removed override");
+
+    // Promote the first version to current
+    if (versions.data.length > 0) {
+      const v = versions.data[versions.data.length - 1].version; // oldest version
+      await prompts.promote(slug, v);
+      logger.info("Promoted version", { version: v });
+    }
+
+    return { success: true, slug, versionsCount: versions.data.length };
+  },
+});
diff --git a/references/hello-world/src/trigger/query.ts b/references/hello-world/src/trigger/query.ts
new file mode 100644
index 00000000000..bad268470c2
--- /dev/null
+++ b/references/hello-world/src/trigger/query.ts
@@ -0,0 +1,183 @@
+import { logger, query, task } from "@trigger.dev/sdk";
+import type { QueryTable } from "@trigger.dev/sdk";
+
+// Simple query example - tests different from/to formats
+export const simpleQueryTask = task({
+  id: "simple-query",
+  run: async () => {
+    logger.info("Running simple query example");
+
+    // 1. Default: no from/to, uses default period
+    const defaultResult = await query.execute("SELECT * FROM runs LIMIT 5");
+    logger.info("Default (no from/to)", {
+      rowCount: defaultResult.results.length,
+      firstRow: defaultResult.results[0],
+    });
+
+    // 2. Using Date objects for from/to
+    const withDates = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: new Date("2025-01-01T00:00:00Z"),
+      to: new Date(),
+    });
+    logger.info("With Date objects", {
+      rowCount: withDates.results.length,
+      firstRow: withDates.results[0],
+    });
+
+    // 3. Using Unix timestamps in milliseconds (Date.now() returns ms)
+    const now = Date.now();
+    const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+    const withTimestamps = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: sevenDaysAgo,
+      to: now,
+    });
+    logger.info("With Unix timestamps (ms)", {
+      rowCount: withTimestamps.results.length,
+      firstRow: withTimestamps.results[0],
+    });
+
+    // 4. Mixing Date and number
+    const mixed = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: new Date("2025-01-01"),
+      to: Date.now(),
+    });
+    logger.info("Mixed Date + timestamp", {
+      rowCount: mixed.results.length,
+      firstRow: mixed.results[0],
+    });
+
+    return {
+      defaultRows: defaultResult.results.length,
+      dateRows: withDates.results.length,
+      timestampRows: withTimestamps.results.length,
+      mixedRows: mixed.results.length,
+    };
+  },
+});
+
+// JSON query with all options - aggregation queries use inline types
+export const fullJsonQueryTask = task({
+  id: "full-json-query",
+  run: async () => {
+    logger.info("Running full JSON query example with all options");
+
+    // For aggregation queries, use inline types since the result shape
+    // doesn't match a table row. For non-aggregated queries, use QueryTable.
+    const result = await query.execute<{
+      status: string;
+      count: number;
+      avg_duration: number;
+    }>(
+      `SELECT
+        status,
+        COUNT(*) as count,
+        AVG(total_duration) as avg_duration
+      FROM runs
+      WHERE status IN ('Completed', 'Failed')
+      GROUP BY status`,
+      {
+        scope: "environment", // Query current environment only
+        period: "30d", // Last 30 days of data
+        // format defaults to "json"
+      }
+    );
+
+    logger.info("Query completed", {
+      format: result.format,
+      rowCount: result.results.length,
+    });
+
+    // Log the aggregated results - now fully type-safe!
+    result.results.forEach((row) => {
+      logger.info("Status breakdown", {
+        status: row.status, // string
+        count: row.count, // number
+        averageDuration: row.avg_duration, // number
+      });
+    });
+
+    return {
+      summary: result.results,
+    };
+  },
+});
+
+// CSV export example
+export const csvQueryTask = task({
+  id: "csv-query",
+  run: async () => {
+    logger.info("Running CSV query example");
+
+    // Query with CSV format - automatically typed as discriminated union!
+    const result = await query.execute(
+      "SELECT run_id, status, triggered_at, total_duration FROM runs LIMIT 10",
+      {
+        scope: "project", // Query all environments in the project
+        period: "7d", // Last 7 days
+        format: "csv", // CSV format
+      }
+    );
+
+    // result.format is "csv" and result.results is automatically typed as string!
+    logger.info("CSV query completed", {
+      format: result.format,
+      dataLength: result.results.length,
+      results: result.results,
+    });
+
+    return {
+      format: result.format,
+      csv: result.results,
+    };
+  },
+});
+
+// Organization-wide query with QueryTable for full row access
+export const orgQueryTask = task({
+  id: "org-query",
+  run: async () => {
+    logger.info("Running organization-wide query");
+
+    // Use QueryTable to get typed rows for specific columns
+    const result = await query.execute<
+      QueryTable<"runs", "run_id" | "project" | "environment" | "status" | "task_identifier" | "machine">
+    >(
+      `SELECT run_id, project, environment, status, task_identifier, machine
+      FROM runs
+      ORDER BY triggered_at DESC
+      LIMIT 50`,
+      {
+        scope: "organization", // Query across all projects
+        from: new Date("2025-02-01T00:00:00Z"), // Custom date range
+        to: new Date("2025-02-11T23:59:59Z"),
+      }
+    );
+
+    logger.info("Organization query completed", {
+      format: result.format,
+      runCount: result.results.length,
+    });
+
+    // Fully typed - status is RunFriendlyStatus, machine is MachinePresetName
+    result.results.forEach((row) => {
+      logger.info("Run info", {
+        runId: row.run_id, // string
+        project: row.project, // string
+        environment: row.environment, // string
+        status: row.status, // "Completed" | "Failed" | "Executing" | ...
+        task: row.task_identifier, // string
+        machine: row.machine, // "micro" | "small-1x" | "small-2x" | ...
+      });
+    });
+
+    return {
+      runs: result.results,
+    };
+  },
+});
diff --git a/references/hello-world/src/trigger/rateLimitStress.ts b/references/hello-world/src/trigger/rateLimitStress.ts
new file mode 100644
index 00000000000..cb2c20c5798
--- /dev/null
+++ b/references/hello-world/src/trigger/rateLimitStress.ts
@@ -0,0 +1,257 @@
+import { logger, task, tasks, RateLimitError } from "@trigger.dev/sdk/v3";
+import { setTimeout } from "timers/promises";
+
+/**
+ * A simple no-op task that does minimal work.
+ * Used as the target for rate limit stress testing.
+ */
+export const noopTask = task({
+  id: "noop-task",
+  retry: { maxAttempts: 1 },
+  run: async (payload: { index: number }) => {
+    return { index: payload.index, timestamp: Date.now() };
+  },
+});
+
+/**
+ * Stress test task that triggers many runs rapidly to hit the API rate limit.
+ * Fires triggers as fast as possible for a set duration, then stops.
+ *
+ * Note: Already-triggered runs will continue to execute after the test completes.
+ *
+ * Default rate limits (per environment API key):
+ * - Free: 1,200 runs bucket, refills 100 runs/10 sec
+ * - Hobby/Pro: 5,000 runs bucket, refills 500 runs/5 sec
+ *
+ * Run with: `npx trigger.dev@latest dev` then trigger this task from the dashboard
+ */
+export const rateLimitStressTest = task({
+  id: "rate-limit-stress-test",
+  maxDuration: 120,
+  run: async (payload: {
+    /** How long to run the test in seconds (default: 5) */
+    durationSeconds?: number;
+    /** How many triggers to fire in parallel per batch (default: 100) */
+    batchSize?: number;
+  }) => {
+    const durationSeconds = payload.durationSeconds ?? 5;
+    const batchSize = payload.batchSize ?? 100;
+    const durationMs = durationSeconds * 1000;
+
+    logger.info("Starting rate limit stress test", {
+      durationSeconds,
+      batchSize,
+    });
+
+    const start = Date.now();
+    let totalAttempted = 0;
+    let totalSuccess = 0;
+    let totalRateLimited = 0;
+    let totalOtherErrors = 0;
+    let batchCount = 0;
+
+    // Keep firing batches until time runs out
+    while (Date.now() - start < durationMs) {
+      batchCount++;
+      const batchStart = Date.now();
+      const elapsed = batchStart - start;
+      const remaining = durationMs - elapsed;
+
+      logger.info(`Batch ${batchCount} starting`, {
+        elapsedMs: elapsed,
+        remainingMs: remaining,
+        totalAttempted,
+        totalSuccess,
+        totalRateLimited,
+      });
+
+      // Fire a batch of triggers
+      const promises = Array.from({ length: batchSize }, async (_, i) => {
+        // Check if we've exceeded time before each trigger
+        if (Date.now() - start >= durationMs) {
+          return { skipped: true };
+        }
+
+        const index = totalAttempted + i;
+        try {
+          await tasks.trigger<typeof noopTask>("noop-task", { index });
+          return { success: true, rateLimited: false };
+        } catch (error) {
+          if (error instanceof RateLimitError) {
+            return { success: false, rateLimited: true, resetInMs: error.millisecondsUntilReset };
+          }
+          return { success: false, rateLimited: false };
+        }
+      });
+
+      const results = await Promise.all(promises);
+
+      const batchSuccess = results.filter((r) => "success" in r && r.success).length;
+      const batchRateLimited = results.filter((r) => "rateLimited" in r && r.rateLimited).length;
+      const batchOtherErrors = results.filter(
+        (r) => "success" in r && !r.success && !("rateLimited" in r && r.rateLimited)
+      ).length;
+      const batchSkipped = results.filter((r) => "skipped" in r && r.skipped).length;
+
+      totalAttempted += batchSize - batchSkipped;
+      totalSuccess += batchSuccess;
+      totalRateLimited += batchRateLimited;
+      totalOtherErrors += batchOtherErrors;
+
+      // Log rate limit hits
+      const rateLimitedResult = results.find((r) => "rateLimited" in r && r.rateLimited);
+      if (rateLimitedResult && "resetInMs" in rateLimitedResult) {
+        logger.warn("Rate limit hit!", {
+          batch: batchCount,
+          resetInMs: rateLimitedResult.resetInMs,
+          totalRateLimited,
+        });
+      }
+
+      // Small delay between batches to not overwhelm
+      await setTimeout(50);
+    }
+
+    const duration = Date.now() - start;
+
+    logger.info("Stress test completed", {
+      actualDurationMs: duration,
+      totalAttempted,
+      totalSuccess,
+      totalRateLimited,
+      totalOtherErrors,
+      batchCount,
+    });
+
+    return {
+      config: {
+        durationSeconds,
+        batchSize,
+      },
+      results: {
+        actualDurationMs: duration,
+        totalAttempted,
+        totalSuccess,
+        totalRateLimited,
+        totalOtherErrors,
+        batchCount,
+        hitRateLimit: totalRateLimited > 0,
+        triggersPerSecond: Math.round((totalAttempted / duration) * 1000),
+      },
+    };
+  },
+});
+
+/**
+ * Sustained load test - maintains a steady rate of triggers over time.
+ * Useful for seeing how rate limits behave under sustained load.
+ *
+ * Note: Successfully triggered runs will continue executing after this test completes.
+ */
+export const sustainedLoadTest = task({
+  id: "sustained-load-test",
+  maxDuration: 300,
+  run: async (payload: {
+    /** Triggers per second to attempt (default: 100) */
+    triggersPerSecond?: number;
+    /** Duration in seconds (default: 20) */
+    durationSeconds?: number;
+  }) => {
+    const triggersPerSecond = payload.triggersPerSecond ?? 100;
+    const durationSeconds = payload.durationSeconds ?? 20;
+
+    const intervalMs = 1000 / triggersPerSecond;
+    const totalTriggers = triggersPerSecond * durationSeconds;
+
+    logger.info("Starting sustained load test", {
+      triggersPerSecond,
+      durationSeconds,
+      totalTriggers,
+      intervalMs,
+    });
+
+    const results: Array<{
+      index: number;
+      success: boolean;
+      rateLimited: boolean;
+      timestamp: number;
+    }> = [];
+
+    const start = Date.now();
+    let index = 0;
+
+    while (Date.now() - start < durationSeconds * 1000 && index < totalTriggers) {
+      const triggerStart = Date.now();
+
+      try {
+        await tasks.trigger<typeof noopTask>("noop-task", { index });
+        results.push({
+          index,
+          success: true,
+          rateLimited: false,
+          timestamp: Date.now() - start,
+        });
+      } catch (error) {
+        results.push({
+          index,
+          success: false,
+          rateLimited: error instanceof RateLimitError,
+          timestamp: Date.now() - start,
+        });
+
+        if (error instanceof RateLimitError) {
+          logger.warn("Rate limit hit during sustained load", {
+            index,
+            timestamp: Date.now() - start,
+            resetInMs: error.millisecondsUntilReset,
+          });
+        }
+      }
+
+      index++;
+
+      // Maintain the target rate
+      const elapsed = Date.now() - triggerStart;
+      const sleepTime = Math.max(0, intervalMs - elapsed);
+      if (sleepTime > 0) {
+        await setTimeout(sleepTime);
+      }
+    }
+
+    const duration = Date.now() - start;
+    const successCount = results.filter((r) => r.success).length;
+    const rateLimitedCount = results.filter((r) => r.rateLimited).length;
+
+    // Find when rate limiting started (if at all)
+    const firstRateLimited = results.find((r) => r.rateLimited);
+
+    logger.info("Sustained load test completed", {
+      actualDuration: duration,
+      actualTriggers: results.length,
+      successCount,
+      rateLimitedCount,
+      actualRate: Math.round((results.length / duration) * 1000),
+    });
+
+    return {
+      config: {
+        targetTriggersPerSecond: triggersPerSecond,
+        targetDurationSeconds: durationSeconds,
+      },
+      results: {
+        actualDuration: duration,
+        actualTriggers: results.length,
+        successCount,
+        rateLimitedCount,
+        actualRate: Math.round((results.length / duration) * 1000),
+        hitRateLimit: rateLimitedCount > 0,
+        firstRateLimitedAt: firstRateLimited
+          ? {
+              index: firstRateLimited.index,
+              timestampMs: firstRateLimited.timestamp,
+            }
+          : null,
+      },
+    };
+  },
+});
diff --git a/references/hello-world/src/trigger/realtime.ts b/references/hello-world/src/trigger/realtime.ts
index c53bb2f16ad..3bd051f6a95 100644
--- a/references/hello-world/src/trigger/realtime.ts
+++ b/references/hello-world/src/trigger/realtime.ts
@@ -80,13 +80,13 @@ export const realtimeStreamsTask = task({
 export const realtimeStreamsV2Task = task({
   id: "realtime-streams-v2",
   run: async () => {
-    const mockStream1 = createStreamFromGenerator(generateMockData(5 * 60 * 1000));
+    const mockStream1 = createStreamFromGenerator(generateMockData(10_000));
 
     await metadata.stream("mock-data", mockStream1);
 
-    await setTimeout(10000); // Offset by 10 seconds
+    await setTimeout(5000); // Offset by 5 seconds
 
-    const mockStream2 = createStreamFromGenerator(generateMockData(5 * 60 * 1000));
+    const mockStream2 = createStreamFromGenerator(generateMockData(10_000));
     const stream2 = await metadata.stream("mock-data", mockStream2);
 
     for await (const chunk of stream2) {
diff --git a/references/hello-world/src/trigger/schedule.ts b/references/hello-world/src/trigger/schedule.ts
index 29c363d64ca..46a7d9a18ce 100644
--- a/references/hello-world/src/trigger/schedule.ts
+++ b/references/hello-world/src/trigger/schedule.ts
@@ -3,6 +3,7 @@ import { schedules } from "@trigger.dev/sdk/v3";
 export const simpleSchedule = schedules.task({
   id: "simple-schedule",
   cron: "0 0 * * *",
+  ttl: "30m",
   run: async (payload, { ctx }) => {
     return {
       message: "Hello, world!",
diff --git a/references/hello-world/src/trigger/streams.ts b/references/hello-world/src/trigger/streams.ts
new file mode 100644
index 00000000000..9a10888b532
--- /dev/null
+++ b/references/hello-world/src/trigger/streams.ts
@@ -0,0 +1,17 @@
+import { streams, InferStreamType } from "@trigger.dev/sdk";
+
+export const textStream = streams.define<string>({
+  id: "text",
+});
+
+export const progressStream = streams.define<{ step: string; percent: number }>({
+  id: "progress",
+});
+
+export const logStream = streams.define<string>({
+  id: "logs",
+});
+
+export type TextStreamPart = InferStreamType<typeof textStream>;
+export type ProgressStreamPart = InferStreamType<typeof progressStream>;
+export type LogStreamPart = InferStreamType<typeof logStream>;
diff --git a/references/hello-world/src/trigger/streamsV2.ts b/references/hello-world/src/trigger/streamsV2.ts
new file mode 100644
index 00000000000..cf51e40e5d3
--- /dev/null
+++ b/references/hello-world/src/trigger/streamsV2.ts
@@ -0,0 +1,229 @@
+import { logger, streams, task } from "@trigger.dev/sdk";
+import { setTimeout } from "timers/promises";
+import { textStream, progressStream, logStream } from "./streams.js";
+
+// Test 1: .pipe() then read back from S2 via a coordinator
+export const streamsPipeTask = task({
+  id: "streams-pipe",
+  run: async () => {
+    const source = ReadableStream.from(generateChunks(5));
+    const { waitUntilComplete } = textStream.pipe(source);
+    await waitUntilComplete();
+
+    return { written: 5 };
+  },
+});
+
+export const streamsPipeReadTask = task({
+  id: "streams-pipe-read",
+  run: async () => {
+    const handle = await streamsPipeTask.trigger({});
+
+    const stream = await textStream.read(handle.id);
+    const chunks: string[] = [];
+    for await (const chunk of stream) {
+      logger.info("read chunk from pipe", { chunk });
+      chunks.push(chunk);
+    }
+
+    return { chunks };
+  },
+});
+
+// Test 2: .append() then read back from S2
+export const streamsAppendTask = task({
+  id: "streams-append",
+  run: async () => {
+    await logStream.append("Starting processing");
+    await progressStream.append({ step: "init", percent: 0 });
+
+    await setTimeout(500);
+    await logStream.append("Step 1 complete");
+    await progressStream.append({ step: "step-1", percent: 33 });
+
+    await setTimeout(500);
+    await logStream.append("Step 2 complete");
+    await progressStream.append({ step: "step-2", percent: 66 });
+
+    await setTimeout(500);
+    await logStream.append("All done");
+    await progressStream.append({ step: "done", percent: 100 });
+
+    return { success: true };
+  },
+});
+
+export const streamsAppendReadTask = task({
+  id: "streams-append-read",
+  run: async () => {
+    const handle = await streamsAppendTask.trigger({});
+
+    // Read both log and progress streams from the child
+    const logStreamReader = await logStream.read(handle.id);
+    const logs: string[] = [];
+    for await (const chunk of logStreamReader) {
+      logger.info("read log", { chunk });
+      logs.push(chunk);
+    }
+
+    const progressStreamReader = await progressStream.read(handle.id);
+    const steps: Array<{ step: string; percent: number }> = [];
+    for await (const chunk of progressStreamReader) {
+      logger.info("read progress", { chunk });
+      steps.push(chunk);
+    }
+
+    return { logs, steps };
+  },
+});
+
+// Test 3: .writer() then read back
+export const streamsWriterTask = task({
+  id: "streams-writer",
+  run: async () => {
+    const { waitUntilComplete } = logStream.writer({
+      execute: ({ write, merge }) => {
+        write("Line 1 from write()");
+        write("Line 2 from write()");
+
+        const moreLines = ReadableStream.from(["Line 3 from merge()", "Line 4 from merge()"]);
+        merge(moreLines);
+      },
+    });
+
+    await waitUntilComplete();
+
+    return { written: 4 };
+  },
+});
+
+export const streamsWriterReadTask = task({
+  id: "streams-writer-read",
+  run: async () => {
+    const handle = await streamsWriterTask.trigger({});
+
+    const stream = await logStream.read(handle.id);
+    const lines: string[] = [];
+    for await (const chunk of stream) {
+      logger.info("read writer line", { chunk });
+      lines.push(chunk);
+    }
+
+    return { lines };
+  },
+});
+
+// Test 4: Direct streams.pipe() then read back with streams.read()
+export const streamsDirectPipeTask = task({
+  id: "streams-direct-pipe",
+  run: async () => {
+    const source = ReadableStream.from(generateChunks(3));
+    const { waitUntilComplete } = streams.pipe("direct-output", source);
+    await waitUntilComplete();
+
+    return { written: 3 };
+  },
+});
+
+export const streamsDirectPipeReadTask = task({
+  id: "streams-direct-pipe-read",
+  run: async () => {
+    const handle = await streamsDirectPipeTask.trigger({});
+
+    const stream = await streams.read(handle.id, "direct-output");
+    const chunks: string[] = [];
+    for await (const chunk of stream) {
+      logger.info("read direct pipe chunk", { chunk });
+      chunks.push(chunk as string);
+    }
+
+    return { chunks };
+  },
+});
+
+// Test 5: Direct streams.append() then read back
+export const streamsDirectAppendTask = task({
+  id: "streams-direct-append",
+  run: async () => {
+    await streams.append("direct-logs", "Log entry 1");
+    await setTimeout(300);
+    await streams.append("direct-logs", "Log entry 2");
+    await setTimeout(300);
+    await streams.append("direct-logs", "Log entry 3");
+
+    return { written: 3 };
+  },
+});
+
+export const streamsDirectAppendReadTask = task({
+  id: "streams-direct-append-read",
+  run: async () => {
+    const handle = await streamsDirectAppendTask.trigger({});
+
+    const stream = await streams.read(handle.id, "direct-logs");
+    const entries: string[] = [];
+    for await (const chunk of stream) {
+      logger.info("read direct append entry", { chunk });
+      entries.push(chunk as string);
+    }
+
+    return { entries };
+  },
+});
+
+// Test 6: Multiple streams in one task, read all back
+export const streamsMultiTask = task({
+  id: "streams-multi",
+  run: async () => {
+    await logStream.append("Starting multi-stream test");
+    await progressStream.append({ step: "start", percent: 0 });
+
+    const source = ReadableStream.from(generateChunks(3));
+    const { waitUntilComplete } = textStream.pipe(source);
+
+    await setTimeout(500);
+    await logStream.append("Text stream piped");
+    await progressStream.append({ step: "piped", percent: 50 });
+
+    await waitUntilComplete();
+
+    await logStream.append("Complete");
+    await progressStream.append({ step: "done", percent: 100 });
+
+    return { success: true };
+  },
+});
+
+export const streamsMultiReadTask = task({
+  id: "streams-multi-read",
+  run: async () => {
+    const handle = await streamsMultiTask.trigger({});
+
+    const logReader = await logStream.read(handle.id);
+    const logs: string[] = [];
+    for await (const chunk of logReader) {
+      logs.push(chunk);
+    }
+
+    const progressReader = await progressStream.read(handle.id);
+    const steps: Array<{ step: string; percent: number }> = [];
+    for await (const chunk of progressReader) {
+      steps.push(chunk);
+    }
+
+    const textReader = await textStream.read(handle.id);
+    const texts: string[] = [];
+    for await (const chunk of textReader) {
+      texts.push(chunk);
+    }
+
+    return { logs, steps, texts };
+  },
+});
+
+async function* generateChunks(count: number) {
+  for (let i = 0; i < count; i++) {
+    await setTimeout(200);
+    yield `chunk-${i}`;
+  }
+}
diff --git a/references/hello-world/src/trigger/usage.ts b/references/hello-world/src/trigger/usage.ts
index caacbde2acb..cd5e8dca831 100644
--- a/references/hello-world/src/trigger/usage.ts
+++ b/references/hello-world/src/trigger/usage.ts
@@ -1,5 +1,6 @@
-import { logger, task, wait, usage } from "@trigger.dev/sdk";
+import { logger, task, wait, usage, runs } from "@trigger.dev/sdk";
 import { setTimeout } from "timers/promises";
+import assert from "node:assert";
 
 export const usageExampleTask = task({
   id: "usage-example",
@@ -33,3 +34,197 @@ export const usageExampleTask = task({
     };
   },
 });
+
+/**
+ * Test task to verify usage tracking works correctly after moving updates to run engine.
+ *
+ * Tests:
+ * 1. usageDurationMs accumulates across attempts (retries)
+ * 2. costInCents is only calculated for non-dev environments
+ * 3. Usage is tracked and returned correctly
+ *
+ * Run with:
+ *   - { causeRetry: false } for simple usage test
+ *   - { causeRetry: true } for retry accumulation test
+ */
+export const usageTrackingTestTask = task({
+  id: "usage-tracking-test",
+  retry: {
+    maxAttempts: 3,
+    minTimeoutInMs: 100,
+    maxTimeoutInMs: 200,
+    factor: 1,
+  },
+  run: async (payload: { causeRetry?: boolean; workDurationMs?: number }, { ctx }) => {
+    const workDuration = payload.workDurationMs ?? 2000;
+    const isDev = ctx.environment.type === "DEVELOPMENT";
+
+    logger.info("Starting usage tracking test", {
+      attemptNumber: ctx.attempt.number,
+      environmentType: ctx.environment.type,
+      isDev,
+      workDuration,
+      causeRetry: payload.causeRetry,
+    });
+
+    // Get usage at start of this attempt
+    const usageAtStart = usage.getCurrent();
+    logger.info("Usage at attempt start", {
+      attemptNumber: ctx.attempt.number,
+      usageAtStart,
+    });
+
+    // Do some "work" to accumulate usage duration
+    const workStart = Date.now();
+    await setTimeout(workDuration);
+    const actualWorkTime = Date.now() - workStart;
+
+    // Get usage after work
+    const usageAfterWork = usage.getCurrent();
+    logger.info("Usage after work", {
+      attemptNumber: ctx.attempt.number,
+      usageAfterWork,
+      actualWorkTimeMs: actualWorkTime,
+      attemptDurationDelta:
+        usageAfterWork.compute.attempt.durationMs - usageAtStart.compute.attempt.durationMs,
+    });
+
+    // Cause a retry on first attempt if requested
+    if (payload.causeRetry && ctx.attempt.number === 1) {
+      logger.info("Throwing error to cause retry - usage from this attempt should accumulate");
+      throw new Error("Intentional error to test usage accumulation across retries");
+    }
+
+    // Log expectations for verification
+    logger.info("Usage tracking test completed", {
+      attemptNumber: ctx.attempt.number,
+      finalUsage: usageAfterWork,
+      environmentType: ctx.environment.type,
+      expectations: {
+        usageDurationMs: "Should be > 0 and reflect actual CPU time",
+        costInCents: isDev
+          ? "Should be 0 (dev environment - no cost tracking)"
+          : "Should be > 0 (calculated from usageDurationMs * machine centsPerMs)",
+        retryAccumulation: payload.causeRetry
+          ? "If this is attempt 2+, usageDurationMs should include time from previous attempts"
+          : "N/A - no retry",
+      },
+    });
+
+    return {
+      success: true,
+      attemptNumber: ctx.attempt.number,
+      environmentType: ctx.environment.type,
+      finalUsage: usageAfterWork,
+      isDev,
+      note: isDev
+        ? "costInCents will be 0 in dev - deploy to staging/prod to test cost calculation"
+        : "costInCents should reflect accumulated usage cost",
+    };
+  },
+});
+
+/**
+ * Parent task that triggers usageTrackingTestTask and verifies the usage values
+ * are correctly stored in the database via runs.retrieve().
+ *
+ * This tests the full flow:
+ * 1. Trigger child task and wait for completion
+ * 2. Use runs.retrieve() to fetch the run from the database
+ * 3. Verify usageDurationMs > 0
+ * 4. Verify costInCents behavior based on environment type
+ */
+export const usageVerificationParentTask = task({
+  id: "usage-verification-parent",
+  run: async (payload: { causeRetry?: boolean; workDurationMs?: number }, { ctx }) => {
+    const isDev = ctx.environment.type === "DEVELOPMENT";
+
+    logger.info("Starting usage verification parent task", {
+      environmentType: ctx.environment.type,
+      isDev,
+      causeRetry: payload.causeRetry,
+      workDurationMs: payload.workDurationMs,
+    });
+
+    // Trigger the child task and wait for it to complete
+    const childResult = await usageTrackingTestTask.triggerAndWait({
+      causeRetry: payload.causeRetry,
+      workDurationMs: payload.workDurationMs ?? 2000,
+    });
+
+    if (!childResult.ok) {
+      throw new Error(`Child task failed: ${JSON.stringify(childResult.error)}`);
+    }
+
+    logger.info("Child task completed", {
+      childRunId: childResult.id,
+      childOutput: childResult.output,
+    });
+
+    // Retrieve the run from the database to verify usage values were stored
+    const retrievedRun = await runs.retrieve(childResult.id);
+
+    logger.info("Retrieved run from database", {
+      runId: retrievedRun.id,
+      status: retrievedRun.status,
+      durationMs: retrievedRun.durationMs,
+      costInCents: retrievedRun.costInCents,
+      baseCostInCents: retrievedRun.baseCostInCents,
+    });
+
+    // Verify usageDurationMs (durationMs in the API response) is greater than 0
+    assert.ok(
+      retrievedRun.durationMs > 0,
+      `Expected durationMs > 0, got ${retrievedRun.durationMs}`
+    );
+
+    // For retry test, verify duration accumulated across attempts
+    if (payload.causeRetry) {
+      // With a retry, we should have at least 2x the work duration (attempt 1 + attempt 2)
+      const minExpectedDuration = (payload.workDurationMs ?? 2000) * 1.5; // Allow some variance
+      assert.ok(
+        retrievedRun.durationMs >= minExpectedDuration,
+        `Expected durationMs >= ${minExpectedDuration} for retry test (got ${retrievedRun.durationMs})`
+      );
+      logger.info("✅ Retry accumulation verified - duration includes time from both attempts");
+    }
+
+    // Verify costInCents based on environment type
+    if (isDev) {
+      // In dev, cost should be 0
+      assert.strictEqual(
+        retrievedRun.costInCents,
+        0,
+        `Expected costInCents to be 0 in dev environment, got ${retrievedRun.costInCents}`
+      );
+      logger.info("✅ Dev environment verified - costInCents is 0 as expected");
+    } else {
+      // In non-dev, cost should be > 0
+      assert.ok(
+        retrievedRun.costInCents > 0,
+        `Expected costInCents > 0 in ${ctx.environment.type} environment, got ${retrievedRun.costInCents}`
+      );
+      logger.info(
+        `✅ ${ctx.environment.type} environment verified - costInCents is ${retrievedRun.costInCents}`
+      );
+    }
+
+    logger.info("✅ All usage verification checks passed!", {
+      durationMs: retrievedRun.durationMs,
+      costInCents: retrievedRun.costInCents,
+      baseCostInCents: retrievedRun.baseCostInCents,
+      environmentType: ctx.environment.type,
+      hadRetry: payload.causeRetry,
+    });
+
+    return {
+      success: true,
+      childRunId: childResult.id,
+      durationMs: retrievedRun.durationMs,
+      costInCents: retrievedRun.costInCents,
+      baseCostInCents: retrievedRun.baseCostInCents,
+      environmentType: ctx.environment.type,
+      hadRetry: payload.causeRetry ?? false,
+    };
+  },
+});
diff --git a/references/hello-world/trigger.config.ts b/references/hello-world/trigger.config.ts
index 2c3751b041f..e0b875cd6d1 100644
--- a/references/hello-world/trigger.config.ts
+++ b/references/hello-world/trigger.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
   },
   logLevel: "debug",
   maxDuration: 3600,
+  ttl: "1h",
   retries: {
     enabledInDev: true,
     default: {
diff --git a/references/nextjs-realtime/.eslintrc.json b/references/nextjs-realtime/.eslintrc.json
new file mode 100644
index 00000000000..6b10a5b7392
--- /dev/null
+++ b/references/nextjs-realtime/.eslintrc.json
@@ -0,0 +1,6 @@
+{
+  "extends": [
+    "next/core-web-vitals",
+    "next/typescript"
+  ]
+}
diff --git a/references/prisma-7/.nvmrc b/references/prisma-7/.nvmrc
index 829e9737e48..76be14da5c4 100644
--- a/references/prisma-7/.nvmrc
+++ b/references/prisma-7/.nvmrc
@@ -1 +1 @@
-20.19.0
\ No newline at end of file
+20.20.0
\ No newline at end of file
diff --git a/references/realtime-streams/src/app/actions.ts b/references/realtime-streams/src/app/actions.ts
index 2c18d11e6c6..b411dadc2c2 100644
--- a/references/realtime-streams/src/app/actions.ts
+++ b/references/realtime-streams/src/app/actions.ts
@@ -3,6 +3,8 @@
 import { tasks, auth } from "@trigger.dev/sdk";
 import type { streamsTask } from "@/trigger/streams";
 import type { aiChatTask } from "@/trigger/ai-chat";
+import type { approvalTask } from "@/trigger/approval";
+import type { messagesTask } from "@/trigger/messages";
 import { redirect } from "next/navigation";
 import type { UIMessage } from "ai";
 
@@ -43,6 +45,16 @@ export async function triggerStreamTask(
   redirect(path);
 }
 
+export async function triggerApprovalTask() {
+  const handle = await tasks.trigger<typeof approvalTask>("approval-flow", {});
+  redirect(`/approval/${handle.id}?accessToken=${handle.publicAccessToken}`);
+}
+
+export async function triggerMessagesTask() {
+  const handle = await tasks.trigger<typeof messagesTask>("messages-flow", { messageCount: 5 });
+  redirect(`/messages/${handle.id}?accessToken=${handle.publicAccessToken}`);
+}
+
 export async function triggerAIChatTask(messages: UIMessage[]) {
   // Trigger the AI chat task
   const handle = await tasks.trigger<typeof aiChatTask>("ai-chat", {
diff --git a/references/realtime-streams/src/app/approval/[runId]/page.tsx b/references/realtime-streams/src/app/approval/[runId]/page.tsx
new file mode 100644
index 00000000000..b35d2cbef0b
--- /dev/null
+++ b/references/realtime-streams/src/app/approval/[runId]/page.tsx
@@ -0,0 +1,54 @@
+import { ApprovalFlow } from "@/components/approval-flow";
+import Link from "next/link";
+
+export default function ApprovalPage({
+  params,
+  searchParams,
+}: {
+  params: { runId: string };
+  searchParams: { accessToken?: string };
+}) {
+  const { runId } = params;
+  const accessToken = searchParams.accessToken;
+
+  if (!accessToken) {
+    return (
+      <div className="font-sans grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20">
+        <main className="flex flex-col gap-8 row-start-2 items-center">
+          <h1 className="text-2xl font-bold text-red-600">Missing Access Token</h1>
+          <p className="text-gray-600">This page requires an access token.</p>
+          <Link href="/" className="text-blue-600 hover:underline">
+            Go back home
+          </Link>
+        </main>
+      </div>
+    );
+  }
+
+  return (
+    <div className="font-sans grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20">
+      <main className="flex flex-col gap-8 row-start-2 items-start w-full max-w-4xl">
+        <div className="flex items-center justify-between w-full">
+          <h1 className="text-2xl font-bold">Approval Flow: {runId}</h1>
+          <Link
+            href="/"
+            className="px-4 py-2 bg-gray-200 text-gray-800 rounded-lg hover:bg-gray-300 transition-colors"
+          >
+            &larr; Back to Home
+          </Link>
+        </div>
+
+        <div className="w-full bg-gray-50 p-4 rounded-lg">
+          <p className="text-sm text-gray-600">
+            This task is waiting for your approval. Click Approve or Reject to send input to the
+            running task via <code className="bg-gray-200 px-1 rounded">useInputStreamSend</code>.
+          </p>
+        </div>
+
+        <div className="w-full border border-gray-200 rounded-lg p-6 bg-white">
+          <ApprovalFlow accessToken={accessToken} runId={runId} />
+        </div>
+      </main>
+    </div>
+  );
+}
diff --git a/references/realtime-streams/src/app/messages/[runId]/page.tsx b/references/realtime-streams/src/app/messages/[runId]/page.tsx
new file mode 100644
index 00000000000..040337fe411
--- /dev/null
+++ b/references/realtime-streams/src/app/messages/[runId]/page.tsx
@@ -0,0 +1,56 @@
+import { MessagesFlow } from "@/components/messages-flow";
+import Link from "next/link";
+
+export default function MessagesPage({
+  params,
+  searchParams,
+}: {
+  params: { runId: string };
+  searchParams: { accessToken?: string };
+}) {
+  const { runId } = params;
+  const accessToken = searchParams.accessToken;
+
+  if (!accessToken) {
+    return (
+      <div className="font-sans grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20">
+        <main className="flex flex-col gap-8 row-start-2 items-center">
+          <h1 className="text-2xl font-bold text-red-600">Missing Access Token</h1>
+          <p className="text-gray-600">This page requires an access token.</p>
+          <Link href="/" className="text-blue-600 hover:underline">
+            Go back home
+          </Link>
+        </main>
+      </div>
+    );
+  }
+
+  return (
+    <div className="font-sans grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20">
+      <main className="flex flex-col gap-8 row-start-2 items-start w-full max-w-4xl">
+        <div className="flex items-center justify-between w-full">
+          <h1 className="text-2xl font-bold">Messages Flow: {runId}</h1>
+          <Link
+            href="/"
+            className="px-4 py-2 bg-gray-200 text-gray-800 rounded-lg hover:bg-gray-300 transition-colors"
+          >
+            &larr; Back to Home
+          </Link>
+        </div>
+
+        <div className="w-full bg-gray-50 p-4 rounded-lg">
+          <p className="text-sm text-gray-600">
+            Send messages to the running task using{" "}
+            <code className="bg-gray-200 px-1 rounded">useInputStreamSend</code>. The task
+            subscribes via <code className="bg-gray-200 px-1 rounded">.on()</code> and logs each
+            message as it arrives. Send 5 messages to complete the task.
+          </p>
+        </div>
+
+        <div className="w-full border border-gray-200 rounded-lg p-6 bg-white">
+          <MessagesFlow accessToken={accessToken} runId={runId} />
+        </div>
+      </main>
+    </div>
+  );
+}
diff --git a/references/realtime-streams/src/app/page.tsx b/references/realtime-streams/src/app/page.tsx
index 76beed7a291..63b22909e97 100644
--- a/references/realtime-streams/src/app/page.tsx
+++ b/references/realtime-streams/src/app/page.tsx
@@ -1,5 +1,6 @@
 import { TriggerButton } from "@/components/trigger-button";
 import { AIChatButton } from "@/components/ai-chat-button";
+import { triggerApprovalTask, triggerMessagesTask } from "./actions";
 
 export default function Home() {
   return (
@@ -45,6 +46,31 @@ export default function Home() {
           </TriggerButton>
         </div>
 
+        <div className="mt-8 pt-8 border-t border-gray-300 w-full">
+          <h2 className="text-xl font-semibold mb-4">Input Streams</h2>
+          <p className="text-sm text-gray-600 mb-4">
+            Test sending data from the UI to a running task via useInputStreamSend
+          </p>
+          <div className="flex gap-3">
+            <form action={triggerApprovalTask}>
+              <button
+                type="submit"
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+              >
+                Approval Flow (.wait)
+              </button>
+            </form>
+            <form action={triggerMessagesTask}>
+              <button
+                type="submit"
+                className="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+              >
+                Messages Flow (.on)
+              </button>
+            </form>
+          </div>
+        </div>
+
         <div className="mt-8 pt-8 border-t border-gray-300">
           <h2 className="text-xl font-semibold mb-4">Performance Testing</h2>
           <TriggerButton scenario="performance" redirect="/performance">
diff --git a/references/realtime-streams/src/app/streams.ts b/references/realtime-streams/src/app/streams.ts
index da977ab8714..decbea455a5 100644
--- a/references/realtime-streams/src/app/streams.ts
+++ b/references/realtime-streams/src/app/streams.ts
@@ -10,3 +10,11 @@ export type DemoStreamPart = InferStreamType<typeof demoStream>;
 export const aiStream = streams.define<UIMessageChunk>({
   id: "ai",
 });
+
+export const approvalInputStream = streams.input<{ approved: boolean; reviewer: string }>({
+  id: "approval",
+});
+
+export const messageInputStream = streams.input<{ text: string }>({
+  id: "messages",
+});
diff --git a/references/realtime-streams/src/components/approval-flow.tsx b/references/realtime-streams/src/components/approval-flow.tsx
new file mode 100644
index 00000000000..a108735fd48
--- /dev/null
+++ b/references/realtime-streams/src/components/approval-flow.tsx
@@ -0,0 +1,92 @@
+"use client";
+
+import { useRealtimeRun, useInputStreamSend } from "@trigger.dev/react-hooks";
+import type { approvalTask } from "@/trigger/approval";
+
+export function ApprovalFlow({
+  runId,
+  accessToken,
+}: {
+  runId: string;
+  accessToken: string;
+}) {
+  const { run, error: runError } = useRealtimeRun<typeof approvalTask>(runId, {
+    accessToken,
+    baseURL: process.env.NEXT_PUBLIC_TRIGGER_API_URL,
+  });
+  const {
+    send,
+    isLoading: isSending,
+    error: sendError,
+  } = useInputStreamSend<{ approved: boolean; reviewer: string }>("approval", runId, {
+    accessToken,
+    baseURL: process.env.NEXT_PUBLIC_TRIGGER_API_URL,
+  });
+
+  const status = run?.metadata?.status as string | undefined;
+  const reviewer = run?.metadata?.reviewer as string | undefined;
+  const isWaiting = status === "waiting-for-approval";
+  const isCompleted = run?.status === "COMPLETED";
+  const isFailed = run?.status === "FAILED" || run?.status === "CANCELED";
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex items-center gap-3">
+        <div
+          className={`w-3 h-3 rounded-full ${
+            isWaiting
+              ? "bg-yellow-400 animate-pulse"
+              : status === "approved"
+                ? "bg-green-400"
+                : status === "rejected"
+                  ? "bg-red-400"
+                  : status === "timed-out"
+                    ? "bg-gray-400"
+                    : "bg-blue-400 animate-pulse"
+          }`}
+        />
+        <span className="text-sm text-gray-600">
+          {!run
+            ? "Loading..."
+            : isWaiting
+              ? "Waiting for approval"
+              : status === "approved"
+                ? `Approved by ${reviewer}`
+                : status === "rejected"
+                  ? `Rejected by ${reviewer}`
+                  : status === "timed-out"
+                    ? "Timed out"
+                    : `Status: ${run?.status ?? "unknown"}`}
+        </span>
+      </div>
+
+      {isWaiting && (
+        <div className="flex gap-3">
+          <button
+            onClick={() => send({ approved: true, reviewer: "You" })}
+            disabled={isSending}
+            className="px-6 py-3 bg-green-600 text-white rounded-lg hover:bg-green-700 disabled:opacity-50 transition-colors font-medium"
+          >
+            {isSending ? "Sending..." : "Approve"}
+          </button>
+          <button
+            onClick={() => send({ approved: false, reviewer: "You" })}
+            disabled={isSending}
+            className="px-6 py-3 bg-red-600 text-white rounded-lg hover:bg-red-700 disabled:opacity-50 transition-colors font-medium"
+          >
+            {isSending ? "Sending..." : "Reject"}
+          </button>
+        </div>
+      )}
+
+      {runError && <p className="text-red-500 text-sm">Run error: {runError.message}</p>}
+      {sendError && <p className="text-red-500 text-sm">Send error: {sendError.message}</p>}
+
+      {(isCompleted || isFailed) && run?.output && (
+        <pre className="bg-gray-100 p-4 rounded-lg text-sm overflow-auto">
+          {JSON.stringify(run.output, null, 2)}
+        </pre>
+      )}
+    </div>
+  );
+}
diff --git a/references/realtime-streams/src/components/messages-flow.tsx b/references/realtime-streams/src/components/messages-flow.tsx
new file mode 100644
index 00000000000..6065f2bc99c
--- /dev/null
+++ b/references/realtime-streams/src/components/messages-flow.tsx
@@ -0,0 +1,97 @@
+"use client";
+
+import { useState } from "react";
+import { useRealtimeRun, useInputStreamSend } from "@trigger.dev/react-hooks";
+import type { messagesTask } from "@/trigger/messages";
+
+export function MessagesFlow({
+  runId,
+  accessToken,
+}: {
+  runId: string;
+  accessToken: string;
+}) {
+  const [inputText, setInputText] = useState("");
+  const { run, error: runError } = useRealtimeRun<typeof messagesTask>(runId, {
+    accessToken,
+    baseURL: process.env.NEXT_PUBLIC_TRIGGER_API_URL,
+  });
+  const {
+    send,
+    isLoading: isSending,
+    error: sendError,
+  } = useInputStreamSend<{ text: string }>("messages", runId, {
+    accessToken,
+    baseURL: process.env.NEXT_PUBLIC_TRIGGER_API_URL,
+  });
+
+  const status = run?.metadata?.status as string | undefined;
+  const received = (run?.metadata?.received as number) ?? 0;
+  const expected = (run?.metadata?.expected as number) ?? 0;
+  const isListening = status === "listening";
+  const isDone = status === "done";
+  const isCompleted = run?.status === "COMPLETED";
+
+  function handleSend() {
+    if (!inputText.trim()) return;
+    send({ text: inputText.trim() });
+    setInputText("");
+  }
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex items-center gap-3">
+        <div
+          className={`w-3 h-3 rounded-full ${
+            isListening
+              ? "bg-yellow-400 animate-pulse"
+              : isDone
+                ? "bg-green-400"
+                : "bg-blue-400 animate-pulse"
+          }`}
+        />
+        <span className="text-sm text-gray-600">
+          {!run
+            ? "Loading..."
+            : isListening
+              ? `Listening for messages (${received}/${expected})`
+              : isDone
+                ? `Received all ${received} messages`
+                : `Status: ${run?.status ?? "unknown"}`}
+        </span>
+      </div>
+
+      {isListening && (
+        <div className="flex gap-3">
+          <input
+            type="text"
+            value={inputText}
+            onChange={(e) => setInputText(e.target.value)}
+            onKeyDown={(e) => e.key === "Enter" && handleSend()}
+            placeholder="Type a message..."
+            className="flex-1 px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+          />
+          <button
+            onClick={handleSend}
+            disabled={isSending || !inputText.trim()}
+            className="px-6 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50 transition-colors font-medium"
+          >
+            {isSending ? "Sending..." : "Send"}
+          </button>
+        </div>
+      )}
+
+      {runError && <p className="text-red-500 text-sm">Run error: {runError.message}</p>}
+      {sendError && <p className="text-red-500 text-sm">Send error: {sendError.message}</p>}
+
+      {isCompleted && run?.output && (
+        <div className="bg-gray-50 p-4 rounded-lg">
+          <h3 className="text-sm font-semibold mb-2">Task output:</h3>
+          <pre className="text-sm overflow-auto">
+            {JSON.stringify(run.output, null, 2)}
+          </pre>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/references/realtime-streams/src/trigger/approval.ts b/references/realtime-streams/src/trigger/approval.ts
new file mode 100644
index 00000000000..11692820da1
--- /dev/null
+++ b/references/realtime-streams/src/trigger/approval.ts
@@ -0,0 +1,20 @@
+import { task, metadata } from "@trigger.dev/sdk";
+import { approvalInputStream } from "../app/streams";
+
+export const approvalTask = task({
+  id: "approval-flow",
+  run: async () => {
+    metadata.set("status", "waiting-for-approval");
+
+    const result = await approvalInputStream.wait({ timeout: "5m" });
+
+    if (result.ok) {
+      metadata.set("status", result.output.approved ? "approved" : "rejected");
+      metadata.set("reviewer", result.output.reviewer);
+    } else {
+      metadata.set("status", "timed-out");
+    }
+
+    return { approval: result };
+  },
+});
diff --git a/references/realtime-streams/src/trigger/messages.ts b/references/realtime-streams/src/trigger/messages.ts
new file mode 100644
index 00000000000..2dfea5e660a
--- /dev/null
+++ b/references/realtime-streams/src/trigger/messages.ts
@@ -0,0 +1,33 @@
+import { task, logger, metadata, wait } from "@trigger.dev/sdk";
+import { messageInputStream } from "../app/streams";
+
+export const messagesTask = task({
+  id: "messages-flow",
+  run: async (payload: { messageCount?: number }) => {
+    const expected = payload.messageCount ?? 5;
+    const received: { text: string }[] = [];
+
+    metadata.set("status", "listening");
+    metadata.set("received", 0);
+    metadata.set("expected", expected);
+
+    logger.info("Subscribing to messages via .on()", { expected });
+
+    const { off } = messageInputStream.on((data) => {
+      logger.info("Received message", { data });
+      received.push(data);
+      metadata.set("received", received.length);
+    });
+
+    while (received.length < expected) {
+      await wait.for({ seconds: 1 });
+    }
+
+    off();
+
+    metadata.set("status", "done");
+    logger.info("Done receiving messages", { count: received.length });
+
+    return { messages: received };
+  },
+});
diff --git a/references/seed/.gitignore b/references/seed/.gitignore
new file mode 100644
index 00000000000..6524f048dcb
--- /dev/null
+++ b/references/seed/.gitignore
@@ -0,0 +1 @@
+.trigger
\ No newline at end of file
diff --git a/references/seed/package.json b/references/seed/package.json
new file mode 100644
index 00000000000..aa788c467a1
--- /dev/null
+++ b/references/seed/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "references-seed",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "trigger.dev": "workspace:*"
+  },
+  "dependencies": {
+    "@trigger.dev/build": "workspace:*",
+    "@trigger.dev/sdk": "workspace:*",
+    "arktype": "^2.0.0",
+    "openai": "^4.97.0",
+    "puppeteer-core": "^24.15.0",
+    "replicate": "^1.0.1",
+    "yup": "^1.6.1",
+    "zod": "3.25.76",
+    "@sinclair/typebox": "^0.34.3"
+  },
+  "scripts": {
+    "dev": "trigger dev",
+    "deploy": "trigger deploy"
+  }
+}
diff --git a/references/seed/src/index.ts b/references/seed/src/index.ts
new file mode 100644
index 00000000000..cb0ff5c3b54
--- /dev/null
+++ b/references/seed/src/index.ts
@@ -0,0 +1 @@
+export {};
diff --git a/references/seed/src/trigger/logSpammer.ts b/references/seed/src/trigger/logSpammer.ts
new file mode 100644
index 00000000000..7156b556020
--- /dev/null
+++ b/references/seed/src/trigger/logSpammer.ts
@@ -0,0 +1,109 @@
+import { logger, task, wait } from "@trigger.dev/sdk/v3";
+
+const LONG_TEXT = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.`;
+
+const SEARCHABLE_TERMS = [
+  "authentication_failed",
+  "database_connection_error",
+  "payment_processed",
+  "user_registration_complete",
+  "api_rate_limit_exceeded",
+  "cache_invalidation",
+  "webhook_delivery_success",
+  "session_expired",
+  "file_upload_complete",
+  "email_sent_successfully",
+];
+
+function generateLargeJson(index: number) {
+  return {
+    requestId: `req_${Date.now()}_${index}`,
+    timestamp: new Date().toISOString(),
+    metadata: {
+      source: "log-spammer-task",
+      environment: "development",
+      version: "1.0.0",
+      region: ["us-east-1", "eu-west-1", "ap-southeast-1"][index % 3],
+    },
+    user: {
+      id: `user_${1000 + index}`,
+      email: `testuser${index}@example.com`,
+      name: `Test User ${index}`,
+      preferences: {
+        theme: index % 2 === 0 ? "dark" : "light",
+        notifications: { email: true, push: false, sms: index % 3 === 0 },
+        language: ["en", "es", "fr", "de"][index % 4],
+      },
+    },
+    payload: {
+      items: Array.from({ length: 5 }, (_, i) => ({
+        itemId: `item_${index}_${i}`,
+        name: `Product ${i}`,
+        price: Math.random() * 100,
+        quantity: Math.floor(Math.random() * 10) + 1,
+        tags: ["electronics", "sale", "featured"].slice(0, (i % 3) + 1),
+      })),
+      totals: {
+        subtotal: Math.random() * 500,
+        tax: Math.random() * 50,
+        shipping: Math.random() * 20,
+        discount: Math.random() * 30,
+      },
+    },
+    debugInfo: {
+      stackTrace: `Error: ${SEARCHABLE_TERMS[index % SEARCHABLE_TERMS.length]}\n    at processRequest (/app/src/handlers/main.ts:${100 + index}:15)\n    at handleEvent (/app/src/events/processor.ts:${50 + index}:8)\n    at async Runtime.handler (/app/src/index.ts:25:3)`,
+      memoryUsage: { heapUsed: 45000000 + index * 1000, heapTotal: 90000000 },
+      cpuTime: Math.random() * 1000,
+    },
+    longDescription: LONG_TEXT.repeat(2),
+  };
+}
+
+export const logSpammerTask = task({
+  id: "log-spammer",
+  maxDuration: 300,
+  run: async () => {
+    logger.info("Starting log spammer task for search testing");
+
+    for (let i = 0; i < 50; i++) {
+      const term = SEARCHABLE_TERMS[i % SEARCHABLE_TERMS.length];
+      const jsonPayload = generateLargeJson(i);
+
+      logger.log(`Processing event: ${term}`, { data: jsonPayload });
+
+      if (i % 5 === 0) {
+        logger.warn(`Warning triggered for ${term}`, {
+          warningCode: `WARN_${i}`,
+          details: jsonPayload,
+          longMessage: LONG_TEXT,
+        });
+      }
+
+      if (i % 10 === 0) {
+        logger.error(`Error encountered: ${term}`, {
+          errorCode: `ERR_${i}`,
+          stack: jsonPayload.debugInfo.stackTrace,
+          context: jsonPayload,
+        });
+      }
+
+      logger.debug(`Debug info for iteration ${i}`, {
+        iteration: i,
+        searchTerm: term,
+        fullPayload: jsonPayload,
+        additionalText: `${LONG_TEXT} --- Iteration ${i} complete with term ${term}`,
+      });
+
+      if (i % 10 === 0) {
+        await wait.for({ seconds: 0.5 });
+      }
+    }
+
+    logger.info("Log spammer task completed", {
+      totalLogs: 50 * 4,
+      searchableTerms: SEARCHABLE_TERMS,
+    });
+
+    return { success: true, logsGenerated: 200 };
+  },
+});
diff --git a/references/seed/src/trigger/seedTask.ts b/references/seed/src/trigger/seedTask.ts
new file mode 100644
index 00000000000..2fb43054924
--- /dev/null
+++ b/references/seed/src/trigger/seedTask.ts
@@ -0,0 +1,32 @@
+import { task, batch } from "@trigger.dev/sdk/v3";
+import { ErrorTask } from "./throwError.js";
+import { SpanSpammerTask } from "./spanSpammer.js";
+import { logSpammerTask } from "./logSpammer.js";
+
+export const seedTask = task({
+  id: "seed-task",
+  run: async (payload: any, { ctx }) => {
+    let tasksToRun = [];
+
+    for (let i = 0; i < 10; i++) {
+      tasksToRun.push({
+        id: "simple-throw-error",
+        payload: {},
+        options: { delay: `${i}s` },
+      });
+    }
+
+    tasksToRun.push({
+      id: "span-spammer",
+      payload: {},
+    });
+
+    tasksToRun.push({
+      id: "log-spammer",
+      payload: {},
+    });
+
+    await batch.triggerAndWait(tasksToRun);
+    return;
+  },
+});
diff --git a/references/seed/src/trigger/spanSpammer.ts b/references/seed/src/trigger/spanSpammer.ts
new file mode 100644
index 00000000000..dc79ce93bf0
--- /dev/null
+++ b/references/seed/src/trigger/spanSpammer.ts
@@ -0,0 +1,66 @@
+import { logger, task, wait, metadata } from "@trigger.dev/sdk/v3";
+
+const CONFIG = {
+  delayBetweenBatchesSeconds: 0.2,
+  logsPerBatch: 30,
+  totalBatches: 100,
+  initialDelaySeconds: 5,
+} as const;
+
+export const SpanSpammerTask = task({
+  id: "span-spammer",
+  maxDuration: 300,
+  run: async (payload: any, { ctx }) => {
+    const context = { payload, ctx };
+    let logCount = 0;
+
+    // 30s trace with events every 5s
+    await logger.trace("10s-span", async () => {
+      const totalSeconds = 10;
+      const intervalSeconds = 2;
+      const totalEvents = totalSeconds / intervalSeconds;
+
+      logger.info("Starting 30s span", context);
+
+      for (let i = 1; i <= totalEvents; i++) {
+        await wait.for({ seconds: intervalSeconds });
+        logger.info(`Inner event ${i}/${totalEvents} at ${i * intervalSeconds}s`, context);
+      }
+
+      logger.info("Completed 30s span", context);
+    });
+
+    logger.info("Starting span spammer task", context);
+    logger.warn("This will generate a lot of logs", context);
+
+
+    const emitBatch = (prefix: string) => {
+      logger.debug("Started spam batch emit!", context);
+
+      for (let i = 0; i < CONFIG.logsPerBatch; i++) {
+        logger.log(`${prefix} ${++logCount}`, context);
+      }
+
+      logger.debug('Completed spam batch emit!', context);
+    };
+
+    emitBatch("Log number");
+    await wait.for({ seconds: CONFIG.initialDelaySeconds });
+
+    for (let batch = 0; batch < CONFIG.totalBatches; batch++) {
+      await wait.for({ seconds: CONFIG.delayBetweenBatchesSeconds });
+      emitBatch("This is a test log!!! Log number: ");
+    }
+
+    metadata.parent.set("childStatus", "running");
+    metadata.parent.increment("completedChildren", 1);
+
+    // Update the root run's metadata (top-level run in the chain)
+    metadata.root.set("deepChildStatus", "done");
+    metadata.root.append("completedTasks", "child-task");
+
+
+    logger.info("Completed span spammer task", context);
+    return { message: `Created ${logCount} logs` };
+  },
+});
diff --git a/references/seed/src/trigger/throwError.ts b/references/seed/src/trigger/throwError.ts
new file mode 100644
index 00000000000..5f2d623a015
--- /dev/null
+++ b/references/seed/src/trigger/throwError.ts
@@ -0,0 +1,16 @@
+import { logger, task, wait } from "@trigger.dev/sdk/v3";
+
+
+export const ErrorTask = task({
+  id: "simple-throw-error",
+  maxDuration: 60,
+  run: async (payload: any, { ctx }) => {
+    logger.log("This task is about to throw an error!", { payload, ctx });
+
+    await wait.for({ seconds: 9 });
+    throw new Error("This is an expected test error from ErrorTask!");
+  },
+  onFailure: async ({ payload, error, ctx }) => {
+    logger.warn("ErrorTask failed!", { payload, error, ctx });
+  }
+});
diff --git a/references/seed/trigger.config.ts b/references/seed/trigger.config.ts
new file mode 100644
index 00000000000..f87620cd780
--- /dev/null
+++ b/references/seed/trigger.config.ts
@@ -0,0 +1,56 @@
+import { defineConfig } from "@trigger.dev/sdk/v3";
+import { syncEnvVars } from "@trigger.dev/build/extensions/core";
+import { lightpanda } from "@trigger.dev/build/extensions/lightpanda";
+
+export default defineConfig({
+  compatibilityFlags: ["run_engine_v2"],
+  project: process.env.TRIGGER_PROJECT_REF!,
+  experimental_processKeepAlive: {
+    enabled: true,
+    maxExecutionsPerProcess: 20,
+  },
+  logLevel: "debug",
+  maxDuration: 3600,
+  retries: {
+    enabledInDev: true,
+    default: {
+      maxAttempts: 3,
+      minTimeoutInMs: 1000,
+      maxTimeoutInMs: 10000,
+      factor: 2,
+      randomize: true,
+    },
+  },
+  machine: "small-2x",
+  build: {
+    extensions: [
+      lightpanda(),
+      syncEnvVars(async (ctx) => {
+        return [
+          { name: "SYNC_ENV", value: ctx.environment },
+          { name: "BRANCH", value: ctx.branch ?? "NO_BRANCH" },
+          { name: "BRANCH", value: "PARENT", isParentEnv: true },
+          { name: "SECRET_KEY", value: "secret-value" },
+          { name: "ANOTHER_SECRET", value: "another-secret-value" },
+        ];
+      }),
+      {
+        name: "npm-token",
+        onBuildComplete: async (context, manifest) => {
+          if (context.target === "dev") {
+            return;
+          }
+
+          context.addLayer({
+            id: "npm-token",
+            build: {
+              env: {
+                NPM_TOKEN: manifest.deploy.env?.NPM_TOKEN,
+              },
+            },
+          });
+        },
+      },
+    ],
+  },
+});
diff --git a/references/seed/tsconfig.json b/references/seed/tsconfig.json
new file mode 100644
index 00000000000..9a5ee0b9d68
--- /dev/null
+++ b/references/seed/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "customConditions": ["@triggerdotdev/source"],
+    "jsx": "preserve",
+    "lib": ["DOM", "DOM.Iterable"],
+    "noEmit": true
+  },
+  "include": ["./src/**/*.ts", "trigger.config.ts"]
+}
diff --git a/rules/4.3.0/advanced-tasks.md b/rules/4.3.0/advanced-tasks.md
new file mode 100644
index 00000000000..32a00337f89
--- /dev/null
+++ b/rules/4.3.0/advanced-tasks.md
@@ -0,0 +1,485 @@
+# Trigger.dev Advanced Tasks (v4)
+
+**Advanced patterns and features for writing tasks**
+
+## Tags & Organization
+
+```ts
+import { task, tags } from "@trigger.dev/sdk";
+
+export const processUser = task({
+  id: "process-user",
+  run: async (payload: { userId: string; orgId: string }, { ctx }) => {
+    // Add tags during execution
+    await tags.add(`user_${payload.userId}`);
+    await tags.add(`org_${payload.orgId}`);
+
+    return { processed: true };
+  },
+});
+
+// Trigger with tags
+await processUser.trigger(
+  { userId: "123", orgId: "abc" },
+  { tags: ["priority", "user_123", "org_abc"] } // Max 10 tags per run
+);
+
+// Subscribe to tagged runs
+for await (const run of runs.subscribeToRunsWithTag("user_123")) {
+  console.log(`User task ${run.id}: ${run.status}`);
+}
+```
+
+**Tag Best Practices:**
+
+- Use prefixes: `user_123`, `org_abc`, `video:456`
+- Max 10 tags per run, 1-64 characters each
+- Tags don't propagate to child tasks automatically
+
+## Batch Triggering v2
+
+Enhanced batch triggering with larger payloads and streaming ingestion.
+
+### Limits
+
+- **Maximum batch size**: 1,000 items (increased from 500)
+- **Payload per item**: 3MB each (increased from 1MB combined)
+- Payloads > 512KB automatically offload to object storage
+
+### Rate Limiting (per environment)
+
+| Tier | Bucket Size | Refill Rate |
+|------|-------------|-------------|
+| Free | 1,200 runs | 100 runs/10 sec |
+| Hobby | 5,000 runs | 500 runs/5 sec |
+| Pro | 5,000 runs | 500 runs/5 sec |
+
+### Concurrent Batch Processing
+
+| Tier | Concurrent Batches |
+|------|-------------------|
+| Free | 1 |
+| Hobby | 10 |
+| Pro | 10 |
+
+### Usage
+
+```ts
+import { myTask } from "./trigger/myTask";
+
+// Basic batch trigger (up to 1,000 items)
+const runs = await myTask.batchTrigger([
+  { payload: { userId: "user-1" } },
+  { payload: { userId: "user-2" } },
+  { payload: { userId: "user-3" } },
+]);
+
+// Batch trigger with wait
+const results = await myTask.batchTriggerAndWait([
+  { payload: { userId: "user-1" } },
+  { payload: { userId: "user-2" } },
+]);
+
+for (const result of results) {
+  if (result.ok) {
+    console.log("Result:", result.output);
+  }
+}
+
+// With per-item options
+const batchHandle = await myTask.batchTrigger([
+  {
+    payload: { userId: "123" },
+    options: {
+      idempotencyKey: "user-123-batch",
+      tags: ["priority"],
+    },
+  },
+  {
+    payload: { userId: "456" },
+    options: {
+      idempotencyKey: "user-456-batch",
+    },
+  },
+]);
+```
+
+## Debouncing
+
+Consolidate multiple triggers into a single execution by debouncing task runs with a unique key and delay window.
+
+### Use Cases
+
+- **User activity updates**: Batch rapid user actions into a single run
+- **Webhook deduplication**: Handle webhook bursts without redundant processing
+- **Search indexing**: Combine document updates instead of processing individually
+- **Notification batching**: Group notifications to prevent user spam
+
+### Basic Usage
+
+```ts
+await myTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "user-123-update",  // Unique identifier for debounce group
+      delay: "5s",              // Wait duration ("5s", "1m", or milliseconds)
+    },
+  }
+);
+```
+
+### Execution Modes
+
+**Leading Mode** (default): Uses payload/options from the first trigger; subsequent triggers only reschedule execution time.
+
+```ts
+// First trigger sets the payload
+await myTask.trigger({ action: "first" }, {
+  debounce: { key: "my-key", delay: "10s" }
+});
+
+// Second trigger only reschedules - payload remains "first"
+await myTask.trigger({ action: "second" }, {
+  debounce: { key: "my-key", delay: "10s" }
+});
+// Task executes with { action: "first" }
+```
+
+**Trailing Mode**: Uses payload/options from the most recent trigger.
+
+```ts
+await myTask.trigger(
+  { data: "latest-value" },
+  {
+    debounce: {
+      key: "trailing-example",
+      delay: "10s",
+      mode: "trailing",
+    },
+  }
+);
+```
+
+In trailing mode, these options update with each trigger:
+- `payload` — task input data
+- `metadata` — run metadata
+- `tags` — run tags (replaces existing)
+- `maxAttempts` — retry attempts
+- `maxDuration` — maximum compute time
+- `machine` — machine preset
+
+### Important Notes
+
+- Idempotency keys take precedence over debounce settings
+- Compatible with `triggerAndWait()` — parent runs block correctly on debounced execution
+- Debounce key is scoped to the task
+
+## Concurrency & Queues
+
+```ts
+import { task, queue } from "@trigger.dev/sdk";
+
+// Shared queue for related tasks
+const emailQueue = queue({
+  name: "email-processing",
+  concurrencyLimit: 5, // Max 5 emails processing simultaneously
+});
+
+// Task-level concurrency
+export const oneAtATime = task({
+  id: "sequential-task",
+  queue: { concurrencyLimit: 1 }, // Process one at a time
+  run: async (payload) => {
+    // Critical section - only one instance runs
+  },
+});
+
+// Per-user concurrency
+export const processUserData = task({
+  id: "process-user-data",
+  run: async (payload: { userId: string }) => {
+    // Override queue with user-specific concurrency
+    await childTask.trigger(payload, {
+      queue: {
+        name: `user-${payload.userId}`,
+        concurrencyLimit: 2,
+      },
+    });
+  },
+});
+
+export const emailTask = task({
+  id: "send-email",
+  queue: emailQueue, // Use shared queue
+  run: async (payload: { to: string }) => {
+    // Send email logic
+  },
+});
+```
+
+## Error Handling & Retries
+
+```ts
+import { task, retry, AbortTaskRunError } from "@trigger.dev/sdk";
+
+export const resilientTask = task({
+  id: "resilient-task",
+  retry: {
+    maxAttempts: 10,
+    factor: 1.8, // Exponential backoff multiplier
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+    randomize: false,
+  },
+  catchError: async ({ error, ctx }) => {
+    // Custom error handling
+    if (error.code === "FATAL_ERROR") {
+      throw new AbortTaskRunError("Cannot retry this error");
+    }
+
+    // Log error details
+    console.error(`Task ${ctx.task.id} failed:`, error);
+
+    // Allow retry by returning nothing
+    return { retryAt: new Date(Date.now() + 60000) }; // Retry in 1 minute
+  },
+  run: async (payload) => {
+    // Retry specific operations
+    const result = await retry.onThrow(
+      async () => {
+        return await unstableApiCall(payload);
+      },
+      { maxAttempts: 3 }
+    );
+
+    // Conditional HTTP retries
+    const response = await retry.fetch("https://api.example.com", {
+      retry: {
+        maxAttempts: 5,
+        condition: (response, error) => {
+          return response?.status === 429 || response?.status >= 500;
+        },
+      },
+    });
+
+    return result;
+  },
+});
+```
+
+## Machines & Performance
+
+```ts
+export const heavyTask = task({
+  id: "heavy-computation",
+  machine: { preset: "large-2x" }, // 8 vCPU, 16 GB RAM
+  maxDuration: 1800, // 30 minutes timeout
+  run: async (payload, { ctx }) => {
+    // Resource-intensive computation
+    if (ctx.machine.preset === "large-2x") {
+      // Use all available cores
+      return await parallelProcessing(payload);
+    }
+
+    return await standardProcessing(payload);
+  },
+});
+
+// Override machine when triggering
+await heavyTask.trigger(payload, {
+  machine: { preset: "medium-1x" }, // Override for this run
+});
+```
+
+**Machine Presets:**
+
+- `micro`: 0.25 vCPU, 0.25 GB RAM
+- `small-1x`: 0.5 vCPU, 0.5 GB RAM (default)
+- `small-2x`: 1 vCPU, 1 GB RAM
+- `medium-1x`: 1 vCPU, 2 GB RAM
+- `medium-2x`: 2 vCPU, 4 GB RAM
+- `large-1x`: 4 vCPU, 8 GB RAM
+- `large-2x`: 8 vCPU, 16 GB RAM
+
+## Idempotency
+
+```ts
+import { task, idempotencyKeys } from "@trigger.dev/sdk";
+
+export const paymentTask = task({
+  id: "process-payment",
+  retry: {
+    maxAttempts: 3,
+  },
+  run: async (payload: { orderId: string; amount: number }) => {
+    // Automatically scoped to this task run, so if the task is retried, the idempotency key will be the same
+    const idempotencyKey = await idempotencyKeys.create(`payment-${payload.orderId}`);
+
+    // Ensure payment is processed only once
+    await chargeCustomer.trigger(payload, {
+      idempotencyKey,
+      idempotencyKeyTTL: "24h", // Key expires in 24 hours
+    });
+  },
+});
+
+// Payload-based idempotency
+import { createHash } from "node:crypto";
+
+function createPayloadHash(payload: any): string {
+  const hash = createHash("sha256");
+  hash.update(JSON.stringify(payload));
+  return hash.digest("hex");
+}
+
+export const deduplicatedTask = task({
+  id: "deduplicated-task",
+  run: async (payload) => {
+    const payloadHash = createPayloadHash(payload);
+    const idempotencyKey = await idempotencyKeys.create(payloadHash);
+
+    await processData.trigger(payload, { idempotencyKey });
+  },
+});
+```
+
+## Metadata & Progress Tracking
+
+```ts
+import { task, metadata } from "@trigger.dev/sdk";
+
+export const batchProcessor = task({
+  id: "batch-processor",
+  run: async (payload: { items: any[] }, { ctx }) => {
+    const totalItems = payload.items.length;
+
+    // Initialize progress metadata
+    metadata
+      .set("progress", 0)
+      .set("totalItems", totalItems)
+      .set("processedItems", 0)
+      .set("status", "starting");
+
+    const results = [];
+
+    for (let i = 0; i < payload.items.length; i++) {
+      const item = payload.items[i];
+
+      // Process item
+      const result = await processItem(item);
+      results.push(result);
+
+      // Update progress
+      const progress = ((i + 1) / totalItems) * 100;
+      metadata
+        .set("progress", progress)
+        .increment("processedItems", 1)
+        .append("logs", `Processed item ${i + 1}/${totalItems}`)
+        .set("currentItem", item.id);
+    }
+
+    // Final status
+    metadata.set("status", "completed");
+
+    return { results, totalProcessed: results.length };
+  },
+});
+
+// Update parent metadata from child task
+export const childTask = task({
+  id: "child-task",
+  run: async (payload, { ctx }) => {
+    // Update parent task metadata
+    metadata.parent.set("childStatus", "processing");
+    metadata.root.increment("childrenCompleted", 1);
+
+    return { processed: true };
+  },
+});
+```
+
+## Logging & Tracing
+
+```ts
+import { task, logger } from "@trigger.dev/sdk";
+
+export const tracedTask = task({
+  id: "traced-task",
+  run: async (payload, { ctx }) => {
+    logger.info("Task started", { userId: payload.userId });
+
+    // Custom trace with attributes
+    const user = await logger.trace(
+      "fetch-user",
+      async (span) => {
+        span.setAttribute("user.id", payload.userId);
+        span.setAttribute("operation", "database-fetch");
+
+        const userData = await database.findUser(payload.userId);
+        span.setAttribute("user.found", !!userData);
+
+        return userData;
+      },
+      { userId: payload.userId }
+    );
+
+    logger.debug("User fetched", { user: user.id });
+
+    try {
+      const result = await processUser(user);
+      logger.info("Processing completed", { result });
+      return result;
+    } catch (error) {
+      logger.error("Processing failed", {
+        error: error.message,
+        userId: payload.userId,
+      });
+      throw error;
+    }
+  },
+});
+```
+
+## Hidden Tasks
+
+```ts
+// Hidden task - not exported, only used internally
+const internalProcessor = task({
+  id: "internal-processor",
+  run: async (payload: { data: string }) => {
+    return { processed: payload.data.toUpperCase() };
+  },
+});
+
+// Public task that uses hidden task
+export const publicWorkflow = task({
+  id: "public-workflow",
+  run: async (payload: { input: string }) => {
+    // Use hidden task internally
+    const result = await internalProcessor.triggerAndWait({
+      data: payload.input,
+    });
+
+    if (result.ok) {
+      return { output: result.output.processed };
+    }
+
+    throw new Error("Internal processing failed");
+  },
+});
+```
+
+## Best Practices
+
+- **Concurrency**: Use queues to prevent overwhelming external services
+- **Retries**: Configure exponential backoff for transient failures
+- **Idempotency**: Always use for payment/critical operations
+- **Metadata**: Track progress for long-running tasks
+- **Machines**: Match machine size to computational requirements
+- **Tags**: Use consistent naming patterns for filtering
+- **Debouncing**: Use for user activity, webhooks, and notification batching
+- **Batch triggering**: Use for bulk operations up to 1,000 items
+- **Error Handling**: Distinguish between retryable and fatal errors
+
+Design tasks to be stateless, idempotent, and resilient to failures. Use metadata for state tracking and queues for resource management.
diff --git a/rules/4.3.0/basic-tasks.md b/rules/4.3.0/basic-tasks.md
new file mode 100644
index 00000000000..56bff340761
--- /dev/null
+++ b/rules/4.3.0/basic-tasks.md
@@ -0,0 +1,199 @@
+# Trigger.dev Basic Tasks (v4)
+
+**MUST use `@trigger.dev/sdk`, NEVER `client.defineJob`**
+
+## Basic Task
+
+```ts
+import { task } from "@trigger.dev/sdk";
+
+export const processData = task({
+  id: "process-data",
+  retry: {
+    maxAttempts: 10,
+    factor: 1.8,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+    randomize: false,
+  },
+  run: async (payload: { userId: string; data: any[] }) => {
+    // Task logic - runs for long time, no timeouts
+    console.log(`Processing ${payload.data.length} items for user ${payload.userId}`);
+    return { processed: payload.data.length };
+  },
+});
+```
+
+## Schema Task (with validation)
+
+```ts
+import { schemaTask } from "@trigger.dev/sdk";
+import { z } from "zod";
+
+export const validatedTask = schemaTask({
+  id: "validated-task",
+  schema: z.object({
+    name: z.string(),
+    age: z.number(),
+    email: z.string().email(),
+  }),
+  run: async (payload) => {
+    // Payload is automatically validated and typed
+    return { message: `Hello ${payload.name}, age ${payload.age}` };
+  },
+});
+```
+
+## Triggering Tasks
+
+### From Backend Code
+
+```ts
+import { tasks } from "@trigger.dev/sdk";
+import type { processData } from "./trigger/tasks";
+
+// Single trigger
+const handle = await tasks.trigger<typeof processData>("process-data", {
+  userId: "123",
+  data: [{ id: 1 }, { id: 2 }],
+});
+
+// Batch trigger (up to 1,000 items, 3MB per payload)
+const batchHandle = await tasks.batchTrigger<typeof processData>("process-data", [
+  { payload: { userId: "123", data: [{ id: 1 }] } },
+  { payload: { userId: "456", data: [{ id: 2 }] } },
+]);
+```
+
+### Debounced Triggering
+
+Consolidate multiple triggers into a single execution:
+
+```ts
+// Multiple rapid triggers with same key = single execution
+await myTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "user-123-update",  // Unique key for debounce group
+      delay: "5s",              // Wait before executing
+    },
+  }
+);
+
+// Trailing mode: use payload from LAST trigger
+await myTask.trigger(
+  { data: "latest-value" },
+  {
+    debounce: {
+      key: "trailing-example",
+      delay: "10s",
+      mode: "trailing",  // Default is "leading" (first payload)
+    },
+  }
+);
+```
+
+**Debounce modes:**
+- `leading` (default): Uses payload from first trigger, subsequent triggers only reschedule
+- `trailing`: Uses payload from most recent trigger
+
+### From Inside Tasks (with Result handling)
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Trigger and continue
+    const handle = await childTask.trigger({ data: "value" });
+
+    // Trigger and wait - returns Result object, NOT task output
+    const result = await childTask.triggerAndWait({ data: "value" });
+    if (result.ok) {
+      console.log("Task output:", result.output); // Actual task return value
+    } else {
+      console.error("Task failed:", result.error);
+    }
+
+    // Quick unwrap (throws on error)
+    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
+
+    // Batch trigger and wait
+    const results = await childTask.batchTriggerAndWait([
+      { payload: { data: "item1" } },
+      { payload: { data: "item2" } },
+    ]);
+
+    for (const run of results) {
+      if (run.ok) {
+        console.log("Success:", run.output);
+      } else {
+        console.log("Failed:", run.error);
+      }
+    }
+  },
+});
+
+export const childTask = task({
+  id: "child-task",
+  run: async (payload: { data: string }) => {
+    return { processed: payload.data };
+  },
+});
+```
+
+> Never wrap triggerAndWait or batchTriggerAndWait calls in a Promise.all or Promise.allSettled as this is not supported in Trigger.dev tasks.
+
+## Waits
+
+```ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const taskWithWaits = task({
+  id: "task-with-waits",
+  run: async (payload) => {
+    console.log("Starting task");
+
+    // Wait for specific duration
+    await wait.for({ seconds: 30 });
+    await wait.for({ minutes: 5 });
+    await wait.for({ hours: 1 });
+    await wait.for({ days: 1 });
+
+    // Wait until specific date
+    await wait.until({ date: new Date("2024-12-25") });
+
+    // Wait for token (from external system)
+    await wait.forToken({
+      token: "user-approval-token",
+      timeoutInSeconds: 3600, // 1 hour timeout
+    });
+
+    console.log("All waits completed");
+    return { status: "completed" };
+  },
+});
+```
+
+> Never wrap wait calls in a Promise.all or Promise.allSettled as this is not supported in Trigger.dev tasks.
+
+## Key Points
+
+- **Result vs Output**: `triggerAndWait()` returns a `Result` object with `ok`, `output`, `error` properties - NOT the direct task output
+- **Type safety**: Use `import type` for task references when triggering from backend
+- **Waits > 5 seconds**: Automatically checkpointed, don't count toward compute usage
+- **Debounce + idempotency**: Idempotency keys take precedence over debounce settings
+
+## NEVER Use (v2 deprecated)
+
+```ts
+// BREAKS APPLICATION
+client.defineJob({
+  id: "job-id",
+  run: async (payload, io) => {
+    /* ... */
+  },
+});
+```
+
+Use SDK (`@trigger.dev/sdk`), check `result.ok` before accessing `result.output`
diff --git a/rules/manifest.json b/rules/manifest.json
index 1c481d92777..64d9a86139e 100644
--- a/rules/manifest.json
+++ b/rules/manifest.json
@@ -1,7 +1,7 @@
 {
   "name": "trigger.dev",
   "description": "Trigger.dev coding agent rules",
-  "currentVersion": "4.1.0",
+  "currentVersion": "4.3.0",
   "versions": {
     "4.0.0": {
       "options": [
@@ -100,6 +100,55 @@
           "installStrategy": "claude-code-subagent"
         }
       ]
+    },
+    "4.3.0": {
+      "options": [
+        {
+          "name": "basic",
+          "title": "Basic tasks",
+          "label": "Only the most important rules for writing basic Trigger.dev tasks",
+          "path": "4.3.0/basic-tasks.md",
+          "tokens": 1400
+        },
+        {
+          "name": "advanced-tasks",
+          "title": "Advanced tasks",
+          "label": "Comprehensive rules to help you write advanced Trigger.dev tasks",
+          "path": "4.3.0/advanced-tasks.md",
+          "tokens": 3500
+        },
+        {
+          "name": "config",
+          "title": "Configuring Trigger.dev",
+          "label": "Configure your Trigger.dev project with a trigger.config.ts file",
+          "path": "4.1.0/config.md",
+          "tokens": 1900,
+          "applyTo": "**/trigger.config.ts"
+        },
+        {
+          "name": "scheduled-tasks",
+          "title": "Scheduled Tasks",
+          "label": "How to write and use scheduled Trigger.dev tasks",
+          "path": "4.0.0/scheduled-tasks.md",
+          "tokens": 780
+        },
+        {
+          "name": "realtime",
+          "title": "Realtime",
+          "label": "How to use realtime in your Trigger.dev tasks and your frontend",
+          "path": "4.1.0/realtime.md",
+          "tokens": 1700
+        },
+        {
+          "name": "claude-code-agent",
+          "title": "Claude Code Agent",
+          "label": "An expert Trigger.dev developer as a Claude Code subagent",
+          "path": "4.0.0/claude-code-agent.md",
+          "tokens": 2700,
+          "client": "claude-code",
+          "installStrategy": "claude-code-subagent"
+        }
+      ]
     }
   }
 }
\ No newline at end of file
diff --git a/scripts/batch-concurrency-cleaner.sh b/scripts/batch-concurrency-cleaner.sh
new file mode 100755
index 00000000000..b7cef3b50d7
--- /dev/null
+++ b/scripts/batch-concurrency-cleaner.sh
@@ -0,0 +1,180 @@
+#!/bin/bash
+#
+# Batch Queue Concurrency Cleaner
+#
+# Detects and cleans up stale concurrency entries that block batch processing.
+# This is a workaround for a bug where visibility timeout reclaims don't release concurrency.
+#
+# Uses a Lua script for ATOMIC detection of stale entries - no race conditions.
+#
+# Usage:
+#   ./batch-concurrency-cleaner.sh --read-redis <url> --write-redis <url> [--delay <seconds>] [--dry-run]
+#
+
+set -e
+
+# Defaults
+DELAY=10
+DRY_RUN=false
+READ_REDIS=""
+WRITE_REDIS=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --read-redis)
+      READ_REDIS="$2"
+      shift 2
+      ;;
+    --write-redis)
+      WRITE_REDIS="$2"
+      shift 2
+      ;;
+    --delay)
+      DELAY="$2"
+      shift 2
+      ;;
+    --dry-run)
+      DRY_RUN=true
+      shift
+      ;;
+    -h|--help)
+      echo "Usage: $0 --read-redis <url> --write-redis <url> [--delay <seconds>] [--dry-run]"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "$READ_REDIS" ]] || [[ -z "$WRITE_REDIS" ]]; then
+  echo "Error: --read-redis and --write-redis are required"
+  exit 1
+fi
+
+echo "Batch Queue Concurrency Cleaner (Atomic Version)"
+echo "================================================="
+echo "Read Redis:  ${READ_REDIS:0:30}..."
+echo "Write Redis: ${WRITE_REDIS:0:30}..."
+echo "Delay:       ${DELAY}s"
+echo "Dry run:     $DRY_RUN"
+echo ""
+
+rcli_read() {
+  redis-cli -u "$READ_REDIS" --no-auth-warning "$@" 2>/dev/null
+}
+
+rcli_write() {
+  redis-cli -u "$WRITE_REDIS" --no-auth-warning "$@" 2>/dev/null
+}
+
+# Lua script that ATOMICALLY checks for stale concurrency entries
+# KEYS[1] = concurrency key to check
+# KEYS[2-13] = in-flight data hash keys for shards 0-11
+# Returns: list of stale messageIds (not in any in-flight hash)
+FIND_STALE_LUA='
+local concurrency_key = KEYS[1]
+local stale = {}
+
+-- Get all members of the concurrency set
+local members = redis.call("SMEMBERS", concurrency_key)
+
+for _, msg_id in ipairs(members) do
+  local found = false
+  -- Check each in-flight shard (KEYS[2] through KEYS[13])
+  for i = 2, 13 do
+    if redis.call("HEXISTS", KEYS[i], msg_id) == 1 then
+      found = true
+      break
+    end
+  end
+  if not found then
+    table.insert(stale, msg_id)
+  end
+end
+
+return stale
+'
+
+# Build the in-flight keys array (used in every Lua call)
+INFLIGHT_KEYS="engine:batch:inflight:0:data"
+for shard in 1 2 3 4 5 6 7 8 9 10 11; do
+  INFLIGHT_KEYS="$INFLIGHT_KEYS engine:batch:inflight:$shard:data"
+done
+
+# Main loop
+while true; do
+  ts=$(date '+%H:%M:%S')
+
+  # Get master queue total and in-flight count for status display
+  master_total=0
+  for i in 0 1 2 3 4 5 6 7 8 9 10 11; do
+    count=$(rcli_read ZCARD "engine:batch:master:$i")
+    master_total=$((master_total + count))
+  done
+
+  inflight_total=0
+  for i in 0 1 2 3 4 5 6 7 8 9 10 11; do
+    count=$(rcli_read HLEN "engine:batch:inflight:$i:data")
+    inflight_total=$((inflight_total + count))
+  done
+
+  # Scan for concurrency keys
+  cursor=0
+  total_stale=0
+  cleaned_tenants=0
+
+  while true; do
+    scan_output=$(rcli_read SCAN $cursor MATCH 'engine:batch:concurrency:tenant:*' COUNT 1000)
+    cursor=$(echo "$scan_output" | head -1)
+    keys=$(echo "$scan_output" | tail -n +2)
+
+    while IFS= read -r conc_key; do
+      [[ -z "$conc_key" ]] && continue
+
+      # ATOMIC check: Run Lua script to find stale entries
+      # 13 keys total: 1 concurrency key + 12 in-flight keys
+      stale_ids=$(rcli_read EVAL "$FIND_STALE_LUA" 13 "$conc_key" $INFLIGHT_KEYS)
+
+      # Count stale entries
+      stale_count=0
+      stale_array=()
+      while IFS= read -r stale_id; do
+        [[ -z "$stale_id" ]] && continue
+        stale_array+=("$stale_id")
+        stale_count=$((stale_count + 1))
+      done <<< "$stale_ids"
+
+      if [[ $stale_count -gt 0 ]]; then
+        tenant="${conc_key#engine:batch:concurrency:tenant:}"
+        total_stale=$((total_stale + stale_count))
+
+        if [[ "$DRY_RUN" == "true" ]]; then
+          echo "[$ts] STALE (dry-run): $tenant ($stale_count entries)"
+          for sid in "${stale_array[@]}"; do
+            echo "       - $sid"
+          done
+        else
+          # Remove each stale entry individually with SREM (idempotent, safe)
+          for sid in "${stale_array[@]}"; do
+            rcli_write SREM "$conc_key" "$sid" >/dev/null
+          done
+          echo "[$ts] CLEANED: $tenant ($stale_count stale entries removed)"
+          cleaned_tenants=$((cleaned_tenants + 1))
+        fi
+      fi
+    done <<< "$keys"
+
+    [[ "$cursor" == "0" ]] && break
+  done
+
+  if [[ "$DRY_RUN" == "true" ]]; then
+    echo "[$ts] in-flight=$inflight_total master-queue=$master_total stale-found=$total_stale"
+  else
+    echo "[$ts] in-flight=$inflight_total master-queue=$master_total cleaned=$cleaned_tenants"
+  fi
+
+  sleep "$DELAY"
+done
diff --git a/scripts/enhance-release-pr.mjs b/scripts/enhance-release-pr.mjs
new file mode 100644
index 00000000000..6a446e794b2
--- /dev/null
+++ b/scripts/enhance-release-pr.mjs
@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+/**
+ * Enhances the changeset release PR with a well-written, deduplicated summary.
+ *
+ * Reads:
+ *   - The raw changeset PR body (via CHANGESET_PR_BODY env var or stdin)
+ *   - .server-changes/*.md files for server-only changes
+ *
+ * Outputs a formatted PR body to stdout that includes:
+ *   - A clean summary with categories
+ *   - Server changes section
+ *   - The raw changeset output in a collapsed <details> section
+ *
+ * Usage:
+ *   CHANGESET_PR_BODY="..." node scripts/enhance-release-pr.mjs <version>
+ *   echo "$PR_BODY" | node scripts/enhance-release-pr.mjs <version>
+ */
+
+import { promises as fs } from "fs";
+import { execFile } from "child_process";
+import { join } from "path";
+
+const version = process.argv[2];
+if (!version) {
+  console.error("Usage: node scripts/enhance-release-pr.mjs <version>");
+  process.exit(1);
+}
+
+const ROOT_DIR = join(import.meta.dirname, "..");
+
+// --- Parse changeset PR body ---
+
+function parsePrBody(body) {
+  const entries = [];
+  if (!body) return entries;
+
+  // Deduplicate by PR number
+  const seen = new Set();
+  const prPattern = /\[#(\d+)\]\(([^)]+)\)/;
+
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("- ") && !trimmed.startsWith("* ")) continue;
+
+    let text = trimmed.replace(/^[-*]\s+/, "").trim();
+    if (!text) continue;
+
+    // Skip dependency-only updates (e.g. "Updated dependencies:" or "@trigger.dev/core@4.4.2")
+    if (text.startsWith("Updated dependencies")) continue;
+    if (text.startsWith("`@trigger.dev/")) continue;
+    if (text.startsWith("@trigger.dev/")) continue;
+    if (text.startsWith("`trigger.dev@")) continue;
+    if (text.startsWith("trigger.dev@")) continue;
+
+    const prMatch = trimmed.match(prPattern);
+    if (prMatch) {
+      const prNumber = prMatch[1];
+      if (seen.has(prNumber)) continue;
+      seen.add(prNumber);
+    }
+
+    // Categorize
+    const lower = text.toLowerCase();
+    let type = "improvement";
+    if (lower.startsWith("fix") || lower.includes("bug fix")) {
+      type = "fix";
+    } else if (
+      lower.startsWith("feat") ||
+      lower.includes("new feature") ||
+      lower.includes("add support") ||
+      lower.includes("added support") ||
+      lower.includes("expose") ||
+      lower.includes("allow")
+    ) {
+      type = "feature";
+    } else if (lower.includes("breaking")) {
+      type = "breaking";
+    }
+
+    entries.push({ text, type });
+  }
+
+  return entries;
+}
+
+// --- Git + GitHub helpers for finding PR numbers ---
+
+const REPO = "triggerdotdev/trigger.dev";
+
+function gitExec(args) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd: ROOT_DIR, maxBuffer: 1024 * 1024 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+async function getCommitForFile(filePath) {
+  try {
+    // Find the commit that added this file
+    const sha = await gitExec(["log", "--diff-filter=A", "--format=%H", "--", filePath]);
+    return sha.split("\n")[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+async function getPrForCommit(commitSha) {
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (!token || !commitSha) return null;
+
+  try {
+    const res = await fetch(`https://api.github.com/repos/${REPO}/commits/${commitSha}/pulls`, {
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: "application/vnd.github.v3+json",
+      },
+    });
+    if (!res.ok) return null;
+
+    const pulls = await res.json();
+    if (!pulls.length) return null;
+
+    // Prefer merged PRs, earliest merge first (same logic as @changesets/get-github-info)
+    const sorted = pulls.sort((a, b) => {
+      if (!a.merged_at && !b.merged_at) return 0;
+      if (!a.merged_at) return 1;
+      if (!b.merged_at) return -1;
+      return new Date(a.merged_at) - new Date(b.merged_at);
+    });
+
+    return sorted[0].number;
+  } catch {
+    return null;
+  }
+}
+
+// --- Parse .server-changes/ files ---
+
+async function parseServerChanges() {
+  const dir = join(ROOT_DIR, ".server-changes");
+  const entries = [];
+
+  let files;
+  try {
+    files = await fs.readdir(dir);
+  } catch {
+    return entries;
+  }
+
+  // Collect file info and look up commits in parallel
+  const fileData = [];
+  for (const file of files) {
+    if (!file.endsWith(".md") || file === "README.md") continue;
+
+    const filePath = join(".server-changes", file);
+    const content = await fs.readFile(join(dir, file), "utf-8");
+    const parsed = parseFrontmatter(content);
+    if (!parsed.body.trim()) continue;
+
+    fileData.push({ filePath, parsed });
+  }
+
+  // Look up commits for all files in parallel
+  const commits = await Promise.all(fileData.map((f) => getCommitForFile(f.filePath)));
+
+  // Look up PRs for all commits in parallel
+  const prNumbers = await Promise.all(commits.map((sha) => getPrForCommit(sha)));
+
+  for (let i = 0; i < fileData.length; i++) {
+    const { parsed } = fileData[i];
+    let text = parsed.body.trim();
+    const pr = prNumbers[i];
+
+    // Append PR link if we found one and it's not already in the text
+    if (pr && !text.includes(`#${pr}`)) {
+      text += ` ([#${pr}](https://github.com/${REPO}/pull/${pr}))`;
+    }
+
+    entries.push({
+      text,
+      type: parsed.frontmatter.type || "improvement",
+      area: parsed.frontmatter.area || "webapp",
+    });
+  }
+
+  return entries;
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: content };
+
+  const frontmatter = {};
+  for (const line of match[1].split("\n")) {
+    const [key, ...rest] = line.split(":");
+    if (key && rest.length) {
+      frontmatter[key.trim()] = rest.join(":").trim();
+    }
+  }
+
+  return { frontmatter, body: match[2] };
+}
+
+// --- Format the enhanced PR body ---
+
+function formatPrBody({ version, packageEntries, serverEntries, rawBody }) {
+  const lines = [];
+
+  const features = packageEntries.filter((e) => e.type === "feature");
+  const fixes = packageEntries.filter((e) => e.type === "fix");
+  const improvements = packageEntries.filter((e) => e.type === "improvement" || e.type === "other");
+  const breaking = packageEntries.filter((e) => e.type === "breaking");
+
+  const serverFeatures = serverEntries.filter((e) => e.type === "feature");
+  const serverFixes = serverEntries.filter((e) => e.type === "fix");
+  const serverImprovements = serverEntries.filter((e) => e.type === "improvement");
+  const serverBreaking = serverEntries.filter((e) => e.type === "breaking");
+
+  const totalFeatures = features.length + serverFeatures.length;
+  const totalFixes = fixes.length + serverFixes.length;
+  const totalImprovements = improvements.length + serverImprovements.length;
+
+  // Summary line
+  const parts = [];
+  if (totalFeatures > 0) parts.push(`${totalFeatures} new feature${totalFeatures > 1 ? "s" : ""}`);
+  if (totalImprovements > 0)
+    parts.push(`${totalImprovements} improvement${totalImprovements > 1 ? "s" : ""}`);
+  if (totalFixes > 0) parts.push(`${totalFixes} bug fix${totalFixes > 1 ? "es" : ""}`);
+  if (parts.length > 0) {
+    lines.push(`## Summary`);
+    lines.push(`${parts.join(", ")}.`);
+    lines.push("");
+  }
+
+  // Breaking changes
+  if (breaking.length > 0 || serverBreaking.length > 0) {
+    lines.push("## Breaking changes");
+    for (const entry of [...breaking, ...serverBreaking]) lines.push(`- ${entry.text}`);
+    lines.push("");
+  }
+
+  // Highlights (features)
+  if (features.length > 0) {
+    lines.push("## Highlights");
+    lines.push("");
+    for (const entry of features) {
+      lines.push(`- ${entry.text}`);
+    }
+    lines.push("");
+  }
+
+  // Improvements
+  if (improvements.length > 0) {
+    lines.push("## Improvements");
+    for (const entry of improvements) lines.push(`- ${entry.text}`);
+    lines.push("");
+  }
+
+  // Bug fixes
+  if (fixes.length > 0) {
+    lines.push("## Bug fixes");
+    for (const entry of fixes) lines.push(`- ${entry.text}`);
+    lines.push("");
+  }
+
+  // Server changes
+  const allServer = [...serverFeatures, ...serverImprovements, ...serverFixes];
+  if (allServer.length > 0) {
+    lines.push("## Server changes");
+    lines.push("");
+    lines.push("These changes affect the self-hosted Docker image and Trigger.dev Cloud:");
+    lines.push("");
+    for (const entry of allServer) {
+      // Indent continuation lines so multi-line entries stay inside the list item
+      const indented = entry.text.replace(/\n/g, "\n  ");
+      lines.push(`- ${indented}`);
+    }
+    lines.push("");
+  }
+
+  // Raw changeset output in collapsed section
+  if (rawBody) {
+    // Strip the Changesets action boilerplate from the raw body
+    const cleanedBody = rawBody
+      .replace(
+        /This PR was opened by the \[Changesets release\].*?If you're not ready to do a release yet.*?\n/gs,
+        ""
+      )
+      .trim();
+
+    if (cleanedBody) {
+      lines.push("<details>");
+      lines.push("<summary>Raw changeset output</summary>");
+      lines.push("");
+      lines.push(cleanedBody);
+      lines.push("");
+      lines.push("</details>");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// --- Main ---
+
+async function main() {
+  let rawBody = process.env.CHANGESET_PR_BODY || "";
+  if (!rawBody && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    rawBody = Buffer.concat(chunks).toString("utf-8");
+  }
+
+  const packageEntries = parsePrBody(rawBody);
+  const serverEntries = await parseServerChanges();
+
+  const body = formatPrBody({
+    version,
+    packageEntries,
+    serverEntries,
+    rawBody,
+  });
+
+  process.stdout.write(body);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/scripts/generate-github-release.mjs b/scripts/generate-github-release.mjs
new file mode 100755
index 00000000000..fda2f3cb8c6
--- /dev/null
+++ b/scripts/generate-github-release.mjs
@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+/**
+ * Generates a unified GitHub release body for a trigger.dev version release.
+ *
+ * Usage:
+ *   node scripts/generate-github-release.mjs <version>
+ *
+ * Reads:
+ *   - The enhanced changeset release PR body (via RELEASE_PR_BODY env var or stdin).
+ *     By the time this runs, the PR body has already been enhanced by enhance-release-pr.mjs
+ *     to include server changes, deduplication, and categorization. The .server-changes/ files
+ *     themselves are already deleted (consumed on the release branch, same as .changeset/ files).
+ *   - Git log for contributor info
+ *
+ * Outputs the formatted GitHub release body to stdout.
+ */
+
+import { execSync } from "child_process";
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+
+const version = process.argv[2];
+if (!version) {
+  console.error("Usage: node scripts/generate-github-release.mjs <version>");
+  process.exit(1);
+}
+
+const ROOT_DIR = join(import.meta.dirname, "..");
+
+// --- Parse the enhanced PR body ---
+// The PR body from enhance-release-pr.mjs has sections like:
+//   ## Highlights
+//   ## Improvements
+//   ## Bug fixes
+//   ## Server changes
+//   ## Breaking changes
+//   <details>...</details>
+// We extract the content between the first heading and the <details> block.
+
+function extractChangesFromPrBody(body) {
+  if (!body) return "";
+
+  const lines = body.split("\n");
+  const outputLines = [];
+  let inDetails = false;
+  let inSummary = false;
+  let foundContent = false;
+
+  for (const line of lines) {
+    // Skip the title line (# trigger.dev vX.Y.Z)
+    if (line.startsWith("# trigger.dev v")) continue;
+
+    // Skip the entire Summary section (heading + content until next heading)
+    if (line.startsWith("## Summary")) {
+      inSummary = true;
+      continue;
+    }
+    if (inSummary) {
+      if (line.startsWith("## ")) {
+        inSummary = false;
+      } else {
+        continue;
+      }
+    }
+
+    // Stop before raw changeset output
+    if (line.trim() === "<details>") {
+      inDetails = true;
+      continue;
+    }
+    if (inDetails) continue;
+
+    // Collect everything from the first ## heading onward
+    if (line.startsWith("## ") && !foundContent) {
+      foundContent = true;
+    }
+
+    if (foundContent) {
+      outputLines.push(line);
+    }
+  }
+
+  return outputLines.join("\n").trim();
+}
+
+// --- Get contributors from git log ---
+
+function getContributors(previousVersion) {
+  try {
+    const range = previousVersion
+      ? `v${previousVersion}...HEAD`
+      : "HEAD~50..HEAD";
+    const log = execSync(`git log ${range} --format="%aN|%aE" --no-merges`, {
+      cwd: ROOT_DIR,
+      encoding: "utf-8",
+    });
+
+    const contributors = new Map();
+    for (const line of log.split("\n").filter(Boolean)) {
+      const [name, email] = line.split("|");
+      if (!name || email?.endsWith("@users.noreply.github.com")) {
+        // Try to extract username from noreply email
+        const match = email?.match(/(\d+\+)?(.+)@users\.noreply\.github\.com/);
+        if (match) {
+          const username = match[2];
+          contributors.set(username, (contributors.get(username) || 0) + 1);
+        }
+        continue;
+      }
+      contributors.set(name, (contributors.get(name) || 0) + 1);
+    }
+
+    return [...contributors.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .map(([name]) => name);
+  } catch {
+    return [];
+  }
+}
+
+// --- Get published packages ---
+
+function getPublishedPackages() {
+  try {
+    const packagesDir = join(ROOT_DIR, "packages");
+    const names = [];
+    for (const dir of readdirSync(packagesDir, { withFileTypes: true })) {
+      if (!dir.isDirectory()) continue;
+      try {
+        const pkg = JSON.parse(
+          readFileSync(join(packagesDir, dir.name, "package.json"), "utf-8")
+        );
+        if (pkg.name && !pkg.private) {
+          names.push(pkg.name);
+        }
+      } catch {
+        // skip directories without package.json
+      }
+    }
+    return names.sort();
+  } catch {
+    return [
+      "@trigger.dev/build",
+      "@trigger.dev/core",
+      "@trigger.dev/react-hooks",
+      "@trigger.dev/sdk",
+      "trigger.dev",
+    ];
+  }
+}
+
+function getPreviousVersion(version) {
+  const parts = version.split(".").map(Number);
+  if (parts[2] > 0) {
+    parts[2]--;
+  } else if (parts[1] > 0) {
+    parts[1]--;
+    parts[2] = 0;
+  } else if (parts[0] > 0) {
+    parts[0]--;
+    parts[1] = 0;
+    parts[2] = 0;
+  } else {
+    return null;
+  }
+  return parts.join(".");
+}
+
+// --- Format the release body ---
+
+function formatRelease({ version, changesContent, contributors, packages }) {
+  const lines = [];
+
+  lines.push(`# trigger.dev v${version}`);
+  lines.push("");
+  lines.push("## Upgrade");
+  lines.push("");
+  lines.push("```sh");
+  lines.push("npx trigger.dev@latest update  # npm");
+  lines.push("pnpm dlx trigger.dev@latest update  # pnpm");
+  lines.push("yarn dlx trigger.dev@latest update  # yarn");
+  lines.push("bunx trigger.dev@latest update  # bun");
+  lines.push("```");
+  lines.push("");
+  // The Docker image link initially points to the container page without a tag filter.
+  // After Docker images are built, the update-release job patches this with the exact tag URL.
+  lines.push(
+    `Self-hosted Docker image: [\`ghcr.io/triggerdotdev/trigger.dev:v${version}\`](https://github.com/triggerdotdev/trigger.dev/pkgs/container/trigger.dev)`
+  );
+  lines.push("");
+  lines.push("## Release notes");
+  lines.push("");
+  lines.push(
+    `Read the full release notes: https://trigger.dev/changelog/v${version.replace(/\./g, "-")}`
+  );
+  lines.push("");
+
+  // What's changed — extracted from the enhanced PR body
+  if (changesContent) {
+    lines.push("## What's changed");
+    lines.push("");
+    lines.push(changesContent);
+    lines.push("");
+  }
+
+  // Packages
+  if (packages.length > 0) {
+    lines.push(`## All packages: v${version}`);
+    lines.push("");
+    lines.push(packages.join(", "));
+    lines.push("");
+  }
+
+  // Contributors
+  if (contributors.length > 0) {
+    lines.push("## Contributors");
+    lines.push("");
+    lines.push(
+      contributors
+        .map((c) => (/^[A-Za-z0-9][-A-Za-z0-9]*$/.test(c) ? `@${c}` : c))
+        .join(", ")
+    );
+    lines.push("");
+  }
+
+  // Comparison link
+  const prevVersion = getPreviousVersion(version);
+  if (prevVersion) {
+    lines.push(
+      `**Full changelog**: https://github.com/triggerdotdev/trigger.dev/compare/v${prevVersion}...v${version}`
+    );
+  }
+
+  return lines.join("\n");
+}
+
+// --- Main ---
+
+async function main() {
+  // Read PR body from env or stdin
+  let prBody = process.env.RELEASE_PR_BODY || "";
+  if (!prBody && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    prBody = Buffer.concat(chunks).toString("utf-8");
+  }
+
+  const changesContent = extractChangesFromPrBody(prBody);
+  const contributors = getContributors(getPreviousVersion(version));
+  const packages = getPublishedPackages();
+
+  const body = formatRelease({
+    version,
+    changesContent,
+    contributors,
+    packages,
+  });
+
+  process.stdout.write(body);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/scripts/recover-stuck-runs.ts b/scripts/recover-stuck-runs.ts
new file mode 100755
index 00000000000..15deeb899c9
--- /dev/null
+++ b/scripts/recover-stuck-runs.ts
@@ -0,0 +1,367 @@
+#!/usr/bin/env tsx
+
+/**
+ * Recovery script for runs stuck in currentConcurrency with QUEUED execution status
+ *
+ * PROBLEM:
+ * During high database load, runs can get dequeued from Redis (added to currentConcurrency)
+ * but fail to update their execution status in the database. This leaves them stuck in an
+ * inconsistent state where they won't be re-dequeued because they're marked as "in progress"
+ * in Redis, but their database state still shows QUEUED.
+ *
+ * SOLUTION:
+ * This script identifies and recovers these stuck runs by:
+ * 1. Reading from the environment currentConcurrency Redis set
+ * 2. Checking which runs have QUEUED execution status (inconsistent state)
+ * 3. Re-adding them to their specific queue sorted sets
+ * 4. Removing them from the queue-specific currentConcurrency sets
+ * 5. Removing them from the environment-level currentConcurrency set
+ *
+ * SAFETY:
+ * - Dry-run mode when no write Redis URL is provided (read-only, no writes)
+ * - Uses separate Redis connections for reads and writes
+ * - Write connection only created when redisWriteUrl is provided
+ *
+ * ARGUMENTS:
+ *   <environmentId>   The Trigger.dev environment ID (e.g., env_abc123)
+ *   <postgresUrl>     PostgreSQL connection string
+ *   <redisReadUrl>    Redis connection string for reads (redis:// or rediss://)
+ *   [redisWriteUrl]   Optional Redis connection string for writes (omit for dry-run)
+ *
+ * USAGE:
+ *   tsx scripts/recover-stuck-runs.ts <environmentId> <postgresUrl> <redisReadUrl> [redisWriteUrl]
+ *
+ * EXAMPLES:
+ *
+ *   Dry-run mode (safe, no writes):
+ *   tsx scripts/recover-stuck-runs.ts env_1234567890 \
+ *     "postgresql://user:pass@localhost:5432/triggerdev" \
+ *     "redis://readonly.example.com:6379"
+ *
+ *   Execute mode (makes actual changes):
+ *   tsx scripts/recover-stuck-runs.ts env_1234567890 \
+ *     "postgresql://user:pass@localhost:5432/triggerdev" \
+ *     "redis://readonly.example.com:6379" \
+ *     "redis://writeonly.example.com:6379"
+ */
+
+import { PrismaClient, TaskRunExecutionStatus } from "@trigger.dev/database";
+import { createRedisClient } from "@internal/redis";
+
+interface StuckRun {
+  runId: string;
+  orgId: string;
+  projectId: string;
+  environmentId: string;
+  queue: string;
+  concurrencyKey: string | null;
+  executionStatus: TaskRunExecutionStatus;
+  snapshotCreatedAt: Date;
+  taskIdentifier: string;
+}
+
+interface RedisOperation {
+  type: "ZADD" | "SREM";
+  key: string;
+  args: (string | number)[];
+  description: string;
+}
+
+async function main() {
+  const [environmentId, postgresUrl, redisReadUrl, redisWriteUrl] = process.argv.slice(2);
+
+  if (!environmentId || !postgresUrl || !redisReadUrl) {
+    console.error("Usage: tsx scripts/recover-stuck-runs.ts <environmentId> <postgresUrl> <redisReadUrl> [redisWriteUrl]");
+    console.error("");
+    console.error("Dry-run mode when no redisWriteUrl is provided (read-only).");
+    console.error("Execute mode when redisWriteUrl is provided (makes actual changes).");
+    console.error("");
+    console.error("Example (dry-run):");
+    console.error('  tsx scripts/recover-stuck-runs.ts env_1234567890 \\');
+    console.error('    "postgresql://user:pass@localhost:5432/triggerdev" \\');
+    console.error('    "redis://readonly.example.com:6379"');
+    console.error("");
+    console.error("Example (execute):");
+    console.error('  tsx scripts/recover-stuck-runs.ts env_1234567890 \\');
+    console.error('    "postgresql://user:pass@localhost:5432/triggerdev" \\');
+    console.error('    "redis://readonly.example.com:6379" \\');
+    console.error('    "redis://writeonly.example.com:6379"');
+    process.exit(1);
+  }
+
+  const executeMode = !!redisWriteUrl;
+
+  if (executeMode) {
+    console.log("⚠️  EXECUTE MODE - Changes will be made to Redis\n");
+  } else {
+    console.log("🔍 DRY RUN MODE - No changes will be made to Redis\n");
+  }
+
+  console.log(`🔍 Scanning for stuck runs in environment: ${environmentId}`);
+
+  // Create Prisma client with the provided connection URL
+  const prisma = new PrismaClient({
+    datasources: {
+      db: {
+        url: postgresUrl,
+      },
+    },
+  });
+
+  try {
+    // Get environment details
+    const environment = await prisma.runtimeEnvironment.findUnique({
+      where: { id: environmentId },
+      include: {
+        organization: true,
+        project: true,
+      },
+    });
+
+    if (!environment) {
+      console.error(`❌ Environment not found: ${environmentId}`);
+      process.exit(1);
+    }
+
+    console.log(`📍 Environment: ${environment.slug} (${environment.type})`);
+    console.log(`📍 Organization: ${environment.organization.slug}`);
+    console.log(`📍 Project: ${environment.project.slug}`);
+
+    // Parse Redis read URL
+    const redisReadUrlObj = new URL(redisReadUrl);
+    const redisReadOptions = {
+      host: redisReadUrlObj.hostname,
+      port: parseInt(redisReadUrlObj.port || "6379"),
+      username: redisReadUrlObj.username || undefined,
+      password: redisReadUrlObj.password || undefined,
+      enableAutoPipelining: false,
+      ...(redisReadUrlObj.protocol === "rediss:"
+        ? {
+            tls: {
+              // If connecting via localhost tunnel to a remote Redis, disable cert verification
+              rejectUnauthorized: redisReadUrlObj.hostname === "localhost" ? false : true,
+            },
+          }
+        : {}),
+    };
+
+    // Create Redis read client
+    const redisRead = createRedisClient(redisReadOptions);
+
+    // Create Redis write client if redisWriteUrl is provided
+    let redisWrite = null;
+    if (redisWriteUrl) {
+      const redisWriteUrlObj = new URL(redisWriteUrl);
+      const redisWriteOptions = {
+        host: redisWriteUrlObj.hostname,
+        port: parseInt(redisWriteUrlObj.port || "6379"),
+        username: redisWriteUrlObj.username || undefined,
+        password: redisWriteUrlObj.password || undefined,
+        enableAutoPipelining: false,
+        ...(redisWriteUrlObj.protocol === "rediss:"
+          ? {
+              tls: {
+                // If connecting via localhost tunnel to a remote Redis, disable cert verification
+                rejectUnauthorized: redisWriteUrlObj.hostname === "localhost" ? false : true,
+              },
+            }
+          : {}),
+      };
+      redisWrite = createRedisClient(redisWriteOptions);
+    }
+
+    try {
+      // Build the Redis key for environment-level currentConcurrency set
+      // Format: engine:runqueue:{org:X}:proj:Y:env:Z:currentConcurrency
+      const envConcurrencyKey = `engine:runqueue:{org:${environment.organizationId}}:proj:${environment.projectId}:env:${environmentId}:currentConcurrency`;
+
+      console.log(`\n🔑 Checking Redis key: ${envConcurrencyKey}`);
+
+      // Get all run IDs in the environment's currentConcurrency set
+      const runIds = await redisRead.smembers(envConcurrencyKey);
+
+      if (runIds.length === 0) {
+        console.log(`✅ No runs in currentConcurrency set`);
+        return;
+      }
+
+      console.log(`📊 Found ${runIds.length} runs in currentConcurrency set`);
+
+      // Query database for latest snapshots and queue info of these runs
+      const runInfo = await prisma.$queryRaw<
+        Array<{
+          runId: string;
+          executionStatus: TaskRunExecutionStatus;
+          snapshotCreatedAt: Date;
+          organizationId: string;
+          projectId: string;
+          environmentId: string;
+          taskIdentifier: string;
+          queue: string;
+          concurrencyKey: string | null;
+        }>
+      >`
+        SELECT DISTINCT ON (s."runId")
+          s."runId",
+          s."executionStatus",
+          s."createdAt" as "snapshotCreatedAt",
+          r."organizationId",
+          r."projectId",
+          r."runtimeEnvironmentId" as "environmentId",
+          r."taskIdentifier",
+          r."queue",
+          r."concurrencyKey"
+        FROM "TaskRunExecutionSnapshot" s
+        INNER JOIN "TaskRun" r ON r.id = s."runId"
+        WHERE s."runId" = ANY(${runIds})
+          AND s."isValid" = true
+        ORDER BY s."runId", s."createdAt" DESC
+      `;
+
+      const stuckRuns: StuckRun[] = [];
+
+      // Find runs with QUEUED execution status (inconsistent state)
+      for (const info of runInfo) {
+        if (info.executionStatus === "QUEUED") {
+          stuckRuns.push({
+            runId: info.runId,
+            orgId: info.organizationId,
+            projectId: info.projectId,
+            environmentId: info.environmentId,
+            queue: info.queue,
+            concurrencyKey: info.concurrencyKey,
+            executionStatus: info.executionStatus,
+            snapshotCreatedAt: info.snapshotCreatedAt,
+            taskIdentifier: info.taskIdentifier,
+          });
+        }
+      }
+
+      if (stuckRuns.length === 0) {
+        console.log(`✅ No stuck runs found (all runs have progressed beyond QUEUED state)`);
+        return;
+      }
+
+      console.log(`\n⚠️  Found ${stuckRuns.length} stuck runs in QUEUED state:`);
+      console.log(`════════════════════════════════════════════════════════════════`);
+
+      for (const run of stuckRuns) {
+        const age = Date.now() - run.snapshotCreatedAt.getTime();
+        const ageMinutes = Math.floor(age / 1000 / 60);
+        console.log(`  • Run: ${run.runId}`);
+        console.log(`    Task: ${run.taskIdentifier}`);
+        console.log(`    Queue: ${run.queue}`);
+        console.log(`    Concurrency Key: ${run.concurrencyKey || "(none)"}`);
+        console.log(`    Status: ${run.executionStatus}`);
+        console.log(`    Stuck for: ${ageMinutes} minutes`);
+        console.log(`    Snapshot created: ${run.snapshotCreatedAt.toISOString()}`);
+        console.log();
+      }
+
+      // Prepare recovery operations
+      console.log(`\n⚡ ${executeMode ? "Executing" : "Planning"} recovery for ${stuckRuns.length} stuck runs`);
+      console.log(`This will:`);
+      console.log(`  1. Add each run back to its specific queue sorted set`);
+      console.log(`  2. Remove each run from the queue-specific currentConcurrency set`);
+      console.log(`  3. Remove each run from the env-level currentConcurrency set`);
+      console.log();
+
+      let successCount = 0;
+      let failureCount = 0;
+
+      const currentTimestamp = Date.now();
+
+      for (const run of stuckRuns) {
+        try {
+          // Build queue key: engine:runqueue:{org:X}:proj:Y:env:Z:queue:QUEUENAME
+          // Build queue currentConcurrency key: engine:runqueue:{org:X}:proj:Y:env:Z:queue:QUEUENAME:currentConcurrency
+          const queueKey = run.concurrencyKey
+            ? `engine:runqueue:{org:${run.orgId}}:proj:${run.projectId}:env:${run.environmentId}:queue:${run.queue}:ck:${run.concurrencyKey}`
+            : `engine:runqueue:{org:${run.orgId}}:proj:${run.projectId}:env:${run.environmentId}:queue:${run.queue}`;
+
+          const queueConcurrencyKey = `${queueKey}:currentConcurrency`;
+
+          const operations: RedisOperation[] = [
+            {
+              type: "ZADD",
+              key: queueKey,
+              args: [currentTimestamp, run.runId],
+              description: `Add run to queue sorted set with score ${currentTimestamp}`,
+            },
+            {
+              type: "SREM",
+              key: queueConcurrencyKey,
+              args: [run.runId],
+              description: `Remove run from queue currentConcurrency set`,
+            },
+            {
+              type: "SREM",
+              key: envConcurrencyKey,
+              args: [run.runId],
+              description: `Remove run from env currentConcurrency set`,
+            },
+          ];
+
+          if (executeMode && redisWrite) {
+            // Execute operations using the write client
+            await redisWrite.zadd(queueKey, currentTimestamp, run.runId);
+            const removedFromQueue = await redisWrite.srem(queueConcurrencyKey, run.runId);
+            const removedFromEnv = await redisWrite.srem(envConcurrencyKey, run.runId);
+
+            console.log(`  ✓ Recovered run ${run.runId} (${run.taskIdentifier})`);
+            if (removedFromQueue === 0) {
+              console.log(`    ⚠ Run was not in queue currentConcurrency set`);
+            }
+            if (removedFromEnv === 0) {
+              console.log(`    ⚠ Run was not in env currentConcurrency set`);
+            }
+            successCount++;
+          } else {
+            // Dry run - just show what would be done
+            console.log(`  📝 Would recover run ${run.runId} (${run.taskIdentifier}):`);
+            for (const op of operations) {
+              console.log(`     ${op.type} ${op.key}`);
+              console.log(`       Args: ${JSON.stringify(op.args)}`);
+              console.log(`       (${op.description})`);
+            }
+            successCount++;
+          }
+        } catch (error) {
+          console.error(`  ✗ Failed to recover run ${run.runId}:`, error);
+          failureCount++;
+        }
+      }
+
+      console.log(`\n═══════════════════════════════════════════════════════════════`);
+      if (executeMode) {
+        console.log(`✅ Recovery complete!`);
+        console.log(`   Recovered: ${successCount}`);
+        console.log(`   Failed: ${failureCount}`);
+        console.log();
+        console.log(`ℹ️  Note: The recovered runs should be automatically dequeued`);
+        console.log(`   by the master queue consumers within a few seconds.`);
+      } else {
+        console.log(`📋 Dry run complete - no changes were made`);
+        console.log(`   Would recover: ${successCount}`);
+        console.log(`   Would fail: ${failureCount}`);
+        console.log();
+        console.log(`💡 To execute these changes, run again with a redisWriteUrl argument`);
+      }
+    } finally {
+      await redisRead.quit();
+      if (redisWrite) {
+        await redisWrite.quit();
+      }
+    }
+  } catch (error) {
+    console.error("❌ Error during recovery:", error);
+    throw error;
+  } finally {
+    await prisma.$disconnect();
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});